package metric

Import Path
	go.opentelemetry.io/otel/metric (on go.dev)

Dependency Relation
	imports 3 packages, and imported by 6 packages

Involved Source Files

	    asyncfloat64.go
	    asyncint64.go
	    config.go
	  d doc.go
		Package metric provides the OpenTelemetry API used to measure metrics about
		source code operation.
		
		This API is separate from its implementation so the instrumentation built from
		it is reusable. See [go.opentelemetry.io/otel/sdk/metric] for the official
		OpenTelemetry implementation of this API.
		
		All measurements made with this package are made via instruments. These
		instruments are created by a [Meter] which itself is created by a
		[MeterProvider]. Applications need to accept a [MeterProvider] implementation
		as a starting point when instrumenting. This can be done directly, or by using
		the OpenTelemetry global MeterProvider via [GetMeterProvider]. Using an
		appropriately named [Meter] from the accepted [MeterProvider], instrumentation
		can then be built from the [Meter]'s instruments.
		
		# Instruments
		
		Each instrument is designed to make measurements of a particular type. Broadly,
		all instruments fall into two overlapping logical categories: asynchronous or
		synchronous, and int64 or float64.
		
		All synchronous instruments ([Int64Counter], [Int64UpDownCounter],
		[Int64Histogram], [Float64Counter], [Float64UpDownCounter], and
		[Float64Histogram]) are used to measure the operation and performance of source
		code during the source code execution. These instruments only make measurements
		when the source code they instrument is run.
		
		All asynchronous instruments ([Int64ObservableCounter],
		[Int64ObservableUpDownCounter], [Int64ObservableGauge],
		[Float64ObservableCounter], [Float64ObservableUpDownCounter], and
		[Float64ObservableGauge]) are used to measure metrics outside of the execution
		of source code. They are said to make "observations" via a callback function
		called once every measurement collection cycle.
		
		Each instrument is also grouped by the value type it measures. Either int64 or
		float64. The value being measured will dictate which instrument in these
		categories to use.
		
		Outside of these two broad categories, instruments are described by the
		function they are designed to serve. All Counters ([Int64Counter],
		[Float64Counter], [Int64ObservableCounter], and [Float64ObservableCounter]) are
		designed to measure values that never decrease in value, but instead only
		incrementally increase in value. UpDownCounters ([Int64UpDownCounter],
		[Float64UpDownCounter], [Int64ObservableUpDownCounter], and
		[Float64ObservableUpDownCounter]) on the other hand, are designed to measure
		values that can increase and decrease. When more information needs to be
		conveyed about all the synchronous measurements made during a collection cycle,
		a Histogram ([Int64Histogram] and [Float64Histogram]) should be used. Finally,
		when just the most recent measurement needs to be conveyed about an
		asynchronous measurement, a Gauge ([Int64ObservableGauge] and
		[Float64ObservableGauge]) should be used.
		
		See the [OpenTelemetry documentation] for more information about instruments
		and their intended use.
		
		# Instrument Name
		
		OpenTelemetry defines an [instrument name syntax] that restricts what
		instrument names are allowed.
		
		Instrument names should ...
		
		  - Not be empty.
		  - Have an alphabetic character as their first letter.
		  - Have any letter after the first be an alphanumeric character, ‘_’, ‘.’,
		    ‘-’, or ‘/’.
		  - Have a maximum length of 255 letters.
		
		To ensure compatibility with observability platforms, all instruments created
		need to conform to this syntax. Not all implementations of the API will validate
		these names, it is the callers responsibility to ensure compliance.
		
		# Measurements
		
		Measurements are made by recording values and information about the values with
		an instrument. How these measurements are recorded depends on the instrument.
		
		Measurements for synchronous instruments ([Int64Counter], [Int64UpDownCounter],
		[Int64Histogram], [Float64Counter], [Float64UpDownCounter], and
		[Float64Histogram]) are recorded using the instrument methods directly. All
		counter instruments have an Add method that is used to measure an increment
		value, and all histogram instruments have a Record method to measure a data
		point.
		
		Asynchronous instruments ([Int64ObservableCounter],
		[Int64ObservableUpDownCounter], [Int64ObservableGauge],
		[Float64ObservableCounter], [Float64ObservableUpDownCounter], and
		[Float64ObservableGauge]) record measurements within a callback function. The
		callback is registered with the Meter which ensures the callback is called once
		per collection cycle. A callback can be registered two ways: during the
		instrument's creation using an option, or later using the RegisterCallback
		method of the [Meter] that created the instrument.
		
		If the following criteria are met, an option ([WithInt64Callback] or
		[WithFloat64Callback]) can be used during the asynchronous instrument's
		creation to register a callback ([Int64Callback] or [Float64Callback],
		respectively):
		
		  - The measurement process is known when the instrument is created
		  - Only that instrument will make a measurement within the callback
		  - The callback never needs to be unregistered
		
		If the criteria are not met, use the RegisterCallback method of the [Meter] that
		created the instrument to register a [Callback].
		
		# API Implementations
		
		This package does not conform to the standard Go versioning policy, all of its
		interfaces may have methods added to them without a package major version bump.
		This non-standard API evolution could surprise an uninformed implementation
		author. They could unknowingly build their implementation in a way that would
		result in a runtime panic for their users that update to the new API.
		
		The API is designed to help inform an instrumentation author about this
		non-standard API evolution. It requires them to choose a default behavior for
		unimplemented interface methods. There are three behavior choices they can
		make:
		
		  - Compilation failure
		  - Panic
		  - Default to another implementation
		
		All interfaces in this API embed a corresponding interface from
		[go.opentelemetry.io/otel/metric/embedded]. If an author wants the default
		behavior of their implementations to be a compilation failure, signaling to
		their users they need to update to the latest version of that implementation,
		they need to embed the corresponding interface from
		[go.opentelemetry.io/otel/metric/embedded] in their implementation. For
		example,
		
			import "go.opentelemetry.io/otel/metric/embedded"
		
			type MeterProvider struct {
				embedded.MeterProvider
				// ...
			}
		
		If an author wants the default behavior of their implementations to a panic,
		they need to embed the API interface directly.
		
			import "go.opentelemetry.io/otel/metric"
		
			type MeterProvider struct {
				metric.MeterProvider
				// ...
			}
		
		This is not a recommended behavior as it could lead to publishing packages that
		contain runtime panics when users update other package that use newer versions
		of [go.opentelemetry.io/otel/metric].
		
		Finally, an author can embed another implementation in theirs. The embedded
		implementation will be used for methods not defined by the author. For example,
		an author who wants to default to silently dropping the call can use
		[go.opentelemetry.io/otel/metric/noop]:
		
			import "go.opentelemetry.io/otel/metric/noop"
		
			type MeterProvider struct {
				noop.MeterProvider
				// ...
			}
		
		It is strongly recommended that authors only embed
		[go.opentelemetry.io/otel/metric/noop] if they choose this default behavior.
		That implementation is the only one OpenTelemetry authors can guarantee will
		fully implement all the API interfaces when a user updates their API.

	    instrument.go
	    meter.go
	    syncfloat64.go
	    syncint64.go
Code Examples

	Meter_asynchronous_multiple
		package main
		
		import (
			"context"
			"fmt"
			"runtime"
		
			"go.opentelemetry.io/otel"
			"go.opentelemetry.io/otel/metric"
		)
		
		var meter = otel.Meter("my-service-meter")
		
		func main() {
			// This is just a sample of memory stats to record from the Memstats
			heapAlloc, err := meter.Int64ObservableUpDownCounter("heapAllocs")
			if err != nil {
				fmt.Println("failed to register updown counter for heapAllocs")
				panic(err)
			}
			gcCount, err := meter.Int64ObservableCounter("gcCount")
			if err != nil {
				fmt.Println("failed to register counter for gcCount")
				panic(err)
			}
		
			_, err = meter.RegisterCallback(
				func(_ context.Context, o metric.Observer) error {
					memStats := &runtime.MemStats{}
					// This call does work
					runtime.ReadMemStats(memStats)
		
					o.ObserveInt64(heapAlloc, int64(memStats.HeapAlloc))
					o.ObserveInt64(gcCount, int64(memStats.NumGC))
		
					return nil
				},
				heapAlloc,
				gcCount,
			)
			if err != nil {
				fmt.Println("Failed to register callback")
				panic(err)
			}
		}

	Meter_asynchronous_single
		package main
		
		import (
			"context"
			"fmt"
		
			"go.opentelemetry.io/otel"
			"go.opentelemetry.io/otel/attribute"
			"go.opentelemetry.io/otel/metric"
		)
		
		var meter = otel.Meter("my-service-meter")
		
		func main() {
			_, err := meter.Int64ObservableGauge(
				"DiskUsage",
				metric.WithUnit("By"),
				metric.WithInt64Callback(func(_ context.Context, obsrv metric.Int64Observer) error {
					// Do the real work here to get the real disk usage. For example,
					//
					//   usage, err := GetDiskUsage(diskID)
					//   if err != nil {
					//   	if retryable(err) {
					//   		// Retry the usage measurement.
					//   	} else {
					//   		return err
					//   	}
					//   }
					//
					// For demonstration purpose, a static value is used here.
					usage := 75000
					obsrv.Observe(int64(usage), metric.WithAttributes(attribute.Int("disk.id", 3)))
					return nil
				}),
			)
			if err != nil {
				fmt.Println("failed to register instrument")
				panic(err)
			}
		}

	Meter_attributes
		package main
		
		import (
			"net/http"
		
			"go.opentelemetry.io/otel"
			"go.opentelemetry.io/otel/metric"
		
			semconv "go.opentelemetry.io/otel/semconv/v1.37.0"
		)
		
		var meter = otel.Meter("my-service-meter")
		
		func main() {
			apiCounter, err := meter.Int64UpDownCounter(
				"api.finished.counter",
				metric.WithDescription("Number of finished API calls."),
				metric.WithUnit("{call}"),
			)
			if err != nil {
				panic(err)
			}
			http.HandleFunc("/", func(_ http.ResponseWriter, r *http.Request) {
				// do some work in an API call and set the response HTTP status code
				statusCode := http.StatusOK
		
				apiCounter.Add(r.Context(), 1,
					metric.WithAttributes(semconv.HTTPResponseStatusCode(statusCode)))
			})
		}

	Meter_counter
		package main
		
		import (
			"net/http"
		
			"go.opentelemetry.io/otel"
			"go.opentelemetry.io/otel/metric"
		)
		
		var meter = otel.Meter("my-service-meter")
		
		func main() {
			apiCounter, err := meter.Int64Counter(
				"api.counter",
				metric.WithDescription("Number of API calls."),
				metric.WithUnit("{call}"),
			)
			if err != nil {
				panic(err)
			}
			http.HandleFunc("/", func(_ http.ResponseWriter, r *http.Request) {
				apiCounter.Add(r.Context(), 1)
		
				// do some work in an API call
			})
		}

	Meter_gauge
	  {
	  	speedGauge, err := meter.Int64Gauge(
	  		"cpu.fan.speed",
	  		metric.WithDescription("Speed of CPU fan"),
	  		metric.WithUnit("RPM"),
	  	)
	  	if err != nil {
	  		panic(err)
	  	}
	  
	  	getCPUFanSpeed := func() int64 {
	  
	  		return int64(1500 + rand.IntN(1000))
	  	}
	  
	  	fanSpeedSubscription := make(chan int64, 1)
	  	go func() {
	  		defer close(fanSpeedSubscription)
	  
	  		for range 5 {
	  
	  			time.Sleep(time.Duration(rand.IntN(3)) * time.Second)
	  			fanSpeed := getCPUFanSpeed()
	  			fanSpeedSubscription <- fanSpeed
	  		}
	  	}()
	  
	  	ctx := context.Background()
	  	for fanSpeed := range fanSpeedSubscription {
	  		speedGauge.Record(ctx, fanSpeed)
	  	}
	  }
	Meter_histogram
		package main
		
		import (
			"net/http"
			"time"
		
			"go.opentelemetry.io/otel"
			"go.opentelemetry.io/otel/metric"
		)
		
		var meter = otel.Meter("my-service-meter")
		
		func main() {
			histogram, err := meter.Float64Histogram(
				"task.duration",
				metric.WithDescription("The duration of task execution."),
				metric.WithUnit("s"),
				metric.WithExplicitBucketBoundaries(.005, .01, .025, .05, .075, .1, .25, .5, .75, 1, 2.5, 5, 7.5, 10),
			)
			if err != nil {
				panic(err)
			}
			http.HandleFunc("/", func(_ http.ResponseWriter, r *http.Request) {
				start := time.Now()
		
				// do some work in an API call
		
				duration := time.Since(start)
				histogram.Record(r.Context(), duration.Seconds())
			})
		}

	Meter_observableCounter
		package main
		
		import (
			"context"
			"time"
		
			"go.opentelemetry.io/otel"
			"go.opentelemetry.io/otel/metric"
		)
		
		var meter = otel.Meter("my-service-meter")
		
		func main() {
			start := time.Now()
			if _, err := meter.Float64ObservableCounter(
				"uptime",
				metric.WithDescription("The duration since the application started."),
				metric.WithUnit("s"),
				metric.WithFloat64Callback(func(_ context.Context, o metric.Float64Observer) error {
					o.Observe(float64(time.Since(start).Seconds()))
					return nil
				}),
			); err != nil {
				panic(err)
			}
		}

	Meter_observableGauge
		package main
		
		import (
			"context"
			"runtime"
		
			"go.opentelemetry.io/otel"
			"go.opentelemetry.io/otel/metric"
		)
		
		var meter = otel.Meter("my-service-meter")
		
		func main() {
			if _, err := meter.Int64ObservableGauge(
				"memory.heap",
				metric.WithDescription(
					"Memory usage of the allocated heap objects.",
				),
				metric.WithUnit("By"),
				metric.WithInt64Callback(func(_ context.Context, o metric.Int64Observer) error {
					var m runtime.MemStats
					runtime.ReadMemStats(&m)
					o.Observe(int64(m.HeapAlloc))
					return nil
				}),
			); err != nil {
				panic(err)
			}
		}

	Meter_observableUpDownCounter
		package main
		
		import (
			"context"
			"database/sql"
		
			"go.opentelemetry.io/otel/metric"
		)
		
		func main() {
			// The function registers asynchronous metrics for the provided db.
			// Make sure to unregister metric.Registration before closing the provided db.
			_ = func(db *sql.DB, meter metric.Meter, _ string) (metric.Registration, error) {
				m, err := meter.Int64ObservableUpDownCounter(
					"db.client.connections.max",
					metric.WithDescription("The maximum number of open connections allowed."),
					metric.WithUnit("{connection}"),
				)
				if err != nil {
					return nil, err
				}
		
				waitTime, err := meter.Int64ObservableUpDownCounter(
					"db.client.connections.wait_time",
					metric.WithDescription("The time it took to obtain an open connection from the pool."),
					metric.WithUnit("ms"),
				)
				if err != nil {
					return nil, err
				}
		
				reg, err := meter.RegisterCallback(
					func(_ context.Context, o metric.Observer) error {
						stats := db.Stats()
						o.ObserveInt64(m, int64(stats.MaxOpenConnections))
						o.ObserveInt64(waitTime, int64(stats.WaitDuration))
						return nil
					},
					m,
					waitTime,
				)
				if err != nil {
					return nil, err
				}
				return reg, nil
			}
		}

	Meter_synchronous
		package main
		
		import (
			"context"
			"fmt"
			"time"
		
			"go.opentelemetry.io/otel"
			"go.opentelemetry.io/otel/metric"
		)
		
		var meter = otel.Meter("my-service-meter")
		
		func main() {
			// Create a histogram using the global MeterProvider.
			workDuration, err := meter.Int64Histogram(
				"workDuration",
				metric.WithUnit("ms"))
			if err != nil {
				fmt.Println("Failed to register instrument")
				panic(err)
			}
		
			startTime := time.Now()
			ctx := context.Background()
			// Do work
			// ...
			workDuration.Record(ctx, time.Since(startTime).Milliseconds())
		}

	Meter_upDownCounter
		package main
		
		import (
			"context"
		
			"go.opentelemetry.io/otel"
			"go.opentelemetry.io/otel/metric"
		)
		
		var meter = otel.Meter("my-service-meter")
		
		func main() {
			var err error
			itemsCounter, err := meter.Int64UpDownCounter(
				"items.counter",
				metric.WithDescription("Number of items."),
				metric.WithUnit("{item}"),
			)
			if err != nil {
				panic(err)
			}
		
			_ = func() {
				// code that adds an item to the collection
				itemsCounter.Add(context.Background(), 1)
			}
		
			_ = func() {
				// code that removes an item from the collection
				itemsCounter.Add(context.Background(), -1)
			}
		}


Package-Level Type Names (total 67)

	/* sort by: alphabet | popularity */
	 type AddConfig (struct)
		AddConfig contains options for an addition measurement.


		Methods (only one)
			( AddConfig) Attributes() attribute.Set
				Attributes returns the configured attribute set.


		As Outputs Of (at least one exported)
			func NewAddConfig(opts []AddOption) AddConfig

	 type AddOption (interface)
		AddOption applies options to an addition measurement. See
		[MeasurementOption] for other options that can be used as an AddOption.

		Implemented By (at least one exported)
			 MeasurementOption (interface)
		As Inputs Of (at least 9)
			func NewAddConfig(opts []AddOption) AddConfig
			func Float64Counter.Add(ctx context.Context, incr float64, options ...AddOption)
			func Float64UpDownCounter.Add(ctx context.Context, incr float64, options ...AddOption)
			func Int64Counter.Add(ctx context.Context, incr int64, options ...AddOption)
			func Int64UpDownCounter.Add(ctx context.Context, incr int64, options ...AddOption)
			func go.opentelemetry.io/otel/metric/noop.Float64Counter.Add(context.Context, float64, ...AddOption)
			func go.opentelemetry.io/otel/metric/noop.Float64UpDownCounter.Add(context.Context, float64, ...AddOption)
			func go.opentelemetry.io/otel/metric/noop.Int64Counter.Add(context.Context, int64, ...AddOption)
			func go.opentelemetry.io/otel/metric/noop.Int64UpDownCounter.Add(context.Context, int64, ...AddOption)

	 type Callback (func)
		Callback is a function registered with a Meter that makes observations for
		the set of instruments it is registered with. The Observer parameter is used
		to record measurement observations for these instruments.
		
		The function needs to complete in a finite amount of time and the deadline
		of the passed context is expected to be honored.
		
		The function needs to make unique observations across all registered
		Callbacks. Meaning, it should not report measurements for an instrument with
		the same attributes as another Callback will report.
		
		The function needs to be concurrent safe.

		As Inputs Of (at least 2)
			func Meter.RegisterCallback(f Callback, instruments ...Observable) (Registration, error)
			func go.opentelemetry.io/otel/metric/noop.Meter.RegisterCallback(Callback, ...Observable) (Registration, error)

	 type Float64Callback (func)
		Float64Callback is a function registered with a Meter that makes
		observations for a Float64Observable instrument it is registered with.
		Calls to the Float64Observer record measurement values for the
		Float64Observable.
		
		The function needs to complete in a finite amount of time and the deadline
		of the passed context is expected to be honored.
		
		The function needs to make unique observations across all registered
		Float64Callbacks. Meaning, it should not report measurements with the same
		attributes as another Float64Callbacks also registered for the same
		instrument.
		
		The function needs to be concurrent safe.

		As Outputs Of (at least 3)
			func Float64ObservableCounterConfig.Callbacks() []Float64Callback
			func Float64ObservableGaugeConfig.Callbacks() []Float64Callback
			func Float64ObservableUpDownCounterConfig.Callbacks() []Float64Callback
		As Inputs Of (at least one exported)
			func WithFloat64Callback(callback Float64Callback) Float64ObservableOption

	 type Float64Counter (interface)
		Float64Counter is an instrument that records increasing float64 values.
		
		Warning: Methods may be added to this interface in minor releases. See
		package documentation on API implementation for information on how to set
		default behavior for unimplemented methods.

		Methods (only one)
			( Float64Counter) Add(ctx context.Context, incr float64, options ...AddOption)
				Add records a change to the counter.
				
				Use the WithAttributeSet (or, if performance is not a concern,
				the WithAttributes) option to include measurement attributes.

		Implemented By (at least one exported)
			 go.opentelemetry.io/otel/metric/noop.Float64Counter
		Implements (at least one exported)
			 Float64Counter : go.opentelemetry.io/otel/metric/embedded.Float64Counter
		As Outputs Of (at least 2)
			func Meter.Float64Counter(name string, options ...Float64CounterOption) (Float64Counter, error)
			func go.opentelemetry.io/otel/metric/noop.Meter.Float64Counter(string, ...Float64CounterOption) (Float64Counter, error)

	 type Float64CounterConfig (struct)
		Float64CounterConfig contains options for synchronous counter instruments that
		record float64 values.

		Methods (total 2)
			( Float64CounterConfig) Description() string
				Description returns the configured description.

			( Float64CounterConfig) Unit() string
				Unit returns the configured unit.

		Implements (at least one exported)
			 Float64CounterConfig : github.com/alexflint/go-arg.Described
		As Outputs Of (at least one exported)
			func NewFloat64CounterConfig(opts ...Float64CounterOption) Float64CounterConfig

	 type Float64CounterOption (interface)
		Float64CounterOption applies options to a [Float64CounterConfig]. See
		[InstrumentOption] for other options that can be used as a
		Float64CounterOption.

		Implemented By (at least one exported)
			 InstrumentOption (interface)
		As Inputs Of (at least 3)
			func NewFloat64CounterConfig(opts ...Float64CounterOption) Float64CounterConfig
			func Meter.Float64Counter(name string, options ...Float64CounterOption) (Float64Counter, error)
			func go.opentelemetry.io/otel/metric/noop.Meter.Float64Counter(string, ...Float64CounterOption) (Float64Counter, error)

	 type Float64Gauge (interface)
		Float64Gauge is an instrument that records instantaneous float64 values.
		
		Warning: Methods may be added to this interface in minor releases. See
		package documentation on API implementation for information on how to set
		default behavior for unimplemented methods.

		Methods (only one)
			( Float64Gauge) Record(ctx context.Context, value float64, options ...RecordOption)
				Record records the instantaneous value.
				
				Use the WithAttributeSet (or, if performance is not a concern,
				the WithAttributes) option to include measurement attributes.

		Implemented By (at least one exported)
			 go.opentelemetry.io/otel/metric/noop.Float64Gauge
		Implements (at least one exported)
			 Float64Gauge : go.opentelemetry.io/otel/metric/embedded.Float64Gauge
		As Outputs Of (at least 2)
			func Meter.Float64Gauge(name string, options ...Float64GaugeOption) (Float64Gauge, error)
			func go.opentelemetry.io/otel/metric/noop.Meter.Float64Gauge(string, ...Float64GaugeOption) (Float64Gauge, error)

	 type Float64GaugeConfig (struct)
		Float64GaugeConfig contains options for synchronous gauge instruments that
		record float64 values.

		Methods (total 2)
			( Float64GaugeConfig) Description() string
				Description returns the configured description.

			( Float64GaugeConfig) Unit() string
				Unit returns the configured unit.

		Implements (at least one exported)
			 Float64GaugeConfig : github.com/alexflint/go-arg.Described
		As Outputs Of (at least one exported)
			func NewFloat64GaugeConfig(opts ...Float64GaugeOption) Float64GaugeConfig

	 type Float64GaugeOption (interface)
		Float64GaugeOption applies options to a [Float64GaugeConfig]. See
		[InstrumentOption] for other options that can be used as a
		Float64GaugeOption.

		Implemented By (at least one exported)
			 InstrumentOption (interface)
		As Inputs Of (at least 3)
			func NewFloat64GaugeConfig(opts ...Float64GaugeOption) Float64GaugeConfig
			func Meter.Float64Gauge(name string, options ...Float64GaugeOption) (Float64Gauge, error)
			func go.opentelemetry.io/otel/metric/noop.Meter.Float64Gauge(string, ...Float64GaugeOption) (Float64Gauge, error)

	 type Float64Histogram (interface)
		Float64Histogram is an instrument that records a distribution of float64
		values.
		
		Warning: Methods may be added to this interface in minor releases. See
		package documentation on API implementation for information on how to set
		default behavior for unimplemented methods.

		Methods (only one)
			( Float64Histogram) Record(ctx context.Context, incr float64, options ...RecordOption)
				Record adds an additional value to the distribution.
				
				Use the WithAttributeSet (or, if performance is not a concern,
				the WithAttributes) option to include measurement attributes.

		Implemented By (at least one exported)
			 go.opentelemetry.io/otel/metric/noop.Float64Histogram
		Implements (at least one exported)
			 Float64Histogram : go.opentelemetry.io/otel/metric/embedded.Float64Histogram
		As Outputs Of (at least 4)
			func Meter.Float64Histogram(name string, options ...Float64HistogramOption) (Float64Histogram, error)
			func go.opentelemetry.io/otel/metric/noop.Meter.Float64Histogram(string, ...Float64HistogramOption) (Float64Histogram, error)
			func go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.SDKExporterOperationDuration.Inst() Float64Histogram
			func go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.SDKMetricReaderCollectionDuration.Inst() Float64Histogram

	 type Float64HistogramConfig (struct)
		Float64HistogramConfig contains options for synchronous histogram
		instruments that record float64 values.

		Methods (total 3)
			( Float64HistogramConfig) Description() string
				Description returns the configured description.

			( Float64HistogramConfig) ExplicitBucketBoundaries() []float64
				ExplicitBucketBoundaries returns the configured explicit bucket boundaries.

			( Float64HistogramConfig) Unit() string
				Unit returns the configured unit.

		Implements (at least one exported)
			 Float64HistogramConfig : github.com/alexflint/go-arg.Described
		As Outputs Of (at least one exported)
			func NewFloat64HistogramConfig(opts ...Float64HistogramOption) Float64HistogramConfig

	 type Float64HistogramOption (interface)
		Float64HistogramOption applies options to a [Float64HistogramConfig]. See
		[InstrumentOption] for other options that can be used as a
		Float64HistogramOption.

		Implemented By (at least 2)
			 HistogramOption (interface)
			 InstrumentOption (interface)
		As Inputs Of (at least 5)
			func NewFloat64HistogramConfig(opts ...Float64HistogramOption) Float64HistogramConfig
			func Meter.Float64Histogram(name string, options ...Float64HistogramOption) (Float64Histogram, error)
			func go.opentelemetry.io/otel/metric/noop.Meter.Float64Histogram(string, ...Float64HistogramOption) (Float64Histogram, error)
			func go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.NewSDKExporterOperationDuration(m Meter, opt ...Float64HistogramOption) (otelconv.SDKExporterOperationDuration, error)
			func go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.NewSDKMetricReaderCollectionDuration(m Meter, opt ...Float64HistogramOption) (otelconv.SDKMetricReaderCollectionDuration, error)

	 type Float64Observable (interface)
		Float64Observable describes a set of instruments used asynchronously to
		record float64 measurements once per collection cycle. Observations of
		these instruments are only made within a callback.
		
		Warning: Methods may be added to this interface in minor releases.

		Implemented By (at least 6)
			 Float64ObservableCounter (interface)
			 Float64ObservableGauge (interface)
			 Float64ObservableUpDownCounter (interface)
			 go.opentelemetry.io/otel/metric/noop.Float64ObservableCounter
			 go.opentelemetry.io/otel/metric/noop.Float64ObservableGauge
			 go.opentelemetry.io/otel/metric/noop.Float64ObservableUpDownCounter
		Implements (at least one exported)
			 Float64Observable : Observable
		As Inputs Of (at least 2)
			func Observer.ObserveFloat64(obsrv Float64Observable, value float64, opts ...ObserveOption)
			func go.opentelemetry.io/otel/metric/noop.Observer.ObserveFloat64(Float64Observable, float64, ...ObserveOption)

	 type Float64ObservableCounter (interface)
		Float64ObservableCounter is an instrument used to asynchronously record
		increasing float64 measurements once per collection cycle. Observations are
		only made within a callback for this instrument. The value observed is
		assumed the to be the cumulative sum of the count.
		
		Warning: Methods may be added to this interface in minor releases. See
		package documentation on API implementation for information on how to set
		default behavior for
		unimplemented methods.

		Implemented By (at least one exported)
			 go.opentelemetry.io/otel/metric/noop.Float64ObservableCounter
		Implements (at least 3)
			 Float64ObservableCounter : Float64Observable
			 Float64ObservableCounter : Observable
			 Float64ObservableCounter : go.opentelemetry.io/otel/metric/embedded.Float64ObservableCounter
		As Outputs Of (at least 2)
			func Meter.Float64ObservableCounter(name string, options ...Float64ObservableCounterOption) (Float64ObservableCounter, error)
			func go.opentelemetry.io/otel/metric/noop.Meter.Float64ObservableCounter(string, ...Float64ObservableCounterOption) (Float64ObservableCounter, error)

	 type Float64ObservableCounterConfig (struct)
		Float64ObservableCounterConfig contains options for asynchronous counter
		instruments that record float64 values.

		Methods (total 3)
			( Float64ObservableCounterConfig) Callbacks() []Float64Callback
				Callbacks returns the configured callbacks.

			( Float64ObservableCounterConfig) Description() string
				Description returns the configured description.

			( Float64ObservableCounterConfig) Unit() string
				Unit returns the configured unit.

		Implements (at least one exported)
			 Float64ObservableCounterConfig : github.com/alexflint/go-arg.Described
		As Outputs Of (at least one exported)
			func NewFloat64ObservableCounterConfig(opts ...Float64ObservableCounterOption) Float64ObservableCounterConfig

	 type Float64ObservableCounterOption (interface)
		Float64ObservableCounterOption applies options to a
		[Float64ObservableCounterConfig]. See [Float64ObservableOption] and
		[InstrumentOption] for other options that can be used as a
		Float64ObservableCounterOption.

		Implemented By (at least 2)
			 Float64ObservableOption (interface)
			 InstrumentOption (interface)
		As Inputs Of (at least 3)
			func NewFloat64ObservableCounterConfig(opts ...Float64ObservableCounterOption) Float64ObservableCounterConfig
			func Meter.Float64ObservableCounter(name string, options ...Float64ObservableCounterOption) (Float64ObservableCounter, error)
			func go.opentelemetry.io/otel/metric/noop.Meter.Float64ObservableCounter(string, ...Float64ObservableCounterOption) (Float64ObservableCounter, error)

	 type Float64ObservableGauge (interface)
		Float64ObservableGauge is an instrument used to asynchronously record
		instantaneous float64 measurements once per collection cycle. Observations
		are only made within a callback for this instrument.
		
		Warning: Methods may be added to this interface in minor releases. See
		package documentation on API implementation for information on how to set
		default behavior for unimplemented methods.

		Implemented By (at least one exported)
			 go.opentelemetry.io/otel/metric/noop.Float64ObservableGauge
		Implements (at least 3)
			 Float64ObservableGauge : Float64Observable
			 Float64ObservableGauge : Observable
			 Float64ObservableGauge : go.opentelemetry.io/otel/metric/embedded.Float64ObservableGauge
		As Outputs Of (at least 2)
			func Meter.Float64ObservableGauge(name string, options ...Float64ObservableGaugeOption) (Float64ObservableGauge, error)
			func go.opentelemetry.io/otel/metric/noop.Meter.Float64ObservableGauge(string, ...Float64ObservableGaugeOption) (Float64ObservableGauge, error)

	 type Float64ObservableGaugeConfig (struct)
		Float64ObservableGaugeConfig contains options for asynchronous counter
		instruments that record float64 values.

		Methods (total 3)
			( Float64ObservableGaugeConfig) Callbacks() []Float64Callback
				Callbacks returns the configured callbacks.

			( Float64ObservableGaugeConfig) Description() string
				Description returns the configured description.

			( Float64ObservableGaugeConfig) Unit() string
				Unit returns the configured unit.

		Implements (at least one exported)
			 Float64ObservableGaugeConfig : github.com/alexflint/go-arg.Described
		As Outputs Of (at least one exported)
			func NewFloat64ObservableGaugeConfig(opts ...Float64ObservableGaugeOption) Float64ObservableGaugeConfig

	 type Float64ObservableGaugeOption (interface)
		Float64ObservableGaugeOption applies options to a
		[Float64ObservableGaugeConfig]. See [Float64ObservableOption] and
		[InstrumentOption] for other options that can be used as a
		Float64ObservableGaugeOption.

		Implemented By (at least 2)
			 Float64ObservableOption (interface)
			 InstrumentOption (interface)
		As Inputs Of (at least 3)
			func NewFloat64ObservableGaugeConfig(opts ...Float64ObservableGaugeOption) Float64ObservableGaugeConfig
			func Meter.Float64ObservableGauge(name string, options ...Float64ObservableGaugeOption) (Float64ObservableGauge, error)
			func go.opentelemetry.io/otel/metric/noop.Meter.Float64ObservableGauge(string, ...Float64ObservableGaugeOption) (Float64ObservableGauge, error)

	 type Float64ObservableOption (interface)
		Float64ObservableOption applies options to float64 Observer instruments.

		Implemented By (at least one exported)
			 InstrumentOption (interface)
		Implements (at least 3)
			 Float64ObservableOption : Float64ObservableCounterOption
			 Float64ObservableOption : Float64ObservableGaugeOption
			 Float64ObservableOption : Float64ObservableUpDownCounterOption
		As Outputs Of (at least one exported)
			func WithFloat64Callback(callback Float64Callback) Float64ObservableOption

	 type Float64ObservableUpDownCounter (interface)
		Float64ObservableUpDownCounter is an instrument used to asynchronously
		record float64 measurements once per collection cycle. Observations are only
		made within a callback for this instrument. The value observed is assumed
		the to be the cumulative sum of the count.
		
		Warning: Methods may be added to this interface in minor releases. See
		package documentation on API implementation for information on how to set
		default behavior for unimplemented methods.

		Implemented By (at least one exported)
			 go.opentelemetry.io/otel/metric/noop.Float64ObservableUpDownCounter
		Implements (at least 3)
			 Float64ObservableUpDownCounter : Float64Observable
			 Float64ObservableUpDownCounter : Observable
			 Float64ObservableUpDownCounter : go.opentelemetry.io/otel/metric/embedded.Float64ObservableUpDownCounter
		As Outputs Of (at least 2)
			func Meter.Float64ObservableUpDownCounter(name string, options ...Float64ObservableUpDownCounterOption) (Float64ObservableUpDownCounter, error)
			func go.opentelemetry.io/otel/metric/noop.Meter.Float64ObservableUpDownCounter(string, ...Float64ObservableUpDownCounterOption) (Float64ObservableUpDownCounter, error)

	 type Float64ObservableUpDownCounterConfig (struct)
		Float64ObservableUpDownCounterConfig contains options for asynchronous
		counter instruments that record float64 values.

		Methods (total 3)
			( Float64ObservableUpDownCounterConfig) Callbacks() []Float64Callback
				Callbacks returns the configured callbacks.

			( Float64ObservableUpDownCounterConfig) Description() string
				Description returns the configured description.

			( Float64ObservableUpDownCounterConfig) Unit() string
				Unit returns the configured unit.

		Implements (at least one exported)
			 Float64ObservableUpDownCounterConfig : github.com/alexflint/go-arg.Described
		As Outputs Of (at least one exported)
			func NewFloat64ObservableUpDownCounterConfig(opts ...Float64ObservableUpDownCounterOption) Float64ObservableUpDownCounterConfig

	 type Float64ObservableUpDownCounterOption (interface)
		Float64ObservableUpDownCounterOption applies options to a
		[Float64ObservableUpDownCounterConfig]. See [Float64ObservableOption] and
		[InstrumentOption] for other options that can be used as a
		Float64ObservableUpDownCounterOption.

		Implemented By (at least 2)
			 Float64ObservableOption (interface)
			 InstrumentOption (interface)
		As Inputs Of (at least 3)
			func NewFloat64ObservableUpDownCounterConfig(opts ...Float64ObservableUpDownCounterOption) Float64ObservableUpDownCounterConfig
			func Meter.Float64ObservableUpDownCounter(name string, options ...Float64ObservableUpDownCounterOption) (Float64ObservableUpDownCounter, error)
			func go.opentelemetry.io/otel/metric/noop.Meter.Float64ObservableUpDownCounter(string, ...Float64ObservableUpDownCounterOption) (Float64ObservableUpDownCounter, error)

	 type Float64Observer (interface)
		Float64Observer is a recorder of float64 measurements.
		
		Warning: Methods may be added to this interface in minor releases. See
		package documentation on API implementation for information on how to set
		default behavior for unimplemented methods.

		Methods (only one)
			( Float64Observer) Observe(value float64, options ...ObserveOption)
				Observe records the float64 value.
				
				Use the WithAttributeSet (or, if performance is not a concern,
				the WithAttributes) option to include measurement attributes.

		Implemented By (at least one exported)
			 go.opentelemetry.io/otel/metric/noop.Float64Observer
		Implements (at least one exported)
			 Float64Observer : go.opentelemetry.io/otel/metric/embedded.Float64Observer

	 type Float64UpDownCounter (interface)
		Float64UpDownCounter is an instrument that records increasing or decreasing
		float64 values.
		
		Warning: Methods may be added to this interface in minor releases. See
		package documentation on API implementation for information on how to set
		default behavior for unimplemented methods.

		Methods (only one)
			( Float64UpDownCounter) Add(ctx context.Context, incr float64, options ...AddOption)
				Add records a change to the counter.
				
				Use the WithAttributeSet (or, if performance is not a concern,
				the WithAttributes) option to include measurement attributes.

		Implemented By (at least one exported)
			 go.opentelemetry.io/otel/metric/noop.Float64UpDownCounter
		Implements (at least one exported)
			 Float64UpDownCounter : go.opentelemetry.io/otel/metric/embedded.Float64UpDownCounter
		As Outputs Of (at least 2)
			func Meter.Float64UpDownCounter(name string, options ...Float64UpDownCounterOption) (Float64UpDownCounter, error)
			func go.opentelemetry.io/otel/metric/noop.Meter.Float64UpDownCounter(string, ...Float64UpDownCounterOption) (Float64UpDownCounter, error)

	 type Float64UpDownCounterConfig (struct)
		Float64UpDownCounterConfig contains options for synchronous counter
		instruments that record float64 values.

		Methods (total 2)
			( Float64UpDownCounterConfig) Description() string
				Description returns the configured description.

			( Float64UpDownCounterConfig) Unit() string
				Unit returns the configured unit.

		Implements (at least one exported)
			 Float64UpDownCounterConfig : github.com/alexflint/go-arg.Described
		As Outputs Of (at least one exported)
			func NewFloat64UpDownCounterConfig(opts ...Float64UpDownCounterOption) Float64UpDownCounterConfig

	 type Float64UpDownCounterOption (interface)
		Float64UpDownCounterOption applies options to a
		[Float64UpDownCounterConfig]. See [InstrumentOption] for other options that
		can be used as a Float64UpDownCounterOption.

		Implemented By (at least one exported)
			 InstrumentOption (interface)
		As Inputs Of (at least 3)
			func NewFloat64UpDownCounterConfig(opts ...Float64UpDownCounterOption) Float64UpDownCounterConfig
			func Meter.Float64UpDownCounter(name string, options ...Float64UpDownCounterOption) (Float64UpDownCounter, error)
			func go.opentelemetry.io/otel/metric/noop.Meter.Float64UpDownCounter(string, ...Float64UpDownCounterOption) (Float64UpDownCounter, error)

	 type HistogramOption (interface)
		HistogramOption applies options to histogram instruments.

		Implemented By (at least one exported)
			 InstrumentOption (interface)
		Implements (at least 2)
			 HistogramOption : Float64HistogramOption
			 HistogramOption : Int64HistogramOption
		As Outputs Of (at least one exported)
			func WithExplicitBucketBoundaries(bounds ...float64) HistogramOption

	 type InstrumentOption (interface)
		InstrumentOption applies options to all instruments.

		Implements (at least 17)
			 InstrumentOption : Float64CounterOption
			 InstrumentOption : Float64GaugeOption
			 InstrumentOption : Float64HistogramOption
			 InstrumentOption : Float64ObservableCounterOption
			 InstrumentOption : Float64ObservableGaugeOption
			 InstrumentOption : Float64ObservableOption
			 InstrumentOption : Float64ObservableUpDownCounterOption
			 InstrumentOption : Float64UpDownCounterOption
			 InstrumentOption : HistogramOption
			 InstrumentOption : Int64CounterOption
			 InstrumentOption : Int64GaugeOption
			 InstrumentOption : Int64HistogramOption
			 InstrumentOption : Int64ObservableCounterOption
			 InstrumentOption : Int64ObservableGaugeOption
			 InstrumentOption : Int64ObservableOption
			 InstrumentOption : Int64ObservableUpDownCounterOption
			 InstrumentOption : Int64UpDownCounterOption
		As Outputs Of (at least 2)
			func WithDescription(desc string) InstrumentOption
			func WithUnit(u string) InstrumentOption

	 type Int64Callback (func)
		Int64Callback is a function registered with a Meter that makes observations
		for an Int64Observable instrument it is registered with. Calls to the
		Int64Observer record measurement values for the Int64Observable.
		
		The function needs to complete in a finite amount of time and the deadline
		of the passed context is expected to be honored.
		
		The function needs to make unique observations across all registered
		Int64Callbacks. Meaning, it should not report measurements with the same
		attributes as another Int64Callbacks also registered for the same
		instrument.
		
		The function needs to be concurrent safe.

		As Outputs Of (at least 3)
			func Int64ObservableCounterConfig.Callbacks() []Int64Callback
			func Int64ObservableGaugeConfig.Callbacks() []Int64Callback
			func Int64ObservableUpDownCounterConfig.Callbacks() []Int64Callback
		As Inputs Of (at least one exported)
			func WithInt64Callback(callback Int64Callback) Int64ObservableOption

	 type Int64Counter (interface)
		Int64Counter is an instrument that records increasing int64 values.
		
		Warning: Methods may be added to this interface in minor releases. See
		package documentation on API implementation for information on how to set
		default behavior for unimplemented methods.

		Methods (only one)
			( Int64Counter) Add(ctx context.Context, incr int64, options ...AddOption)
				Add records a change to the counter.
				
				Use the WithAttributeSet (or, if performance is not a concern,
				the WithAttributes) option to include measurement attributes.

		Implemented By (at least one exported)
			 go.opentelemetry.io/otel/metric/noop.Int64Counter
		Implements (at least one exported)
			 Int64Counter : go.opentelemetry.io/otel/metric/embedded.Int64Counter
		As Outputs Of (at least 9)
			func Meter.Int64Counter(name string, options ...Int64CounterOption) (Int64Counter, error)
			func go.opentelemetry.io/otel/metric/noop.Meter.Int64Counter(string, ...Int64CounterOption) (Int64Counter, error)
			func go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.SDKExporterLogExported.Inst() Int64Counter
			func go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.SDKExporterMetricDataPointExported.Inst() Int64Counter
			func go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.SDKExporterSpanExported.Inst() Int64Counter
			func go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.SDKLogCreated.Inst() Int64Counter
			func go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.SDKProcessorLogProcessed.Inst() Int64Counter
			func go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.SDKProcessorSpanProcessed.Inst() Int64Counter
			func go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.SDKSpanStarted.Inst() Int64Counter

	 type Int64CounterConfig (struct)
		Int64CounterConfig contains options for synchronous counter instruments that
		record int64 values.

		Methods (total 2)
			( Int64CounterConfig) Description() string
				Description returns the configured description.

			( Int64CounterConfig) Unit() string
				Unit returns the configured unit.

		Implements (at least one exported)
			 Int64CounterConfig : github.com/alexflint/go-arg.Described
		As Outputs Of (at least one exported)
			func NewInt64CounterConfig(opts ...Int64CounterOption) Int64CounterConfig

	 type Int64CounterOption (interface)
		Int64CounterOption applies options to a [Int64CounterConfig]. See
		[InstrumentOption] for other options that can be used as an
		Int64CounterOption.

		Implemented By (at least one exported)
			 InstrumentOption (interface)
		As Inputs Of (at least 10)
			func NewInt64CounterConfig(opts ...Int64CounterOption) Int64CounterConfig
			func Meter.Int64Counter(name string, options ...Int64CounterOption) (Int64Counter, error)
			func go.opentelemetry.io/otel/metric/noop.Meter.Int64Counter(string, ...Int64CounterOption) (Int64Counter, error)
			func go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.NewSDKExporterLogExported(m Meter, opt ...Int64CounterOption) (otelconv.SDKExporterLogExported, error)
			func go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.NewSDKExporterMetricDataPointExported(m Meter, opt ...Int64CounterOption) (otelconv.SDKExporterMetricDataPointExported, error)
			func go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.NewSDKExporterSpanExported(m Meter, opt ...Int64CounterOption) (otelconv.SDKExporterSpanExported, error)
			func go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.NewSDKLogCreated(m Meter, opt ...Int64CounterOption) (otelconv.SDKLogCreated, error)
			func go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.NewSDKProcessorLogProcessed(m Meter, opt ...Int64CounterOption) (otelconv.SDKProcessorLogProcessed, error)
			func go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.NewSDKProcessorSpanProcessed(m Meter, opt ...Int64CounterOption) (otelconv.SDKProcessorSpanProcessed, error)
			func go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.NewSDKSpanStarted(m Meter, opt ...Int64CounterOption) (otelconv.SDKSpanStarted, error)

	 type Int64Gauge (interface)
		Int64Gauge is an instrument that records instantaneous int64 values.
		
		Warning: Methods may be added to this interface in minor releases. See
		package documentation on API implementation for information on how to set
		default behavior for unimplemented methods.

		Methods (only one)
			( Int64Gauge) Record(ctx context.Context, value int64, options ...RecordOption)
				Record records the instantaneous value.
				
				Use the WithAttributeSet (or, if performance is not a concern,
				the WithAttributes) option to include measurement attributes.

		Implemented By (at least one exported)
			 go.opentelemetry.io/otel/metric/noop.Int64Gauge
		Implements (at least one exported)
			 Int64Gauge : go.opentelemetry.io/otel/metric/embedded.Int64Gauge
		As Outputs Of (at least 2)
			func Meter.Int64Gauge(name string, options ...Int64GaugeOption) (Int64Gauge, error)
			func go.opentelemetry.io/otel/metric/noop.Meter.Int64Gauge(string, ...Int64GaugeOption) (Int64Gauge, error)

	 type Int64GaugeConfig (struct)
		Int64GaugeConfig contains options for synchronous gauge instruments that
		record int64 values.

		Methods (total 2)
			( Int64GaugeConfig) Description() string
				Description returns the configured description.

			( Int64GaugeConfig) Unit() string
				Unit returns the configured unit.

		Implements (at least one exported)
			 Int64GaugeConfig : github.com/alexflint/go-arg.Described
		As Outputs Of (at least one exported)
			func NewInt64GaugeConfig(opts ...Int64GaugeOption) Int64GaugeConfig

	 type Int64GaugeOption (interface)
		Int64GaugeOption applies options to a [Int64GaugeConfig]. See
		[InstrumentOption] for other options that can be used as a
		Int64GaugeOption.

		Implemented By (at least one exported)
			 InstrumentOption (interface)
		As Inputs Of (at least 3)
			func NewInt64GaugeConfig(opts ...Int64GaugeOption) Int64GaugeConfig
			func Meter.Int64Gauge(name string, options ...Int64GaugeOption) (Int64Gauge, error)
			func go.opentelemetry.io/otel/metric/noop.Meter.Int64Gauge(string, ...Int64GaugeOption) (Int64Gauge, error)

	 type Int64Histogram (interface)
		Int64Histogram is an instrument that records a distribution of int64
		values.
		
		Warning: Methods may be added to this interface in minor releases. See
		package documentation on API implementation for information on how to set
		default behavior for unimplemented methods.

		Methods (only one)
			( Int64Histogram) Record(ctx context.Context, incr int64, options ...RecordOption)
				Record adds an additional value to the distribution.
				
				Use the WithAttributeSet (or, if performance is not a concern,
				the WithAttributes) option to include measurement attributes.

		Implemented By (at least one exported)
			 go.opentelemetry.io/otel/metric/noop.Int64Histogram
		Implements (at least one exported)
			 Int64Histogram : go.opentelemetry.io/otel/metric/embedded.Int64Histogram
		As Outputs Of (at least 2)
			func Meter.Int64Histogram(name string, options ...Int64HistogramOption) (Int64Histogram, error)
			func go.opentelemetry.io/otel/metric/noop.Meter.Int64Histogram(string, ...Int64HistogramOption) (Int64Histogram, error)

	 type Int64HistogramConfig (struct)
		Int64HistogramConfig contains options for synchronous histogram instruments
		that record int64 values.

		Methods (total 3)
			( Int64HistogramConfig) Description() string
				Description returns the configured description.

			( Int64HistogramConfig) ExplicitBucketBoundaries() []float64
				ExplicitBucketBoundaries returns the configured explicit bucket boundaries.

			( Int64HistogramConfig) Unit() string
				Unit returns the configured unit.

		Implements (at least one exported)
			 Int64HistogramConfig : github.com/alexflint/go-arg.Described
		As Outputs Of (at least one exported)
			func NewInt64HistogramConfig(opts ...Int64HistogramOption) Int64HistogramConfig

	 type Int64HistogramOption (interface)
		Int64HistogramOption applies options to a [Int64HistogramConfig]. See
		[InstrumentOption] for other options that can be used as an
		Int64HistogramOption.

		Implemented By (at least 2)
			 HistogramOption (interface)
			 InstrumentOption (interface)
		As Inputs Of (at least 3)
			func NewInt64HistogramConfig(opts ...Int64HistogramOption) Int64HistogramConfig
			func Meter.Int64Histogram(name string, options ...Int64HistogramOption) (Int64Histogram, error)
			func go.opentelemetry.io/otel/metric/noop.Meter.Int64Histogram(string, ...Int64HistogramOption) (Int64Histogram, error)

	 type Int64Observable (interface)
		Int64Observable describes a set of instruments used asynchronously to record
		int64 measurements once per collection cycle. Observations of these
		instruments are only made within a callback.
		
		Warning: Methods may be added to this interface in minor releases.

		Implemented By (at least 10)
			 Int64ObservableCounter (interface)
			 Int64ObservableGauge (interface)
			 Int64ObservableUpDownCounter (interface)
			 go.opentelemetry.io/otel/metric/noop.Int64ObservableCounter
			 go.opentelemetry.io/otel/metric/noop.Int64ObservableGauge
			 go.opentelemetry.io/otel/metric/noop.Int64ObservableUpDownCounter
			 go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.SDKProcessorLogQueueCapacity
			 go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.SDKProcessorLogQueueSize
			 go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.SDKProcessorSpanQueueCapacity
			 go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.SDKProcessorSpanQueueSize
		Implements (at least one exported)
			 Int64Observable : Observable
		As Inputs Of (at least 2)
			func Observer.ObserveInt64(obsrv Int64Observable, value int64, opts ...ObserveOption)
			func go.opentelemetry.io/otel/metric/noop.Observer.ObserveInt64(Int64Observable, int64, ...ObserveOption)

	 type Int64ObservableCounter (interface)
		Int64ObservableCounter is an instrument used to asynchronously record
		increasing int64 measurements once per collection cycle. Observations are
		only made within a callback for this instrument. The value observed is
		assumed the to be the cumulative sum of the count.
		
		Warning: Methods may be added to this interface in minor releases. See
		package documentation on API implementation for information on how to set
		default behavior for unimplemented methods.

		Implemented By (at least one exported)
			 go.opentelemetry.io/otel/metric/noop.Int64ObservableCounter
		Implements (at least 3)
			 Int64ObservableCounter : Int64Observable
			 Int64ObservableCounter : Observable
			 Int64ObservableCounter : go.opentelemetry.io/otel/metric/embedded.Int64ObservableCounter
		As Outputs Of (at least 2)
			func Meter.Int64ObservableCounter(name string, options ...Int64ObservableCounterOption) (Int64ObservableCounter, error)
			func go.opentelemetry.io/otel/metric/noop.Meter.Int64ObservableCounter(string, ...Int64ObservableCounterOption) (Int64ObservableCounter, error)

	 type Int64ObservableCounterConfig (struct)
		Int64ObservableCounterConfig contains options for asynchronous counter
		instruments that record int64 values.

		Methods (total 3)
			( Int64ObservableCounterConfig) Callbacks() []Int64Callback
				Callbacks returns the configured callbacks.

			( Int64ObservableCounterConfig) Description() string
				Description returns the configured description.

			( Int64ObservableCounterConfig) Unit() string
				Unit returns the configured unit.

		Implements (at least one exported)
			 Int64ObservableCounterConfig : github.com/alexflint/go-arg.Described
		As Outputs Of (at least one exported)
			func NewInt64ObservableCounterConfig(opts ...Int64ObservableCounterOption) Int64ObservableCounterConfig

	 type Int64ObservableCounterOption (interface)
		Int64ObservableCounterOption applies options to a
		[Int64ObservableCounterConfig]. See [Int64ObservableOption] and
		[InstrumentOption] for other options that can be used as an
		Int64ObservableCounterOption.

		Implemented By (at least 2)
			 InstrumentOption (interface)
			 Int64ObservableOption (interface)
		As Inputs Of (at least 3)
			func NewInt64ObservableCounterConfig(opts ...Int64ObservableCounterOption) Int64ObservableCounterConfig
			func Meter.Int64ObservableCounter(name string, options ...Int64ObservableCounterOption) (Int64ObservableCounter, error)
			func go.opentelemetry.io/otel/metric/noop.Meter.Int64ObservableCounter(string, ...Int64ObservableCounterOption) (Int64ObservableCounter, error)

	 type Int64ObservableGauge (interface)
		Int64ObservableGauge is an instrument used to asynchronously record
		instantaneous int64 measurements once per collection cycle. Observations are
		only made within a callback for this instrument.
		
		Warning: Methods may be added to this interface in minor releases. See
		package documentation on API implementation for information on how to set
		default behavior for unimplemented methods.

		Implemented By (at least one exported)
			 go.opentelemetry.io/otel/metric/noop.Int64ObservableGauge
		Implements (at least 3)
			 Int64ObservableGauge : Int64Observable
			 Int64ObservableGauge : Observable
			 Int64ObservableGauge : go.opentelemetry.io/otel/metric/embedded.Int64ObservableGauge
		As Outputs Of (at least 2)
			func Meter.Int64ObservableGauge(name string, options ...Int64ObservableGaugeOption) (Int64ObservableGauge, error)
			func go.opentelemetry.io/otel/metric/noop.Meter.Int64ObservableGauge(string, ...Int64ObservableGaugeOption) (Int64ObservableGauge, error)

	 type Int64ObservableGaugeConfig (struct)
		Int64ObservableGaugeConfig contains options for asynchronous counter
		instruments that record int64 values.

		Methods (total 3)
			( Int64ObservableGaugeConfig) Callbacks() []Int64Callback
				Callbacks returns the configured callbacks.

			( Int64ObservableGaugeConfig) Description() string
				Description returns the configured description.

			( Int64ObservableGaugeConfig) Unit() string
				Unit returns the configured unit.

		Implements (at least one exported)
			 Int64ObservableGaugeConfig : github.com/alexflint/go-arg.Described
		As Outputs Of (at least one exported)
			func NewInt64ObservableGaugeConfig(opts ...Int64ObservableGaugeOption) Int64ObservableGaugeConfig

	 type Int64ObservableGaugeOption (interface)
		Int64ObservableGaugeOption applies options to a
		[Int64ObservableGaugeConfig]. See [Int64ObservableOption] and
		[InstrumentOption] for other options that can be used as an
		Int64ObservableGaugeOption.

		Implemented By (at least 2)
			 InstrumentOption (interface)
			 Int64ObservableOption (interface)
		As Inputs Of (at least 3)
			func NewInt64ObservableGaugeConfig(opts ...Int64ObservableGaugeOption) Int64ObservableGaugeConfig
			func Meter.Int64ObservableGauge(name string, options ...Int64ObservableGaugeOption) (Int64ObservableGauge, error)
			func go.opentelemetry.io/otel/metric/noop.Meter.Int64ObservableGauge(string, ...Int64ObservableGaugeOption) (Int64ObservableGauge, error)

	 type Int64ObservableOption (interface)
		Int64ObservableOption applies options to int64 Observer instruments.

		Implemented By (at least one exported)
			 InstrumentOption (interface)
		Implements (at least 3)
			 Int64ObservableOption : Int64ObservableCounterOption
			 Int64ObservableOption : Int64ObservableGaugeOption
			 Int64ObservableOption : Int64ObservableUpDownCounterOption
		As Outputs Of (at least one exported)
			func WithInt64Callback(callback Int64Callback) Int64ObservableOption

	 type Int64ObservableUpDownCounter (interface)
		Int64ObservableUpDownCounter is an instrument used to asynchronously record
		int64 measurements once per collection cycle. Observations are only made
		within a callback for this instrument. The value observed is assumed the to
		be the cumulative sum of the count.
		
		Warning: Methods may be added to this interface in minor releases. See
		package documentation on API implementation for information on how to set
		default behavior for unimplemented methods.

		Implemented By (at least 5)
			 go.opentelemetry.io/otel/metric/noop.Int64ObservableUpDownCounter
			 go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.SDKProcessorLogQueueCapacity
			 go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.SDKProcessorLogQueueSize
			 go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.SDKProcessorSpanQueueCapacity
			 go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.SDKProcessorSpanQueueSize
		Implements (at least 3)
			 Int64ObservableUpDownCounter : Int64Observable
			 Int64ObservableUpDownCounter : Observable
			 Int64ObservableUpDownCounter : go.opentelemetry.io/otel/metric/embedded.Int64ObservableUpDownCounter
		As Outputs Of (at least 6)
			func Meter.Int64ObservableUpDownCounter(name string, options ...Int64ObservableUpDownCounterOption) (Int64ObservableUpDownCounter, error)
			func go.opentelemetry.io/otel/metric/noop.Meter.Int64ObservableUpDownCounter(string, ...Int64ObservableUpDownCounterOption) (Int64ObservableUpDownCounter, error)
			func go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.SDKProcessorLogQueueCapacity.Inst() Int64ObservableUpDownCounter
			func go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.SDKProcessorLogQueueSize.Inst() Int64ObservableUpDownCounter
			func go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.SDKProcessorSpanQueueCapacity.Inst() Int64ObservableUpDownCounter
			func go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.SDKProcessorSpanQueueSize.Inst() Int64ObservableUpDownCounter

	 type Int64ObservableUpDownCounterConfig (struct)
		Int64ObservableUpDownCounterConfig contains options for asynchronous counter
		instruments that record int64 values.

		Methods (total 3)
			( Int64ObservableUpDownCounterConfig) Callbacks() []Int64Callback
				Callbacks returns the configured callbacks.

			( Int64ObservableUpDownCounterConfig) Description() string
				Description returns the configured description.

			( Int64ObservableUpDownCounterConfig) Unit() string
				Unit returns the configured unit.

		Implements (at least one exported)
			 Int64ObservableUpDownCounterConfig : github.com/alexflint/go-arg.Described
		As Outputs Of (at least one exported)
			func NewInt64ObservableUpDownCounterConfig(opts ...Int64ObservableUpDownCounterOption) Int64ObservableUpDownCounterConfig

	 type Int64ObservableUpDownCounterOption (interface)
		Int64ObservableUpDownCounterOption applies options to a
		[Int64ObservableUpDownCounterConfig]. See [Int64ObservableOption] and
		[InstrumentOption] for other options that can be used as an
		Int64ObservableUpDownCounterOption.

		Implemented By (at least 2)
			 InstrumentOption (interface)
			 Int64ObservableOption (interface)
		As Inputs Of (at least 7)
			func NewInt64ObservableUpDownCounterConfig(opts ...Int64ObservableUpDownCounterOption) Int64ObservableUpDownCounterConfig
			func Meter.Int64ObservableUpDownCounter(name string, options ...Int64ObservableUpDownCounterOption) (Int64ObservableUpDownCounter, error)
			func go.opentelemetry.io/otel/metric/noop.Meter.Int64ObservableUpDownCounter(string, ...Int64ObservableUpDownCounterOption) (Int64ObservableUpDownCounter, error)
			func go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.NewSDKProcessorLogQueueCapacity(m Meter, opt ...Int64ObservableUpDownCounterOption) (otelconv.SDKProcessorLogQueueCapacity, error)
			func go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.NewSDKProcessorLogQueueSize(m Meter, opt ...Int64ObservableUpDownCounterOption) (otelconv.SDKProcessorLogQueueSize, error)
			func go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.NewSDKProcessorSpanQueueCapacity(m Meter, opt ...Int64ObservableUpDownCounterOption) (otelconv.SDKProcessorSpanQueueCapacity, error)
			func go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.NewSDKProcessorSpanQueueSize(m Meter, opt ...Int64ObservableUpDownCounterOption) (otelconv.SDKProcessorSpanQueueSize, error)

	 type Int64Observer (interface)
		Int64Observer is a recorder of int64 measurements.
		
		Warning: Methods may be added to this interface in minor releases. See
		package documentation on API implementation for information on how to set
		default behavior for unimplemented methods.

		Methods (only one)
			( Int64Observer) Observe(value int64, options ...ObserveOption)
				Observe records the int64 value.
				
				Use the WithAttributeSet (or, if performance is not a concern,
				the WithAttributes) option to include measurement attributes.

		Implemented By (at least one exported)
			 go.opentelemetry.io/otel/metric/noop.Int64Observer
		Implements (at least one exported)
			 Int64Observer : go.opentelemetry.io/otel/metric/embedded.Int64Observer

	 type Int64UpDownCounter (interface)
		Int64UpDownCounter is an instrument that records increasing or decreasing
		int64 values.
		
		Warning: Methods may be added to this interface in minor releases. See
		package documentation on API implementation for information on how to set
		default behavior for unimplemented methods.

		Methods (only one)
			( Int64UpDownCounter) Add(ctx context.Context, incr int64, options ...AddOption)
				Add records a change to the counter.
				
				Use the WithAttributeSet (or, if performance is not a concern,
				the WithAttributes) option to include measurement attributes.

		Implemented By (at least one exported)
			 go.opentelemetry.io/otel/metric/noop.Int64UpDownCounter
		Implements (at least one exported)
			 Int64UpDownCounter : go.opentelemetry.io/otel/metric/embedded.Int64UpDownCounter
		As Outputs Of (at least 6)
			func Meter.Int64UpDownCounter(name string, options ...Int64UpDownCounterOption) (Int64UpDownCounter, error)
			func go.opentelemetry.io/otel/metric/noop.Meter.Int64UpDownCounter(string, ...Int64UpDownCounterOption) (Int64UpDownCounter, error)
			func go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.SDKExporterLogInflight.Inst() Int64UpDownCounter
			func go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.SDKExporterMetricDataPointInflight.Inst() Int64UpDownCounter
			func go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.SDKExporterSpanInflight.Inst() Int64UpDownCounter
			func go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.SDKSpanLive.Inst() Int64UpDownCounter

	 type Int64UpDownCounterConfig (struct)
		Int64UpDownCounterConfig contains options for synchronous counter
		instruments that record int64 values.

		Methods (total 2)
			( Int64UpDownCounterConfig) Description() string
				Description returns the configured description.

			( Int64UpDownCounterConfig) Unit() string
				Unit returns the configured unit.

		Implements (at least one exported)
			 Int64UpDownCounterConfig : github.com/alexflint/go-arg.Described
		As Outputs Of (at least one exported)
			func NewInt64UpDownCounterConfig(opts ...Int64UpDownCounterOption) Int64UpDownCounterConfig

	 type Int64UpDownCounterOption (interface)
		Int64UpDownCounterOption applies options to a [Int64UpDownCounterConfig].
		See [InstrumentOption] for other options that can be used as an
		Int64UpDownCounterOption.

		Implemented By (at least one exported)
			 InstrumentOption (interface)
		As Inputs Of (at least 7)
			func NewInt64UpDownCounterConfig(opts ...Int64UpDownCounterOption) Int64UpDownCounterConfig
			func Meter.Int64UpDownCounter(name string, options ...Int64UpDownCounterOption) (Int64UpDownCounter, error)
			func go.opentelemetry.io/otel/metric/noop.Meter.Int64UpDownCounter(string, ...Int64UpDownCounterOption) (Int64UpDownCounter, error)
			func go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.NewSDKExporterLogInflight(m Meter, opt ...Int64UpDownCounterOption) (otelconv.SDKExporterLogInflight, error)
			func go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.NewSDKExporterMetricDataPointInflight(m Meter, opt ...Int64UpDownCounterOption) (otelconv.SDKExporterMetricDataPointInflight, error)
			func go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.NewSDKExporterSpanInflight(m Meter, opt ...Int64UpDownCounterOption) (otelconv.SDKExporterSpanInflight, error)
			func go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.NewSDKSpanLive(m Meter, opt ...Int64UpDownCounterOption) (otelconv.SDKSpanLive, error)

	 type MeasurementOption (interface)
		MeasurementOption applies options to all instrument measurement.

		Implements (at least 3)
			 MeasurementOption : AddOption
			 MeasurementOption : ObserveOption
			 MeasurementOption : RecordOption
		As Outputs Of (at least 2)
			func WithAttributes(attributes ...attribute.KeyValue) MeasurementOption
			func WithAttributeSet(attributes attribute.Set) MeasurementOption

	 type Meter (interface)
		Meter provides access to instrument instances for recording metrics.
		
		Warning: Methods may be added to this interface in minor releases. See
		package documentation on API implementation for information on how to set
		default behavior for unimplemented methods.

		Methods (total 15)
			( Meter) Float64Counter(name string, options ...Float64CounterOption) (Float64Counter, error)
				Float64Counter returns a new Float64Counter instrument identified by
				name and configured with options. The instrument is used to
				synchronously record increasing float64 measurements during a
				computational operation.
				
				The name needs to conform to the OpenTelemetry instrument name syntax.
				See the Instrument Name section of the package documentation for more
				information.

			( Meter) Float64Gauge(name string, options ...Float64GaugeOption) (Float64Gauge, error)
				Float64Gauge returns a new Float64Gauge instrument identified by name and
				configured with options. The instrument is used to synchronously record
				instantaneous float64 measurements during a computational operation.
				
				The name needs to conform to the OpenTelemetry instrument name syntax.
				See the Instrument Name section of the package documentation for more
				information.

			( Meter) Float64Histogram(name string, options ...Float64HistogramOption) (Float64Histogram, error)
				Float64Histogram returns a new Float64Histogram instrument identified by
				name and configured with options. The instrument is used to
				synchronously record the distribution of float64 measurements during a
				computational operation.
				
				The name needs to conform to the OpenTelemetry instrument name syntax.
				See the Instrument Name section of the package documentation for more
				information.

			( Meter) Float64ObservableCounter(name string, options ...Float64ObservableCounterOption) (Float64ObservableCounter, error)
				Float64ObservableCounter returns a new Float64ObservableCounter
				instrument identified by name and configured with options. The
				instrument is used to asynchronously record increasing float64
				measurements once per a measurement collection cycle.
				
				Measurements for the returned instrument are made via a callback. Use
				the WithFloat64Callback option to register the callback here, or use the
				RegisterCallback method of this Meter to register one later. See the
				Measurements section of the package documentation for more information.
				
				The name needs to conform to the OpenTelemetry instrument name syntax.
				See the Instrument Name section of the package documentation for more
				information.

			( Meter) Float64ObservableGauge(name string, options ...Float64ObservableGaugeOption) (Float64ObservableGauge, error)
				Float64ObservableGauge returns a new Float64ObservableGauge instrument
				identified by name and configured with options. The instrument is used
				to asynchronously record instantaneous float64 measurements once per a
				measurement collection cycle.
				
				Measurements for the returned instrument are made via a callback. Use
				the WithFloat64Callback option to register the callback here, or use the
				RegisterCallback method of this Meter to register one later. See the
				Measurements section of the package documentation for more information.
				
				The name needs to conform to the OpenTelemetry instrument name syntax.
				See the Instrument Name section of the package documentation for more
				information.

			( Meter) Float64ObservableUpDownCounter(name string, options ...Float64ObservableUpDownCounterOption) (Float64ObservableUpDownCounter, error)
				Float64ObservableUpDownCounter returns a new
				Float64ObservableUpDownCounter instrument identified by name and
				configured with options. The instrument is used to asynchronously record
				float64 measurements once per a measurement collection cycle.
				
				Measurements for the returned instrument are made via a callback. Use
				the WithFloat64Callback option to register the callback here, or use the
				RegisterCallback method of this Meter to register one later. See the
				Measurements section of the package documentation for more information.
				
				The name needs to conform to the OpenTelemetry instrument name syntax.
				See the Instrument Name section of the package documentation for more
				information.

			( Meter) Float64UpDownCounter(name string, options ...Float64UpDownCounterOption) (Float64UpDownCounter, error)
				Float64UpDownCounter returns a new Float64UpDownCounter instrument
				identified by name and configured with options. The instrument is used
				to synchronously record float64 measurements during a computational
				operation.
				
				The name needs to conform to the OpenTelemetry instrument name syntax.
				See the Instrument Name section of the package documentation for more
				information.

			( Meter) Int64Counter(name string, options ...Int64CounterOption) (Int64Counter, error)
				Int64Counter returns a new Int64Counter instrument identified by name
				and configured with options. The instrument is used to synchronously
				record increasing int64 measurements during a computational operation.
				
				The name needs to conform to the OpenTelemetry instrument name syntax.
				See the Instrument Name section of the package documentation for more
				information.

			( Meter) Int64Gauge(name string, options ...Int64GaugeOption) (Int64Gauge, error)
				Int64Gauge returns a new Int64Gauge instrument identified by name and
				configured with options. The instrument is used to synchronously record
				instantaneous int64 measurements during a computational operation.
				
				The name needs to conform to the OpenTelemetry instrument name syntax.
				See the Instrument Name section of the package documentation for more
				information.

			( Meter) Int64Histogram(name string, options ...Int64HistogramOption) (Int64Histogram, error)
				Int64Histogram returns a new Int64Histogram instrument identified by
				name and configured with options. The instrument is used to
				synchronously record the distribution of int64 measurements during a
				computational operation.
				
				The name needs to conform to the OpenTelemetry instrument name syntax.
				See the Instrument Name section of the package documentation for more
				information.

			( Meter) Int64ObservableCounter(name string, options ...Int64ObservableCounterOption) (Int64ObservableCounter, error)
				Int64ObservableCounter returns a new Int64ObservableCounter identified
				by name and configured with options. The instrument is used to
				asynchronously record increasing int64 measurements once per a
				measurement collection cycle.
				
				Measurements for the returned instrument are made via a callback. Use
				the WithInt64Callback option to register the callback here, or use the
				RegisterCallback method of this Meter to register one later. See the
				Measurements section of the package documentation for more information.
				
				The name needs to conform to the OpenTelemetry instrument name syntax.
				See the Instrument Name section of the package documentation for more
				information.

			( Meter) Int64ObservableGauge(name string, options ...Int64ObservableGaugeOption) (Int64ObservableGauge, error)
				Int64ObservableGauge returns a new Int64ObservableGauge instrument
				identified by name and configured with options. The instrument is used
				to asynchronously record instantaneous int64 measurements once per a
				measurement collection cycle.
				
				Measurements for the returned instrument are made via a callback. Use
				the WithInt64Callback option to register the callback here, or use the
				RegisterCallback method of this Meter to register one later. See the
				Measurements section of the package documentation for more information.
				
				The name needs to conform to the OpenTelemetry instrument name syntax.
				See the Instrument Name section of the package documentation for more
				information.

			( Meter) Int64ObservableUpDownCounter(name string, options ...Int64ObservableUpDownCounterOption) (Int64ObservableUpDownCounter, error)
				Int64ObservableUpDownCounter returns a new Int64ObservableUpDownCounter
				instrument identified by name and configured with options. The
				instrument is used to asynchronously record int64 measurements once per
				a measurement collection cycle.
				
				Measurements for the returned instrument are made via a callback. Use
				the WithInt64Callback option to register the callback here, or use the
				RegisterCallback method of this Meter to register one later. See the
				Measurements section of the package documentation for more information.
				
				The name needs to conform to the OpenTelemetry instrument name syntax.
				See the Instrument Name section of the package documentation for more
				information.

			( Meter) Int64UpDownCounter(name string, options ...Int64UpDownCounterOption) (Int64UpDownCounter, error)
				Int64UpDownCounter returns a new Int64UpDownCounter instrument
				identified by name and configured with options. The instrument is used
				to synchronously record int64 measurements during a computational
				operation.
				
				The name needs to conform to the OpenTelemetry instrument name syntax.
				See the Instrument Name section of the package documentation for more
				information.

			( Meter) RegisterCallback(f Callback, instruments ...Observable) (Registration, error)
				RegisterCallback registers f to be called during the collection of a
				measurement cycle.
				
				If Unregister of the returned Registration is called, f needs to be
				unregistered and not called during collection.
				
				The instruments f is registered with are the only instruments that f may
				observe values for.
				
				If no instruments are passed, f should not be registered nor called
				during collection.
				
				The function f needs to be concurrent safe.

		Implemented By (at least one exported)
			 go.opentelemetry.io/otel/metric/noop.Meter
		Implements (at least one exported)
			 Meter : go.opentelemetry.io/otel/metric/embedded.Meter
		As Outputs Of (at least 3)
			func MeterProvider.Meter(name string, opts ...MeterOption) Meter
			func go.opentelemetry.io/otel/metric/noop.MeterProvider.Meter(string, ...MeterOption) Meter
			func go.opentelemetry.io/otel.Meter(name string, opts ...MeterOption) Meter
		As Inputs Of (at least 17)
			func go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.NewSDKExporterLogExported(m Meter, opt ...Int64CounterOption) (otelconv.SDKExporterLogExported, error)
			func go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.NewSDKExporterLogInflight(m Meter, opt ...Int64UpDownCounterOption) (otelconv.SDKExporterLogInflight, error)
			func go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.NewSDKExporterMetricDataPointExported(m Meter, opt ...Int64CounterOption) (otelconv.SDKExporterMetricDataPointExported, error)
			func go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.NewSDKExporterMetricDataPointInflight(m Meter, opt ...Int64UpDownCounterOption) (otelconv.SDKExporterMetricDataPointInflight, error)
			func go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.NewSDKExporterOperationDuration(m Meter, opt ...Float64HistogramOption) (otelconv.SDKExporterOperationDuration, error)
			func go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.NewSDKExporterSpanExported(m Meter, opt ...Int64CounterOption) (otelconv.SDKExporterSpanExported, error)
			func go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.NewSDKExporterSpanInflight(m Meter, opt ...Int64UpDownCounterOption) (otelconv.SDKExporterSpanInflight, error)
			func go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.NewSDKLogCreated(m Meter, opt ...Int64CounterOption) (otelconv.SDKLogCreated, error)
			func go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.NewSDKMetricReaderCollectionDuration(m Meter, opt ...Float64HistogramOption) (otelconv.SDKMetricReaderCollectionDuration, error)
			func go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.NewSDKProcessorLogProcessed(m Meter, opt ...Int64CounterOption) (otelconv.SDKProcessorLogProcessed, error)
			func go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.NewSDKProcessorLogQueueCapacity(m Meter, opt ...Int64ObservableUpDownCounterOption) (otelconv.SDKProcessorLogQueueCapacity, error)
			func go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.NewSDKProcessorLogQueueSize(m Meter, opt ...Int64ObservableUpDownCounterOption) (otelconv.SDKProcessorLogQueueSize, error)
			func go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.NewSDKProcessorSpanProcessed(m Meter, opt ...Int64CounterOption) (otelconv.SDKProcessorSpanProcessed, error)
			func go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.NewSDKProcessorSpanQueueCapacity(m Meter, opt ...Int64ObservableUpDownCounterOption) (otelconv.SDKProcessorSpanQueueCapacity, error)
			func go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.NewSDKProcessorSpanQueueSize(m Meter, opt ...Int64ObservableUpDownCounterOption) (otelconv.SDKProcessorSpanQueueSize, error)
			func go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.NewSDKSpanLive(m Meter, opt ...Int64UpDownCounterOption) (otelconv.SDKSpanLive, error)
			func go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.NewSDKSpanStarted(m Meter, opt ...Int64CounterOption) (otelconv.SDKSpanStarted, error)

	 type MeterConfig (struct)
		MeterConfig contains options for Meters.

		Methods (total 3)
			( MeterConfig) InstrumentationAttributes() attribute.Set
				InstrumentationAttributes returns the attributes associated with the library
				providing instrumentation.

			( MeterConfig) InstrumentationVersion() string
				InstrumentationVersion returns the version of the library providing
				instrumentation.

			( MeterConfig) SchemaURL() string
				SchemaURL is the schema_url of the library providing instrumentation.

		As Outputs Of (at least one exported)
			func NewMeterConfig(opts ...MeterOption) MeterConfig

	 type MeterOption (interface)
		MeterOption is an interface for applying Meter options.

		As Outputs Of (at least 3)
			func WithInstrumentationAttributes(attr ...attribute.KeyValue) MeterOption
			func WithInstrumentationVersion(version string) MeterOption
			func WithSchemaURL(schemaURL string) MeterOption
		As Inputs Of (at least 4)
			func NewMeterConfig(opts ...MeterOption) MeterConfig
			func MeterProvider.Meter(name string, opts ...MeterOption) Meter
			func go.opentelemetry.io/otel/metric/noop.MeterProvider.Meter(string, ...MeterOption) Meter
			func go.opentelemetry.io/otel.Meter(name string, opts ...MeterOption) Meter

	 type MeterProvider (interface)
		MeterProvider provides access to named Meter instances, for instrumenting
		an application or package.
		
		Warning: Methods may be added to this interface in minor releases. See
		package documentation on API implementation for information on how to set
		default behavior for unimplemented methods.

		Methods (only one)
			( MeterProvider) Meter(name string, opts ...MeterOption) Meter
				Meter returns a new Meter with the provided name and configuration.
				
				A Meter should be scoped at most to a single package. The name needs to
				be unique so it does not collide with other names used by
				an application, nor other applications. To achieve this, the import path
				of the instrumentation package is recommended to be used as name.
				
				If the name is empty, then an implementation defined default name will
				be used instead.

		Implemented By (at least one exported)
			 go.opentelemetry.io/otel/metric/noop.MeterProvider
		Implements (at least one exported)
			 MeterProvider : go.opentelemetry.io/otel/metric/embedded.MeterProvider
		As Outputs Of (at least 2)
			func go.opentelemetry.io/otel.GetMeterProvider() MeterProvider
			func go.opentelemetry.io/otel/internal/global.MeterProvider() MeterProvider
		As Inputs Of (at least 2)
			func go.opentelemetry.io/otel.SetMeterProvider(mp MeterProvider)
			func go.opentelemetry.io/otel/internal/global.SetMeterProvider(mp MeterProvider)

	 type Observable (interface)
		Observable is used as a grouping mechanism for all instruments that are
		updated within a Callback.

		Implemented By (at least 18)
			 Float64Observable (interface)
			 Float64ObservableCounter (interface)
			 Float64ObservableGauge (interface)
			 Float64ObservableUpDownCounter (interface)
			 Int64Observable (interface)
			 Int64ObservableCounter (interface)
			 Int64ObservableGauge (interface)
			 Int64ObservableUpDownCounter (interface)
			 go.opentelemetry.io/otel/metric/noop.Float64ObservableCounter
			 go.opentelemetry.io/otel/metric/noop.Float64ObservableGauge
			 go.opentelemetry.io/otel/metric/noop.Float64ObservableUpDownCounter
			 go.opentelemetry.io/otel/metric/noop.Int64ObservableCounter
			 go.opentelemetry.io/otel/metric/noop.Int64ObservableGauge
			 go.opentelemetry.io/otel/metric/noop.Int64ObservableUpDownCounter
			 go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.SDKProcessorLogQueueCapacity
			 go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.SDKProcessorLogQueueSize
			 go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.SDKProcessorSpanQueueCapacity
			 go.opentelemetry.io/otel/semconv/v1.37.0/otelconv.SDKProcessorSpanQueueSize
		As Inputs Of (at least 2)
			func Meter.RegisterCallback(f Callback, instruments ...Observable) (Registration, error)
			func go.opentelemetry.io/otel/metric/noop.Meter.RegisterCallback(Callback, ...Observable) (Registration, error)

	 type ObserveConfig (struct)
		ObserveConfig contains options for an observed measurement.

		Methods (only one)
			( ObserveConfig) Attributes() attribute.Set
				Attributes returns the configured attribute set.

		As Outputs Of (at least one exported)
			func NewObserveConfig(opts []ObserveOption) ObserveConfig

	 type ObserveOption (interface)
		ObserveOption applies options to an addition measurement. See
		[MeasurementOption] for other options that can be used as a ObserveOption.

		Implemented By (at least one exported)
			 MeasurementOption (interface)
		As Inputs Of (at least 9)
			func NewObserveConfig(opts []ObserveOption) ObserveConfig
			func Float64Observer.Observe(value float64, options ...ObserveOption)
			func Int64Observer.Observe(value int64, options ...ObserveOption)
			func Observer.ObserveFloat64(obsrv Float64Observable, value float64, opts ...ObserveOption)
			func Observer.ObserveInt64(obsrv Int64Observable, value int64, opts ...ObserveOption)
			func go.opentelemetry.io/otel/metric/noop.Float64Observer.Observe(float64, ...ObserveOption)
			func go.opentelemetry.io/otel/metric/noop.Int64Observer.Observe(int64, ...ObserveOption)
			func go.opentelemetry.io/otel/metric/noop.Observer.ObserveFloat64(Float64Observable, float64, ...ObserveOption)
			func go.opentelemetry.io/otel/metric/noop.Observer.ObserveInt64(Int64Observable, int64, ...ObserveOption)

	 type Observer (interface)
		Observer records measurements for multiple instruments in a Callback.
		
		Warning: Methods may be added to this interface in minor releases. See
		package documentation on API implementation for information on how to set
		default behavior for unimplemented methods.

		Methods (total 2)
			( Observer) ObserveFloat64(obsrv Float64Observable, value float64, opts ...ObserveOption)
				ObserveFloat64 records the float64 value for obsrv.

			( Observer) ObserveInt64(obsrv Int64Observable, value int64, opts ...ObserveOption)
				ObserveInt64 records the int64 value for obsrv.

		Implemented By (at least one exported)
			 go.opentelemetry.io/otel/metric/noop.Observer
		Implements (at least one exported)
			 Observer : go.opentelemetry.io/otel/metric/embedded.Observer

	 type RecordConfig (struct)
		RecordConfig contains options for a recorded measurement.

		Methods (only one)
			( RecordConfig) Attributes() attribute.Set
				Attributes returns the configured attribute set.

		As Outputs Of (at least one exported)
			func NewRecordConfig(opts []RecordOption) RecordConfig

	 type RecordOption (interface)
		RecordOption applies options to an addition measurement. See
		[MeasurementOption] for other options that can be used as a RecordOption.

		Implemented By (at least one exported)
			 MeasurementOption (interface)
		As Inputs Of (at least 9)
			func NewRecordConfig(opts []RecordOption) RecordConfig
			func Float64Gauge.Record(ctx context.Context, value float64, options ...RecordOption)
			func Float64Histogram.Record(ctx context.Context, incr float64, options ...RecordOption)
			func Int64Gauge.Record(ctx context.Context, value int64, options ...RecordOption)
			func Int64Histogram.Record(ctx context.Context, incr int64, options ...RecordOption)
			func go.opentelemetry.io/otel/metric/noop.Float64Gauge.Record(context.Context, float64, ...RecordOption)
			func go.opentelemetry.io/otel/metric/noop.Float64Histogram.Record(context.Context, float64, ...RecordOption)
			func go.opentelemetry.io/otel/metric/noop.Int64Gauge.Record(context.Context, int64, ...RecordOption)
			func go.opentelemetry.io/otel/metric/noop.Int64Histogram.Record(context.Context, int64, ...RecordOption)

	 type Registration (interface)
		Registration is an token representing the unique registration of a callback
		for a set of instruments with a Meter.
		
		Warning: Methods may be added to this interface in minor releases. See
		package documentation on API implementation for information on how to set
		default behavior for unimplemented methods.

		Methods (only one)
			( Registration) Unregister() error
				Unregister removes the callback registration from a Meter.
				
				This method needs to be idempotent and concurrent safe.

		Implemented By (at least one exported)
			 go.opentelemetry.io/otel/metric/noop.Registration
		Implements (at least one exported)
			 Registration : go.opentelemetry.io/otel/metric/embedded.Registration
		As Outputs Of (at least 2)
			func Meter.RegisterCallback(f Callback, instruments ...Observable) (Registration, error)
			func go.opentelemetry.io/otel/metric/noop.Meter.RegisterCallback(Callback, ...Observable) (Registration, error)


Package-Level Functions (total 28)

	 func NewAddConfig(opts []AddOption) AddConfig
		NewAddConfig returns a new [AddConfig] with all opts applied.

	 func NewFloat64CounterConfig(opts ...Float64CounterOption) Float64CounterConfig
		NewFloat64CounterConfig returns a new [Float64CounterConfig] with all opts
		applied.

	 func NewFloat64GaugeConfig(opts ...Float64GaugeOption) Float64GaugeConfig
		NewFloat64GaugeConfig returns a new [Float64GaugeConfig] with all opts
		applied.

	 func NewFloat64HistogramConfig(opts ...Float64HistogramOption) Float64HistogramConfig
		NewFloat64HistogramConfig returns a new [Float64HistogramConfig] with all
		opts applied.

	 func NewFloat64ObservableCounterConfig(opts ...Float64ObservableCounterOption) Float64ObservableCounterConfig
		NewFloat64ObservableCounterConfig returns a new
		[Float64ObservableCounterConfig] with all opts applied.

	 func NewFloat64ObservableGaugeConfig(opts ...Float64ObservableGaugeOption) Float64ObservableGaugeConfig
		NewFloat64ObservableGaugeConfig returns a new [Float64ObservableGaugeConfig]
		with all opts applied.

	 func NewFloat64ObservableUpDownCounterConfig(opts ...Float64ObservableUpDownCounterOption) Float64ObservableUpDownCounterConfig
		NewFloat64ObservableUpDownCounterConfig returns a new
		[Float64ObservableUpDownCounterConfig] with all opts applied.

	 func NewFloat64UpDownCounterConfig(opts ...Float64UpDownCounterOption) Float64UpDownCounterConfig
		NewFloat64UpDownCounterConfig returns a new [Float64UpDownCounterConfig]
		with all opts applied.

	 func NewInt64CounterConfig(opts ...Int64CounterOption) Int64CounterConfig
		NewInt64CounterConfig returns a new [Int64CounterConfig] with all opts
		applied.

	 func NewInt64GaugeConfig(opts ...Int64GaugeOption) Int64GaugeConfig
		NewInt64GaugeConfig returns a new [Int64GaugeConfig] with all opts
		applied.

	 func NewInt64HistogramConfig(opts ...Int64HistogramOption) Int64HistogramConfig
		NewInt64HistogramConfig returns a new [Int64HistogramConfig] with all opts
		applied.

	 func NewInt64ObservableCounterConfig(opts ...Int64ObservableCounterOption) Int64ObservableCounterConfig
		NewInt64ObservableCounterConfig returns a new [Int64ObservableCounterConfig]
		with all opts applied.

	 func NewInt64ObservableGaugeConfig(opts ...Int64ObservableGaugeOption) Int64ObservableGaugeConfig
		NewInt64ObservableGaugeConfig returns a new [Int64ObservableGaugeConfig]
		with all opts applied.

	 func NewInt64ObservableUpDownCounterConfig(opts ...Int64ObservableUpDownCounterOption) Int64ObservableUpDownCounterConfig
		NewInt64ObservableUpDownCounterConfig returns a new
		[Int64ObservableUpDownCounterConfig] with all opts applied.

	 func NewInt64UpDownCounterConfig(opts ...Int64UpDownCounterOption) Int64UpDownCounterConfig
		NewInt64UpDownCounterConfig returns a new [Int64UpDownCounterConfig] with
		all opts applied.

	 func NewMeterConfig(opts ...MeterOption) MeterConfig
		NewMeterConfig creates a new MeterConfig and applies
		all the given options.

	 func NewObserveConfig(opts []ObserveOption) ObserveConfig
		NewObserveConfig returns a new [ObserveConfig] with all opts applied.

	 func NewRecordConfig(opts []RecordOption) RecordConfig
		NewRecordConfig returns a new [RecordConfig] with all opts applied.

	 func WithAttributes(attributes ...attribute.KeyValue) MeasurementOption
		WithAttributes converts attributes into an attribute Set and sets the Set to
		be associated with a measurement. This is shorthand for:
		
			cp := make([]attribute.KeyValue, len(attributes))
			copy(cp, attributes)
			WithAttributeSet(attribute.NewSet(cp...))
		
		[attribute.NewSet] may modify the passed attributes so this will make a copy
		of attributes before creating a set in order to ensure this function is
		concurrent safe. This makes this option function less optimized in
		comparison to [WithAttributeSet]. Therefore, [WithAttributeSet] should be
		preferred for performance sensitive code.
		
		See [WithAttributeSet] for information about how multiple WithAttributes are
		merged.

	 func WithAttributeSet(attributes attribute.Set) MeasurementOption
		WithAttributeSet sets the attribute Set associated with a measurement is
		made with.
		
		If multiple WithAttributeSet or WithAttributes options are passed the
		attributes will be merged together in the order they are passed. Attributes
		with duplicate keys will use the last value passed.

	 func WithDescription(desc string) InstrumentOption
		WithDescription sets the instrument description.

	 func WithExplicitBucketBoundaries(bounds ...float64) HistogramOption
		WithExplicitBucketBoundaries sets the instrument explicit bucket boundaries.
		
		This option is considered "advisory", and may be ignored by API implementations.

	 func WithFloat64Callback(callback Float64Callback) Float64ObservableOption
		WithFloat64Callback adds callback to be called for an instrument.

	 func WithInstrumentationAttributes(attr ...attribute.KeyValue) MeterOption
		WithInstrumentationAttributes sets the instrumentation attributes.
		
		The passed attributes will be de-duplicated.

	 func WithInstrumentationVersion(version string) MeterOption
		WithInstrumentationVersion sets the instrumentation version.

	 func WithInt64Callback(callback Int64Callback) Int64ObservableOption
		WithInt64Callback adds callback to be called for an instrument.

	 func WithSchemaURL(schemaURL string) MeterOption
		WithSchemaURL sets the schema URL.

	 func WithUnit(u string) InstrumentOption
		WithUnit sets the instrument unit.
		
		The unit u should be defined using the appropriate [UCUM](https://ucum.org) case-sensitive code.

The pages are generated with Golds v0.8.2. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds.