Struct rama::telemetry::opentelemetry::metrics::Meter

#[non_exhaustive]
pub struct Meter { /* private fields */ }

Provides the ability to create instruments for recording measurements or accepting callbacks to report measurements.

Instrument Types

Instruments are categorized as either synchronous or asynchronous:

• Synchronous Instruments (e.g., Counter): These are used inline with your application’s processing logic. For example, you might use a Counter to record the number of HTTP requests received.

• Asynchronous Instruments (e.g., ObservableGauge): These allow you to register a callback function that is invoked during export. For instance, you could use an asynchronous gauge to monitor temperature from a sensor every time metrics are exported.

Example Usage

use opentelemetry::{global, KeyValue};

let meter = global::meter("my-meter");

// Synchronous Instruments

// u64 Counter
let u64_counter = meter.u64_counter("my_u64_counter").build();
u64_counter.add(
    10,
    &[
        KeyValue::new("mykey1", "myvalue1"),
        KeyValue::new("mykey2", "myvalue2"),
    ],
);

// f64 Counter
let f64_counter = meter.f64_counter("my_f64_counter").build();
f64_counter.add(
    3.15,
    &[
        KeyValue::new("mykey1", "myvalue1"),
        KeyValue::new("mykey2", "myvalue2"),
    ],
);


// u64 Observable Counter
let _observable_u64_counter = meter
    .u64_observable_counter("my_observable_u64_counter")
    .with_description("My observable counter example")
    .with_unit("myunit")
    .with_callback(|observer| {
        observer.observe(
            100,
            &[
                KeyValue::new("mykey1", "myvalue1"),
                KeyValue::new("mykey2", "myvalue2"),
            ],
        )
    })
    .build();

// f64 Observable Counter
let _observable_f64_counter = meter
    .f64_observable_counter("my_observable_f64_counter")
    .with_description("My observable counter example")
    .with_unit("myunit")
    .with_callback(|observer| {
        observer.observe(
            100.0,
            &[
                KeyValue::new("mykey1", "myvalue1"),
                KeyValue::new("mykey2", "myvalue2"),
            ],
        )
    })
    .build();

// i64 UpDownCounter
let updown_i64_counter = meter.i64_up_down_counter("my_updown_i64_counter").build();
updown_i64_counter.add(
    -10,
    &[
        KeyValue::new("mykey1", "myvalue1"),
        KeyValue::new("mykey2", "myvalue2"),
    ],
);

// f64 UpDownCounter
let updown_f64_counter = meter.f64_up_down_counter("my_updown_f64_counter").build();
updown_f64_counter.add(
    -10.67,
    &[
        KeyValue::new("mykey1", "myvalue1"),
        KeyValue::new("mykey2", "myvalue2"),
    ],
);

// i64 Observable UpDownCounter
let _observable_updown_i64_counter = meter
    .i64_observable_up_down_counter("my_observable_i64_updown_counter")
    .with_description("My observable updown counter example")
    .with_unit("myunit")
    .with_callback(|observer| {
        observer.observe(
            100,
            &[
                KeyValue::new("mykey1", "myvalue1"),
                KeyValue::new("mykey2", "myvalue2"),
            ],
        )
    })
    .build();

// f64 Observable UpDownCounter
let _observable_updown_f64_counter = meter
    .f64_observable_up_down_counter("my_observable_f64_updown_counter")
    .with_description("My observable updown counter example")
    .with_unit("myunit")
    .with_callback(|observer| {
        observer.observe(
            100.0,
            &[
                KeyValue::new("mykey1", "myvalue1"),
                KeyValue::new("mykey2", "myvalue2"),
            ],
        )
    })
    .build();

// i64 Gauge
let gauge = meter.i64_gauge("my_gauge").build();
gauge.record(
-10,
&[
    KeyValue::new("mykey1", "myvalue1"),
    KeyValue::new("mykey2", "myvalue2"),
],
);

// u64 Gauge
let gauge = meter.u64_gauge("my_gauge").build();
gauge.record(
101,
&[
    KeyValue::new("mykey1", "myvalue1"),
    KeyValue::new("mykey2", "myvalue2"),
],
);

// f64 Gauge
let gauge = meter.f64_gauge("my_gauge").build();
gauge.record(
12.5,
&[
    KeyValue::new("mykey1", "myvalue1"),
    KeyValue::new("mykey2", "myvalue2"),
],
);

// u64 Observable Gauge
let _observable_u64_gauge = meter
    .u64_observable_gauge("my_u64_gauge")
    .with_description("An observable gauge set to 1")
    .with_unit("myunit")
    .with_callback(|observer| {
        observer.observe(
            1,
            &[
                KeyValue::new("mykey1", "myvalue1"),
                KeyValue::new("mykey2", "myvalue2"),
            ],
        )
    })
    .build();

// f64 Observable Gauge
let _observable_f64_gauge = meter
    .f64_observable_gauge("my_f64_gauge")
    .with_description("An observable gauge set to 1.0")
    .with_unit("myunit")
    .with_callback(|observer| {
        observer.observe(
            1.0,
            &[
                KeyValue::new("mykey1", "myvalue1"),
                KeyValue::new("mykey2", "myvalue2"),
            ],
        )
    })
    .build();

// i64 Observable Gauge
let _observable_i64_gauge = meter
    .i64_observable_gauge("my_i64_gauge")
    .with_description("An observable gauge set to 1")
    .with_unit("myunit")
    .with_callback(|observer| {
        observer.observe(
            1,
            &[
                KeyValue::new("mykey1", "myvalue1"),
                KeyValue::new("mykey2", "myvalue2"),
            ],
        )
    })
    .build();

// f64 Histogram
let f64_histogram = meter.f64_histogram("my_f64_histogram").build();
f64_histogram.record(
    10.5,
    &[
        KeyValue::new("mykey1", "myvalue1"),
        KeyValue::new("mykey2", "myvalue2"),
    ],
);

// u64 Histogram
let u64_histogram = meter.u64_histogram("my_u64_histogram").build();
u64_histogram.record(
    12,
    &[
        KeyValue::new("mykey1", "myvalue1"),
        KeyValue::new("mykey2", "myvalue2"),
    ],
);

Implementations

impl Meter

pub fn u64_counter( &self, name: impl Into<Cow<'static, str>>, ) -> InstrumentBuilder<'_, Counter<u64>>

creates an instrument builder for recording increasing values.

Counter can be cloned to create multiple handles to the same instrument. If a Counter needs to be shared, users are recommended to clone the Counter instead of creating duplicate Counters for the same metric. Creating duplicate Counters for the same metric could lower SDK performance.

pub fn f64_counter( &self, name: impl Into<Cow<'static, str>>, ) -> InstrumentBuilder<'_, Counter<f64>>

creates an instrument builder for recording increasing values.

Counter can be cloned to create multiple handles to the same instrument. If a Counter needs to be shared, users are recommended to clone the Counter instead of creating duplicate Counters for the same metric. Creating duplicate Counters for the same metric could lower SDK performance.

pub fn u64_observable_counter( &self, name: impl Into<Cow<'static, str>>, ) -> AsyncInstrumentBuilder<'_, ObservableCounter<u64>, u64>

creates an instrument builder for recording increasing values via callback.

pub fn f64_observable_counter( &self, name: impl Into<Cow<'static, str>>, ) -> AsyncInstrumentBuilder<'_, ObservableCounter<f64>, f64>

creates an instrument builder for recording increasing values via callback.

pub fn i64_up_down_counter( &self, name: impl Into<Cow<'static, str>>, ) -> InstrumentBuilder<'_, UpDownCounter<i64>>

creates an instrument builder for recording changes of a value.

UpDownCounter can be cloned to create multiple handles to the same instrument. If a UpDownCounter needs to be shared, users are recommended to clone the UpDownCounter instead of creating duplicate UpDownCounters for the same metric. Creating duplicate UpDownCounters for the same metric could lower SDK performance.

pub fn f64_up_down_counter( &self, name: impl Into<Cow<'static, str>>, ) -> InstrumentBuilder<'_, UpDownCounter<f64>>

creates an instrument builder for recording changes of a value.

UpDownCounter can be cloned to create multiple handles to the same instrument. If a UpDownCounter needs to be shared, users are recommended to clone the UpDownCounter instead of creating duplicate UpDownCounters for the same metric. Creating duplicate UpDownCounters for the same metric could lower SDK performance.

pub fn i64_observable_up_down_counter( &self, name: impl Into<Cow<'static, str>>, ) -> AsyncInstrumentBuilder<'_, ObservableUpDownCounter<i64>, i64>

creates an instrument builder for recording changes of a value via callback.

UpDownCounter can be cloned to create multiple handles to the same instrument. If a UpDownCounter needs to be shared, users are recommended to clone the UpDownCounter instead of creating duplicate UpDownCounters for the same metric. Creating duplicate UpDownCounters for the same metric could lower SDK performance.

pub fn f64_observable_up_down_counter( &self, name: impl Into<Cow<'static, str>>, ) -> AsyncInstrumentBuilder<'_, ObservableUpDownCounter<f64>, f64>

creates an instrument builder for recording changes of a value via callback.

pub fn u64_gauge( &self, name: impl Into<Cow<'static, str>>, ) -> InstrumentBuilder<'_, Gauge<u64>>

creates an instrument builder for recording independent values.

Gauge can be cloned to create multiple handles to the same instrument. If a Gauge needs to be shared, users are recommended to clone the Gauge instead of creating duplicate Gauges for the same metric. Creating duplicate Gauges for the same metric could lower SDK performance.

pub fn f64_gauge( &self, name: impl Into<Cow<'static, str>>, ) -> InstrumentBuilder<'_, Gauge<f64>>

creates an instrument builder for recording independent values.

Gauge can be cloned to create multiple handles to the same instrument. If a Gauge needs to be shared, users are recommended to clone the Gauge instead of creating duplicate Gauges for the same metric. Creating duplicate Gauges for the same metric could lower SDK performance.

pub fn i64_gauge( &self, name: impl Into<Cow<'static, str>>, ) -> InstrumentBuilder<'_, Gauge<i64>>

creates an instrument builder for recording independent values. Gauge can be cloned to create multiple handles to the same instrument. If a Gauge needs to be shared, users are recommended to clone the Gauge instead of creating duplicate Gauges for the same metric. Creating duplicate Gauges for the same metric could lower SDK performance.

pub fn u64_observable_gauge( &self, name: impl Into<Cow<'static, str>>, ) -> AsyncInstrumentBuilder<'_, ObservableGauge<u64>, u64>

creates an instrument builder for recording the current value via callback.

pub fn i64_observable_gauge( &self, name: impl Into<Cow<'static, str>>, ) -> AsyncInstrumentBuilder<'_, ObservableGauge<i64>, i64>

creates an instrument builder for recording the current value via callback.

pub fn f64_observable_gauge( &self, name: impl Into<Cow<'static, str>>, ) -> AsyncInstrumentBuilder<'_, ObservableGauge<f64>, f64>

creates an instrument builder for recording the current value via callback.

pub fn f64_histogram( &self, name: impl Into<Cow<'static, str>>, ) -> HistogramBuilder<'_, Histogram<f64>>

creates an instrument builder for recording a distribution of values.

Histogram can be cloned to create multiple handles to the same instrument. If a Histogram needs to be shared, users are recommended to clone the Histogram instead of creating duplicate Histograms for the same metric. Creating duplicate Histograms for the same metric could lower SDK performance.

pub fn u64_histogram( &self, name: impl Into<Cow<'static, str>>, ) -> HistogramBuilder<'_, Histogram<u64>>

creates an instrument builder for recording a distribution of values.

Histogram can be cloned to create multiple handles to the same instrument. If a Histogram needs to be shared, users are recommended to clone the Histogram instead of creating duplicate Histograms for the same metric. Creating duplicate Histograms for the same metric could lower SDK performance.

Trait Implementations

impl Clone for Meter

fn clone(&self) -> Meter

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Meter

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.