Debian Codegraph @

internal/global/trace_test.go

raw
1 // Copyright The OpenTelemetry Authors
2 // SPDX-License-Identifier: Apache-2.0
3
4 package global
5
6 import (
7 "context"
8 "sync/atomic"
9 "testing"
10 "time"
11
12 "github.com/stretchr/testify/assert"
13 "go.opentelemetry.io/auto/sdk"
14
15 "go.opentelemetry.io/otel/attribute"
16 "go.opentelemetry.io/otel/trace"
17 "go.opentelemetry.io/otel/trace/embedded"
18 "go.opentelemetry.io/otel/trace/noop"
19 )
20
21 type fnTracerProvider struct {
22 embedded.TracerProvider
23
24 tracer func(string, ...trace.TracerOption) trace.Tracer
25 }
26
27 func (fn fnTracerProvider) Tracer(instrumentationName string, opts ...trace.TracerOption) trace.Tracer {
28 return fn.tracer(instrumentationName, opts...)
29 }
30
31 type fnTracer struct {
32 embedded.Tracer
33
34 start func(ctx context.Context, spanName string, opts ...trace.SpanStartOption) (context.Context, trace.Span)
35 }
36
37 func (fn fnTracer) Start(
38 ctx context.Context,
39 spanName string,
40 opts ...trace.SpanStartOption,
41 ) (context.Context, trace.Span) {
42 return fn.start(ctx, spanName, opts...)
43 }
44
45 func TestTraceProviderDelegation(t *testing.T) {
46 ResetForTest(t)
47
48 // Map of tracers to expected span names.
49 expected := map[string][]string{
50 "pre": {"span2"},
51 "post": {"span3"},
52 "fromSpan": {"span4"},
53 }
54
55 ctx := t.Context()
56 gtp := TracerProvider()
57 tracer1 := gtp.Tracer("pre")
58 // This is started before an SDK was registered and should be dropped.
59 _, span1 := tracer1.Start(ctx, "span1")
60
61 SetTracerProvider(fnTracerProvider{
62 tracer: func(name string, _ ...trace.TracerOption) trace.Tracer {
63 spans, ok := expected[name]
64 assert.Truef(t, ok, "invalid tracer: %s", name)
65 return fnTracer{
66 start: func(ctx context.Context, spanName string, _ ...trace.SpanStartOption) (context.Context, trace.Span) {
67 if ok {
68 if len(spans) == 0 {
69 t.Errorf("unexpected span: %s", spanName)
70 } else {
71 var want string
72 want, spans = spans[0], spans[1:]
73 assert.Equal(t, want, spanName)
74 }
75 }
76 return noop.NewTracerProvider().Tracer(name).Start(ctx, spanName)
77 },
78 }
79 },
80 })
81
82 // This span was started before initialization, it is expected to be dropped.
83 span1.End()
84
85 // The existing Tracer should have been configured to now use the configured SDK.
86 _, span2 := tracer1.Start(ctx, "span2")
87 span2.End()
88
89 // The global TracerProvider should now create Tracers that also use the newly configured SDK.
90 tracer2 := gtp.Tracer("post")
91 _, span3 := tracer2.Start(ctx, "span3")
92 span3.End()
93
94 // The noop-span should still provide access to a usable TracerProvider.
95 _, span4 := span1.TracerProvider().Tracer("fromSpan").Start(ctx, "span4")
96 span4.End()
97 }
98
99 func TestTraceProviderDelegates(t *testing.T) {
100 ResetForTest(t)
101
102 // Retrieve the placeholder TracerProvider.
103 gtp := TracerProvider()
104
105 // Configure it with a spy.
106 called := false
107 SetTracerProvider(fnTracerProvider{
108 tracer: func(name string, _ ...trace.TracerOption) trace.Tracer {
109 called = true
110 assert.Equal(t, "abc", name)
111 return noop.NewTracerProvider().Tracer("")
112 },
113 })
114
115 gtp.Tracer("abc", trace.WithInstrumentationVersion("xyz"))
116 assert.True(t, called, "expected configured TraceProvider to be called")
117 }
118
119 func TestTraceProviderDelegatesConcurrentSafe(t *testing.T) {
120 ResetForTest(t)
121
122 // Retrieve the placeholder TracerProvider.
123 gtp := TracerProvider()
124
125 done := make(chan struct{})
126 quit := make(chan struct{})
127 go func() {
128 defer close(done)
129 for {
130 select {
131 case <-time.After(1 * time.Millisecond):
132 gtp.Tracer("abc", trace.WithInstrumentationVersion("xyz"))
133 case <-quit:
134 return
135 }
136 }
137 }()
138
139 // Wait for the goroutine to make some calls before installing the provider.
140 <-time.After(100 * time.Millisecond)
141
142 // Configure it with a spy.
143 var called atomic.Int32
144 SetTracerProvider(fnTracerProvider{
145 tracer: func(name string, _ ...trace.TracerOption) trace.Tracer {
146 newVal := called.Add(1)
147 assert.Equal(t, "abc", name)
148 if newVal == 10 {
149 // Signal the goroutine to finish.
150 close(quit)
151 }
152 return noop.NewTracerProvider().Tracer("")
153 },
154 })
155
156 // Wait for the go routine to finish
157 <-done
158
159 assert.LessOrEqual(t, int32(10), called.Load(), "expected configured TraceProvider to be called")
160 }
161
162 func TestTracerDelegatesConcurrentSafe(t *testing.T) {
163 ResetForTest(t)
164
165 // Retrieve the placeholder TracerProvider.
166 gtp := TracerProvider()
167 tracer := gtp.Tracer("abc", trace.WithInstrumentationVersion("xyz"))
168
169 done := make(chan struct{})
170 quit := make(chan struct{})
171 go func() {
172 defer close(done)
173 for {
174 select {
175 case <-time.After(1 * time.Millisecond):
176 tracer.Start(t.Context(), "name")
177 case <-quit:
178 return
179 }
180 }
181 }()
182
183 // Wait for the goroutine to make some calls before installing the provider.
184 <-time.After(100 * time.Millisecond)
185
186 // Configure it with a spy.
187 var called atomic.Int32
188 SetTracerProvider(fnTracerProvider{
189 tracer: func(name string, _ ...trace.TracerOption) trace.Tracer {
190 assert.Equal(t, "abc", name)
191 return fnTracer{
192 start: func(ctx context.Context, spanName string, _ ...trace.SpanStartOption) (context.Context, trace.Span) {
193 newVal := called.Add(1)
194 assert.Equal(t, "name", spanName)
195 if newVal == 10 {
196 // Signal the goroutine to finish.
197 close(quit)
198 }
199 return noop.NewTracerProvider().Tracer("").Start(ctx, spanName)
200 },
201 }
202 },
203 })
204
205 // Wait for the go routine to finish
206 <-done
207
208 assert.LessOrEqual(t, int32(10), called.Load(), "expected configured TraceProvider to be called")
209 }
210
211 func TestTraceProviderDelegatesSameInstance(t *testing.T) {
212 ResetForTest(t)
213
214 // Retrieve the placeholder TracerProvider.
215 gtp := TracerProvider()
216 tracer := gtp.Tracer("abc", trace.WithInstrumentationVersion("xyz"))
217 assert.Same(t, tracer, gtp.Tracer("abc", trace.WithInstrumentationVersion("xyz")))
218 assert.Same(t, tracer, gtp.Tracer("abc", trace.WithInstrumentationVersion("xyz")))
219
220 SetTracerProvider(fnTracerProvider{
221 tracer: func(string, ...trace.TracerOption) trace.Tracer {
222 return noop.NewTracerProvider().Tracer("")
223 },
224 })
225
226 assert.NotEqual(t, tracer, gtp.Tracer("abc", trace.WithInstrumentationVersion("xyz")))
227 }
228
229 func TestSpanContextPropagatedWithNonRecordingSpan(t *testing.T) {
230 ResetForTest(t)
231
232 sc := trace.NewSpanContext(trace.SpanContextConfig{
233 TraceID: [16]byte{0x01},
234 SpanID: [8]byte{0x01},
235 TraceFlags: trace.FlagsSampled,
236 Remote: true,
237 })
238 ctx := trace.ContextWithSpanContext(t.Context(), sc)
239 _, span := TracerProvider().Tracer("test").Start(ctx, "test")
240
241 assert.Equal(t, sc, span.SpanContext())
242 assert.False(t, span.IsRecording())
243 }
244
245 func TestTracerIdentity(t *testing.T) {
246 type id struct{ name, ver, url, attr string }
247
248 ids := []id{
249 {"name-a", "version-a", "url-a", ""},
250 {"name-a", "version-a", "url-a", "attr"},
251 {"name-a", "version-a", "url-b", ""},
252 {"name-a", "version-b", "url-a", ""},
253 {"name-a", "version-b", "url-b", ""},
254 {"name-b", "version-a", "url-a", ""},
255 {"name-b", "version-a", "url-b", ""},
256 {"name-b", "version-b", "url-a", ""},
257 {"name-b", "version-b", "url-b", ""},
258 }
259
260 provider := &tracerProvider{}
261 newTracer := func(i id) trace.Tracer {
262 return provider.Tracer(
263 i.name,
264 trace.WithInstrumentationVersion(i.ver),
265 trace.WithSchemaURL(i.url),
266 trace.WithInstrumentationAttributes(attribute.String("key", i.attr)),
267 )
268 }
269
270 for i, id0 := range ids {
271 for j, id1 := range ids {
272 l0, l1 := newTracer(id0), newTracer(id1)
273
274 if i == j {
275 assert.Samef(t, l0, l1, "Tracer(%v) != Tracer(%v)", id0, id1)
276 } else {
277 assert.NotSamef(t, l0, l1, "Tracer(%v) == Tracer(%v)", id0, id1)
278 }
279 }
280 }
281 }
282
283 func TestNewSpanType(t *testing.T) {
284 tracer := new(tracer)
285 ctx := t.Context()
286 _, got := tracer.newSpan(ctx, autoInstEnabled, "", nil)
287 assert.IsType(t, nonRecordingSpan{}, got, "default span type")
288
289 orig := *autoInstEnabled
290 *autoInstEnabled = true
291 t.Cleanup(func() { *autoInstEnabled = orig })
292
293 _, got = tracer.newSpan(ctx, autoInstEnabled, "", nil)
294 autoTracer := sdk.TracerProvider().Tracer("")
295 _, span := autoTracer.Start(ctx, "")
296 assert.IsType(t, span, got, "auto span type")
297 }