Struct Reporter 

pub struct Reporter { /* private fields */ }

A set of Sources that are all sampled together.

The reporter can be sampled like any other source through its own Source implementation.

Normalization

The reporter will attempt to normalize the extents of any metrics sampled from its sources. Normalization will:

1. Take the current timestamp, now, when sampling metrics.
2. If the metric sample has no extent, or has a point extent, it will be replaced with now.
3. If the metric sample has a range extent, the end will be set to now and the start will be now minus the original length. If this would produce an invalid range then the original is kept.

When the std Cargo feature is enabled this will be done automatically. In other cases, normalization won’t happen unless it’s configured by Reporter::normalize_with_clock.

Normalization can be disabled by calling Reporter::without_normalization.

Implementations

impl Reporter

pub const fn new() -> Self

Create a new empty reporter.

When the std Cargo feature is enabled, the reporter will normalize timestamps on reported samples using the system clock. When the std Cargo feature is not enabled, the reporter will not attempt to normalize timestamps.

pub fn normalize_with_clock( &mut self, clock: impl Clock + Send + Sync + 'static, ) -> &mut Self

Set the clock the reporter will use to unify timestamps on sampled metrics.

pub fn without_normalization(&mut self) -> &mut Self

Disable the clock, preventing the reporter from normalizing timestamps on sampled metrics.

pub fn add_source( &mut self, source: impl Source + Send + Sync + 'static, ) -> &mut Self

Add a Source to the reporter.

pub fn sample_metrics<S: Sampler>(&self, sampler: S)

Produce a current sample for all metrics.

pub fn emit_metrics<E: Emitter>(&self, emitter: E)

Produce a current sample for all metrics, emitting them as diagnostic events to the given Emitter.

Trait Implementations

impl Source for Reporter

fn sample_metrics<S: Sampler>(&self, sampler: S)

Produce a current sample for all metrics in the source.

fn and_sample<U>(self, other: U) -> And<Self, U>

where Self: Sized,

Chain this source to other, sampling metrics from both.