Debian Codegraph @

sdk/metric/reader_test.go

raw
1 // Copyright The OpenTelemetry Authors
2 // SPDX-License-Identifier: Apache-2.0
3
4 package metric // import "go.opentelemetry.io/otel/sdk/metric"
5
6 import (
7 "context"
8 "sync"
9 "testing"
10 "time"
11
12 "github.com/go-logr/logr/testr"
13 "github.com/stretchr/testify/assert"
14 "github.com/stretchr/testify/suite"
15
16 "go.opentelemetry.io/otel"
17 "go.opentelemetry.io/otel/attribute"
18 "go.opentelemetry.io/otel/sdk/instrumentation"
19 "go.opentelemetry.io/otel/sdk/metric/metricdata"
20 "go.opentelemetry.io/otel/sdk/resource"
21 )
22
23 type readerTestSuite struct {
24 suite.Suite
25
26 Factory func(...ReaderOption) Reader
27 Reader Reader
28 }
29
30 func (ts *readerTestSuite) SetupSuite() {
31 otel.SetLogger(testr.New(ts.T()))
32 }
33
34 func (ts *readerTestSuite) TearDownTest() {
35 // Ensure Reader is allowed attempt to clean up.
36 _ = ts.Reader.Shutdown(context.Background())
37 }
38
39 func (ts *readerTestSuite) TestErrorForNotRegistered() {
40 ts.Reader = ts.Factory()
41 err := ts.Reader.Collect(context.Background(), &metricdata.ResourceMetrics{})
42 ts.ErrorIs(err, ErrReaderNotRegistered)
43 }
44
45 func (ts *readerTestSuite) TestSDKProducer() {
46 ts.Reader = ts.Factory()
47 ts.Reader.register(testSDKProducer{})
48 m := metricdata.ResourceMetrics{}
49 err := ts.Reader.Collect(context.Background(), &m)
50 ts.NoError(err)
51 ts.Equal(testResourceMetricsA, m)
52 }
53
54 func (ts *readerTestSuite) TestExternalProducer() {
55 ts.Reader = ts.Factory(WithProducer(testExternalProducer{}))
56 ts.Reader.register(testSDKProducer{})
57 m := metricdata.ResourceMetrics{}
58 err := ts.Reader.Collect(context.Background(), &m)
59 ts.NoError(err)
60 ts.Equal(testResourceMetricsAB, m)
61 }
62
63 func (ts *readerTestSuite) TestCollectAfterShutdown() {
64 ts.Reader = ts.Factory(WithProducer(testExternalProducer{}))
65 ctx := context.Background()
66 ts.Reader.register(testSDKProducer{})
67 ts.Require().NoError(ts.Reader.Shutdown(ctx))
68
69 m := metricdata.ResourceMetrics{}
70 err := ts.Reader.Collect(ctx, &m)
71 ts.ErrorIs(err, ErrReaderShutdown)
72 ts.Equal(metricdata.ResourceMetrics{}, m)
73 }
74
75 func (ts *readerTestSuite) TestShutdownTwice() {
76 ts.Reader = ts.Factory(WithProducer(testExternalProducer{}))
77 ctx := context.Background()
78 ts.Reader.register(testSDKProducer{})
79 ts.Require().NoError(ts.Reader.Shutdown(ctx))
80 ts.ErrorIs(ts.Reader.Shutdown(ctx), ErrReaderShutdown)
81 }
82
83 func (ts *readerTestSuite) TestMultipleRegister() {
84 ts.Reader = ts.Factory()
85 p0 := testSDKProducer{
86 produceFunc: func(_ context.Context, rm *metricdata.ResourceMetrics) error {
87 // Differentiate this producer from the second by returning an
88 // error.
89 *rm = testResourceMetricsA
90 return assert.AnError
91 },
92 }
93 p1 := testSDKProducer{}
94
95 ts.Reader.register(p0)
96 // This should be ignored.
97 ts.Reader.register(p1)
98
99 err := ts.Reader.Collect(context.Background(), &metricdata.ResourceMetrics{})
100 ts.Equal(assert.AnError, err)
101 }
102
103 func (ts *readerTestSuite) TestExternalProducerPartialSuccess() {
104 ts.Reader = ts.Factory(
105 WithProducer(testExternalProducer{
106 produceFunc: func(context.Context) ([]metricdata.ScopeMetrics, error) {
107 return []metricdata.ScopeMetrics{}, assert.AnError
108 },
109 }),
110 WithProducer(testExternalProducer{
111 produceFunc: func(context.Context) ([]metricdata.ScopeMetrics, error) {
112 return []metricdata.ScopeMetrics{testScopeMetricsB}, nil
113 },
114 }),
115 )
116 ts.Reader.register(testSDKProducer{})
117
118 m := metricdata.ResourceMetrics{}
119 err := ts.Reader.Collect(context.Background(), &m)
120 ts.ErrorIs(err, assert.AnError)
121 ts.Equal(testResourceMetricsAB, m)
122 }
123
124 func (ts *readerTestSuite) TestSDKFailureBlocksExternalProducer() {
125 ts.Reader = ts.Factory(WithProducer(testExternalProducer{}))
126 ts.Reader.register(testSDKProducer{
127 produceFunc: func(_ context.Context, rm *metricdata.ResourceMetrics) error {
128 *rm = metricdata.ResourceMetrics{}
129 return assert.AnError
130 },
131 })
132
133 m := metricdata.ResourceMetrics{}
134 err := ts.Reader.Collect(context.Background(), &m)
135 ts.Equal(assert.AnError, err)
136 ts.Equal(metricdata.ResourceMetrics{}, m)
137 }
138
139 func (ts *readerTestSuite) TestMethodConcurrentSafe() {
140 ts.Reader = ts.Factory(WithProducer(testExternalProducer{}))
141 // Requires the race-detector (a default test option for the project).
142
143 // All reader methods should be concurrent-safe.
144 ts.Reader.register(testSDKProducer{})
145 ctx := context.Background()
146
147 var wg sync.WaitGroup
148 const threads = 2
149 for range threads {
150 wg.Go(func() {
151 _ = ts.Reader.temporality(InstrumentKindCounter)
152 })
153
154 wg.Go(func() {
155 _ = ts.Reader.aggregation(InstrumentKindCounter)
156 })
157
158 wg.Go(func() {
159 _ = ts.Reader.Collect(ctx, &metricdata.ResourceMetrics{})
160 })
161
162 if f, ok := ts.Reader.(interface{ ForceFlush(context.Context) error }); ok {
163 wg.Go(func() {
164 _ = f.ForceFlush(ctx)
165 })
166 }
167
168 wg.Go(func() {
169 _ = ts.Reader.Shutdown(ctx)
170 })
171 }
172 wg.Wait()
173 }
174
175 func (ts *readerTestSuite) TestShutdownBeforeRegister() {
176 ts.Reader = ts.Factory(WithProducer(testExternalProducer{}))
177 ctx := context.Background()
178 ts.Require().NoError(ts.Reader.Shutdown(ctx))
179 // Registering after shutdown should not revert the shutdown.
180 ts.Reader.register(testSDKProducer{})
181
182 m := metricdata.ResourceMetrics{}
183 err := ts.Reader.Collect(ctx, &m)
184 ts.ErrorIs(err, ErrReaderShutdown)
185 ts.Equal(metricdata.ResourceMetrics{}, m)
186 }
187
188 func (ts *readerTestSuite) TestCollectNilResourceMetricError() {
189 ts.Reader = ts.Factory()
190 ctx := context.Background()
191 ts.Error(ts.Reader.Collect(ctx, nil))
192 }
193
194 var testScopeMetricsA = metricdata.ScopeMetrics{
195 Scope: instrumentation.Scope{Name: "sdk/metric/test/reader"},
196 Metrics: []metricdata.Metrics{{
197 Name: "fake data",
198 Description: "Data used to test a reader",
199 Unit: "1",
200 Data: metricdata.Sum[int64]{
201 Temporality: metricdata.CumulativeTemporality,
202 IsMonotonic: true,
203 DataPoints: []metricdata.DataPoint[int64]{{
204 Attributes: attribute.NewSet(attribute.String("user", "alice")),
205 StartTime: time.Now(),
206 Time: time.Now().Add(time.Second),
207 Value: -1,
208 }},
209 },
210 }},
211 }
212
213 var testScopeMetricsB = metricdata.ScopeMetrics{
214 Scope: instrumentation.Scope{Name: "sdk/metric/test/reader/external"},
215 Metrics: []metricdata.Metrics{{
216 Name: "fake scope data",
217 Description: "Data used to test a Producer reader",
218 Unit: "ms",
219 Data: metricdata.Gauge[int64]{
220 DataPoints: []metricdata.DataPoint[int64]{{
221 Attributes: attribute.NewSet(attribute.String("user", "ben")),
222 StartTime: time.Now(),
223 Time: time.Now().Add(time.Second),
224 Value: 10,
225 }},
226 },
227 }},
228 }
229
230 var testResourceMetricsA = metricdata.ResourceMetrics{
231 Resource: resource.NewSchemaless(attribute.String("test", "Reader")),
232 ScopeMetrics: []metricdata.ScopeMetrics{testScopeMetricsA},
233 }
234
235 var testResourceMetricsAB = metricdata.ResourceMetrics{
236 Resource: resource.NewSchemaless(attribute.String("test", "Reader")),
237 ScopeMetrics: []metricdata.ScopeMetrics{testScopeMetricsA, testScopeMetricsB},
238 }
239
240 type testSDKProducer struct {
241 produceFunc func(context.Context, *metricdata.ResourceMetrics) error
242 }
243
244 func (p testSDKProducer) produce(ctx context.Context, rm *metricdata.ResourceMetrics) error {
245 if p.produceFunc != nil {
246 return p.produceFunc(ctx, rm)
247 }
248 *rm = testResourceMetricsA
249 return nil
250 }
251
252 type testExternalProducer struct {
253 produceFunc func(context.Context) ([]metricdata.ScopeMetrics, error)
254 }
255
256 func (p testExternalProducer) Produce(ctx context.Context) ([]metricdata.ScopeMetrics, error) {
257 if p.produceFunc != nil {
258 return p.produceFunc(ctx)
259 }
260 return []metricdata.ScopeMetrics{testScopeMetricsB}, nil
261 }
262
263 func benchReaderCollectFunc(r Reader) func(b *testing.B) {
264 r.register(testSDKProducer{})
265
266 // Store benchmark results in a closure to prevent the compiler from
267 // inlining and skipping the function.
268 var (
269 collectedMetrics metricdata.ResourceMetrics
270 err error
271 )
272
273 return func(b *testing.B) {
274 b.ReportAllocs()
275 b.ResetTimer()
276
277 for n := 0; n < b.N; n++ {
278 err = r.Collect(b.Context(), &collectedMetrics)
279 assert.Equalf(
280 b,
281 testResourceMetricsA,
282 collectedMetrics,
283 "unexpected Collect response: (%#v, %v)",
284 collectedMetrics,
285 err,
286 )
287 }
288 }
289 }
290
291 func TestDefaultAggregationSelector(t *testing.T) {
292 var undefinedInstrument InstrumentKind
293 assert.Panics(t, func() { DefaultAggregationSelector(undefinedInstrument) })
294
295 iKinds := []InstrumentKind{
296 InstrumentKindCounter,
297 InstrumentKindUpDownCounter,
298 InstrumentKindHistogram,
299 InstrumentKindGauge,
300 InstrumentKindObservableCounter,
301 InstrumentKindObservableUpDownCounter,
302 InstrumentKindObservableGauge,
303 }
304
305 for _, ik := range iKinds {
306 assert.NoError(t, DefaultAggregationSelector(ik).err(), "%+v", ik)
307 }
308 }
309
310 func TestDefaultTemporalitySelector(t *testing.T) {
311 var undefinedInstrument InstrumentKind
312 for _, ik := range []InstrumentKind{
313 undefinedInstrument,
314 InstrumentKindCounter,
315 InstrumentKindUpDownCounter,
316 InstrumentKindHistogram,
317 InstrumentKindGauge,
318 InstrumentKindObservableCounter,
319 InstrumentKindObservableUpDownCounter,
320 InstrumentKindObservableGauge,
321 } {
322 assert.Equal(t, metricdata.CumulativeTemporality, DefaultTemporalitySelector(ik))
323 }
324 }
325
326 func TestCumulativeTemporalitySelector(t *testing.T) {
327 var undefinedInstrument InstrumentKind
328 for _, ik := range []InstrumentKind{
329 undefinedInstrument,
330 InstrumentKindCounter,
331 InstrumentKindUpDownCounter,
332 InstrumentKindHistogram,
333 InstrumentKindGauge,
334 InstrumentKindObservableCounter,
335 InstrumentKindObservableUpDownCounter,
336 InstrumentKindObservableGauge,
337 } {
338 assert.Equal(t, metricdata.CumulativeTemporality, CumulativeTemporalitySelector(ik))
339 }
340 }
341
342 func TestDeltaTemporalitySelector(t *testing.T) {
343 var undefinedInstrument InstrumentKind
344 for _, ik := range []InstrumentKind{
345 InstrumentKindCounter,
346 InstrumentKindHistogram,
347 InstrumentKindObservableCounter,
348 } {
349 assert.Equal(t, metricdata.DeltaTemporality, DeltaTemporalitySelector(ik))
350 }
351
352 for _, ik := range []InstrumentKind{
353 undefinedInstrument,
354 InstrumentKindGauge,
355 InstrumentKindObservableGauge,
356 InstrumentKindObservableUpDownCounter,
357 InstrumentKindUpDownCounter,
358 } {
359 assert.Equal(t, metricdata.CumulativeTemporality, DeltaTemporalitySelector(ik))
360 }
361 }
362
363 func TestLowMemoryTemporalitySelector(t *testing.T) {
364 var undefinedInstrument InstrumentKind
365 for _, ik := range []InstrumentKind{
366 InstrumentKindCounter,
367 InstrumentKindHistogram,
368 } {
369 assert.Equal(t, metricdata.DeltaTemporality, LowMemoryTemporalitySelector(ik))
370 }
371
372 for _, ik := range []InstrumentKind{
373 undefinedInstrument,
374 InstrumentKindGauge,
375 InstrumentKindObservableCounter,
376 InstrumentKindObservableGauge,
377 InstrumentKindObservableUpDownCounter,
378 InstrumentKindUpDownCounter,
379 } {
380 assert.Equal(t, metricdata.CumulativeTemporality, LowMemoryTemporalitySelector(ik))
381 }
382 }
383
384 type notComparable [0]func() // nolint:unused // non-comparable type itself is used.
385
386 type noCompareReader struct {
387 notComparable // nolint:unused // non-comparable type itself is used.
388 Reader
389 }
390
391 func TestReadersNotRequiredToBeComparable(t *testing.T) {
392 r := noCompareReader{Reader: NewManualReader()}
393 assert.NotPanics(t, func() { _ = NewMeterProvider(WithReader(r)) })
394 }