Struct tracing_causality::data::Consequences

pub struct Consequences<M = &'static Metadata<'static>> where
    M: Clone + Debug, { /* private fields */ }

The consequences — direct and indirect — of a Span.

Implementations

impl<M> Consequences<M> where
    M: Clone + Debug, 

pub fn none() -> Self

Constructs a new, empty Consequences.

pub fn with_direct(direct: Span<M>) -> Self

Constructs a Consequences with the given direct consequence.

pub fn with_indirect(indirect: Span<M>) -> Self

Constructs a Consequences with the given indirect consequence.

pub fn add_direct(&mut self, direct: Span<M>)

Add the given direct consequence.

pub fn add_indirect(&mut self, indirect: Span<M>)

Add the given indirect consequence.

pub fn contains_direct(&self, span: &Span<M>) -> bool

Returns true if the given id is among this span’s direct consequences.

use std::sync::Arc;
use tracing::{Subscriber, trace_span};
use tracing_causality::{self as causality, Consequences};
use tracing_subscriber::{prelude::*, registry::{LookupSpan, SpanData, Registry}};

let subscriber: Arc<dyn Subscriber + Send + Sync > =
    Arc::new(Registry::default().with(causality::Layer));
subscriber.clone().init();
let subscriber: Arc<dyn Subscriber> = subscriber;
let registry = subscriber.downcast_ref::<Registry>().unwrap();

let root = trace_span!("root");
let root_id_and_metadata = causality::Span {
    id: root.id().unwrap(),
    metadata: root.metadata().unwrap()
};
let consequence = root.in_scope(|| trace_span!("consequence"));
let consequence_id_and_metadata = causality::Span {
    id: consequence.id().unwrap(),
    metadata: consequence.metadata().unwrap()
};

let root_data = registry.span_data(&root_id_and_metadata.id).unwrap();
let root_extensions = root_data.extensions();
let root_consequences = root_extensions.get::<Consequences>().unwrap();
assert!(root_consequences.contains_direct(&consequence_id_and_metadata));

pub fn contains_indirect(&self, span: &Span<M>) -> bool

Returns true if the given id is among this span’s indirect consequences.

use std::sync::Arc;
use tracing::{Subscriber, trace_span};
use tracing_causality::{self as causality, Consequences};
use tracing_subscriber::{prelude::*, registry::{LookupSpan, SpanData, Registry}};

let subscriber: Arc<dyn Subscriber + Send + Sync > =
    Arc::new(Registry::default().with(causality::Layer));
subscriber.clone().init();
let subscriber: Arc<dyn Subscriber> = subscriber;
let registry = subscriber.downcast_ref::<Registry>().unwrap();

let root = trace_span!("root");
let root_id_and_metadata = causality::Span {
    id: root.id().unwrap(),
    metadata: root.metadata().unwrap()
};
let consequence = trace_span!("consequence");
let consequence_id_and_metadata = causality::Span {
    id: consequence.id().unwrap(),
    metadata: consequence.metadata().unwrap()
};
consequence.follows_from(&root_id_and_metadata.id);

let root_data = registry.span_data(&root_id_and_metadata.id).unwrap();
let root_extensions = root_data.extensions();
let root_consequences = root_extensions.get::<Consequences>().unwrap();
assert!(root_consequences.contains_indirect(&consequence_id_and_metadata));

pub fn iter_direct(&self) -> impl ExactSizeIterator<Item = Span<M>> + '_

An iterator visiting all direct consequences in arbitrary order.

use std::sync::Arc;
use tracing::{Subscriber, trace_span};
use tracing_causality::{self as causality, Consequences};
use tracing_subscriber::{prelude::*, registry::{LookupSpan, SpanData, Registry}};

let subscriber: Arc<dyn Subscriber + Send + Sync > =
    Arc::new(Registry::default().with(causality::Layer));
subscriber.clone().init();
let subscriber: Arc<dyn Subscriber> = subscriber;
let registry = subscriber.downcast_ref::<Registry>().unwrap();

let root = trace_span!("root");
let root_id_and_metadata = causality::Span {
    id: root.id().unwrap(),
    metadata: root.metadata().unwrap()
};
let consequence = root.in_scope(|| trace_span!("consequence"));
let consequence_id_and_metadata = causality::Span {
    id: consequence.id().unwrap(),
    metadata: consequence.metadata().unwrap()
};

let root_data = registry.span_data(&root_id_and_metadata.id).unwrap();
let root_extensions = root_data.extensions();
let root_consequences = root_extensions.get::<Consequences>().unwrap();
assert_eq!(
    root_consequences.iter_direct().next(),
    Some(consequence_id_and_metadata)
);

pub fn iter_indirect(&self) -> impl ExactSizeIterator<Item = Span<M>> + '_

An iterator visiting all direct consequences in arbitrary order.

use std::sync::Arc;
use tracing::{Subscriber, trace_span};
use tracing_causality::{self as causality, Consequences};
use tracing_subscriber::{prelude::*, registry::{LookupSpan, SpanData, Registry}};

let subscriber: Arc<dyn Subscriber + Send + Sync > =
    Arc::new(Registry::default().with(causality::Layer));
subscriber.clone().init();
let subscriber: Arc<dyn Subscriber> = subscriber;
let registry = subscriber.downcast_ref::<Registry>().unwrap();

let root = trace_span!("root");
let root_id_and_metadata = causality::Span {
    id: root.id().unwrap(),
    metadata: root.metadata().unwrap()
};
let consequence = trace_span!("consequence");
let consequence_id_and_metadata = causality::Span {
    id: consequence.id().unwrap(),
    metadata: consequence.metadata().unwrap()
};
consequence.follows_from(&root_id_and_metadata.id);

let root_data = registry.span_data(&root_id_and_metadata.id).unwrap();
let root_extensions = root_data.extensions();
let root_consequences = root_extensions.get::<Consequences>().unwrap();
assert_eq!(
    root_consequences.iter_indirect().next(),
    Some(consequence_id_and_metadata)
);

Trait Implementations

impl<M: Clone> Clone for Consequences<M> where
    M: Clone + Debug, 

fn clone(&self) -> Consequences<M>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<M: Debug> Debug for Consequences<M> where
    M: Clone + Debug, 

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

Formats the value using the given formatter.

impl<M> Default for Consequences<M> where
    M: Clone + Debug, 

fn default() -> Self

Returns the “default value” for a type.

impl<M> PartialEq<Consequences<M>> for Consequences<M> where
    M: Clone + Debug, 

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl<M> Eq for Consequences<M> where
    M: Clone + Debug,