Debian Codegraph @

sdk/metric/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 mapi "go.opentelemetry.io/otel/metric"
16 "go.opentelemetry.io/otel/sdk"
17 "go.opentelemetry.io/otel/sdk/instrumentation"
18 "go.opentelemetry.io/otel/sdk/metric"
19 "go.opentelemetry.io/otel/sdk/metric/internal/observ"
20 "go.opentelemetry.io/otel/sdk/metric/metricdata"
21 "go.opentelemetry.io/otel/sdk/metric/metricdata/metricdatatest"
22 semconv "go.opentelemetry.io/otel/semconv/v1.40.0"
23 "go.opentelemetry.io/otel/semconv/v1.40.0/otelconv"
24 )
25
26 const (
27 ID = int64(42)
28 ComponentType = "test-reader"
29 )
30
31 var Scope = instrumentation.Scope{
32 Name: observ.ScopeName,
33 Version: sdk.Version(),
34 SchemaURL: observ.SchemaURL,
35 }
36
37 type errMeterProvider struct {
38 mapi.MeterProvider
39 err error
40 }
41
42 func (m *errMeterProvider) Meter(string, ...mapi.MeterOption) mapi.Meter {
43 return &errMeter{err: m.err}
44 }
45
46 type errMeter struct {
47 mapi.Meter
48 err error
49 }
50
51 func (m *errMeter) Float64Histogram(string, ...mapi.Float64HistogramOption) (mapi.Float64Histogram, error) {
52 return nil, m.err
53 }
54
55 func TestNewInstrumentationObservabilityErrors(t *testing.T) {
56 orig := otel.GetMeterProvider()
57 t.Cleanup(func() { otel.SetMeterProvider(orig) })
58 mp := &errMeterProvider{err: assert.AnError}
59 otel.SetMeterProvider(mp)
60
61 t.Setenv("OTEL_GO_X_OBSERVABILITY", "true")
62
63 _, err := observ.NewInstrumentation(ComponentType, ID)
64 require.ErrorIs(t, err, assert.AnError, "new instrument errors should be joined")
65
66 assert.ErrorContains(t, err, "collection duration metric")
67 }
68
69 func TestNewInstrumentationObservabilityDisabled(t *testing.T) {
70 // Do not set OTEL_GO_X_OBSERVABILITY.
71 got, err := observ.NewInstrumentation(ComponentType, ID)
72 assert.NoError(t, err)
73 assert.Nil(t, got)
74 }
75
76 // setup installs a ManualReader MeterProvider and returns an instantiated
77 // Instrumentation plus a collector that returns the single ScopeMetrics group.
78 func setup(t *testing.T) (*observ.Instrumentation, func() metricdata.ScopeMetrics) {
79 t.Helper()
80
81 t.Setenv("OTEL_GO_X_OBSERVABILITY", "true")
82
83 original := otel.GetMeterProvider()
84 t.Cleanup(func() { otel.SetMeterProvider(original) })
85
86 r := metric.NewManualReader()
87 mp := metric.NewMeterProvider(metric.WithReader(r))
88 otel.SetMeterProvider(mp)
89
90 inst, err := observ.NewInstrumentation(ComponentType, ID)
91 require.NoError(t, err)
92 require.NotNil(t, inst)
93
94 return inst, func() metricdata.ScopeMetrics {
95 var rm metricdata.ResourceMetrics
96 require.NoError(t, r.Collect(t.Context(), &rm))
97 require.Len(t, rm.ScopeMetrics, 1)
98 return rm.ScopeMetrics[0]
99 }
100 }
101
102 func baseAttrs(err error) []attribute.KeyValue {
103 attrs := []attribute.KeyValue{
104 semconv.OTelComponentName(observ.ComponentName(ComponentType, ID)),
105 semconv.OTelComponentTypeKey.String(ComponentType),
106 }
107 if err != nil {
108 attrs = append(attrs, semconv.ErrorType(err))
109 }
110 return attrs
111 }
112
113 func set(err error) attribute.Set {
114 return attribute.NewSet(baseAttrs(err)...)
115 }
116
117 func collectionDuration(err error) metricdata.Metrics {
118 return metricdata.Metrics{
119 Name: otelconv.SDKMetricReaderCollectionDuration{}.Name(),
120 Description: otelconv.SDKMetricReaderCollectionDuration{}.Description(),
121 Unit: otelconv.SDKMetricReaderCollectionDuration{}.Unit(),
122 Data: metricdata.Histogram[float64]{
123 Temporality: metricdata.CumulativeTemporality,
124 DataPoints: []metricdata.HistogramDataPoint[float64]{
125 {Attributes: set(err)},
126 },
127 },
128 }
129 }
130
131 func assertCollectionMetrics(t *testing.T, got metricdata.ScopeMetrics, err error) {
132 t.Helper()
133
134 assert.Equal(t, Scope, got.Scope, "unexpected scope")
135
136 m := got.Metrics
137 require.Len(t, m, 1, "expected 1 metric (collection duration)")
138
139 want := collectionDuration(err)
140 metricdatatest.AssertEqual(t, want, m[0], metricdatatest.IgnoreTimestamp(), metricdatatest.IgnoreValue())
141 }
142
143 func TestInstrumentationCollectMetricsSuccess(t *testing.T) {
144 inst, collect := setup(t)
145
146 inst.CollectMetrics(t.Context()).End(nil)
147
148 assertCollectionMetrics(t, collect(), nil)
149 }
150
151 func TestInstrumentationCollectMetricsError(t *testing.T) {
152 inst, collect := setup(t)
153
154 wantErr := assert.AnError
155 inst.CollectMetrics(t.Context()).End(wantErr)
156
157 assertCollectionMetrics(t, collect(), wantErr)
158 }
159
160 func TestComponentName(t *testing.T) {
161 tests := []struct {
162 componentType string
163 id int64
164 want string
165 }{
166 {componentType: "periodic_metric_reader", id: 0, want: "periodic_metric_reader/0"},
167 {componentType: "periodic_metric_reader", id: 1, want: "periodic_metric_reader/1"},
168 {componentType: "periodic_metric_reader", id: 42, want: "periodic_metric_reader/42"},
169 {componentType: "periodic_metric_reader", id: -1, want: "periodic_metric_reader/-1"},
170 {componentType: "manual_metric_reader", id: 0, want: "manual_metric_reader/0"},
171 }
172
173 for _, tt := range tests {
174 got := observ.ComponentName(tt.componentType, tt.id)
175 assert.Equal(t, tt.want, got)
176 }
177 }
178
179 func setupBench(b *testing.B) *observ.Instrumentation {
180 b.Helper()
181 b.Setenv("OTEL_GO_X_OBSERVABILITY", "true")
182
183 // Set up a proper MeterProvider for benchmarks
184 original := otel.GetMeterProvider()
185 b.Cleanup(func() { otel.SetMeterProvider(original) })
186
187 r := metric.NewManualReader()
188 mp := metric.NewMeterProvider(metric.WithReader(r))
189 otel.SetMeterProvider(mp)
190
191 inst, err := observ.NewInstrumentation(ComponentType, ID)
192 if err != nil {
193 b.Fatalf("failed to create instrumentation: %v", err)
194 }
195 if inst == nil {
196 b.Fatal("expected instrumentation, got nil")
197 }
198 return inst
199 }
200
201 func BenchmarkInstrumentationCollectMetrics(b *testing.B) {
202 run := func(err error) func(*testing.B) {
203 inst := setupBench(b)
204 return func(b *testing.B) {
205 ctx := b.Context()
206 b.ReportAllocs()
207 b.ResetTimer()
208 for b.Loop() {
209 inst.CollectMetrics(ctx).End(err)
210 }
211 }
212 }
213
214 err := errors.New("benchmark error")
215 b.Run("NoError", run(nil))
216 b.Run("Error", run(err))
217 }