Struct tracing_subscriber::registry::SpanRef

source ·
pub struct SpanRef<'a, R: LookupSpan<'a>> { /* private fields */ }
Expand description

A reference to [span data] and the associated registry.

This type implements all the same methods as SpanData, and provides additional methods for querying the registry based on values from the span.

Implementations§

source§

impl<'a, R> SpanRef<'a, R>
where R: LookupSpan<'a>,

source

pub fn id(&self) -> Id

Returns this span’s ID.

source

pub fn metadata(&self) -> &'static Metadata<'static>

Returns a static reference to the span’s metadata.

source

pub fn name(&self) -> &'static str

Returns the span’s name,

source

pub fn fields(&self) -> &FieldSet

Returns a list of fields defined by the span.

source

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.

source

pub fn scope(&self) -> Scope<'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"]
});
source

pub fn extensions(&self) -> Extensions<'_>

Returns a reference to this span’s Extensions.

The extensions may be used by Layers to store additional data describing the span.

source

pub fn extensions_mut(&self) -> ExtensionsMut<'_>

Returns a mutable reference to this span’s Extensions.

The extensions may be used by Layers to store additional data describing the span.

Trait Implementations§

source§

impl<'a, R: Debug + LookupSpan<'a>> Debug for SpanRef<'a, R>
where R::Data: Debug,

source§

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

Formats the value using the given formatter. Read more

Auto Trait Implementations§

§

impl<'a, R> Freeze for SpanRef<'a, R>
where <R as LookupSpan<'a>>::Data: Freeze,

§

impl<'a, R> RefUnwindSafe for SpanRef<'a, R>
where <R as LookupSpan<'a>>::Data: RefUnwindSafe, R: RefUnwindSafe,

§

impl<'a, R> Send for SpanRef<'a, R>
where <R as LookupSpan<'a>>::Data: Send, R: Sync,

§

impl<'a, R> Sync for SpanRef<'a, R>
where <R as LookupSpan<'a>>::Data: Sync, R: 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 as LookupSpan<'a>>::Data: UnwindSafe, R: RefUnwindSafe,

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T> Instrument for T

source§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more
source§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
source§

impl<T> WithSubscriber for T

source§

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
source§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more