Struct TimingLayer

pub struct TimingLayer<S = ByName, E = ByMessage>
where
    S: SpanGroup,
    S::Id: Hash + Eq,
    E: EventGroup,
    E::Id: Hash + Eq,
{ /* private fields */ }

Timing-gathering tracing layer.

This type is constructed using a Builder.

See the [crate-level docs] for details.

Implementations

impl<S, E> TimingLayer<S, E>

where S: SpanGroup, E: EventGroup, S::Id: Hash + Eq, E::Id: Hash + Eq,

pub fn force_synchronize(&self)

Force all current timing information to be refreshed immediately.

Note that this will interrupt all concurrent metrics gathering until it returns.

pub fn with_histograms<F, R>(&self, f: F) -> R

where F: FnOnce(&mut HashMap<S::Id, IndexMap<E::Id, SyncHistogram<u64>, Hasher>>) -> R,

Access the timing histograms.

Be aware that the contained histograms are not automatically updated to reflect recently gathered samples. For each histogram you wish to read from, you must call refresh or refresh_timeout to gather up-to-date samples.

For information about what you can do with the histograms, see the hdrhistogram documentation.

impl<S, E> TimingLayer<S, E>

where S: SpanGroup, E: EventGroup, S::Id: Clone + Hash + Eq, E::Id: Clone + Hash + Eq,

pub fn downcaster(&self) -> Downcaster<S, E>

Returns an identifier that can later be used to get access to this TimingLayer after it has been turned into a tracing::Dispatch.

use tracing::*;
use tracing_timing::{Builder, Histogram, TimingLayer};
use tracing_subscriber::{registry::Registry, Layer};
let layer = Builder::default()
    .layer(|| Histogram::new_with_max(1_000_000, 2).unwrap());
let downcaster = layer.downcaster();
let dispatch = Dispatch::new(layer.with_subscriber(Registry::default()));
// ...
// code that hands off clones of the dispatch
// maybe to other threads
// ...
downcaster.downcast(&dispatch).unwrap().with_histograms(|hs| {
    for (span_group, hs) in hs {
        for (event_group, h) in hs {
            // make sure we see the latest samples:
            h.refresh();
            // print the median:
            println!("{} -> {}: {}ns", span_group, event_group, h.value_at_quantile(0.5))
        }
    }
});

Trait Implementations

impl<S, E> Debug for TimingLayer<S, E>

where S: SpanGroup + Debug, S::Id: Hash + Eq + Debug, E: EventGroup + Debug, E::Id: Hash + Eq + Debug,

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

Formats the value using the given formatter.

impl<S, SG, EG> Layer<S> for TimingLayer<SG, EG>

where S: Subscriber + for<'span> LookupSpan<'span>, Self: 'static, SG: SpanGroup, EG: EventGroup, SG::Id: Clone + Hash + Eq + Send + Sync, EG::Id: Clone + Hash + Eq + Send + Sync,

fn on_new_span(&self, attrs: &Attributes<'_>, id: &Id, ctx: Context<'_, S>)

Notifies this layer that a new span was constructed with the given Attributes and Id.

fn on_event(&self, event: &Event<'_>, ctx: Context<'_, S>)

Notifies this layer that an event has occurred.

fn on_close(&self, id: Id, ctx: Context<'_, S>)

Notifies this layer that the span with the given ID has been closed.

fn on_register_dispatch(&self, subscriber: &Dispatch)

Performs late initialization when installing this layer as a Subscriber.

fn on_layer(&mut self, subscriber: &mut S)

Performs late initialization when attaching a Layer to a Subscriber.

fn register_callsite(&self, metadata: &'static Metadata<'static>) -> Interest

Registers a new callsite with this layer, returning whether or not the layer is interested in being notified about the callsite, similarly to Subscriber::register_callsite.

fn enabled(&self, metadata: &Metadata<'_>, ctx: Context<'_, S>) -> bool

Returns true if this layer is interested in a span or event with the given metadata in the current Context, similarly to Subscriber::enabled.

fn on_record(&self, _span: &Id, _values: &Record<'_>, _ctx: Context<'_, S>)

Notifies this layer that a span with the given Id recorded the given values.

fn on_follows_from(&self, _span: &Id, _follows: &Id, _ctx: Context<'_, S>)

Notifies this layer that a span with the ID span recorded that it follows from the span with the ID follows.

fn event_enabled(&self, _event: &Event<'_>, _ctx: Context<'_, S>) -> bool

Called before on_event, to determine if on_event should be called.

fn on_enter(&self, _id: &Id, _ctx: Context<'_, S>)

Notifies this layer that a span with the given ID was entered.

fn on_exit(&self, _id: &Id, _ctx: Context<'_, S>)

Notifies this layer that the span with the given ID was exited.

fn on_id_change(&self, _old: &Id, _new: &Id, _ctx: Context<'_, S>)

Notifies this layer that a span ID has been cloned, and that the subscriber returned a different ID.

fn and_then<L>(self, layer: L) -> Layered<L, Self, S>

where L: Layer<S>, Self: Sized,

Composes this layer around the given Layer, returning a Layered struct implementing Layer.

fn with_subscriber(self, inner: S) -> Layered<Self, S>

where Self: Sized,

Composes this Layer with the given Subscriber, returning a Layered struct that implements Subscriber.

fn with_filter<F>(self, filter: F) -> Filtered<Self, F, S>

where Self: Sized, F: Filter<S>,

Combines self with a Filter, returning a Filtered layer.

fn boxed(self) -> Box<dyn Layer<S> + Send + Sync>

where Self: Sized + Layer<S> + Send + Sync + 'static, S: Subscriber,

Erases the type of this Layer, returning a Boxed dyn Layer trait object.