noop.go

Documentation: go.opentelemetry.io/otel/metric/noop

     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 noop provides an implementation of the OpenTelemetry metric API that
    16  // produces no telemetry and minimizes used computation resources.
    17  //
    18  // Using this package to implement the OpenTelemetry metric API will
    19  // effectively disable OpenTelemetry.
    20  //
    21  // This implementation can be embedded in other implementations of the
    22  // OpenTelemetry metric API. Doing so will mean the implementation defaults to
    23  // no operation for methods it does not implement.
    24  package noop // import "go.opentelemetry.io/otel/metric/noop"
    25  
    26  import (
    27  	"context"
    28  
    29  	"go.opentelemetry.io/otel/metric"
    30  	"go.opentelemetry.io/otel/metric/embedded"
    31  )
    32  
    33  var (
    34  	// Compile-time check this implements the OpenTelemetry API.
    35  
    36  	_ metric.MeterProvider                  = MeterProvider{}
    37  	_ metric.Meter                          = Meter{}
    38  	_ metric.Observer                       = Observer{}
    39  	_ metric.Registration                   = Registration{}
    40  	_ metric.Int64Counter                   = Int64Counter{}
    41  	_ metric.Float64Counter                 = Float64Counter{}
    42  	_ metric.Int64UpDownCounter             = Int64UpDownCounter{}
    43  	_ metric.Float64UpDownCounter           = Float64UpDownCounter{}
    44  	_ metric.Int64Histogram                 = Int64Histogram{}
    45  	_ metric.Float64Histogram               = Float64Histogram{}
    46  	_ metric.Int64ObservableCounter         = Int64ObservableCounter{}
    47  	_ metric.Float64ObservableCounter       = Float64ObservableCounter{}
    48  	_ metric.Int64ObservableGauge           = Int64ObservableGauge{}
    49  	_ metric.Float64ObservableGauge         = Float64ObservableGauge{}
    50  	_ metric.Int64ObservableUpDownCounter   = Int64ObservableUpDownCounter{}
    51  	_ metric.Float64ObservableUpDownCounter = Float64ObservableUpDownCounter{}
    52  	_ metric.Int64Observer                  = Int64Observer{}
    53  	_ metric.Float64Observer                = Float64Observer{}
    54  )
    55  
    56  // MeterProvider is an OpenTelemetry No-Op MeterProvider.
    57  type MeterProvider struct{ embedded.MeterProvider }
    58  
    59  // NewMeterProvider returns a MeterProvider that does not record any telemetry.
    60  func NewMeterProvider() MeterProvider {
    61  	return MeterProvider{}
    62  }
    63  
    64  // Meter returns an OpenTelemetry Meter that does not record any telemetry.
    65  func (MeterProvider) Meter(string, ...metric.MeterOption) metric.Meter {
    66  	return Meter{}
    67  }
    68  
    69  // Meter is an OpenTelemetry No-Op Meter.
    70  type Meter struct{ embedded.Meter }
    71  
    72  // Int64Counter returns a Counter used to record int64 measurements that
    73  // produces no telemetry.
    74  func (Meter) Int64Counter(string, ...metric.Int64CounterOption) (metric.Int64Counter, error) {
    75  	return Int64Counter{}, nil
    76  }
    77  
    78  // Int64UpDownCounter returns an UpDownCounter used to record int64
    79  // measurements that produces no telemetry.
    80  func (Meter) Int64UpDownCounter(string, ...metric.Int64UpDownCounterOption) (metric.Int64UpDownCounter, error) {
    81  	return Int64UpDownCounter{}, nil
    82  }
    83  
    84  // Int64Histogram returns a Histogram used to record int64 measurements that
    85  // produces no telemetry.
    86  func (Meter) Int64Histogram(string, ...metric.Int64HistogramOption) (metric.Int64Histogram, error) {
    87  	return Int64Histogram{}, nil
    88  }
    89  
    90  // Int64ObservableCounter returns an ObservableCounter used to record int64
    91  // measurements that produces no telemetry.
    92  func (Meter) Int64ObservableCounter(string, ...metric.Int64ObservableCounterOption) (metric.Int64ObservableCounter, error) {
    93  	return Int64ObservableCounter{}, nil
    94  }
    95  
    96  // Int64ObservableUpDownCounter returns an ObservableUpDownCounter used to
    97  // record int64 measurements that produces no telemetry.
    98  func (Meter) Int64ObservableUpDownCounter(string, ...metric.Int64ObservableUpDownCounterOption) (metric.Int64ObservableUpDownCounter, error) {
    99  	return Int64ObservableUpDownCounter{}, nil
   100  }
   101  
   102  // Int64ObservableGauge returns an ObservableGauge used to record int64
   103  // measurements that produces no telemetry.
   104  func (Meter) Int64ObservableGauge(string, ...metric.Int64ObservableGaugeOption) (metric.Int64ObservableGauge, error) {
   105  	return Int64ObservableGauge{}, nil
   106  }
   107  
   108  // Float64Counter returns a Counter used to record int64 measurements that
   109  // produces no telemetry.
   110  func (Meter) Float64Counter(string, ...metric.Float64CounterOption) (metric.Float64Counter, error) {
   111  	return Float64Counter{}, nil
   112  }
   113  
   114  // Float64UpDownCounter returns an UpDownCounter used to record int64
   115  // measurements that produces no telemetry.
   116  func (Meter) Float64UpDownCounter(string, ...metric.Float64UpDownCounterOption) (metric.Float64UpDownCounter, error) {
   117  	return Float64UpDownCounter{}, nil
   118  }
   119  
   120  // Float64Histogram returns a Histogram used to record int64 measurements that
   121  // produces no telemetry.
   122  func (Meter) Float64Histogram(string, ...metric.Float64HistogramOption) (metric.Float64Histogram, error) {
   123  	return Float64Histogram{}, nil
   124  }
   125  
   126  // Float64ObservableCounter returns an ObservableCounter used to record int64
   127  // measurements that produces no telemetry.
   128  func (Meter) Float64ObservableCounter(string, ...metric.Float64ObservableCounterOption) (metric.Float64ObservableCounter, error) {
   129  	return Float64ObservableCounter{}, nil
   130  }
   131  
   132  // Float64ObservableUpDownCounter returns an ObservableUpDownCounter used to
   133  // record int64 measurements that produces no telemetry.
   134  func (Meter) Float64ObservableUpDownCounter(string, ...metric.Float64ObservableUpDownCounterOption) (metric.Float64ObservableUpDownCounter, error) {
   135  	return Float64ObservableUpDownCounter{}, nil
   136  }
   137  
   138  // Float64ObservableGauge returns an ObservableGauge used to record int64
   139  // measurements that produces no telemetry.
   140  func (Meter) Float64ObservableGauge(string, ...metric.Float64ObservableGaugeOption) (metric.Float64ObservableGauge, error) {
   141  	return Float64ObservableGauge{}, nil
   142  }
   143  
   144  // RegisterCallback performs no operation.
   145  func (Meter) RegisterCallback(metric.Callback, ...metric.Observable) (metric.Registration, error) {
   146  	return Registration{}, nil
   147  }
   148  
   149  // Observer acts as a recorder of measurements for multiple instruments in a
   150  // Callback, it performing no operation.
   151  type Observer struct{ embedded.Observer }
   152  
   153  // ObserveFloat64 performs no operation.
   154  func (Observer) ObserveFloat64(metric.Float64Observable, float64, ...metric.ObserveOption) {
   155  }
   156  
   157  // ObserveInt64 performs no operation.
   158  func (Observer) ObserveInt64(metric.Int64Observable, int64, ...metric.ObserveOption) {
   159  }
   160  
   161  // Registration is the registration of a Callback with a No-Op Meter.
   162  type Registration struct{ embedded.Registration }
   163  
   164  // Unregister unregisters the Callback the Registration represents with the
   165  // No-Op Meter. This will always return nil because the No-Op Meter performs no
   166  // operation, including hold any record of registrations.
   167  func (Registration) Unregister() error { return nil }
   168  
   169  // Int64Counter is an OpenTelemetry Counter used to record int64 measurements.
   170  // It produces no telemetry.
   171  type Int64Counter struct{ embedded.Int64Counter }
   172  
   173  // Add performs no operation.
   174  func (Int64Counter) Add(context.Context, int64, ...metric.AddOption) {}
   175  
   176  // Float64Counter is an OpenTelemetry Counter used to record float64
   177  // measurements. It produces no telemetry.
   178  type Float64Counter struct{ embedded.Float64Counter }
   179  
   180  // Add performs no operation.
   181  func (Float64Counter) Add(context.Context, float64, ...metric.AddOption) {}
   182  
   183  // Int64UpDownCounter is an OpenTelemetry UpDownCounter used to record int64
   184  // measurements. It produces no telemetry.
   185  type Int64UpDownCounter struct{ embedded.Int64UpDownCounter }
   186  
   187  // Add performs no operation.
   188  func (Int64UpDownCounter) Add(context.Context, int64, ...metric.AddOption) {}
   189  
   190  // Float64UpDownCounter is an OpenTelemetry UpDownCounter used to record
   191  // float64 measurements. It produces no telemetry.
   192  type Float64UpDownCounter struct{ embedded.Float64UpDownCounter }
   193  
   194  // Add performs no operation.
   195  func (Float64UpDownCounter) Add(context.Context, float64, ...metric.AddOption) {}
   196  
   197  // Int64Histogram is an OpenTelemetry Histogram used to record int64
   198  // measurements. It produces no telemetry.
   199  type Int64Histogram struct{ embedded.Int64Histogram }
   200  
   201  // Record performs no operation.
   202  func (Int64Histogram) Record(context.Context, int64, ...metric.RecordOption) {}
   203  
   204  // Float64Histogram is an OpenTelemetry Histogram used to record float64
   205  // measurements. It produces no telemetry.
   206  type Float64Histogram struct{ embedded.Float64Histogram }
   207  
   208  // Record performs no operation.
   209  func (Float64Histogram) Record(context.Context, float64, ...metric.RecordOption) {}
   210  
   211  // Int64ObservableCounter is an OpenTelemetry ObservableCounter used to record
   212  // int64 measurements. It produces no telemetry.
   213  type Int64ObservableCounter struct {
   214  	metric.Int64Observable
   215  	embedded.Int64ObservableCounter
   216  }
   217  
   218  // Float64ObservableCounter is an OpenTelemetry ObservableCounter used to record
   219  // float64 measurements. It produces no telemetry.
   220  type Float64ObservableCounter struct {
   221  	metric.Float64Observable
   222  	embedded.Float64ObservableCounter
   223  }
   224  
   225  // Int64ObservableGauge is an OpenTelemetry ObservableGauge used to record
   226  // int64 measurements. It produces no telemetry.
   227  type Int64ObservableGauge struct {
   228  	metric.Int64Observable
   229  	embedded.Int64ObservableGauge
   230  }
   231  
   232  // Float64ObservableGauge is an OpenTelemetry ObservableGauge used to record
   233  // float64 measurements. It produces no telemetry.
   234  type Float64ObservableGauge struct {
   235  	metric.Float64Observable
   236  	embedded.Float64ObservableGauge
   237  }
   238  
   239  // Int64ObservableUpDownCounter is an OpenTelemetry ObservableUpDownCounter
   240  // used to record int64 measurements. It produces no telemetry.
   241  type Int64ObservableUpDownCounter struct {
   242  	metric.Int64Observable
   243  	embedded.Int64ObservableUpDownCounter
   244  }
   245  
   246  // Float64ObservableUpDownCounter is an OpenTelemetry ObservableUpDownCounter
   247  // used to record float64 measurements. It produces no telemetry.
   248  type Float64ObservableUpDownCounter struct {
   249  	metric.Float64Observable
   250  	embedded.Float64ObservableUpDownCounter
   251  }
   252  
   253  // Int64Observer is a recorder of int64 measurements that performs no operation.
   254  type Int64Observer struct{ embedded.Int64Observer }
   255  
   256  // Observe performs no operation.
   257  func (Int64Observer) Observe(int64, ...metric.ObserveOption) {}
   258  
   259  // Float64Observer is a recorder of float64 measurements that performs no
   260  // operation.
   261  type Float64Observer struct{ embedded.Float64Observer }
   262  
   263  // Observe performs no operation.
   264  func (Float64Observer) Observe(float64, ...metric.ObserveOption) {}
   265
View as plain text