OpenCensus bridge to support TraceState

CHANGELOG.md

@@ -17,6 +17,8 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
   See our [versioning policy](VERSIONING.md) for more information about these stability guarantees. (#5629)
 - Add `InstrumentationScope` field to `SpanStub` in `go.opentelemetry.io/otel/sdk/trace/tracetest`, as a replacement for the deprecated `InstrumentationLibrary`. (#5627)
 - Zero value of `SimpleProcessor` in `go.opentelemetry.io/otel/sdk/log` no longer panics. (#5665)
+- Add `Walk` function to `TraceState` in `go.opentelemetry.io/otel/trace` to iterate all the key-value pairs. (#5651)
+- Bridge the trace state in `go.opentelemetry.io/otel/bridge/opencensus`. (#5651)
 
 ### Changed
 

bridge/opencensus/internal/oc2otel/span_context.go

@@ -14,9 +14,16 @@ func SpanContext(sc octrace.SpanContext) trace.SpanContext {
 	if sc.IsSampled() {
 		traceFlags = trace.FlagsSampled
 	}
+
+	tsOtel := trace.TraceState{}
+	for _, entry := range sc.Tracestate.Entries() {
+		tsOtel, _ = tsOtel.Insert(entry.Key, entry.Value)
+	}
+
 	return trace.NewSpanContext(trace.SpanContextConfig{
 		TraceID:    trace.TraceID(sc.TraceID),
 		SpanID:     trace.SpanID(sc.SpanID),
 		TraceFlags: traceFlags,
+		TraceState: tsOtel,
 	})
 }

bridge/opencensus/internal/oc2otel/span_context_test.go

@@ -13,6 +13,14 @@ import (
 )
 
 func TestSpanContextConversion(t *testing.T) {
+	tsOc, _ := tracestate.New(nil,
+		tracestate.Entry{Key: "key1", Value: "value1"},
+		tracestate.Entry{Key: "key2", Value: "value2"},
+	)
+	tsOtel := trace.TraceState{}
+	tsOtel, _ = tsOtel.Insert("key1", "value1")
+	tsOtel, _ = tsOtel.Insert("key2", "value2")
+
 	for _, tc := range []struct {
 		description string
 		input       octrace.SpanContext
@@ -47,15 +55,16 @@ func TestSpanContextConversion(t *testing.T) {
 			}),
 		},
 		{
-			description: "trace state is ignored",
+			description: "trace state should be propagated",
 			input: octrace.SpanContext{
 				TraceID:    octrace.TraceID([16]byte{1}),
 				SpanID:     octrace.SpanID([8]byte{2}),
-				Tracestate: &tracestate.Tracestate{},
+				Tracestate: tsOc,
 			},
 			expected: trace.NewSpanContext(trace.SpanContextConfig{
-				TraceID: trace.TraceID([16]byte{1}),
-				SpanID:  trace.SpanID([8]byte{2}),
+				TraceID:    trace.TraceID([16]byte{1}),
+				SpanID:     trace.SpanID([8]byte{2}),
+				TraceState: tsOtel,
 			}),
 		},
 	} {

bridge/opencensus/internal/otel2oc/span_context.go

@@ -5,6 +5,7 @@ package otel2oc // import "go.opentelemetry.io/otel/bridge/opencensus/internal/o
 
 import (
 	octrace "go.opencensus.io/trace"
+	"go.opencensus.io/trace/tracestate"
 
 	"go.opentelemetry.io/otel/trace"
 )
@@ -15,9 +16,18 @@ func SpanContext(sc trace.SpanContext) octrace.SpanContext {
 		// OpenCensus doesn't expose functions to directly set sampled
 		to = 0x1
 	}
+
+	entries := make([]tracestate.Entry, 0, sc.TraceState().Len())
+	sc.TraceState().Walk(func(key, value string) bool {
+		entries = append(entries, tracestate.Entry{Key: key, Value: value})
+		return true
+	})
+	tsOc, _ := tracestate.New(nil, entries...)
+
 	return octrace.SpanContext{
 		TraceID:      octrace.TraceID(sc.TraceID()),
 		SpanID:       octrace.SpanID(sc.SpanID()),
 		TraceOptions: to,
+		Tracestate:   tsOc,
 	}
 }

bridge/opencensus/internal/otel2oc/span_context_test.go

@@ -6,12 +6,25 @@ package otel2oc
 import (
 	"testing"
 
+	"github.com/stretchr/testify/assert"
+
+	"go.opencensus.io/trace/tracestate"
+
 	octrace "go.opencensus.io/trace"
 
 	"go.opentelemetry.io/otel/trace"
 )
 
 func TestSpanContextConversion(t *testing.T) {
+	tsOc, _ := tracestate.New(nil,
+		// Oc has a reverse order of TraceState entries compared to OTel
+		tracestate.Entry{Key: "key2", Value: "value2"},
+		tracestate.Entry{Key: "key1", Value: "value1"},
+	)
+	tsOtel := trace.TraceState{}
+	tsOtel, _ = tsOtel.Insert("key1", "value1")
+	tsOtel, _ = tsOtel.Insert("key2", "value2")
+
 	for _, tc := range []struct {
 		description string
 		input       trace.SpanContext
@@ -45,12 +58,24 @@ func TestSpanContextConversion(t *testing.T) {
 				TraceOptions: octrace.TraceOptions(0),
 			},
 		},
+		{
+			description: "trace state should be propagated",
+			input: trace.NewSpanContext(trace.SpanContextConfig{
+				TraceID:    trace.TraceID([16]byte{1}),
+				SpanID:     trace.SpanID([8]byte{2}),
+				TraceState: tsOtel,
+			}),
+			expected: octrace.SpanContext{
+				TraceID:      octrace.TraceID([16]byte{1}),
+				SpanID:       octrace.SpanID([8]byte{2}),
+				TraceOptions: octrace.TraceOptions(0),
+				Tracestate:   tsOc,
+			},
+		},
 	} {
 		t.Run(tc.description, func(t *testing.T) {
 			output := SpanContext(tc.input)
-			if output != tc.expected {
-				t.Fatalf("Got %+v spancontext, expected %+v.", output, tc.expected)
-			}
+			assert.Equal(t, tc.expected, output)
 		})
 	}
 }

trace/tracestate.go

@@ -260,6 +260,16 @@ func (ts TraceState) Get(key string) string {
 	return ""
 }
 
+// Walk walks all key value pairs in the TraceState by calling f
+// Iteration stops if f returns false.
+func (ts TraceState) Walk(f func(key, value string) bool) {
+	for _, m := range ts.list {
+		if !f(m.Key, m.Value) {
+			break
+		}
+	}
+}
+
 // Insert adds a new list-member defined by the key/value pair to the
 // TraceState. If a list-member already exists for the given key, that
 // list-member's value is updated. The new or updated list-member is always

trace/tracestate_test.go

@@ -409,6 +409,52 @@ func TestTraceStateDelete(t *testing.T) {
 	}
 }
 
+func TestTraceStateWalk(t *testing.T) {
+	testCases := []struct {
+		name       string
+		tracestate TraceState
+		num        int
+		expected   [][]string
+	}{
+		{
+			name: "With keys",
+			tracestate: TraceState{list: []member{
+				{Key: "key1", Value: "val1"},
+				{Key: "key2", Value: "val2"},
+			}},
+			num:      3,
+			expected: [][]string{{"key1", "val1"}, {"key2", "val2"}},
+		},
+		{
+			name: "With keys walk partially",
+			tracestate: TraceState{list: []member{
+				{Key: "key1", Value: "val1"},
+				{Key: "key2", Value: "val2"},
+			}},
+			num:      1,
+			expected: [][]string{{"key1", "val1"}},
+		},
+
+		{
+			name:       "Without keys",
+			tracestate: TraceState{list: []member{}},
+			num:        2,
+			expected:   [][]string{},
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			got := [][]string{}
+			tc.tracestate.Walk(func(key, value string) bool {
+				got = append(got, []string{key, value})
+				return len(got) < tc.num
+			})
+			assert.Equal(t, tc.expected, got)
+		})
+	}
+}
+
 var insertTS = TraceState{list: []member{
 	{Key: "key1", Value: "val1"},
 	{Key: "key2", Value: "val2"},