Struct opentelemetry::metrics::Meter

source ·
pub struct Meter { /* private fields */ }
Expand description

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"),
    ]
);

// 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"),
    ],
);

// 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"),
        ],
    )
});

// 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"),
        ],
    )
});

// 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"),
    ],
);

// 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"),
    ],
);

// 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"),
        ],
    )
});

// 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"),
        ],
    )
});

// 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"),
        ],
    )
});

// 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"),
        ],
    )
});

// 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"),
        ],
    )
});

// 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"),
    ],
);

// 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"),
    ],
);

Implementations§

source§

impl Meter

source

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

creates an instrument builder for recording increasing values.

source

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

creates an instrument builder for recording increasing values.

source

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.

source

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.

source

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.

source

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.

source

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.

source

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.

source

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

creates an instrument builder for recording independent values.

source

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

creates an instrument builder for recording independent values.

source

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

creates an instrument builder for recording independent values.

source

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.

source

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.

source

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.

source

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

creates an instrument builder for recording a distribution of values.

source

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

creates an instrument builder for recording a distribution of values.

source

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§

source§

impl Clone for Meter

source§

fn clone(&self) -> Meter

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
source§

impl Debug for Meter

source§

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

Formats the value using the given formatter. Read more

Auto Trait Implementations§

§

impl Freeze for Meter

§

impl !RefUnwindSafe for Meter

§

impl Send for Meter

§

impl Sync for Meter

§

impl Unpin for Meter

§

impl !UnwindSafe for Meter

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> CloneToUninit for T
where T: Clone,

source§

unsafe fn clone_to_uninit(&self, dst: *mut T)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T> FutureExt for T

source§

fn with_context(self, otel_cx: Context) -> WithContext<Self>

Attaches the provided Context to this type, returning a WithContext wrapper. Read more
source§

fn with_current_context(self) -> WithContext<Self>

Attaches the current Context to this type, returning a WithContext wrapper. Read more
source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T> ToOwned for T
where T: Clone,

source§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

source§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.