Debian Codegraph @

bridge/opencensus/trace_test.go

raw
1 // Copyright The OpenTelemetry Authors
2 // SPDX-License-Identifier: Apache-2.0
3
4 package opencensus // import "go.opentelemetry.io/otel/bridge/opencensus"
5
6 import (
7 "strings"
8 "testing"
9
10 "github.com/stretchr/testify/assert"
11 "github.com/stretchr/testify/require"
12 octrace "go.opencensus.io/trace"
13
14 "go.opentelemetry.io/otel/sdk/trace"
15 "go.opentelemetry.io/otel/sdk/trace/tracetest"
16 oteltrace "go.opentelemetry.io/otel/trace"
17 )
18
19 func TestNewTraceBridge(t *testing.T) {
20 exporter := tracetest.NewInMemoryExporter()
21 tp := trace.NewTracerProvider(trace.WithSyncer(exporter))
22 bridge := newTraceBridge([]TraceOption{WithTracerProvider(tp)})
23 _, span := bridge.StartSpan(t.Context(), "foo")
24 span.End()
25 gotSpans := exporter.GetSpans()
26 require.Len(t, gotSpans, 1)
27 gotSpan := gotSpans[0]
28 assert.Equal(t, scopeName, gotSpan.InstrumentationScope.Name)
29 assert.Equal(t, gotSpan.InstrumentationScope.Version, Version())
30 }
31
32 func TestOCSpanContextToOTel(t *testing.T) {
33 input := octrace.SpanContext{
34 TraceID: [16]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16},
35 SpanID: [8]byte{1, 2, 3, 4, 5, 6, 7, 8},
36 TraceOptions: octrace.TraceOptions(1),
37 }
38 want := oteltrace.NewSpanContext(oteltrace.SpanContextConfig{
39 TraceID: oteltrace.TraceID{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16},
40 SpanID: oteltrace.SpanID{1, 2, 3, 4, 5, 6, 7, 8},
41 TraceFlags: oteltrace.TraceFlags(1),
42 })
43 got := OCSpanContextToOTel(input)
44 assert.Equal(t, want, got)
45 }
46
47 func TestOTelSpanContextToOC(t *testing.T) {
48 tests := []struct {
49 name string
50 input oteltrace.SpanContext
51 expected octrace.SpanContext
52 }{
53 {
54 name: "empty span context",
55 input: oteltrace.SpanContext{},
56 expected: octrace.SpanContext{
57 TraceID: [16]byte{},
58 SpanID: [8]byte{},
59 TraceOptions: octrace.TraceOptions(0),
60 },
61 },
62 {
63 name: "sampled span context",
64 input: oteltrace.NewSpanContext(oteltrace.SpanContextConfig{
65 TraceID: oteltrace.TraceID{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16},
66 SpanID: oteltrace.SpanID{1, 2, 3, 4, 5, 6, 7, 8},
67 TraceFlags: oteltrace.FlagsSampled,
68 }),
69 expected: octrace.SpanContext{
70 TraceID: [16]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16},
71 SpanID: [8]byte{1, 2, 3, 4, 5, 6, 7, 8},
72 TraceOptions: octrace.TraceOptions(1),
73 },
74 },
75 {
76 name: "not sampled span context",
77 input: oteltrace.NewSpanContext(oteltrace.SpanContextConfig{
78 TraceID: oteltrace.TraceID{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16},
79 SpanID: oteltrace.SpanID{1, 2, 3, 4, 5, 6, 7, 8},
80 }),
81 expected: octrace.SpanContext{
82 TraceID: [16]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16},
83 SpanID: [8]byte{1, 2, 3, 4, 5, 6, 7, 8},
84 TraceOptions: octrace.TraceOptions(0),
85 },
86 },
87 {
88 name: "span context with tracestate",
89 input: func() oteltrace.SpanContext {
90 ts := oteltrace.TraceState{}
91 ts, _ = ts.Insert("key1", "value1")
92 ts, _ = ts.Insert("key2", "value2")
93 return oteltrace.NewSpanContext(oteltrace.SpanContextConfig{
94 TraceID: oteltrace.TraceID{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16},
95 SpanID: oteltrace.SpanID{1, 2, 3, 4, 5, 6, 7, 8},
96 TraceState: ts,
97 })
98 }(),
99 expected: octrace.SpanContext{
100 TraceID: [16]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16},
101 SpanID: [8]byte{1, 2, 3, 4, 5, 6, 7, 8},
102 TraceOptions: octrace.TraceOptions(0),
103 // Tracestate will be set by the conversion function
104 },
105 },
106 }
107
108 for _, tt := range tests {
109 t.Run(tt.name, func(t *testing.T) {
110 got := OTelSpanContextToOC(tt.input)
111
112 assert.Equal(t, tt.expected.TraceID, got.TraceID, "TraceID should be correctly converted")
113
114 assert.Equal(t, tt.expected.SpanID, got.SpanID, "SpanID should be correctly converted")
115
116 assert.Equal(t, tt.expected.TraceOptions, got.TraceOptions, "TraceOptions should be correctly converted")
117
118 // Verify Tracestate is populated when input has tracestate
119 if tt.input.TraceState().Len() > 0 {
120 assert.NotNil(t, got.Tracestate, "Tracestate should be populated when input has tracestate")
121 // Verify the tracestate entries are preserved
122 expectedTraceState := tt.input.TraceState().String()
123 gotEntries := got.Tracestate.Entries()
124
125 // Convert entries back to a string representation for comparison
126 var gotTraceStateEntries []string
127 for _, entry := range gotEntries {
128 gotTraceStateEntries = append(gotTraceStateEntries, entry.Key+"="+entry.Value)
129 }
130 gotTraceState := ""
131 if len(gotTraceStateEntries) > 0 {
132 gotTraceState = strings.Join(gotTraceStateEntries, ",")
133 }
134 assert.Equal(t, expectedTraceState, gotTraceState, "Tracestate should preserve entries")
135 } else if got.Tracestate != nil {
136 // For empty tracestate cases, ensure the field is properly handled
137 entries := got.Tracestate.Entries()
138 assert.Empty(t, entries, "Empty tracestate should result in empty entries")
139 }
140 })
141 }
142 }
143
144 func TestInstallTraceBridge(t *testing.T) {
145 originalTracer := octrace.DefaultTracer
146 defer func() {
147 octrace.DefaultTracer = originalTracer
148 }()
149
150 tests := []struct {
151 name string
152 opts []TraceOption
153 expectValidSpans bool
154 }{
155 {
156 name: "install with default options",
157 opts: nil,
158 expectValidSpans: false,
159 },
160 {
161 name: "install with custom tracer provider",
162 opts: []TraceOption{
163 WithTracerProvider(trace.NewTracerProvider()),
164 },
165 expectValidSpans: true,
166 },
167 {
168 name: "install with tracer provider with exporter",
169 opts: []TraceOption{
170 WithTracerProvider(
171 trace.NewTracerProvider(
172 trace.WithSyncer(tracetest.NewInMemoryExporter()),
173 ),
174 ),
175 },
176 expectValidSpans: true,
177 },
178 }
179
180 for _, tt := range tests {
181 t.Run(tt.name, func(t *testing.T) {
182 beforeTracer := octrace.DefaultTracer
183
184 InstallTraceBridge(tt.opts...)
185
186 assert.NotEqual(
187 t,
188 beforeTracer,
189 octrace.DefaultTracer,
190 "DefaultTracer should be updated",
191 )
192 assert.NotNil(
193 t,
194 octrace.DefaultTracer,
195 "DefaultTracer should not be nil",
196 )
197
198 ctx, span := octrace.DefaultTracer.StartSpan(
199 t.Context(),
200 "test-span",
201 )
202 assert.NotNil(
203 t,
204 span,
205 "Should be able to create spans",
206 )
207 assert.NotNil(t, ctx, "Should return a valid context")
208
209 spanContext := span.SpanContext()
210 if tt.expectValidSpans {
211 assert.NotEqual(
212 t,
213 octrace.TraceID{},
214 spanContext.TraceID,
215 "Span should have a non-zero TraceID",
216 )
217 assert.NotEqual(
218 t,
219 octrace.SpanID{},
220 spanContext.SpanID,
221 "Span should have a non-zero SpanID",
222 )
223 }
224
225 span.End()
226
227 spanFromContext := octrace.DefaultTracer.FromContext(ctx)
228 assert.NotNil(
229 t,
230 spanFromContext,
231 "Should be able to get span from context",
232 )
233 })
234 }
235 }