1// Copyright The OpenTelemetry Authors
2// SPDX-License-Identifier: Apache-2.0
3
4package global // import "go.opentelemetry.io/otel/internal/global"
5
6import (
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.
15type unwrapper interface {
16 unwrap() metric.Observable
17}
18
19type 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
29var (
30 _ unwrapper = (*afCounter)(nil)
31 _ metric.Float64ObservableCounter = (*afCounter)(nil)
32)
33
34func (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
43func (i *afCounter) unwrap() metric.Observable {
44 if ctr := i.delegate.Load(); ctr != nil {
45 return ctr.(metric.Float64ObservableCounter)
46 }
47 return nil
48}
49
50type 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
60var (
61 _ unwrapper = (*afUpDownCounter)(nil)
62 _ metric.Float64ObservableUpDownCounter = (*afUpDownCounter)(nil)
63)
64
65func (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
74func (i *afUpDownCounter) unwrap() metric.Observable {
75 if ctr := i.delegate.Load(); ctr != nil {
76 return ctr.(metric.Float64ObservableUpDownCounter)
77 }
78 return nil
79}
80
81type 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
91var (
92 _ unwrapper = (*afGauge)(nil)
93 _ metric.Float64ObservableGauge = (*afGauge)(nil)
94)
95
96func (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
105func (i *afGauge) unwrap() metric.Observable {
106 if ctr := i.delegate.Load(); ctr != nil {
107 return ctr.(metric.Float64ObservableGauge)
108 }
109 return nil
110}
111
112type 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
122var (
123 _ unwrapper = (*aiCounter)(nil)
124 _ metric.Int64ObservableCounter = (*aiCounter)(nil)
125)
126
127func (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
136func (i *aiCounter) unwrap() metric.Observable {
137 if ctr := i.delegate.Load(); ctr != nil {
138 return ctr.(metric.Int64ObservableCounter)
139 }
140 return nil
141}
142
143type 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
153var (
154 _ unwrapper = (*aiUpDownCounter)(nil)
155 _ metric.Int64ObservableUpDownCounter = (*aiUpDownCounter)(nil)
156)
157
158func (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
167func (i *aiUpDownCounter) unwrap() metric.Observable {
168 if ctr := i.delegate.Load(); ctr != nil {
169 return ctr.(metric.Int64ObservableUpDownCounter)
170 }
171 return nil
172}
173
174type 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
184var (
185 _ unwrapper = (*aiGauge)(nil)
186 _ metric.Int64ObservableGauge = (*aiGauge)(nil)
187)
188
189func (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
198func (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.
206type sfCounter struct {
207 embedded.Float64Counter
208
209 name string
210 opts []metric.Float64CounterOption
211
212 delegate atomic.Value // metric.Float64Counter
213}
214
215var _ metric.Float64Counter = (*sfCounter)(nil)
216
217func (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
226func (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
232type sfUpDownCounter struct {
233 embedded.Float64UpDownCounter
234
235 name string
236 opts []metric.Float64UpDownCounterOption
237
238 delegate atomic.Value // metric.Float64UpDownCounter
239}
240
241var _ metric.Float64UpDownCounter = (*sfUpDownCounter)(nil)
242
243func (i *sfUpDownCounter) setDelegate(m metric.Meter) {
244 ctr, err := m.Float64UpDownCounter(i.name, i.opts...)
245 if err != nil {
246 GetErrorHandler().Handle(err)
247 return
248 }
249 i.delegate.Store(ctr)
250}
251
252func (i *sfUpDownCounter) Add(ctx context.Context, incr float64, opts ...metric.AddOption) {
253 if ctr := i.delegate.Load(); ctr != nil {
254 ctr.(metric.Float64UpDownCounter).Add(ctx, incr, opts...)
255 }
256}
257
258type sfHistogram struct {
259 embedded.Float64Histogram
260
261 name string
262 opts []metric.Float64HistogramOption
263
264 delegate atomic.Value // metric.Float64Histogram
265}
266
267var _ metric.Float64Histogram = (*sfHistogram)(nil)
268
269func (i *sfHistogram) setDelegate(m metric.Meter) {
270 ctr, err := m.Float64Histogram(i.name, i.opts...)
271 if err != nil {
272 GetErrorHandler().Handle(err)
273 return
274 }
275 i.delegate.Store(ctr)
276}
277
278func (i *sfHistogram) Record(ctx context.Context, x float64, opts ...metric.RecordOption) {
279 if ctr := i.delegate.Load(); ctr != nil {
280 ctr.(metric.Float64Histogram).Record(ctx, x, opts...)
281 }
282}
283
284type sfGauge struct {
285 embedded.Float64Gauge
286
287 name string
288 opts []metric.Float64GaugeOption
289
290 delegate atomic.Value // metric.Float64Gauge
291}
292
293var _ metric.Float64Gauge = (*sfGauge)(nil)
294
295func (i *sfGauge) setDelegate(m metric.Meter) {
296 ctr, err := m.Float64Gauge(i.name, i.opts...)
297 if err != nil {
298 GetErrorHandler().Handle(err)
299 return
300 }
301 i.delegate.Store(ctr)
302}
303
304func (i *sfGauge) Record(ctx context.Context, x float64, opts ...metric.RecordOption) {
305 if ctr := i.delegate.Load(); ctr != nil {
306 ctr.(metric.Float64Gauge).Record(ctx, x, opts...)
307 }
308}
309
310type siCounter struct {
311 embedded.Int64Counter
312
313 name string
314 opts []metric.Int64CounterOption
315
316 delegate atomic.Value // metric.Int64Counter
317}
318
319var _ metric.Int64Counter = (*siCounter)(nil)
320
321func (i *siCounter) setDelegate(m metric.Meter) {
322 ctr, err := m.Int64Counter(i.name, i.opts...)
323 if err != nil {
324 GetErrorHandler().Handle(err)
325 return
326 }
327 i.delegate.Store(ctr)
328}
329
330func (i *siCounter) Add(ctx context.Context, x int64, opts ...metric.AddOption) {
331 if ctr := i.delegate.Load(); ctr != nil {
332 ctr.(metric.Int64Counter).Add(ctx, x, opts...)
333 }
334}
335
336type siUpDownCounter struct {
337 embedded.Int64UpDownCounter
338
339 name string
340 opts []metric.Int64UpDownCounterOption
341
342 delegate atomic.Value // metric.Int64UpDownCounter
343}
344
345var _ metric.Int64UpDownCounter = (*siUpDownCounter)(nil)
346
347func (i *siUpDownCounter) setDelegate(m metric.Meter) {
348 ctr, err := m.Int64UpDownCounter(i.name, i.opts...)
349 if err != nil {
350 GetErrorHandler().Handle(err)
351 return
352 }
353 i.delegate.Store(ctr)
354}
355
356func (i *siUpDownCounter) Add(ctx context.Context, x int64, opts ...metric.AddOption) {
357 if ctr := i.delegate.Load(); ctr != nil {
358 ctr.(metric.Int64UpDownCounter).Add(ctx, x, opts...)
359 }
360}
361
362type siHistogram struct {
363 embedded.Int64Histogram
364
365 name string
366 opts []metric.Int64HistogramOption
367
368 delegate atomic.Value // metric.Int64Histogram
369}
370
371var _ metric.Int64Histogram = (*siHistogram)(nil)
372
373func (i *siHistogram) setDelegate(m metric.Meter) {
374 ctr, err := m.Int64Histogram(i.name, i.opts...)
375 if err != nil {
376 GetErrorHandler().Handle(err)
377 return
378 }
379 i.delegate.Store(ctr)
380}
381
382func (i *siHistogram) Record(ctx context.Context, x int64, opts ...metric.RecordOption) {
383 if ctr := i.delegate.Load(); ctr != nil {
384 ctr.(metric.Int64Histogram).Record(ctx, x, opts...)
385 }
386}
387
388type siGauge struct {
389 embedded.Int64Gauge
390
391 name string
392 opts []metric.Int64GaugeOption
393
394 delegate atomic.Value // metric.Int64Gauge
395}
396
397var _ metric.Int64Gauge = (*siGauge)(nil)
398
399func (i *siGauge) setDelegate(m metric.Meter) {
400 ctr, err := m.Int64Gauge(i.name, i.opts...)
401 if err != nil {
402 GetErrorHandler().Handle(err)
403 return
404 }
405 i.delegate.Store(ctr)
406}
407
408func (i *siGauge) Record(ctx context.Context, x int64, opts ...metric.RecordOption) {
409 if ctr := i.delegate.Load(); ctr != nil {
410 ctr.(metric.Int64Gauge).Record(ctx, x, opts...)
411 }
412}