Debian Codegraph @

propagation/trace_context_test.go

raw
1 // Copyright The OpenTelemetry Authors
2 // SPDX-License-Identifier: Apache-2.0
3
4 package propagation_test
5
6 import (
7 "net/http"
8 "testing"
9
10 "github.com/stretchr/testify/assert"
11 "github.com/stretchr/testify/require"
12
13 "go.opentelemetry.io/otel/propagation"
14 "go.opentelemetry.io/otel/trace"
15 )
16
17 var (
18 traceparent = http.CanonicalHeaderKey("traceparent")
19 tracestate = http.CanonicalHeaderKey("tracestate")
20
21 prop = propagation.TraceContext{}
22 )
23
24 type testcase struct {
25 name string
26 header http.Header
27 sc trace.SpanContext
28 }
29
30 func TestExtractValidTraceContext(t *testing.T) {
31 stateStr := "key1=value1,key2=value2"
32 state, err := trace.ParseTraceState(stateStr)
33 require.NoError(t, err)
34
35 tests := []testcase{
36 {
37 name: "not sampled",
38 header: http.Header{
39 traceparent: []string{"00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-00"},
40 },
41 sc: trace.NewSpanContext(trace.SpanContextConfig{
42 TraceID: traceID,
43 SpanID: spanID,
44 Remote: true,
45 }),
46 },
47 {
48 name: "sampled",
49 header: http.Header{
50 traceparent: []string{"00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01"},
51 },
52 sc: trace.NewSpanContext(trace.SpanContextConfig{
53 TraceID: traceID,
54 SpanID: spanID,
55 TraceFlags: trace.FlagsSampled,
56 Remote: true,
57 }),
58 },
59 {
60 name: "random",
61 header: http.Header{
62 traceparent: []string{"00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-02"},
63 },
64 sc: trace.NewSpanContext(trace.SpanContextConfig{
65 TraceID: traceID,
66 SpanID: spanID,
67 TraceFlags: trace.TraceFlags(0x02),
68 Remote: true,
69 }),
70 },
71 {
72 name: "sampled and random",
73 header: http.Header{
74 traceparent: []string{"00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-03"},
75 },
76 sc: trace.NewSpanContext(trace.SpanContextConfig{
77 TraceID: traceID,
78 SpanID: spanID,
79 TraceFlags: trace.TraceFlags(0x03),
80 Remote: true,
81 }),
82 },
83 {
84 name: "valid tracestate",
85 header: http.Header{
86 traceparent: []string{"00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-00"},
87 tracestate: []string{stateStr},
88 },
89 sc: trace.NewSpanContext(trace.SpanContextConfig{
90 TraceID: traceID,
91 SpanID: spanID,
92 TraceState: state,
93 Remote: true,
94 }),
95 },
96 {
97 name: "invalid tracestate preserves traceparent",
98 header: http.Header{
99 traceparent: []string{"00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-00"},
100 tracestate: []string{"invalid$@#=invalid"},
101 },
102 sc: trace.NewSpanContext(trace.SpanContextConfig{
103 TraceID: traceID,
104 SpanID: spanID,
105 Remote: true,
106 }),
107 },
108 {
109 name: "future version not sampled",
110 header: http.Header{
111 traceparent: []string{"02-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-00"},
112 },
113 sc: trace.NewSpanContext(trace.SpanContextConfig{
114 TraceID: traceID,
115 SpanID: spanID,
116 Remote: true,
117 }),
118 },
119 {
120 name: "future version sampled",
121 header: http.Header{
122 traceparent: []string{"02-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01"},
123 },
124 sc: trace.NewSpanContext(trace.SpanContextConfig{
125 TraceID: traceID,
126 SpanID: spanID,
127 TraceFlags: trace.FlagsSampled,
128 Remote: true,
129 }),
130 },
131 {
132 name: "future version sample bit set reserved bits zeroed",
133 header: http.Header{
134 traceparent: []string{"02-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-09"},
135 },
136 sc: trace.NewSpanContext(trace.SpanContextConfig{
137 TraceID: traceID,
138 SpanID: spanID,
139 TraceFlags: trace.FlagsSampled,
140 Remote: true,
141 }),
142 },
143 {
144 name: "future version reserved bits zeroed",
145 header: http.Header{
146 traceparent: []string{"02-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-08"},
147 },
148 sc: trace.NewSpanContext(trace.SpanContextConfig{
149 TraceID: traceID,
150 SpanID: spanID,
151 Remote: true,
152 }),
153 },
154 {
155 name: "future version additional data",
156 header: http.Header{
157 traceparent: []string{"02-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-00-XYZxsf09"},
158 },
159 sc: trace.NewSpanContext(trace.SpanContextConfig{
160 TraceID: traceID,
161 SpanID: spanID,
162 Remote: true,
163 }),
164 },
165 {
166 name: "B3 format ending in dash",
167 header: http.Header{
168 traceparent: []string{"00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-00-"},
169 },
170 sc: trace.NewSpanContext(trace.SpanContextConfig{
171 TraceID: traceID,
172 SpanID: spanID,
173 Remote: true,
174 }),
175 },
176 {
177 name: "future version B3 format ending in dash",
178 header: http.Header{
179 traceparent: []string{"03-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-00-"},
180 },
181 sc: trace.NewSpanContext(trace.SpanContextConfig{
182 TraceID: traceID,
183 SpanID: spanID,
184 Remote: true,
185 }),
186 },
187 }
188
189 for _, tc := range tests {
190 t.Run(tc.name, func(t *testing.T) {
191 ctx := t.Context()
192 ctx = prop.Extract(ctx, propagation.HeaderCarrier(tc.header))
193 assert.Equal(t, tc.sc, trace.SpanContextFromContext(ctx))
194 })
195 }
196 }
197
198 func TestExtractInvalidTraceContextFromHTTPReq(t *testing.T) {
199 tests := []struct {
200 name string
201 header string
202 }{
203 {
204 name: "wrong version length",
205 header: "0000-00000000000000000000000000000000-0000000000000000-01",
206 },
207 {
208 name: "wrong trace ID length",
209 header: "00-ab00000000000000000000000000000000-cd00000000000000-01",
210 },
211 {
212 name: "wrong span ID length",
213 header: "00-ab000000000000000000000000000000-cd0000000000000000-01",
214 },
215 {
216 name: "wrong trace flag length",
217 header: "00-ab000000000000000000000000000000-cd00000000000000-0100",
218 },
219 {
220 name: "bogus version",
221 header: "qw-00000000000000000000000000000000-0000000000000000-01",
222 },
223 {
224 name: "bogus trace ID",
225 header: "00-qw000000000000000000000000000000-cd00000000000000-01",
226 },
227 {
228 name: "bogus span ID",
229 header: "00-ab000000000000000000000000000000-qw00000000000000-01",
230 },
231 {
232 name: "bogus trace flag",
233 header: "00-ab000000000000000000000000000000-cd00000000000000-qw",
234 },
235 {
236 name: "upper case version",
237 header: "A0-00000000000000000000000000000000-0000000000000000-01",
238 },
239 {
240 name: "upper case trace ID",
241 header: "00-AB000000000000000000000000000000-cd00000000000000-01",
242 },
243 {
244 name: "upper case span ID",
245 header: "00-ab000000000000000000000000000000-CD00000000000000-01",
246 },
247 {
248 name: "upper case trace flag",
249 header: "00-ab000000000000000000000000000000-cd00000000000000-A1",
250 },
251 {
252 name: "zero trace ID and span ID",
253 header: "00-00000000000000000000000000000000-0000000000000000-01",
254 },
255 {
256 name: "missing options",
257 header: "00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7",
258 },
259 {
260 name: "empty options",
261 header: "00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-",
262 },
263 {
264 name: "version 0 reserved trace flag bits set",
265 header: "00-ab000000000000000000000000000000-cd00000000000000-09",
266 },
267 {
268 name: "version 0 with extra content",
269 header: "00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01-extra",
270 },
271 }
272
273 empty := trace.SpanContext{}
274 for _, tt := range tests {
275 t.Run(tt.name, func(t *testing.T) {
276 h := http.Header{traceparent: []string{tt.header}}
277 ctx := t.Context()
278 ctx = prop.Extract(ctx, propagation.HeaderCarrier(h))
279
280 // Failure to extract needs to result in no SpanContext being set.
281 // This cannot be directly measured, but we can check that an
282 // zero-value SpanContext is returned from SpanContextFromContext.
283 assert.Equal(t, empty, trace.SpanContextFromContext(ctx))
284 })
285 }
286 }
287
288 func TestInjectValidTraceContext(t *testing.T) {
289 stateStr := "key1=value1,key2=value2"
290 state, err := trace.ParseTraceState(stateStr)
291 require.NoError(t, err)
292
293 tests := []testcase{
294 {
295 name: "not sampled",
296 header: http.Header{
297 traceparent: []string{"00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-00"},
298 },
299 sc: trace.NewSpanContext(trace.SpanContextConfig{
300 TraceID: traceID,
301 SpanID: spanID,
302 Remote: true,
303 }),
304 },
305 {
306 name: "sampled",
307 header: http.Header{
308 traceparent: []string{"00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01"},
309 },
310 sc: trace.NewSpanContext(trace.SpanContextConfig{
311 TraceID: traceID,
312 SpanID: spanID,
313 TraceFlags: trace.FlagsSampled,
314 Remote: true,
315 }),
316 },
317 {
318 name: "reserved trace flag bits dropped on inject",
319 header: http.Header{
320 traceparent: []string{"00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-03"},
321 },
322 sc: trace.NewSpanContext(trace.SpanContextConfig{
323 TraceID: traceID,
324 SpanID: spanID,
325 TraceFlags: trace.TraceFlags(0xff),
326 Remote: true,
327 }),
328 },
329 {
330 name: "random",
331 header: http.Header{
332 traceparent: []string{"00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-02"},
333 },
334 sc: trace.NewSpanContext(trace.SpanContextConfig{
335 TraceID: traceID,
336 SpanID: spanID,
337 TraceFlags: trace.TraceFlags(0x02),
338 Remote: true,
339 }),
340 },
341 {
342 name: "sampled and random",
343 header: http.Header{
344 traceparent: []string{"00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-03"},
345 },
346 sc: trace.NewSpanContext(trace.SpanContextConfig{
347 TraceID: traceID,
348 SpanID: spanID,
349 TraceFlags: trace.TraceFlags(0x03),
350 Remote: true,
351 }),
352 },
353 {
354 name: "with tracestate",
355 header: http.Header{
356 traceparent: []string{"00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-00"},
357 tracestate: []string{stateStr},
358 },
359 sc: trace.NewSpanContext(trace.SpanContextConfig{
360 TraceID: traceID,
361 SpanID: spanID,
362 TraceState: state,
363 Remote: true,
364 }),
365 },
366 }
367
368 for _, tc := range tests {
369 t.Run(tc.name, func(t *testing.T) {
370 ctx := t.Context()
371 ctx = trace.ContextWithRemoteSpanContext(ctx, tc.sc)
372
373 h := http.Header{}
374 prop.Inject(ctx, propagation.HeaderCarrier(h))
375 assert.Equal(t, tc.header, h)
376 })
377 }
378 }
379
380 func TestInvalidSpanContextDropped(t *testing.T) {
381 invalidSC := trace.SpanContext{}
382 require.False(t, invalidSC.IsValid())
383 ctx := trace.ContextWithRemoteSpanContext(t.Context(), invalidSC)
384
385 header := http.Header{}
386 propagation.TraceContext{}.Inject(ctx, propagation.HeaderCarrier(header))
387 assert.Empty(t, header.Get("traceparent"), "injected invalid SpanContext")
388 }
389
390 func TestTraceContextFields(t *testing.T) {
391 expected := []string{"traceparent", "tracestate"}
392 assert.Equal(t, expected, propagation.TraceContext{}.Fields())
393 }