Struct tracing_timing::TimingSubscriber

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

Timing-gathering tracing subscriber.

This type is constructed using a Builder.

See the crate-level docs for details.

Implementations

impl<S, E> TimingSubscriber<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 or force_synchronize to gather up-to-date samples.

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

impl<S, E> TimingSubscriber<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 TimingSubscriber after it has been turned into a tracing::Dispatch.

use tracing::*;
use tracing_timing::{Builder, Histogram, TimingSubscriber};
let subscriber = Builder::default().build(|| Histogram::new_with_max(1_000_000, 2).unwrap());
let downcaster = subscriber.downcaster();
let dispatch = Dispatch::new(subscriber);
// ...
// 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 TimingSubscriber<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, E> Subscriber for TimingSubscriber<S, E> where
    S: SpanGroup + 'static,
    E: EventGroup + 'static,
    S::Id: Clone + Hash + Eq + 'static,
    E::Id: Clone + Hash + Eq + 'static, 

fn enabled(&self, _: &Metadata<'_>) -> bool

Returns true if a span or event with the specified metadata would be recorded.

fn new_span(&self, span: &Attributes<'_>) -> Id

Visit the construction of a new span, returning a new span ID for the span being constructed.

fn record(&self, _: &Id, _: &Record<'_>)

Record a set of values on a span.

fn record_follows_from(&self, span: &Id, follows: &Id)

Adds an indication that span follows from the span with the id follows.

fn event(&self, event: &Event<'_>)

Records that an Event has occurred.

fn enter(&self, span: &Id)

Records that a span has been entered.

fn exit(&self, span: &Id)

Records that a span has been exited.

fn clone_span(&self, span: &Id) -> Id

Notifies the subscriber that a span ID has been cloned.

fn try_close(&self, span: Id) -> bool

Notifies the subscriber that a span ID has been dropped, and returns true if there are now 0 IDs that refer to that span.

fn current_span(&self) -> Current

Returns a type representing this subscriber’s view of the current span.

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

Registers a new callsite with this subscriber, returning whether or not the subscriber is interested in being notified about the callsite.

fn max_level_hint(&self) -> Option<LevelFilter>

Returns the highest verbosity level that this Subscriber will enable, or None, if the subscriber does not implement level-based filtering or chooses not to implement this method.

fn drop_span(&self, _id: Id)

👎 Deprecated since 0.1.2:

use Subscriber::try_close instead

This method is deprecated.

unsafe fn downcast_raw(&self, id: TypeId) -> Option<*const ()>

If self is the same type as the provided TypeId, returns an untyped *const pointer to that type. Otherwise, returns None.