Struct tracing_capture::CaptureLayer

pub struct CaptureLayer<S> { /* private fields */ }

Tracing Layer that captures (optionally filtered) spans and events.

The layer can optionally filter spans and events in addition to global Subscriber filtering. This could be used instead of per-layer filtering if it’s not supported by the Subscriber. Keep in mind that without filtering, CaptureLayer can capture a lot of unnecessary spans / events.

Captured events are tied to the nearest captured span in the span hierarchy. If no entered spans are captured when the event is emitted, the event will be captured in Storage::root_events().

Examples

See crate-level docs for an example of usage.

Implementations

impl<S> CaptureLayer<S>where
    S: Subscriber + for<'a> LookupSpan<'a>,

pub fn new(storage: &SharedStorage) -> Self

Creates a new layer that will use the specified storage to store captured data. Captured spans are not filtered; like any Layer, filtering can be set up on the layer or subscriber level.

pub fn with_filter<F>(self, filter: F) -> Selfwhere
    F: Filter<S> + Send + Sync + 'static,

Specifies filtering for this layer. Unlike with per-layer filtering, the resulting layer will perform filtering for all Subscribers, not just Registry.

Trait Implementations

impl<S> Debug for CaptureLayer<S>

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

Formats the value using the given formatter.

impl<S> Layer<S> for CaptureLayer<S>where
    S: Subscriber + for<'a> LookupSpan<'a>,

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_record(&self, id: &Id, values: &Record<'_>, ctx: Context<'_, S>)

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

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

Notifies this layer that an event has occurred.

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_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, collector: &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_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_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, 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> + Sync + Send + 'static, Global>where
    Self: Sized + 'static + Layer<S> + Send + Sync,
    S: Subscriber,

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