Debian Codegraph @

trace/tracestate_test.go

raw
1 // Copyright The OpenTelemetry Authors
2 // SPDX-License-Identifier: Apache-2.0
3
4 package trace
5
6 import (
7 "encoding/json"
8 "fmt"
9 "testing"
10
11 "github.com/stretchr/testify/assert"
12 "github.com/stretchr/testify/require"
13 )
14
15 // Taken from the W3C tests:
16 // https://github.com/w3c/trace-context/blob/dcd3ad9b7d6ac36f70ff3739874b73c11b0302a1/test/test_data.json
17 var testcases = []struct {
18 name string
19 in string
20 tracestate TraceState
21 out string
22 err error
23 }{
24 {
25 name: "duplicate with the same value",
26 in: "foo=1,foo=1",
27 err: errDuplicate,
28 },
29 {
30 name: "duplicate with different values",
31 in: "foo=1,foo=2",
32 err: errDuplicate,
33 },
34 {
35 name: "improperly formatted key/value pair",
36 in: "foo =1",
37 err: errInvalidMember,
38 },
39 {
40 name: "upper case key",
41 in: "FOO=1",
42 err: errInvalidMember,
43 },
44 {
45 name: "key with invalid character",
46 in: "foo.bar=1",
47 err: errInvalidMember,
48 },
49 {
50 name: "multiple keys, one with empty tenant key",
51 in: "foo@=1,bar=2",
52 err: errInvalidMember,
53 },
54 {
55 name: "multiple keys, one with only tenant",
56 in: "@foo=1,bar=2",
57 err: errInvalidMember,
58 },
59 {
60 name: "multiple keys, one with double tenant separator",
61 in: "foo@@bar=1,bar=2",
62 err: errInvalidMember,
63 },
64 {
65 name: "multiple keys, one with multiple tenants",
66 in: "foo@bar@baz=1,bar=2",
67 err: errInvalidMember,
68 },
69 {
70 name: "key too long",
71 in: "foo=1,zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz=1",
72 err: errInvalidMember,
73 },
74 {
75 name: "key too long, with tenant",
76 in: "foo=1,tttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttt@v=1",
77 err: errInvalidMember,
78 },
79 {
80 name: "tenant too long",
81 in: "foo=1,t@vvvvvvvvvvvvvvv=1",
82 err: errInvalidMember,
83 },
84 {
85 name: "multiple values for a single key",
86 in: "foo=bar=baz",
87 err: errInvalidMember,
88 },
89 {
90 name: "no value",
91 in: "foo=,bar=3",
92 err: errInvalidMember,
93 },
94 {
95 name: "too many members",
96 in: "bar01=01,bar02=02,bar03=03,bar04=04,bar05=05,bar06=06,bar07=07,bar08=08,bar09=09,bar10=10,bar11=11,bar12=12,bar13=13,bar14=14,bar15=15,bar16=16,bar17=17,bar18=18,bar19=19,bar20=20,bar21=21,bar22=22,bar23=23,bar24=24,bar25=25,bar26=26,bar27=27,bar28=28,bar29=29,bar30=30,bar31=31,bar32=32,bar33=33",
97 err: errMemberNumber,
98 },
99 {
100 name: "valid key/value list",
101 in: "abcdefghijklmnopqrstuvwxyz0123456789_-*/= !\"#$%&'()*+-./0123456789:;<>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~",
102 out: "abcdefghijklmnopqrstuvwxyz0123456789_-*/= !\"#$%&'()*+-./0123456789:;<>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~",
103 tracestate: TraceState{list: []member{
104 {
105 Key: "abcdefghijklmnopqrstuvwxyz0123456789_-*/",
106 Value: " !\"#$%&'()*+-./0123456789:;<>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~",
107 },
108 }},
109 },
110 {
111 name: "valid key/value list with tenant",
112 in: "abcdefghijklmnopqrstuvwxyz0123456789_-*/@a-z0-9_-*/= !\"#$%&'()*+-./0123456789:;<>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~",
113 out: "abcdefghijklmnopqrstuvwxyz0123456789_-*/@a-z0-9_-*/= !\"#$%&'()*+-./0123456789:;<>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~",
114 tracestate: TraceState{list: []member{
115 {
116 Key: "abcdefghijklmnopqrstuvwxyz0123456789_-*/@a-z0-9_-*/",
117 Value: " !\"#$%&'()*+-./0123456789:;<>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~",
118 },
119 }},
120 },
121 {
122 name: "empty input",
123 // Empty input should result in no error and a zero value
124 // TraceState being returned, that TraceState should be encoded as an
125 // empty string.
126 },
127 {
128 name: "single key and value",
129 in: "foo=1",
130 out: "foo=1",
131 tracestate: TraceState{list: []member{
132 {Key: "foo", Value: "1"},
133 }},
134 },
135 {
136 name: "single key and value with empty separator",
137 in: "foo=1,",
138 out: "foo=1",
139 tracestate: TraceState{list: []member{
140 {Key: "foo", Value: "1"},
141 }},
142 },
143 {
144 name: "multiple keys and values",
145 in: "foo=1,bar=2",
146 out: "foo=1,bar=2",
147 tracestate: TraceState{list: []member{
148 {Key: "foo", Value: "1"},
149 {Key: "bar", Value: "2"},
150 }},
151 },
152 {
153 name: "with a key at maximum length",
154 in: "foo=1,zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz=1",
155 out: "foo=1,zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz=1",
156 tracestate: TraceState{list: []member{
157 {
158 Key: "foo",
159 Value: "1",
160 },
161 {
162 Key: "zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz",
163 Value: "1",
164 },
165 }},
166 },
167 {
168 name: "with a key and tenant at maximum length",
169 in: "foo=1,ttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttt@vvvvvvvvvvvvvv=1",
170 out: "foo=1,ttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttt@vvvvvvvvvvvvvv=1",
171 tracestate: TraceState{list: []member{
172 {
173 Key: "foo",
174 Value: "1",
175 },
176 {
177 Key: "ttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttt@vvvvvvvvvvvvvv",
178 Value: "1",
179 },
180 }},
181 },
182 {
183 name: "with maximum members",
184 in: "bar01=01,bar02=02,bar03=03,bar04=04,bar05=05,bar06=06,bar07=07,bar08=08,bar09=09,bar10=10,bar11=11,bar12=12,bar13=13,bar14=14,bar15=15,bar16=16,bar17=17,bar18=18,bar19=19,bar20=20,bar21=21,bar22=22,bar23=23,bar24=24,bar25=25,bar26=26,bar27=27,bar28=28,bar29=29,bar30=30,bar31=31,bar32=32",
185 out: "bar01=01,bar02=02,bar03=03,bar04=04,bar05=05,bar06=06,bar07=07,bar08=08,bar09=09,bar10=10,bar11=11,bar12=12,bar13=13,bar14=14,bar15=15,bar16=16,bar17=17,bar18=18,bar19=19,bar20=20,bar21=21,bar22=22,bar23=23,bar24=24,bar25=25,bar26=26,bar27=27,bar28=28,bar29=29,bar30=30,bar31=31,bar32=32",
186 tracestate: TraceState{list: []member{
187 {Key: "bar01", Value: "01"},
188 {Key: "bar02", Value: "02"},
189 {Key: "bar03", Value: "03"},
190 {Key: "bar04", Value: "04"},
191 {Key: "bar05", Value: "05"},
192 {Key: "bar06", Value: "06"},
193 {Key: "bar07", Value: "07"},
194 {Key: "bar08", Value: "08"},
195 {Key: "bar09", Value: "09"},
196 {Key: "bar10", Value: "10"},
197 {Key: "bar11", Value: "11"},
198 {Key: "bar12", Value: "12"},
199 {Key: "bar13", Value: "13"},
200 {Key: "bar14", Value: "14"},
201 {Key: "bar15", Value: "15"},
202 {Key: "bar16", Value: "16"},
203 {Key: "bar17", Value: "17"},
204 {Key: "bar18", Value: "18"},
205 {Key: "bar19", Value: "19"},
206 {Key: "bar20", Value: "20"},
207 {Key: "bar21", Value: "21"},
208 {Key: "bar22", Value: "22"},
209 {Key: "bar23", Value: "23"},
210 {Key: "bar24", Value: "24"},
211 {Key: "bar25", Value: "25"},
212 {Key: "bar26", Value: "26"},
213 {Key: "bar27", Value: "27"},
214 {Key: "bar28", Value: "28"},
215 {Key: "bar29", Value: "29"},
216 {Key: "bar30", Value: "30"},
217 {Key: "bar31", Value: "31"},
218 {Key: "bar32", Value: "32"},
219 }},
220 },
221 {
222 name: "with several members",
223 in: "foo=1,bar=2,rojo=1,congo=2,baz=3",
224 out: "foo=1,bar=2,rojo=1,congo=2,baz=3",
225 tracestate: TraceState{list: []member{
226 {Key: "foo", Value: "1"},
227 {Key: "bar", Value: "2"},
228 {Key: "rojo", Value: "1"},
229 {Key: "congo", Value: "2"},
230 {Key: "baz", Value: "3"},
231 }},
232 },
233 {
234 name: "with tabs between members",
235 in: "foo=1 \t , \t bar=2, \t baz=3",
236 out: "foo=1,bar=2,baz=3",
237 tracestate: TraceState{list: []member{
238 {Key: "foo", Value: "1"},
239 {Key: "bar", Value: "2"},
240 {Key: "baz", Value: "3"},
241 }},
242 },
243 {
244 name: "with multiple tabs between members",
245 in: "foo=1\t \t,\t \tbar=2,\t \tbaz=3",
246 out: "foo=1,bar=2,baz=3",
247 tracestate: TraceState{list: []member{
248 {Key: "foo", Value: "1"},
249 {Key: "bar", Value: "2"},
250 {Key: "baz", Value: "3"},
251 }},
252 },
253 {
254 name: "with space at the end of the member",
255 in: "foo=1 ",
256 out: "foo=1",
257 tracestate: TraceState{list: []member{
258 {Key: "foo", Value: "1"},
259 }},
260 },
261 {
262 name: "with tab at the end of the member",
263 in: "foo=1\t",
264 out: "foo=1",
265 tracestate: TraceState{list: []member{
266 {Key: "foo", Value: "1"},
267 }},
268 },
269 {
270 name: "with tab and space at the end of the member",
271 in: "foo=1 \t",
272 out: "foo=1",
273 tracestate: TraceState{list: []member{
274 {Key: "foo", Value: "1"},
275 }},
276 },
277 }
278
279 var maxMembers = func() TraceState {
280 members := make([]member, maxListMembers)
281 for i := range maxListMembers {
282 members[i] = member{
283 Key: fmt.Sprintf("key%d", i+1),
284 Value: fmt.Sprintf("value%d", i+1),
285 }
286 }
287 return TraceState{list: members}
288 }()
289
290 func TestParseTraceState(t *testing.T) {
291 for _, tc := range testcases {
292 t.Run(tc.name, func(t *testing.T) {
293 got, err := ParseTraceState(tc.in)
294 assert.Equal(t, tc.tracestate, got)
295 if tc.err != nil {
296 assert.ErrorIs(t, err, tc.err, tc.in)
297 } else {
298 assert.NoError(t, err, tc.in)
299 }
300 })
301 }
302 }
303
304 func TestTraceStateString(t *testing.T) {
305 for _, tc := range testcases {
306 if tc.err != nil {
307 // Only test non-zero value TraceState.
308 continue
309 }
310 t.Run(tc.name, func(t *testing.T) {
311 assert.Equal(t, tc.out, tc.tracestate.String())
312 })
313 }
314 }
315
316 func TestTraceStateMarshalJSON(t *testing.T) {
317 for _, tc := range testcases {
318 if tc.err != nil {
319 // Only test non-zero value TraceState.
320 continue
321 }
322 t.Run(tc.name, func(t *testing.T) {
323 // Encode UTF-8.
324 expected, err := json.Marshal(tc.out)
325 require.NoError(t, err)
326
327 actual, err := json.Marshal(tc.tracestate)
328 require.NoError(t, err)
329
330 assert.Equal(t, expected, actual)
331 })
332 }
333 }
334
335 func TestTraceStateGet(t *testing.T) {
336 testCases := []struct {
337 name string
338 key string
339 expected string
340 }{
341 {
342 name: "OK case",
343 key: "key16",
344 expected: "value16",
345 },
346 {
347 name: "not found",
348 key: "keyxx",
349 expected: "",
350 },
351 {
352 name: "invalid W3C key",
353 key: "key!",
354 expected: "",
355 },
356 }
357
358 for _, tc := range testCases {
359 t.Run(tc.name, func(t *testing.T) {
360 assert.Equal(t, tc.expected, maxMembers.Get(tc.key))
361 })
362 }
363 }
364
365 func TestTraceStateDelete(t *testing.T) {
366 ts := TraceState{list: []member{
367 {Key: "key1", Value: "val1"},
368 {Key: "key2", Value: "val2"},
369 {Key: "key3", Value: "val3"},
370 }}
371
372 testCases := []struct {
373 name string
374 key string
375 expected TraceState
376 }{
377 {
378 name: "OK case",
379 key: "key2",
380 expected: TraceState{list: []member{
381 {Key: "key1", Value: "val1"},
382 {Key: "key3", Value: "val3"},
383 }},
384 },
385 {
386 name: "Non-existing key",
387 key: "keyx",
388 expected: TraceState{list: []member{
389 {Key: "key1", Value: "val1"},
390 {Key: "key2", Value: "val2"},
391 {Key: "key3", Value: "val3"},
392 }},
393 },
394 {
395 name: "Invalid key",
396 key: "in va lid",
397 expected: TraceState{list: []member{
398 {Key: "key1", Value: "val1"},
399 {Key: "key2", Value: "val2"},
400 {Key: "key3", Value: "val3"},
401 }},
402 },
403 }
404
405 for _, tc := range testCases {
406 t.Run(tc.name, func(t *testing.T) {
407 assert.Equal(t, tc.expected, ts.Delete(tc.key))
408 })
409 }
410 }
411
412 func TestTraceStateWalk(t *testing.T) {
413 testCases := []struct {
414 name string
415 tracestate TraceState
416 num int
417 expected [][]string
418 }{
419 {
420 name: "With keys",
421 tracestate: TraceState{list: []member{
422 {Key: "key1", Value: "val1"},
423 {Key: "key2", Value: "val2"},
424 }},
425 num: 3,
426 expected: [][]string{{"key1", "val1"}, {"key2", "val2"}},
427 },
428 {
429 name: "With keys walk partially",
430 tracestate: TraceState{list: []member{
431 {Key: "key1", Value: "val1"},
432 {Key: "key2", Value: "val2"},
433 }},
434 num: 1,
435 expected: [][]string{{"key1", "val1"}},
436 },
437
438 {
439 name: "Without keys",
440 tracestate: TraceState{list: []member{}},
441 num: 2,
442 expected: [][]string{},
443 },
444 }
445
446 for _, tc := range testCases {
447 t.Run(tc.name, func(t *testing.T) {
448 got := [][]string{}
449 tc.tracestate.Walk(func(key, value string) bool {
450 got = append(got, []string{key, value})
451 return len(got) < tc.num
452 })
453 assert.Equal(t, tc.expected, got)
454 })
455 }
456 }
457
458 var insertTS = TraceState{list: []member{
459 {Key: "key1", Value: "val1"},
460 {Key: "key2", Value: "val2"},
461 {Key: "key3", Value: "val3"},
462 }}
463
464 var insertTestcase = []struct {
465 name string
466 tracestate TraceState
467 key, value string
468 expected TraceState
469 err error
470 }{
471 {
472 name: "add new",
473 tracestate: insertTS,
474 key: "key4@vendor",
475 value: "val4",
476 expected: TraceState{list: []member{
477 {Key: "key4@vendor", Value: "val4"},
478 {Key: "key1", Value: "val1"},
479 {Key: "key2", Value: "val2"},
480 {Key: "key3", Value: "val3"},
481 }},
482 },
483 {
484 name: "replace",
485 tracestate: insertTS,
486 key: "key2",
487 value: "valX",
488 expected: TraceState{list: []member{
489 {Key: "key2", Value: "valX"},
490 {Key: "key1", Value: "val1"},
491 {Key: "key3", Value: "val3"},
492 }},
493 },
494 {
495 name: "invalid key",
496 tracestate: insertTS,
497 key: "key!",
498 value: "val",
499 expected: insertTS,
500 err: errInvalidKey,
501 },
502 {
503 name: "invalid value",
504 tracestate: insertTS,
505 key: "key",
506 value: "v=l",
507 expected: insertTS,
508 err: errInvalidValue,
509 },
510 {
511 name: "invalid key/value",
512 tracestate: insertTS,
513 key: "key!",
514 value: "v=l",
515 expected: insertTS,
516 err: errInvalidKey,
517 },
518 {
519 name: "drop the right-most member(oldest) in queue",
520 tracestate: maxMembers,
521 key: "keyx",
522 value: "valx",
523 expected: func() TraceState {
524 // Prepend the new element and remove the oldest one, which is over capacity.
525 return TraceState{
526 list: append(
527 []member{{Key: "keyx", Value: "valx"}},
528 maxMembers.list[:len(maxMembers.list)-1]...,
529 ),
530 }
531 }(),
532 },
533 }
534
535 func TestTraceStateInsert(t *testing.T) {
536 for _, tc := range insertTestcase {
537 t.Run(tc.name, func(t *testing.T) {
538 actual, err := tc.tracestate.Insert(tc.key, tc.value)
539 assert.ErrorIs(t, err, tc.err, tc.name)
540 if tc.err != nil {
541 assert.Equal(t, tc.tracestate, actual)
542 } else {
543 assert.Equal(t, tc.expected, actual)
544 }
545 })
546 }
547 }
548
549 func TestTraceStateLen(t *testing.T) {
550 ts := TraceState{}
551 assert.Equal(t, 0, ts.Len(), "zero value TraceState is empty")
552
553 key := "key"
554 ts = TraceState{list: []member{{key, "value"}}}
555 assert.Equal(t, 1, ts.Len(), "TraceState with one value")
556 }
557
558 func TestTraceStateImmutable(t *testing.T) {
559 k0, v0 := "k0", "v0"
560 ts0 := TraceState{list: []member{{k0, v0}}}
561 assert.Equal(t, v0, ts0.Get(k0))
562
563 // Insert should not modify the original.
564 k1, v1 := "k1", "v1"
565 ts1, err := ts0.Insert(k1, v1)
566 require.NoError(t, err)
567 assert.Equal(t, v0, ts0.Get(k0))
568 assert.Empty(t, ts0.Get(k1))
569 assert.Equal(t, v0, ts1.Get(k0))
570 assert.Equal(t, v1, ts1.Get(k1))
571
572 // Update should not modify the original.
573 v2 := "v2"
574 ts2, err := ts1.Insert(k1, v2)
575 require.NoError(t, err)
576 assert.Equal(t, v0, ts0.Get(k0))
577 assert.Empty(t, ts0.Get(k1))
578 assert.Equal(t, v0, ts1.Get(k0))
579 assert.Equal(t, v1, ts1.Get(k1))
580 assert.Equal(t, v0, ts2.Get(k0))
581 assert.Equal(t, v2, ts2.Get(k1))
582
583 // Delete should not modify the original.
584 ts3 := ts2.Delete(k0)
585 assert.Equal(t, v0, ts0.Get(k0))
586 assert.Equal(t, v0, ts1.Get(k0))
587 assert.Equal(t, v0, ts2.Get(k0))
588 assert.Empty(t, ts3.Get(k0))
589 }
590
591 func BenchmarkParseTraceState(b *testing.B) {
592 benches := []struct {
593 name string
594 in string
595 }{
596 {
597 name: "single key",
598 in: "somewhat-realistic-key-length=someValueAbcdefgh1234567890",
599 },
600 {
601 name: "tenant single key",
602 in: "somewhat-realistic-key-length@some-tenant=someValueAbcdefgh1234567890",
603 },
604 {
605 name: "three keys",
606 in: "some-key-name/one=someValue1,some-key-name/two=someValue2,some-key-name/three=someValue3",
607 },
608 {
609 name: "tenant three keys",
610 in: "some-key-name/one@tenant=someValue1,some-key-name/two@tenant=someValue2,some-key-name/three@tenant=someValue3",
611 },
612 }
613 for _, bench := range benches {
614 b.Run(bench.name, func(b *testing.B) {
615 b.ReportAllocs()
616 b.ResetTimer()
617
618 for i := 0; i < b.N; i++ {
619 _, err := ParseTraceState(bench.in)
620 if err != nil {
621 b.Fatalf("parse TraceState: %v", err)
622 }
623 }
624 })
625 }
626 }