Struct tracing_timing::Builder
source · [−]Expand description
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
sourceimpl<S, E> Builder<S, E>
impl<S, E> Builder<S, E>
sourcepub fn events<E2>(self, event_group: E2) -> Builder<S, E2>
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.
sourcepub fn time(self, time: Clock) -> Builder<S, E>
pub fn time(self, time: Clock) -> Builder<S, E>
Set the time source to use for time measurements.
sourcepub fn no_span_recursion(self) -> Self
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.
sourcepub fn span_close_events(self) -> Self
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
.
sourcepub 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,
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());
sourcepub 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,
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.
sourcepub 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,
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());
Trait Implementations
Auto Trait Implementations
impl<S, E> RefUnwindSafe for Builder<S, E> where
E: RefUnwindSafe,
S: RefUnwindSafe,
impl<S, E> Send for Builder<S, E> where
E: Send,
S: Send,
impl<S, E> Sync for Builder<S, E> where
E: Sync,
S: Sync,
impl<S, E> Unpin for Builder<S, E> where
E: Unpin,
S: Unpin,
impl<S, E> UnwindSafe for Builder<S, E> where
E: UnwindSafe,
S: UnwindSafe,
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more