Enum Update

Source

pub enum Update<M = &'static Metadata<'static>>where
    M: Clone + Debug,{
    OpenDirect {
        cause: Span<M>,
        consequence: Span<M>,
    },
    NewIndirect {
        cause: Span<M>,
        consequence: Span<M>,
    },
    CloseDirect {
        span: Span<M>,
        direct_cause: Option<Span<M>>,
    },
    CloseIndirect {
        span: Span<M>,
        indirect_causes: Vec<Span<M>>,
    },
    CloseCyclic {
        span: Span<M>,
        direct_cause: Option<Span<M>>,
        indirect_causes: Vec<Span<M>>,
    },
}

Expand description

An update that should be applied to a Trace.

Variants§

§

OpenDirect

Announces that consequence directly follows from cause.

§Example

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

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

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

    let (_trace, cause_updates) = causality::trace(registry, &cause_id_and_metadata.id, 1024).unwrap();

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

    assert_eq!(
        cause_updates.drain().collect::<Vec<_>>(),
        vec![Update::OpenDirect {
            cause: cause_id_and_metadata,
            consequence: consequence_id_and_metadata,
        }],
        "The listeners on `cause` should be notified that it has a \
        direct `consequence`."
    );
}

Fields

§cause: Span<M>

§consequence: Span<M>

§

NewIndirect

Announces that consequence indirectly follows from cause.

§Example

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

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

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

    let (_trace, cause_updates) = causality::trace(registry, &cause_id_and_metadata.id, 1024).unwrap();

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

    assert_eq!(
        cause_updates.drain().collect::<Vec<_>>(),
        vec![Update::NewIndirect {
            cause: cause_id_and_metadata.clone(),
            consequence: consequence_id_and_metadata.clone(),
        }],
        "The listeners on `cause` should be notified that it has a \
        indirect `consequence`."
    );
}

Fields

§cause: Span<M>

§consequence: Span<M>

§

CloseDirect

Announces that a direct consequence of a Span within Trace was closed, and is thus no longer an extant consequence of direct_cause.

§Example

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

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

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

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

    let (_trace, cause_updates) = causality::trace(registry, &cause_id_and_metadata.id, 1024).unwrap();

    drop(consequence);

    assert_eq!(
        cause_updates.drain().collect::<Vec<_>>(),
        vec![Update::CloseDirect {
            span: consequence_id_and_metadata.clone(),
            direct_cause: Some(cause_id_and_metadata),
        }],
        "The listeners on `cause` should be notified that
        `consequence` was closed."
    );
}

Fields

§span: Span<M>

§direct_cause: Option<Span<M>>

§

CloseIndirect

Announces that an indirect consequence of a Span within Trace was closed, and is thus no longer an extant consequence of indirect_causes.

§Example

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

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

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

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

    consequence.follows_from(&cause_id_and_metadata.id);

    let (_trace, cause_updates) = causality::trace(registry, &cause_id_and_metadata.id, 1024).unwrap();

    drop(consequence);

    assert_eq!(
        cause_updates.drain().collect::<Vec<_>>(),
        vec![Update::CloseIndirect {
            span: consequence_id_and_metadata,
            indirect_causes: vec![cause_id_and_metadata],
        }],
        "The listeners on `cause` should be notified that
        `consequence` was closed."
    );
}

Fields

§span: Span<M>

§indirect_causes: Vec<Span<M>>

§

CloseCyclic

Announces that a self-cycling consequence of a Span within Trace was closed, and is thus no longer an extant consequence of direct_cause or indirect_cause.

§Example

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

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

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

    let consequence = cause.clone();
    let consequence_id_and_metadata = causality::Span {
        id: consequence.id().unwrap(),
        metadata: consequence.metadata().unwrap()
    };

    consequence.follows_from(&cause_id_and_metadata.id);

    let (_trace, cause_updates) = causality::trace(registry, &cause_id_and_metadata.id, 1024).unwrap();

    drop([cause, consequence]);

    assert_eq!(
        cause_updates.into_iter().collect::<Vec<_>>(),
        vec![Update::CloseCyclic {
            span: consequence_id_and_metadata.clone(),
            direct_cause: None,
            indirect_causes: vec![cause_id_and_metadata.clone()],
        }],
        "The listeners on `cause` should be notified that
        `consequence` was closed."
    );
}