Module tracing_subscriber::registry
source · Expand description
Storage for span data shared by multiple Layer
s.
Using the Span Registry
This module provides the Registry
type, a Subscriber
implementation
which tracks per-span data and exposes it to Layer
s. When a Registry
is used as the base Subscriber
of a Layer
stack, the
layer::Context
type will provide methods allowing Layer
s to
look up span data stored in the registry. While Registry
is a
reasonable default for storing spans and events, other stores that implement
LookupSpan
and Subscriber
themselves (with SpanData
implemented
by the per-span data they store) can be used as a drop-in replacement.
For example, we might create a Registry
and add multiple Layer
s like so:
use tracing_subscriber::{registry::Registry, Layer, prelude::*};
let subscriber = Registry::default()
.with(FooLayer::new())
.with(BarLayer::new());
If a type implementing Layer
depends on the functionality of a Registry
implementation, it should bound its Subscriber
type parameter with the
LookupSpan
trait, like so:
use tracing_subscriber::{registry, Layer};
use tracing_core::Subscriber;
pub struct MyLayer {
// ...
}
impl<S> Layer<S> for MyLayer
where
S: Subscriber + for<'a> registry::LookupSpan<'a>,
{
// ...
}
When this bound is added, the Layer
implementation will be guaranteed
access to the Context
methods, such as Context::span
, that
require the root subscriber to be a registry.
Structs
- Span data stored in a
Registry
. - An immutable, read-only reference to a Span’s extensions.
- An mutable reference to a Span’s extensions.
- FromRootDeprecatedAn iterator over a span’s parents, starting with the root of the trace tree.
- ParentsDeprecatedAn iterator over the parents of a span.
- A shared, reusable store for spans.
- An iterator over the parents of a span, ordered from leaf to root.
- An iterator over the parents of a span, ordered from root to leaf.
Traits
- Provides access to stored span data.
- A stored representation of data associated with a span.