Debian Codegraph @

sdk/trace/internal/observ/tracer_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/metricdata"
16 "go.opentelemetry.io/otel/sdk/trace"
17 "go.opentelemetry.io/otel/sdk/trace/internal/observ"
18 "go.opentelemetry.io/otel/semconv/v1.40.0/otelconv"
19 tapi "go.opentelemetry.io/otel/trace"
20 )
21
22 func live(dPts ...metricdata.DataPoint[int64]) metricdata.Metrics {
23 return metricdata.Metrics{
24 Name: otelconv.SDKSpanLive{}.Name(),
25 Description: otelconv.SDKSpanLive{}.Description(),
26 Unit: otelconv.SDKSpanLive{}.Unit(),
27 Data: metricdata.Sum[int64]{
28 Temporality: metricdata.CumulativeTemporality,
29 DataPoints: dPts,
30 },
31 }
32 }
33
34 func sampledLive(value int64) metricdata.Metrics {
35 set := attribute.NewSet(
36 otelconv.SDKSpanLive{}.AttrSpanSamplingResult(
37 otelconv.SpanSamplingResultRecordAndSample,
38 ),
39 )
40 return live(dPt(set, value))
41 }
42
43 func started(dPts ...metricdata.DataPoint[int64]) metricdata.Metrics {
44 return metricdata.Metrics{
45 Name: otelconv.SDKSpanStarted{}.Name(),
46 Description: otelconv.SDKSpanStarted{}.Description(),
47 Unit: otelconv.SDKSpanStarted{}.Unit(),
48 Data: metricdata.Sum[int64]{
49 Temporality: metricdata.CumulativeTemporality,
50 IsMonotonic: true,
51 DataPoints: dPts,
52 },
53 }
54 }
55
56 func sampledStarted(value int64) metricdata.Metrics {
57 set := attribute.NewSet(
58 otelconv.SDKSpanStarted{}.AttrSpanParentOrigin(
59 otelconv.SpanParentOriginNone,
60 ),
61 otelconv.SDKSpanStarted{}.AttrSpanSamplingResult(
62 otelconv.SpanSamplingResultRecordAndSample,
63 ),
64 )
65 return started(dPt(set, value))
66 }
67
68 func TestTracer(t *testing.T) {
69 collect := setup(t)
70 tracer := trace.NewTracerProvider().Tracer(t.Name())
71
72 _, span := tracer.Start(t.Context(), "span")
73 check(t, collect(), sampledLive(1), sampledStarted(1))
74
75 span.End()
76 check(t, collect(), sampledLive(0), sampledStarted(1))
77 }
78
79 func dropStarted(value int64) metricdata.Metrics {
80 set := attribute.NewSet(
81 otelconv.SDKSpanStarted{}.AttrSpanParentOrigin(
82 otelconv.SpanParentOriginNone,
83 ),
84 otelconv.SDKSpanStarted{}.AttrSpanSamplingResult(
85 otelconv.SpanSamplingResultDrop,
86 ),
87 )
88 return started(dPt(set, value))
89 }
90
91 func TestTracerNonRecording(t *testing.T) {
92 collect := setup(t)
93 tracer := trace.NewTracerProvider(
94 trace.WithSampler(trace.NeverSample()),
95 ).Tracer(t.Name())
96
97 _, _ = tracer.Start(t.Context(), "span")
98 check(t, collect(), dropStarted(1))
99 }
100
101 func recLive(value int64) metricdata.Metrics {
102 set := attribute.NewSet(
103 otelconv.SDKSpanLive{}.AttrSpanSamplingResult(
104 otelconv.SpanSamplingResultRecordOnly,
105 ),
106 )
107 return live(dPt(set, value))
108 }
109
110 func recStarted(value int64) metricdata.Metrics {
111 set := attribute.NewSet(
112 otelconv.SDKSpanStarted{}.AttrSpanParentOrigin(
113 otelconv.SpanParentOriginNone,
114 ),
115 otelconv.SDKSpanStarted{}.AttrSpanSamplingResult(
116 otelconv.SpanSamplingResultRecordOnly,
117 ),
118 )
119 return started(dPt(set, value))
120 }
121
122 type recOnly struct{}
123
124 func (recOnly) ShouldSample(p trace.SamplingParameters) trace.SamplingResult {
125 psc := tapi.SpanContextFromContext(p.ParentContext)
126 return trace.SamplingResult{
127 Decision: trace.RecordOnly,
128 Tracestate: psc.TraceState(),
129 }
130 }
131
132 func (recOnly) Description() string { return "RecordingOnly" }
133
134 func TestTracerRecordOnly(t *testing.T) {
135 collect := setup(t)
136 tracer := trace.NewTracerProvider(
137 trace.WithSampler(recOnly{}),
138 ).Tracer(t.Name())
139
140 _, _ = tracer.Start(t.Context(), "span")
141 check(t, collect(), recLive(1), recStarted(1))
142 }
143
144 func remoteStarted(value int64) metricdata.Metrics {
145 set := attribute.NewSet(
146 otelconv.SDKSpanStarted{}.AttrSpanParentOrigin(
147 otelconv.SpanParentOriginRemote,
148 ),
149 otelconv.SDKSpanStarted{}.AttrSpanSamplingResult(
150 otelconv.SpanSamplingResultRecordAndSample,
151 ),
152 )
153 return started(dPt(set, value))
154 }
155
156 func TestTracerRemoteParent(t *testing.T) {
157 collect := setup(t)
158 tracer := trace.NewTracerProvider().Tracer(t.Name())
159
160 ctx := tapi.ContextWithRemoteSpanContext(
161 t.Context(),
162 tapi.NewSpanContext(tapi.SpanContextConfig{
163 TraceID: tapi.TraceID{0x01},
164 SpanID: tapi.SpanID{0x01},
165 TraceFlags: 0x1,
166 Remote: true,
167 }))
168
169 _, _ = tracer.Start(ctx, "span")
170 check(t, collect(), sampledLive(1), remoteStarted(1))
171 }
172
173 func chainStarted(parent, child int64) metricdata.Metrics {
174 noParentSet := attribute.NewSet(
175 otelconv.SDKSpanStarted{}.AttrSpanParentOrigin(
176 otelconv.SpanParentOriginNone,
177 ),
178 otelconv.SDKSpanStarted{}.AttrSpanSamplingResult(
179 otelconv.SpanSamplingResultRecordAndSample,
180 ),
181 )
182 localSet := attribute.NewSet(
183 otelconv.SDKSpanStarted{}.AttrSpanParentOrigin(
184 otelconv.SpanParentOriginLocal,
185 ),
186 otelconv.SDKSpanStarted{}.AttrSpanSamplingResult(
187 otelconv.SpanSamplingResultRecordAndSample,
188 ),
189 )
190 return started(dPt(noParentSet, parent), dPt(localSet, child))
191 }
192
193 func TestTracerLocalParent(t *testing.T) {
194 collect := setup(t)
195 tracer := trace.NewTracerProvider().Tracer(t.Name())
196
197 ctx, parent := tracer.Start(t.Context(), "parent")
198 _, child := tracer.Start(ctx, "child")
199
200 check(t, collect(), sampledLive(2), chainStarted(1, 1))
201
202 child.End()
203 parent.End()
204
205 check(t, collect(), sampledLive(0), chainStarted(1, 1))
206 }
207
208 func TestNewTracerObservabilityDisabled(t *testing.T) {
209 // Do not set OTEL_GO_X_OBSERVABILITY
210 tracer, err := observ.NewTracer()
211 assert.NoError(t, err)
212 assert.False(t, tracer.Enabled())
213 }
214
215 func TestNewTracerErrors(t *testing.T) {
216 t.Setenv("OTEL_GO_X_OBSERVABILITY", "true")
217
218 orig := otel.GetMeterProvider()
219 t.Cleanup(func() { otel.SetMeterProvider(orig) })
220
221 mp := &errMeterProvider{err: assert.AnError}
222 otel.SetMeterProvider(mp)
223
224 _, err := observ.NewTracer()
225 require.ErrorIs(t, err, assert.AnError, "new instrument errors")
226
227 assert.ErrorContains(t, err, "span live metric")
228 assert.ErrorContains(t, err, "span started metric")
229 }
230
231 func BenchmarkTracer(b *testing.B) {
232 b.Setenv("OTEL_GO_X_OBSERVABILITY", "true")
233
234 orig := otel.GetMeterProvider()
235 b.Cleanup(func() { otel.SetMeterProvider(orig) })
236
237 // Ensure deterministic benchmark by using noop meter.
238 otel.SetMeterProvider(noop.NewMeterProvider())
239
240 tracer, err := observ.NewTracer()
241 require.NoError(b, err)
242 require.True(b, tracer.Enabled())
243
244 t := otel.GetTracerProvider().Tracer(b.Name())
245 ctx, span := t.Start(b.Context(), "parent")
246 psc := span.SpanContext()
247 span.End()
248
249 b.Run("SpanStarted", func(b *testing.B) {
250 b.ReportAllocs()
251 b.RunParallel(func(p *testing.PB) {
252 for p.Next() {
253 tracer.SpanStarted(ctx, psc, span)
254 }
255 })
256 })
257
258 b.Run("SpanLive", func(b *testing.B) {
259 b.ReportAllocs()
260 b.RunParallel(func(p *testing.PB) {
261 for p.Next() {
262 tracer.SpanLive(ctx, span)
263 }
264 })
265 })
266
267 b.Run("SpanEnded", func(b *testing.B) {
268 b.ReportAllocs()
269 b.RunParallel(func(p *testing.PB) {
270 for p.Next() {
271 tracer.SpanEnded(ctx, span)
272 }
273 })
274 })
275 }
276
277 func BenchmarkNewTracer(b *testing.B) {
278 b.Setenv("OTEL_GO_X_OBSERVABILITY", "true")
279
280 orig := otel.GetMeterProvider()
281 b.Cleanup(func() { otel.SetMeterProvider(orig) })
282
283 // Ensure deterministic benchmark by using noop meter.
284 otel.SetMeterProvider(noop.NewMeterProvider())
285
286 var tracer observ.Tracer
287
288 b.ReportAllocs()
289 b.ResetTimer()
290 for b.Loop() {
291 tracer, _ = observ.NewTracer()
292 }
293
294 _ = tracer
295 }