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 type sfUpDownCounter struct {
233 embedded.Float64UpDownCounter
234
235 name string
236 opts []metric.Float64UpDownCounterOption
237
238 delegate atomic.Value // metric.Float64UpDownCounter
239 }
240
241 var _ metric.Float64UpDownCounter = (*sfUpDownCounter)(nil)
242
243 func (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
252 func (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
258 type sfHistogram struct {
259 embedded.Float64Histogram
260
261 name string
262 opts []metric.Float64HistogramOption
263
264 delegate atomic.Value // metric.Float64Histogram
265 }
266
267 var _ metric.Float64Histogram = (*sfHistogram)(nil)
268
269 func (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
278 func (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
284 type sfGauge struct {
285 embedded.Float64Gauge
286
287 name string
288 opts []metric.Float64GaugeOption
289
290 delegate atomic.Value // metric.Float64Gauge
291 }
292
293 var _ metric.Float64Gauge = (*sfGauge)(nil)
294
295 func (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
304 func (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
310 type siCounter struct {
311 embedded.Int64Counter
312
313 name string
314 opts []metric.Int64CounterOption
315
316 delegate atomic.Value // metric.Int64Counter
317 }
318
319 var _ metric.Int64Counter = (*siCounter)(nil)
320
321 func (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
330 func (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
336 type siUpDownCounter struct {
337 embedded.Int64UpDownCounter
338
339 name string
340 opts []metric.Int64UpDownCounterOption
341
342 delegate atomic.Value // metric.Int64UpDownCounter
343 }
344
345 var _ metric.Int64UpDownCounter = (*siUpDownCounter)(nil)
346
347 func (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
356 func (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
362 type siHistogram struct {
363 embedded.Int64Histogram
364
365 name string
366 opts []metric.Int64HistogramOption
367
368 delegate atomic.Value // metric.Int64Histogram
369 }
370
371 var _ metric.Int64Histogram = (*siHistogram)(nil)
372
373 func (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
382 func (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
388 type siGauge struct {
389 embedded.Int64Gauge
390
391 name string
392 opts []metric.Int64GaugeOption
393
394 delegate atomic.Value // metric.Int64Gauge
395 }
396
397 var _ metric.Int64Gauge = (*siGauge)(nil)
398
399 func (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
408 func (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 }
413