Struct rama::telemetry::opentelemetry::metrics::AsyncInstrumentBuilder

#[non_exhaustive]
pub struct AsyncInstrumentBuilder<'a, I, M> {
    pub instrument_provider: &'a dyn InstrumentProvider,
    pub name: Cow<'static, str>,
    pub description: Option<Cow<'static, str>>,
    pub unit: Option<Cow<'static, str>>,
    pub callbacks: Vec<Box<dyn Fn(&dyn AsyncInstrument<M>) + Sync + Send>>,
    /* private fields */
}

Configuration for building an async instrument.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

instrument_provider: &'a dyn InstrumentProvider

Instrument provider is used to create the instrument.

name: Cow<'static, str>

Name of the instrument.

description: Option<Cow<'static, str>>

Description of the instrument.

unit: Option<Cow<'static, str>>

Unit of the instrument.

callbacks: Vec<Box<dyn Fn(&dyn AsyncInstrument<M>) + Sync + Send>>

Callbacks to be called for this instrument.

Implementations

impl<'a, I, M> AsyncInstrumentBuilder<'a, I, M>

pub fn with_description<S>( self, description: S, ) -> AsyncInstrumentBuilder<'a, I, M>

where S: Into<Cow<'static, str>>,

Set the description for this instrument

pub fn with_unit<S>(self, unit: S) -> AsyncInstrumentBuilder<'a, I, M>

where S: Into<Cow<'static, str>>,

Set the unit for this instrument.

Unit is case sensitive(kb is not the same as kB).

Unit must be:

• ASCII string
• No longer than 63 characters

pub fn with_callback<F>(self, callback: F) -> AsyncInstrumentBuilder<'a, I, M>

where F: Fn(&dyn AsyncInstrument<M>) + Send + Sync + 'static,

Set the callback to be called for this instrument.

impl<'a> AsyncInstrumentBuilder<'a, ObservableCounter<u64>, u64>

pub fn build(self) -> ObservableCounter<u64>

Validates the instrument configuration and creates a new ObservableCounter<u64>. In case of invalid configuration, a no-op instrument is returned and an error is logged using internal logging.

impl<'a> AsyncInstrumentBuilder<'a, ObservableCounter<f64>, f64>

pub fn build(self) -> ObservableCounter<f64>

Validates the instrument configuration and creates a new ObservableCounter<f64>. In case of invalid configuration, a no-op instrument is returned and an error is logged using internal logging.

impl<'a> AsyncInstrumentBuilder<'a, ObservableGauge<u64>, u64>

pub fn build(self) -> ObservableGauge<u64>

Validates the instrument configuration and creates a new ObservableGauge<u64>. In case of invalid configuration, a no-op instrument is returned and an error is logged using internal logging.

impl<'a> AsyncInstrumentBuilder<'a, ObservableGauge<f64>, f64>

pub fn build(self) -> ObservableGauge<f64>

Validates the instrument configuration and creates a new ObservableGauge<f64>. In case of invalid configuration, a no-op instrument is returned and an error is logged using internal logging.

impl<'a> AsyncInstrumentBuilder<'a, ObservableGauge<i64>, i64>

pub fn build(self) -> ObservableGauge<i64>

Validates the instrument configuration and creates a new ObservableGauge<i64>. In case of invalid configuration, a no-op instrument is returned and an error is logged using internal logging.

impl<'a> AsyncInstrumentBuilder<'a, ObservableUpDownCounter<i64>, i64>

pub fn build(self) -> ObservableUpDownCounter<i64>

Validates the instrument configuration and creates a new ObservableUpDownCounter<i64>. In case of invalid configuration, a no-op instrument is returned and an error is logged using internal logging.

impl<'a> AsyncInstrumentBuilder<'a, ObservableUpDownCounter<f64>, f64>

pub fn build(self) -> ObservableUpDownCounter<f64>

Validates the instrument configuration and creates a new ObservableUpDownCounter<f64>. In case of invalid configuration, a no-op instrument is returned and an error is logged using internal logging.

Trait Implementations

impl<I, M> Debug for AsyncInstrumentBuilder<'_, I, M>

where I: AsyncInstrument<M>,

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

Formats the value using the given formatter.