Debian Codegraph @

sdk/metric/provider_test.go

raw
1 // Copyright The OpenTelemetry Authors
2 // SPDX-License-Identifier: Apache-2.0
3
4 package metric
5
6 import (
7 "context"
8 "fmt"
9 "strings"
10 "testing"
11
12 "github.com/go-logr/logr/funcr"
13 "github.com/go-logr/logr/testr"
14 "github.com/stretchr/testify/assert"
15 "github.com/stretchr/testify/require"
16
17 "go.opentelemetry.io/otel"
18 "go.opentelemetry.io/otel/attribute"
19 api "go.opentelemetry.io/otel/metric"
20 "go.opentelemetry.io/otel/metric/noop"
21 "go.opentelemetry.io/otel/sdk/metric/metricdata"
22 )
23
24 func TestMeterConcurrentSafe(*testing.T) {
25 const name = "TestMeterConcurrentSafe meter"
26 mp := NewMeterProvider()
27
28 done := make(chan struct{})
29 go func() {
30 defer close(done)
31 _ = mp.Meter(name)
32 }()
33
34 _ = mp.Meter(name)
35 <-done
36 }
37
38 func TestForceFlushConcurrentSafe(t *testing.T) {
39 mp := NewMeterProvider()
40
41 done := make(chan struct{})
42 go func() {
43 defer close(done)
44 _ = mp.ForceFlush(t.Context())
45 }()
46
47 _ = mp.ForceFlush(t.Context())
48 <-done
49 }
50
51 func TestShutdownConcurrentSafe(t *testing.T) {
52 mp := NewMeterProvider()
53
54 done := make(chan struct{})
55 go func() {
56 defer close(done)
57 _ = mp.Shutdown(t.Context())
58 }()
59
60 _ = mp.Shutdown(t.Context())
61 <-done
62 }
63
64 func TestMeterAndShutdownConcurrentSafe(t *testing.T) {
65 const name = "TestMeterAndShutdownConcurrentSafe meter"
66 mp := NewMeterProvider()
67
68 done := make(chan struct{})
69 go func() {
70 defer close(done)
71 _ = mp.Shutdown(t.Context())
72 }()
73
74 _ = mp.Meter(name)
75 <-done
76 }
77
78 func TestMeterDoesNotPanicForEmptyMeterProvider(t *testing.T) {
79 mp := MeterProvider{}
80 assert.NotPanics(t, func() { _ = mp.Meter("") })
81 }
82
83 func TestForceFlushDoesNotPanicForEmptyMeterProvider(t *testing.T) {
84 mp := MeterProvider{}
85 assert.NotPanics(t, func() { _ = mp.ForceFlush(t.Context()) })
86 }
87
88 func TestShutdownDoesNotPanicForEmptyMeterProvider(t *testing.T) {
89 mp := MeterProvider{}
90 assert.NotPanics(t, func() { _ = mp.Shutdown(t.Context()) })
91 }
92
93 func TestMeterProviderReturnsSameMeter(t *testing.T) {
94 mp := MeterProvider{}
95 mtr := mp.Meter("")
96
97 assert.Same(t, mtr, mp.Meter(""))
98 assert.NotSame(t, mtr, mp.Meter("diff"))
99 assert.NotSame(t, mtr, mp.Meter("", api.WithInstrumentationAttributes(attribute.String("k", "v"))))
100 }
101
102 func TestEmptyMeterName(t *testing.T) {
103 var buf strings.Builder
104 warnLevel := 1
105 l := funcr.New(func(prefix, args string) {
106 _, _ = fmt.Fprint(&buf, prefix, args)
107 }, funcr.Options{Verbosity: warnLevel})
108 otel.SetLogger(l)
109 mp := NewMeterProvider()
110
111 mp.Meter("")
112
113 assert.Contains(t, buf.String(), `"level"=1 "msg"="Invalid Meter name." "name"=""`)
114 }
115
116 func TestMeterProviderReturnsNoopMeterAfterShutdown(t *testing.T) {
117 mp := NewMeterProvider()
118
119 m := mp.Meter("")
120 _, ok := m.(noop.Meter)
121 assert.False(t, ok, "Meter from running MeterProvider is NoOp")
122
123 require.NoError(t, mp.Shutdown(t.Context()))
124
125 m = mp.Meter("")
126 _, ok = m.(noop.Meter)
127 assert.Truef(t, ok, "Meter from shutdown MeterProvider is not NoOp: %T", m)
128 }
129
130 func TestMeterProviderMixingOnRegisterErrors(t *testing.T) {
131 otel.SetLogger(testr.New(t))
132
133 rdr0 := NewManualReader()
134 mp0 := NewMeterProvider(WithReader(rdr0))
135
136 rdr1 := NewManualReader()
137 mp1 := NewMeterProvider(WithReader(rdr1))
138
139 // Meters with the same scope but different MeterProviders.
140 m0 := mp0.Meter("TestMeterProviderMixingOnRegisterErrors")
141 m1 := mp1.Meter("TestMeterProviderMixingOnRegisterErrors")
142
143 m0Gauge, err := m0.Float64ObservableGauge("float64Gauge")
144 require.NoError(t, err)
145
146 m1Gauge, err := m1.Int64ObservableGauge("int64Gauge")
147 require.NoError(t, err)
148
149 _, err = m0.RegisterCallback(
150 func(_ context.Context, o api.Observer) error {
151 o.ObserveFloat64(m0Gauge, 2)
152 // Observe an instrument from a different MeterProvider.
153 o.ObserveInt64(m1Gauge, 1)
154
155 return nil
156 },
157 m0Gauge, m1Gauge,
158 )
159 assert.Error(
160 t,
161 err,
162 "Instrument registered with Meter from different MeterProvider",
163 )
164
165 var data metricdata.ResourceMetrics
166 _ = rdr0.Collect(t.Context(), &data)
167 // Only the metrics from mp0 should be produced.
168 assert.Len(t, data.ScopeMetrics, 1)
169
170 err = rdr1.Collect(t.Context(), &data)
171 assert.NoError(t, err, "Errored when collect should be a noop")
172 assert.Empty(
173 t, data.ScopeMetrics,
174 "Metrics produced for instrument collected by different MeterProvider",
175 )
176 }
177
178 func TestMeterProviderCardinalityLimit(t *testing.T) {
179 const uniqueAttributesCount = 10
180
181 tests := []struct {
182 name string
183 options []Option
184 wantDataPoints int
185 }{
186 {
187 name: "no limit (default)",
188 options: nil,
189 wantDataPoints: uniqueAttributesCount,
190 },
191 {
192 name: "no limit (limit=0)",
193 options: []Option{WithCardinalityLimit(0)},
194 wantDataPoints: uniqueAttributesCount,
195 },
196 {
197 name: "no limit (negative)",
198 options: []Option{WithCardinalityLimit(-5)},
199 wantDataPoints: uniqueAttributesCount,
200 },
201 {
202 name: "limit=5",
203 options: []Option{WithCardinalityLimit(5)},
204 wantDataPoints: 5,
205 },
206 }
207
208 for _, tt := range tests {
209 t.Run(tt.name, func(t *testing.T) {
210 reader := NewManualReader()
211
212 opts := append(tt.options, WithReader(reader))
213 mp := NewMeterProvider(opts...)
214
215 meter := mp.Meter("test-meter")
216 counter, err := meter.Int64Counter("metric")
217 require.NoError(t, err, "failed to create counter")
218
219 for i := range uniqueAttributesCount {
220 counter.Add(
221 t.Context(),
222 1,
223 api.WithAttributes(attribute.Int("key", i)),
224 )
225 }
226
227 var rm metricdata.ResourceMetrics
228 err = reader.Collect(t.Context(), &rm)
229 require.NoError(t, err, "failed to collect metrics")
230
231 require.Len(t, rm.ScopeMetrics, 1, "expected 1 ScopeMetrics")
232 require.Len(t, rm.ScopeMetrics[0].Metrics, 1, "expected 1 Metric")
233
234 data := rm.ScopeMetrics[0].Metrics[0].Data
235 require.IsType(t, metricdata.Sum[int64]{}, data, "expected metricdata.Sum[int64]")
236
237 sumData := data.(metricdata.Sum[int64])
238 assert.Len(
239 t,
240 sumData.DataPoints,
241 tt.wantDataPoints,
242 "unexpected number of data points",
243 )
244 })
245 }
246 }
247
248 func TestMeterProviderPerInstrumentCardinalityLimits(t *testing.T) {
249 const uniqueAttributesCount = 10
250
251 type metricCase struct {
252 name string
253 selector CardinalityLimitSelector
254 globalLimit int
255 build func(t *testing.T, meter api.Meter)
256 wantPoints int
257 }
258
259 testCases := []metricCase{
260 {
261 name: "counter uses counter-specific limit",
262 selector: func(kind InstrumentKind) (int, bool) {
263 if kind == InstrumentKindCounter {
264 return 3, false
265 }
266 return 0, true
267 },
268 globalLimit: 8,
269 build: func(t *testing.T, meter api.Meter) {
270 counter, err := meter.Int64Counter("counter-metric")
271 require.NoError(t, err)
272 for i := range uniqueAttributesCount {
273 counter.Add(t.Context(), 1, api.WithAttributes(attribute.Int("key", i)))
274 }
275 },
276 wantPoints: 3,
277 },
278 {
279 name: "histogram uses histogram-specific limit",
280 selector: func(kind InstrumentKind) (int, bool) {
281 if kind == InstrumentKindHistogram {
282 return 4, false
283 }
284 return 0, true
285 },
286 globalLimit: 8,
287 build: func(t *testing.T, meter api.Meter) {
288 histogram, err := meter.Int64Histogram("histogram-metric")
289 require.NoError(t, err)
290 for i := range uniqueAttributesCount {
291 histogram.Record(t.Context(), int64(i), api.WithAttributes(attribute.Int("key", i)))
292 }
293 },
294 wantPoints: 4,
295 },
296 {
297 name: "gauge uses gauge-specific limit",
298 selector: func(kind InstrumentKind) (int, bool) {
299 if kind == InstrumentKindGauge {
300 return 5, false
301 }
302 return 0, true
303 },
304 globalLimit: 8,
305 build: func(t *testing.T, meter api.Meter) {
306 gauge, err := meter.Int64Gauge("gauge-metric")
307 require.NoError(t, err)
308 for i := range uniqueAttributesCount {
309 gauge.Record(t.Context(), int64(i), api.WithAttributes(attribute.Int("key", i)))
310 }
311 },
312 wantPoints: 5,
313 },
314 {
315 name: "up down counter uses updowncounter-specific limit",
316 selector: func(kind InstrumentKind) (int, bool) {
317 if kind == InstrumentKindUpDownCounter {
318 return 2, false
319 }
320 return 0, true
321 },
322 globalLimit: 8,
323 build: func(t *testing.T, meter api.Meter) {
324 upDownCounter, err := meter.Int64UpDownCounter("updowncounter-metric")
325 require.NoError(t, err)
326 for i := range uniqueAttributesCount {
327 upDownCounter.Add(t.Context(), 1, api.WithAttributes(attribute.Int("key", i)))
328 }
329 },
330 wantPoints: 2,
331 },
332 {
333 name: "observable counter uses observable-counter-specific limit",
334 selector: func(kind InstrumentKind) (int, bool) {
335 if kind == InstrumentKindObservableCounter {
336 return 4, false
337 }
338 return 0, true
339 },
340 globalLimit: 8,
341 build: func(t *testing.T, meter api.Meter) {
342 obs, err := meter.Int64ObservableCounter(
343 "observable-counter-metric",
344 api.WithInt64Callback(func(_ context.Context, o api.Int64Observer) error {
345 for i := range uniqueAttributesCount {
346 o.Observe(int64(i), api.WithAttributes(attribute.Int("key", i)))
347 }
348 return nil
349 }),
350 )
351 require.NoError(t, err)
352 require.NotNil(t, obs)
353 },
354 wantPoints: 4,
355 },
356 {
357 name: "observable gauge uses observable-gauge-specific limit",
358 selector: func(kind InstrumentKind) (int, bool) {
359 if kind == InstrumentKindObservableGauge {
360 return 5, false
361 }
362 return 0, true
363 },
364 globalLimit: 8,
365 build: func(t *testing.T, meter api.Meter) {
366 obs, err := meter.Int64ObservableGauge(
367 "observable-gauge-metric",
368 api.WithInt64Callback(func(_ context.Context, o api.Int64Observer) error {
369 for i := range uniqueAttributesCount {
370 o.Observe(int64(i), api.WithAttributes(attribute.Int("key", i)))
371 }
372 return nil
373 }),
374 )
375 require.NoError(t, err)
376 require.NotNil(t, obs)
377 },
378 wantPoints: 5,
379 },
380 {
381 name: "observable up down counter uses limit",
382 selector: func(kind InstrumentKind) (int, bool) {
383 if kind == InstrumentKindObservableUpDownCounter {
384 return 3, false
385 }
386 return 0, true
387 },
388 globalLimit: 8,
389 build: func(t *testing.T, meter api.Meter) {
390 obs, err := meter.Int64ObservableUpDownCounter(
391 "observable-updowncounter-metric",
392 api.WithInt64Callback(func(_ context.Context, o api.Int64Observer) error {
393 for i := range uniqueAttributesCount {
394 o.Observe(int64(i), api.WithAttributes(attribute.Int("key", i)))
395 }
396 return nil
397 }),
398 )
399 require.NoError(t, err)
400 require.NotNil(t, obs)
401 },
402 wantPoints: 3,
403 },
404 {
405 name: "instrument without specific limit falls back to global limit",
406 selector: func(kind InstrumentKind) (int, bool) {
407 if kind == InstrumentKindCounter {
408 return 3, false
409 }
410 return 0, true // fall back to global limit for other kinds
411 },
412 globalLimit: 6,
413 build: func(t *testing.T, meter api.Meter) {
414 histogram, err := meter.Int64Histogram("histogram-metric")
415 require.NoError(t, err)
416 for i := range uniqueAttributesCount {
417 histogram.Record(t.Context(), int64(i), api.WithAttributes(attribute.Int("key", i)))
418 }
419 },
420 wantPoints: 6,
421 },
422 {
423 name: "selector can set specific kind to unlimited while global limit is nonzero (limited)",
424 selector: func(kind InstrumentKind) (int, bool) {
425 if kind == InstrumentKindCounter {
426 return 0, false // unlimited for counter only
427 }
428 return 0, true // fallback to global limit
429 },
430 globalLimit: 3,
431 build: func(t *testing.T, meter api.Meter) {
432 counter, err := meter.Int64Counter("counter-metric")
433 require.NoError(t, err)
434 for i := range uniqueAttributesCount {
435 counter.Add(t.Context(), 1, api.WithAttributes(attribute.Int("key", i)))
436 }
437 },
438 wantPoints: uniqueAttributesCount,
439 },
440 }
441
442 for _, tc := range testCases {
443 t.Run(tc.name, func(t *testing.T) {
444 reader := NewManualReader(
445 WithCardinalityLimitSelector(tc.selector),
446 )
447 mp := NewMeterProvider(
448 WithReader(reader),
449 WithCardinalityLimit(tc.globalLimit),
450 )
451
452 meter := mp.Meter("test-meter")
453 tc.build(t, meter)
454
455 var rm metricdata.ResourceMetrics
456 err := reader.Collect(t.Context(), &rm)
457 require.NoError(t, err)
458
459 require.Len(t, rm.ScopeMetrics, 1)
460 require.Len(t, rm.ScopeMetrics[0].Metrics, 1)
461
462 switch data := rm.ScopeMetrics[0].Metrics[0].Data.(type) {
463 case metricdata.Sum[int64]:
464 assert.Len(t, data.DataPoints, tc.wantPoints, tc.name)
465 case metricdata.Histogram[int64]:
466 assert.Len(t, data.DataPoints, tc.wantPoints, tc.name)
467 case metricdata.Gauge[int64]:
468 assert.Len(t, data.DataPoints, tc.wantPoints, tc.name)
469 default:
470 t.Fatalf("unexpected data type %T", data)
471 }
472 })
473 }
474 }