Struct tracing_forest::processor::sync::AsyncProcessor

pub struct AsyncProcessor { /* private fields */ }

A Processor that sends logs to another tokio task for processing.

This type is usually created and used by the LayerBuilder type.

Implementations

impl AsyncProcessor

pub fn spawn<F, W>(
    formatter: F,
    make_writer: W
) -> (Self, impl Future<Output = ()>) where
    F: 'static + Formatter + Send,
    W: 'static + for<'a> MakeWriter<'a> + Send, 

Create a new AsyncProcessor and Future for processing, returning the processor and the future.

Examples

In a function that runs indefinitely, where the writing thread doesn’t need to explicitly be awaited:

#[tokio::main(flavor = "current_thread")]
async fn main() {
    let (processor, fut) = AsyncProcessor::spawn(Pretty::new(), std::io::stdout);
    tokio::spawn(fut);
    tracing::subscriber::set_global_default({
        processor
            .into_layer()
            .into_subscriber()
    }).unwrap();
     
    start_server().await;
}

In a function that terminates, where the writing thread needs to be explicitly awaited before going out of scope:

#[tokio::test]
async fn my_short_test() {
    let (processor, fut) = AsyncProcessor::spawn(Pretty::new(), std::io::stdout);
    let handle = tokio::spawn(fut);
     
    let guard = tracing::subscriber::set_default({
        processor
            .into_layer()
            .into_subscriber()
    });

    tracing::info!(satisfied = true, "it works!");
     
    // drop subscriber to close all senders
    drop(guard);
    handle.await.unwrap();
}

Trait Implementations

impl From<UnboundedSender<Tree>> for AsyncProcessor

fn from(tx: UnboundedSender<Tree>) -> Self

Performs the conversion.

impl Processor for AsyncProcessor

fn process(&self, tree: Tree)

Processes the Tree of logs. Implementors of this trait are free to define what this means, such as:

fn into_layer(self) -> TreeLayer<Self>

Converts the Processor into a TreeLayer.