Struct tracing_timing::Builder

pub struct Builder<S = ByName, E = ByMessage> { /* private fields */ }

Builder for TimingSubscriber instances.

This type implements the builder pattern. It lets you easily configure and construct a new TimingSubscriber subscriber. See the individual methods for details. To start, use Builder::default:

use tracing_timing::{Builder, Histogram};
let builder = Builder::default();
let subscriber = builder.build(|| Histogram::new(3).unwrap());

See the various new_* methods on Histogram for how to construct an appropriate histogram in the first place. All samples recorded by the subscriber returned from Builder::build will be recorded into histograms as returned by the provided constructor. You can also construct the histograms based on the span and event group it will be tracking by using Builder::build_informed.

Implementations

impl<S, E> Builder<S, E>

pub fn spans<S2>(self, span_group: S2) -> Builder<S2, E>

Set the mechanism used to divide spans into groups.

See SpanGroup and the group module for details.

pub fn events<E2>(self, event_group: E2) -> Builder<S, E2>

Set the mechanism used to divide events into per-span groups.

See EventGroup and the group module for details.

pub fn time(self, time: Clock) -> Builder<S, E>

Set the time source to use for time measurements.

pub fn no_span_recursion(self) -> Self

By default, a TimingSubscriber will record the time since the last event in any child span:

| span foo
| - event a
| | span bar
| | - event b
| - event c

What time is recorded for event c? The default is t_c - t_b. With no_span_recursion, event c will have t_c - t_a. event b will record the time since the start of span bar.

pub fn span_close_events(self) -> Self

By default, a TimingSubscriber or TimingLayer won’t record a span closure as an event.

| span foo
| - event a
| | span bar
| | - (bar closed)
| - event c

Without span close events, event c will record t_c - t_a. With span_close_events, event c will record t_c - t_bar_close.

pub fn build_informed<F>(self, new_histogram: F) -> TimingSubscriber<S, E> where
    S: SpanGroup,
    E: EventGroup,
    S::Id: Hash + Eq,
    E::Id: Hash + Eq,
    F: FnMut(&S::Id, &E::Id) -> Histogram<u64> + Send + Sync + 'static, 

Construct a TimingSubscriber that uses the given function to construct new histograms.

This is equivalent to [build], except that the passed function is also told which span/event group the histogram is for.

Note that you may run into weird lifetime errors from the compiler when using this method with a closure. This is a known compiler issue. You can work around it by adding a slight type hint to the arguments passed to the closure as follows (note the : &_):

use tracing_timing::{Builder, Histogram};
let builder = Builder::default();
let subscriber = builder.build_informed(|s: &_, e: &_| Histogram::new(3).unwrap());

pub fn build<F>(self, new_histogram: F) -> TimingSubscriber<S, E> where
    S: SpanGroup,
    E: EventGroup,
    S::Id: Hash + Eq,
    E::Id: Hash + Eq,
    F: FnMut() -> Histogram<u64> + Send + Sync + 'static, 

Construct a TimingSubscriber that uses the given function to construct new histograms.

pub fn layer_informed<F>(self, new_histogram: F) -> TimingLayer<S, E> where
    S: SpanGroup,
    E: EventGroup,
    S::Id: Hash + Eq,
    E::Id: Hash + Eq,
    F: FnMut(&S::Id, &E::Id) -> Histogram<u64> + Send + Sync + 'static, 

Construct a TimingLayer that uses the given function to construct new histograms.

This is equivalent to [layer], except that the passed function is also told which span/event group the histogram is for.

Note that you may run into weird lifetime errors from the compiler when using this method with a closure. This is a known compiler issue. You can work around it by adding a slight type hint to the arguments passed to the closure as follows (note the : &_):

use tracing_timing::{Builder, Histogram};
let builder = Builder::default();
let layer = builder.layer_informed(|s: &_, e: &_| Histogram::new(3).unwrap());

pub fn layer<F>(self, new_histogram: F) -> TimingLayer<S, E> where
    S: SpanGroup,
    E: EventGroup,
    S::Id: Hash + Eq,
    E::Id: Hash + Eq,
    F: FnMut() -> Histogram<u64> + Send + Sync + 'static, 

Construct a TimingSubscriber that uses the given function to construct new histograms.

Trait Implementations

impl Default for Builder<ByName, ByMessage>

fn default() -> Self

Returns the “default value” for a type.