Struct tracing::span::Inner

pub(crate) struct Inner {
    id: Id,
    subscriber: Dispatch,
}

A handle representing the capacity to enter a span which is known to exist.

Unlike Span, this type is only constructed for spans which have been enabled by the current filter. This type is primarily used for implementing span handles; users should typically not need to interact with it directly.

Fields

id: Id

The span’s ID, as provided by subscriber.

subscriber: Dispatch

The subscriber that will receive events relating to this span.

This should be the same subscriber that provided this span with its id.

Implementations

impl Inner

fn follows_from(&self, from: &Id)

Indicates that the span with the given ID has an indirect causal relationship with this span.

This relationship differs somewhat from the parent-child relationship: a span may have any number of prior spans, rather than a single one; and spans are not considered to be executing inside of the spans they follow from. This means that a span may close even if subsequent spans that follow from it are still open, and time spent inside of a subsequent span should not be included in the time its precedents were executing. This is used to model causal relationships such as when a single future spawns several related background tasks, et cetera.

If this span is disabled, this function will do nothing. Otherwise, it returns Ok(()) if the other span was added as a precedent of this span, or an error if this was not possible.

fn id(&self) -> Id

Returns the span’s ID.

fn record(&self, values: &Record<'_>)

fn new(id: Id, subscriber: &Dispatch) -> Self

Trait Implementations

impl Clone for Inner

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Inner

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

Formats the value using the given formatter.

impl Hash for Inner

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Inner

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.