Trait tracing_subscriber::registry::LookupSpan

source ·
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 { ... }
Expand description

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.


If this Subscriber does not support per-layer filtering.



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>> as LookupSpan<'a>>::Data