🥮 mooncakes.io
README

#OpenTelemetry Metrics API

This package is the public metrics API. It lets instrumentation code describe measurements without depending on a concrete SDK, reader, or exporter.

Metrics are not exported one measurement at a time. Instruments record raw measurements into in-memory aggregation state. SDK readers later collect the aggregated metric points and exporters send those points to a backend.

#Main Types

  • MeterProvider: entry point that creates meters
  • Meter: creates instruments for one instrumentation scope
  • Counter, UpDownCounter, Histogram, Gauge: synchronous instruments
  • ObservableCounter, ObservableUpDownCounter, ObservableGauge: callback instruments observed during collection
  • builder types for every instrument kind

#Choosing Instruments

Choose the instrument based on the meaning of the value, not only its type:

Use caseInstrument
Count requests, errors, bytes sent, or other monotonic totalsCounter
Track active requests, queue depth, or connections that go up and downUpDownCounter
Record latency, payload size, or other distributionsHistogram
Record latest temperature, memory use, or other current stateGauge
Read a value owned elsewhere only when metrics are collectedObservable instrument

Prefer low-cardinality attributes. Values such as user IDs, raw URLs, UUIDs, or unbounded error strings can create too many time series.

#Recording Measurements

Create instruments once and reuse them. Instrument creation may register SDK state; recording is the hot path.

///|
fn _metrics_readme_record() -> Unit {
  let meter = MeterProvider::noop().meter("example")
  let counter = meter
    .u64_counter("request.count")
    .with_description("Total handled requests")
    .build()
  let latency = meter.f64_histogram("request.duration").with_unit("ms").build()

  counter.add(1UL, attributes=[
    @common.KeyValue::new("http.request.method", String("GET")),
  ])
  latency.record(12.5, attributes=[
    @common.KeyValue::new("http.route", String("/health")),
  ])
}

The SDK ignores negative deltas for monotonic counters. Use an up-down counter when the value can decrease.

#Observable Instruments

Observable instruments are callbacks. Use them when the measurement already lives somewhere else and should be read during collection, for example process memory, queue length, connection pool size, or OS counters.

///|
fn _metrics_readme_observable() -> Unit {
  let meter = MeterProvider::noop().meter("example")
  let observable = meter
    .i64_observable_up_down_counter("queue.depth")
    .with_callback(observer => observer.observe(42L))
    .build()
  ignore(observable)
}

Callbacks are frozen when build() is called. If a no-op meter is used, callbacks are accepted but never collected by an SDK reader.

#Provider Reference

  • MeterProvider::noop() creates no-op instruments.
  • meter(name) creates a meter for one instrumentation name.
  • meter_with_scope(scope) creates a meter from a full instrumentation scope.

Applications register SDK providers through sdk.set_meter_provider(provider); the SDK facade updates interface/global for API callers.

#Instrument Reference

  • Counter::add(value, attributes?) records a monotonic delta.
  • UpDownCounter::add(value, attributes?) records a signed delta.
  • Histogram::record(value, attributes?) records one sample.
  • Gauge::record(value, attributes?) records the latest value.
  • ObservableCounter::observe(value, attributes?) reports a callback value for a monotonic observable counter.
  • ObservableUpDownCounter::observe(value, attributes?) reports a callback value for an additive observable counter.
  • ObservableGauge::observe(value, attributes?) reports a callback value for a gauge.

#Builder Reference

All builders expose:

  • with_description(description): human-readable explanation of the instrument
  • with_unit(unit): UCUM-style unit such as ms, By, or 1
  • build(): creates the instrument

Observable builders also expose with_callback(callback).

#Meter Factory Reference

Counters:

  • u64_counter(name)
  • f64_counter(name)

Up-down counters:

  • i64_up_down_counter(name)
  • f64_up_down_counter(name)

Histograms:

  • u64_histogram(name)
  • f64_histogram(name)

Gauges:

  • u64_gauge(name)
  • i64_gauge(name), converted to the SDK's floating-point representation
  • f64_gauge(name)

Observable counters:

  • u64_observable_counter(name)
  • f64_observable_counter(name)

Observable up-down counters:

  • i64_observable_up_down_counter(name)
  • f64_observable_up_down_counter(name)

Observable gauges:

  • u64_observable_gauge(name)
  • i64_observable_gauge(name), callback values converted to floating point
  • f64_observable_gauge(name)

#No-Op Behavior

No-op meters return builders whose built instruments silently discard measurements. This lets libraries record metrics unconditionally while the final application decides whether a real SDK provider and reader are installed.

#
Counter

source

Monotonic synchronous counter handle.

Use counters for values that only increase, such as requests served, errors observed, or bytes sent. Negative deltas are ignored by the SDK. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#counter

#
Counter::add

source
fn[T] Counter::add(self : Counter[T], value : T, attributes? : ArrayView[
KeyValue]) -> Unit

Adds one measurement to a monotonic counter.

The underlying SDK ignores negative deltas. Attributes should be low-cardinality because they form metric series identity. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#counter

#
Counter::from_functions

source

Builds a counter handle from an add callback. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#counter

#
CounterBuilder

source
pub struct CounterBuilder[T] {
  description : String?
  unit : String?
  create_fn : (String?, String?) -> Counter[T]
}

Builder for Counter. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#instrument

#
CounterBuilder::build

source
fn[T] CounterBuilder::build(self : CounterBuilder[T]) -> Counter[T]

Builds the counter with the current builder options. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#instrument

#
CounterBuilder::from_functions

source
fn[T] CounterBuilder::from_functions(create_fn : (String?, String?) -> Counter[T]) -> CounterBuilder[T]

Builds a counter builder from a creation callback. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#instrument

#
CounterBuilder::with_description

source
fn[T] CounterBuilder::with_description(self : CounterBuilder[T], description : StringView) -> CounterBuilder[T]

Sets the instrument description on the counter builder. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#instrument-description

#
CounterBuilder::with_unit

source
fn[T] CounterBuilder::with_unit(self : CounterBuilder[T], unit : StringView) -> CounterBuilder[T]

Sets the instrument unit on the counter builder. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#instrument-unit

#
Gauge

source
pub struct Gauge[T] {
  record_fn : (T, ArrayView[
KeyValue]) -> Unit
}

Synchronous gauge handle recording the latest value for one attribute set.

Use gauges for current-state measurements such as memory usage or temperature. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#gauge

#
Gauge::from_functions

source
fn[T] Gauge::from_functions(record_fn : (T, ArrayView[
KeyValue]) -> Unit) -> Gauge[T]

Builds a gauge handle from a record callback. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#gauge

#
Gauge::record

source
fn[T] Gauge::record(self : Gauge[T], value : T, attributes? : ArrayView[
KeyValue]) -> Unit

Records the latest gauge value for one attribute set.

The latest value replaces the previous value for the same attribute set. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#gauge

#
GaugeBuilder

source
pub struct GaugeBuilder[T] {
  description : String?
  unit : String?
  create_fn : (String?, String?) -> Gauge[T]
}

Builder for Gauge. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#instrument

#
GaugeBuilder::build

source
fn[T] GaugeBuilder::build(self : GaugeBuilder[T]) -> Gauge[T]

Builds the gauge with the current builder options. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#instrument

#
GaugeBuilder::from_functions

source
fn[T] GaugeBuilder::from_functions(create_fn : (String?, String?) -> Gauge[T]) -> GaugeBuilder[T]

Builds a gauge builder from a creation callback. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#instrument

#
GaugeBuilder::with_description

source
fn[T] GaugeBuilder::with_description(self : GaugeBuilder[T], description : StringView) -> GaugeBuilder[T]

Sets the instrument description on the gauge builder. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#instrument-description

#
GaugeBuilder::with_unit

source
fn[T] GaugeBuilder::with_unit(self : GaugeBuilder[T], unit : StringView) -> GaugeBuilder[T]

Sets the instrument unit on the gauge builder. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#instrument-unit

#
Histogram

source
pub struct Histogram[T] {
  record_fn : (T, ArrayView[
KeyValue]) -> Unit
}

Synchronous histogram handle.

Use histograms for distributions such as request latency, payload size, or retry count. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#histogram

#
Histogram::from_functions

source

Builds a histogram handle from a record callback. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#histogram

#
Histogram::record

source
fn[T] Histogram::record(self : Histogram[T], value : T, attributes? : ArrayView[
KeyValue]) -> Unit

Records one histogram sample.

Histograms aggregate distributions and are usually the right choice for latency and size measurements. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#histogram

#
HistogramBuilder

source
pub struct HistogramBuilder[T] {
  description : String?
  unit : String?
  create_fn : (String?, String?) -> Histogram[T]
}

Builder for Histogram. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#instrument

#
HistogramBuilder::build

source
fn[T] HistogramBuilder::build(self : HistogramBuilder[T]) -> Histogram[T]

Builds the histogram with the current builder options. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#instrument

#
HistogramBuilder::from_functions

source
fn[T] HistogramBuilder::from_functions(create_fn : (String?, String?) -> Histogram[T]) -> HistogramBuilder[T]

Builds a histogram builder from a creation callback. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#instrument

#
HistogramBuilder::with_description

source
fn[T] HistogramBuilder::with_description(self : HistogramBuilder[T], description : StringView) -> HistogramBuilder[T]

Sets the instrument description on the histogram builder. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#instrument-description

#
HistogramBuilder::with_unit

source
fn[T] HistogramBuilder::with_unit(self : HistogramBuilder[T], unit : StringView) -> HistogramBuilder[T]

Sets the instrument unit on the histogram builder. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#instrument-unit

#
Meter

source
pub struct Meter {
  u64_counter_fn : (String) -> CounterBuilder[UInt64]
  f64_counter_fn : (String) -> CounterBuilder[Double]
  i64_up_down_counter_fn : (String) -> UpDownCounterBuilder[Int64]
  f64_up_down_counter_fn : (String) -> UpDownCounterBuilder[Double]
  u64_histogram_fn : (String) -> HistogramBuilder[UInt64]
  f64_histogram_fn : (String) -> HistogramBuilder[Double]
  u64_gauge_fn : (String) -> GaugeBuilder[UInt64]
  i64_gauge_fn : (String) -> GaugeBuilder[Int64]
  f64_gauge_fn : (String) -> GaugeBuilder[Double]
  u64_observable_counter_fn : (String) -> ObservableCounterBuilder[UInt64]
  f64_observable_counter_fn : (String) -> ObservableCounterBuilder[Double]
  i64_observable_up_down_counter_fn : (String) -> ObservableUpDownCounterBuilder[Int64]
  f64_observable_up_down_counter_fn : (String) -> ObservableUpDownCounterBuilder[Double]
  u64_observable_gauge_fn : (String) -> ObservableGaugeBuilder[UInt64]
  i64_observable_gauge_fn : (String) -> ObservableGaugeBuilder[Int64]
  f64_observable_gauge_fn : (String) -> ObservableGaugeBuilder[Double]
}

Public meter handle.

A meter creates reusable instruments for one instrumentation scope. Create instruments once and reuse them on hot paths. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#meter

#
Meter::f64_counter

source
fn Meter::f64_counter(self : Meter, name : StringView) -> CounterBuilder[Double]

Starts building a Double monotonic counter.

The underlying SDK ignores negative deltas. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#counter-creation

#
Meter::f64_gauge

source
fn Meter::f64_gauge(self : Meter, name : StringView) -> GaugeBuilder[Double]

Starts building a Double gauge. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#gauge-creation

#
Meter::f64_histogram

source
fn Meter::f64_histogram(self : Meter, name : StringView) -> HistogramBuilder[Double]

Starts building a Double histogram. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#histogram-creation

#
Meter::f64_observable_counter

source
fn Meter::f64_observable_counter(self : Meter, name : StringView) -> ObservableCounterBuilder[Double]

Starts building a Double observable counter. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#asynchronous-counter-creation

#
Meter::f64_observable_gauge

source
fn Meter::f64_observable_gauge(self : Meter, name : StringView) -> ObservableGaugeBuilder[Double]

Starts building a Double observable gauge. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#asynchronous-gauge-creation

#
Meter::f64_observable_up_down_counter

source
fn Meter::f64_observable_up_down_counter(self : Meter, name : StringView) -> ObservableUpDownCounterBuilder[Double]

Starts building a Double observable up-down counter. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#asynchronous-updowncounter-creation

#
Meter::f64_up_down_counter

source
fn Meter::f64_up_down_counter(self : Meter, name : StringView) -> UpDownCounterBuilder[Double]

Starts building a Double up-down counter. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#updowncounter-creation

#
Meter::from_functions

source
fn Meter::from_functions(u64_counter_fn : (String) -> CounterBuilder[UInt64], f64_counter_fn : (String) -> CounterBuilder[Double], i64_up_down_counter_fn : (String) -> UpDownCounterBuilder[Int64], f64_up_down_counter_fn : (String) -> UpDownCounterBuilder[Double], u64_histogram_fn : (String) -> HistogramBuilder[UInt64], f64_histogram_fn : (String) -> HistogramBuilder[Double], u64_gauge_fn : (String) -> GaugeBuilder[UInt64], i64_gauge_fn : (String) -> GaugeBuilder[Int64], f64_gauge_fn : (String) -> GaugeBuilder[Double], u64_observable_counter_fn : (String) -> ObservableCounterBuilder[UInt64], f64_observable_counter_fn : (String) -> ObservableCounterBuilder[Double], i64_observable_up_down_counter_fn : (String) -> ObservableUpDownCounterBuilder[Int64], f64_observable_up_down_counter_fn : (String) -> ObservableUpDownCounterBuilder[Double], u64_observable_gauge_fn : (String) -> ObservableGaugeBuilder[UInt64], i64_observable_gauge_fn : (String) -> ObservableGaugeBuilder[Int64], f64_observable_gauge_fn : (String) -> ObservableGaugeBuilder[Double]) -> Meter

Builds a meter from instrument-builder callbacks.

SDK implementations use this to erase concrete meter types into the public API without making the API package depend on the SDK. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#meter

#
Meter::i64_gauge

source
fn Meter::i64_gauge(self : Meter, name : StringView) -> GaugeBuilder[Int64]

Starts building an Int64 gauge.

Values are converted to Double before they are forwarded to the SDK. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#gauge-creation

#
Meter::i64_observable_gauge

source
fn Meter::i64_observable_gauge(self : Meter, name : StringView) -> ObservableGaugeBuilder[Int64]

Starts building an Int64 observable gauge.

Callback observations are converted to Double before they are forwarded to the SDK. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#asynchronous-gauge-creation

#
Meter::i64_observable_up_down_counter

source
fn Meter::i64_observable_up_down_counter(self : Meter, name : StringView) -> ObservableUpDownCounterBuilder[Int64]

Starts building an Int64 observable up-down counter. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#asynchronous-updowncounter-creation

#
Meter::i64_up_down_counter

source
fn Meter::i64_up_down_counter(self : Meter, name : StringView) -> UpDownCounterBuilder[Int64]

Starts building an Int64 up-down counter. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#updowncounter-creation

#
Meter::u64_counter

source
fn Meter::u64_counter(self : Meter, name : StringView) -> CounterBuilder[UInt64]

Starts building a UInt64 monotonic counter.

Instrument names should be stable and low-cardinality. The same named instrument should be built once and reused. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#counter-creation

#
Meter::u64_gauge

source
fn Meter::u64_gauge(self : Meter, name : StringView) -> GaugeBuilder[UInt64]

Starts building a UInt64 gauge. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#gauge-creation

#
Meter::u64_histogram

source
fn Meter::u64_histogram(self : Meter, name : StringView) -> HistogramBuilder[UInt64]

Starts building a UInt64 histogram. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#histogram-creation

#
Meter::u64_observable_counter

source
fn Meter::u64_observable_counter(self : Meter, name : StringView) -> ObservableCounterBuilder[UInt64]

Starts building a UInt64 observable counter. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#asynchronous-counter-creation

#
Meter::u64_observable_gauge

source
fn Meter::u64_observable_gauge(self : Meter, name : StringView) -> ObservableGaugeBuilder[UInt64]

Starts building a UInt64 observable gauge. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#asynchronous-gauge-creation

#
MeterProvider

source

Public meter provider.

The default provider is no-op. Applications install SDK-backed providers through the SDK facade while library code depends only on this API type. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#meterprovider

#
MeterProvider::from_functions

source

Builds a meter provider from a scope-to-meter callback. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#meterprovider

#
MeterProvider::meter

source
fn MeterProvider::meter(self : MeterProvider, name : StringView) -> Meter

Returns a meter for one instrumentation name.

If the provider is no-op, the returned meter creates no-op instruments. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#get-a-meter

#
MeterProvider::meter_with_scope

source

Returns a meter for a fully constructed instrumentation scope. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#get-a-meter

#
MeterProvider::noop

source

Returns a no-op meter provider.

Meters from this provider create instruments that silently discard all measurements and never run observable callbacks. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#meterprovider

#
ObservableCounter

source
pub struct ObservableCounter[T] {
  observe_fn : (T, ArrayView[
KeyValue]) -> Unit
}

Observable monotonic counter handle used inside callbacks.

Observable instruments report values during SDK collection instead of at the point where application work happens. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#asynchronous-counter

#
ObservableCounter::from_functions

source

Builds an observable counter handle from an observe callback. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#asynchronous-counter

#
ObservableCounter::observe

source

Reports one observable counter value from a callback. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#asynchronous-counter

#
ObservableCounterBuilder

source
pub struct ObservableCounterBuilder[T] {
  description : String?
  unit : String?
  callbacks : Array[(ObservableCounter[T]) -> Unit]
  create_fn : (String?, String?, Array[(ObservableCounter[T]) -> Unit]) -> ObservableCounter[T]
}

Builder for ObservableCounter. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#instrument

#
ObservableCounterBuilder::build

source

Builds the observable counter and freezes the currently registered callbacks. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#instrument

#
ObservableCounterBuilder::from_functions

source
fn[T] ObservableCounterBuilder::from_functions(create_fn : (String?, String?, Array[(ObservableCounter[T]) -> Unit]) -> ObservableCounter[T]) -> ObservableCounterBuilder[T]

Builds an observable counter builder from a creation callback. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#instrument

#
ObservableCounterBuilder::with_callback

source
fn[T] ObservableCounterBuilder::with_callback(self : ObservableCounterBuilder[T], callback : (ObservableCounter[T]) -> Unit) -> ObservableCounterBuilder[T]

Registers one callback to run during metric collection.

Keep callbacks fast and side-effect-light. They run on collection/export paths, not when the observable instrument is created. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#instrument

#
ObservableCounterBuilder::with_description

source
fn[T] ObservableCounterBuilder::with_description(self : ObservableCounterBuilder[T], description : StringView) -> ObservableCounterBuilder[T]

Sets the instrument description on the observable counter builder. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#instrument-description

#
ObservableCounterBuilder::with_unit

source
fn[T] ObservableCounterBuilder::with_unit(self : ObservableCounterBuilder[T], unit : StringView) -> ObservableCounterBuilder[T]

Sets the instrument unit on the observable counter builder. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#instrument-unit

#
ObservableGauge

source
pub struct ObservableGauge[T] {
  observe_fn : (T, ArrayView[
KeyValue]) -> Unit
}

Observable gauge handle used inside callbacks. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#asynchronous-gauge

#
ObservableGauge::from_functions

source

Builds an observable gauge handle from an observe callback. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#asynchronous-gauge

#
ObservableGauge::observe

source

Reports one observable gauge value from a callback. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#asynchronous-gauge

#
ObservableGaugeBuilder

source
pub struct ObservableGaugeBuilder[T] {
  description : String?
  unit : String?
  callbacks : Array[(ObservableGauge[T]) -> Unit]
  create_fn : (String?, String?, Array[(ObservableGauge[T]) -> Unit]) -> ObservableGauge[T]
}

Builder for ObservableGauge. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#instrument

#
ObservableGaugeBuilder::build

source

Builds the observable gauge and freezes the currently registered callbacks. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#instrument

#
ObservableGaugeBuilder::from_functions

source
fn[T] ObservableGaugeBuilder::from_functions(create_fn : (String?, String?, Array[(ObservableGauge[T]) -> Unit]) -> ObservableGauge[T]) -> ObservableGaugeBuilder[T]

Builds an observable gauge builder from a creation callback. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#instrument

#
ObservableGaugeBuilder::with_callback

source
fn[T] ObservableGaugeBuilder::with_callback(self : ObservableGaugeBuilder[T], callback : (ObservableGauge[T]) -> Unit) -> ObservableGaugeBuilder[T]

Registers one callback to run during metric collection.

Keep callbacks fast and side-effect-light. They run on collection/export paths, not when the observable instrument is created. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#instrument

#
ObservableGaugeBuilder::with_description

source
fn[T] ObservableGaugeBuilder::with_description(self : ObservableGaugeBuilder[T], description : StringView) -> ObservableGaugeBuilder[T]

Sets the instrument description on the observable gauge builder. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#instrument-description

#
ObservableGaugeBuilder::with_unit

source
fn[T] ObservableGaugeBuilder::with_unit(self : ObservableGaugeBuilder[T], unit : StringView) -> ObservableGaugeBuilder[T]

Sets the instrument unit on the observable gauge builder. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#instrument-unit

#
ObservableUpDownCounter

source
pub struct ObservableUpDownCounter[T] {
  observe_fn : (T, ArrayView[
KeyValue]) -> Unit
}

Observable additive counter handle used inside callbacks. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#asynchronous-updowncounter

#
ObservableUpDownCounter::from_functions

source

Builds an observable up-down counter handle from an observe callback. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#asynchronous-updowncounter

#
ObservableUpDownCounter::observe

source

Reports one observable up-down counter value from a callback. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#asynchronous-updowncounter

#
ObservableUpDownCounterBuilder

source
pub struct ObservableUpDownCounterBuilder[T] {
  description : String?
  unit : String?
  callbacks : Array[(ObservableUpDownCounter[T]) -> Unit]
  create_fn : (String?, String?, Array[(ObservableUpDownCounter[T]) -> Unit]) -> ObservableUpDownCounter[T]
}

Builder for ObservableUpDownCounter. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#instrument

#
ObservableUpDownCounterBuilder::build

source

Builds the observable up-down counter and freezes the currently registered callbacks. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#instrument

#
ObservableUpDownCounterBuilder::from_functions

source
fn[T] ObservableUpDownCounterBuilder::from_functions(create_fn : (String?, String?, Array[(ObservableUpDownCounter[T]) -> Unit]) -> ObservableUpDownCounter[T]) -> ObservableUpDownCounterBuilder[T]

Builds an observable up-down counter builder from a creation callback. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#instrument

#
ObservableUpDownCounterBuilder::with_callback

source

Registers one callback to run during metric collection.

Keep callbacks fast and side-effect-light. They run on collection/export paths, not when the observable instrument is created. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#instrument

#
ObservableUpDownCounterBuilder::with_description

source
fn[T] ObservableUpDownCounterBuilder::with_description(self : ObservableUpDownCounterBuilder[T], description : StringView) -> ObservableUpDownCounterBuilder[T]

Sets the instrument description on the observable up-down counter builder. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#instrument-description

#
ObservableUpDownCounterBuilder::with_unit

source

Sets the instrument unit on the observable up-down counter builder. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#instrument-unit

#
UpDownCounter

source
pub struct UpDownCounter[T] {
  add_fn : (T, ArrayView[
KeyValue]) -> Unit
}

Additive synchronous counter that accepts positive and negative deltas.

Use up-down counters for state that can increase and decrease, such as active requests, queue depth, or open connections. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#updowncounter

#
UpDownCounter::add

source

Adds one measurement to an up-down counter.

Use this for state that can go up and down. For monotonically increasing totals, prefer Counter. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#updowncounter

#
UpDownCounter::from_functions

source

Builds an up-down counter handle from an add callback. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#updowncounter

#
UpDownCounterBuilder

source
pub struct UpDownCounterBuilder[T] {
  description : String?
  unit : String?
  create_fn : (String?, String?) -> UpDownCounter[T]
}

Builder for UpDownCounter. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#instrument

#
UpDownCounterBuilder::build

source

Builds the up-down counter with the current builder options. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#instrument

#
UpDownCounterBuilder::from_functions

source
fn[T] UpDownCounterBuilder::from_functions(create_fn : (String?, String?) -> UpDownCounter[T]) -> UpDownCounterBuilder[T]

Builds an up-down counter builder from a creation callback. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#instrument

#
UpDownCounterBuilder::with_description

source
fn[T] UpDownCounterBuilder::with_description(self : UpDownCounterBuilder[T], description : StringView) -> UpDownCounterBuilder[T]

Sets the instrument description on the up-down counter builder. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#instrument-description

#
UpDownCounterBuilder::with_unit

source
fn[T] UpDownCounterBuilder::with_unit(self : UpDownCounterBuilder[T], unit : StringView) -> UpDownCounterBuilder[T]

Sets the instrument unit on the up-down counter builder. Spec: https://opentelemetry.io/docs/specs/otel/metrics/api/#instrument-unit

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io