Debian Codegraph @

sdk/trace/internal/observ/batch_span_processor_test.go

raw
1 // Copyright The OpenTelemetry Authors
2 // SPDX-License-Identifier: Apache-2.0
3
4 package observ_test
5
6 import (
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/metric"
16 "go.opentelemetry.io/otel/sdk/metric/metricdata"
17 "go.opentelemetry.io/otel/sdk/trace/internal/observ"
18 semconv "go.opentelemetry.io/otel/semconv/v1.40.0"
19 "go.opentelemetry.io/otel/semconv/v1.40.0/otelconv"
20 )
21
22 const id = 0
23
24 func TestBSPComponentName(t *testing.T) {
25 got := observ.BSPComponentName(42)
26 want := semconv.OTelComponentName("batching_span_processor/42")
27 assert.Equal(t, want, got)
28 }
29
30 func TestNewBSPDisabled(t *testing.T) {
31 // Do not set OTEL_GO_X_OBSERVABILITY
32 bsp, err := observ.NewBSP(id, nil, 0)
33 assert.NoError(t, err)
34 assert.Nil(t, bsp)
35 }
36
37 func TestNewBSPErrors(t *testing.T) {
38 t.Setenv("OTEL_GO_X_OBSERVABILITY", "true")
39
40 orig := otel.GetMeterProvider()
41 t.Cleanup(func() { otel.SetMeterProvider(orig) })
42
43 mp := &errMeterProvider{err: assert.AnError}
44 otel.SetMeterProvider(mp)
45
46 _, err := observ.NewBSP(id, nil, 0)
47 require.ErrorIs(t, err, assert.AnError, "new instrument errors")
48
49 assert.ErrorContains(t, err, "create BSP queue capacity metric")
50 assert.ErrorContains(t, err, "create BSP queue size metric")
51 assert.ErrorContains(t, err, "register BSP queue size/capacity callback")
52 assert.ErrorContains(t, err, "create BSP processed spans metric")
53 }
54
55 func bspSet(attrs ...attribute.KeyValue) attribute.Set {
56 return attribute.NewSet(append([]attribute.KeyValue{
57 semconv.OTelComponentTypeBatchingSpanProcessor,
58 observ.BSPComponentName(id),
59 }, attrs...)...)
60 }
61
62 func qCap(v int64) metricdata.Metrics {
63 return metricdata.Metrics{
64 Name: otelconv.SDKProcessorSpanQueueCapacity{}.Name(),
65 Description: otelconv.SDKProcessorSpanQueueCapacity{}.Description(),
66 Unit: otelconv.SDKProcessorSpanQueueCapacity{}.Unit(),
67 Data: metricdata.Sum[int64]{
68 Temporality: metricdata.CumulativeTemporality,
69 IsMonotonic: false,
70 DataPoints: []metricdata.DataPoint[int64]{
71 {Attributes: bspSet(), Value: v},
72 },
73 },
74 }
75 }
76
77 func qSize(v int64) metricdata.Metrics {
78 return metricdata.Metrics{
79 Name: otelconv.SDKProcessorSpanQueueSize{}.Name(),
80 Description: otelconv.SDKProcessorSpanQueueSize{}.Description(),
81 Unit: otelconv.SDKProcessorSpanQueueSize{}.Unit(),
82 Data: metricdata.Sum[int64]{
83 Temporality: metricdata.CumulativeTemporality,
84 IsMonotonic: false,
85 DataPoints: []metricdata.DataPoint[int64]{
86 {Attributes: bspSet(), Value: v},
87 },
88 },
89 }
90 }
91
92 func TestBSPCallback(t *testing.T) {
93 collect := setup(t)
94
95 var n int64 = 3
96 bsp, err := observ.NewBSP(id, func() int64 { return n }, 5)
97 require.NoError(t, err)
98 require.NotNil(t, bsp)
99
100 check(t, collect(), qSize(n), qCap(5))
101
102 n = 4
103 check(t, collect(), qSize(n), qCap(5))
104
105 require.NoError(t, bsp.Shutdown())
106 got := collect()
107 assert.Empty(t, got.Metrics, "no metrics after shutdown")
108 }
109
110 func processed(dPts ...metricdata.DataPoint[int64]) metricdata.Metrics {
111 return metricdata.Metrics{
112 Name: otelconv.SDKProcessorSpanProcessed{}.Name(),
113 Description: otelconv.SDKProcessorSpanProcessed{}.Description(),
114 Unit: otelconv.SDKProcessorSpanProcessed{}.Unit(),
115 Data: metricdata.Sum[int64]{
116 Temporality: metricdata.CumulativeTemporality,
117 IsMonotonic: true,
118 DataPoints: dPts,
119 },
120 }
121 }
122
123 func TestBSPProcessed(t *testing.T) {
124 collect := setup(t)
125
126 bsp, err := observ.NewBSP(id, nil, 0)
127 require.NoError(t, err)
128 require.NotNil(t, bsp)
129 require.NoError(t, bsp.Shutdown()) // Unregister callback.
130
131 ctx := t.Context()
132 const p0 int64 = 10
133 bsp.Processed(ctx, p0)
134 const e0 int64 = 1
135 bsp.ProcessedQueueFull(ctx, e0)
136 check(t, collect(), processed(
137 dPt(bspSet(), p0),
138 dPt(bspSet(observ.ErrQueueFull), e0),
139 ))
140
141 const p1 int64 = 20
142 bsp.Processed(ctx, p1)
143 const e1 int64 = 2
144 bsp.ProcessedQueueFull(ctx, e1)
145 check(t, collect(), processed(
146 dPt(bspSet(), p0+p1),
147 dPt(bspSet(observ.ErrQueueFull), e0+e1),
148 ))
149 }
150
151 func BenchmarkBSP(b *testing.B) {
152 b.Setenv("OTEL_GO_X_OBSERVABILITY", "true")
153
154 newBSP := func(b *testing.B) *observ.BSP {
155 b.Helper()
156 bsp, err := observ.NewBSP(id, func() int64 { return 3 }, 5)
157 require.NoError(b, err)
158 require.NotNil(b, bsp)
159 b.Cleanup(func() {
160 if err := bsp.Shutdown(); err != nil {
161 b.Errorf("Shutdown: %v", err)
162 }
163 })
164 return bsp
165 }
166 ctx := b.Context()
167
168 b.Run("Processed", func(b *testing.B) {
169 orig := otel.GetMeterProvider()
170 b.Cleanup(func() { otel.SetMeterProvider(orig) })
171
172 // Ensure deterministic benchmark by using noop meter.
173 otel.SetMeterProvider(noop.NewMeterProvider())
174
175 bsp := newBSP(b)
176
177 b.ResetTimer()
178 b.ReportAllocs()
179 b.RunParallel(func(pb *testing.PB) {
180 for pb.Next() {
181 bsp.Processed(ctx, 10)
182 }
183 })
184 })
185 b.Run("ProcessedQueueFull", func(b *testing.B) {
186 orig := otel.GetMeterProvider()
187 b.Cleanup(func() { otel.SetMeterProvider(orig) })
188
189 // Ensure deterministic benchmark by using noop meter.
190 otel.SetMeterProvider(noop.NewMeterProvider())
191
192 bsp := newBSP(b)
193
194 b.ResetTimer()
195 b.ReportAllocs()
196 b.RunParallel(func(pb *testing.PB) {
197 for pb.Next() {
198 bsp.ProcessedQueueFull(ctx, 1)
199 }
200 })
201 })
202 b.Run("Callback", func(b *testing.B) {
203 orig := otel.GetMeterProvider()
204 b.Cleanup(func() { otel.SetMeterProvider(orig) })
205
206 reader := metric.NewManualReader()
207 mp := metric.NewMeterProvider(metric.WithReader(reader))
208 otel.SetMeterProvider(mp)
209
210 bsp := newBSP(b)
211 var got metricdata.ResourceMetrics
212
213 b.ResetTimer()
214 b.ReportAllocs()
215 for b.Loop() {
216 _ = reader.Collect(ctx, &got)
217 }
218
219 _ = got
220 _ = bsp
221 })
222 }