Struct SpanRef

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

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

impl<'a, R> SpanRef<'a, R>

where R: LookupSpan<'a>,

pub fn id(&self) -> Id

Returns this span’s ID.

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

Returns a static reference to the span’s metadata.

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

Returns the span’s name,

pub fn fields(&self) -> &FieldSet

Returns a list of fields defined by the span.

pub fn parent_id(&self) -> Option<&Id>

👎Deprecated since 0.2.21: this method cannot properly support per-subscriber filtering, and may return the Id of a disabled span if per-subscriber filtering is in use. use .parent().map(SpanRef::id) instead.

Returns the ID of this span’s parent, or None if this span is the root of its trace tree.

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.

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, Collect};
use tracing_subscriber::{
    subscribe::{Context, Subscribe},
    prelude::*,
    registry::LookupSpan,
};

struct PrintingSubscriber;
impl<C> Subscribe<C> for PrintingSubscriber
where
    C: Collect + for<'lookup> LookupSpan<'lookup>,
{
    fn on_enter(&self, id: &span::Id, ctx: Context<C>) {
        let span = ctx.span(id).unwrap();
        let scope = span.scope().map(|span| span.name()).collect::<Vec<_>>();
        println!("Entering span: {:?}", scope);
    }
}

tracing::collect::with_default(tracing_subscriber::registry().with(PrintingSubscriber), || {
    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<C> Subscribe<C> for PrintingSubscriber
where
    C: Collect + for<'lookup> LookupSpan<'lookup>,
{
    fn on_enter(&self, id: &span::Id, ctx: Context<C>) {
        let span = ctx.span(id).unwrap();
        let scope = span.scope().from_root().map(|span| span.name()).collect::<Vec<_>>();
        println!("Entering span: {:?}", scope);
    }
}

tracing::collect::with_default(tracing_subscriber::registry().with(PrintingSubscriber), || {
    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"]
});

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

Available on crate feature std only.

Returns a reference to this span’s Extensions.

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

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

Available on crate feature std only.

Returns a mutable reference to this span’s Extensions.

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

Trait Implementations

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

where R::Data: Debug,

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

Formats the value using the given formatter.