[][src]Struct tracing::dispatch::Dispatch

pub struct Dispatch { /* fields omitted */ }

Dispatch trace data to a Collect.

Implementations

impl Dispatch[src]

pub fn none() -> Dispatch[src]

Returns a new Dispatch that discards events and spans.

pub fn new<S>(collector: S) -> Dispatch where
    S: Collect + Send + Sync + 'static, 
[src]

Returns a Dispatch that forwards to the given Collect.

pub fn from_static(
    collector: &'static (dyn Collect + 'static + Send + Sync)
) -> Dispatch
[src]

Returns a Dispatch that forwards to the given static collector.

Unlike Dispatch::new, this function is always available on all platforms, even when the std or alloc features are disabled.

In order to use from_static, the Collector itself must be stored in a static. For example:

struct MyCollector {
   // ...
}

impl tracing_core::Collect for MyCollector {
    // ...
}

static COLLECTOR: MyCollector = MyCollector {
    // ...
};

fn main() {
    use tracing_core::dispatch::{self, Dispatch};

    let dispatch = Dispatch::from_static(&COLLECTOR);

    dispatch::set_global_default(dispatch)
        .expect("no global default collector should have been set previously!");
}

Constructing the collector in a static initializer may make some forms of runtime configuration more challenging. If this is the case, users with access to liballoc or the Rust standard library are encouraged to use Dispatch::new rather than from_static. no_std users who cannot allocate or do not have access to liballoc may want to consider the lazy_static crate, or another library which allows lazy initialization of statics.

pub fn register_callsite(
    &self,
    metadata: &'static Metadata<'static>
) -> Interest
[src]

Registers a new callsite with this collector, returning whether or not the collector is interested in being notified about the callsite.

This calls the register_callsite function on the Collect that this Dispatch forwards to.

pub fn new_span(&self, span: &Attributes<'_>) -> Id[src]

Record the construction of a new span, returning a new ID for the span being constructed.

This calls the new_span function on the Collect that this Dispatch forwards to.

pub fn record(&self, span: &Id, values: &Record<'_>)[src]

Record a set of values on a span.

This calls the record function on the Collect that this Dispatch forwards to.

pub fn record_follows_from(&self, span: &Id, follows: &Id)[src]

Adds an indication that span follows from the span with the id follows.

This calls the record_follows_from function on the Collect that this Dispatch forwards to.

pub fn enabled(&self, metadata: &Metadata<'_>) -> bool[src]

Returns true if a span with the specified metadata would be recorded.

This calls the enabled function on the Collect that this Dispatch forwards to.

pub fn event(&self, event: &Event<'_>)[src]

Records that an Event has occurred.

This calls the event function on the Collect that this Dispatch forwards to.

pub fn enter(&self, span: &Id)[src]

Records that a span has been can_enter.

This calls the enter function on the Collect that this Dispatch forwards to.

pub fn exit(&self, span: &Id)[src]

Records that a span has been exited.

This calls the exit function on the Collect that this Dispatch forwards to.

pub fn clone_span(&self, id: &Id) -> Id[src]

Notifies the collector that a span ID has been cloned.

This function must only be called with span IDs that were returned by this Dispatch's new_span function. The tracing crate upholds this guarantee and any other libraries implementing instrumentation APIs must as well.

This calls the clone_span function on the Collect that this Dispatch forwards to.

pub fn drop_span(&self, id: Id)[src]

👎 Deprecated since 0.1.2:

use Dispatch::try_close instead

Notifies the collector that a span ID has been dropped.

This function must only be called with span IDs that were returned by this Dispatch's new_span function. The tracing crate upholds this guarantee and any other libraries implementing instrumentation APIs must as well.

This calls the drop_span function on the Collect that this Dispatch forwards to.

⚠ ️Warning

Deprecated: The try_close method is functionally identical, but returns true if the span is now closed. It should be used instead of this method.

pub fn try_close(&self, id: Id) -> bool[src]

Notifies the collector that a span ID has been dropped, and returns true if there are now 0 IDs referring to that span.

This function must only be called with span IDs that were returned by this Dispatch's new_span function. The tracing crate upholds this guarantee and any other libraries implementing instrumentation APIs must as well.

This calls the try_close function on the Collect trait that this Dispatch forwards to.

pub fn current_span(&self) -> Current[src]

Returns a type representing this collector's view of the current span.

This calls the current function on the Collect that this Dispatch forwards to.

pub fn is<T>(&self) -> bool where
    T: Any
[src]

Returns true if this Dispatch forwards to a collector of type T.

pub fn downcast_ref<T>(&self) -> Option<&T> where
    T: Any
[src]

Returns some reference to the Collect this Dispatch forwards to if it is of type T, or None if it isn't.

Trait Implementations

impl Clone for Dispatch[src]

impl Debug for Dispatch[src]

impl Default for Dispatch[src]

pub fn default() -> Dispatch[src]

Returns the current default dispatcher

impl<S> From<S> for Dispatch where
    S: Collect + Send + Sync + 'static, 
[src]

Auto Trait Implementations

impl !RefUnwindSafe for Dispatch

impl Send for Dispatch

impl Sync for Dispatch

impl Unpin for Dispatch

impl !UnwindSafe for Dispatch

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> From<T> for T[src]

impl<T> Instrument for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<T> ToOwned for T where
    T: Clone
[src]

type Owned = T

The resulting type after obtaining ownership.

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.