Debian Codegraph @

internal/global/meter_test.go

raw
1 // Copyright The OpenTelemetry Authors
2 // SPDX-License-Identifier: Apache-2.0
3
4 package global // import "go.opentelemetry.io/otel/internal/global"
5
6 import (
7 "context"
8 "errors"
9 "fmt"
10 "sync"
11 "testing"
12
13 "github.com/stretchr/testify/assert"
14 "github.com/stretchr/testify/require"
15
16 "go.opentelemetry.io/otel/attribute"
17 "go.opentelemetry.io/otel/metric"
18 "go.opentelemetry.io/otel/metric/noop"
19 )
20
21 func TestMeterProviderConcurrentSafe(*testing.T) {
22 mp := &meterProvider{}
23 done := make(chan struct{})
24 finish := make(chan struct{})
25 go func() {
26 defer close(done)
27 for i := 0; ; i++ {
28 mp.Meter(fmt.Sprintf("a%d", i))
29 select {
30 case <-finish:
31 return
32 default:
33 }
34 }
35 }()
36
37 mp.setDelegate(noop.NewMeterProvider())
38 close(finish)
39 <-done
40 }
41
42 var zeroCallback metric.Callback = func(context.Context, metric.Observer) error {
43 return nil
44 }
45
46 func TestMeterConcurrentSafe(t *testing.T) {
47 mtr := &meter{instruments: make(map[instID]delegatedInstrument)}
48
49 wg := &sync.WaitGroup{}
50 wg.Add(1)
51 done := make(chan struct{})
52 finish := make(chan struct{})
53 go func() {
54 defer close(done)
55 for i, once := 0, false; ; i++ {
56 name := fmt.Sprintf("a%d", i)
57 _, _ = mtr.Float64ObservableCounter(name)
58 _, _ = mtr.Float64ObservableUpDownCounter(name)
59 _, _ = mtr.Float64ObservableGauge(name)
60 _, _ = mtr.Int64ObservableCounter(name)
61 _, _ = mtr.Int64ObservableUpDownCounter(name)
62 _, _ = mtr.Int64ObservableGauge(name)
63 _, _ = mtr.Float64Counter(name)
64 _, _ = mtr.Float64UpDownCounter(name)
65 _, _ = mtr.Float64Histogram(name)
66 _, _ = mtr.Float64Gauge(name)
67 _, _ = mtr.Int64Counter(name)
68 _, _ = mtr.Int64UpDownCounter(name)
69 _, _ = mtr.Int64Histogram(name)
70 _, _ = mtr.Int64Gauge(name)
71 _, _ = mtr.RegisterCallback(zeroCallback)
72 if !once {
73 wg.Done()
74 once = true
75 }
76 select {
77 case <-finish:
78 return
79 default:
80 }
81 }
82 }()
83
84 wg.Wait()
85 mtr.setDelegate(noop.NewMeterProvider())
86 close(finish)
87 <-done
88
89 // No instruments should be left after the meter is replaced.
90 assert.Empty(t, mtr.instruments)
91
92 // No callbacks should be left after the meter is replaced.
93 assert.Zero(t, mtr.registry.Len())
94 }
95
96 func TestUnregisterConcurrentSafe(t *testing.T) {
97 mtr := &meter{instruments: make(map[instID]delegatedInstrument)}
98 reg, err := mtr.RegisterCallback(zeroCallback)
99 require.NoError(t, err)
100
101 wg := &sync.WaitGroup{}
102 wg.Add(1)
103 done := make(chan struct{})
104 finish := make(chan struct{})
105 go func() {
106 defer close(done)
107 for i, once := 0, false; ; i++ {
108 _ = reg.Unregister()
109 if !once {
110 wg.Done()
111 once = true
112 }
113 select {
114 case <-finish:
115 return
116 default:
117 }
118 }
119 }()
120 _ = reg.Unregister()
121
122 wg.Wait()
123 mtr.setDelegate(noop.NewMeterProvider())
124 close(finish)
125 <-done
126 }
127
128 func testSetupAllInstrumentTypes(
129 t *testing.T,
130 m metric.Meter,
131 ) (metric.Float64Counter, metric.Float64ObservableCounter) {
132 afcounter, err := m.Float64ObservableCounter("test_Async_Counter")
133 require.NoError(t, err)
134 _, err = m.Float64ObservableUpDownCounter("test_Async_UpDownCounter")
135 assert.NoError(t, err)
136 _, err = m.Float64ObservableGauge("test_Async_Gauge")
137 assert.NoError(t, err)
138
139 _, err = m.Int64ObservableCounter("test_Async_Counter")
140 assert.NoError(t, err)
141 _, err = m.Int64ObservableUpDownCounter("test_Async_UpDownCounter")
142 assert.NoError(t, err)
143 _, err = m.Int64ObservableGauge("test_Async_Gauge")
144 assert.NoError(t, err)
145
146 _, err = m.RegisterCallback(func(_ context.Context, obs metric.Observer) error {
147 obs.ObserveFloat64(afcounter, 3)
148 return nil
149 }, afcounter)
150 require.NoError(t, err)
151
152 sfcounter, err := m.Float64Counter("test_Sync_Counter")
153 require.NoError(t, err)
154 _, err = m.Float64UpDownCounter("test_Sync_UpDownCounter")
155 assert.NoError(t, err)
156 _, err = m.Float64Histogram("test_Sync_Histogram")
157 assert.NoError(t, err)
158 _, err = m.Float64Gauge("test_Sync_Gauge")
159 assert.NoError(t, err)
160
161 _, err = m.Int64Counter("test_Sync_Counter")
162 assert.NoError(t, err)
163 _, err = m.Int64UpDownCounter("test_Sync_UpDownCounter")
164 assert.NoError(t, err)
165 _, err = m.Int64Histogram("test_Sync_Histogram")
166 assert.NoError(t, err)
167 _, err = m.Int64Gauge("test_Sync_Gauge")
168 assert.NoError(t, err)
169
170 return sfcounter, afcounter
171 }
172
173 // This is to emulate a read from an exporter.
174 func testCollect(t *testing.T, m metric.Meter) {
175 if tMeter, ok := m.(*meter); ok {
176 // This changes the input m to the delegate.
177 m = tMeter.delegate
178 if m == nil {
179 t.Error("meter was not delegated")
180 return
181 }
182 }
183 tMeter, ok := m.(*testMeter)
184 if !ok {
185 t.Error("collect called on non-test Meter")
186 return
187 }
188 tMeter.collect()
189 }
190
191 func TestInstrumentIdentity(t *testing.T) {
192 globalMeterProvider := &meterProvider{}
193 m := globalMeterProvider.Meter("go.opentelemetry.io/otel/metric/internal/global/meter_test")
194 tMeter := m.(*meter)
195 testSetupAllInstrumentTypes(t, m)
196 assert.Len(t, tMeter.instruments, 14)
197 // Creating the same instruments multiple times should not increase the
198 // number of instruments.
199 testSetupAllInstrumentTypes(t, m)
200 assert.Len(t, tMeter.instruments, 14)
201 }
202
203 func TestMeterProviderDelegatesCalls(t *testing.T) {
204 // The global MeterProvider should directly call the underlying MeterProvider
205 // if it is set prior to Meter() being called.
206
207 // globalMeterProvider := otel.GetMeterProvider
208 globalMeterProvider := &meterProvider{}
209
210 mp := &testMeterProvider{}
211
212 // otel.SetMeterProvider(mp)
213 globalMeterProvider.setDelegate(mp)
214
215 assert.Equal(t, 0, mp.count)
216
217 meter := globalMeterProvider.Meter("go.opentelemetry.io/otel/metric/internal/global/meter_test")
218
219 ctr, actr := testSetupAllInstrumentTypes(t, meter)
220
221 ctr.Add(t.Context(), 5)
222
223 testCollect(t, meter) // This is a hacky way to emulate a read from an exporter
224
225 // Calls to Meter() after setDelegate() should be executed by the delegate
226 require.IsType(t, &testMeter{}, meter)
227 tMeter := meter.(*testMeter)
228 assert.Equal(t, 1, tMeter.afCount)
229 assert.Equal(t, 1, tMeter.afUDCount)
230 assert.Equal(t, 1, tMeter.afGauge)
231 assert.Equal(t, 1, tMeter.aiCount)
232 assert.Equal(t, 1, tMeter.aiUDCount)
233 assert.Equal(t, 1, tMeter.aiGauge)
234 assert.Equal(t, 1, tMeter.sfCount)
235 assert.Equal(t, 1, tMeter.sfUDCount)
236 assert.Equal(t, 1, tMeter.sfHist)
237 assert.Equal(t, 1, tMeter.siCount)
238 assert.Equal(t, 1, tMeter.siUDCount)
239 assert.Equal(t, 1, tMeter.siHist)
240 assert.Len(t, tMeter.callbacks, 1)
241
242 // Because the Meter was provided by testMeterProvider it should also return our test instrument
243 require.IsType(t, &testCountingFloatInstrument{}, ctr, "the meter did not delegate calls to the meter")
244 assert.Equal(t, 1, ctr.(*testCountingFloatInstrument).count)
245
246 require.IsType(t, &testCountingFloatInstrument{}, actr, "the meter did not delegate calls to the meter")
247 assert.Equal(t, 1, actr.(*testCountingFloatInstrument).count)
248
249 assert.Equal(t, 1, mp.count)
250 }
251
252 func TestMeterDelegatesCalls(t *testing.T) {
253 // The global MeterProvider should directly provide a Meter instance that
254 // can be updated. If the SetMeterProvider is called after a Meter was
255 // obtained, but before instruments only the instrument should be generated
256 // by the delegated type.
257
258 globalMeterProvider := &meterProvider{}
259
260 mp := &testMeterProvider{}
261
262 assert.Equal(t, 0, mp.count)
263
264 m := globalMeterProvider.Meter("go.opentelemetry.io/otel/metric/internal/global/meter_test")
265
266 globalMeterProvider.setDelegate(mp)
267
268 ctr, actr := testSetupAllInstrumentTypes(t, m)
269
270 ctr.Add(t.Context(), 5)
271
272 testCollect(t, m) // This is a hacky way to emulate a read from an exporter
273
274 // Calls to Meter methods after setDelegate() should be executed by the delegate
275 require.IsType(t, &meter{}, m)
276 tMeter := m.(*meter).delegate.(*testMeter)
277 require.NotNil(t, tMeter)
278 assert.Equal(t, 1, tMeter.afCount)
279 assert.Equal(t, 1, tMeter.afUDCount)
280 assert.Equal(t, 1, tMeter.afGauge)
281 assert.Equal(t, 1, tMeter.aiCount)
282 assert.Equal(t, 1, tMeter.aiUDCount)
283 assert.Equal(t, 1, tMeter.aiGauge)
284 assert.Equal(t, 1, tMeter.sfCount)
285 assert.Equal(t, 1, tMeter.sfUDCount)
286 assert.Equal(t, 1, tMeter.sfHist)
287 assert.Equal(t, 1, tMeter.siCount)
288 assert.Equal(t, 1, tMeter.siUDCount)
289 assert.Equal(t, 1, tMeter.siHist)
290
291 // Because the Meter was provided by testMeterProvider it should also return our test instrument
292 require.IsType(t, &testCountingFloatInstrument{}, ctr, "the meter did not delegate calls to the meter")
293 assert.Equal(t, 1, ctr.(*testCountingFloatInstrument).count)
294
295 // Because the Meter was provided by testMeterProvider it should also return our test instrument
296 require.IsType(t, &testCountingFloatInstrument{}, actr, "the meter did not delegate calls to the meter")
297 assert.Equal(t, 1, actr.(*testCountingFloatInstrument).count)
298
299 assert.Equal(t, 1, mp.count)
300 }
301
302 func TestMeterDefersDelegations(t *testing.T) {
303 // If SetMeterProvider is called after instruments are registered, the
304 // instruments should be recreated with the new meter.
305
306 // globalMeterProvider := otel.GetMeterProvider
307 globalMeterProvider := &meterProvider{}
308
309 m := globalMeterProvider.Meter("go.opentelemetry.io/otel/metric/internal/global/meter_test")
310
311 ctr, actr := testSetupAllInstrumentTypes(t, m)
312
313 ctr.Add(t.Context(), 5)
314
315 mp := &testMeterProvider{}
316
317 // otel.SetMeterProvider(mp)
318 globalMeterProvider.setDelegate(mp)
319
320 testCollect(t, m) // This is a hacky way to emulate a read from an exporter
321
322 // Calls to Meter() before setDelegate() should be the delegated type
323 require.IsType(t, &meter{}, m)
324 tMeter := m.(*meter).delegate.(*testMeter)
325 require.NotNil(t, tMeter)
326 assert.Equal(t, 1, tMeter.afCount)
327 assert.Equal(t, 1, tMeter.afUDCount)
328 assert.Equal(t, 1, tMeter.afGauge)
329 assert.Equal(t, 1, tMeter.aiCount)
330 assert.Equal(t, 1, tMeter.aiUDCount)
331 assert.Equal(t, 1, tMeter.aiGauge)
332 assert.Equal(t, 1, tMeter.sfCount)
333 assert.Equal(t, 1, tMeter.sfUDCount)
334 assert.Equal(t, 1, tMeter.sfHist)
335 assert.Equal(t, 1, tMeter.siCount)
336 assert.Equal(t, 1, tMeter.siUDCount)
337 assert.Equal(t, 1, tMeter.siHist)
338
339 // Because the Meter was a delegate it should return a delegated instrument
340
341 assert.IsType(t, &sfCounter{}, ctr)
342 assert.IsType(t, &afCounter{}, actr)
343 assert.Equal(t, 1, mp.count)
344 }
345
346 func TestRegistrationDelegation(t *testing.T) {
347 // globalMeterProvider := otel.GetMeterProvider
348 globalMeterProvider := &meterProvider{}
349
350 m := globalMeterProvider.Meter("go.opentelemetry.io/otel/metric/internal/global/meter_test")
351 require.IsType(t, &meter{}, m)
352 mImpl := m.(*meter)
353
354 actr, err := m.Float64ObservableCounter("test_Async_Counter")
355 require.NoError(t, err)
356
357 var called0 bool
358 reg0, err := m.RegisterCallback(func(context.Context, metric.Observer) error {
359 called0 = true
360 return nil
361 }, actr)
362 require.NoError(t, err)
363 require.Equal(t, 1, mImpl.registry.Len(), "callback not registered")
364 // This means reg0 should not be delegated.
365 assert.NoError(t, reg0.Unregister())
366 assert.Equal(t, 0, mImpl.registry.Len(), "callback not unregistered")
367
368 var called1 bool
369 reg1, err := m.RegisterCallback(func(context.Context, metric.Observer) error {
370 called1 = true
371 return nil
372 }, actr)
373 require.NoError(t, err)
374 require.Equal(t, 1, mImpl.registry.Len(), "second callback not registered")
375
376 var called2 bool
377 _, err = m.RegisterCallback(func(context.Context, metric.Observer) error {
378 called2 = true
379 return nil
380 }, actr)
381 require.NoError(t, err)
382 require.Equal(t, 2, mImpl.registry.Len(), "third callback not registered")
383
384 mp := &testMeterProvider{}
385 globalMeterProvider.setDelegate(mp)
386
387 testCollect(t, m) // This is a hacky way to emulate a read from an exporter
388 require.False(t, called0, "pre-delegation unregistered callback called")
389 require.True(t, called1, "second callback not called")
390 require.True(t, called2, "third callback not called")
391
392 assert.NoError(t, reg1.Unregister(), "unregister second callback")
393 called1, called2 = false, false // reset called capture
394 testCollect(t, m) // This is a hacky way to emulate a read from an exporter
395 assert.False(t, called1, "unregistered second callback called")
396 require.True(t, called2, "third callback not called")
397
398 assert.NotPanics(t, func() {
399 assert.NoError(t, reg1.Unregister(), "duplicate unregister calls")
400 })
401 }
402
403 func TestMeterIdentity(t *testing.T) {
404 type id struct{ name, ver, url, attr string }
405
406 ids := []id{
407 {"name-a", "version-a", "url-a", ""},
408 {"name-a", "version-a", "url-a", "attr"},
409 {"name-a", "version-a", "url-b", ""},
410 {"name-a", "version-b", "url-a", ""},
411 {"name-a", "version-b", "url-b", ""},
412 {"name-b", "version-a", "url-a", ""},
413 {"name-b", "version-a", "url-b", ""},
414 {"name-b", "version-b", "url-a", ""},
415 {"name-b", "version-b", "url-b", ""},
416 }
417
418 provider := &meterProvider{}
419 newMeter := func(i id) metric.Meter {
420 return provider.Meter(
421 i.name,
422 metric.WithInstrumentationVersion(i.ver),
423 metric.WithSchemaURL(i.url),
424 metric.WithInstrumentationAttributes(attribute.String("key", i.attr)),
425 )
426 }
427
428 for i, id0 := range ids {
429 for j, id1 := range ids {
430 l0, l1 := newMeter(id0), newMeter(id1)
431
432 if i == j {
433 assert.Samef(t, l0, l1, "Meter(%v) != Meter(%v)", id0, id1)
434 } else {
435 assert.NotSamef(t, l0, l1, "Meter(%v) == Meter(%v)", id0, id1)
436 }
437 }
438 }
439 }
440
441 type failingRegisterCallbackMeter struct {
442 noop.Meter
443 }
444
445 func (*failingRegisterCallbackMeter) RegisterCallback(
446 metric.Callback,
447 ...metric.Observable,
448 ) (metric.Registration, error) {
449 return nil, errors.New("an error occurred")
450 }
451
452 func TestRegistrationDelegateFailingCallback(t *testing.T) {
453 r := &registration{
454 unreg: func() error { return nil },
455 }
456 m := &failingRegisterCallbackMeter{}
457
458 assert.NotPanics(t, func() {
459 r.setDelegate(m)
460 })
461 }