Struct CapturedEvent

pub struct CapturedEvent<'a> { /* private fields */ }

Captured tracing event containing a reference to its [Metadata] and values that the event was created with.

CapturedEvents are comparable and are partially ordered according to the capture order. Events are considered equal iff both are aliases of the same event; i.e., equality is reference-based rather than content-based. Two events from different Storages are not ordered and are always non-equal.

Values recorded with the event can be accessed by indexing or using Self::value(), or iterated over using Self::values().

Examples

let event: CapturedEvent = // ...
// Accessing event metadata and fields:
assert_eq!(*event.metadata().level(), Level::INFO);
assert_eq!(event["return"], 42_u64);
assert_eq!(event.message(), Some("finished computations"));
assert!(event.value("err").is_none());
// Filtering unsigned integer values:
let numbers = event.values().filter_map(|(_, val)| val.as_uint());

// Accessing the parent span:
let parent_name = event.parent().unwrap().metadata().name();
assert!(event
    .ancestors()
    .any(|span| span.metadata().name() == "test"));

Implementations

impl<'a> CapturedEvent<'a>

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

Provides a reference to the event metadata.

pub fn values(&self) -> impl Iterator<Item = (&'a str, &'a TracedValue)> + 'a

Iterates over values associated with the event.

pub fn value(&self, name: &str) -> Option<&'a TracedValue>

Returns a value for the specified field, or None if the value is not defined.

pub fn message(&self) -> Option<&'a str>

Returns the message recorded in this event, i.e., the value of the message field if it has a string presentation.

pub fn parent(&self) -> Option<CapturedSpan<'a>>

Returns the parent span for this event, or None if is not tied to a captured span.

pub fn ancestors(&self) -> impl Iterator<Item = CapturedSpan<'a>> + '_

Returns the references to the ancestor spans, starting from the direct parent and ending in one of root spans.

Trait Implementations

impl<'a> Captured<'a> for CapturedEvent<'a>

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

Provides a reference to the span / event metadata.

fn value(&self, name: &str) -> Option<&'a TracedValue>

Returns a value for the specified field, or None if the value is not defined.

fn parent(&self) -> Option<CapturedSpan<'a>>

Returns the reference to the parent span, if any.

impl<'a> Clone for CapturedEvent<'a>

fn clone(&self) -> CapturedEvent<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for CapturedEvent<'_>

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

Formats the value using the given formatter.

impl Index<&str> for CapturedEvent<'_>

type Output = TracedValue

The returned type after indexing.

fn index(&self, index: &str) -> &Self::Output

Performs the indexing (container[index]) operation.

impl PartialEq for CapturedEvent<'_>

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.

impl PartialOrd for CapturedEvent<'_>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<P: Predicate<str>> Predicate<CapturedEvent<'_>> for MessagePredicate<P>

fn eval(&self, variable: &CapturedEvent<'_>) -> bool

Execute this Predicate against variable, returning the resulting boolean.

fn find_case( &self, expected: bool, variable: &CapturedEvent<'_>, ) -> Option<Case<'_>>

Find a case that proves this predicate as expected when run against variable.

impl<'a> Copy for CapturedEvent<'a>

impl Eq for CapturedEvent<'_>