Debian Codegraph @

sdk/metric/meter_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 "encoding/json"
9 "errors"
10 "fmt"
11 "strings"
12 "sync"
13 "testing"
14
15 "github.com/go-logr/logr"
16 "github.com/go-logr/logr/funcr"
17 "github.com/go-logr/logr/testr"
18 "github.com/stretchr/testify/assert"
19 "github.com/stretchr/testify/require"
20
21 "go.opentelemetry.io/otel"
22 "go.opentelemetry.io/otel/attribute"
23 "go.opentelemetry.io/otel/internal/global"
24 "go.opentelemetry.io/otel/metric"
25 "go.opentelemetry.io/otel/sdk/instrumentation"
26 "go.opentelemetry.io/otel/sdk/metric/exemplar"
27 "go.opentelemetry.io/otel/sdk/metric/metricdata"
28 "go.opentelemetry.io/otel/sdk/metric/metricdata/metricdatatest"
29 "go.opentelemetry.io/otel/sdk/resource"
30 )
31
32 // A meter should be able to make instruments concurrently.
33 func TestMeterInstrumentConcurrentSafe(*testing.T) {
34 wg := &sync.WaitGroup{}
35 wg.Add(12)
36
37 m := NewMeterProvider().Meter("inst-concurrency")
38
39 go func() {
40 _, _ = m.Float64ObservableCounter("AFCounter")
41 wg.Done()
42 }()
43 go func() {
44 _, _ = m.Float64ObservableUpDownCounter("AFUpDownCounter")
45 wg.Done()
46 }()
47 go func() {
48 _, _ = m.Float64ObservableGauge("AFGauge")
49 wg.Done()
50 }()
51 go func() {
52 _, _ = m.Int64ObservableCounter("AICounter")
53 wg.Done()
54 }()
55 go func() {
56 _, _ = m.Int64ObservableUpDownCounter("AIUpDownCounter")
57 wg.Done()
58 }()
59 go func() {
60 _, _ = m.Int64ObservableGauge("AIGauge")
61 wg.Done()
62 }()
63 go func() {
64 _, _ = m.Float64Counter("SFCounter")
65 wg.Done()
66 }()
67 go func() {
68 _, _ = m.Float64UpDownCounter("SFUpDownCounter")
69 wg.Done()
70 }()
71 go func() {
72 _, _ = m.Float64Histogram("SFHistogram")
73 wg.Done()
74 }()
75 go func() {
76 _, _ = m.Int64Counter("SICounter")
77 wg.Done()
78 }()
79 go func() {
80 _, _ = m.Int64UpDownCounter("SIUpDownCounter")
81 wg.Done()
82 }()
83 go func() {
84 _, _ = m.Int64Histogram("SIHistogram")
85 wg.Done()
86 }()
87
88 wg.Wait()
89 }
90
91 var emptyCallback metric.Callback = func(context.Context, metric.Observer) error { return nil }
92
93 // A Meter Should be able register Callbacks Concurrently.
94 func TestMeterCallbackCreationConcurrency(*testing.T) {
95 wg := &sync.WaitGroup{}
96 wg.Add(2)
97
98 m := NewMeterProvider().Meter("callback-concurrency")
99
100 go func() {
101 _, _ = m.RegisterCallback(emptyCallback)
102 wg.Done()
103 }()
104 go func() {
105 _, _ = m.RegisterCallback(emptyCallback)
106 wg.Done()
107 }()
108 wg.Wait()
109 }
110
111 func TestNoopCallbackUnregisterConcurrency(t *testing.T) {
112 m := NewMeterProvider().Meter("noop-unregister-concurrency")
113 reg, err := m.RegisterCallback(emptyCallback)
114 require.NoError(t, err)
115
116 wg := &sync.WaitGroup{}
117 wg.Add(2)
118 go func() {
119 _ = reg.Unregister()
120 wg.Done()
121 }()
122 go func() {
123 _ = reg.Unregister()
124 wg.Done()
125 }()
126 wg.Wait()
127 }
128
129 func TestCallbackUnregisterConcurrency(t *testing.T) {
130 reader := NewManualReader()
131 provider := NewMeterProvider(WithReader(reader))
132 meter := provider.Meter("unregister-concurrency")
133
134 actr, err := meter.Float64ObservableCounter("counter")
135 require.NoError(t, err)
136
137 ag, err := meter.Int64ObservableGauge("gauge")
138 require.NoError(t, err)
139
140 regCtr, err := meter.RegisterCallback(emptyCallback, actr)
141 require.NoError(t, err)
142
143 regG, err := meter.RegisterCallback(emptyCallback, ag)
144 require.NoError(t, err)
145
146 wg := &sync.WaitGroup{}
147 wg.Add(2)
148 go func() {
149 _ = regCtr.Unregister()
150 _ = regG.Unregister()
151 wg.Done()
152 }()
153 go func() {
154 _ = regCtr.Unregister()
155 _ = regG.Unregister()
156 wg.Done()
157 }()
158 wg.Wait()
159 }
160
161 // Instruments should produce correct ResourceMetrics.
162 func TestMeterCreatesInstruments(t *testing.T) {
163 // The synchronous measurement methods must ignore the context cancellation.
164 ctx, cancel := context.WithCancel(t.Context())
165 cancel()
166
167 alice := attribute.NewSet(
168 attribute.String("name", "Alice"),
169 attribute.Bool("admin", true),
170 )
171 optAlice := metric.WithAttributeSet(alice)
172
173 bob := attribute.NewSet(
174 attribute.String("name", "Bob"),
175 attribute.Bool("admin", false),
176 )
177 optBob := metric.WithAttributeSet(bob)
178
179 testCases := []struct {
180 name string
181 fn func(*testing.T, metric.Meter)
182 want metricdata.Metrics
183 }{
184 {
185 name: "ObservableInt64Count",
186 fn: func(t *testing.T, m metric.Meter) {
187 ctr, err := m.Int64ObservableCounter(
188 "aint",
189 metric.WithInt64Callback(func(_ context.Context, o metric.Int64Observer) error {
190 o.Observe(4, optAlice)
191 return nil
192 }),
193 metric.WithInt64Callback(func(_ context.Context, o metric.Int64Observer) error {
194 o.Observe(5, optBob)
195 return nil
196 }),
197 )
198 assert.NoError(t, err)
199 _, err = m.RegisterCallback(func(_ context.Context, o metric.Observer) error {
200 o.ObserveInt64(ctr, 3)
201 return nil
202 }, ctr)
203 assert.NoError(t, err)
204 },
205 want: metricdata.Metrics{
206 Name: "aint",
207 Data: metricdata.Sum[int64]{
208 Temporality: metricdata.CumulativeTemporality,
209 IsMonotonic: true,
210 DataPoints: []metricdata.DataPoint[int64]{
211 {Attributes: alice, Value: 4},
212 {Attributes: bob, Value: 5},
213 {Value: 3},
214 },
215 },
216 },
217 },
218 {
219 name: "ObservableInt64UpDownCount",
220 fn: func(t *testing.T, m metric.Meter) {
221 ctr, err := m.Int64ObservableUpDownCounter(
222 "aint",
223 metric.WithInt64Callback(func(_ context.Context, o metric.Int64Observer) error {
224 o.Observe(4, optAlice)
225 return nil
226 }),
227 metric.WithInt64Callback(func(_ context.Context, o metric.Int64Observer) error {
228 o.Observe(5, optBob)
229 return nil
230 }),
231 )
232 assert.NoError(t, err)
233 _, err = m.RegisterCallback(func(_ context.Context, o metric.Observer) error {
234 o.ObserveInt64(ctr, 11)
235 return nil
236 }, ctr)
237 assert.NoError(t, err)
238 },
239 want: metricdata.Metrics{
240 Name: "aint",
241 Data: metricdata.Sum[int64]{
242 Temporality: metricdata.CumulativeTemporality,
243 IsMonotonic: false,
244 DataPoints: []metricdata.DataPoint[int64]{
245 {Attributes: alice, Value: 4},
246 {Attributes: bob, Value: 5},
247 {Value: 11},
248 },
249 },
250 },
251 },
252 {
253 name: "ObservableInt64Gauge",
254 fn: func(t *testing.T, m metric.Meter) {
255 gauge, err := m.Int64ObservableGauge(
256 "agauge",
257 metric.WithInt64Callback(func(_ context.Context, o metric.Int64Observer) error {
258 o.Observe(4, optAlice)
259 return nil
260 }),
261 metric.WithInt64Callback(func(_ context.Context, o metric.Int64Observer) error {
262 o.Observe(5, optBob)
263 return nil
264 }),
265 )
266 assert.NoError(t, err)
267 _, err = m.RegisterCallback(func(_ context.Context, o metric.Observer) error {
268 o.ObserveInt64(gauge, 11)
269 return nil
270 }, gauge)
271 assert.NoError(t, err)
272 },
273 want: metricdata.Metrics{
274 Name: "agauge",
275 Data: metricdata.Gauge[int64]{
276 DataPoints: []metricdata.DataPoint[int64]{
277 {Attributes: alice, Value: 4},
278 {Attributes: bob, Value: 5},
279 {Value: 11},
280 },
281 },
282 },
283 },
284 {
285 name: "ObservableFloat64Count",
286 fn: func(t *testing.T, m metric.Meter) {
287 ctr, err := m.Float64ObservableCounter(
288 "afloat",
289 metric.WithFloat64Callback(func(_ context.Context, o metric.Float64Observer) error {
290 o.Observe(4, optAlice)
291 return nil
292 }),
293 metric.WithFloat64Callback(func(_ context.Context, o metric.Float64Observer) error {
294 o.Observe(5, optBob)
295 return nil
296 }),
297 )
298 assert.NoError(t, err)
299 _, err = m.RegisterCallback(func(_ context.Context, o metric.Observer) error {
300 o.ObserveFloat64(ctr, 3)
301 return nil
302 }, ctr)
303 assert.NoError(t, err)
304 },
305 want: metricdata.Metrics{
306 Name: "afloat",
307 Data: metricdata.Sum[float64]{
308 Temporality: metricdata.CumulativeTemporality,
309 IsMonotonic: true,
310 DataPoints: []metricdata.DataPoint[float64]{
311 {Attributes: alice, Value: 4},
312 {Attributes: bob, Value: 5},
313 {Value: 3},
314 },
315 },
316 },
317 },
318 {
319 name: "ObservableFloat64UpDownCount",
320 fn: func(t *testing.T, m metric.Meter) {
321 ctr, err := m.Float64ObservableUpDownCounter(
322 "afloat",
323 metric.WithFloat64Callback(func(_ context.Context, o metric.Float64Observer) error {
324 o.Observe(4, optAlice)
325 return nil
326 }),
327 metric.WithFloat64Callback(func(_ context.Context, o metric.Float64Observer) error {
328 o.Observe(5, optBob)
329 return nil
330 }),
331 )
332 assert.NoError(t, err)
333 _, err = m.RegisterCallback(func(_ context.Context, o metric.Observer) error {
334 o.ObserveFloat64(ctr, 11)
335 return nil
336 }, ctr)
337 assert.NoError(t, err)
338 },
339 want: metricdata.Metrics{
340 Name: "afloat",
341 Data: metricdata.Sum[float64]{
342 Temporality: metricdata.CumulativeTemporality,
343 IsMonotonic: false,
344 DataPoints: []metricdata.DataPoint[float64]{
345 {Attributes: alice, Value: 4},
346 {Attributes: bob, Value: 5},
347 {Value: 11},
348 },
349 },
350 },
351 },
352 {
353 name: "ObservableFloat64Gauge",
354 fn: func(t *testing.T, m metric.Meter) {
355 gauge, err := m.Float64ObservableGauge(
356 "agauge",
357 metric.WithFloat64Callback(func(_ context.Context, o metric.Float64Observer) error {
358 o.Observe(4, optAlice)
359 return nil
360 }),
361 metric.WithFloat64Callback(func(_ context.Context, o metric.Float64Observer) error {
362 o.Observe(5, optBob)
363 return nil
364 }),
365 )
366 assert.NoError(t, err)
367 _, err = m.RegisterCallback(func(_ context.Context, o metric.Observer) error {
368 o.ObserveFloat64(gauge, 11)
369 return nil
370 }, gauge)
371 assert.NoError(t, err)
372 },
373 want: metricdata.Metrics{
374 Name: "agauge",
375 Data: metricdata.Gauge[float64]{
376 DataPoints: []metricdata.DataPoint[float64]{
377 {Attributes: alice, Value: 4},
378 {Attributes: bob, Value: 5},
379 {Value: 11},
380 },
381 },
382 },
383 },
384
385 {
386 name: "SyncInt64Count",
387 fn: func(t *testing.T, m metric.Meter) {
388 ctr, err := m.Int64Counter("sint")
389 assert.NoError(t, err)
390
391 assert.True(t, ctr.Enabled(t.Context()))
392 ctr.Add(ctx, 3)
393 },
394 want: metricdata.Metrics{
395 Name: "sint",
396 Data: metricdata.Sum[int64]{
397 Temporality: metricdata.CumulativeTemporality,
398 IsMonotonic: true,
399 DataPoints: []metricdata.DataPoint[int64]{
400 {Value: 3},
401 },
402 },
403 },
404 },
405 {
406 name: "SyncInt64UpDownCount",
407 fn: func(t *testing.T, m metric.Meter) {
408 ctr, err := m.Int64UpDownCounter("sint")
409 assert.NoError(t, err)
410
411 assert.True(t, ctr.Enabled(t.Context()))
412 ctr.Add(ctx, 11)
413 },
414 want: metricdata.Metrics{
415 Name: "sint",
416 Data: metricdata.Sum[int64]{
417 Temporality: metricdata.CumulativeTemporality,
418 IsMonotonic: false,
419 DataPoints: []metricdata.DataPoint[int64]{
420 {Value: 11},
421 },
422 },
423 },
424 },
425 {
426 name: "SyncInt64Histogram",
427 fn: func(t *testing.T, m metric.Meter) {
428 histo, err := m.Int64Histogram("histogram")
429 assert.NoError(t, err)
430
431 histo.Record(ctx, 7)
432 },
433 want: metricdata.Metrics{
434 Name: "histogram",
435 Data: metricdata.Histogram[int64]{
436 Temporality: metricdata.CumulativeTemporality,
437 DataPoints: []metricdata.HistogramDataPoint[int64]{
438 {
439 Attributes: attribute.Set{},
440 Count: 1,
441 Bounds: []float64{
442 0, 5, 10, 25, 50, 75, 100, 250, 500,
443 750, 1000, 2500, 5000, 7500, 10000,
444 },
445 BucketCounts: []uint64{0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
446 Min: metricdata.NewExtrema[int64](7),
447 Max: metricdata.NewExtrema[int64](7),
448 Sum: 7,
449 },
450 },
451 },
452 },
453 },
454 {
455 name: "SyncFloat64Count",
456 fn: func(t *testing.T, m metric.Meter) {
457 ctr, err := m.Float64Counter("sfloat")
458 assert.NoError(t, err)
459
460 assert.True(t, ctr.Enabled(t.Context()))
461 ctr.Add(ctx, 3)
462 },
463 want: metricdata.Metrics{
464 Name: "sfloat",
465 Data: metricdata.Sum[float64]{
466 Temporality: metricdata.CumulativeTemporality,
467 IsMonotonic: true,
468 DataPoints: []metricdata.DataPoint[float64]{
469 {Value: 3},
470 },
471 },
472 },
473 },
474 {
475 name: "SyncFloat64UpDownCount",
476 fn: func(t *testing.T, m metric.Meter) {
477 ctr, err := m.Float64UpDownCounter("sfloat")
478 assert.NoError(t, err)
479
480 assert.True(t, ctr.Enabled(t.Context()))
481 ctr.Add(ctx, 11)
482 },
483 want: metricdata.Metrics{
484 Name: "sfloat",
485 Data: metricdata.Sum[float64]{
486 Temporality: metricdata.CumulativeTemporality,
487 IsMonotonic: false,
488 DataPoints: []metricdata.DataPoint[float64]{
489 {Value: 11},
490 },
491 },
492 },
493 },
494 {
495 name: "SyncFloat64Histogram",
496 fn: func(t *testing.T, m metric.Meter) {
497 histo, err := m.Float64Histogram("histogram")
498 assert.NoError(t, err)
499
500 histo.Record(ctx, 7)
501 },
502 want: metricdata.Metrics{
503 Name: "histogram",
504 Data: metricdata.Histogram[float64]{
505 Temporality: metricdata.CumulativeTemporality,
506 DataPoints: []metricdata.HistogramDataPoint[float64]{
507 {
508 Attributes: attribute.Set{},
509 Count: 1,
510 Bounds: []float64{
511 0, 5, 10, 25, 50, 75, 100, 250, 500,
512 750, 1000, 2500, 5000, 7500, 10000,
513 },
514 BucketCounts: []uint64{0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
515 Min: metricdata.NewExtrema[float64](7.),
516 Max: metricdata.NewExtrema[float64](7.),
517 Sum: 7.0,
518 },
519 },
520 },
521 },
522 },
523 }
524
525 for _, tt := range testCases {
526 t.Run(tt.name, func(t *testing.T) {
527 rdr := NewManualReader()
528 m := NewMeterProvider(WithReader(rdr)).Meter("testInstruments")
529
530 tt.fn(t, m)
531
532 rm := metricdata.ResourceMetrics{}
533 err := rdr.Collect(t.Context(), &rm)
534 assert.NoError(t, err)
535
536 require.Len(t, rm.ScopeMetrics, 1)
537 sm := rm.ScopeMetrics[0]
538 require.Len(t, sm.Metrics, 1)
539 got := sm.Metrics[0]
540 metricdatatest.AssertEqual(t, tt.want, got, metricdatatest.IgnoreTimestamp())
541 })
542 }
543 }
544
545 func TestMeterWithDropView(t *testing.T) {
546 dropView := NewView(
547 Instrument{Name: "*"},
548 Stream{Aggregation: AggregationDrop{}},
549 )
550 m := NewMeterProvider(WithView(dropView)).Meter(t.Name())
551
552 testCases := []struct {
553 name string
554 fn func(*testing.T) (any, error)
555 }{
556 {
557 name: "Int64Counter",
558 fn: func(*testing.T) (any, error) {
559 return m.Int64Counter("sint")
560 },
561 },
562 {
563 name: "Int64UpDownCounter",
564 fn: func(*testing.T) (any, error) {
565 return m.Int64UpDownCounter("sint")
566 },
567 },
568 {
569 name: "Int64Gauge",
570 fn: func(*testing.T) (any, error) {
571 return m.Int64Gauge("sint")
572 },
573 },
574 {
575 name: "Int64Histogram",
576 fn: func(*testing.T) (any, error) {
577 return m.Int64Histogram("histogram")
578 },
579 },
580 {
581 name: "Float64Counter",
582 fn: func(*testing.T) (any, error) {
583 return m.Float64Counter("sfloat")
584 },
585 },
586 {
587 name: "Float64UpDownCounter",
588 fn: func(*testing.T) (any, error) {
589 return m.Float64UpDownCounter("sfloat")
590 },
591 },
592 {
593 name: "Float64Gauge",
594 fn: func(*testing.T) (any, error) {
595 return m.Float64Gauge("sfloat")
596 },
597 },
598 {
599 name: "Float64Histogram",
600 fn: func(*testing.T) (any, error) {
601 return m.Float64Histogram("histogram")
602 },
603 },
604 }
605
606 for _, tt := range testCases {
607 t.Run(tt.name, func(t *testing.T) {
608 got, err := tt.fn(t)
609 require.NoError(t, err)
610 c, ok := got.(interface {
611 Enabled(context.Context) bool
612 })
613 require.True(t, ok)
614 assert.False(t, c.Enabled(t.Context()))
615 })
616 }
617 }
618
619 func TestMeterCreatesInstrumentsValidations(t *testing.T) {
620 testCases := []struct {
621 name string
622 fn func(*testing.T, metric.Meter) error
623
624 wantErr error
625 }{
626 {
627 name: "Int64Counter with no validation issues",
628
629 fn: func(t *testing.T, m metric.Meter) error {
630 i, err := m.Int64Counter("counter")
631 assert.NotNil(t, i)
632 return err
633 },
634 },
635 {
636 name: "Int64Counter with an invalid name",
637
638 fn: func(t *testing.T, m metric.Meter) error {
639 i, err := m.Int64Counter("_")
640 assert.NotNil(t, i)
641 return err
642 },
643
644 wantErr: fmt.Errorf("%w: _: must start with a letter", ErrInstrumentName),
645 },
646 {
647 name: "Int64UpDownCounter with no validation issues",
648
649 fn: func(t *testing.T, m metric.Meter) error {
650 i, err := m.Int64UpDownCounter("upDownCounter")
651 assert.NotNil(t, i)
652 return err
653 },
654 },
655 {
656 name: "Int64UpDownCounter with an invalid name",
657
658 fn: func(t *testing.T, m metric.Meter) error {
659 i, err := m.Int64UpDownCounter("_")
660 assert.NotNil(t, i)
661 return err
662 },
663
664 wantErr: fmt.Errorf("%w: _: must start with a letter", ErrInstrumentName),
665 },
666 {
667 name: "Int64Histogram with no validation issues",
668
669 fn: func(t *testing.T, m metric.Meter) error {
670 i, err := m.Int64Histogram("histogram")
671 assert.NotNil(t, i)
672 return err
673 },
674 },
675 {
676 name: "Int64Histogram with an invalid name",
677
678 fn: func(t *testing.T, m metric.Meter) error {
679 i, err := m.Int64Histogram("_")
680 assert.NotNil(t, i)
681 return err
682 },
683
684 wantErr: fmt.Errorf("%w: _: must start with a letter", ErrInstrumentName),
685 },
686 {
687 name: "Int64Histogram with invalid buckets",
688
689 fn: func(t *testing.T, m metric.Meter) error {
690 i, err := m.Int64Histogram("histogram", metric.WithExplicitBucketBoundaries(-1, 1, -5))
691 assert.NotNil(t, i)
692 return err
693 },
694
695 wantErr: errors.Join(fmt.Errorf("%w: non-monotonic boundaries: %v", errHist, []float64{-1, 1, -5})),
696 },
697 {
698 name: "Int64ObservableCounter with no validation issues",
699
700 fn: func(t *testing.T, m metric.Meter) error {
701 i, err := m.Int64ObservableCounter("aint")
702 assert.NotNil(t, i)
703 return err
704 },
705 },
706 {
707 name: "Int64ObservableCounter with an invalid name",
708
709 fn: func(t *testing.T, m metric.Meter) error {
710 i, err := m.Int64ObservableCounter("_")
711 assert.NotNil(t, i)
712 return err
713 },
714
715 wantErr: fmt.Errorf("%w: _: must start with a letter", ErrInstrumentName),
716 },
717 {
718 name: "Int64ObservableUpDownCounter with no validation issues",
719
720 fn: func(t *testing.T, m metric.Meter) error {
721 i, err := m.Int64ObservableUpDownCounter("aint")
722 assert.NotNil(t, i)
723 return err
724 },
725 },
726 {
727 name: "Int64ObservableUpDownCounter with an invalid name",
728
729 fn: func(t *testing.T, m metric.Meter) error {
730 i, err := m.Int64ObservableUpDownCounter("_")
731 assert.NotNil(t, i)
732 return err
733 },
734
735 wantErr: fmt.Errorf("%w: _: must start with a letter", ErrInstrumentName),
736 },
737 {
738 name: "Int64ObservableGauge with no validation issues",
739
740 fn: func(t *testing.T, m metric.Meter) error {
741 i, err := m.Int64ObservableGauge("aint")
742 assert.NotNil(t, i)
743 return err
744 },
745 },
746 {
747 name: "Int64ObservableGauge with an invalid name",
748
749 fn: func(t *testing.T, m metric.Meter) error {
750 i, err := m.Int64ObservableGauge("_")
751 assert.NotNil(t, i)
752 return err
753 },
754
755 wantErr: fmt.Errorf("%w: _: must start with a letter", ErrInstrumentName),
756 },
757 {
758 name: "Float64Counter with no validation issues",
759
760 fn: func(t *testing.T, m metric.Meter) error {
761 i, err := m.Float64Counter("counter")
762 assert.NotNil(t, i)
763 return err
764 },
765 },
766 {
767 name: "Float64Counter with an invalid name",
768
769 fn: func(t *testing.T, m metric.Meter) error {
770 i, err := m.Float64Counter("_")
771 assert.NotNil(t, i)
772 return err
773 },
774
775 wantErr: fmt.Errorf("%w: _: must start with a letter", ErrInstrumentName),
776 },
777 {
778 name: "Float64UpDownCounter with no validation issues",
779
780 fn: func(t *testing.T, m metric.Meter) error {
781 i, err := m.Int64UpDownCounter("upDownCounter")
782 assert.NotNil(t, i)
783 return err
784 },
785 },
786 {
787 name: "Float64UpDownCounter with an invalid name",
788
789 fn: func(t *testing.T, m metric.Meter) error {
790 i, err := m.Int64UpDownCounter("_")
791 assert.NotNil(t, i)
792 return err
793 },
794
795 wantErr: fmt.Errorf("%w: _: must start with a letter", ErrInstrumentName),
796 },
797 {
798 name: "Float64Histogram with no validation issues",
799
800 fn: func(t *testing.T, m metric.Meter) error {
801 i, err := m.Float64Histogram("histogram")
802 assert.NotNil(t, i)
803 return err
804 },
805 },
806 {
807 name: "Float64Histogram with an invalid name",
808
809 fn: func(t *testing.T, m metric.Meter) error {
810 i, err := m.Float64Histogram("_")
811 assert.NotNil(t, i)
812 return err
813 },
814
815 wantErr: fmt.Errorf("%w: _: must start with a letter", ErrInstrumentName),
816 },
817 {
818 name: "Float64Histogram with invalid buckets",
819
820 fn: func(t *testing.T, m metric.Meter) error {
821 i, err := m.Float64Histogram("histogram", metric.WithExplicitBucketBoundaries(-1, 1, -5))
822 assert.NotNil(t, i)
823 return err
824 },
825
826 wantErr: errors.Join(fmt.Errorf("%w: non-monotonic boundaries: %v", errHist, []float64{-1, 1, -5})),
827 },
828 {
829 name: "Float64ObservableCounter with no validation issues",
830
831 fn: func(t *testing.T, m metric.Meter) error {
832 i, err := m.Float64ObservableCounter("aint")
833 assert.NotNil(t, i)
834 return err
835 },
836 },
837 {
838 name: "Float64ObservableCounter with an invalid name",
839
840 fn: func(t *testing.T, m metric.Meter) error {
841 i, err := m.Int64ObservableCounter("_")
842 assert.NotNil(t, i)
843 return err
844 },
845
846 wantErr: fmt.Errorf("%w: _: must start with a letter", ErrInstrumentName),
847 },
848 {
849 name: "Float64ObservableUpDownCounter with no validation issues",
850
851 fn: func(t *testing.T, m metric.Meter) error {
852 i, err := m.Float64ObservableUpDownCounter("aint")
853 assert.NotNil(t, i)
854 return err
855 },
856 },
857 {
858 name: "Float64ObservableUpDownCounter with an invalid name",
859
860 fn: func(t *testing.T, m metric.Meter) error {
861 i, err := m.Float64ObservableUpDownCounter("_")
862 assert.NotNil(t, i)
863 return err
864 },
865
866 wantErr: fmt.Errorf("%w: _: must start with a letter", ErrInstrumentName),
867 },
868 {
869 name: "Float64ObservableGauge with no validation issues",
870
871 fn: func(t *testing.T, m metric.Meter) error {
872 i, err := m.Float64ObservableGauge("aint")
873 assert.NotNil(t, i)
874 return err
875 },
876 },
877 {
878 name: "Float64ObservableGauge with an invalid name",
879
880 fn: func(t *testing.T, m metric.Meter) error {
881 i, err := m.Float64ObservableGauge("_")
882 assert.NotNil(t, i)
883 return err
884 },
885
886 wantErr: fmt.Errorf("%w: _: must start with a letter", ErrInstrumentName),
887 },
888 }
889
890 for _, tt := range testCases {
891 t.Run(tt.name, func(t *testing.T) {
892 m := NewMeterProvider().Meter("testInstruments")
893 err := tt.fn(t, m)
894 assert.Equal(t, tt.wantErr, err)
895 })
896 }
897 }
898
899 func TestValidateInstrumentName(t *testing.T) {
900 const longName = "longNameOver255characters" +
901 "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" +
902 "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" +
903 "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" +
904 "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
905 testCases := []struct {
906 name string
907
908 wantErr error
909 }{
910 {
911 name: "",
912 wantErr: fmt.Errorf("%w: : is empty", ErrInstrumentName),
913 },
914 {
915 name: "1",
916 wantErr: fmt.Errorf("%w: 1: must start with a letter", ErrInstrumentName),
917 },
918 {
919 name: "a",
920 },
921 {
922 name: "n4me",
923 },
924 {
925 name: "n-me",
926 },
927 {
928 name: "na_e",
929 },
930 {
931 name: "nam.",
932 },
933 {
934 name: "nam/e",
935 },
936 {
937 name: "name!",
938 wantErr: fmt.Errorf("%w: name!: must only contain [A-Za-z0-9_.-/]", ErrInstrumentName),
939 },
940 {
941 name: longName,
942 wantErr: fmt.Errorf("%w: %s: longer than 255 characters", ErrInstrumentName, longName),
943 },
944 }
945
946 for _, tt := range testCases {
947 t.Run(tt.name, func(t *testing.T) {
948 assert.Equal(t, tt.wantErr, validateInstrumentName(tt.name))
949 })
950 }
951 }
952
953 func TestRegisterNonSDKObserverErrors(t *testing.T) {
954 rdr := NewManualReader()
955 mp := NewMeterProvider(WithReader(rdr))
956 meter := mp.Meter("scope")
957
958 type obsrv struct{ metric.Observable }
959 o := obsrv{}
960
961 _, err := meter.RegisterCallback(
962 func(context.Context, metric.Observer) error { return nil },
963 o,
964 )
965 assert.ErrorContains(
966 t,
967 err,
968 "invalid observable: from different implementation",
969 "External instrument registered",
970 )
971 }
972
973 func TestMeterMixingOnRegisterErrors(t *testing.T) {
974 rdr := NewManualReader()
975 mp := NewMeterProvider(WithReader(rdr))
976
977 m1 := mp.Meter("scope1")
978 m2 := mp.Meter("scope2")
979 iCtr, err := m2.Int64ObservableCounter("int64ctr")
980 require.NoError(t, err)
981 fCtr, err := m2.Float64ObservableCounter("float64ctr")
982 require.NoError(t, err)
983 _, err = m1.RegisterCallback(
984 func(context.Context, metric.Observer) error { return nil },
985 iCtr, fCtr,
986 )
987 assert.ErrorContains(
988 t,
989 err,
990 `invalid registration: observable "int64ctr" from Meter "scope2", registered with Meter "scope1"`,
991 "Instrument registered with non-creation Meter",
992 )
993 assert.ErrorContains(
994 t,
995 err,
996 `invalid registration: observable "float64ctr" from Meter "scope2", registered with Meter "scope1"`,
997 "Instrument registered with non-creation Meter",
998 )
999 }
1000
1001 func TestCallbackObserverNonRegistered(t *testing.T) {
1002 rdr := NewManualReader()
1003 mp := NewMeterProvider(WithReader(rdr))
1004
1005 m1 := mp.Meter("scope1")
1006 valid, err := m1.Int64ObservableCounter("ctr")
1007 require.NoError(t, err)
1008
1009 m2 := mp.Meter("scope2")
1010 iCtr, err := m2.Int64ObservableCounter("int64ctr")
1011 require.NoError(t, err)
1012 fCtr, err := m2.Float64ObservableCounter("float64ctr")
1013 require.NoError(t, err)
1014
1015 type int64Obsrv struct{ metric.Int64Observable }
1016 int64Foreign := int64Obsrv{}
1017 type float64Obsrv struct{ metric.Float64Observable }
1018 float64Foreign := float64Obsrv{}
1019
1020 _, err = m1.RegisterCallback(
1021 func(_ context.Context, o metric.Observer) error {
1022 o.ObserveInt64(valid, 1)
1023 o.ObserveInt64(iCtr, 1)
1024 o.ObserveFloat64(fCtr, 1)
1025 o.ObserveInt64(int64Foreign, 1)
1026 o.ObserveFloat64(float64Foreign, 1)
1027 return nil
1028 },
1029 valid,
1030 )
1031 require.NoError(t, err)
1032
1033 var got metricdata.ResourceMetrics
1034 assert.NotPanics(t, func() {
1035 err = rdr.Collect(t.Context(), &got)
1036 })
1037
1038 assert.NoError(t, err)
1039 want := metricdata.ResourceMetrics{
1040 Resource: resource.Default(),
1041 ScopeMetrics: []metricdata.ScopeMetrics{
1042 {
1043 Scope: instrumentation.Scope{
1044 Name: "scope1",
1045 },
1046 Metrics: []metricdata.Metrics{
1047 {
1048 Name: "ctr",
1049 Data: metricdata.Sum[int64]{
1050 Temporality: metricdata.CumulativeTemporality,
1051 IsMonotonic: true,
1052 DataPoints: []metricdata.DataPoint[int64]{
1053 {
1054 Value: 1,
1055 },
1056 },
1057 },
1058 },
1059 },
1060 },
1061 },
1062 }
1063 metricdatatest.AssertEqual(t, want, got, metricdatatest.IgnoreTimestamp())
1064 }
1065
1066 type logSink struct {
1067 logr.LogSink
1068
1069 messages []string
1070 }
1071
1072 func newLogSink(t *testing.T) *logSink {
1073 return &logSink{LogSink: testr.New(t).GetSink()}
1074 }
1075
1076 func (l *logSink) Info(level int, msg string, keysAndValues ...any) {
1077 l.messages = append(l.messages, msg)
1078 l.LogSink.Info(level, msg, keysAndValues...)
1079 }
1080
1081 func (l *logSink) Error(err error, msg string, keysAndValues ...any) {
1082 l.messages = append(l.messages, fmt.Sprintf("%s: %s", err, msg))
1083 l.LogSink.Error(err, msg, keysAndValues...)
1084 }
1085
1086 func (l *logSink) String() string {
1087 out := make([]string, len(l.messages))
1088 for i := range l.messages {
1089 out[i] = "\t-" + l.messages[i]
1090 }
1091 return strings.Join(out, "\n")
1092 }
1093
1094 func TestGlobalInstRegisterCallback(t *testing.T) {
1095 l := newLogSink(t)
1096 otel.SetLogger(logr.New(l))
1097
1098 const mtrName = "TestGlobalInstRegisterCallback"
1099 preMtr := otel.Meter(mtrName)
1100 preInt64Ctr, err := preMtr.Int64ObservableCounter("pre.int64.counter")
1101 require.NoError(t, err)
1102 preFloat64Ctr, err := preMtr.Float64ObservableCounter("pre.float64.counter")
1103 require.NoError(t, err)
1104
1105 rdr := NewManualReader()
1106 mp := NewMeterProvider(WithReader(rdr), WithResource(resource.Empty()))
1107 otel.SetMeterProvider(mp)
1108
1109 postMtr := otel.Meter(mtrName)
1110 postInt64Ctr, err := postMtr.Int64ObservableCounter("post.int64.counter")
1111 require.NoError(t, err)
1112 postFloat64Ctr, err := postMtr.Float64ObservableCounter("post.float64.counter")
1113 require.NoError(t, err)
1114
1115 cb := func(_ context.Context, o metric.Observer) error {
1116 o.ObserveInt64(preInt64Ctr, 1)
1117 o.ObserveFloat64(preFloat64Ctr, 2)
1118 o.ObserveInt64(postInt64Ctr, 3)
1119 o.ObserveFloat64(postFloat64Ctr, 4)
1120 return nil
1121 }
1122
1123 _, err = preMtr.RegisterCallback(cb, preInt64Ctr, preFloat64Ctr, postInt64Ctr, postFloat64Ctr)
1124 assert.NoError(t, err)
1125
1126 got := metricdata.ResourceMetrics{}
1127 err = rdr.Collect(t.Context(), &got)
1128 assert.NoError(t, err)
1129 assert.Emptyf(t, l.messages, "Warnings and errors logged:\n%s", l)
1130 metricdatatest.AssertEqual(t, metricdata.ResourceMetrics{
1131 ScopeMetrics: []metricdata.ScopeMetrics{
1132 {
1133 Scope: instrumentation.Scope{Name: "TestGlobalInstRegisterCallback"},
1134 Metrics: []metricdata.Metrics{
1135 {
1136 Name: "pre.int64.counter",
1137 Data: metricdata.Sum[int64]{
1138 Temporality: metricdata.CumulativeTemporality,
1139 IsMonotonic: true,
1140 DataPoints: []metricdata.DataPoint[int64]{{Value: 1}},
1141 },
1142 },
1143 {
1144 Name: "pre.float64.counter",
1145 Data: metricdata.Sum[float64]{
1146 DataPoints: []metricdata.DataPoint[float64]{{Value: 2}},
1147 Temporality: metricdata.CumulativeTemporality,
1148 IsMonotonic: true,
1149 },
1150 },
1151 {
1152 Name: "post.int64.counter",
1153 Data: metricdata.Sum[int64]{
1154 Temporality: metricdata.CumulativeTemporality,
1155 IsMonotonic: true,
1156 DataPoints: []metricdata.DataPoint[int64]{{Value: 3}},
1157 },
1158 },
1159 {
1160 Name: "post.float64.counter",
1161 Data: metricdata.Sum[float64]{
1162 DataPoints: []metricdata.DataPoint[float64]{{Value: 4}},
1163 Temporality: metricdata.CumulativeTemporality,
1164 IsMonotonic: true,
1165 },
1166 },
1167 },
1168 },
1169 },
1170 }, got, metricdatatest.IgnoreTimestamp())
1171 }
1172
1173 func TestMetersProvideScope(t *testing.T) {
1174 rdr := NewManualReader()
1175 mp := NewMeterProvider(WithReader(rdr))
1176
1177 m1 := mp.Meter("scope1")
1178 ctr1, err := m1.Float64ObservableCounter("ctr1")
1179 assert.NoError(t, err)
1180 _, err = m1.RegisterCallback(func(_ context.Context, o metric.Observer) error {
1181 o.ObserveFloat64(ctr1, 5)
1182 return nil
1183 }, ctr1)
1184 assert.NoError(t, err)
1185
1186 m2 := mp.Meter("scope2")
1187 ctr2, err := m2.Int64ObservableCounter("ctr2")
1188 assert.NoError(t, err)
1189 _, err = m2.RegisterCallback(func(_ context.Context, o metric.Observer) error {
1190 o.ObserveInt64(ctr2, 7)
1191 return nil
1192 }, ctr2)
1193 assert.NoError(t, err)
1194
1195 want := metricdata.ResourceMetrics{
1196 Resource: resource.Default(),
1197 ScopeMetrics: []metricdata.ScopeMetrics{
1198 {
1199 Scope: instrumentation.Scope{
1200 Name: "scope1",
1201 },
1202 Metrics: []metricdata.Metrics{
1203 {
1204 Name: "ctr1",
1205 Data: metricdata.Sum[float64]{
1206 Temporality: metricdata.CumulativeTemporality,
1207 IsMonotonic: true,
1208 DataPoints: []metricdata.DataPoint[float64]{
1209 {
1210 Value: 5,
1211 },
1212 },
1213 },
1214 },
1215 },
1216 },
1217 {
1218 Scope: instrumentation.Scope{
1219 Name: "scope2",
1220 },
1221 Metrics: []metricdata.Metrics{
1222 {
1223 Name: "ctr2",
1224 Data: metricdata.Sum[int64]{
1225 Temporality: metricdata.CumulativeTemporality,
1226 IsMonotonic: true,
1227 DataPoints: []metricdata.DataPoint[int64]{
1228 {
1229 Value: 7,
1230 },
1231 },
1232 },
1233 },
1234 },
1235 },
1236 },
1237 }
1238
1239 got := metricdata.ResourceMetrics{}
1240 err = rdr.Collect(t.Context(), &got)
1241 assert.NoError(t, err)
1242 metricdatatest.AssertEqual(t, want, got, metricdatatest.IgnoreTimestamp())
1243 }
1244
1245 func TestUnregisterUnregisters(t *testing.T) {
1246 r := NewManualReader()
1247 mp := NewMeterProvider(WithReader(r))
1248 m := mp.Meter("TestUnregisterUnregisters")
1249
1250 int64Counter, err := m.Int64ObservableCounter("int64.counter")
1251 require.NoError(t, err)
1252
1253 int64UpDownCounter, err := m.Int64ObservableUpDownCounter("int64.up_down_counter")
1254 require.NoError(t, err)
1255
1256 int64Gauge, err := m.Int64ObservableGauge("int64.gauge")
1257 require.NoError(t, err)
1258
1259 float64Counter, err := m.Float64ObservableCounter("float64.counter")
1260 require.NoError(t, err)
1261
1262 float64UpDownCounter, err := m.Float64ObservableUpDownCounter("float64.up_down_counter")
1263 require.NoError(t, err)
1264
1265 float64Gauge, err := m.Float64ObservableGauge("float64.gauge")
1266 require.NoError(t, err)
1267
1268 var called bool
1269 reg, err := m.RegisterCallback(
1270 func(context.Context, metric.Observer) error {
1271 called = true
1272 return nil
1273 },
1274 int64Counter,
1275 int64UpDownCounter,
1276 int64Gauge,
1277 float64Counter,
1278 float64UpDownCounter,
1279 float64Gauge,
1280 )
1281 require.NoError(t, err)
1282
1283 ctx := t.Context()
1284 err = r.Collect(ctx, &metricdata.ResourceMetrics{})
1285 require.NoError(t, err)
1286 assert.True(t, called, "callback not called for registered callback")
1287
1288 called = false
1289 require.NoError(t, reg.Unregister(), "unregister")
1290
1291 err = r.Collect(ctx, &metricdata.ResourceMetrics{})
1292 require.NoError(t, err)
1293 assert.False(t, called, "callback called for unregistered callback")
1294 }
1295
1296 func TestRegisterCallbackDropAggregations(t *testing.T) {
1297 aggFn := func(InstrumentKind) Aggregation {
1298 return AggregationDrop{}
1299 }
1300 r := NewManualReader(WithAggregationSelector(aggFn))
1301 mp := NewMeterProvider(WithReader(r))
1302 m := mp.Meter("testRegisterCallbackDropAggregations")
1303
1304 int64Counter, err := m.Int64ObservableCounter("int64.counter")
1305 require.NoError(t, err)
1306
1307 int64UpDownCounter, err := m.Int64ObservableUpDownCounter("int64.up_down_counter")
1308 require.NoError(t, err)
1309
1310 int64Gauge, err := m.Int64ObservableGauge("int64.gauge")
1311 require.NoError(t, err)
1312
1313 float64Counter, err := m.Float64ObservableCounter("float64.counter")
1314 require.NoError(t, err)
1315
1316 float64UpDownCounter, err := m.Float64ObservableUpDownCounter("float64.up_down_counter")
1317 require.NoError(t, err)
1318
1319 float64Gauge, err := m.Float64ObservableGauge("float64.gauge")
1320 require.NoError(t, err)
1321
1322 var called bool
1323 _, err = m.RegisterCallback(
1324 func(context.Context, metric.Observer) error {
1325 called = true
1326 return nil
1327 },
1328 int64Counter,
1329 int64UpDownCounter,
1330 int64Gauge,
1331 float64Counter,
1332 float64UpDownCounter,
1333 float64Gauge,
1334 )
1335 require.NoError(t, err)
1336
1337 data := metricdata.ResourceMetrics{}
1338 err = r.Collect(t.Context(), &data)
1339 require.NoError(t, err)
1340
1341 assert.False(t, called, "callback called for all drop instruments")
1342 assert.Empty(t, data.ScopeMetrics, "metrics exported for drop instruments")
1343 }
1344
1345 func TestAttributeFilter(t *testing.T) {
1346 t.Run("Delta", testAttributeFilter(metricdata.DeltaTemporality))
1347 t.Run("Cumulative", testAttributeFilter(metricdata.CumulativeTemporality))
1348 }
1349
1350 func testAttributeFilter(temporality metricdata.Temporality) func(*testing.T) {
1351 fooBar := attribute.NewSet(attribute.String("foo", "bar"))
1352 withFooBar := metric.WithAttributeSet(fooBar)
1353 v1 := attribute.NewSet(attribute.String("foo", "bar"), attribute.Int("version", 1))
1354 withV1 := metric.WithAttributeSet(v1)
1355 v2 := attribute.NewSet(attribute.String("foo", "bar"), attribute.Int("version", 2))
1356 withV2 := metric.WithAttributeSet(v2)
1357 testcases := []struct {
1358 name string
1359 register func(t *testing.T, mtr metric.Meter) error
1360 wantMetric metricdata.Metrics
1361 }{
1362 {
1363 name: "ObservableFloat64Counter",
1364 register: func(_ *testing.T, mtr metric.Meter) error {
1365 ctr, err := mtr.Float64ObservableCounter("afcounter")
1366 if err != nil {
1367 return err
1368 }
1369 _, err = mtr.RegisterCallback(func(_ context.Context, o metric.Observer) error {
1370 o.ObserveFloat64(ctr, 1.0, withV1)
1371 o.ObserveFloat64(ctr, 2.0, withFooBar)
1372 o.ObserveFloat64(ctr, 1.0, withV2)
1373 return nil
1374 }, ctr)
1375 return err
1376 },
1377 wantMetric: metricdata.Metrics{
1378 Name: "afcounter",
1379 Data: metricdata.Sum[float64]{
1380 DataPoints: []metricdata.DataPoint[float64]{
1381 {Attributes: fooBar, Value: 4.0},
1382 },
1383 Temporality: temporality,
1384 IsMonotonic: true,
1385 },
1386 },
1387 },
1388 {
1389 name: "ObservableFloat64UpDownCounter",
1390 register: func(_ *testing.T, mtr metric.Meter) error {
1391 ctr, err := mtr.Float64ObservableUpDownCounter("afupdowncounter")
1392 if err != nil {
1393 return err
1394 }
1395 _, err = mtr.RegisterCallback(func(_ context.Context, o metric.Observer) error {
1396 o.ObserveFloat64(ctr, 1.0, withV1)
1397 o.ObserveFloat64(ctr, 2.0, withFooBar)
1398 o.ObserveFloat64(ctr, 1.0, withV2)
1399 return nil
1400 }, ctr)
1401 return err
1402 },
1403 wantMetric: metricdata.Metrics{
1404 Name: "afupdowncounter",
1405 Data: metricdata.Sum[float64]{
1406 DataPoints: []metricdata.DataPoint[float64]{
1407 {
1408 Attributes: attribute.NewSet(attribute.String("foo", "bar")),
1409 Value: 4.0,
1410 },
1411 },
1412 Temporality: temporality,
1413 IsMonotonic: false,
1414 },
1415 },
1416 },
1417 {
1418 name: "ObservableFloat64Gauge",
1419 register: func(_ *testing.T, mtr metric.Meter) error {
1420 ctr, err := mtr.Float64ObservableGauge("afgauge")
1421 if err != nil {
1422 return err
1423 }
1424 _, err = mtr.RegisterCallback(func(_ context.Context, o metric.Observer) error {
1425 o.ObserveFloat64(ctr, 1.0, withV1)
1426 o.ObserveFloat64(ctr, 2.0, withV2)
1427 return nil
1428 }, ctr)
1429 return err
1430 },
1431 wantMetric: metricdata.Metrics{
1432 Name: "afgauge",
1433 Data: metricdata.Gauge[float64]{
1434 DataPoints: []metricdata.DataPoint[float64]{
1435 {Attributes: fooBar, Value: 2.0},
1436 },
1437 },
1438 },
1439 },
1440 {
1441 name: "ObservableInt64Counter",
1442 register: func(_ *testing.T, mtr metric.Meter) error {
1443 ctr, err := mtr.Int64ObservableCounter("aicounter")
1444 if err != nil {
1445 return err
1446 }
1447 _, err = mtr.RegisterCallback(func(_ context.Context, o metric.Observer) error {
1448 o.ObserveInt64(ctr, 10, withV1)
1449 o.ObserveInt64(ctr, 20, withFooBar)
1450 o.ObserveInt64(ctr, 10, withV2)
1451 return nil
1452 }, ctr)
1453 return err
1454 },
1455 wantMetric: metricdata.Metrics{
1456 Name: "aicounter",
1457 Data: metricdata.Sum[int64]{
1458 DataPoints: []metricdata.DataPoint[int64]{
1459 {Attributes: fooBar, Value: 40},
1460 },
1461 Temporality: temporality,
1462 IsMonotonic: true,
1463 },
1464 },
1465 },
1466 {
1467 name: "ObservableInt64UpDownCounter",
1468 register: func(_ *testing.T, mtr metric.Meter) error {
1469 ctr, err := mtr.Int64ObservableUpDownCounter("aiupdowncounter")
1470 if err != nil {
1471 return err
1472 }
1473 _, err = mtr.RegisterCallback(func(_ context.Context, o metric.Observer) error {
1474 o.ObserveInt64(ctr, 10, withV1)
1475 o.ObserveInt64(ctr, 20, withFooBar)
1476 o.ObserveInt64(ctr, 10, withV2)
1477 return nil
1478 }, ctr)
1479 return err
1480 },
1481 wantMetric: metricdata.Metrics{
1482 Name: "aiupdowncounter",
1483 Data: metricdata.Sum[int64]{
1484 DataPoints: []metricdata.DataPoint[int64]{
1485 {Attributes: fooBar, Value: 40},
1486 },
1487 Temporality: temporality,
1488 IsMonotonic: false,
1489 },
1490 },
1491 },
1492 {
1493 name: "ObservableInt64Gauge",
1494 register: func(_ *testing.T, mtr metric.Meter) error {
1495 ctr, err := mtr.Int64ObservableGauge("aigauge")
1496 if err != nil {
1497 return err
1498 }
1499 _, err = mtr.RegisterCallback(func(_ context.Context, o metric.Observer) error {
1500 o.ObserveInt64(ctr, 10, withV1)
1501 o.ObserveInt64(ctr, 20, withV2)
1502 return nil
1503 }, ctr)
1504 return err
1505 },
1506 wantMetric: metricdata.Metrics{
1507 Name: "aigauge",
1508 Data: metricdata.Gauge[int64]{
1509 DataPoints: []metricdata.DataPoint[int64]{
1510 {Attributes: fooBar, Value: 20},
1511 },
1512 },
1513 },
1514 },
1515 {
1516 name: "SyncFloat64Counter",
1517 register: func(t *testing.T, mtr metric.Meter) error {
1518 ctr, err := mtr.Float64Counter("sfcounter")
1519 if err != nil {
1520 return err
1521 }
1522
1523 ctr.Add(t.Context(), 1.0, withV1)
1524 ctr.Add(t.Context(), 2.0, withV2)
1525 return nil
1526 },
1527 wantMetric: metricdata.Metrics{
1528 Name: "sfcounter",
1529 Data: metricdata.Sum[float64]{
1530 DataPoints: []metricdata.DataPoint[float64]{
1531 {Attributes: fooBar, Value: 3.0},
1532 },
1533 Temporality: temporality,
1534 IsMonotonic: true,
1535 },
1536 },
1537 },
1538 {
1539 name: "SyncFloat64UpDownCounter",
1540 register: func(t *testing.T, mtr metric.Meter) error {
1541 ctr, err := mtr.Float64UpDownCounter("sfupdowncounter")
1542 if err != nil {
1543 return err
1544 }
1545
1546 ctr.Add(t.Context(), 1.0, withV1)
1547 ctr.Add(t.Context(), 2.0, withV2)
1548 return nil
1549 },
1550 wantMetric: metricdata.Metrics{
1551 Name: "sfupdowncounter",
1552 Data: metricdata.Sum[float64]{
1553 DataPoints: []metricdata.DataPoint[float64]{
1554 {Attributes: fooBar, Value: 3.0},
1555 },
1556 Temporality: temporality,
1557 IsMonotonic: false,
1558 },
1559 },
1560 },
1561 {
1562 name: "SyncFloat64Histogram",
1563 register: func(t *testing.T, mtr metric.Meter) error {
1564 ctr, err := mtr.Float64Histogram("sfhistogram")
1565 if err != nil {
1566 return err
1567 }
1568
1569 ctr.Record(t.Context(), 1.0, withV1)
1570 ctr.Record(t.Context(), 2.0, withV2)
1571 return nil
1572 },
1573 wantMetric: metricdata.Metrics{
1574 Name: "sfhistogram",
1575 Data: metricdata.Histogram[float64]{
1576 DataPoints: []metricdata.HistogramDataPoint[float64]{
1577 {
1578 Attributes: fooBar,
1579 Bounds: []float64{
1580 0, 5, 10, 25, 50, 75, 100, 250, 500,
1581 750, 1000, 2500, 5000, 7500, 10000,
1582 },
1583 BucketCounts: []uint64{0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
1584 Count: 2,
1585 Min: metricdata.NewExtrema(1.),
1586 Max: metricdata.NewExtrema(2.),
1587 Sum: 3.0,
1588 },
1589 },
1590 Temporality: temporality,
1591 },
1592 },
1593 },
1594 {
1595 name: "SyncInt64Counter",
1596 register: func(t *testing.T, mtr metric.Meter) error {
1597 ctr, err := mtr.Int64Counter("sicounter")
1598 if err != nil {
1599 return err
1600 }
1601
1602 ctr.Add(t.Context(), 10, withV1)
1603 ctr.Add(t.Context(), 20, withV2)
1604 return nil
1605 },
1606 wantMetric: metricdata.Metrics{
1607 Name: "sicounter",
1608 Data: metricdata.Sum[int64]{
1609 DataPoints: []metricdata.DataPoint[int64]{
1610 {Attributes: fooBar, Value: 30},
1611 },
1612 Temporality: temporality,
1613 IsMonotonic: true,
1614 },
1615 },
1616 },
1617 {
1618 name: "SyncInt64UpDownCounter",
1619 register: func(t *testing.T, mtr metric.Meter) error {
1620 ctr, err := mtr.Int64UpDownCounter("siupdowncounter")
1621 if err != nil {
1622 return err
1623 }
1624
1625 ctr.Add(t.Context(), 10, withV1)
1626 ctr.Add(t.Context(), 20, withV2)
1627 return nil
1628 },
1629 wantMetric: metricdata.Metrics{
1630 Name: "siupdowncounter",
1631 Data: metricdata.Sum[int64]{
1632 DataPoints: []metricdata.DataPoint[int64]{
1633 {Attributes: fooBar, Value: 30},
1634 },
1635 Temporality: temporality,
1636 IsMonotonic: false,
1637 },
1638 },
1639 },
1640 {
1641 name: "SyncInt64Histogram",
1642 register: func(t *testing.T, mtr metric.Meter) error {
1643 ctr, err := mtr.Int64Histogram("sihistogram")
1644 if err != nil {
1645 return err
1646 }
1647
1648 ctr.Record(t.Context(), 1, withV1)
1649 ctr.Record(t.Context(), 2, withV2)
1650 return nil
1651 },
1652 wantMetric: metricdata.Metrics{
1653 Name: "sihistogram",
1654 Data: metricdata.Histogram[int64]{
1655 DataPoints: []metricdata.HistogramDataPoint[int64]{
1656 {
1657 Attributes: fooBar,
1658 Bounds: []float64{
1659 0, 5, 10, 25, 50, 75, 100, 250, 500,
1660 750, 1000, 2500, 5000, 7500, 10000,
1661 },
1662 BucketCounts: []uint64{0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
1663 Count: 2,
1664 Min: metricdata.NewExtrema[int64](1),
1665 Max: metricdata.NewExtrema[int64](2),
1666 Sum: 3.0,
1667 },
1668 },
1669 Temporality: temporality,
1670 },
1671 },
1672 },
1673 }
1674
1675 return func(t *testing.T) {
1676 for _, tt := range testcases {
1677 t.Run(tt.name, func(t *testing.T) {
1678 rdr := NewManualReader(WithTemporalitySelector(func(InstrumentKind) metricdata.Temporality {
1679 return temporality
1680 }))
1681 mtr := NewMeterProvider(
1682 WithReader(rdr),
1683 WithView(NewView(
1684 Instrument{Name: "*"},
1685 Stream{AttributeFilter: attribute.NewAllowKeysFilter("foo")},
1686 )),
1687 ).Meter("TestAttributeFilter")
1688 require.NoError(t, tt.register(t, mtr))
1689
1690 m := metricdata.ResourceMetrics{}
1691 err := rdr.Collect(t.Context(), &m)
1692 assert.NoError(t, err)
1693
1694 require.Len(t, m.ScopeMetrics, 1)
1695 require.Len(t, m.ScopeMetrics[0].Metrics, 1)
1696
1697 metricdatatest.AssertEqual(
1698 t,
1699 tt.wantMetric,
1700 m.ScopeMetrics[0].Metrics[0],
1701 metricdatatest.IgnoreTimestamp(),
1702 )
1703 })
1704 }
1705 }
1706 }
1707
1708 func TestObservableExample(t *testing.T) {
1709 // This example can be found:
1710 // https://github.com/open-telemetry/opentelemetry-specification/blob/v1.20.0/specification/metrics/supplementary-guidelines.md#asynchronous-example
1711 var (
1712 threadID1 = attribute.Int("tid", 1)
1713 threadID2 = attribute.Int("tid", 2)
1714 threadID3 = attribute.Int("tid", 3)
1715
1716 processID1001 = attribute.String("pid", "1001")
1717
1718 thread1 = attribute.NewSet(processID1001, threadID1)
1719 thread2 = attribute.NewSet(processID1001, threadID2)
1720 thread3 = attribute.NewSet(processID1001, threadID3)
1721
1722 process1001 = attribute.NewSet(processID1001)
1723 )
1724
1725 type observation struct {
1726 attrs attribute.Set
1727 value int64
1728 }
1729
1730 setup := func(t *testing.T, temp metricdata.Temporality) (map[attribute.Distinct]observation, func(*testing.T), *metricdata.ScopeMetrics, *int64, *int64, *int64) {
1731 t.Helper()
1732
1733 const (
1734 instName = "pageFaults"
1735 filteredStream = "filteredPageFaults"
1736 scopeName = "ObservableExample"
1737 )
1738
1739 selector := func(InstrumentKind) metricdata.Temporality { return temp }
1740 reader1 := NewManualReader(WithTemporalitySelector(selector))
1741 reader2 := NewManualReader(WithTemporalitySelector(selector))
1742
1743 allowAll := attribute.NewDenyKeysFilter()
1744 noFiltered := NewView(Instrument{Name: instName}, Stream{Name: instName, AttributeFilter: allowAll})
1745
1746 filter := attribute.NewDenyKeysFilter("tid")
1747 filtered := NewView(Instrument{Name: instName}, Stream{Name: filteredStream, AttributeFilter: filter})
1748
1749 mp := NewMeterProvider(WithReader(reader1), WithReader(reader2), WithView(noFiltered, filtered))
1750 meter := mp.Meter(scopeName)
1751
1752 observations := make(map[attribute.Distinct]observation)
1753 _, err := meter.Int64ObservableCounter(instName, metric.WithInt64Callback(
1754 func(_ context.Context, o metric.Int64Observer) error {
1755 for _, val := range observations {
1756 o.Observe(val.value, metric.WithAttributeSet(val.attrs))
1757 }
1758 return nil
1759 },
1760 ))
1761 require.NoError(t, err)
1762
1763 want := &metricdata.ScopeMetrics{
1764 Scope: instrumentation.Scope{Name: scopeName},
1765 Metrics: []metricdata.Metrics{
1766 {
1767 Name: filteredStream,
1768 Data: metricdata.Sum[int64]{
1769 Temporality: temp,
1770 IsMonotonic: true,
1771 DataPoints: []metricdata.DataPoint[int64]{
1772 {Attributes: process1001},
1773 },
1774 },
1775 },
1776 {
1777 Name: instName,
1778 Data: metricdata.Sum[int64]{
1779 Temporality: temp,
1780 IsMonotonic: true,
1781 DataPoints: []metricdata.DataPoint[int64]{
1782 {Attributes: thread1},
1783 {Attributes: thread2},
1784 },
1785 },
1786 },
1787 },
1788 }
1789 wantFiltered := &want.Metrics[0].Data.(metricdata.Sum[int64]).DataPoints[0].Value
1790 wantThread1 := &want.Metrics[1].Data.(metricdata.Sum[int64]).DataPoints[0].Value
1791 wantThread2 := &want.Metrics[1].Data.(metricdata.Sum[int64]).DataPoints[1].Value
1792
1793 collect := func(t *testing.T) {
1794 t.Helper()
1795 got := metricdata.ResourceMetrics{}
1796 err := reader1.Collect(t.Context(), &got)
1797 require.NoError(t, err)
1798 require.Len(t, got.ScopeMetrics, 1)
1799 metricdatatest.AssertEqual(t, *want, got.ScopeMetrics[0], metricdatatest.IgnoreTimestamp())
1800
1801 got = metricdata.ResourceMetrics{}
1802 err = reader2.Collect(t.Context(), &got)
1803 require.NoError(t, err)
1804 require.Len(t, got.ScopeMetrics, 1)
1805 metricdatatest.AssertEqual(t, *want, got.ScopeMetrics[0], metricdatatest.IgnoreTimestamp())
1806 }
1807
1808 return observations, collect, want, wantFiltered, wantThread1, wantThread2
1809 }
1810
1811 t.Run("Cumulative", func(t *testing.T) {
1812 temporality := metricdata.CumulativeTemporality
1813 observations, verify, want, wantFiltered, wantThread1, wantThread2 := setup(t, temporality)
1814
1815 // During the time range (T0, T1]:
1816 // pid = 1001, tid = 1, #PF = 50
1817 // pid = 1001, tid = 2, #PF = 30
1818 observations[thread1.Equivalent()] = observation{attrs: thread1, value: 50}
1819 observations[thread2.Equivalent()] = observation{attrs: thread2, value: 30}
1820
1821 *wantFiltered = 80
1822 *wantThread1 = 50
1823 *wantThread2 = 30
1824
1825 verify(t)
1826
1827 // During the time range (T1, T2]:
1828 // pid = 1001, tid = 1, #PF = 53
1829 // pid = 1001, tid = 2, #PF = 38
1830 observations[thread1.Equivalent()] = observation{attrs: thread1, value: 53}
1831 observations[thread2.Equivalent()] = observation{attrs: thread2, value: 38}
1832
1833 *wantFiltered = 91
1834 *wantThread1 = 53
1835 *wantThread2 = 38
1836
1837 verify(t)
1838
1839 // During the time range (T2, T3]
1840 // pid = 1001, tid = 1, #PF = 56
1841 // pid = 1001, tid = 2, #PF = 42
1842 observations[thread1.Equivalent()] = observation{attrs: thread1, value: 56}
1843 observations[thread2.Equivalent()] = observation{attrs: thread2, value: 42}
1844
1845 *wantFiltered = 98
1846 *wantThread1 = 56
1847 *wantThread2 = 42
1848
1849 verify(t)
1850
1851 // During the time range (T3, T4]:
1852 // pid = 1001, tid = 1, #PF = 60
1853 // pid = 1001, tid = 2, #PF = 47
1854 observations[thread1.Equivalent()] = observation{attrs: thread1, value: 60}
1855 observations[thread2.Equivalent()] = observation{attrs: thread2, value: 47}
1856
1857 *wantFiltered = 107
1858 *wantThread1 = 60
1859 *wantThread2 = 47
1860
1861 verify(t)
1862
1863 // During the time range (T4, T5]:
1864 // thread 1 died, thread 3 started
1865 // pid = 1001, tid = 2, #PF = 53
1866 // pid = 1001, tid = 3, #PF = 5
1867 delete(observations, thread1.Equivalent())
1868 observations[thread2.Equivalent()] = observation{attrs: thread2, value: 53}
1869 observations[thread3.Equivalent()] = observation{attrs: thread3, value: 5}
1870
1871 *wantFiltered = 58
1872 want.Metrics[1].Data = metricdata.Sum[int64]{
1873 Temporality: temporality,
1874 IsMonotonic: true,
1875 DataPoints: []metricdata.DataPoint[int64]{
1876 // Thread 1 is no longer exported.
1877 {Attributes: thread2, Value: 53},
1878 {Attributes: thread3, Value: 5},
1879 },
1880 }
1881
1882 verify(t)
1883 })
1884
1885 t.Run("Delta", func(t *testing.T) {
1886 temporality := metricdata.DeltaTemporality
1887 observations, verify, want, wantFiltered, wantThread1, wantThread2 := setup(t, temporality)
1888
1889 // During the time range (T0, T1]:
1890 // pid = 1001, tid = 1, #PF = 50
1891 // pid = 1001, tid = 2, #PF = 30
1892 observations[thread1.Equivalent()] = observation{attrs: thread1, value: 50}
1893 observations[thread2.Equivalent()] = observation{attrs: thread2, value: 30}
1894
1895 *wantFiltered = 80
1896 *wantThread1 = 50
1897 *wantThread2 = 30
1898
1899 verify(t)
1900
1901 // During the time range (T1, T2]:
1902 // pid = 1001, tid = 1, #PF = 53
1903 // pid = 1001, tid = 2, #PF = 38
1904 observations[thread1.Equivalent()] = observation{attrs: thread1, value: 53}
1905 observations[thread2.Equivalent()] = observation{attrs: thread2, value: 38}
1906
1907 *wantFiltered = 11
1908 *wantThread1 = 3
1909 *wantThread2 = 8
1910
1911 verify(t)
1912
1913 // During the time range (T2, T3]
1914 // pid = 1001, tid = 1, #PF = 56
1915 // pid = 1001, tid = 2, #PF = 42
1916 observations[thread1.Equivalent()] = observation{attrs: thread1, value: 56}
1917 observations[thread2.Equivalent()] = observation{attrs: thread2, value: 42}
1918
1919 *wantFiltered = 7
1920 *wantThread1 = 3
1921 *wantThread2 = 4
1922
1923 verify(t)
1924
1925 // During the time range (T3, T4]:
1926 // pid = 1001, tid = 1, #PF = 60
1927 // pid = 1001, tid = 2, #PF = 47
1928 observations[thread1.Equivalent()] = observation{attrs: thread1, value: 60}
1929 observations[thread2.Equivalent()] = observation{attrs: thread2, value: 47}
1930
1931 *wantFiltered = 9
1932 *wantThread1 = 4
1933 *wantThread2 = 5
1934
1935 verify(t)
1936
1937 // During the time range (T4, T5]:
1938 // thread 1 died, thread 3 started
1939 // pid = 1001, tid = 2, #PF = 53
1940 // pid = 1001, tid = 3, #PF = 5
1941 delete(observations, thread1.Equivalent())
1942 observations[thread2.Equivalent()] = observation{attrs: thread2, value: 53}
1943 observations[thread3.Equivalent()] = observation{attrs: thread3, value: 5}
1944
1945 *wantFiltered = -49
1946 want.Metrics[1].Data = metricdata.Sum[int64]{
1947 Temporality: temporality,
1948 IsMonotonic: true,
1949 DataPoints: []metricdata.DataPoint[int64]{
1950 // Thread 1 is no longer exported.
1951 {Attributes: thread2, Value: 6},
1952 {Attributes: thread3, Value: 5},
1953 },
1954 }
1955
1956 verify(t)
1957 })
1958 }
1959
1960 var (
1961 aiCounter metric.Int64ObservableCounter
1962 aiUpDownCounter metric.Int64ObservableUpDownCounter
1963 aiGauge metric.Int64ObservableGauge
1964
1965 afCounter metric.Float64ObservableCounter
1966 afUpDownCounter metric.Float64ObservableUpDownCounter
1967 afGauge metric.Float64ObservableGauge
1968
1969 siCounter metric.Int64Counter
1970 siUpDownCounter metric.Int64UpDownCounter
1971 siHistogram metric.Int64Histogram
1972
1973 sfCounter metric.Float64Counter
1974 sfUpDownCounter metric.Float64UpDownCounter
1975 sfHistogram metric.Float64Histogram
1976 )
1977
1978 func BenchmarkInstrumentCreation(b *testing.B) {
1979 provider := NewMeterProvider(WithReader(NewManualReader()))
1980 meter := provider.Meter("BenchmarkInstrumentCreation")
1981
1982 b.ReportAllocs()
1983 b.ResetTimer()
1984
1985 for n := 0; n < b.N; n++ {
1986 aiCounter, _ = meter.Int64ObservableCounter("observable.int64.counter")
1987 aiUpDownCounter, _ = meter.Int64ObservableUpDownCounter("observable.int64.up.down.counter")
1988 aiGauge, _ = meter.Int64ObservableGauge("observable.int64.gauge")
1989
1990 afCounter, _ = meter.Float64ObservableCounter("observable.float64.counter")
1991 afUpDownCounter, _ = meter.Float64ObservableUpDownCounter("observable.float64.up.down.counter")
1992 afGauge, _ = meter.Float64ObservableGauge("observable.float64.gauge")
1993
1994 siCounter, _ = meter.Int64Counter("sync.int64.counter")
1995 siUpDownCounter, _ = meter.Int64UpDownCounter("sync.int64.up.down.counter")
1996 siHistogram, _ = meter.Int64Histogram("sync.int64.histogram")
1997
1998 sfCounter, _ = meter.Float64Counter("sync.float64.counter")
1999 sfUpDownCounter, _ = meter.Float64UpDownCounter("sync.float64.up.down.counter")
2000 sfHistogram, _ = meter.Float64Histogram("sync.float64.histogram")
2001 }
2002 }
2003
2004 func testNilAggregationSelector(InstrumentKind) Aggregation {
2005 return nil
2006 }
2007
2008 func testDefaultAggregationSelector(InstrumentKind) Aggregation {
2009 return AggregationDefault{}
2010 }
2011
2012 func testUndefinedTemporalitySelector(InstrumentKind) metricdata.Temporality {
2013 return metricdata.Temporality(0)
2014 }
2015
2016 func testInvalidTemporalitySelector(InstrumentKind) metricdata.Temporality {
2017 return metricdata.Temporality(255)
2018 }
2019
2020 type noErrorHandler struct {
2021 t *testing.T
2022 }
2023
2024 func (h noErrorHandler) Handle(err error) {
2025 assert.NoError(h.t, err)
2026 }
2027
2028 func TestMalformedSelectors(t *testing.T) {
2029 type testCase struct {
2030 name string
2031 reader Reader
2032 }
2033 testCases := []testCase{
2034 {
2035 name: "nil aggregation selector",
2036 reader: NewManualReader(WithAggregationSelector(testNilAggregationSelector)),
2037 },
2038 {
2039 name: "nil aggregation selector periodic",
2040 reader: NewPeriodicReader(&fnExporter{aggregationFunc: testNilAggregationSelector}),
2041 },
2042 {
2043 name: "default aggregation selector",
2044 reader: NewManualReader(WithAggregationSelector(testDefaultAggregationSelector)),
2045 },
2046 {
2047 name: "default aggregation selector periodic",
2048 reader: NewPeriodicReader(&fnExporter{aggregationFunc: testDefaultAggregationSelector}),
2049 },
2050 {
2051 name: "undefined temporality selector",
2052 reader: NewManualReader(WithTemporalitySelector(testUndefinedTemporalitySelector)),
2053 },
2054 {
2055 name: "undefined temporality selector periodic",
2056 reader: NewPeriodicReader(&fnExporter{temporalityFunc: testUndefinedTemporalitySelector}),
2057 },
2058 {
2059 name: "invalid temporality selector",
2060 reader: NewManualReader(WithTemporalitySelector(testInvalidTemporalitySelector)),
2061 },
2062 {
2063 name: "invalid temporality selector periodic",
2064 reader: NewPeriodicReader(&fnExporter{temporalityFunc: testInvalidTemporalitySelector}),
2065 },
2066 {
2067 name: "both aggregation and temporality selector",
2068 reader: NewManualReader(
2069 WithAggregationSelector(testNilAggregationSelector),
2070 WithTemporalitySelector(testUndefinedTemporalitySelector),
2071 ),
2072 },
2073 {
2074 name: "both aggregation and temporality selector periodic",
2075 reader: NewPeriodicReader(&fnExporter{
2076 aggregationFunc: testNilAggregationSelector,
2077 temporalityFunc: testUndefinedTemporalitySelector,
2078 }),
2079 },
2080 }
2081
2082 for _, tt := range testCases {
2083 t.Run(tt.name, func(t *testing.T) {
2084 origErrorHandler := global.GetErrorHandler()
2085 defer global.SetErrorHandler(origErrorHandler)
2086 global.SetErrorHandler(noErrorHandler{t})
2087
2088 defer func() {
2089 _ = tt.reader.Shutdown(t.Context())
2090 }()
2091
2092 meter := NewMeterProvider(WithReader(tt.reader)).Meter("TestNilAggregationSelector")
2093
2094 // Create All instruments, they should not error
2095 aiCounter, err := meter.Int64ObservableCounter("observable.int64.counter")
2096 require.NoError(t, err)
2097 aiUpDownCounter, err := meter.Int64ObservableUpDownCounter("observable.int64.up.down.counter")
2098 require.NoError(t, err)
2099 aiGauge, err := meter.Int64ObservableGauge("observable.int64.gauge")
2100 require.NoError(t, err)
2101
2102 afCounter, err := meter.Float64ObservableCounter("observable.float64.counter")
2103 require.NoError(t, err)
2104 afUpDownCounter, err := meter.Float64ObservableUpDownCounter("observable.float64.up.down.counter")
2105 require.NoError(t, err)
2106 afGauge, err := meter.Float64ObservableGauge("observable.float64.gauge")
2107 require.NoError(t, err)
2108
2109 siCounter, err := meter.Int64Counter("sync.int64.counter")
2110 require.NoError(t, err)
2111 siUpDownCounter, err := meter.Int64UpDownCounter("sync.int64.up.down.counter")
2112 require.NoError(t, err)
2113 siHistogram, err := meter.Int64Histogram("sync.int64.histogram")
2114 require.NoError(t, err)
2115
2116 sfCounter, err := meter.Float64Counter("sync.float64.counter")
2117 require.NoError(t, err)
2118 sfUpDownCounter, err := meter.Float64UpDownCounter("sync.float64.up.down.counter")
2119 require.NoError(t, err)
2120 sfHistogram, err := meter.Float64Histogram("sync.float64.histogram")
2121 require.NoError(t, err)
2122
2123 callback := func(_ context.Context, obs metric.Observer) error {
2124 obs.ObserveInt64(aiCounter, 1)
2125 obs.ObserveInt64(aiUpDownCounter, 1)
2126 obs.ObserveInt64(aiGauge, 1)
2127 obs.ObserveFloat64(afCounter, 1)
2128 obs.ObserveFloat64(afUpDownCounter, 1)
2129 obs.ObserveFloat64(afGauge, 1)
2130 return nil
2131 }
2132 _, err = meter.RegisterCallback(
2133 callback,
2134 aiCounter,
2135 aiUpDownCounter,
2136 aiGauge,
2137 afCounter,
2138 afUpDownCounter,
2139 afGauge,
2140 )
2141 require.NoError(t, err)
2142
2143 siCounter.Add(t.Context(), 1)
2144 siUpDownCounter.Add(t.Context(), 1)
2145 siHistogram.Record(t.Context(), 1)
2146 sfCounter.Add(t.Context(), 1)
2147 sfUpDownCounter.Add(t.Context(), 1)
2148 sfHistogram.Record(t.Context(), 1)
2149
2150 var rm metricdata.ResourceMetrics
2151 err = tt.reader.Collect(t.Context(), &rm)
2152 require.NoError(t, err)
2153
2154 require.Len(t, rm.ScopeMetrics, 1)
2155 require.Len(t, rm.ScopeMetrics[0].Metrics, 12)
2156 })
2157 }
2158 }
2159
2160 func TestHistogramBucketPrecedenceOrdering(t *testing.T) {
2161 defaultBuckets := []float64{0, 5, 10, 25, 50, 75, 100, 250, 500, 750, 1000, 2500, 5000, 7500, 10000}
2162 aggregationSelector := func(InstrumentKind) Aggregation {
2163 return AggregationExplicitBucketHistogram{Boundaries: []float64{0, 1, 2, 3, 4, 5}}
2164 }
2165 for _, tt := range []struct {
2166 desc string
2167 reader Reader
2168 views []View
2169 histogramOpts []metric.Float64HistogramOption
2170 expectedBucketBoundaries []float64
2171 }{
2172 {
2173 desc: "default",
2174 reader: NewManualReader(),
2175 expectedBucketBoundaries: defaultBuckets,
2176 },
2177 {
2178 desc: "custom reader aggregation overrides default",
2179 reader: NewManualReader(WithAggregationSelector(aggregationSelector)),
2180 expectedBucketBoundaries: []float64{0, 1, 2, 3, 4, 5},
2181 },
2182 {
2183 desc: "overridden by histogram option",
2184 reader: NewManualReader(WithAggregationSelector(aggregationSelector)),
2185 histogramOpts: []metric.Float64HistogramOption{
2186 metric.WithExplicitBucketBoundaries(0, 2, 4, 6, 8, 10),
2187 },
2188 expectedBucketBoundaries: []float64{0, 2, 4, 6, 8, 10},
2189 },
2190 {
2191 desc: "overridden by view",
2192 reader: NewManualReader(WithAggregationSelector(aggregationSelector)),
2193 histogramOpts: []metric.Float64HistogramOption{
2194 metric.WithExplicitBucketBoundaries(0, 2, 4, 6, 8, 10),
2195 },
2196 views: []View{NewView(Instrument{Name: "*"}, Stream{
2197 Aggregation: AggregationExplicitBucketHistogram{Boundaries: []float64{0, 3, 6, 9, 12, 15}},
2198 })},
2199 expectedBucketBoundaries: []float64{0, 3, 6, 9, 12, 15},
2200 },
2201 } {
2202 t.Run(tt.desc, func(t *testing.T) {
2203 meter := NewMeterProvider(
2204 WithView(tt.views...),
2205 WithReader(tt.reader),
2206 ).Meter("TestHistogramBucketPrecedenceOrdering")
2207 sfHistogram, err := meter.Float64Histogram("sync.float64.histogram", tt.histogramOpts...)
2208 require.NoError(t, err)
2209 sfHistogram.Record(t.Context(), 1)
2210 var rm metricdata.ResourceMetrics
2211 err = tt.reader.Collect(t.Context(), &rm)
2212 require.NoError(t, err)
2213 require.Len(t, rm.ScopeMetrics, 1)
2214 require.Len(t, rm.ScopeMetrics[0].Metrics, 1)
2215 gotHist, ok := rm.ScopeMetrics[0].Metrics[0].Data.(metricdata.Histogram[float64])
2216 require.True(t, ok)
2217 require.Len(t, gotHist.DataPoints, 1)
2218 assert.Equal(t, tt.expectedBucketBoundaries, gotHist.DataPoints[0].Bounds)
2219 })
2220 }
2221 }
2222
2223 func TestObservableDropAggregation(t *testing.T) {
2224 const (
2225 intPrefix = "observable.int64."
2226 intCntName = "observable.int64.counter"
2227 intUDCntName = "observable.int64.up.down.counter"
2228 intGaugeName = "observable.int64.gauge"
2229 floatPrefix = "observable.float64."
2230 floatCntName = "observable.float64.counter"
2231 floatUDCntName = "observable.float64.up.down.counter"
2232 floatGaugeName = "observable.float64.gauge"
2233 unregPrefix = "unregistered.observable."
2234 unregIntCntName = "unregistered.observable.int64.counter"
2235 unregFloatCntName = "unregistered.observable.float64.counter"
2236 )
2237
2238 type log struct {
2239 name string
2240 number string
2241 }
2242
2243 testcases := []struct {
2244 name string
2245 views []View
2246 wantObservables []string
2247 wantUnregLogs []log
2248 }{
2249 {
2250 name: "default",
2251 views: nil,
2252 wantObservables: []string{
2253 intCntName, intUDCntName, intGaugeName,
2254 floatCntName, floatUDCntName, floatGaugeName,
2255 },
2256 wantUnregLogs: []log{
2257 {
2258 name: unregIntCntName,
2259 number: "int64",
2260 },
2261 {
2262 name: unregFloatCntName,
2263 number: "float64",
2264 },
2265 },
2266 },
2267 {
2268 name: "drop all metrics",
2269 views: []View{
2270 func(Instrument) (Stream, bool) {
2271 return Stream{Aggregation: AggregationDrop{}}, true
2272 },
2273 },
2274 wantObservables: nil,
2275 wantUnregLogs: nil,
2276 },
2277 {
2278 name: "drop float64 observable",
2279 views: []View{
2280 func(i Instrument) (Stream, bool) {
2281 if strings.HasPrefix(i.Name, floatPrefix) {
2282 return Stream{Aggregation: AggregationDrop{}}, true
2283 }
2284 return Stream{}, false
2285 },
2286 },
2287 wantObservables: []string{
2288 intCntName, intUDCntName, intGaugeName,
2289 },
2290 wantUnregLogs: []log{
2291 {
2292 name: unregIntCntName,
2293 number: "int64",
2294 },
2295 {
2296 name: unregFloatCntName,
2297 number: "float64",
2298 },
2299 },
2300 },
2301 {
2302 name: "drop int64 observable",
2303 views: []View{
2304 func(i Instrument) (Stream, bool) {
2305 if strings.HasPrefix(i.Name, intPrefix) {
2306 return Stream{Aggregation: AggregationDrop{}}, true
2307 }
2308 return Stream{}, false
2309 },
2310 },
2311 wantObservables: []string{
2312 floatCntName, floatUDCntName, floatGaugeName,
2313 },
2314 wantUnregLogs: []log{
2315 {
2316 name: unregIntCntName,
2317 number: "int64",
2318 },
2319 {
2320 name: unregFloatCntName,
2321 number: "float64",
2322 },
2323 },
2324 },
2325 {
2326 name: "drop unregistered observable",
2327 views: []View{
2328 func(i Instrument) (Stream, bool) {
2329 if strings.HasPrefix(i.Name, unregPrefix) {
2330 return Stream{Aggregation: AggregationDrop{}}, true
2331 }
2332 return Stream{}, false
2333 },
2334 },
2335 wantObservables: []string{
2336 intCntName, intUDCntName, intGaugeName,
2337 floatCntName, floatUDCntName, floatGaugeName,
2338 },
2339 wantUnregLogs: nil,
2340 },
2341 }
2342 for _, tt := range testcases {
2343 t.Run(tt.name, func(t *testing.T) {
2344 var unregLogs []log
2345 otel.SetLogger(
2346 funcr.NewJSON(
2347 func(obj string) {
2348 var entry map[string]any
2349 _ = json.Unmarshal([]byte(obj), &entry)
2350
2351 // All unregistered observables should log `errUnregObserver` error.
2352 // A observable with drop aggregation is also unregistered,
2353 // however this is expected and should not log an error.
2354 assert.Equal(t, errUnregObserver.Error(), entry["error"])
2355
2356 unregLogs = append(unregLogs, log{
2357 name: fmt.Sprintf("%v", entry["name"]),
2358 number: fmt.Sprintf("%v", entry["number"]),
2359 })
2360 },
2361 funcr.Options{Verbosity: 0},
2362 ),
2363 )
2364 defer otel.SetLogger(logr.Discard())
2365
2366 reader := NewManualReader()
2367 meter := NewMeterProvider(WithView(tt.views...), WithReader(reader)).Meter("TestObservableDropAggregation")
2368
2369 intCnt, err := meter.Int64ObservableCounter(intCntName)
2370 require.NoError(t, err)
2371 intUDCnt, err := meter.Int64ObservableUpDownCounter(intUDCntName)
2372 require.NoError(t, err)
2373 intGaugeCnt, err := meter.Int64ObservableGauge(intGaugeName)
2374 require.NoError(t, err)
2375
2376 floatCnt, err := meter.Float64ObservableCounter(floatCntName)
2377 require.NoError(t, err)
2378 floatUDCnt, err := meter.Float64ObservableUpDownCounter(floatUDCntName)
2379 require.NoError(t, err)
2380 floatGaugeCnt, err := meter.Float64ObservableGauge(floatGaugeName)
2381 require.NoError(t, err)
2382
2383 unregIntCnt, err := meter.Int64ObservableCounter(unregIntCntName)
2384 require.NoError(t, err)
2385 unregFloatCnt, err := meter.Float64ObservableCounter(unregFloatCntName)
2386 require.NoError(t, err)
2387
2388 _, err = meter.RegisterCallback(
2389 func(_ context.Context, obs metric.Observer) error {
2390 obs.ObserveInt64(intCnt, 1)
2391 obs.ObserveInt64(intUDCnt, 1)
2392 obs.ObserveInt64(intGaugeCnt, 1)
2393 obs.ObserveFloat64(floatCnt, 1)
2394 obs.ObserveFloat64(floatUDCnt, 1)
2395 obs.ObserveFloat64(floatGaugeCnt, 1)
2396 // We deliberately call observe to unregistered observables
2397 obs.ObserveInt64(unregIntCnt, 1)
2398 obs.ObserveFloat64(unregFloatCnt, 1)
2399
2400 return nil
2401 },
2402 intCnt, intUDCnt, intGaugeCnt,
2403 floatCnt, floatUDCnt, floatGaugeCnt,
2404 // We deliberately do not register `unregIntCnt` and `unregFloatCnt`
2405 // to test that `errUnregObserver` is logged when observed by callback.
2406 )
2407 require.NoError(t, err)
2408
2409 var rm metricdata.ResourceMetrics
2410 err = reader.Collect(t.Context(), &rm)
2411 require.NoError(t, err)
2412
2413 if len(tt.wantObservables) == 0 {
2414 require.Empty(t, rm.ScopeMetrics)
2415 return
2416 }
2417
2418 require.Len(t, rm.ScopeMetrics, 1)
2419 require.Len(t, rm.ScopeMetrics[0].Metrics, len(tt.wantObservables))
2420
2421 for i, m := range rm.ScopeMetrics[0].Metrics {
2422 assert.Equal(t, tt.wantObservables[i], m.Name)
2423 }
2424 assert.Equal(t, tt.wantUnregLogs, unregLogs)
2425 })
2426 }
2427 }
2428
2429 func TestDuplicateInstrumentCreation(t *testing.T) {
2430 for _, tt := range []struct {
2431 desc string
2432 createInstrument func(metric.Meter) error
2433 }{
2434 {
2435 desc: "Int64ObservableCounter",
2436 createInstrument: func(meter metric.Meter) error {
2437 _, err := meter.Int64ObservableCounter("observable.int64.counter")
2438 return err
2439 },
2440 },
2441 {
2442 desc: "Int64ObservableUpDownCounter",
2443 createInstrument: func(meter metric.Meter) error {
2444 _, err := meter.Int64ObservableUpDownCounter("observable.int64.up.down.counter")
2445 return err
2446 },
2447 },
2448 {
2449 desc: "Int64ObservableGauge",
2450 createInstrument: func(meter metric.Meter) error {
2451 _, err := meter.Int64ObservableGauge("observable.int64.gauge")
2452 return err
2453 },
2454 },
2455 {
2456 desc: "Float64ObservableCounter",
2457 createInstrument: func(meter metric.Meter) error {
2458 _, err := meter.Float64ObservableCounter("observable.float64.counter")
2459 return err
2460 },
2461 },
2462 {
2463 desc: "Float64ObservableUpDownCounter",
2464 createInstrument: func(meter metric.Meter) error {
2465 _, err := meter.Float64ObservableUpDownCounter("observable.float64.up.down.counter")
2466 return err
2467 },
2468 },
2469 {
2470 desc: "Float64ObservableGauge",
2471 createInstrument: func(meter metric.Meter) error {
2472 _, err := meter.Float64ObservableGauge("observable.float64.gauge")
2473 return err
2474 },
2475 },
2476 {
2477 desc: "Int64Counter",
2478 createInstrument: func(meter metric.Meter) error {
2479 _, err := meter.Int64Counter("sync.int64.counter")
2480 return err
2481 },
2482 },
2483 {
2484 desc: "Int64UpDownCounter",
2485 createInstrument: func(meter metric.Meter) error {
2486 _, err := meter.Int64UpDownCounter("sync.int64.up.down.counter")
2487 return err
2488 },
2489 },
2490 {
2491 desc: "Int64Histogram",
2492 createInstrument: func(meter metric.Meter) error {
2493 _, err := meter.Int64Histogram("sync.int64.histogram")
2494 return err
2495 },
2496 },
2497 {
2498 desc: "Float64Counter",
2499 createInstrument: func(meter metric.Meter) error {
2500 _, err := meter.Float64Counter("sync.float64.counter")
2501 return err
2502 },
2503 },
2504 {
2505 desc: "Float64UpDownCounter",
2506 createInstrument: func(meter metric.Meter) error {
2507 _, err := meter.Float64UpDownCounter("sync.float64.up.down.counter")
2508 return err
2509 },
2510 },
2511 {
2512 desc: "Float64Histogram",
2513 createInstrument: func(meter metric.Meter) error {
2514 _, err := meter.Float64Histogram("sync.float64.histogram")
2515 return err
2516 },
2517 },
2518 } {
2519 t.Run(tt.desc, func(t *testing.T) {
2520 reader := NewManualReader()
2521 defer func() {
2522 require.NoError(t, reader.Shutdown(t.Context()))
2523 }()
2524
2525 m := NewMeterProvider(WithReader(reader)).Meter("TestDuplicateInstrumentCreation")
2526 for range 3 {
2527 require.NoError(t, tt.createInstrument(m))
2528 }
2529 internalMeter, ok := m.(*meter)
2530 require.True(t, ok)
2531 // check that multiple calls to create the same instrument only create 1 instrument
2532 numInstruments := len(
2533 internalMeter.int64Insts.data,
2534 ) + len(
2535 internalMeter.float64Insts.data,
2536 ) + len(
2537 internalMeter.int64ObservableInsts.data,
2538 ) + len(
2539 internalMeter.float64ObservableInsts.data,
2540 )
2541 require.Equal(t, 1, numInstruments)
2542 })
2543 }
2544 }
2545
2546 func TestMeterProviderDelegation(t *testing.T) {
2547 meter := otel.Meter("go.opentelemetry.io/otel/metric/internal/global/meter_test")
2548 otel.SetErrorHandler(otel.ErrorHandlerFunc(func(err error) { require.NoError(t, err) }))
2549 for range 5 {
2550 int64Counter, err := meter.Int64ObservableCounter("observable.int64.counter")
2551 require.NoError(t, err)
2552 int64UpDownCounter, err := meter.Int64ObservableUpDownCounter("observable.int64.up.down.counter")
2553 require.NoError(t, err)
2554 int64Gauge, err := meter.Int64ObservableGauge("observable.int64.gauge")
2555 require.NoError(t, err)
2556 floatCounter, err := meter.Float64ObservableCounter("observable.float.counter")
2557 require.NoError(t, err)
2558 floatUpDownCounter, err := meter.Float64ObservableUpDownCounter("observable.float.up.down.counter")
2559 require.NoError(t, err)
2560 floatGauge, err := meter.Float64ObservableGauge("observable.float.gauge")
2561 require.NoError(t, err)
2562 _, err = meter.RegisterCallback(func(_ context.Context, o metric.Observer) error {
2563 o.ObserveInt64(int64Counter, int64(10))
2564 o.ObserveInt64(int64UpDownCounter, int64(10))
2565 o.ObserveInt64(int64Gauge, int64(10))
2566
2567 o.ObserveFloat64(floatCounter, float64(10))
2568 o.ObserveFloat64(floatUpDownCounter, float64(10))
2569 o.ObserveFloat64(floatGauge, float64(10))
2570 return nil
2571 }, int64Counter, int64UpDownCounter, int64Gauge, floatCounter, floatUpDownCounter, floatGauge)
2572 require.NoError(t, err)
2573 }
2574 provider := NewMeterProvider()
2575
2576 assert.NotPanics(t, func() {
2577 otel.SetMeterProvider(provider)
2578 })
2579 }
2580
2581 func TestExemplarFilter(t *testing.T) {
2582 rdr := NewManualReader()
2583 mp := NewMeterProvider(
2584 WithReader(rdr),
2585 // Passing AlwaysOnFilter causes collection of the exemplar for the
2586 // counter increment below.
2587 WithExemplarFilter(exemplar.AlwaysOnFilter),
2588 )
2589
2590 m1 := mp.Meter("scope")
2591 ctr1, err := m1.Float64Counter("ctr")
2592 assert.NoError(t, err)
2593 ctr1.Add(t.Context(), 1.0)
2594
2595 want := metricdata.ResourceMetrics{
2596 Resource: resource.Default(),
2597 ScopeMetrics: []metricdata.ScopeMetrics{
2598 {
2599 Scope: instrumentation.Scope{
2600 Name: "scope",
2601 },
2602 Metrics: []metricdata.Metrics{
2603 {
2604 Name: "ctr",
2605 Data: metricdata.Sum[float64]{
2606 Temporality: metricdata.CumulativeTemporality,
2607 IsMonotonic: true,
2608 DataPoints: []metricdata.DataPoint[float64]{
2609 {
2610 Value: 1.0,
2611 Exemplars: []metricdata.Exemplar[float64]{
2612 {
2613 Value: 1.0,
2614 },
2615 },
2616 },
2617 },
2618 },
2619 },
2620 },
2621 },
2622 },
2623 }
2624
2625 got := metricdata.ResourceMetrics{}
2626 err = rdr.Collect(t.Context(), &got)
2627 assert.NoError(t, err)
2628 metricdatatest.AssertEqual(t, want, got, metricdatatest.IgnoreTimestamp())
2629 }