Suppression des macros de débogage dans Rust

Afin de simplifier le problème, j'ai créé un autre exemple de travail avec la version actuelle de slog (2.4.1) qui définissait un enregistreur de portée globale et le problème toujours reproduit. Voici l'exemple de code:

Jan 30 13:56:30.839 INFO some interesting info, where: right here, version: 0.1.0
{"msg":"some interesting info","level":"INFO","ts":"2019-01-30T13:56:30.839762+00:00","version":"0.1.0","where":"right here"}
Jan 30 13:56:30.839 WARN be cautious!, why: you never know..., version: 0.1.0
{"msg":"be cautious!","level":"WARN","ts":"2019-01-30T13:56:30.839787+00:00","version":"0.1.0","why":"you never know..."}
Jan 30 13:56:30.839 ERRO wrong foobar, type: unknown, version: 0.1.0
{"msg":"wrong foobar","level":"ERRO","ts":"2019-01-30T13:56:30.839802+00:00","version":"0.1.0","type":"unknown"}
Jan 30 13:56:30.839 CRIT abandoning test, version: 0.1.0
{"msg":"abandoning test","level":"CRIT","ts":"2019-01-30T13:56:30.839815+00:00","version":"0.1.0"}

L'exécution de l'exemple ci-dessus après la construction pour la publication donne ce résultat:

#[macro_use]
extern crate slog;
extern crate slog_async;
extern crate slog_json;
extern crate slog_term;
extern crate slog_scope;
extern crate slog_stdlog;

use slog::Drain;
use std::fs::OpenOptions;
use std::io;
use std::sync::Mutex;

fn duplicate_log() {
    let plain = slog_term::PlainSyncDecorator::new(std::io::stdout());
    let d1 = slog_term::FullFormat::new(plain).build().fuse();
    let d2 = Mutex::new(slog_json::Json::default(io::stdout())).fuse();
    let log = slog::Logger::root(slog::Duplicate::new(d1, d2).fuse(), o!("version" => env!("CARGO_PKG_VERSION")));

    trace!(log, "logging a trace message");
    debug!(log, "debug values"; "x" => 1, "y" => -1);
    info!(log, "some interesting info"; "where" => "right here");
    warn!(log, "be cautious!"; "why" => "you never know...");
    error!(log, "wrong {}", "foobar"; "type" => "unknown");
    crit!(log, "abandoning test");
}

fn main() {
   duplicate_log();
}

Cependant, un nouvel exemple qui passe les bûcherons corrige le problème. Voici l'exemple de travail:

Jan 30 13:53:52.398 TRCE logging a trace message
Jan 30 13:53:52.399 DEBG debug values "x" => 1, "y" => -1
Jan 30 13:53:52.399 INFO some interesting info; where => right here
Jan 30 13:53:52.399 WARN be cautious!; why => you never know...
Jan 30 13:53:52.399 ERRO wrong, foobar; type => unknown

L'exécution de l'exemple de travail donne le résultat suivant:

extern crate slog;
extern crate slog_async;
extern crate slog_json;
extern crate slog_term;
extern crate slog_scope;
extern crate slog_stdlog;
#[macro_use]
extern crate log;

fn complex_logging() -> Result<(), log::SetLoggerError> {
    //Create the output file
    let log_path = "your_log_file_path.log";
    let file = OpenOptions::new()
        .create(true)
        .write(true)
        .truncate(true)
        .open(log_path)
        .unwrap();

    //Create the terminal drain
    let decorator = slog_term::TermDecorator::new().build();
    let d1 = slog_term::FullFormat::new(decorator).build().fuse();
    let d1 = slog_async::Async::new(d1).build().fuse();

    //Create the file drain
    let d2 = slog_json::Json::new(file)
        .add_default_keys()
        .build()
        .fuse();
    let d2 = slog_async::Async::new(d2).build().fuse();

    //Fuse the drains and create the logger
    let logger = slog::Logger::root(slog::Duplicate::new(d1, d2).fuse(), o!());
    let _guard = slog_scope::set_global_logger(logger);

    //register slog_stdlog as the log handler with the log crate
    slog_stdlog::init().unwrap();


    trace!("logging a trace message");
    debug!("debug values \"x\" => 1, \"y\" => -1");
    info!("some interesting info; where => right here");
    warn!("be cautious!; why => you never know...");
    error!("wrong, foobar; type => unknown");

    Ok(())
}

fn main() {
  let _res = complex_logging();    
}

Si vous rencontrez un problème similaire à celui que j'ai fait, mon problème était de configurer un enregistreur global de portée . Faire circuler les enregistreurs résout ce problème.