Debian Codegraph @

propagation/baggage_test.go

raw
1 // Copyright The OpenTelemetry Authors
2 // SPDX-License-Identifier: Apache-2.0
3
4 package propagation_test
5
6 import (
7 "fmt"
8 "net/http"
9 "strings"
10 "testing"
11
12 "github.com/google/go-cmp/cmp"
13 "github.com/stretchr/testify/assert"
14
15 "go.opentelemetry.io/otel/baggage"
16 "go.opentelemetry.io/otel/propagation"
17 )
18
19 type property struct {
20 Key, Value string
21 }
22
23 type member struct {
24 Key, Value string
25
26 Properties []property
27 }
28
29 func (m member) Member(t *testing.T) baggage.Member {
30 props := make([]baggage.Property, 0, len(m.Properties))
31 for _, p := range m.Properties {
32 p, err := baggage.NewKeyValuePropertyRaw(p.Key, p.Value)
33 if err != nil {
34 t.Fatal(err)
35 }
36 props = append(props, p)
37 }
38 bMember, err := baggage.NewMemberRaw(m.Key, m.Value, props...)
39 if err != nil {
40 t.Fatal(err)
41 }
42 return bMember
43 }
44
45 type members []member
46
47 func (m members) Baggage(t *testing.T) baggage.Baggage {
48 bMembers := make([]baggage.Member, 0, len(m))
49 for _, mem := range m {
50 bMembers = append(bMembers, mem.Member(t))
51 }
52 bag, err := baggage.New(bMembers...)
53 if err != nil {
54 t.Fatal(err)
55 }
56 return bag
57 }
58
59 func TestExtractValidBaggage(t *testing.T) {
60 prop := propagation.TextMapPropagator(propagation.Baggage{})
61 tests := []struct {
62 name string
63 header string
64 want members
65 }{
66 {
67 name: "valid w3cHeader",
68 header: "key1=val1,key2=val2",
69 want: members{
70 {Key: "key1", Value: "val1"},
71 {Key: "key2", Value: "val2"},
72 },
73 },
74 {
75 name: "valid w3cHeader with spaces",
76 header: "key1 = val1, key2 =val2 ",
77 want: members{
78 {Key: "key1", Value: "val1"},
79 {Key: "key2", Value: "val2"},
80 },
81 },
82 {
83 name: "valid w3cHeader with properties",
84 header: "key1=val1,key2=val2;prop=1",
85 want: members{
86 {Key: "key1", Value: "val1"},
87 {
88 Key: "key2",
89 Value: "val2",
90 Properties: []property{
91 {Key: "prop", Value: "1"},
92 },
93 },
94 },
95 },
96 {
97 name: "valid header with an invalid header",
98 header: "key1=val1,key2=val2,a,val3",
99 want: members{
100 {Key: "key1", Value: "val1"},
101 {Key: "key2", Value: "val2"},
102 },
103 },
104 {
105 name: "valid header with no value",
106 header: "key1=,key2=val2",
107 want: members{
108 {Key: "key1", Value: ""},
109 {Key: "key2", Value: "val2"},
110 },
111 },
112 {
113 name: "valid header with url encoded string",
114 header: "key1=val%252",
115 want: members{
116 {Key: "key1", Value: "val%2"},
117 },
118 },
119 {
120 name: "empty header",
121 header: "",
122 want: members{},
123 },
124 }
125
126 for _, tt := range tests {
127 t.Run(tt.name, func(t *testing.T) {
128 mapCarr := propagation.MapCarrier{}
129 mapCarr["baggage"] = tt.header
130 req, _ := http.NewRequestWithContext(t.Context(), http.MethodGet, "http://example.com", http.NoBody)
131 req.Header.Set("baggage", tt.header)
132
133 // test with http header carrier (which implements ValuesGetter)
134 ctx := prop.Extract(t.Context(), propagation.HeaderCarrier(req.Header))
135 expected := tt.want.Baggage(t)
136 assert.Equal(t, expected, baggage.FromContext(ctx), "should extract baggage for HeaderCarrier")
137
138 // test with map carrier (which does not implement ValuesGetter)
139 ctx = prop.Extract(t.Context(), mapCarr)
140 expected = tt.want.Baggage(t)
141 assert.Equal(t, expected, baggage.FromContext(ctx), "should extract baggage for MapCarrier")
142 })
143 }
144 }
145
146 // generateBaggageHeader creates a baggage header string with n members.
147 func generateBaggageHeader(n int, prefix string) string {
148 parts := make([]string, n)
149 for i := range parts {
150 parts[i] = fmt.Sprintf("%s%d=v%d", prefix, i, i)
151 }
152 return strings.Join(parts, ",")
153 }
154
155 // generateMembers creates n members with keys like "prefix0", "prefix1", etc.
156 func generateMembers(n int, prefix string) members {
157 m := make(members, n)
158 for i := range m {
159 m[i] = member{Key: fmt.Sprintf("%s%d", prefix, i), Value: fmt.Sprintf("v%d", i)}
160 }
161 return m
162 }
163
164 func TestExtractValidMultipleBaggageHeaders(t *testing.T) {
165 // W3C Baggage spec limits: https://www.w3.org/TR/baggage/#limits
166 const maxMembers = 64
167 const maxBytesPerBaggageString = 8192
168
169 prop := propagation.TextMapPropagator(propagation.Baggage{})
170 tests := []struct {
171 name string
172 headers []string
173 want members
174 wantCount int // Used when want is nil and we only care about count.
175 wantMaxBytes int // Used to check that baggage size doesn't exceed limit.
176 }{
177 {
178 name: "non conflicting headers",
179 headers: []string{"key1=val1", "key2=val2"},
180 want: members{
181 {Key: "key1", Value: "val1"},
182 {Key: "key2", Value: "val2"},
183 },
184 },
185 {
186 name: "conflicting keys, uses last val",
187 headers: []string{"key1=val1", "key1=val2"},
188 want: members{
189 {Key: "key1", Value: "val2"},
190 },
191 },
192 {
193 name: "single empty",
194 headers: []string{"", "key1=val1"},
195 want: members{
196 {Key: "key1", Value: "val1"},
197 },
198 },
199 {
200 name: "all empty",
201 headers: []string{"", ""},
202 want: members{},
203 },
204 {
205 name: "none",
206 headers: []string{},
207 want: members{},
208 },
209 {
210 name: "single header with one invalid skips invalid",
211 headers: []string{"key1=val1,invalid-no-equals,key2=val2"},
212 want: members{
213 {Key: "key1", Value: "val1"},
214 {Key: "key2", Value: "val2"},
215 },
216 },
217 {
218 name: "multiple headers with one invalid skips invalid and continues",
219 headers: []string{
220 "key1=val1",
221 "invalid-no-equals",
222 "key2=val2",
223 },
224 want: members{
225 {Key: "key1", Value: "val1"},
226 {Key: "key2", Value: "val2"},
227 },
228 },
229 {
230 name: "single header at max members limit",
231 headers: []string{generateBaggageHeader(maxMembers, "k")},
232 want: generateMembers(maxMembers, "k"),
233 },
234 {
235 name: "single header exceeds max members limit keeps 64",
236 headers: []string{generateBaggageHeader(maxMembers+1, "k")},
237 want: generateMembers(maxMembers, "k"),
238 },
239 {
240 name: "multiple headers exceeds total max members limit keeps 64",
241 headers: []string{
242 generateBaggageHeader(maxMembers/2, "a"),
243 generateBaggageHeader(maxMembers/2, "b"),
244 generateBaggageHeader(1, "c"),
245 },
246 want: nil, // Non-deterministic truncation by baggage.New()
247 wantCount: maxMembers,
248 wantMaxBytes: maxBytesPerBaggageString,
249 },
250 {
251 name: "single header at max bytes limit",
252 headers: []string{"k=" + strings.Repeat("v", maxBytesPerBaggageString-2)},
253 want: members{
254 {Key: "k", Value: strings.Repeat("v", maxBytesPerBaggageString-2)},
255 },
256 },
257 {
258 name: "single header exceeds max bytes limit drops oversized member",
259 headers: []string{"k=" + strings.Repeat("v", maxBytesPerBaggageString-1)},
260 want: members{},
261 },
262 {
263 name: "multiple headers exceed total max bytes keeps one that fits",
264 headers: []string{
265 "k=" + strings.Repeat("v", maxBytesPerBaggageString-2),
266 "y=" + strings.Repeat("v", maxBytesPerBaggageString-2),
267 },
268 want: nil, // Non-deterministic: either k or y will be kept
269 wantCount: 1, // Only one member fits
270 wantMaxBytes: maxBytesPerBaggageString,
271 },
272 {
273 name: "multiple headers within total max bytes",
274 headers: []string{
275 "k=" + strings.Repeat("v", maxBytesPerBaggageString/2-2),
276 // The comma as the separator of member would take 1 byte.
277 "y=" + strings.Repeat("v", maxBytesPerBaggageString/2-2-1),
278 },
279 want: members{
280 {Key: "k", Value: strings.Repeat("v", maxBytesPerBaggageString/2-2)},
281 {Key: "y", Value: strings.Repeat("v", maxBytesPerBaggageString/2-2-1)},
282 },
283 },
284 {
285 name: "many headers exceeding member limit caps collection early",
286 headers: func() []string {
287 // 100 headers with 10 members each = 1000 total members.
288 // The cap should stop collecting after ~maxMembers and
289 // New() truncates to exactly maxMembers.
290 h := make([]string, 100)
291 for i := range h {
292 h[i] = generateBaggageHeader(10, fmt.Sprintf("h%d_k", i))
293 }
294 return h
295 }(),
296 wantCount: maxMembers,
297 wantMaxBytes: maxBytesPerBaggageString,
298 },
299 {
300 name: "skips large member that exceeds byte limit and continues",
301 headers: []string{
302 "small1=v1,small2=v2",
303 "large=" + strings.Repeat("x", maxBytesPerBaggageString),
304 "small3=v3",
305 },
306 want: members{
307 {Key: "small1", Value: "v1"},
308 {Key: "small2", Value: "v2"},
309 {Key: "small3", Value: "v3"},
310 },
311 },
312 }
313
314 for _, tt := range tests {
315 t.Run(tt.name, func(t *testing.T) {
316 req, _ := http.NewRequestWithContext(t.Context(), http.MethodGet, "http://example.com", http.NoBody)
317 req.Header["Baggage"] = tt.headers
318
319 ctx := t.Context()
320 ctx = prop.Extract(ctx, propagation.HeaderCarrier(req.Header))
321 got := baggage.FromContext(ctx)
322
323 // If want is specified, check exact match
324 if tt.want != nil {
325 expected := tt.want.Baggage(t)
326 assert.Equal(t, expected, got)
327 } else if tt.wantCount > 0 {
328 // If only count is specified, verify count and byte limit
329 assert.Equal(t, tt.wantCount, got.Len(), "expected member count")
330 assert.LessOrEqual(t, len(got.String()), tt.wantMaxBytes, "baggage size exceeds limit")
331 }
332 })
333 }
334 }
335
336 func TestExtractInvalidDistributedContextFromHTTPReq(t *testing.T) {
337 prop := propagation.TextMapPropagator(propagation.Baggage{})
338 tests := []struct {
339 name string
340 header string
341 has members
342 }{
343 {
344 name: "no key values",
345 header: "header1",
346 },
347 {
348 name: "invalid header with existing context",
349 header: "header2",
350 has: members{
351 {Key: "key1", Value: "val1"},
352 {Key: "key2", Value: "val2"},
353 },
354 },
355 {
356 name: "empty header value",
357 header: "",
358 has: members{
359 {Key: "key1", Value: "val1"},
360 {Key: "key2", Value: "val2"},
361 },
362 },
363 {
364 name: "with properties",
365 header: "key1=val1,key2=val2;prop=1",
366 has: members{
367 {Key: "key1", Value: "val1"},
368 {
369 Key: "key2",
370 Value: "val2",
371 Properties: []property{
372 {Key: "prop", Value: "1"},
373 },
374 },
375 },
376 },
377 }
378
379 for _, tt := range tests {
380 t.Run(tt.name, func(t *testing.T) {
381 req, _ := http.NewRequestWithContext(t.Context(), http.MethodGet, "http://example.com", http.NoBody)
382 req.Header.Set("baggage", tt.header)
383
384 expected := tt.has.Baggage(t)
385 ctx := baggage.ContextWithBaggage(t.Context(), expected)
386 ctx = prop.Extract(ctx, propagation.HeaderCarrier(req.Header))
387 assert.Equal(t, expected, baggage.FromContext(ctx))
388 })
389 }
390 }
391
392 func TestInjectBaggageToHTTPReq(t *testing.T) {
393 propagator := propagation.Baggage{}
394 tests := []struct {
395 name string
396 mems members
397 wantInHeader []string
398 }{
399 {
400 name: "two simple values",
401 mems: members{
402 {Key: "key1", Value: "val1"},
403 {Key: "key2", Value: "val2"},
404 },
405 wantInHeader: []string{"key1=val1", "key2=val2"},
406 },
407 {
408 name: "values with escaped chars",
409 mems: members{
410 {Key: "key2", Value: "val3,4"},
411 },
412 wantInHeader: []string{"key2=val3%2C4"},
413 },
414 {
415 name: "with properties",
416 mems: members{
417 {Key: "key1", Value: "val1"},
418 {
419 Key: "key2",
420 Value: "val2",
421 Properties: []property{
422 {Key: "prop", Value: "1"},
423 },
424 },
425 },
426 wantInHeader: []string{
427 "key1=val1",
428 "key2=val2;prop=1",
429 },
430 },
431 }
432 for _, tt := range tests {
433 t.Run(tt.name, func(t *testing.T) {
434 req, _ := http.NewRequestWithContext(t.Context(), http.MethodGet, "http://example.com", http.NoBody)
435 ctx := baggage.ContextWithBaggage(t.Context(), tt.mems.Baggage(t))
436 propagator.Inject(ctx, propagation.HeaderCarrier(req.Header))
437
438 got := strings.Split(req.Header.Get("baggage"), ",")
439 assert.ElementsMatch(t, tt.wantInHeader, got)
440 })
441 }
442 }
443
444 func TestBaggageInjectExtractRoundtrip(t *testing.T) {
445 propagator := propagation.Baggage{}
446 tests := []struct {
447 name string
448 mems members
449 }{
450 {
451 name: "two simple values",
452 mems: members{
453 {Key: "key1", Value: "val1"},
454 {Key: "key2", Value: "val2"},
455 },
456 },
457 {
458 name: "values with escaped chars",
459 mems: members{
460 {Key: "key1", Value: "val3=4"},
461 {Key: "key2", Value: "mess,me%up"},
462 },
463 },
464 {
465 name: "with properties",
466 mems: members{
467 {Key: "key1", Value: "val1"},
468 {
469 Key: "key2",
470 Value: "val2",
471 Properties: []property{
472 {Key: "prop", Value: "1"},
473 },
474 },
475 },
476 },
477 }
478 for _, tt := range tests {
479 t.Run(tt.name, func(t *testing.T) {
480 b := tt.mems.Baggage(t)
481 req, _ := http.NewRequestWithContext(t.Context(), http.MethodGet, "http://example.com", http.NoBody)
482 ctx := baggage.ContextWithBaggage(t.Context(), b)
483 propagator.Inject(ctx, propagation.HeaderCarrier(req.Header))
484
485 ctx = propagator.Extract(t.Context(), propagation.HeaderCarrier(req.Header))
486 got := baggage.FromContext(ctx)
487
488 assert.Equal(t, b, got)
489 })
490 }
491 }
492
493 func TestBaggagePropagatorGetAllKeys(t *testing.T) {
494 var propagator propagation.Baggage
495 want := []string{"baggage"}
496 got := propagator.Fields()
497 if diff := cmp.Diff(got, want); diff != "" {
498 t.Errorf("GetAllKeys: -got +want %s", diff)
499 }
500 }