From 47335f6eaf27b85fb86df6b39f70d89757ed9da3 Mon Sep 17 00:00:00 2001 From: tttoad Date: Wed, 18 May 2022 11:44:37 +0800 Subject: [PATCH 01/13] feat: support TextMap --- bridge/opentracing/bridge.go | 156 ++++++++++++++++++++++++++++++++--- 1 file changed, 144 insertions(+), 12 deletions(-) diff --git a/bridge/opentracing/bridge.go b/bridge/opentracing/bridge.go index 6b0e102e331..7a4a3737944 100644 --- a/bridge/opentracing/bridge.go +++ b/bridge/opentracing/bridge.go @@ -25,6 +25,7 @@ import ( otext "github.com/opentracing/opentracing-go/ext" otlog "github.com/opentracing/opentracing-go/log" + "github.com/opentracing/opentracing-go" "go.opentelemetry.io/otel" "go.opentelemetry.io/otel/attribute" "go.opentelemetry.io/otel/baggage" @@ -639,21 +640,40 @@ func (t *BridgeTracer) Inject(sm ot.SpanContext, format interface{}, carrier int if !bridgeSC.otelSpanContext.IsValid() { return ot.ErrInvalidSpanContext } - if builtinFormat, ok := format.(ot.BuiltinFormat); !ok || builtinFormat != ot.HTTPHeaders { + + builtinFormat, ok := format.(ot.BuiltinFormat) + if !ok { return ot.ErrUnsupportedFormat } - hhcarrier, ok := carrier.(ot.HTTPHeadersCarrier) - if !ok { - return ot.ErrInvalidCarrier + + var textCarrier propagation.TextMapCarrier + + switch builtinFormat { + case ot.HTTPHeaders: + hhcarrier, ok := carrier.(ot.HTTPHeadersCarrier) + if !ok { + return ot.ErrInvalidCarrier + } + + textCarrier = propagation.HeaderCarrier(hhcarrier) + case ot.TextMap: + if textCarrier, ok = carrier.(propagation.TextMapCarrier); !ok { + var err error + if textCarrier, err = NewTextMapWrapperForInject(carrier); err != nil { + return err + } + } + default: + return ot.ErrUnsupportedFormat } - header := http.Header(hhcarrier) + fs := fakeSpan{ Span: noopSpan, sc: bridgeSC.otelSpanContext, } ctx := trace.ContextWithSpan(context.Background(), fs) ctx = baggage.ContextWithBaggage(ctx, bridgeSC.bag) - t.getPropagator().Inject(ctx, propagation.HeaderCarrier(header)) + t.getPropagator().Inject(ctx, textCarrier) return nil } @@ -662,15 +682,33 @@ func (t *BridgeTracer) Inject(sm ot.SpanContext, format interface{}, carrier int // // Currently only the HTTPHeaders format is supported. func (t *BridgeTracer) Extract(format interface{}, carrier interface{}) (ot.SpanContext, error) { - if builtinFormat, ok := format.(ot.BuiltinFormat); !ok || builtinFormat != ot.HTTPHeaders { + builtinFormat, ok := format.(ot.BuiltinFormat) + if !ok { return nil, ot.ErrUnsupportedFormat } - hhcarrier, ok := carrier.(ot.HTTPHeadersCarrier) - if !ok { - return nil, ot.ErrInvalidCarrier + + var textCarrier propagation.TextMapCarrier + + switch builtinFormat { + case ot.HTTPHeaders: + hhcarrier, ok := carrier.(ot.HTTPHeadersCarrier) + if !ok { + return nil, ot.ErrInvalidCarrier + } + + textCarrier = propagation.HeaderCarrier(hhcarrier) + case ot.TextMap: + if textCarrier, ok = carrier.(propagation.TextMapCarrier); !ok { + var err error + if textCarrier, err = NewTextMapWrapperForInject(carrier); err != nil { + return nil, err + } + } + default: + return nil, ot.ErrUnsupportedFormat } - header := http.Header(hhcarrier) - ctx := t.getPropagator().Extract(context.Background(), propagation.HeaderCarrier(header)) + + ctx := t.getPropagator().Extract(context.Background(), textCarrier) baggage := baggage.FromContext(ctx) bridgeSC := &bridgeSpanContext{ bag: baggage, @@ -688,3 +726,97 @@ func (t *BridgeTracer) getPropagator() propagation.TextMapPropagator { } return otel.GetTextMapPropagator() } + +type textMapWrapper struct { + opentracing.TextMapWriter + opentracing.TextMapReader + readerMap map[string]string +} + +func (t *textMapWrapper) Get(key string) string { + if t.readerMap == nil { + t.loadMap() + } + + return t.readerMap[key] +} + +func (t *textMapWrapper) Set(key string, value string) { + t.TextMapWriter.Set(key, value) +} + +func (t *textMapWrapper) Keys() []string { + if t.readerMap == nil { + t.loadMap() + } + + str := make([]string, 0, len(t.readerMap)) + for key := range t.readerMap { + str = append(str, key) + } + + return str +} + +func (t *textMapWrapper) loadMap() { + t.readerMap = make(map[string]string) + + _ = t.ForeachKey(func(key, val string) error { + t.readerMap[key] = val + return nil + }) +} + +func NewTextMapWrapperForExtract(carrier interface{}) (*textMapWrapper, error) { + t := &textMapWrapper{} + + reader, ok := carrier.(opentracing.TextMapReader) + if !ok { + return nil, ot.ErrInvalidCarrier + } + + t.TextMapReader = reader + + writer, ok := carrier.(opentracing.TextMapWriter) + if ok { + t.TextMapWriter = writer + } else { + t.TextMapWriter = &textMapWriter{} + } + + return t, nil +} + +func NewTextMapWrapperForInject(carrier interface{}) (*textMapWrapper, error) { + t := &textMapWrapper{} + + writer, ok := carrier.(opentracing.TextMapWriter) + if !ok { + return nil, ot.ErrInvalidCarrier + } + + t.TextMapWriter = writer + + reader, ok := carrier.(opentracing.TextMapReader) + if ok { + t.TextMapReader = reader + } else { + t.TextMapReader = &textMapReader{} + } + + return t, nil +} + +type textMapWriter struct { +} + +func (t *textMapWriter) Set(key string, value string) { + return // maybe print a warning log +} + +type textMapReader struct { +} + +func (t *textMapReader) ForeachKey(handler func(key, val string) error) error { + return nil // maybe print a warning log +} From ba149767ef1c0435b8986a1630efc450de872359 Mon Sep 17 00:00:00 2001 From: tttoad Date: Wed, 18 May 2022 14:18:34 +0800 Subject: [PATCH 02/13] doc: add comment --- bridge/opentracing/bridge.go | 19 +++++++++++++------ 1 file changed, 13 insertions(+), 6 deletions(-) diff --git a/bridge/opentracing/bridge.go b/bridge/opentracing/bridge.go index 7a4a3737944..de7def9e863 100644 --- a/bridge/opentracing/bridge.go +++ b/bridge/opentracing/bridge.go @@ -631,7 +631,7 @@ func (s fakeSpan) SpanContext() trace.SpanContext { // Inject is a part of the implementation of the OpenTracing Tracer // interface. // -// Currently only the HTTPHeaders format is supported. +// Currently only the HTTPHeaders and TextMap format is supported. func (t *BridgeTracer) Inject(sm ot.SpanContext, format interface{}, carrier interface{}) error { bridgeSC, ok := sm.(*bridgeSpanContext) if !ok { @@ -659,7 +659,7 @@ func (t *BridgeTracer) Inject(sm ot.SpanContext, format interface{}, carrier int case ot.TextMap: if textCarrier, ok = carrier.(propagation.TextMapCarrier); !ok { var err error - if textCarrier, err = NewTextMapWrapperForInject(carrier); err != nil { + if textCarrier, err = newTextMapWrapperForInject(carrier); err != nil { return err } } @@ -680,7 +680,7 @@ func (t *BridgeTracer) Inject(sm ot.SpanContext, format interface{}, carrier int // Extract is a part of the implementation of the OpenTracing Tracer // interface. // -// Currently only the HTTPHeaders format is supported. +// Currently only the HTTPHeaders and TextMap format is supported. func (t *BridgeTracer) Extract(format interface{}, carrier interface{}) (ot.SpanContext, error) { builtinFormat, ok := format.(ot.BuiltinFormat) if !ok { @@ -700,7 +700,7 @@ func (t *BridgeTracer) Extract(format interface{}, carrier interface{}) (ot.Span case ot.TextMap: if textCarrier, ok = carrier.(propagation.TextMapCarrier); !ok { var err error - if textCarrier, err = NewTextMapWrapperForInject(carrier); err != nil { + if textCarrier, err = newTextMapWrapperForExtract(carrier); err != nil { return nil, err } } @@ -727,6 +727,13 @@ func (t *BridgeTracer) getPropagator() propagation.TextMapPropagator { return otel.GetTextMapPropagator() } +// textMapWrapper Provides opentracing.TextMapWriter and opentracing.TextMapReader to +// propagation.TextMapCarrier compatibility. +// Usually, Inject method will only use the write-related interface. +// Extract method will only use the reade-related interface. +// To avoid panic, +// when the carrier implements only one of the interfaces, +// it provides a default implementation of the other interface (textMapWriter and textMapReader). type textMapWrapper struct { opentracing.TextMapWriter opentracing.TextMapReader @@ -767,7 +774,7 @@ func (t *textMapWrapper) loadMap() { }) } -func NewTextMapWrapperForExtract(carrier interface{}) (*textMapWrapper, error) { +func newTextMapWrapperForExtract(carrier interface{}) (*textMapWrapper, error) { t := &textMapWrapper{} reader, ok := carrier.(opentracing.TextMapReader) @@ -787,7 +794,7 @@ func NewTextMapWrapperForExtract(carrier interface{}) (*textMapWrapper, error) { return t, nil } -func NewTextMapWrapperForInject(carrier interface{}) (*textMapWrapper, error) { +func newTextMapWrapperForInject(carrier interface{}) (*textMapWrapper, error) { t := &textMapWrapper{} writer, ok := carrier.(opentracing.TextMapWriter) From 89552268fc322dedc33e2ea5b36a7f0ee9b910c0 Mon Sep 17 00:00:00 2001 From: tttoad Date: Tue, 24 May 2022 22:52:48 +0800 Subject: [PATCH 03/13] test: support for ot.TextMap --- bridge/opentracing/bridge_test.go | 292 ++++++++++++++++++++++++++++++ bridge/opentracing/go.mod | 1 + bridge/opentracing/go.sum | 1 + 3 files changed, 294 insertions(+) create mode 100644 bridge/opentracing/bridge_test.go diff --git a/bridge/opentracing/bridge_test.go b/bridge/opentracing/bridge_test.go new file mode 100644 index 00000000000..2700d7e1515 --- /dev/null +++ b/bridge/opentracing/bridge_test.go @@ -0,0 +1,292 @@ +package opentracing + +import ( + "context" + "errors" + ot "github.com/opentracing/opentracing-go" + "github.com/stretchr/testify/assert" + "go.opentelemetry.io/otel/propagation" + "go.opentelemetry.io/otel/trace" + "strings" + "testing" +) + +type testOnlyTextMapReader struct { +} + +func newTestOnlyTextMapReader() *testOnlyTextMapReader { + return &testOnlyTextMapReader{} +} + +func (t *testOnlyTextMapReader) ForeachKey(handler func(key string, val string) error) error { + _ = handler("key1", "val1") + _ = handler("key2", "val2") + + return nil +} + +type testOnlyTextMapWriter struct { + m map[string]string +} + +func newTestOnlyTextMapWriter() *testOnlyTextMapWriter { + return &testOnlyTextMapWriter{m: map[string]string{}} +} + +func (t *testOnlyTextMapWriter) Set(key, val string) { + t.m[key] = val + + return +} + +type testTextMapReaderAndWriter struct { + *testOnlyTextMapReader + *testOnlyTextMapWriter +} + +func newTestTextMapReaderAndWriter() *testTextMapReaderAndWriter { + return &testTextMapReaderAndWriter{ + testOnlyTextMapReader: newTestOnlyTextMapReader(), + testOnlyTextMapWriter: newTestOnlyTextMapWriter(), + } +} + +func TestTextMapWrapper_New(t *testing.T) { + _, err := newTextMapWrapperForExtract(newTestOnlyTextMapReader()) + assert.NoError(t, err) + + _, err = newTextMapWrapperForExtract(newTestOnlyTextMapWriter()) + assert.True(t, errors.Is(err, ot.ErrInvalidCarrier)) + + _, err = newTextMapWrapperForExtract(newTestTextMapReaderAndWriter()) + assert.NoError(t, err) + + _, err = newTextMapWrapperForInject(newTestOnlyTextMapWriter()) + assert.NoError(t, err) + + _, err = newTextMapWrapperForInject(newTestOnlyTextMapReader()) + assert.True(t, errors.Is(err, ot.ErrInvalidCarrier)) + + _, err = newTextMapWrapperForInject(newTestTextMapReaderAndWriter()) + assert.NoError(t, err) +} + +func TestTextMapWrapper_action(t *testing.T) { + testExtractFunc := func(carrier propagation.TextMapCarrier) { + assert.Equal(t, carrier.Get("key1"), "val1") + assert.Equal(t, carrier.Get("key2"), "val2") + + str := carrier.Keys() + assert.Len(t, str, 2) + assert.Contains(t, str, "key1", "key2") + } + + testInjectFunc := func(carrier propagation.TextMapCarrier) { + carrier.Set("key1", "val1") + carrier.Set("key2", "val2") + + wrap, ok := carrier.(*textMapWrapper) + assert.True(t, ok) + + writer, ok := wrap.TextMapWriter.(*testOnlyTextMapWriter) + if ok { + assert.Contains(t, writer.m, "key1", "key2", "val1", "val2") + return + } + + writer2, ok := wrap.TextMapWriter.(*testTextMapReaderAndWriter) + assert.True(t, ok) + assert.Contains(t, writer2.m, "key1", "key2", "val1", "val2") + } + + onlyWriter, err := newTextMapWrapperForExtract(newTestOnlyTextMapReader()) + assert.NoError(t, err) + testExtractFunc(onlyWriter) + + onlyReader, err := newTextMapWrapperForInject(&testOnlyTextMapWriter{m: map[string]string{}}) + assert.NoError(t, err) + testInjectFunc(onlyReader) + + both, err := newTextMapWrapperForExtract(newTestTextMapReaderAndWriter()) + assert.NoError(t, err) + testExtractFunc(both) + + both, err = newTextMapWrapperForInject(newTestTextMapReaderAndWriter()) + assert.NoError(t, err) + testInjectFunc(both) +} + +var ( + testHeader = "test-trace-id" + traceID trace.TraceID = [16]byte{byte(10)} + spanID trace.SpanID = [8]byte{byte(11)} +) + +type testTextMapPropagator struct { +} + +func (t testTextMapPropagator) Inject(ctx context.Context, carrier propagation.TextMapCarrier) { + + carrier.Set(testHeader, strings.Join([]string{traceID.String(), spanID.String()}, ":")) +} + +func (t testTextMapPropagator) Extract(ctx context.Context, carrier propagation.TextMapCarrier) context.Context { + traces := carrier.Get(testHeader) + + str := strings.Split(traces, ":") + if len(str) != 2 { + return ctx + } + + var ( + traceID, _ = trace.TraceIDFromHex(str[0]) + spanID, _ = trace.SpanIDFromHex(str[1]) + sc = trace.NewSpanContext(trace.SpanContextConfig{ + TraceID: traceID, + SpanID: spanID, + }) + ) + + return trace.ContextWithRemoteSpanContext(ctx, sc) +} + +func (t testTextMapPropagator) Fields() []string { + return []string{"test"} +} + +// textMapCarrier Implemented propagation.TextMapCarrier interface +type textMapCarrier struct { + m map[string]string +} + +func newTextCarrier() *textMapCarrier { + return &textMapCarrier{m: map[string]string{}} +} + +func (t *textMapCarrier) Get(key string) string { + return t.m[key] +} + +func (t *textMapCarrier) Set(key string, value string) { + t.m[key] = value +} + +func (t *textMapCarrier) Keys() []string { + str := make([]string, 0, len(t.m)) + + for key := range t.m { + str = append(str, key) + } + + return str +} + +// opentracingTextMap Implemented opentracing.TextMapReader and opentracing.TextMapWriter interface +type opentracingTextMapCarrier struct { + m map[string]string +} + +func newOpentracingTextMapCarrier() *opentracingTextMapCarrier { + return &opentracingTextMapCarrier{m: map[string]string{}} +} + +func (o *opentracingTextMapCarrier) Set(key, val string) { + o.m[key] = val +} + +func (o *opentracingTextMapCarrier) ForeachKey(handler func(key string, val string) error) error { + for key, val := range o.m { + if err := handler(key, val); err != nil { + return err + } + } + + return nil +} + +// testTextMapReader only implemented opentracing.TextMapReader interface +type testTextMapReader struct { + m *map[string]string +} + +func newTestTextMapReader(m *map[string]string) *testTextMapReader { + return &testTextMapReader{m: m} +} + +func (t *testTextMapReader) ForeachKey(handler func(key string, val string) error) error { + for key, val := range *t.m { + if err := handler(key, val); err != nil { + return err + } + } + + return nil +} + +// testTextMapWriter only implemented opentracing.TextMapWriter interface +type testTextMapWriter struct { + m *map[string]string +} + +func newTestTextMapWriter(m *map[string]string) *testTextMapWriter { + return &testTextMapWriter{m: m} +} + +func (t *testTextMapWriter) Set(key, val string) { + (*t.m)[key] = val +} + +func TestBridgeTracer_ExtractAndInject(t *testing.T) { + bridge := NewBridgeTracer() + bridge.SetTextMapPropagator(new(testTextMapPropagator)) + + tmc := newTextCarrier() + otmc := newOpentracingTextMapCarrier() + shareMap := map[string]string{} + + testCases := []struct { + name string + carrierType ot.BuiltinFormat + extractCarrier interface{} + injectCarrier interface{} + }{ + { + name: "support for propagation.TextMapCarrier", + carrierType: ot.TextMap, + extractCarrier: tmc, + injectCarrier: tmc, + }, + { + name: "support for opentracing.TextMapReader and opentracing.TextMapWriter", + carrierType: ot.TextMap, + extractCarrier: otmc, + injectCarrier: otmc, + }, + { + name: "support for opentracing.TextMapReader and opentracing.TextMapWriter,non-same instance", + carrierType: ot.TextMap, + extractCarrier: newTestTextMapReader(&shareMap), + injectCarrier: newTestTextMapWriter(&shareMap), + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + err := bridge.Inject(newBridgeSpanContext(trace.NewSpanContext(trace.SpanContextConfig{ + TraceID: [16]byte{byte(1)}, + SpanID: [8]byte{byte(2)}, + }), nil), tc.carrierType, tc.injectCarrier) + assert.NoError(t, err) + + spanContext, err := bridge.Extract(tc.carrierType, tc.extractCarrier) + assert.NoError(t, err) + + bsc, ok := spanContext.(*bridgeSpanContext) + assert.True(t, ok) + + assert.Equal(t, spanID.String(), bsc.otelSpanContext.SpanID().String()) + assert.Equal(t, traceID.String(), bsc.otelSpanContext.TraceID().String()) + }) + } + +} diff --git a/bridge/opentracing/go.mod b/bridge/opentracing/go.mod index 5e362031cc9..df0cc2fb0ac 100644 --- a/bridge/opentracing/go.mod +++ b/bridge/opentracing/go.mod @@ -6,6 +6,7 @@ replace go.opentelemetry.io/otel => ../.. require ( github.com/opentracing/opentracing-go v1.2.0 + github.com/stretchr/testify v1.7.1 go.opentelemetry.io/otel v1.7.0 go.opentelemetry.io/otel/trace v1.7.0 ) diff --git a/bridge/opentracing/go.sum b/bridge/opentracing/go.sum index 5ec9e745497..e6ca6acfa16 100644 --- a/bridge/opentracing/go.sum +++ b/bridge/opentracing/go.sum @@ -15,6 +15,7 @@ github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+ github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= github.com/stretchr/testify v1.7.1 h1:5TQK59W5E3v0r2duFAb7P95B6hEeOyEnHRa8MjYSMTY= github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo= gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= From f76da80b48ac7ba7219a7424d1b6e2bbfe8b8a67 Mon Sep 17 00:00:00 2001 From: tttoad Date: Thu, 26 May 2022 01:48:46 +0800 Subject: [PATCH 04/13] Retrieve lost code due to merge --- bridge/opentracing/bridge.go | 101 +++++++++++++++++++++++++++++++++++ 1 file changed, 101 insertions(+) diff --git a/bridge/opentracing/bridge.go b/bridge/opentracing/bridge.go index 1dd02bb2f83..31b4d9f29ba 100644 --- a/bridge/opentracing/bridge.go +++ b/bridge/opentracing/bridge.go @@ -711,3 +711,104 @@ func (t *BridgeTracer) getPropagator() propagation.TextMapPropagator { } return otel.GetTextMapPropagator() } + +// textMapWrapper Provides opentracing.TextMapWriter and opentracing.TextMapReader to +// propagation.TextMapCarrier compatibility. +// Usually, Inject method will only use the write-related interface. +// Extract method will only use the reade-related interface. +// To avoid panic, +// when the carrier implements only one of the interfaces, +// it provides a default implementation of the other interface (textMapWriter and textMapReader). +type textMapWrapper struct { + opentracing.TextMapWriter + opentracing.TextMapReader + readerMap map[string]string +} + +func (t *textMapWrapper) Get(key string) string { + if t.readerMap == nil { + t.loadMap() + } + + return t.readerMap[key] +} + +func (t *textMapWrapper) Set(key string, value string) { + t.TextMapWriter.Set(key, value) +} + +func (t *textMapWrapper) Keys() []string { + if t.readerMap == nil { + t.loadMap() + } + + str := make([]string, 0, len(t.readerMap)) + for key := range t.readerMap { + str = append(str, key) + } + + return str +} + +func (t *textMapWrapper) loadMap() { + t.readerMap = make(map[string]string) + + _ = t.ForeachKey(func(key, val string) error { + t.readerMap[key] = val + return nil + }) +} + +func newTextMapWrapperForExtract(carrier interface{}) (*textMapWrapper, error) { + t := &textMapWrapper{} + + reader, ok := carrier.(opentracing.TextMapReader) + if !ok { + return nil, ot.ErrInvalidCarrier + } + + t.TextMapReader = reader + + writer, ok := carrier.(opentracing.TextMapWriter) + if ok { + t.TextMapWriter = writer + } else { + t.TextMapWriter = &textMapWriter{} + } + + return t, nil +} + +func newTextMapWrapperForInject(carrier interface{}) (*textMapWrapper, error) { + t := &textMapWrapper{} + + writer, ok := carrier.(opentracing.TextMapWriter) + if !ok { + return nil, ot.ErrInvalidCarrier + } + + t.TextMapWriter = writer + + reader, ok := carrier.(opentracing.TextMapReader) + if ok { + t.TextMapReader = reader + } else { + t.TextMapReader = &textMapReader{} + } + + return t, nil +} + +type textMapWriter struct { +} + +func (t *textMapWriter) Set(key string, value string) { + return // maybe print a warning log +} + +type textMapReader struct { +} + +func (t *textMapReader) ForeachKey(handler func(key, val string) error) error { + return nil // maybe print a warning log +} From d25e080ee5233f015d7c506bccd2cf4e1553b5f1 Mon Sep 17 00:00:00 2001 From: tttoad Date: Thu, 26 May 2022 02:07:49 +0800 Subject: [PATCH 05/13] fix: retrieve lost code due to merge. test: support for ot.HTTPHeaders --- bridge/opentracing/bridge.go | 35 ++++++++++++++++++++++------- bridge/opentracing/bridge_test.go | 37 +++++++++---------------------- 2 files changed, 38 insertions(+), 34 deletions(-) diff --git a/bridge/opentracing/bridge.go b/bridge/opentracing/bridge.go index 31b4d9f29ba..1f1650ec60a 100644 --- a/bridge/opentracing/bridge.go +++ b/bridge/opentracing/bridge.go @@ -635,7 +635,7 @@ func (s fakeSpan) SpanContext() trace.SpanContext { // Inject is a part of the implementation of the OpenTracing Tracer // interface. // -// Currently only the HTTPHeaders format is supported. +// Currently only the HTTPHeaders and TextMap format are supported. func (t *BridgeTracer) Inject(sm ot.SpanContext, format interface{}, carrier interface{}) error { bridgeSC, ok := sm.(*bridgeSpanContext) if !ok { @@ -644,28 +644,47 @@ func (t *BridgeTracer) Inject(sm ot.SpanContext, format interface{}, carrier int if !bridgeSC.otelSpanContext.IsValid() { return ot.ErrInvalidSpanContext } - if builtinFormat, ok := format.(ot.BuiltinFormat); !ok || builtinFormat != ot.HTTPHeaders { + + builtinFormat, ok := format.(ot.BuiltinFormat) + if !ok { return ot.ErrUnsupportedFormat } - hhcarrier, ok := carrier.(ot.HTTPHeadersCarrier) - if !ok { - return ot.ErrInvalidCarrier + + var textCarrier propagation.TextMapCarrier + + switch builtinFormat { + case ot.HTTPHeaders: + hhcarrier, ok := carrier.(ot.HTTPHeadersCarrier) + if !ok { + return ot.ErrInvalidCarrier + } + + textCarrier = propagation.HeaderCarrier(hhcarrier) + case ot.TextMap: + if textCarrier, ok = carrier.(propagation.TextMapCarrier); !ok { + var err error + if textCarrier, err = newTextMapWrapperForInject(carrier); err != nil { + return err + } + } + default: + return ot.ErrUnsupportedFormat } - header := http.Header(hhcarrier) + fs := fakeSpan{ Span: noopSpan, sc: bridgeSC.otelSpanContext, } ctx := trace.ContextWithSpan(context.Background(), fs) ctx = baggage.ContextWithBaggage(ctx, bridgeSC.bag) - t.getPropagator().Inject(ctx, propagation.HeaderCarrier(header)) + t.getPropagator().Inject(ctx, textCarrier) return nil } // Extract is a part of the implementation of the OpenTracing Tracer // interface. // -// Currently only the HTTPHeaders format is supported. +// Currently only the HTTPHeaders and TextMap format are supported. func (t *BridgeTracer) Extract(format interface{}, carrier interface{}) (ot.SpanContext, error) { builtinFormat, ok := format.(ot.BuiltinFormat) if !ok { diff --git a/bridge/opentracing/bridge_test.go b/bridge/opentracing/bridge_test.go index 2700d7e1515..aaef1f3ca50 100644 --- a/bridge/opentracing/bridge_test.go +++ b/bridge/opentracing/bridge_test.go @@ -7,6 +7,7 @@ import ( "github.com/stretchr/testify/assert" "go.opentelemetry.io/otel/propagation" "go.opentelemetry.io/otel/trace" + "net/http" "strings" "testing" ) @@ -181,29 +182,6 @@ func (t *textMapCarrier) Keys() []string { return str } -// opentracingTextMap Implemented opentracing.TextMapReader and opentracing.TextMapWriter interface -type opentracingTextMapCarrier struct { - m map[string]string -} - -func newOpentracingTextMapCarrier() *opentracingTextMapCarrier { - return &opentracingTextMapCarrier{m: map[string]string{}} -} - -func (o *opentracingTextMapCarrier) Set(key, val string) { - o.m[key] = val -} - -func (o *opentracingTextMapCarrier) ForeachKey(handler func(key string, val string) error) error { - for key, val := range o.m { - if err := handler(key, val); err != nil { - return err - } - } - - return nil -} - // testTextMapReader only implemented opentracing.TextMapReader interface type testTextMapReader struct { m *map[string]string @@ -241,8 +219,9 @@ func TestBridgeTracer_ExtractAndInject(t *testing.T) { bridge.SetTextMapPropagator(new(testTextMapPropagator)) tmc := newTextCarrier() - otmc := newOpentracingTextMapCarrier() shareMap := map[string]string{} + otTextMap := ot.TextMapCarrier{} + httpHeader := ot.HTTPHeadersCarrier(http.Header{}) testCases := []struct { name string @@ -259,8 +238,14 @@ func TestBridgeTracer_ExtractAndInject(t *testing.T) { { name: "support for opentracing.TextMapReader and opentracing.TextMapWriter", carrierType: ot.TextMap, - extractCarrier: otmc, - injectCarrier: otmc, + extractCarrier: otTextMap, + injectCarrier: otTextMap, + }, + { + name: "support for HTTPHeaders", + carrierType: ot.HTTPHeaders, + extractCarrier: httpHeader, + injectCarrier: httpHeader, }, { name: "support for opentracing.TextMapReader and opentracing.TextMapWriter,non-same instance", From 753565669955bdcc11fdf8b8700458a4685d4646 Mon Sep 17 00:00:00 2001 From: ttoad Date: Mon, 30 May 2022 22:09:14 +0800 Subject: [PATCH 06/13] go mod tidy --- bridge/opentracing/go.mod | 3 +++ 1 file changed, 3 insertions(+) diff --git a/bridge/opentracing/go.mod b/bridge/opentracing/go.mod index 305b8b47f4b..41f9dd76c1e 100644 --- a/bridge/opentracing/go.mod +++ b/bridge/opentracing/go.mod @@ -12,8 +12,11 @@ require ( ) require ( + github.com/davecgh/go-spew v1.1.0 // indirect github.com/go-logr/logr v1.2.3 // indirect github.com/go-logr/stdr v1.2.2 // indirect + github.com/pmezard/go-difflib v1.0.0 // indirect + gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c // indirect ) replace go.opentelemetry.io/otel/trace => ../../trace From 98789fe10e0ad145d9b5d4d18b8edac377352235 Mon Sep 17 00:00:00 2001 From: ttoad Date: Wed, 1 Jun 2022 04:39:45 +0800 Subject: [PATCH 07/13] Optimized code style, add changelog --- CHANGELOG.md | 1 + bridge/opentracing/bridge.go | 20 ++++++++++---------- bridge/opentracing/bridge_test.go | 18 ++++++++---------- 3 files changed, 19 insertions(+), 20 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index ca0334fbcea..fee58f36f46 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -27,6 +27,7 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm - Add the `go.opentelemetry.io/otel/semconv/v1.10.0` package. The package contains semantic conventions from the `v1.10.0` version of the OpenTelemetry specification. (#2842) - Added an in-memory exporter to metrictest to aid testing with a full SDK. (#2776) +- The bridge package supported extract and injection of opentracing.TextMap type. (#2911) ### Fixed diff --git a/bridge/opentracing/bridge.go b/bridge/opentracing/bridge.go index 1f1650ec60a..cb51f9a001b 100644 --- a/bridge/opentracing/bridge.go +++ b/bridge/opentracing/bridge.go @@ -25,7 +25,6 @@ import ( otext "github.com/opentracing/opentracing-go/ext" otlog "github.com/opentracing/opentracing-go/log" - "github.com/opentracing/opentracing-go" "go.opentelemetry.io/otel" "go.opentelemetry.io/otel/attribute" "go.opentelemetry.io/otel/baggage" @@ -731,7 +730,7 @@ func (t *BridgeTracer) getPropagator() propagation.TextMapPropagator { return otel.GetTextMapPropagator() } -// textMapWrapper Provides opentracing.TextMapWriter and opentracing.TextMapReader to +// textMapWrapper Provides ot.TextMapWriter and ot.TextMapReader to // propagation.TextMapCarrier compatibility. // Usually, Inject method will only use the write-related interface. // Extract method will only use the reade-related interface. @@ -739,8 +738,8 @@ func (t *BridgeTracer) getPropagator() propagation.TextMapPropagator { // when the carrier implements only one of the interfaces, // it provides a default implementation of the other interface (textMapWriter and textMapReader). type textMapWrapper struct { - opentracing.TextMapWriter - opentracing.TextMapReader + ot.TextMapWriter + ot.TextMapReader readerMap map[string]string } @@ -774,6 +773,7 @@ func (t *textMapWrapper) loadMap() { _ = t.ForeachKey(func(key, val string) error { t.readerMap[key] = val + return nil }) } @@ -781,14 +781,14 @@ func (t *textMapWrapper) loadMap() { func newTextMapWrapperForExtract(carrier interface{}) (*textMapWrapper, error) { t := &textMapWrapper{} - reader, ok := carrier.(opentracing.TextMapReader) + reader, ok := carrier.(ot.TextMapReader) if !ok { return nil, ot.ErrInvalidCarrier } t.TextMapReader = reader - writer, ok := carrier.(opentracing.TextMapWriter) + writer, ok := carrier.(ot.TextMapWriter) if ok { t.TextMapWriter = writer } else { @@ -801,14 +801,14 @@ func newTextMapWrapperForExtract(carrier interface{}) (*textMapWrapper, error) { func newTextMapWrapperForInject(carrier interface{}) (*textMapWrapper, error) { t := &textMapWrapper{} - writer, ok := carrier.(opentracing.TextMapWriter) + writer, ok := carrier.(ot.TextMapWriter) if !ok { return nil, ot.ErrInvalidCarrier } t.TextMapWriter = writer - reader, ok := carrier.(opentracing.TextMapReader) + reader, ok := carrier.(ot.TextMapReader) if ok { t.TextMapReader = reader } else { @@ -822,12 +822,12 @@ type textMapWriter struct { } func (t *textMapWriter) Set(key string, value string) { - return // maybe print a warning log + // maybe print a warning log. } type textMapReader struct { } func (t *textMapReader) ForeachKey(handler func(key, val string) error) error { - return nil // maybe print a warning log + return nil // maybe print a warning log. } diff --git a/bridge/opentracing/bridge_test.go b/bridge/opentracing/bridge_test.go index aaef1f3ca50..4f4b3d45f53 100644 --- a/bridge/opentracing/bridge_test.go +++ b/bridge/opentracing/bridge_test.go @@ -3,13 +3,15 @@ package opentracing import ( "context" "errors" + "net/http" + "strings" + "testing" + ot "github.com/opentracing/opentracing-go" "github.com/stretchr/testify/assert" + "go.opentelemetry.io/otel/propagation" "go.opentelemetry.io/otel/trace" - "net/http" - "strings" - "testing" ) type testOnlyTextMapReader struct { @@ -36,8 +38,6 @@ func newTestOnlyTextMapWriter() *testOnlyTextMapWriter { func (t *testOnlyTextMapWriter) Set(key, val string) { t.m[key] = val - - return } type testTextMapReaderAndWriter struct { @@ -127,7 +127,6 @@ type testTextMapPropagator struct { } func (t testTextMapPropagator) Inject(ctx context.Context, carrier propagation.TextMapCarrier) { - carrier.Set(testHeader, strings.Join([]string{traceID.String(), spanID.String()}, ":")) } @@ -155,7 +154,7 @@ func (t testTextMapPropagator) Fields() []string { return []string{"test"} } -// textMapCarrier Implemented propagation.TextMapCarrier interface +// textMapCarrier Implemented propagation.TextMapCarrier interface. type textMapCarrier struct { m map[string]string } @@ -182,7 +181,7 @@ func (t *textMapCarrier) Keys() []string { return str } -// testTextMapReader only implemented opentracing.TextMapReader interface +// testTextMapReader only implemented opentracing.TextMapReader interface. type testTextMapReader struct { m *map[string]string } @@ -201,7 +200,7 @@ func (t *testTextMapReader) ForeachKey(handler func(key string, val string) erro return nil } -// testTextMapWriter only implemented opentracing.TextMapWriter interface +// testTextMapWriter only implemented opentracing.TextMapWriter interface. type testTextMapWriter struct { m *map[string]string } @@ -273,5 +272,4 @@ func TestBridgeTracer_ExtractAndInject(t *testing.T) { assert.Equal(t, traceID.String(), bsc.otelSpanContext.TraceID().String()) }) } - } From facc98d94d9a0207921e09dd90f9ad2287724a35 Mon Sep 17 00:00:00 2001 From: ttoad Date: Wed, 1 Jun 2022 04:47:40 +0800 Subject: [PATCH 08/13] doc: Restore comments --- bridge/opentracing/bridge.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/bridge/opentracing/bridge.go b/bridge/opentracing/bridge.go index cb51f9a001b..f3f747d3fb4 100644 --- a/bridge/opentracing/bridge.go +++ b/bridge/opentracing/bridge.go @@ -730,7 +730,7 @@ func (t *BridgeTracer) getPropagator() propagation.TextMapPropagator { return otel.GetTextMapPropagator() } -// textMapWrapper Provides ot.TextMapWriter and ot.TextMapReader to +// textMapWrapper Provides operating.TextMapWriter and operating.TextMapReader to // propagation.TextMapCarrier compatibility. // Usually, Inject method will only use the write-related interface. // Extract method will only use the reade-related interface. From 1d0f3fd4881ad244ff14788122160463fabe15be Mon Sep 17 00:00:00 2001 From: ttoad Date: Wed, 8 Jun 2022 05:17:28 +0800 Subject: [PATCH 09/13] wip: add test cases --- CHANGELOG.md | 2 +- bridge/opentracing/bridge_test.go | 144 ++++++++++++++++++++++++------ 2 files changed, 117 insertions(+), 29 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index fee58f36f46..9ada02d27a3 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -27,7 +27,7 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm - Add the `go.opentelemetry.io/otel/semconv/v1.10.0` package. The package contains semantic conventions from the `v1.10.0` version of the OpenTelemetry specification. (#2842) - Added an in-memory exporter to metrictest to aid testing with a full SDK. (#2776) -- The bridge package supported extract and injection of opentracing.TextMap type. (#2911) +- The bridge package supported extract and injection of opentracing.TextMap type. (#2911) ### Fixed diff --git a/bridge/opentracing/bridge_test.go b/bridge/opentracing/bridge_test.go index 4f4b3d45f53..656f6e77dc9 100644 --- a/bridge/opentracing/bridge_test.go +++ b/bridge/opentracing/bridge_test.go @@ -1,3 +1,17 @@ +// Copyright The OpenTelemetry Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + package opentracing import ( @@ -128,6 +142,10 @@ type testTextMapPropagator struct { func (t testTextMapPropagator) Inject(ctx context.Context, carrier propagation.TextMapCarrier) { carrier.Set(testHeader, strings.Join([]string{traceID.String(), spanID.String()}, ":")) + + // Test for panic + _ = carrier.Get("test") + _ = carrier.Keys() } func (t testTextMapPropagator) Extract(ctx context.Context, carrier propagation.TextMapCarrier) context.Context { @@ -138,6 +156,20 @@ func (t testTextMapPropagator) Extract(ctx context.Context, carrier propagation. return ctx } + var exist = false + + for _, key := range carrier.Keys() { + if key == testHeader { + exist = true + + break + } + } + + if !exist { + return ctx + } + var ( traceID, _ = trace.TraceIDFromHex(str[0]) spanID, _ = trace.SpanIDFromHex(str[1]) @@ -147,6 +179,9 @@ func (t testTextMapPropagator) Extract(ctx context.Context, carrier propagation. }) ) + // Test for panic + carrier.Set("key", "val") + return trace.ContextWithRemoteSpanContext(ctx, sc) } @@ -223,34 +258,82 @@ func TestBridgeTracer_ExtractAndInject(t *testing.T) { httpHeader := ot.HTTPHeadersCarrier(http.Header{}) testCases := []struct { - name string - carrierType ot.BuiltinFormat - extractCarrier interface{} - injectCarrier interface{} + name string + injectCarrierType ot.BuiltinFormat + extractCarrierType ot.BuiltinFormat + extractCarrier interface{} + injectCarrier interface{} + extractErr error + injectErr error }{ { - name: "support for propagation.TextMapCarrier", - carrierType: ot.TextMap, - extractCarrier: tmc, - injectCarrier: tmc, + name: "support for propagation.TextMapCarrier", + injectCarrierType: ot.TextMap, + injectCarrier: tmc, + extractCarrierType: ot.TextMap, + extractCarrier: tmc, + }, + { + name: "support for opentracing.TextMapReader and opentracing.TextMapWriter", + injectCarrierType: ot.TextMap, + injectCarrier: otTextMap, + extractCarrierType: ot.TextMap, + extractCarrier: otTextMap, + }, + { + name: "support for HTTPHeaders", + injectCarrierType: ot.HTTPHeaders, + injectCarrier: httpHeader, + extractCarrierType: ot.HTTPHeaders, + extractCarrier: httpHeader, + }, + { + name: "support for opentracing.TextMapReader and opentracing.TextMapWriter,non-same instance", + injectCarrierType: ot.TextMap, + injectCarrier: newTestTextMapWriter(&shareMap), + extractCarrierType: ot.TextMap, + extractCarrier: newTestTextMapReader(&shareMap), + }, + { + name: "inject: format type is HTTPHeaders, but carrier is not HTTPHeadersCarrier", + injectCarrierType: ot.HTTPHeaders, + injectCarrier: struct{}{}, + injectErr: ot.ErrInvalidCarrier, + }, + { + name: "extract: format type is HTTPHeaders, but carrier is not HTTPHeadersCarrier", + injectCarrierType: ot.HTTPHeaders, + injectCarrier: httpHeader, + extractCarrierType: ot.HTTPHeaders, + extractCarrier: struct{}{}, + extractErr: ot.ErrInvalidCarrier, }, { - name: "support for opentracing.TextMapReader and opentracing.TextMapWriter", - carrierType: ot.TextMap, - extractCarrier: otTextMap, - injectCarrier: otTextMap, + name: "inject: format type is TextMap, but carrier is cannot be wrapped into propagation.TextMapCarrier", + injectCarrierType: ot.TextMap, + injectCarrier: struct{}{}, + injectErr: ot.ErrInvalidCarrier, }, { - name: "support for HTTPHeaders", - carrierType: ot.HTTPHeaders, - extractCarrier: httpHeader, - injectCarrier: httpHeader, + name: "extract: format type is TextMap, but carrier is cannot be wrapped into propagation.TextMapCarrier", + injectCarrierType: ot.TextMap, + injectCarrier: otTextMap, + extractCarrierType: ot.TextMap, + extractCarrier: struct{}{}, + extractErr: ot.ErrInvalidCarrier, }, { - name: "support for opentracing.TextMapReader and opentracing.TextMapWriter,non-same instance", - carrierType: ot.TextMap, - extractCarrier: newTestTextMapReader(&shareMap), - injectCarrier: newTestTextMapWriter(&shareMap), + name: "inject: unsupported format type", + injectCarrierType: ot.Binary, + injectErr: ot.ErrUnsupportedFormat, + }, + { + name: "extract: unsupported format type", + injectCarrierType: ot.TextMap, + injectCarrier: otTextMap, + extractCarrierType: ot.Binary, + extractCarrier: struct{}{}, + extractErr: ot.ErrUnsupportedFormat, }, } @@ -259,17 +342,22 @@ func TestBridgeTracer_ExtractAndInject(t *testing.T) { err := bridge.Inject(newBridgeSpanContext(trace.NewSpanContext(trace.SpanContextConfig{ TraceID: [16]byte{byte(1)}, SpanID: [8]byte{byte(2)}, - }), nil), tc.carrierType, tc.injectCarrier) - assert.NoError(t, err) + }), nil), tc.injectCarrierType, tc.injectCarrier) + assert.Equal(t, tc.injectErr, err) + + if tc.injectErr == nil { + spanContext, err := bridge.Extract(tc.injectCarrierType, tc.extractCarrier) + assert.Equal(t, tc.extractErr, err) - spanContext, err := bridge.Extract(tc.carrierType, tc.extractCarrier) - assert.NoError(t, err) + if tc.extractErr == nil { + bsc, ok := spanContext.(*bridgeSpanContext) + assert.True(t, ok) - bsc, ok := spanContext.(*bridgeSpanContext) - assert.True(t, ok) + assert.Equal(t, spanID.String(), bsc.otelSpanContext.SpanID().String()) + assert.Equal(t, traceID.String(), bsc.otelSpanContext.TraceID().String()) + } - assert.Equal(t, spanID.String(), bsc.otelSpanContext.SpanID().String()) - assert.Equal(t, traceID.String(), bsc.otelSpanContext.TraceID().String()) + } }) } } From 0670464236296b881e88e0524a9f12d2be0f37d4 Mon Sep 17 00:00:00 2001 From: ttoad Date: Wed, 8 Jun 2022 06:02:58 +0800 Subject: [PATCH 10/13] test: fix args error --- bridge/opentracing/bridge_test.go | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/bridge/opentracing/bridge_test.go b/bridge/opentracing/bridge_test.go index 656f6e77dc9..deb4c4365b0 100644 --- a/bridge/opentracing/bridge_test.go +++ b/bridge/opentracing/bridge_test.go @@ -88,12 +88,12 @@ func TestTextMapWrapper_New(t *testing.T) { func TestTextMapWrapper_action(t *testing.T) { testExtractFunc := func(carrier propagation.TextMapCarrier) { - assert.Equal(t, carrier.Get("key1"), "val1") - assert.Equal(t, carrier.Get("key2"), "val2") - str := carrier.Keys() assert.Len(t, str, 2) assert.Contains(t, str, "key1", "key2") + + assert.Equal(t, carrier.Get("key1"), "val1") + assert.Equal(t, carrier.Get("key2"), "val2") } testInjectFunc := func(carrier propagation.TextMapCarrier) { @@ -159,7 +159,7 @@ func (t testTextMapPropagator) Extract(ctx context.Context, carrier propagation. var exist = false for _, key := range carrier.Keys() { - if key == testHeader { + if strings.EqualFold(testHeader, key) { exist = true break @@ -346,7 +346,7 @@ func TestBridgeTracer_ExtractAndInject(t *testing.T) { assert.Equal(t, tc.injectErr, err) if tc.injectErr == nil { - spanContext, err := bridge.Extract(tc.injectCarrierType, tc.extractCarrier) + spanContext, err := bridge.Extract(tc.extractCarrierType, tc.extractCarrier) assert.Equal(t, tc.extractErr, err) if tc.extractErr == nil { From c688a5a49eb7008390795c4b39e2bbe2ea24b04b Mon Sep 17 00:00:00 2001 From: ttoad Date: Wed, 8 Jun 2022 18:36:38 +0800 Subject: [PATCH 11/13] delete empty line --- bridge/opentracing/bridge_test.go | 1 - 1 file changed, 1 deletion(-) diff --git a/bridge/opentracing/bridge_test.go b/bridge/opentracing/bridge_test.go index deb4c4365b0..eea3091f265 100644 --- a/bridge/opentracing/bridge_test.go +++ b/bridge/opentracing/bridge_test.go @@ -356,7 +356,6 @@ func TestBridgeTracer_ExtractAndInject(t *testing.T) { assert.Equal(t, spanID.String(), bsc.otelSpanContext.SpanID().String()) assert.Equal(t, traceID.String(), bsc.otelSpanContext.TraceID().String()) } - } }) } From b181e67bd69924a864ee7c2b3882eac0f903c2bd Mon Sep 17 00:00:00 2001 From: ttoad Date: Mon, 13 Jun 2022 18:37:17 +0800 Subject: [PATCH 12/13] Fix syntax and changelog errors --- CHANGELOG.md | 6 +++++- bridge/opentracing/bridge.go | 4 ++-- bridge/opentracing/go.mod | 4 ++-- bridge/opentracing/go.sum | 6 ++++-- 4 files changed, 13 insertions(+), 7 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 9ada02d27a3..51b9c196707 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -8,6 +8,11 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm ## [Unreleased] +### Added + +- Add support for `opentracing.TextMap` format in the `Inject` and `Extract` methods + of the `"go.opentelemetry.io/otel/bridge/opentracing".BridgeTracer` type. (#2911) + ### Changed - The `crosslink` make target has been updated to use the `go.opentelemetry.io/build-tools/crosslink` package. (#2886) @@ -27,7 +32,6 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm - Add the `go.opentelemetry.io/otel/semconv/v1.10.0` package. The package contains semantic conventions from the `v1.10.0` version of the OpenTelemetry specification. (#2842) - Added an in-memory exporter to metrictest to aid testing with a full SDK. (#2776) -- The bridge package supported extract and injection of opentracing.TextMap type. (#2911) ### Fixed diff --git a/bridge/opentracing/bridge.go b/bridge/opentracing/bridge.go index f3f747d3fb4..2927e86535a 100644 --- a/bridge/opentracing/bridge.go +++ b/bridge/opentracing/bridge.go @@ -634,7 +634,7 @@ func (s fakeSpan) SpanContext() trace.SpanContext { // Inject is a part of the implementation of the OpenTracing Tracer // interface. // -// Currently only the HTTPHeaders and TextMap format are supported. +// Currently only the HTTPHeaders and TextMap formats are supported. func (t *BridgeTracer) Inject(sm ot.SpanContext, format interface{}, carrier interface{}) error { bridgeSC, ok := sm.(*bridgeSpanContext) if !ok { @@ -683,7 +683,7 @@ func (t *BridgeTracer) Inject(sm ot.SpanContext, format interface{}, carrier int // Extract is a part of the implementation of the OpenTracing Tracer // interface. // -// Currently only the HTTPHeaders and TextMap format are supported. +// Currently only the HTTPHeaders and TextMap formats are supported. func (t *BridgeTracer) Extract(format interface{}, carrier interface{}) (ot.SpanContext, error) { builtinFormat, ok := format.(ot.BuiltinFormat) if !ok { diff --git a/bridge/opentracing/go.mod b/bridge/opentracing/go.mod index 41f9dd76c1e..765d1bad47f 100644 --- a/bridge/opentracing/go.mod +++ b/bridge/opentracing/go.mod @@ -6,7 +6,7 @@ replace go.opentelemetry.io/otel => ../.. require ( github.com/opentracing/opentracing-go v1.2.0 - github.com/stretchr/testify v1.7.1 + github.com/stretchr/testify v1.7.2 go.opentelemetry.io/otel v1.7.0 go.opentelemetry.io/otel/trace v1.7.0 ) @@ -16,7 +16,7 @@ require ( github.com/go-logr/logr v1.2.3 // indirect github.com/go-logr/stdr v1.2.2 // indirect github.com/pmezard/go-difflib v1.0.0 // indirect - gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c // indirect + gopkg.in/yaml.v3 v3.0.1 // indirect ) replace go.opentelemetry.io/otel/trace => ../../trace diff --git a/bridge/opentracing/go.sum b/bridge/opentracing/go.sum index e6ca6acfa16..4814eca5ba9 100644 --- a/bridge/opentracing/go.sum +++ b/bridge/opentracing/go.sum @@ -13,9 +13,11 @@ github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZb github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= -github.com/stretchr/testify v1.7.1 h1:5TQK59W5E3v0r2duFAb7P95B6hEeOyEnHRa8MjYSMTY= github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.7.2 h1:4jaiDzPyXQvSd7D0EjG45355tLlV3VOECpq10pLC+8s= +github.com/stretchr/testify v1.7.2/go.mod h1:R6va5+xMeoiuVRoj+gSkQ7d3FALtqAAGI1FQKckRals= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo= gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= From a1939b5d8b9e0f67ab7c9219e6bd5fe878721534 Mon Sep 17 00:00:00 2001 From: ttoad Date: Tue, 14 Jun 2022 17:33:10 +0800 Subject: [PATCH 13/13] Fix formatting errors --- CHANGELOG.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 51b9c196707..49c63275a09 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -10,8 +10,8 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm ### Added -- Add support for `opentracing.TextMap` format in the `Inject` and `Extract` methods - of the `"go.opentelemetry.io/otel/bridge/opentracing".BridgeTracer` type. (#2911) +- Add support for `opentracing.TextMap` format in the `Inject` and `Extract` methods +of the `"go.opentelemetry.io/otel/bridge/opentracing".BridgeTracer` type. (#2911) ### Changed