Debian Codegraph @

bridge/opentracing/bridge.go

raw
1 // Copyright The OpenTelemetry Authors
2 // SPDX-License-Identifier: Apache-2.0
3
4 package opentracing // import "go.opentelemetry.io/otel/bridge/opentracing"
5
6 import (
7 "context"
8 "fmt"
9 "maps"
10 "strconv"
11 "strings"
12 "sync"
13
14 ot "github.com/opentracing/opentracing-go"
15 otext "github.com/opentracing/opentracing-go/ext"
16 otlog "github.com/opentracing/opentracing-go/log"
17
18 "go.opentelemetry.io/otel"
19 "go.opentelemetry.io/otel/attribute"
20 "go.opentelemetry.io/otel/baggage"
21 "go.opentelemetry.io/otel/bridge/opentracing/migration"
22 "go.opentelemetry.io/otel/codes"
23 iBaggage "go.opentelemetry.io/otel/internal/baggage"
24 "go.opentelemetry.io/otel/propagation"
25 "go.opentelemetry.io/otel/trace"
26 "go.opentelemetry.io/otel/trace/noop"
27 )
28
29 var (
30 noopTracer = noop.NewTracerProvider().Tracer("")
31 noopSpan = func() trace.Span {
32 _, s := noopTracer.Start(context.Background(), "")
33 return s
34 }()
35 )
36
37 type bridgeSpanContext struct {
38 bag baggage.Baggage
39 trace.SpanContext
40 }
41
42 var _ ot.SpanContext = &bridgeSpanContext{}
43
44 func newBridgeSpanContext(otelSpanContext trace.SpanContext, parentOtSpanContext ot.SpanContext) *bridgeSpanContext {
45 bCtx := &bridgeSpanContext{
46 bag: baggage.Baggage{},
47 SpanContext: otelSpanContext,
48 }
49 if parentOtSpanContext != nil {
50 parentOtSpanContext.ForeachBaggageItem(func(key, value string) bool {
51 bCtx.setBaggageItem(key, value)
52 return true
53 })
54 }
55 return bCtx
56 }
57
58 func (c *bridgeSpanContext) ForeachBaggageItem(handler func(k, v string) bool) {
59 for _, m := range c.bag.Members() {
60 if !handler(m.Key(), m.Value()) {
61 return
62 }
63 }
64 }
65
66 func (c *bridgeSpanContext) setBaggageItem(restrictedKey, value string) {
67 m, err := baggage.NewMemberRaw(restrictedKey, value)
68 if err != nil {
69 return
70 }
71 c.bag, _ = c.bag.SetMember(m)
72 }
73
74 func (c *bridgeSpanContext) baggageItem(restrictedKey string) baggage.Member {
75 return c.bag.Member(restrictedKey)
76 }
77
78 type bridgeSpan struct {
79 otelSpan trace.Span
80 ctx *bridgeSpanContext
81 tracer *BridgeTracer
82 skipDeferHook bool
83 extraBaggageItems map[string]string
84 }
85
86 var _ ot.Span = &bridgeSpan{}
87
88 func newBridgeSpan(otelSpan trace.Span, bridgeSC *bridgeSpanContext, tracer *BridgeTracer) *bridgeSpan {
89 return &bridgeSpan{
90 otelSpan: otelSpan,
91 ctx: bridgeSC,
92 tracer: tracer,
93 skipDeferHook: false,
94 extraBaggageItems: nil,
95 }
96 }
97
98 func (s *bridgeSpan) Finish() {
99 s.otelSpan.End()
100 }
101
102 func (s *bridgeSpan) FinishWithOptions(opts ot.FinishOptions) {
103 var otelOpts []trace.SpanEndOption
104
105 if !opts.FinishTime.IsZero() {
106 otelOpts = append(otelOpts, trace.WithTimestamp(opts.FinishTime))
107 }
108 for _, record := range opts.LogRecords {
109 s.logRecord(record)
110 }
111 for _, data := range opts.BulkLogData {
112 s.logRecord(data.ToLogRecord())
113 }
114 s.otelSpan.End(otelOpts...)
115 }
116
117 func (s *bridgeSpan) logRecord(record ot.LogRecord) {
118 s.otelSpan.AddEvent(
119 "",
120 trace.WithTimestamp(record.Timestamp),
121 trace.WithAttributes(otLogFieldsToOTelAttrs(record.Fields)...),
122 )
123 }
124
125 func (s *bridgeSpan) Context() ot.SpanContext {
126 return s.ctx
127 }
128
129 func (s *bridgeSpan) SetOperationName(operationName string) ot.Span {
130 s.otelSpan.SetName(operationName)
131 return s
132 }
133
134 // SetTag method adds a tag to the span.
135 //
136 // Note about the following value conversions:
137 // - int -> int64
138 // - uint -> string
139 // - int32 -> int64
140 // - uint32 -> int64
141 // - uint64 -> string
142 // - float32 -> float64
143 func (s *bridgeSpan) SetTag(key string, value any) ot.Span {
144 switch key {
145 case string(otext.SpanKind):
146 // TODO: Should we ignore it?
147 case string(otext.Error):
148 if b, ok := value.(bool); ok && b {
149 s.otelSpan.SetStatus(codes.Error, "")
150 }
151 default:
152 s.otelSpan.SetAttributes(otTagToOTelAttr(key, value))
153 }
154 return s
155 }
156
157 func (s *bridgeSpan) LogFields(fields ...otlog.Field) {
158 s.otelSpan.AddEvent(
159 "",
160 trace.WithAttributes(otLogFieldsToOTelAttrs(fields)...),
161 )
162 }
163
164 type bridgeFieldEncoder struct {
165 pairs []attribute.KeyValue
166 }
167
168 var _ otlog.Encoder = &bridgeFieldEncoder{}
169
170 func (e *bridgeFieldEncoder) EmitString(key, value string) {
171 e.emitCommon(key, value)
172 }
173
174 func (e *bridgeFieldEncoder) EmitBool(key string, value bool) {
175 e.emitCommon(key, value)
176 }
177
178 func (e *bridgeFieldEncoder) EmitInt(key string, value int) {
179 e.emitCommon(key, value)
180 }
181
182 func (e *bridgeFieldEncoder) EmitInt32(key string, value int32) {
183 e.emitCommon(key, value)
184 }
185
186 func (e *bridgeFieldEncoder) EmitInt64(key string, value int64) {
187 e.emitCommon(key, value)
188 }
189
190 func (e *bridgeFieldEncoder) EmitUint32(key string, value uint32) {
191 e.emitCommon(key, value)
192 }
193
194 func (e *bridgeFieldEncoder) EmitUint64(key string, value uint64) {
195 e.emitCommon(key, value)
196 }
197
198 func (e *bridgeFieldEncoder) EmitFloat32(key string, value float32) {
199 e.emitCommon(key, value)
200 }
201
202 func (e *bridgeFieldEncoder) EmitFloat64(key string, value float64) {
203 e.emitCommon(key, value)
204 }
205
206 func (e *bridgeFieldEncoder) EmitObject(key string, value any) {
207 e.emitCommon(key, value)
208 }
209
210 func (e *bridgeFieldEncoder) EmitLazyLogger(value otlog.LazyLogger) {
211 value(e)
212 }
213
214 func (e *bridgeFieldEncoder) emitCommon(key string, value any) {
215 e.pairs = append(e.pairs, otTagToOTelAttr(key, value))
216 }
217
218 func otLogFieldsToOTelAttrs(fields []otlog.Field) []attribute.KeyValue {
219 encoder := &bridgeFieldEncoder{}
220 for _, field := range fields {
221 field.Marshal(encoder)
222 }
223 return encoder.pairs
224 }
225
226 func (s *bridgeSpan) LogKV(alternatingKeyValues ...any) {
227 fields, err := otlog.InterleavedKVToFields(alternatingKeyValues...)
228 if err != nil {
229 return
230 }
231 s.LogFields(fields...)
232 }
233
234 func (s *bridgeSpan) SetBaggageItem(restrictedKey, value string) ot.Span {
235 s.updateOTelContext(restrictedKey, value)
236 s.setBaggageItemOnly(restrictedKey, value)
237 return s
238 }
239
240 func (s *bridgeSpan) setBaggageItemOnly(restrictedKey, value string) {
241 s.ctx.setBaggageItem(restrictedKey, value)
242 }
243
244 func (s *bridgeSpan) updateOTelContext(restrictedKey, value string) {
245 if s.extraBaggageItems == nil {
246 s.extraBaggageItems = make(map[string]string)
247 }
248 s.extraBaggageItems[restrictedKey] = value
249 }
250
251 func (s *bridgeSpan) BaggageItem(restrictedKey string) string {
252 return s.ctx.baggageItem(restrictedKey).Value()
253 }
254
255 func (s *bridgeSpan) Tracer() ot.Tracer {
256 return s.tracer
257 }
258
259 func (s *bridgeSpan) LogEvent(event string) {
260 s.LogEventWithPayload(event, nil)
261 }
262
263 func (s *bridgeSpan) LogEventWithPayload(event string, payload any) {
264 data := ot.LogData{
265 Event: event,
266 Payload: payload,
267 }
268 s.Log(data)
269 }
270
271 func (s *bridgeSpan) Log(data ot.LogData) {
272 record := data.ToLogRecord()
273 s.LogFields(record.Fields...)
274 }
275
276 type bridgeSetTracer struct {
277 isSet bool
278 otelTracer trace.Tracer
279
280 warningHandler BridgeWarningHandler
281 warnOnce sync.Once
282 }
283
284 func (s *bridgeSetTracer) tracer() trace.Tracer {
285 if !s.isSet {
286 s.warnOnce.Do(func() {
287 s.warningHandler(
288 "The OpenTelemetry tracer is not set, default no-op tracer is used! Call SetOpenTelemetryTracer to set it up.\n",
289 )
290 })
291 }
292 return s.otelTracer
293 }
294
295 // BridgeWarningHandler is a type of handler that receives warnings
296 // from the BridgeTracer.
297 type BridgeWarningHandler func(msg string)
298
299 // BridgeTracer is an implementation of the OpenTracing tracer, which
300 // translates the calls to the OpenTracing API into OpenTelemetry
301 // counterparts and calls the underlying OpenTelemetry tracer.
302 type BridgeTracer struct {
303 setTracer bridgeSetTracer
304
305 warningHandler BridgeWarningHandler
306 warnOnce sync.Once
307
308 propagator propagation.TextMapPropagator
309 }
310
311 var (
312 _ ot.Tracer = &BridgeTracer{}
313 _ ot.TracerContextWithSpanExtension = &BridgeTracer{}
314 )
315
316 // NewBridgeTracer creates a new BridgeTracer. The new tracer forwards
317 // the calls to the OpenTelemetry Noop tracer, so it should be
318 // overridden with the SetOpenTelemetryTracer function. The warnings
319 // handler does nothing by default, so to override it use the
320 // SetWarningHandler function.
321 func NewBridgeTracer() *BridgeTracer {
322 return &BridgeTracer{
323 setTracer: bridgeSetTracer{
324 warningHandler: func(string) {},
325 otelTracer: noopTracer,
326 },
327 warningHandler: func(string) {},
328 propagator: nil,
329 }
330 }
331
332 // SetWarningHandler overrides the warning handler.
333 func (t *BridgeTracer) SetWarningHandler(handler BridgeWarningHandler) {
334 t.setTracer.warningHandler = handler
335 t.warningHandler = handler
336 }
337
338 // SetOpenTelemetryTracer overrides the underlying OpenTelemetry
339 // tracer. The passed tracer should know how to operate in the
340 // environment that uses OpenTracing API.
341 func (t *BridgeTracer) SetOpenTelemetryTracer(tracer trace.Tracer) {
342 t.setTracer.otelTracer = tracer
343 t.setTracer.isSet = true
344 }
345
346 // SetTextMapPropagator sets propagator as the TextMapPropagator to use by the
347 // BridgeTracer.
348 func (t *BridgeTracer) SetTextMapPropagator(propagator propagation.TextMapPropagator) {
349 t.propagator = propagator
350 }
351
352 // NewHookedContext returns a Context that has ctx as its parent and is
353 // wrapped to handle baggage set and get operations.
354 func (t *BridgeTracer) NewHookedContext(ctx context.Context) context.Context {
355 ctx = iBaggage.ContextWithSetHook(ctx, t.baggageSetHook)
356 ctx = iBaggage.ContextWithGetHook(ctx, t.baggageGetHook)
357 return ctx
358 }
359
360 func (t *BridgeTracer) baggageSetHook(ctx context.Context, list iBaggage.List) context.Context {
361 span := ot.SpanFromContext(ctx)
362 if span == nil {
363 t.warningHandler("No active OpenTracing span, can not propagate the baggage items from OpenTelemetry context\n")
364 return ctx
365 }
366 bSpan, ok := span.(*bridgeSpan)
367 if !ok {
368 t.warningHandler(
369 "Encountered a foreign OpenTracing span, will not propagate the baggage items from OpenTelemetry context\n",
370 )
371 return ctx
372 }
373 for k, v := range list {
374 bSpan.setBaggageItemOnly(k, v.Value)
375 }
376 return ctx
377 }
378
379 func (t *BridgeTracer) baggageGetHook(ctx context.Context, list iBaggage.List) iBaggage.List {
380 span := ot.SpanFromContext(ctx)
381 if span == nil {
382 t.warningHandler(
383 "No active OpenTracing span, can not propagate the baggage items from OpenTracing span context\n",
384 )
385 return list
386 }
387 bSpan, ok := span.(*bridgeSpan)
388 if !ok {
389 t.warningHandler(
390 "Encountered a foreign OpenTracing span, will not propagate the baggage items from OpenTracing span context\n",
391 )
392 return list
393 }
394 items := bSpan.extraBaggageItems
395 if len(items) == 0 {
396 return list
397 }
398
399 // Privilege of using the internal representation of Baggage here comes
400 // with the responsibility to make sure we maintain its immutability. We
401 // need to return a copy to ensure this.
402
403 merged := make(iBaggage.List, len(list))
404 maps.Copy(merged, list)
405
406 for k, v := range items {
407 // Overwrite according to OpenTelemetry specification.
408 merged[k] = iBaggage.Item{Value: v}
409 }
410
411 return merged
412 }
413
414 // StartSpan is a part of the implementation of the OpenTracing Tracer
415 // interface.
416 func (t *BridgeTracer) StartSpan(operationName string, opts ...ot.StartSpanOption) ot.Span {
417 sso := ot.StartSpanOptions{}
418 for _, opt := range opts {
419 opt.Apply(&sso)
420 }
421 parentBridgeSC, links := otSpanReferencesToParentAndLinks(sso.References)
422 attributes, kind, hadTrueErrorTag := otTagsToOTelAttributesKindAndError(sso.Tags)
423 checkCtx := migration.WithDeferredSetup(context.Background())
424 if parentBridgeSC != nil {
425 checkCtx = trace.ContextWithRemoteSpanContext(checkCtx, parentBridgeSC.SpanContext)
426 }
427 checkCtx2, otelSpan := t.setTracer.tracer().Start(
428 checkCtx,
429 operationName,
430 trace.WithAttributes(attributes...),
431 trace.WithTimestamp(sso.StartTime),
432 trace.WithLinks(links...),
433 trace.WithSpanKind(kind),
434 )
435 if ot.SpanFromContext(checkCtx2) != nil {
436 t.warnOnce.Do(func() {
437 t.warningHandler(
438 "SDK should have deferred the context setup, see the documentation of go.opentelemetry.io/otel/bridge/opentracing/migration\n",
439 )
440 })
441 }
442 if hadTrueErrorTag {
443 otelSpan.SetStatus(codes.Error, "")
444 }
445 // One does not simply pass a concrete pointer to function
446 // that takes some interface. In case of passing nil concrete
447 // pointer, we get an interface with non-nil type (because the
448 // pointer type is known) and a nil value. Which means
449 // interface is not nil, but calling some interface function
450 // on it will most likely result in nil pointer dereference.
451 var otSpanContext ot.SpanContext
452 if parentBridgeSC != nil {
453 otSpanContext = parentBridgeSC
454 }
455 sctx := newBridgeSpanContext(otelSpan.SpanContext(), otSpanContext)
456 span := newBridgeSpan(otelSpan, sctx, t)
457
458 return span
459 }
460
461 // ContextWithBridgeSpan sets up the context with the passed
462 // OpenTelemetry span as the active OpenTracing span.
463 //
464 // This function should be used by the OpenTelemetry tracers that want
465 // to be aware how to operate in the environment using OpenTracing
466 // API.
467 func (t *BridgeTracer) ContextWithBridgeSpan(ctx context.Context, span trace.Span) context.Context {
468 var otSpanContext ot.SpanContext
469 if parentSpan := ot.SpanFromContext(ctx); parentSpan != nil {
470 otSpanContext = parentSpan.Context()
471 }
472 bCtx := newBridgeSpanContext(span.SpanContext(), otSpanContext)
473 bSpan := newBridgeSpan(span, bCtx, t)
474 bSpan.skipDeferHook = true
475 return ot.ContextWithSpan(ctx, bSpan)
476 }
477
478 // ContextWithSpanHook is an implementation of the OpenTracing tracer
479 // extension interface. It will call the DeferredContextSetupHook
480 // function on the tracer if it implements the
481 // DeferredContextSetupTracerExtension interface.
482 func (t *BridgeTracer) ContextWithSpanHook(ctx context.Context, span ot.Span) context.Context {
483 bSpan, ok := span.(*bridgeSpan)
484 if !ok {
485 t.warningHandler(
486 "Encountered a foreign OpenTracing span, will not run a possible deferred context setup hook\n",
487 )
488 return ctx
489 }
490 if bSpan.skipDeferHook {
491 return ctx
492 }
493 if tracerWithExtension, ok := bSpan.tracer.setTracer.tracer().(migration.DeferredContextSetupTracerExtension); ok {
494 ctx = tracerWithExtension.DeferredContextSetupHook(ctx, bSpan.otelSpan)
495 }
496 return ctx
497 }
498
499 func otTagsToOTelAttributesKindAndError(tags map[string]any) ([]attribute.KeyValue, trace.SpanKind, bool) {
500 kind := trace.SpanKindInternal
501 err := false
502 var pairs []attribute.KeyValue
503 for k, v := range tags {
504 switch k {
505 case string(otext.SpanKind):
506 sk := v
507 if s, ok := v.(string); ok {
508 sk = otext.SpanKindEnum(strings.ToLower(s))
509 }
510 switch sk {
511 case otext.SpanKindRPCClientEnum:
512 kind = trace.SpanKindClient
513 case otext.SpanKindRPCServerEnum:
514 kind = trace.SpanKindServer
515 case otext.SpanKindProducerEnum:
516 kind = trace.SpanKindProducer
517 case otext.SpanKindConsumerEnum:
518 kind = trace.SpanKindConsumer
519 }
520 case string(otext.Error):
521 if b, ok := v.(bool); ok && b {
522 err = true
523 }
524 default:
525 pairs = append(pairs, otTagToOTelAttr(k, v))
526 }
527 }
528 return pairs, kind, err
529 }
530
531 // otTagToOTelAttr converts given key-value into attribute.KeyValue.
532 // Note that some conversions are not obvious:
533 // - int -> int64
534 // - uint -> string
535 // - int32 -> int64
536 // - uint32 -> int64
537 // - uint64 -> string
538 // - float32 -> float64
539 func otTagToOTelAttr(k string, v any) attribute.KeyValue {
540 key := otTagToOTelAttrKey(k)
541 switch val := v.(type) {
542 case bool:
543 return key.Bool(val)
544 case int64:
545 return key.Int64(val)
546 case uint64:
547 return key.String(strconv.FormatUint(val, 10))
548 case float64:
549 return key.Float64(val)
550 case int8:
551 return key.Int64(int64(val))
552 case uint8:
553 return key.Int64(int64(val))
554 case int16:
555 return key.Int64(int64(val))
556 case uint16:
557 return key.Int64(int64(val))
558 case int32:
559 return key.Int64(int64(val))
560 case uint32:
561 return key.Int64(int64(val))
562 case float32:
563 return key.Float64(float64(val))
564 case int:
565 return key.Int(val)
566 case uint:
567 return key.String(strconv.FormatUint(uint64(val), 10))
568 case string:
569 return key.String(val)
570 default:
571 return key.String(fmt.Sprint(v))
572 }
573 }
574
575 func otTagToOTelAttrKey(k string) attribute.Key {
576 return attribute.Key(k)
577 }
578
579 func otSpanReferencesToParentAndLinks(references []ot.SpanReference) (*bridgeSpanContext, []trace.Link) {
580 var (
581 parent *bridgeSpanContext
582 links []trace.Link
583 )
584 for _, reference := range references {
585 bridgeSC, ok := reference.ReferencedContext.(*bridgeSpanContext)
586 if !ok {
587 // We ignore foreign ot span contexts,
588 // sorry. We have no way of getting any
589 // TraceID and SpanID out of it for form a
590 // OTel SpanContext for OTel Link. And
591 // we can't make it a parent - it also needs a
592 // valid OTel SpanContext.
593 continue
594 }
595 if parent != nil {
596 links = append(links, otSpanReferenceToOTelLink(bridgeSC, reference.Type))
597 } else {
598 if reference.Type == ot.ChildOfRef {
599 parent = bridgeSC
600 } else {
601 links = append(links, otSpanReferenceToOTelLink(bridgeSC, reference.Type))
602 }
603 }
604 }
605 return parent, links
606 }
607
608 func otSpanReferenceToOTelLink(bridgeSC *bridgeSpanContext, refType ot.SpanReferenceType) trace.Link {
609 return trace.Link{
610 SpanContext: bridgeSC.SpanContext,
611 Attributes: otSpanReferenceTypeToOTelLinkAttributes(refType),
612 }
613 }
614
615 func otSpanReferenceTypeToOTelLinkAttributes(refType ot.SpanReferenceType) []attribute.KeyValue {
616 return []attribute.KeyValue{
617 attribute.String("ot-span-reference-type", otSpanReferenceTypeToString(refType)),
618 }
619 }
620
621 func otSpanReferenceTypeToString(refType ot.SpanReferenceType) string {
622 switch refType {
623 case ot.ChildOfRef:
624 // "extra", because first child-of reference is used
625 // as a parent, so this function isn't even called for
626 // it.
627 return "extra-child-of"
628 case ot.FollowsFromRef:
629 return "follows-from-ref"
630 default:
631 return fmt.Sprintf("unknown-%d", int(refType))
632 }
633 }
634
635 // fakeSpan is just a holder of span context, nothing more. It's for
636 // propagators, so they can get the span context from Go context.
637 type fakeSpan struct {
638 trace.Span
639 sc trace.SpanContext
640 }
641
642 func (s fakeSpan) SpanContext() trace.SpanContext {
643 return s.sc
644 }
645
646 // Inject is a part of the implementation of the OpenTracing Tracer
647 // interface.
648 //
649 // Currently only the HTTPHeaders and TextMap formats are supported.
650 func (t *BridgeTracer) Inject(sm ot.SpanContext, format, carrier any) error {
651 bridgeSC, ok := sm.(*bridgeSpanContext)
652 if !ok {
653 return ot.ErrInvalidSpanContext
654 }
655 if !bridgeSC.IsValid() {
656 return ot.ErrInvalidSpanContext
657 }
658
659 builtinFormat, ok := format.(ot.BuiltinFormat)
660 if !ok {
661 return ot.ErrUnsupportedFormat
662 }
663
664 var textCarrier propagation.TextMapCarrier
665 var err error
666
667 switch builtinFormat {
668 case ot.HTTPHeaders:
669 if hhcarrier, ok := carrier.(ot.HTTPHeadersCarrier); ok {
670 textCarrier = propagation.HeaderCarrier(hhcarrier)
671 } else {
672 textCarrier, err = newTextMapWrapperForInject(carrier)
673 }
674 case ot.TextMap:
675 if textCarrier, ok = carrier.(propagation.TextMapCarrier); !ok {
676 textCarrier, err = newTextMapWrapperForInject(carrier)
677 }
678 default:
679 err = ot.ErrUnsupportedFormat
680 }
681 if err != nil {
682 return err
683 }
684
685 fs := fakeSpan{
686 Span: noopSpan,
687 sc: bridgeSC.SpanContext,
688 }
689 ctx := trace.ContextWithSpan(context.Background(), fs)
690 ctx = baggage.ContextWithBaggage(ctx, bridgeSC.bag)
691 t.getPropagator().Inject(ctx, textCarrier)
692 return nil
693 }
694
695 // Extract is a part of the implementation of the OpenTracing Tracer
696 // interface.
697 //
698 // Currently only the HTTPHeaders and TextMap formats are supported.
699 func (t *BridgeTracer) Extract(format, carrier any) (ot.SpanContext, error) {
700 builtinFormat, ok := format.(ot.BuiltinFormat)
701 if !ok {
702 return nil, ot.ErrUnsupportedFormat
703 }
704
705 var textCarrier propagation.TextMapCarrier
706 var err error
707
708 switch builtinFormat {
709 case ot.HTTPHeaders:
710 if hhcarrier, ok := carrier.(ot.HTTPHeadersCarrier); ok {
711 textCarrier = propagation.HeaderCarrier(hhcarrier)
712 } else {
713 textCarrier, err = newTextMapWrapperForExtract(carrier)
714 }
715 case ot.TextMap:
716 if textCarrier, ok = carrier.(propagation.TextMapCarrier); !ok {
717 textCarrier, err = newTextMapWrapperForExtract(carrier)
718 }
719 default:
720 err = ot.ErrUnsupportedFormat
721 }
722 if err != nil {
723 return nil, err
724 }
725
726 ctx := t.getPropagator().Extract(context.Background(), textCarrier)
727 bag := baggage.FromContext(ctx)
728 bridgeSC := &bridgeSpanContext{
729 bag: bag,
730 SpanContext: trace.SpanContextFromContext(ctx),
731 }
732 if !bridgeSC.IsValid() {
733 return nil, ot.ErrSpanContextNotFound
734 }
735 return bridgeSC, nil
736 }
737
738 func (t *BridgeTracer) getPropagator() propagation.TextMapPropagator {
739 if t.propagator != nil {
740 return t.propagator
741 }
742 return otel.GetTextMapPropagator()
743 }
744
745 // textMapWrapper Provides operating.TextMapWriter and operating.TextMapReader to
746 // propagation.TextMapCarrier compatibility.
747 // Usually, Inject method will only use the write-related interface.
748 // Extract method will only use the reade-related interface.
749 // To avoid panic,
750 // when the carrier implements only one of the interfaces,
751 // it provides a default implementation of the other interface (textMapWriter and textMapReader).
752 type textMapWrapper struct {
753 ot.TextMapWriter
754 ot.TextMapReader
755 readerMap map[string]string
756 }
757
758 func (t *textMapWrapper) Get(key string) string {
759 if t.readerMap == nil {
760 t.loadMap()
761 }
762
763 return t.readerMap[key]
764 }
765
766 func (t *textMapWrapper) Set(key, value string) {
767 t.TextMapWriter.Set(key, value)
768 }
769
770 func (t *textMapWrapper) Keys() []string {
771 if t.readerMap == nil {
772 t.loadMap()
773 }
774
775 str := make([]string, 0, len(t.readerMap))
776 for key := range t.readerMap {
777 str = append(str, key)
778 }
779
780 return str
781 }
782
783 func (t *textMapWrapper) loadMap() {
784 t.readerMap = make(map[string]string)
785
786 _ = t.ForeachKey(func(key, val string) error {
787 t.readerMap[key] = val
788
789 return nil
790 })
791 }
792
793 func newTextMapWrapperForExtract(carrier any) (*textMapWrapper, error) {
794 t := &textMapWrapper{}
795
796 reader, ok := carrier.(ot.TextMapReader)
797 if !ok {
798 return nil, ot.ErrInvalidCarrier
799 }
800
801 t.TextMapReader = reader
802
803 writer, ok := carrier.(ot.TextMapWriter)
804 if ok {
805 t.TextMapWriter = writer
806 } else {
807 t.TextMapWriter = &textMapWriter{}
808 }
809
810 return t, nil
811 }
812
813 func newTextMapWrapperForInject(carrier any) (*textMapWrapper, error) {
814 t := &textMapWrapper{}
815
816 writer, ok := carrier.(ot.TextMapWriter)
817 if !ok {
818 return nil, ot.ErrInvalidCarrier
819 }
820
821 t.TextMapWriter = writer
822
823 reader, ok := carrier.(ot.TextMapReader)
824 if ok {
825 t.TextMapReader = reader
826 } else {
827 t.TextMapReader = &textMapReader{}
828 }
829
830 return t, nil
831 }
832
833 type textMapWriter struct{}
834
835 func (*textMapWriter) Set(string, string) {
836 // maybe print a warning log.
837 }
838
839 type textMapReader struct{}
840
841 func (*textMapReader) ForeachKey(func(string, string) error) error {
842 return nil // maybe print a warning log.
843 }