Function tracing_causality::trace

pub fn trace<S>(
    s: &S,
    id: &Id,
    update_capacity: usize
) -> Option<(Trace, Updates)> where
    S: for<'span> LookupSpan<'span> + ?Sized, 

Produces the full causality graph for the span corresponding to a given id.

Returns both a Trace rooted at id, and a stream of updates that affect the produced trace, but occurred after the invocation of this method. If the span has already been closed, this function produces None.

use std::sync::Arc;
use tracing_core::Subscriber;
use tracing_causality as causality;
use tracing_subscriber::{prelude::*, registry::Registry};

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

    let a = tracing::trace_span!("a");
    let a_id_and_metadata = causality::Span {
        id: a.id().unwrap(),
        metadata: a.metadata().unwrap()
    };

    let b = a.in_scope(|| tracing::trace_span!("b"));
    let b_id_and_metadata = causality::Span {
        id: b.id().unwrap(),
        metadata: b.metadata().unwrap()
    };

    let (trace, updates) = causality::trace(subscriber, &a_id_and_metadata.id, 1).unwrap();
    assert!(trace.consequences(&a_id_and_metadata).unwrap().contains_direct(&b_id_and_metadata));

    let c = b.in_scope(|| tracing::trace_span!("c"));
    let c_id_and_metadata = causality::Span {
        id: c.id().unwrap(),
        metadata: c.metadata().unwrap()
    };
     
    assert_eq!(
        updates.next(),
        Some(causality::Update::OpenDirect {
            cause: b_id_and_metadata,
            consequence: c_id_and_metadata,
        })
    );
}