How to install a rolling file and console log as the global default.

[ChaseLewis]

The documentation is incredibly confusing on how to set the global default manually & how to put multiple writers on it.

//How I initialize the logger
pub use tracing::{debug,info,warn,error};

pub struct LoggingConfig {
    pub filename: String,
    pub output_path: String
}

impl Default for LoggingConfig {
    fn default() -> Self {
        return LoggingConfig {  
            filename: String::from("logfile.log"),
            output_path: String::from("./logs")
        };
    }
}

pub fn initialize_logger(config: &LoggingConfig) {
    let file_appender = tracing_appender::rolling::daily(config.output_path.to_owned(),config.filename.to_owned());
    let (non_blocking, guard) = tracing_appender::non_blocking(file_appender);

    tracing_subscriber::fmt()
    .with_writer(non_blocking)
    .init(); 
}

mod core;
mod rendering;
use std::process;
use std::panic;
use backtrace::Backtrace;
use self::core::{
    app::{App, AppConfig, Size},
    log::{debug,info,error,initialize_logger}
};

#[tokio::main]
async fn main() -> tokio::io::Result<()> {

    initialize_logger(&Default::default());
    
    panic::set_hook(Box::new(|panic_info|{
        error!("Panic: {:?}", Backtrace::new());
    }));

    info!("Loading configs...");
    info!("Initializing application...");

    let mut app = App::new(&AppConfig {
        title: String::from("Vulkan Tutorial (Rust)"),
        size: Size::new(1024,768)
    });

    info!("Starting Application...");
    process::exit(app.run());
}

This works fine if if I just call tracing_subscriber::fmt::init() instead so the configuration is the issue. Currently it just makes the rolling file and doesn't write anything to it.

[davidbarsky]

You're not returning the guard in initialize_logger. You need to return it and hold it as long as you'd like to log to a file. Take a look at the WorkerGuard's documentation for more details.

You'll need to rewrite your code as:

pub fn initialize_logger(config: &LoggingConfig) -> WorkerGuard {
    let file_appender = tracing_appender::rolling::daily(config.output_path.to_owned(),config.filename.to_owned());
    let (non_blocking, guard) = tracing_appender::non_blocking(file_appender);

    tracing_subscriber::fmt()
        .with_writer(non_blocking)
        .init(); 
    guard
}

#[tokio::main]
async fn main() -> tokio::io::Result<()> {
    let guard = initialize_logger(&Default::default());
    // ... the rest of your main function      
}

[ChaseLewis]

Gotcha, that's pretty simple but any idea how I can also include the console logging?

[davidbarsky]

I'd take a look at https://github.com/tokio-rs/tracing/blob/v0.1.x/examples/examples/fmt-multiple-writers.rs. The approach inside of initialize_logger will boil down to:

let file_appender = tracing_appender::rolling::daily(config.output_path.to_owned(),config.filename.to_owned());
let (non_blocking, guard) = tracing_appender::non_blocking(file_appender);

let subscriber = tracing_subscriber::registry()
    .with(fmt::Layer::new().with_writer(io::stdout))
    .with(fmt::Layer::new().with_writer(non_blocking));
tracing::subscriber::set_global_default(subscriber);

guard

[ChaseLewis]

thanks a lot. The Layer::new() is what I was missing. Much appreciated.