Trait tracing_subscriber::registry::LookupSpan

pub trait LookupSpan<'a> {
    type Data: SpanData<'a>;

    // Required method
    fn span_data(&'a self, id: &Id) -> Option<Self::Data>;

    // Provided methods
    fn span(&'a self, id: &Id) -> Option<SpanRef<'_, Self>>
       where Self: Sized { ... }
    fn register_filter(&mut self) -> FilterId { ... }
}

Provides access to stored span data.

Subscribers which store span data and associate it with span IDs should implement this trait; if they do, any Layers wrapping them can look up metadata via the Context type’s span() method.

Required Associated Types

type Data: SpanData<'a>

The type of span data stored in this registry.

Required Methods

fn span_data(&'a self, id: &Id) -> Option<Self::Data>

Returns the SpanData for a given Id, if it exists.

Note: users of the LookupSpan trait should
typically call the span method rather
than this method. The span method is implemented by
calling span_data, but returns a reference which is
capable of performing more sophisiticated queries.

Provided Methods

fn span(&'a self, id: &Id) -> Option<SpanRef<'_, Self>>where Self: Sized,

Returns a SpanRef for the span with the given Id, if it exists.

A SpanRef is similar to SpanData, but it allows performing additional lookups against the registryr that stores the wrapped data.

In general, users of the LookupSpan trait should use this method rather than the span_data method; while implementors of this trait should only implement span_data.

fn register_filter(&mut self) -> FilterId

Registers a Filter for per-layer filtering with this Subscriber.

The Filter can then use the returned FilterId to check if it previously enabled a span.

Panics

If this Subscriber does not support per-layer filtering.

Implementors

impl<'a> LookupSpan<'a> for Registry

type Data = Data<'a>

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

type Data = <S as LookupSpan<'a>>::Data

impl<'a, N, E, F, W> LookupSpan<'a> for Subscriber<N, E, F, W>where Layered<F, Formatter<N, E, W>>: LookupSpan<'a>,

type Data = <Layered<F, Layered<Layer<Registry, N, E, W>, Registry, Registry>, Layered<Layer<Registry, N, E, W>, Registry, Registry>> as LookupSpan<'a>>::Data