Debian Codegraph @

internal/global/instruments.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 "sync/atomic"
9
10 "go.opentelemetry.io/otel/metric"
11 "go.opentelemetry.io/otel/metric/embedded"
12 )
13
14 // unwrapper unwraps to return the underlying instrument implementation.
15 type unwrapper interface {
16 unwrap() metric.Observable
17 }
18
19 type afCounter struct {
20 embedded.Float64ObservableCounter
21 metric.Float64Observable
22
23 name string
24 opts []metric.Float64ObservableCounterOption
25
26 delegate atomic.Value // metric.Float64ObservableCounter
27 }
28
29 var (
30 _ unwrapper = (*afCounter)(nil)
31 _ metric.Float64ObservableCounter = (*afCounter)(nil)
32 )
33
34 func (i *afCounter) setDelegate(m metric.Meter) {
35 ctr, err := m.Float64ObservableCounter(i.name, i.opts...)
36 if err != nil {
37 GetErrorHandler().Handle(err)
38 return
39 }
40 i.delegate.Store(ctr)
41 }
42
43 func (i *afCounter) unwrap() metric.Observable {
44 if ctr := i.delegate.Load(); ctr != nil {
45 return ctr.(metric.Float64ObservableCounter)
46 }
47 return nil
48 }
49
50 type afUpDownCounter struct {
51 embedded.Float64ObservableUpDownCounter
52 metric.Float64Observable
53
54 name string
55 opts []metric.Float64ObservableUpDownCounterOption
56
57 delegate atomic.Value // metric.Float64ObservableUpDownCounter
58 }
59
60 var (
61 _ unwrapper = (*afUpDownCounter)(nil)
62 _ metric.Float64ObservableUpDownCounter = (*afUpDownCounter)(nil)
63 )
64
65 func (i *afUpDownCounter) setDelegate(m metric.Meter) {
66 ctr, err := m.Float64ObservableUpDownCounter(i.name, i.opts...)
67 if err != nil {
68 GetErrorHandler().Handle(err)
69 return
70 }
71 i.delegate.Store(ctr)
72 }
73
74 func (i *afUpDownCounter) unwrap() metric.Observable {
75 if ctr := i.delegate.Load(); ctr != nil {
76 return ctr.(metric.Float64ObservableUpDownCounter)
77 }
78 return nil
79 }
80
81 type afGauge struct {
82 embedded.Float64ObservableGauge
83 metric.Float64Observable
84
85 name string
86 opts []metric.Float64ObservableGaugeOption
87
88 delegate atomic.Value // metric.Float64ObservableGauge
89 }
90
91 var (
92 _ unwrapper = (*afGauge)(nil)
93 _ metric.Float64ObservableGauge = (*afGauge)(nil)
94 )
95
96 func (i *afGauge) setDelegate(m metric.Meter) {
97 ctr, err := m.Float64ObservableGauge(i.name, i.opts...)
98 if err != nil {
99 GetErrorHandler().Handle(err)
100 return
101 }
102 i.delegate.Store(ctr)
103 }
104
105 func (i *afGauge) unwrap() metric.Observable {
106 if ctr := i.delegate.Load(); ctr != nil {
107 return ctr.(metric.Float64ObservableGauge)
108 }
109 return nil
110 }
111
112 type aiCounter struct {
113 embedded.Int64ObservableCounter
114 metric.Int64Observable
115
116 name string
117 opts []metric.Int64ObservableCounterOption
118
119 delegate atomic.Value // metric.Int64ObservableCounter
120 }
121
122 var (
123 _ unwrapper = (*aiCounter)(nil)
124 _ metric.Int64ObservableCounter = (*aiCounter)(nil)
125 )
126
127 func (i *aiCounter) setDelegate(m metric.Meter) {
128 ctr, err := m.Int64ObservableCounter(i.name, i.opts...)
129 if err != nil {
130 GetErrorHandler().Handle(err)
131 return
132 }
133 i.delegate.Store(ctr)
134 }
135
136 func (i *aiCounter) unwrap() metric.Observable {
137 if ctr := i.delegate.Load(); ctr != nil {
138 return ctr.(metric.Int64ObservableCounter)
139 }
140 return nil
141 }
142
143 type aiUpDownCounter struct {
144 embedded.Int64ObservableUpDownCounter
145 metric.Int64Observable
146
147 name string
148 opts []metric.Int64ObservableUpDownCounterOption
149
150 delegate atomic.Value // metric.Int64ObservableUpDownCounter
151 }
152
153 var (
154 _ unwrapper = (*aiUpDownCounter)(nil)
155 _ metric.Int64ObservableUpDownCounter = (*aiUpDownCounter)(nil)
156 )
157
158 func (i *aiUpDownCounter) setDelegate(m metric.Meter) {
159 ctr, err := m.Int64ObservableUpDownCounter(i.name, i.opts...)
160 if err != nil {
161 GetErrorHandler().Handle(err)
162 return
163 }
164 i.delegate.Store(ctr)
165 }
166
167 func (i *aiUpDownCounter) unwrap() metric.Observable {
168 if ctr := i.delegate.Load(); ctr != nil {
169 return ctr.(metric.Int64ObservableUpDownCounter)
170 }
171 return nil
172 }
173
174 type aiGauge struct {
175 embedded.Int64ObservableGauge
176 metric.Int64Observable
177
178 name string
179 opts []metric.Int64ObservableGaugeOption
180
181 delegate atomic.Value // metric.Int64ObservableGauge
182 }
183
184 var (
185 _ unwrapper = (*aiGauge)(nil)
186 _ metric.Int64ObservableGauge = (*aiGauge)(nil)
187 )
188
189 func (i *aiGauge) setDelegate(m metric.Meter) {
190 ctr, err := m.Int64ObservableGauge(i.name, i.opts...)
191 if err != nil {
192 GetErrorHandler().Handle(err)
193 return
194 }
195 i.delegate.Store(ctr)
196 }
197
198 func (i *aiGauge) unwrap() metric.Observable {
199 if ctr := i.delegate.Load(); ctr != nil {
200 return ctr.(metric.Int64ObservableGauge)
201 }
202 return nil
203 }
204
205 // Sync Instruments.
206 type sfCounter struct {
207 embedded.Float64Counter
208
209 name string
210 opts []metric.Float64CounterOption
211
212 delegate atomic.Value // metric.Float64Counter
213 }
214
215 var _ metric.Float64Counter = (*sfCounter)(nil)
216
217 func (i *sfCounter) setDelegate(m metric.Meter) {
218 ctr, err := m.Float64Counter(i.name, i.opts...)
219 if err != nil {
220 GetErrorHandler().Handle(err)
221 return
222 }
223 i.delegate.Store(ctr)
224 }
225
226 func (i *sfCounter) Add(ctx context.Context, incr float64, opts ...metric.AddOption) {
227 if ctr := i.delegate.Load(); ctr != nil {
228 ctr.(metric.Float64Counter).Add(ctx, incr, opts...)
229 }
230 }
231
232 func (i *sfCounter) Enabled(ctx context.Context) bool {
233 if ctr := i.delegate.Load(); ctr != nil {
234 return ctr.(metric.Float64Counter).Enabled(ctx)
235 }
236 return false
237 }
238
239 type sfUpDownCounter struct {
240 embedded.Float64UpDownCounter
241
242 name string
243 opts []metric.Float64UpDownCounterOption
244
245 delegate atomic.Value // metric.Float64UpDownCounter
246 }
247
248 var _ metric.Float64UpDownCounter = (*sfUpDownCounter)(nil)
249
250 func (i *sfUpDownCounter) setDelegate(m metric.Meter) {
251 ctr, err := m.Float64UpDownCounter(i.name, i.opts...)
252 if err != nil {
253 GetErrorHandler().Handle(err)
254 return
255 }
256 i.delegate.Store(ctr)
257 }
258
259 func (i *sfUpDownCounter) Add(ctx context.Context, incr float64, opts ...metric.AddOption) {
260 if ctr := i.delegate.Load(); ctr != nil {
261 ctr.(metric.Float64UpDownCounter).Add(ctx, incr, opts...)
262 }
263 }
264
265 func (i *sfUpDownCounter) Enabled(ctx context.Context) bool {
266 if ctr := i.delegate.Load(); ctr != nil {
267 return ctr.(metric.Float64UpDownCounter).Enabled(ctx)
268 }
269 return false
270 }
271
272 type sfHistogram struct {
273 embedded.Float64Histogram
274
275 name string
276 opts []metric.Float64HistogramOption
277
278 delegate atomic.Value // metric.Float64Histogram
279 }
280
281 var _ metric.Float64Histogram = (*sfHistogram)(nil)
282
283 func (i *sfHistogram) setDelegate(m metric.Meter) {
284 ctr, err := m.Float64Histogram(i.name, i.opts...)
285 if err != nil {
286 GetErrorHandler().Handle(err)
287 return
288 }
289 i.delegate.Store(ctr)
290 }
291
292 func (i *sfHistogram) Record(ctx context.Context, x float64, opts ...metric.RecordOption) {
293 if ctr := i.delegate.Load(); ctr != nil {
294 ctr.(metric.Float64Histogram).Record(ctx, x, opts...)
295 }
296 }
297
298 func (i *sfHistogram) Enabled(ctx context.Context) bool {
299 if ctr := i.delegate.Load(); ctr != nil {
300 return ctr.(metric.Float64Histogram).Enabled(ctx)
301 }
302 return false
303 }
304
305 type sfGauge struct {
306 embedded.Float64Gauge
307
308 name string
309 opts []metric.Float64GaugeOption
310
311 delegate atomic.Value // metric.Float64Gauge
312 }
313
314 var _ metric.Float64Gauge = (*sfGauge)(nil)
315
316 func (i *sfGauge) setDelegate(m metric.Meter) {
317 ctr, err := m.Float64Gauge(i.name, i.opts...)
318 if err != nil {
319 GetErrorHandler().Handle(err)
320 return
321 }
322 i.delegate.Store(ctr)
323 }
324
325 func (i *sfGauge) Record(ctx context.Context, x float64, opts ...metric.RecordOption) {
326 if ctr := i.delegate.Load(); ctr != nil {
327 ctr.(metric.Float64Gauge).Record(ctx, x, opts...)
328 }
329 }
330
331 func (i *sfGauge) Enabled(ctx context.Context) bool {
332 if ctr := i.delegate.Load(); ctr != nil {
333 return ctr.(metric.Float64Gauge).Enabled(ctx)
334 }
335 return false
336 }
337
338 type siCounter struct {
339 embedded.Int64Counter
340
341 name string
342 opts []metric.Int64CounterOption
343
344 delegate atomic.Value // metric.Int64Counter
345 }
346
347 var _ metric.Int64Counter = (*siCounter)(nil)
348
349 func (i *siCounter) setDelegate(m metric.Meter) {
350 ctr, err := m.Int64Counter(i.name, i.opts...)
351 if err != nil {
352 GetErrorHandler().Handle(err)
353 return
354 }
355 i.delegate.Store(ctr)
356 }
357
358 func (i *siCounter) Add(ctx context.Context, x int64, opts ...metric.AddOption) {
359 if ctr := i.delegate.Load(); ctr != nil {
360 ctr.(metric.Int64Counter).Add(ctx, x, opts...)
361 }
362 }
363
364 func (i *siCounter) Enabled(ctx context.Context) bool {
365 if ctr := i.delegate.Load(); ctr != nil {
366 return ctr.(metric.Int64Counter).Enabled(ctx)
367 }
368 return false
369 }
370
371 type siUpDownCounter struct {
372 embedded.Int64UpDownCounter
373
374 name string
375 opts []metric.Int64UpDownCounterOption
376
377 delegate atomic.Value // metric.Int64UpDownCounter
378 }
379
380 var _ metric.Int64UpDownCounter = (*siUpDownCounter)(nil)
381
382 func (i *siUpDownCounter) setDelegate(m metric.Meter) {
383 ctr, err := m.Int64UpDownCounter(i.name, i.opts...)
384 if err != nil {
385 GetErrorHandler().Handle(err)
386 return
387 }
388 i.delegate.Store(ctr)
389 }
390
391 func (i *siUpDownCounter) Add(ctx context.Context, x int64, opts ...metric.AddOption) {
392 if ctr := i.delegate.Load(); ctr != nil {
393 ctr.(metric.Int64UpDownCounter).Add(ctx, x, opts...)
394 }
395 }
396
397 func (i *siUpDownCounter) Enabled(ctx context.Context) bool {
398 if ctr := i.delegate.Load(); ctr != nil {
399 return ctr.(metric.Int64UpDownCounter).Enabled(ctx)
400 }
401 return false
402 }
403
404 type siHistogram struct {
405 embedded.Int64Histogram
406
407 name string
408 opts []metric.Int64HistogramOption
409
410 delegate atomic.Value // metric.Int64Histogram
411 }
412
413 var _ metric.Int64Histogram = (*siHistogram)(nil)
414
415 func (i *siHistogram) setDelegate(m metric.Meter) {
416 ctr, err := m.Int64Histogram(i.name, i.opts...)
417 if err != nil {
418 GetErrorHandler().Handle(err)
419 return
420 }
421 i.delegate.Store(ctr)
422 }
423
424 func (i *siHistogram) Record(ctx context.Context, x int64, opts ...metric.RecordOption) {
425 if ctr := i.delegate.Load(); ctr != nil {
426 ctr.(metric.Int64Histogram).Record(ctx, x, opts...)
427 }
428 }
429
430 func (i *siHistogram) Enabled(ctx context.Context) bool {
431 if ctr := i.delegate.Load(); ctr != nil {
432 return ctr.(metric.Int64Histogram).Enabled(ctx)
433 }
434 return false
435 }
436
437 type siGauge struct {
438 embedded.Int64Gauge
439
440 name string
441 opts []metric.Int64GaugeOption
442
443 delegate atomic.Value // metric.Int64Gauge
444 }
445
446 var _ metric.Int64Gauge = (*siGauge)(nil)
447
448 func (i *siGauge) setDelegate(m metric.Meter) {
449 ctr, err := m.Int64Gauge(i.name, i.opts...)
450 if err != nil {
451 GetErrorHandler().Handle(err)
452 return
453 }
454 i.delegate.Store(ctr)
455 }
456
457 func (i *siGauge) Record(ctx context.Context, x int64, opts ...metric.RecordOption) {
458 if ctr := i.delegate.Load(); ctr != nil {
459 ctr.(metric.Int64Gauge).Record(ctx, x, opts...)
460 }
461 }
462
463 func (i *siGauge) Enabled(ctx context.Context) bool {
464 if ctr := i.delegate.Load(); ctr != nil {
465 return ctr.(metric.Int64Gauge).Enabled(ctx)
466 }
467 return false
468 }