Debian Codegraph @

exporters/stdout/stdouttrace/internal/observ/instrumentation_test.go

raw
1 // Copyright The OpenTelemetry Authors
2 // SPDX-License-Identifier: Apache-2.0
3
4 package observ_test
5
6 import (
7 "errors"
8 "testing"
9
10 "github.com/stretchr/testify/assert"
11 "github.com/stretchr/testify/require"
12
13 "go.opentelemetry.io/otel"
14 "go.opentelemetry.io/otel/attribute"
15 "go.opentelemetry.io/otel/exporters/stdout/stdouttrace/internal/observ"
16 mapi "go.opentelemetry.io/otel/metric"
17 "go.opentelemetry.io/otel/sdk/instrumentation"
18 "go.opentelemetry.io/otel/sdk/metric"
19 "go.opentelemetry.io/otel/sdk/metric/metricdata"
20 "go.opentelemetry.io/otel/sdk/metric/metricdata/metricdatatest"
21 semconv "go.opentelemetry.io/otel/semconv/v1.40.0"
22 "go.opentelemetry.io/otel/semconv/v1.40.0/otelconv"
23 )
24
25 const ID = 0
26
27 var Scope = instrumentation.Scope{
28 Name: observ.ScopeName,
29 Version: observ.Version,
30 SchemaURL: observ.SchemaURL,
31 }
32
33 type errMeterProvider struct {
34 mapi.MeterProvider
35
36 err error
37 }
38
39 func (m *errMeterProvider) Meter(string, ...mapi.MeterOption) mapi.Meter {
40 return &errMeter{err: m.err}
41 }
42
43 type errMeter struct {
44 mapi.Meter
45
46 err error
47 }
48
49 func (m *errMeter) Int64UpDownCounter(string, ...mapi.Int64UpDownCounterOption) (mapi.Int64UpDownCounter, error) {
50 return nil, m.err
51 }
52
53 func (m *errMeter) Int64Counter(string, ...mapi.Int64CounterOption) (mapi.Int64Counter, error) {
54 return nil, m.err
55 }
56
57 func (m *errMeter) Float64Histogram(string, ...mapi.Float64HistogramOption) (mapi.Float64Histogram, error) {
58 return nil, m.err
59 }
60
61 func TestNewInstrumentationObservabilityErrors(t *testing.T) {
62 orig := otel.GetMeterProvider()
63 t.Cleanup(func() { otel.SetMeterProvider(orig) })
64 mp := &errMeterProvider{err: assert.AnError}
65 otel.SetMeterProvider(mp)
66
67 t.Setenv("OTEL_GO_X_OBSERVABILITY", "true")
68
69 _, err := observ.NewInstrumentation(ID)
70 require.ErrorIs(t, err, assert.AnError, "new instrument errors")
71
72 assert.ErrorContains(t, err, "inflight metric")
73 assert.ErrorContains(t, err, "span exported metric")
74 assert.ErrorContains(t, err, "operation duration metric")
75 }
76
77 func TestNewInstrumentationObservabilityDisabled(t *testing.T) {
78 // Do not set OTEL_GO_X_OBSERVABILITY.
79 got, err := observ.NewInstrumentation(ID)
80 assert.NoError(t, err)
81 assert.Nil(t, got)
82 }
83
84 func setup(t *testing.T) (*observ.Instrumentation, func() metricdata.ScopeMetrics) {
85 t.Helper()
86
87 t.Setenv("OTEL_GO_X_OBSERVABILITY", "true")
88
89 original := otel.GetMeterProvider()
90 t.Cleanup(func() { otel.SetMeterProvider(original) })
91
92 r := metric.NewManualReader()
93 mp := metric.NewMeterProvider(metric.WithReader(r))
94 otel.SetMeterProvider(mp)
95
96 inst, err := observ.NewInstrumentation(ID)
97 require.NoError(t, err)
98 require.NotNil(t, inst)
99
100 return inst, func() metricdata.ScopeMetrics {
101 var rm metricdata.ResourceMetrics
102 require.NoError(t, r.Collect(t.Context(), &rm))
103
104 require.Len(t, rm.ScopeMetrics, 1)
105 return rm.ScopeMetrics[0]
106 }
107 }
108
109 func set(err error) attribute.Set {
110 attrs := []attribute.KeyValue{
111 semconv.OTelComponentName(observ.ComponentName(ID)),
112 semconv.OTelComponentTypeKey.String(observ.ComponentType),
113 }
114 if err != nil {
115 attrs = append(attrs, semconv.ErrorType(err))
116 }
117 return attribute.NewSet(attrs...)
118 }
119
120 func spanInflight() metricdata.Metrics {
121 return metricdata.Metrics{
122 Name: otelconv.SDKExporterSpanInflight{}.Name(),
123 Description: otelconv.SDKExporterSpanInflight{}.Description(),
124 Unit: otelconv.SDKExporterSpanInflight{}.Unit(),
125 Data: metricdata.Sum[int64]{
126 Temporality: metricdata.CumulativeTemporality,
127 DataPoints: []metricdata.DataPoint[int64]{
128 {Attributes: set(nil), Value: 0},
129 },
130 },
131 }
132 }
133
134 func spanExported(success, total int64, err error) metricdata.Metrics {
135 dp := []metricdata.DataPoint[int64]{
136 {Attributes: set(nil), Value: success},
137 }
138 if err != nil {
139 dp = append(dp, metricdata.DataPoint[int64]{
140 Attributes: set(err),
141 Value: total - success,
142 })
143 }
144 return metricdata.Metrics{
145 Name: otelconv.SDKExporterSpanExported{}.Name(),
146 Description: otelconv.SDKExporterSpanExported{}.Description(),
147 Unit: otelconv.SDKExporterSpanExported{}.Unit(),
148 Data: metricdata.Sum[int64]{
149 Temporality: metricdata.CumulativeTemporality,
150 IsMonotonic: true,
151 DataPoints: dp,
152 },
153 }
154 }
155
156 func operationDuration(err error) metricdata.Metrics {
157 return metricdata.Metrics{
158 Name: otelconv.SDKExporterOperationDuration{}.Name(),
159 Description: otelconv.SDKExporterOperationDuration{}.Description(),
160 Unit: otelconv.SDKExporterOperationDuration{}.Unit(),
161 Data: metricdata.Histogram[float64]{
162 Temporality: metricdata.CumulativeTemporality,
163 DataPoints: []metricdata.HistogramDataPoint[float64]{
164 {Attributes: set(err)},
165 },
166 },
167 }
168 }
169
170 func assertMetrics(t *testing.T, got metricdata.ScopeMetrics, spans, success int64, err error) {
171 t.Helper()
172
173 assert.Equal(t, Scope, got.Scope, "unexpected scope")
174
175 m := got.Metrics
176 require.Len(t, m, 3, "expected 3 metrics")
177
178 o := metricdatatest.IgnoreTimestamp()
179 want := spanInflight()
180 metricdatatest.AssertEqual(t, want, m[0], o)
181
182 want = spanExported(success, spans, err)
183 metricdatatest.AssertEqual(t, want, m[1], o)
184
185 want = operationDuration(err)
186 metricdatatest.AssertEqual(t, want, m[2], o, metricdatatest.IgnoreValue())
187 }
188
189 func TestInstrumentationExportSpans(t *testing.T) {
190 inst, collect := setup(t)
191
192 const n = 10
193 inst.ExportSpans(t.Context(), n).End(n, nil)
194
195 assertMetrics(t, collect(), n, n, nil)
196 }
197
198 func TestInstrumentationExportSpansAllErrored(t *testing.T) {
199 inst, collect := setup(t)
200
201 const n = 10
202 const success = 0
203 inst.ExportSpans(t.Context(), n).End(success, assert.AnError)
204
205 assertMetrics(t, collect(), n, success, assert.AnError)
206 }
207
208 func TestInstrumentationExportSpansPartialErrored(t *testing.T) {
209 inst, collect := setup(t)
210
211 const n = 10
212 const success = 5
213 inst.ExportSpans(t.Context(), n).End(success, assert.AnError)
214
215 assertMetrics(t, collect(), n, success, assert.AnError)
216 }
217
218 func BenchmarkInstrumentationExportSpans(b *testing.B) {
219 setup := func(b *testing.B) *observ.Instrumentation {
220 b.Helper()
221 b.Setenv("OTEL_GO_X_OBSERVABILITY", "true")
222 inst, err := observ.NewInstrumentation(ID)
223 if err != nil {
224 b.Fatalf("failed to create instrumentation: %v", err)
225 }
226 return inst
227 }
228
229 const nSpans = 10
230 err := errors.New("benchmark error")
231 run := func(n int64, err error) func(*testing.B) {
232 return func(b *testing.B) {
233 inst := setup(b)
234 b.ReportAllocs()
235 b.ResetTimer()
236 for b.Loop() {
237 inst.ExportSpans(b.Context(), nSpans).End(n, err)
238 }
239 }
240 }
241
242 b.Run("NoError", run(nSpans, nil))
243 b.Run("PartialError", run(4, err))
244 b.Run("FullError", run(0, err))
245 }