Debian Codegraph @

sdk/trace/internal/observ/simple_span_processor_test.go

raw
1 // Copyright The OpenTelemetry Authors
2 // SPDX-License-Identifier: Apache-2.0
3 package observ_test
4
5 import (
6 "errors"
7 "testing"
8
9 "github.com/stretchr/testify/assert"
10 "github.com/stretchr/testify/require"
11
12 "go.opentelemetry.io/otel"
13 "go.opentelemetry.io/otel/attribute"
14 "go.opentelemetry.io/otel/metric/noop"
15 "go.opentelemetry.io/otel/sdk/trace/internal/observ"
16 semconv "go.opentelemetry.io/otel/semconv/v1.40.0"
17 )
18
19 const sspComponentID = 0
20
21 func TestSSPComponentName(t *testing.T) {
22 got := observ.SSPComponentName(10)
23 want := semconv.OTelComponentName("simple_span_processor/10")
24 assert.Equal(t, want, got)
25 }
26
27 func TestNewSSPError(t *testing.T) {
28 t.Setenv("OTEL_GO_X_OBSERVABILITY", "true")
29
30 orig := otel.GetMeterProvider()
31 t.Cleanup(func() { otel.SetMeterProvider(orig) })
32
33 mp := &errMeterProvider{err: assert.AnError}
34 otel.SetMeterProvider(mp)
35
36 _, err := observ.NewSSP(sspComponentID)
37 require.ErrorIs(t, err, assert.AnError, "new instrument errors")
38 assert.ErrorContains(t, err, "create SSP processed spans metric")
39 }
40
41 func TestNewSSPDisabled(t *testing.T) {
42 ssp, err := observ.NewSSP(sspComponentID)
43 assert.NoError(t, err)
44 assert.Nil(t, ssp)
45 }
46
47 func TestSSPSpanProcessed(t *testing.T) {
48 ctx := t.Context()
49 collect := setup(t)
50 ssp, err := observ.NewSSP(sspComponentID)
51 assert.NoError(t, err)
52
53 ssp.SpanProcessed(ctx, nil)
54 check(t, collect(), processed(dPt(sspSet(), 1)))
55 ssp.SpanProcessed(ctx, nil)
56 ssp.SpanProcessed(ctx, nil)
57 check(t, collect(), processed(dPt(sspSet(), 3)))
58
59 processErr := errors.New("error processing span")
60 ssp.SpanProcessed(ctx, processErr)
61 check(t, collect(), processed(
62 dPt(sspSet(), 3),
63 dPt(sspSet(semconv.ErrorType(processErr)), 1),
64 ))
65 }
66
67 func BenchmarkSSP(b *testing.B) {
68 b.Setenv("OTEL_GO_X_OBSERVABILITY", "true")
69
70 newSSP := func(b *testing.B) *observ.SSP {
71 b.Helper()
72 ssp, err := observ.NewSSP(sspComponentID)
73 require.NoError(b, err)
74 require.NotNil(b, ssp)
75 return ssp
76 }
77
78 b.Run("SpanProcessed", func(b *testing.B) {
79 orig := otel.GetMeterProvider()
80 b.Cleanup(func() {
81 otel.SetMeterProvider(orig)
82 })
83
84 // Ensure deterministic benchmark by using noop meter.
85 otel.SetMeterProvider(noop.NewMeterProvider())
86
87 ssp := newSSP(b)
88 ctx := b.Context()
89
90 b.ResetTimer()
91 b.ReportAllocs()
92 b.RunParallel(func(pb *testing.PB) {
93 for pb.Next() {
94 ssp.SpanProcessed(ctx, nil)
95 }
96 })
97 })
98
99 b.Run("SpanProcessedWithError", func(b *testing.B) {
100 orig := otel.GetMeterProvider()
101 b.Cleanup(func() {
102 otel.SetMeterProvider(orig)
103 })
104
105 // Ensure deterministic benchmark by using noop meter.
106 otel.SetMeterProvider(noop.NewMeterProvider())
107
108 ssp := newSSP(b)
109 ctx := b.Context()
110 processErr := errors.New("error processing span")
111
112 b.ResetTimer()
113 b.ReportAllocs()
114 b.RunParallel(func(pb *testing.PB) {
115 for pb.Next() {
116 ssp.SpanProcessed(ctx, processErr)
117 }
118 })
119 })
120 }
121
122 func sspSet(attrs ...attribute.KeyValue) attribute.Set {
123 return attribute.NewSet(append([]attribute.KeyValue{
124 semconv.OTelComponentTypeSimpleSpanProcessor,
125 observ.SSPComponentName(sspComponentID),
126 }, attrs...)...)
127 }