Debian Codegraph @

exporters/stdout/stdouttrace/trace_test.go

raw
1 // Copyright The OpenTelemetry Authors
2 // SPDX-License-Identifier: Apache-2.0
3
4 package stdouttrace_test
5
6 import (
7 "bytes"
8 "context"
9 "encoding/json"
10 "io"
11 "math"
12 "testing"
13 "time"
14
15 "github.com/stretchr/testify/assert"
16 "github.com/stretchr/testify/require"
17
18 "go.opentelemetry.io/otel"
19 "go.opentelemetry.io/otel/attribute"
20 "go.opentelemetry.io/otel/codes"
21 "go.opentelemetry.io/otel/exporters/stdout/stdouttrace"
22 "go.opentelemetry.io/otel/exporters/stdout/stdouttrace/internal/counter"
23 "go.opentelemetry.io/otel/exporters/stdout/stdouttrace/internal/observ"
24 "go.opentelemetry.io/otel/sdk/instrumentation"
25 "go.opentelemetry.io/otel/sdk/metric"
26 "go.opentelemetry.io/otel/sdk/metric/metricdata"
27 "go.opentelemetry.io/otel/sdk/metric/metricdata/metricdatatest"
28 "go.opentelemetry.io/otel/sdk/resource"
29 tracesdk "go.opentelemetry.io/otel/sdk/trace"
30 "go.opentelemetry.io/otel/sdk/trace/tracetest"
31 semconv "go.opentelemetry.io/otel/semconv/v1.40.0"
32 "go.opentelemetry.io/otel/semconv/v1.40.0/otelconv"
33 "go.opentelemetry.io/otel/trace"
34 )
35
36 func TestExporterExportSpan(t *testing.T) {
37 // setup test span
38 now := time.Now()
39 traceID, _ := trace.TraceIDFromHex("0102030405060708090a0b0c0d0e0f10")
40 spanID, _ := trace.SpanIDFromHex("0102030405060708")
41 traceState, _ := trace.ParseTraceState("key=val")
42 keyValue := "value"
43 doubleValue := 123.456
44 res := resource.NewSchemaless(attribute.String("rk1", "rv11"))
45
46 ss := tracetest.SpanStub{
47 SpanContext: trace.NewSpanContext(trace.SpanContextConfig{
48 TraceID: traceID,
49 SpanID: spanID,
50 TraceState: traceState,
51 }),
52 Name: "/foo",
53 StartTime: now,
54 EndTime: now,
55 Attributes: []attribute.KeyValue{
56 attribute.String("key", keyValue),
57 attribute.Float64("double", doubleValue),
58 },
59 Events: []tracesdk.Event{
60 {Name: "foo", Attributes: []attribute.KeyValue{attribute.String("key", keyValue)}, Time: now},
61 {Name: "bar", Attributes: []attribute.KeyValue{attribute.Float64("double", doubleValue)}, Time: now},
62 },
63 SpanKind: trace.SpanKindInternal,
64 Status: tracesdk.Status{
65 Code: codes.Error,
66 Description: "interesting",
67 },
68 Resource: res,
69 }
70
71 tests := []struct {
72 opts []stdouttrace.Option
73 expectNow time.Time
74 ctx context.Context
75 wantErr error
76 }{
77 {
78 opts: []stdouttrace.Option{stdouttrace.WithPrettyPrint()},
79 expectNow: now,
80 ctx: t.Context(),
81 },
82 {
83 opts: []stdouttrace.Option{stdouttrace.WithPrettyPrint(), stdouttrace.WithoutTimestamps()},
84 // expectNow is an empty time.Time
85 ctx: t.Context(),
86 },
87 {
88 opts: []stdouttrace.Option{},
89 ctx: func() context.Context {
90 ctx, cancel := context.WithCancel(t.Context())
91 cancel()
92 return ctx
93 }(),
94 wantErr: context.Canceled,
95 },
96 }
97
98 for _, tt := range tests {
99 // write to buffer for testing
100 var b bytes.Buffer
101 ex, err := stdouttrace.New(append(tt.opts, stdouttrace.WithWriter(&b))...)
102 require.NoError(t, err)
103
104 err = ex.ExportSpans(tt.ctx, tracetest.SpanStubs{ss, ss}.Snapshots())
105 assert.Equal(t, tt.wantErr, err)
106
107 if tt.wantErr == nil {
108 got := b.String()
109 wantone := expectedJSON(tt.expectNow)
110 assert.Equal(t, wantone+wantone, got)
111 }
112 }
113 }
114
115 func expectedJSON(now time.Time) string {
116 serializedNow, _ := json.Marshal(now)
117 return `{
118 "Name": "/foo",
119 "SpanContext": {
120 "TraceID": "0102030405060708090a0b0c0d0e0f10",
121 "SpanID": "0102030405060708",
122 "TraceFlags": "00",
123 "TraceState": "key=val",
124 "Remote": false
125 },
126 "Parent": {
127 "TraceID": "00000000000000000000000000000000",
128 "SpanID": "0000000000000000",
129 "TraceFlags": "00",
130 "TraceState": "",
131 "Remote": false
132 },
133 "SpanKind": 1,
134 "StartTime": ` + string(serializedNow) + `,
135 "EndTime": ` + string(serializedNow) + `,
136 "Attributes": [
137 {
138 "Key": "key",
139 "Value": {
140 "Type": "STRING",
141 "Value": "value"
142 }
143 },
144 {
145 "Key": "double",
146 "Value": {
147 "Type": "FLOAT64",
148 "Value": 123.456
149 }
150 }
151 ],
152 "Events": [
153 {
154 "Name": "foo",
155 "Attributes": [
156 {
157 "Key": "key",
158 "Value": {
159 "Type": "STRING",
160 "Value": "value"
161 }
162 }
163 ],
164 "DroppedAttributeCount": 0,
165 "Time": ` + string(serializedNow) + `
166 },
167 {
168 "Name": "bar",
169 "Attributes": [
170 {
171 "Key": "double",
172 "Value": {
173 "Type": "FLOAT64",
174 "Value": 123.456
175 }
176 }
177 ],
178 "DroppedAttributeCount": 0,
179 "Time": ` + string(serializedNow) + `
180 }
181 ],
182 "Links": null,
183 "Status": {
184 "Code": "Error",
185 "Description": "interesting"
186 },
187 "DroppedAttributes": 0,
188 "DroppedEvents": 0,
189 "DroppedLinks": 0,
190 "ChildSpanCount": 0,
191 "Resource": [
192 {
193 "Key": "rk1",
194 "Value": {
195 "Type": "STRING",
196 "Value": "rv11"
197 }
198 }
199 ],
200 "InstrumentationScope": {
201 "Name": "",
202 "Version": "",
203 "SchemaURL": "",
204 "Attributes": null
205 },
206 "InstrumentationLibrary": {
207 "Name": "",
208 "Version": "",
209 "SchemaURL": "",
210 "Attributes": null
211 }
212 }
213 `
214 }
215
216 func TestExporterShutdownIgnoresContext(t *testing.T) {
217 ctx, cancel := context.WithTimeout(t.Context(), 1*time.Minute)
218 t.Cleanup(cancel)
219
220 e, err := stdouttrace.New()
221 if err != nil {
222 t.Fatalf("failed to create exporter: %v", err)
223 }
224
225 innerCtx, innerCancel := context.WithCancel(ctx)
226 innerCancel()
227 err = e.Shutdown(innerCtx)
228 assert.NoError(t, err)
229 }
230
231 func TestExporterShutdownNoError(t *testing.T) {
232 e, err := stdouttrace.New()
233 if err != nil {
234 t.Fatalf("failed to create exporter: %v", err)
235 }
236
237 if err := e.Shutdown(t.Context()); err != nil {
238 t.Errorf("shutdown errored: expected nil, got %v", err)
239 }
240 }
241
242 func TestObservability(t *testing.T) {
243 defaultCallExportSpans := func(t *testing.T, exporter *stdouttrace.Exporter) {
244 require.NoError(t, exporter.ExportSpans(t.Context(), tracetest.SpanStubs{
245 {Name: "/foo"},
246 {Name: "/bar"},
247 }.Snapshots()))
248 }
249
250 tests := []struct {
251 name string
252 enabled bool
253 callExportSpans func(t *testing.T, exporter *stdouttrace.Exporter)
254 assertMetrics func(t *testing.T, rm metricdata.ResourceMetrics)
255 }{
256 {
257 name: "Disabled",
258 enabled: false,
259 callExportSpans: defaultCallExportSpans,
260 assertMetrics: func(t *testing.T, rm metricdata.ResourceMetrics) {
261 assert.Empty(t, rm.ScopeMetrics)
262 },
263 },
264 {
265 name: "Enabled",
266 enabled: true,
267 callExportSpans: defaultCallExportSpans,
268 assertMetrics: func(t *testing.T, rm metricdata.ResourceMetrics) {
269 t.Helper()
270 require.Len(t, rm.ScopeMetrics, 1)
271
272 sm := rm.ScopeMetrics[0]
273 require.Len(t, sm.Metrics, 3)
274
275 assert.Equal(t, instrumentation.Scope{
276 Name: observ.ScopeName,
277 Version: observ.Version,
278 SchemaURL: observ.SchemaURL,
279 }, sm.Scope)
280
281 metricdatatest.AssertEqual(t, metricdata.Metrics{
282 Name: otelconv.SDKExporterSpanInflight{}.Name(),
283 Description: otelconv.SDKExporterSpanInflight{}.Description(),
284 Unit: otelconv.SDKExporterSpanInflight{}.Unit(),
285 Data: metricdata.Sum[int64]{
286 Temporality: metricdata.CumulativeTemporality,
287 DataPoints: []metricdata.DataPoint[int64]{
288 {
289 Attributes: attribute.NewSet(
290 semconv.OTelComponentName(observ.ComponentName(0)),
291 semconv.OTelComponentTypeKey.String(observ.ComponentType),
292 ),
293 Value: 0,
294 },
295 },
296 },
297 }, sm.Metrics[0], metricdatatest.IgnoreTimestamp())
298
299 metricdatatest.AssertEqual(t, metricdata.Metrics{
300 Name: otelconv.SDKExporterSpanExported{}.Name(),
301 Description: otelconv.SDKExporterSpanExported{}.Description(),
302 Unit: otelconv.SDKExporterSpanExported{}.Unit(),
303 Data: metricdata.Sum[int64]{
304 Temporality: metricdata.CumulativeTemporality,
305 IsMonotonic: true,
306 DataPoints: []metricdata.DataPoint[int64]{
307 {
308 Attributes: attribute.NewSet(
309 semconv.OTelComponentName(observ.ComponentName(0)),
310 semconv.OTelComponentTypeKey.String(observ.ComponentType),
311 ),
312 Value: 2,
313 },
314 },
315 },
316 }, sm.Metrics[1], metricdatatest.IgnoreTimestamp())
317
318 metricdatatest.AssertEqual(t, metricdata.Metrics{
319 Name: otelconv.SDKExporterOperationDuration{}.Name(),
320 Description: otelconv.SDKExporterOperationDuration{}.Description(),
321 Unit: otelconv.SDKExporterOperationDuration{}.Unit(),
322 Data: metricdata.Histogram[float64]{
323 Temporality: metricdata.CumulativeTemporality,
324 DataPoints: []metricdata.HistogramDataPoint[float64]{
325 {
326 Attributes: attribute.NewSet(
327 semconv.OTelComponentName(observ.ComponentName(0)),
328 semconv.OTelComponentTypeKey.String(observ.ComponentType),
329 ),
330 },
331 },
332 },
333 }, sm.Metrics[2], metricdatatest.IgnoreTimestamp(), metricdatatest.IgnoreValue())
334 },
335 },
336 }
337
338 for _, tt := range tests {
339 t.Run(tt.name, func(t *testing.T) {
340 if tt.enabled {
341 t.Setenv("OTEL_GO_X_OBSERVABILITY", "true")
342
343 // Reset component name counter for each test.
344 _ = counter.SetExporterID(0)
345 }
346
347 original := otel.GetMeterProvider()
348 t.Cleanup(func() { otel.SetMeterProvider(original) })
349
350 r := metric.NewManualReader()
351 mp := metric.NewMeterProvider(metric.WithReader(r))
352 otel.SetMeterProvider(mp)
353
354 exporter, err := stdouttrace.New(
355 stdouttrace.WithWriter(io.Discard))
356 require.NoError(t, err)
357
358 tt.callExportSpans(t, exporter)
359
360 var rm metricdata.ResourceMetrics
361 require.NoError(t, r.Collect(t.Context(), &rm))
362
363 tt.assertMetrics(t, rm)
364 })
365 }
366 }
367
368 func BenchmarkExporterExportSpans(b *testing.B) {
369 ss := tracetest.SpanStubs{
370 {Name: "/foo"},
371 {
372 Name: "JSON encoder cannot marshal math.Inf(1)",
373 Attributes: []attribute.KeyValue{attribute.Float64("", math.Inf(1))},
374 },
375 {Name: "/bar"},
376 }.Snapshots()
377
378 run := func(b *testing.B) {
379 ex, err := stdouttrace.New(stdouttrace.WithWriter(io.Discard))
380 if err != nil {
381 b.Fatalf("failed to create exporter: %v", err)
382 }
383
384 b.ReportAllocs()
385 b.ResetTimer()
386 for i := 0; i < b.N; i++ {
387 err = ex.ExportSpans(b.Context(), ss)
388 }
389 _ = err
390 }
391
392 b.Run("Observability", func(b *testing.B) {
393 b.Setenv("OTEL_GO_X_OBSERVABILITY", "true")
394 run(b)
395 })
396
397 b.Run("NoObservability", run)
398 }