Multiple Writers or Subscribers

[mankinskin]

Is it possible to have tracing write logs to multiple writers, such as stdout and a file?
There is tracing_subscriber::fmt::SubscriberBuilder::with_writer(), but this only allows for one writer to be set.
Another option would be to allow for multiple subscribers, however this does not seem to work, as far as I have tried:

fn init_tracing() {
    let file_appender = tracing_appender::rolling::hourly("./logs", "log");
    let (file_writer, _guard) = tracing_appender::non_blocking(file_appender);
    tracing_subscriber::fmt()
        .with_writer(file_writer)
        .init();
    tracing_subscriber::fmt()
        .with_max_level(tracing::Level::DEBUG)
        .init();
    tracing::trace!("Tracing initialized.");
}

thread 'main' panicked at 'Unable to install global subscriber: SetLoggerError(())'

[davidbarsky]

Here's how you can have multiple, distinct writers:

use tracing_subscriber::{fmt, Registry};
use tracing_subscriber::prelude::*;

fn main() {
    let file_appender = tracing_appender::rolling::hourly("./logs", "log");
    let (file_writer, _guard) = tracing_appender::non_blocking(file_appender);

    let subscriber = Registry::default()
        .with(fmt::Layer::default().with(file_writer));
        .with(fmt::Layer::default().with(std::io::stdout));
    
    tracing::subscriber::set_global_default(subscriber).expect("unable to set global subscriber");
}

A note on your provided code example: you should hold onto _guard for as long as you'd like logs to be written to a file—if _guard is dropped at the end of the scope of init_tracing, nothing will be written to a file. Be sure to return the guard and hold onto it in fn main()!

Another option would be to allow for multiple subscribers, however this does not seem to work[..]

We don't support multiple subscribers that are active at the same time. The Layer trait (to be renamed to "Subscriber" soon, see #922) enable functionality similar to what multiple subscribers would enable.

[mankinskin]

Thank you a lot, this was not really clear from the docs, to be honest. Maybe this would be a good tip for under with_writer? because I was looking for something with writers, but there wasn't anything, and understanding Layer is a huge indirection for some reason. The topic of where the logs are written seems somehow lost in the docs, if you know what I mean. Otherwise I can issue a pull request when I have the time ☺️

[mankinskin]

Note: fmt::Layer only exposes a with_writer method (as of tracing-subscriber v0.2.11), which was probably meant in the above code example.

[mankinskin]

This is the code now:

use tracing_subscriber::{
    fmt,
    layer::SubscriberExt,
};
use tracing_appender::{
    non_blocking::{
        WorkerGuard,
    },
};

fn init_tracing() -> WorkerGuard {
    let file_appender = tracing_appender::rolling::hourly("./logs", "log");
    let (file_writer, guard) = tracing_appender::non_blocking(file_appender);
    tracing::subscriber::set_global_default(
        fmt::Subscriber::builder()
            // subscriber configuration
            .with_env_filter("server")
            .with_max_level(tracing::Level::DEBUG)
            .finish()
            // add additional writers
            .with(fmt::Layer::default().with_writer(file_writer))
    ).expect("Unable to set global tracing subscriber");
    debug!("Tracing initialized.");
    guard
}
#[tokio::main]
async fn main() -> Result<(), Error> {
    let _guard = init_tracing(); // hold on to WorkerGuard
    MessageStream::init()
        .await?
        .handle_messages()
        .await
}

I only add the file writer Layer explicitly because logging to stdout seems to be enabled by default for fmt::Subscriber.