Struct Consequences

Source

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

Expand description

The consequences — direct and indirect — of a Span.

Implementations§

Source §

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

Source

pub fn none() -> Self

Constructs a new, empty Consequences.

Source

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

Constructs a Consequences with the given direct consequence.

Source

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

Constructs a Consequences with the given indirect consequence.

Source

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

Add the given direct consequence.

Source

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

Add the given indirect consequence.

Source

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));

Source

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));

Source

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)
);

Source

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)
);