Struct tracing_dipstick::DipstickLayer

pub struct DipstickLayer<S> { /* fields omitted */ }

The bridge from tracing to dipstick.

This takes information from tracing and propagates them into dipstick as metrics. It works as Layer.

Warning

Currently, tracing_subscriber doesn’t allow filtering on per-layer basis. That means if there’s another layer that filters (for example based on the level), it’ll impact this layer too. This would negatively impact the gathered metrics as this expects to get them all.

It has been observed to work together with the tracings log-always feature.

Future versions might bypass the Layer system and wrap a Subscriber directly.

Examples

use std::time::Duration;

use dipstick::{AtomicBucket, ScheduleFlush, Stream};
use log::LevelFilter;
use tracing::subscriber;
use tracing_dipstick::DipstickLayer;
use tracing_subscriber::layer::SubscriberExt;
use tracing_subscriber::Registry;

env_logger::builder()
    .filter_level(LevelFilter::Info)
    .parse_default_env()
    .init();

let root = AtomicBucket::new();
root.stats(dipstick::stats_all);
root.drain(Stream::write_to_stdout());
let _flush = root.flush_every(Duration::from_secs(5));

let bridge = DipstickLayer::new(root);
let subscriber = Registry::default().with(bridge);

subscriber::set_global_default(subscriber).unwrap();

Implementations

impl<S> DipstickLayer<S> where
    S: Clone + InputScope + Prefixed + 'static, 

pub fn new(input_scope: S) -> Self

Creates the bridge.

Expects the scope into which it will put metrics.

Trait Implementations

impl<S: Clone> Clone for DipstickLayer<S>

fn clone(&self) -> DipstickLayer<S>

Returns a copy of the value.

pub fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<S: Copy> Copy for DipstickLayer<S>

impl<S: Debug> Debug for DipstickLayer<S>

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

Formats the value using the given formatter.

impl<S: Default> Default for DipstickLayer<S>

fn default() -> DipstickLayer<S>

Returns the “default value” for a type.

impl<S, I> Layer<I> for DipstickLayer<S> where
    S: Clone + InputScope + Prefixed + Send + Sync + 'static,
    I: Subscriber,
    I: LookupSpan<'l>, 

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

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

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

Notifies this layer that an event has occurred.

pub 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.

pub 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.

pub 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.

pub 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.

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

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

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

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

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

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

pub 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.

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

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

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

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