instruments.go

Documentation: go.opentelemetry.io/otel/internal/global

     1  // Copyright The OpenTelemetry Authors
     2  //
     3  // Licensed under the Apache License, Version 2.0 (the "License");
     4  // you may not use this file except in compliance with the License.
     5  // You may obtain a copy of the License at
     6  //
     7  //     http://www.apache.org/licenses/LICENSE-2.0
     8  //
     9  // Unless required by applicable law or agreed to in writing, software
    10  // distributed under the License is distributed on an "AS IS" BASIS,
    11  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12  // See the License for the specific language governing permissions and
    13  // limitations under the License.
    14  
    15  package global // import "go.opentelemetry.io/otel/internal/global"
    16  
    17  import (
    18  	"context"
    19  	"sync/atomic"
    20  
    21  	"go.opentelemetry.io/otel/metric"
    22  	"go.opentelemetry.io/otel/metric/embedded"
    23  )
    24  
    25  // unwrapper unwraps to return the underlying instrument implementation.
    26  type unwrapper interface {
    27  	Unwrap() metric.Observable
    28  }
    29  
    30  type afCounter struct {
    31  	embedded.Float64ObservableCounter
    32  	metric.Float64Observable
    33  
    34  	name string
    35  	opts []metric.Float64ObservableCounterOption
    36  
    37  	delegate atomic.Value // metric.Float64ObservableCounter
    38  }
    39  
    40  var (
    41  	_ unwrapper                       = (*afCounter)(nil)
    42  	_ metric.Float64ObservableCounter = (*afCounter)(nil)
    43  )
    44  
    45  func (i *afCounter) setDelegate(m metric.Meter) {
    46  	ctr, err := m.Float64ObservableCounter(i.name, i.opts...)
    47  	if err != nil {
    48  		GetErrorHandler().Handle(err)
    49  		return
    50  	}
    51  	i.delegate.Store(ctr)
    52  }
    53  
    54  func (i *afCounter) Unwrap() metric.Observable {
    55  	if ctr := i.delegate.Load(); ctr != nil {
    56  		return ctr.(metric.Float64ObservableCounter)
    57  	}
    58  	return nil
    59  }
    60  
    61  type afUpDownCounter struct {
    62  	embedded.Float64ObservableUpDownCounter
    63  	metric.Float64Observable
    64  
    65  	name string
    66  	opts []metric.Float64ObservableUpDownCounterOption
    67  
    68  	delegate atomic.Value // metric.Float64ObservableUpDownCounter
    69  }
    70  
    71  var (
    72  	_ unwrapper                             = (*afUpDownCounter)(nil)
    73  	_ metric.Float64ObservableUpDownCounter = (*afUpDownCounter)(nil)
    74  )
    75  
    76  func (i *afUpDownCounter) setDelegate(m metric.Meter) {
    77  	ctr, err := m.Float64ObservableUpDownCounter(i.name, i.opts...)
    78  	if err != nil {
    79  		GetErrorHandler().Handle(err)
    80  		return
    81  	}
    82  	i.delegate.Store(ctr)
    83  }
    84  
    85  func (i *afUpDownCounter) Unwrap() metric.Observable {
    86  	if ctr := i.delegate.Load(); ctr != nil {
    87  		return ctr.(metric.Float64ObservableUpDownCounter)
    88  	}
    89  	return nil
    90  }
    91  
    92  type afGauge struct {
    93  	embedded.Float64ObservableGauge
    94  	metric.Float64Observable
    95  
    96  	name string
    97  	opts []metric.Float64ObservableGaugeOption
    98  
    99  	delegate atomic.Value // metric.Float64ObservableGauge
   100  }
   101  
   102  var (
   103  	_ unwrapper                     = (*afGauge)(nil)
   104  	_ metric.Float64ObservableGauge = (*afGauge)(nil)
   105  )
   106  
   107  func (i *afGauge) setDelegate(m metric.Meter) {
   108  	ctr, err := m.Float64ObservableGauge(i.name, i.opts...)
   109  	if err != nil {
   110  		GetErrorHandler().Handle(err)
   111  		return
   112  	}
   113  	i.delegate.Store(ctr)
   114  }
   115  
   116  func (i *afGauge) Unwrap() metric.Observable {
   117  	if ctr := i.delegate.Load(); ctr != nil {
   118  		return ctr.(metric.Float64ObservableGauge)
   119  	}
   120  	return nil
   121  }
   122  
   123  type aiCounter struct {
   124  	embedded.Int64ObservableCounter
   125  	metric.Int64Observable
   126  
   127  	name string
   128  	opts []metric.Int64ObservableCounterOption
   129  
   130  	delegate atomic.Value // metric.Int64ObservableCounter
   131  }
   132  
   133  var (
   134  	_ unwrapper                     = (*aiCounter)(nil)
   135  	_ metric.Int64ObservableCounter = (*aiCounter)(nil)
   136  )
   137  
   138  func (i *aiCounter) setDelegate(m metric.Meter) {
   139  	ctr, err := m.Int64ObservableCounter(i.name, i.opts...)
   140  	if err != nil {
   141  		GetErrorHandler().Handle(err)
   142  		return
   143  	}
   144  	i.delegate.Store(ctr)
   145  }
   146  
   147  func (i *aiCounter) Unwrap() metric.Observable {
   148  	if ctr := i.delegate.Load(); ctr != nil {
   149  		return ctr.(metric.Int64ObservableCounter)
   150  	}
   151  	return nil
   152  }
   153  
   154  type aiUpDownCounter struct {
   155  	embedded.Int64ObservableUpDownCounter
   156  	metric.Int64Observable
   157  
   158  	name string
   159  	opts []metric.Int64ObservableUpDownCounterOption
   160  
   161  	delegate atomic.Value // metric.Int64ObservableUpDownCounter
   162  }
   163  
   164  var (
   165  	_ unwrapper                           = (*aiUpDownCounter)(nil)
   166  	_ metric.Int64ObservableUpDownCounter = (*aiUpDownCounter)(nil)
   167  )
   168  
   169  func (i *aiUpDownCounter) setDelegate(m metric.Meter) {
   170  	ctr, err := m.Int64ObservableUpDownCounter(i.name, i.opts...)
   171  	if err != nil {
   172  		GetErrorHandler().Handle(err)
   173  		return
   174  	}
   175  	i.delegate.Store(ctr)
   176  }
   177  
   178  func (i *aiUpDownCounter) Unwrap() metric.Observable {
   179  	if ctr := i.delegate.Load(); ctr != nil {
   180  		return ctr.(metric.Int64ObservableUpDownCounter)
   181  	}
   182  	return nil
   183  }
   184  
   185  type aiGauge struct {
   186  	embedded.Int64ObservableGauge
   187  	metric.Int64Observable
   188  
   189  	name string
   190  	opts []metric.Int64ObservableGaugeOption
   191  
   192  	delegate atomic.Value // metric.Int64ObservableGauge
   193  }
   194  
   195  var (
   196  	_ unwrapper                   = (*aiGauge)(nil)
   197  	_ metric.Int64ObservableGauge = (*aiGauge)(nil)
   198  )
   199  
   200  func (i *aiGauge) setDelegate(m metric.Meter) {
   201  	ctr, err := m.Int64ObservableGauge(i.name, i.opts...)
   202  	if err != nil {
   203  		GetErrorHandler().Handle(err)
   204  		return
   205  	}
   206  	i.delegate.Store(ctr)
   207  }
   208  
   209  func (i *aiGauge) Unwrap() metric.Observable {
   210  	if ctr := i.delegate.Load(); ctr != nil {
   211  		return ctr.(metric.Int64ObservableGauge)
   212  	}
   213  	return nil
   214  }
   215  
   216  // Sync Instruments.
   217  type sfCounter struct {
   218  	embedded.Float64Counter
   219  
   220  	name string
   221  	opts []metric.Float64CounterOption
   222  
   223  	delegate atomic.Value // metric.Float64Counter
   224  }
   225  
   226  var _ metric.Float64Counter = (*sfCounter)(nil)
   227  
   228  func (i *sfCounter) setDelegate(m metric.Meter) {
   229  	ctr, err := m.Float64Counter(i.name, i.opts...)
   230  	if err != nil {
   231  		GetErrorHandler().Handle(err)
   232  		return
   233  	}
   234  	i.delegate.Store(ctr)
   235  }
   236  
   237  func (i *sfCounter) Add(ctx context.Context, incr float64, opts ...metric.AddOption) {
   238  	if ctr := i.delegate.Load(); ctr != nil {
   239  		ctr.(metric.Float64Counter).Add(ctx, incr, opts...)
   240  	}
   241  }
   242  
   243  type sfUpDownCounter struct {
   244  	embedded.Float64UpDownCounter
   245  
   246  	name string
   247  	opts []metric.Float64UpDownCounterOption
   248  
   249  	delegate atomic.Value // metric.Float64UpDownCounter
   250  }
   251  
   252  var _ metric.Float64UpDownCounter = (*sfUpDownCounter)(nil)
   253  
   254  func (i *sfUpDownCounter) setDelegate(m metric.Meter) {
   255  	ctr, err := m.Float64UpDownCounter(i.name, i.opts...)
   256  	if err != nil {
   257  		GetErrorHandler().Handle(err)
   258  		return
   259  	}
   260  	i.delegate.Store(ctr)
   261  }
   262  
   263  func (i *sfUpDownCounter) Add(ctx context.Context, incr float64, opts ...metric.AddOption) {
   264  	if ctr := i.delegate.Load(); ctr != nil {
   265  		ctr.(metric.Float64UpDownCounter).Add(ctx, incr, opts...)
   266  	}
   267  }
   268  
   269  type sfHistogram struct {
   270  	embedded.Float64Histogram
   271  
   272  	name string
   273  	opts []metric.Float64HistogramOption
   274  
   275  	delegate atomic.Value // metric.Float64Histogram
   276  }
   277  
   278  var _ metric.Float64Histogram = (*sfHistogram)(nil)
   279  
   280  func (i *sfHistogram) setDelegate(m metric.Meter) {
   281  	ctr, err := m.Float64Histogram(i.name, i.opts...)
   282  	if err != nil {
   283  		GetErrorHandler().Handle(err)
   284  		return
   285  	}
   286  	i.delegate.Store(ctr)
   287  }
   288  
   289  func (i *sfHistogram) Record(ctx context.Context, x float64, opts ...metric.RecordOption) {
   290  	if ctr := i.delegate.Load(); ctr != nil {
   291  		ctr.(metric.Float64Histogram).Record(ctx, x, opts...)
   292  	}
   293  }
   294  
   295  type siCounter struct {
   296  	embedded.Int64Counter
   297  
   298  	name string
   299  	opts []metric.Int64CounterOption
   300  
   301  	delegate atomic.Value // metric.Int64Counter
   302  }
   303  
   304  var _ metric.Int64Counter = (*siCounter)(nil)
   305  
   306  func (i *siCounter) setDelegate(m metric.Meter) {
   307  	ctr, err := m.Int64Counter(i.name, i.opts...)
   308  	if err != nil {
   309  		GetErrorHandler().Handle(err)
   310  		return
   311  	}
   312  	i.delegate.Store(ctr)
   313  }
   314  
   315  func (i *siCounter) Add(ctx context.Context, x int64, opts ...metric.AddOption) {
   316  	if ctr := i.delegate.Load(); ctr != nil {
   317  		ctr.(metric.Int64Counter).Add(ctx, x, opts...)
   318  	}
   319  }
   320  
   321  type siUpDownCounter struct {
   322  	embedded.Int64UpDownCounter
   323  
   324  	name string
   325  	opts []metric.Int64UpDownCounterOption
   326  
   327  	delegate atomic.Value // metric.Int64UpDownCounter
   328  }
   329  
   330  var _ metric.Int64UpDownCounter = (*siUpDownCounter)(nil)
   331  
   332  func (i *siUpDownCounter) setDelegate(m metric.Meter) {
   333  	ctr, err := m.Int64UpDownCounter(i.name, i.opts...)
   334  	if err != nil {
   335  		GetErrorHandler().Handle(err)
   336  		return
   337  	}
   338  	i.delegate.Store(ctr)
   339  }
   340  
   341  func (i *siUpDownCounter) Add(ctx context.Context, x int64, opts ...metric.AddOption) {
   342  	if ctr := i.delegate.Load(); ctr != nil {
   343  		ctr.(metric.Int64UpDownCounter).Add(ctx, x, opts...)
   344  	}
   345  }
   346  
   347  type siHistogram struct {
   348  	embedded.Int64Histogram
   349  
   350  	name string
   351  	opts []metric.Int64HistogramOption
   352  
   353  	delegate atomic.Value // metric.Int64Histogram
   354  }
   355  
   356  var _ metric.Int64Histogram = (*siHistogram)(nil)
   357  
   358  func (i *siHistogram) setDelegate(m metric.Meter) {
   359  	ctr, err := m.Int64Histogram(i.name, i.opts...)
   360  	if err != nil {
   361  		GetErrorHandler().Handle(err)
   362  		return
   363  	}
   364  	i.delegate.Store(ctr)
   365  }
   366  
   367  func (i *siHistogram) Record(ctx context.Context, x int64, opts ...metric.RecordOption) {
   368  	if ctr := i.delegate.Load(); ctr != nil {
   369  		ctr.(metric.Int64Histogram).Record(ctx, x, opts...)
   370  	}
   371  }
   372
View as plain text