Struct opentelemetry::metrics::Meter

pub struct Meter { /* private fields */ }

Provides access to instrument instances for recording measurements.

use opentelemetry::{global, KeyValue};

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

// Meters can create metric instruments that can record values of type u64 and f64

// u64 Counter
let u64_counter = meter.u64_counter("my_u64_counter").init();

// Record measurements using the counter instrument add()
u64_counter.add(
    10,
    [
        KeyValue::new("mykey1", "myvalue1"),
        KeyValue::new("mykey2", "myvalue2"),
    ].as_ref()
);

// f64 Counter
let f64_counter = meter.f64_counter("my_f64_counter").init();

// Record measurements using the counter instrument add()
f64_counter.add(
    3.15,
    [
        KeyValue::new("mykey1", "myvalue1"),
        KeyValue::new("mykey2", "myvalue2"),
    ].as_ref()
);

// u6 observable counter
let observable_u4_counter = meter.u64_observable_counter("my_observable_u64_counter").init();

// Register a callback to this meter for an asynchronous instrument to record measurements
meter.register_callback(&[observable_u4_counter.as_any()], move |observer| {
    observer.observe_u64(
        &observable_u4_counter,
        1,
        [
            KeyValue::new("mykey1", "myvalue1"),
            KeyValue::new("mykey2", "myvalue2"),
        ].as_ref(),
    )
});

// f64 observable counter
let observable_f64_counter = meter.f64_observable_counter("my_observable_f64_counter").init();

// Register a callback to this meter for an asynchronous instrument to record measurements
meter.register_callback(&[observable_f64_counter.as_any()], move |observer| {
    observer.observe_f64(
        &observable_f64_counter,
        1.55,
        [
            KeyValue::new("mykey1", "myvalue1"),
            KeyValue::new("mykey2", "myvalue2"),
        ].as_ref(),
    )
});

// i64 updown counter
let updown_i64_counter = meter.i64_up_down_counter("my_updown_i64_counter").init();

// Record measurements using the updown counter instrument add()
updown_i64_counter.add(
    -10,
    [
        KeyValue::new("mykey1", "myvalue1"),
        KeyValue::new("mykey2", "myvalue2"),
    ].as_ref(),
);

// f64 updown counter
let updown_f64_counter = meter.f64_up_down_counter("my_updown_f64_counter").init();

// Record measurements using the updown counter instrument add()
updown_f64_counter.add(
    -10.67,
    [
        KeyValue::new("mykey1", "myvalue1"),
        KeyValue::new("mykey2", "myvalue2"),
    ].as_ref(),
);

// i64 observable updown counter
let observable_i64_up_down_counter = meter.i64_observable_up_down_counter("my_observable_i64_updown_counter").init();

// Register a callback to this meter for an asynchronous instrument to record measurements
meter.register_callback(&[observable_i64_up_down_counter.as_any()], move |observer| {
    observer.observe_i64(
        &observable_i64_up_down_counter,
        1,
        [
            KeyValue::new("mykey1", "myvalue1"),
            KeyValue::new("mykey2", "myvalue2"),
        ].as_ref(),
    )
});

// f64 observable updown counter
let observable_f64_up_down_counter = meter.f64_observable_up_down_counter("my_observable_f64_updown_counter").init();

// Register a callback to this meter for an asynchronous instrument to record measurements
meter.register_callback(&[observable_f64_up_down_counter.as_any()], move |observer| {
    observer.observe_f64(
        &observable_f64_up_down_counter,
        1.16,
        [
            KeyValue::new("mykey1", "myvalue1"),
            KeyValue::new("mykey2", "myvalue2"),
        ].as_ref(),
    )
});

// Observable f64 gauge
let f64_gauge = meter.f64_observable_gauge("my_f64_gauge").init();

// Register a callback to this meter for an asynchronous instrument to record measurements
meter.register_callback(&[f64_gauge.as_any()], move |observer| {
    observer.observe_f64(
        &f64_gauge,
        2.32,
        [
            KeyValue::new("mykey1", "myvalue1"),
            KeyValue::new("mykey2", "myvalue2"),
        ].as_ref(),
    )
});

// Observable i64 gauge
let i64_gauge = meter.i64_observable_gauge("my_i64_gauge").init();

// Register a callback to this meter for an asynchronous instrument to record measurements
meter.register_callback(&[i64_gauge.as_any()], move |observer| {
    observer.observe_i64(
        &i64_gauge,
        12,
        [
            KeyValue::new("mykey1", "myvalue1"),
            KeyValue::new("mykey2", "myvalue2"),
        ].as_ref(),
    )
});

// Observable u64 gauge
let u64_gauge = meter.u64_observable_gauge("my_u64_gauge").init();

// Register a callback to this meter for an asynchronous instrument to record measurements
meter.register_callback(&[u64_gauge.as_any()], move |observer| {
    observer.observe_u64(
        &u64_gauge,
        1,
        [
            KeyValue::new("mykey1", "myvalue1"),
            KeyValue::new("mykey2", "myvalue2"),
        ].as_ref(),
    )
});

// f64 histogram
let f64_histogram = meter.f64_histogram("my_f64_histogram").init();

// Record measurements using the histogram instrument record()
f64_histogram.record(
    10.5,
    [
        KeyValue::new("mykey1", "myvalue1"),
        KeyValue::new("mykey2", "myvalue2"),
    ]
    .as_ref(),
);

// i64 histogram
let i64_histogram = meter.i64_histogram("my_i64_histogram").init();

// Record measurements using the histogram instrument record()
i64_histogram.record(
    1,
    [
        KeyValue::new("mykey1", "myvalue1"),
        KeyValue::new("mykey2", "myvalue2"),
    ]
    .as_ref(),
);

// u64 histogram
let u64_histogram = meter.u64_histogram("my_u64_histogram").init();

// Record measurements using the histogram instrument record()
u64_histogram.record(
    12,
    [
        KeyValue::new("mykey1", "myvalue1"),
        KeyValue::new("mykey2", "myvalue2"),
    ]
    .as_ref(),
);

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.

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

creates an instrument builder for recording increasing values.

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.

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.

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.

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_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>> ) -> InstrumentBuilder<'_, Histogram<f64>>

creates an instrument builder for recording a distribution of values.

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

creates an instrument builder for recording a distribution of values.

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

creates an instrument builder for recording a distribution of values.

pub fn register_callback<F>( &self, instruments: &[Arc<dyn Any>], callback: F ) -> Result<Box<dyn CallbackRegistration>>

where F: Fn(&dyn Observer) + Send + Sync + 'static,

Registers a callback to be called during the collection of a measurement cycle.

The instruments passed as arguments to be registered are the only instruments that may observe values.

If no instruments are passed, the callback will not be registered.

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

Formats the value using the given formatter.