logs: switch from slog to log and env_logger

Author: pietroalbini

Cargo.lock

@@ -49,9 +49,6 @@ serde = "1.0"
 serde_derive = "1.0"
 serde_json = "1.0"
 serde_regex = "0.3.0"
-slog = "2.4.1"
-slog-scope = "4"
-slog-term = "2"
 structopt = "0.2"
 structopt-derive = "0.2"
 tar = "0.4.0"
@@ -64,6 +61,8 @@ url = "1.1"
 walkdir = "2"
 warp = "0.1.9"
 winapi = "0.3"
+log = "0.4.6"
+env_logger = "0.6.0"
 
 [dev-dependencies]
 assert_cmd = "0.10.1"

Cargo.toml

@@ -1,11 +1,11 @@
 use crate::agent::api::AgentApi;
 use crate::crates::{Crate, GitHubRepo};
 use crate::experiments::Experiment;
-use crate::log;
+use crate::logs::{self, LogStorage};
 use crate::prelude::*;
 use crate::results::{TestResult, WriteResults};
 use crate::toolchain::Toolchain;
-use std::io::Read;
+use log::LevelFilter;
 use std::ops::DerefMut;
 use std::sync::{Arc, Mutex};
 
@@ -53,17 +53,15 @@ impl<'a> WriteResults for ResultsUploader<'a> {
     where
         F: FnOnce() -> Fallible<TestResult>,
     {
-        let mut log_file = ::tempfile::NamedTempFile::new()?;
-        let result = log::redirect(log_file.path(), f)?;
-
-        let mut buffer = Vec::new();
-        log_file.read_to_end(&mut buffer)?;
+        let storage = LogStorage::new(LevelFilter::Info);
+        let result = logs::capture(&storage, f)?;
+        let output = storage.to_string();
 
         let shas = ::std::mem::replace(self.shas.lock().unwrap().deref_mut(), Vec::new());
 
         info!("sending results to the crater server...");
         self.api
-            .record_progress(krate, toolchain, &buffer, result, &shas)?;
+            .record_progress(krate, toolchain, output.as_bytes(), result, &shas)?;
 
         Ok(result)
     }

src/agent/results.rs

@@ -50,6 +50,7 @@ impl Database {
         }
 
         let path = WORK_DIR.join(DATABASE_PATH);
+        std::fs::create_dir_all(&*WORK_DIR)?;
         Database::new(SqliteConnectionManager::file(path), None)
     }
 

src/db/mod.rs

@@ -1,18 +1,13 @@
 #![recursion_limit = "256"]
 #![allow(clippy::needless_pass_by_value, clippy::new_ret_no_self)]
 
-#[macro_use(slog_o, slog_info, slog_error, slog_warn)]
-extern crate slog;
-#[macro_use]
-extern crate slog_scope;
 #[cfg_attr(test, macro_use)]
 extern crate toml;
 
 pub mod actions;
 pub mod agent;
 mod assets;
-#[macro_use]
-pub mod log;
+pub mod logs;
 #[macro_use]
 pub mod utils;
 pub mod config;

src/lib.rs

@@ -0,0 +1,89 @@
+mod storage;
+
+use crate::prelude::*;
+use log::{Log, Metadata, Record};
+use std::cell::RefCell;
+use std::thread::LocalKey;
+
+pub(crate) use self::storage::LogStorage;
+
+thread_local! {
+    static SCOPED: RefCell<Vec<Box<Log>>> = RefCell::new(Vec::new());
+}
+
+struct MultiLogger {
+    global: Vec<Box<Log>>,
+    scoped: &'static LocalKey<RefCell<Vec<Box<Log>>>>,
+}
+
+impl MultiLogger {
+    fn new(global: Vec<Box<Log>>, scoped: &'static LocalKey<RefCell<Vec<Box<Log>>>>) -> Self {
+        MultiLogger { global, scoped }
+    }
+
+    fn each<F: FnMut(&Log)>(&self, mut f: F) {
+        for logger in &self.global {
+            f(logger.as_ref());
+        }
+        self.scoped.with(|scoped| {
+            for logger in &*scoped.borrow() {
+                f(logger.as_ref());
+            }
+        });
+    }
+}
+
+impl Log for MultiLogger {
+    fn enabled(&self, metadata: &Metadata) -> bool {
+        let mut result = false;
+        self.each(|logger| {
+            if logger.enabled(metadata) {
+                result = true;
+            }
+        });
+        result
+    }
+
+    fn log(&self, record: &Record) {
+        self.each(|logger| {
+            logger.log(record);
+        });
+    }
+
+    fn flush(&self) {
+        self.each(|logger| {
+            logger.flush();
+        });
+    }
+}
+
+pub fn capture<F, R, L>(storage: &L, f: F) -> Fallible<R>
+where
+    F: FnOnce() -> Fallible<R>,
+    L: Log + Clone + 'static,
+{
+    let storage = Box::new(storage.clone());
+    SCOPED.with(|scoped| scoped.borrow_mut().push(storage));
+    let result = f();
+    SCOPED.with(|scoped| {
+        let _ = scoped.borrow_mut().pop();
+    });
+    result
+}
+
+pub fn init() -> Fallible<()> {
+    // Initialize env_logger
+    // This doesn't use from_default_env() because it doesn't allow to override filter_module()
+    // with the RUST_LOG environment variable
+    let mut env = env_logger::Builder::new();
+    env.filter_module("crater", log::LevelFilter::Info);
+    if let Ok(content) = std::env::var("RUST_LOG") {
+        env.parse(&content);
+    }
+
+    let multi = MultiLogger::new(vec![Box::new(env.build())], &SCOPED);
+    log::set_boxed_logger(Box::new(multi))?;
+    log::set_max_level(log::LevelFilter::Trace);
+
+    Ok(())
+}

src/log.rs

@@ -0,0 +1,58 @@
+use log::{Level, LevelFilter, Log, Metadata, Record};
+use std::fmt;
+use std::sync::{Arc, Mutex};
+
+struct StoredRecord {
+    level: Level,
+    message: String,
+}
+
+struct InnerStorage {
+    records: Vec<StoredRecord>,
+}
+
+#[derive(Clone)]
+pub(crate) struct LogStorage {
+    inner: Arc<Mutex<InnerStorage>>,
+    min_level: LevelFilter,
+}
+
+impl LogStorage {
+    pub(crate) fn new(min_level: LevelFilter) -> Self {
+        LogStorage {
+            inner: Arc::new(Mutex::new(InnerStorage {
+                records: Vec::new(),
+            })),
+            min_level,
+        }
+    }
+}
+
+impl Log for LogStorage {
+    fn enabled(&self, metadata: &Metadata) -> bool {
+        metadata.level() > self.min_level
+    }
+
+    fn log(&self, record: &Record) {
+        if record.level() > self.min_level {
+            return;
+        }
+        let mut inner = self.inner.lock().unwrap();
+        inner.records.push(StoredRecord {
+            level: record.level(),
+            message: record.args().to_string(),
+        });
+    }
+
+    fn flush(&self) {}
+}
+
+impl fmt::Display for LogStorage {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let inner = self.inner.lock().unwrap();
+        for record in &inner.records {
+            writeln!(f, "[{}] {}", record.level, record.message)?;
+        }
+        Ok(())
+    }
+}

src/logs/mod.rs

@@ -1,11 +1,7 @@
-#[macro_use(slog_info)]
-extern crate slog;
-#[macro_use]
-extern crate slog_scope;
-
+use log::info;
 mod cli;
 
-use crater::{log, utils};
+use crater::{logs, utils};
 use failure::Fallible;
 use std::panic;
 use std::process;
@@ -15,7 +11,7 @@ fn main() {
     // Ignore errors loading `.env` file.
     let _ = dotenv::dotenv();
 
-    let _guard = log::init();
+    let _guard = logs::init();
     let success = match panic::catch_unwind(main_) {
         Ok(Ok(())) => true,
         Ok(Err(e)) => {
@@ -35,7 +31,6 @@ fn main() {
             "command failed"
         }
     );
-    log::finish();
     process::exit(if success { 0 } else { 1 });
 }
 

src/logs/storage.rs

@@ -1,6 +1,7 @@
 use failure::Context;
 pub use failure::{bail, err_msg, Fail, Fallible, ResultExt};
 pub use lazy_static::lazy_static;
+pub use log::{debug, error, info, trace, warn};
 pub use serde_derive::{Deserialize, Serialize};
 
 pub trait FailExt {