Struct tracing_subscriber::registry::SpanRef
source · [−]pub struct SpanRef<'a, R: LookupSpan<'a>> { /* private fields */ }
Expand description
Implementations
sourceimpl<'a, R> SpanRef<'a, R> where
R: LookupSpan<'a>,
impl<'a, R> SpanRef<'a, R> where
R: LookupSpan<'a>,
sourcepub fn metadata(&self) -> &'static Metadata<'static>
pub fn metadata(&self) -> &'static Metadata<'static>
Returns a static reference to the span’s metadata.
sourcepub fn parent_id(&self) -> Option<&Id>
pub fn parent_id(&self) -> Option<&Id>
Returns the ID of this span’s parent, or None
if this span is the root
of its trace tree.
sourcepub fn parent(&self) -> Option<Self>
pub fn parent(&self) -> Option<Self>
Returns a SpanRef
describing this span’s parent, or None
if this
span is the root of its trace tree.
sourcepub fn scope(&self) -> Scope<'a, R>ⓘNotable traits for Scope<'a, R>impl<'a, R> Iterator for Scope<'a, R> where
R: LookupSpan<'a>, type Item = SpanRef<'a, R>;
pub fn scope(&self) -> Scope<'a, R>ⓘNotable traits for Scope<'a, R>impl<'a, R> Iterator for Scope<'a, R> where
R: LookupSpan<'a>, type Item = SpanRef<'a, R>;
R: LookupSpan<'a>, type Item = SpanRef<'a, R>;
Returns an iterator over all parents of this span, starting with this span, ordered from leaf to root.
The iterator will first return the span, then the span’s immediate parent, followed by that span’s parent, and so on, until it reaches a root span.
use tracing::{span, Subscriber};
use tracing_subscriber::{
layer::{Context, Layer},
prelude::*,
registry::LookupSpan,
};
struct PrintingLayer;
impl<S> Layer<S> for PrintingLayer
where
S: Subscriber + for<'lookup> LookupSpan<'lookup>,
{
fn on_enter(&self, id: &span::Id, ctx: Context<S>) {
let span = ctx.span(id).unwrap();
let scope = span.scope().map(|span| span.name()).collect::<Vec<_>>();
println!("Entering span: {:?}", scope);
}
}
tracing::subscriber::with_default(tracing_subscriber::registry().with(PrintingLayer), || {
let _root = tracing::info_span!("root").entered();
// Prints: Entering span: ["root"]
let _child = tracing::info_span!("child").entered();
// Prints: Entering span: ["child", "root"]
let _leaf = tracing::info_span!("leaf").entered();
// Prints: Entering span: ["leaf", "child", "root"]
});
If the opposite order (from the root to this span) is desired, calling Scope::from_root
on
the returned iterator reverses the order.
impl<S> Layer<S> for PrintingLayer
where
S: Subscriber + for<'lookup> LookupSpan<'lookup>,
{
fn on_enter(&self, id: &span::Id, ctx: Context<S>) {
let span = ctx.span(id).unwrap();
let scope = span.scope().from_root().map(|span| span.name()).collect::<Vec<_>>();
println!("Entering span: {:?}", scope);
}
}
tracing::subscriber::with_default(tracing_subscriber::registry().with(PrintingLayer), || {
let _root = tracing::info_span!("root").entered();
// Prints: Entering span: ["root"]
let _child = tracing::info_span!("child").entered();
// Prints: Entering span: ["root", "child"]
let _leaf = tracing::info_span!("leaf").entered();
// Prints: Entering span: ["root", "child", "leaf"]
});
sourcepub fn parents(&self) -> Parents<'a, R>ⓘNotable traits for Parents<'a, R>impl<'a, R> Iterator for Parents<'a, R> where
R: LookupSpan<'a>, type Item = SpanRef<'a, R>;
👎 Deprecated: equivalent to self.parent().into_iter().flat_map(SpanRef::scope)
, but consider whether excluding self
is actually intended
pub fn parents(&self) -> Parents<'a, R>ⓘNotable traits for Parents<'a, R>impl<'a, R> Iterator for Parents<'a, R> where
R: LookupSpan<'a>, type Item = SpanRef<'a, R>;
R: LookupSpan<'a>, type Item = SpanRef<'a, R>;
equivalent to self.parent().into_iter().flat_map(SpanRef::scope)
, but consider whether excluding self
is actually intended
Returns an iterator over all parents of this span, starting with the immediate parent.
The iterator will first return the span’s immediate parent, followed by that span’s parent, followed by that span’s parent, and so on, until a it reaches a root span.
sourcepub fn from_root(&self) -> FromRoot<'a, R>ⓘNotable traits for FromRoot<'a, R>impl<'a, R> Iterator for FromRoot<'a, R> where
R: LookupSpan<'a>, type Item = SpanRef<'a, R>;
👎 Deprecated since 0.2.19: equivalent to self.parent().into_iter().flat_map(|span| span.scope().from_root())
, but consider whether excluding self
is actually intended
pub fn from_root(&self) -> FromRoot<'a, R>ⓘNotable traits for FromRoot<'a, R>impl<'a, R> Iterator for FromRoot<'a, R> where
R: LookupSpan<'a>, type Item = SpanRef<'a, R>;
R: LookupSpan<'a>, type Item = SpanRef<'a, R>;
equivalent to self.parent().into_iter().flat_map(|span| span.scope().from_root())
, but consider whether excluding self
is actually intended
Returns an iterator over all parents of this span, starting with the root of the trace tree.
The iterator will return the root of the trace tree, followed by the next span, and then the next, until this span’s immediate parent is returned.
Note: this will allocate if there are many spans remaining, or if the “smallvec” feature flag is not enabled.
sourcepub fn extensions(&self) -> Extensions<'_>
pub fn extensions(&self) -> Extensions<'_>
Returns a reference to this span’s Extensions
.
The extensions may be used by Layer
s to store additional data
describing the span.
sourcepub fn extensions_mut(&self) -> ExtensionsMut<'_>
pub fn extensions_mut(&self) -> ExtensionsMut<'_>
Returns a mutable reference to this span’s Extensions
.
The extensions may be used by Layer
s to store additional data
describing the span.
Trait Implementations
Auto Trait Implementations
impl<'a, R> RefUnwindSafe for SpanRef<'a, R> where
R: RefUnwindSafe,
<R as LookupSpan<'a>>::Data: RefUnwindSafe,
impl<'a, R> Send for SpanRef<'a, R> where
R: Sync,
<R as LookupSpan<'a>>::Data: Send,
impl<'a, R> Sync for SpanRef<'a, R> where
R: Sync,
<R as LookupSpan<'a>>::Data: Sync,
impl<'a, R> Unpin for SpanRef<'a, R> where
<R as LookupSpan<'a>>::Data: Unpin,
impl<'a, R> UnwindSafe for SpanRef<'a, R> where
R: RefUnwindSafe,
<R as LookupSpan<'a>>::Data: UnwindSafe,
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
sourceimpl<T> Instrument for T
impl<T> Instrument for T
sourcefn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
sourcefn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
sourceimpl<T> WithSubscriber for T
impl<T> WithSubscriber for T
sourcefn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> where
S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> where
S: Into<Dispatch>,
Attaches the provided Subscriber
to this type, returning a
WithDispatch
wrapper. Read more
sourcefn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default Subscriber
to this type, returning a
WithDispatch
wrapper. Read more