1 files changed, 35 insertions, 58 deletions

diff --git a/util/flashrom_tester/src/logger.rs b/util/flashrom_tester/src/logger.rs
index e1c00f5de..c9c364066 100644
--- a/util/flashrom_tester/src/logger.rs
+++ b/util/flashrom_tester/src/logger.rs
@@ -35,105 +35,81 @@
 
 use flashrom_tester::types;
 use std::io::Write;
-use std::path::PathBuf;
-use std::sync::Mutex;
 
-struct Logger<W: Write + Send> {
+struct Logger {
     level: log::LevelFilter,
-    target: LogTarget<W>,
+    color: types::Color,
 }
 
-enum LogTarget<W>
-where
-    W: Write,
-{
-    Terminal,
-    Write(Mutex<W>),
-}
-
-impl<W: Write + Send> log::Log for Logger<W> {
+impl log::Log for Logger {
     fn enabled(&self, metadata: &log::Metadata) -> bool {
         metadata.level() <= self.level
     }
 
     fn log(&self, record: &log::Record) {
-        fn log_internal<W: Write>(mut w: W, record: &log::Record) -> std::io::Result<()> {
-            let now = chrono::Local::now();
-            write!(w, "{}{} ", types::MAGENTA, now.format("%Y-%m-%dT%H:%M:%S"))?;
-            write!(
-                w,
-                "{}[ {} ]{} ",
-                types::YELLOW,
-                record.level(),
-                types::RESET
-            )?;
-            writeln!(w, "{}", record.args())
-        }
-
         // Write errors deliberately ignored
-        let _ = match self.target {
-            LogTarget::Terminal => {
-                let stdout = std::io::stdout();
-                let mut lock = stdout.lock();
-                log_internal(&mut lock, record)
-            }
-            LogTarget::Write(ref mutex) => {
-                let mut lock = mutex.lock().unwrap();
-                log_internal(&mut *lock, record)
-            }
-        };
+        let stdout = std::io::stdout();
+        let mut lock = stdout.lock();
+        let now = chrono::Utc::now().to_rfc3339_opts(chrono::SecondsFormat::Micros, true);
+        let _ = write!(lock, "{}{} ", self.color.magenta, now);
+        let _ = write!(
+            lock,
+            "{}[ {} ]{} ",
+            self.color.yellow,
+            record.level(),
+            self.color.reset
+        );
+        let _ = writeln!(lock, "{}", record.args());
     }
 
     fn flush(&self) {
         // Flush errors deliberately ignored
-        let _ = match self.target {
-            LogTarget::Terminal => std::io::stdout().flush(),
-            LogTarget::Write(ref w) => w.lock().unwrap().flush(),
-        };
+        let _ = std::io::stdout().flush();
     }
 }
 
-pub fn init(to_file: Option<PathBuf>, debug: bool) {
+pub fn init(debug: bool) {
     let mut logger = Logger {
         level: log::LevelFilter::Info,
-        target: LogTarget::Terminal,
+        color: if atty::is(atty::Stream::Stdout) {
+            types::COLOR
+        } else {
+            types::NOCOLOR
+        },
     };
 
     if debug {
         logger.level = log::LevelFilter::Debug;
     }
-    if let Some(path) = to_file {
-        logger.target = LogTarget::Write(Mutex::new(
-            std::fs::File::create(path).expect("Unable to open log file for writing"),
-        ));
-    }
-
     log::set_max_level(logger.level);
     log::set_boxed_logger(Box::new(logger)).unwrap();
 }
 
 #[cfg(test)]
 mod tests {
-    use super::{LogTarget, Logger};
+    use std::io::Read;
+
+    use super::Logger;
+    use flashrom_tester::types;
     use log::{Level, LevelFilter, Log, Record};
-    use std::sync::Mutex;
 
     fn run_records(records: &[Record]) -> String {
-        let mut buf = Vec::<u8>::new();
+        let buf = gag::BufferRedirect::stdout().unwrap();
         {
-            let lock = Mutex::new(&mut buf);
             let logger = Logger {
                 level: LevelFilter::Info,
-                target: LogTarget::Write(lock),
+                color: types::COLOR,
             };
 
             for record in records {
                 if logger.enabled(record.metadata()) {
-                    logger.log(&record);
+                    logger.log(record);
                 }
             }
         }
-        String::from_utf8(buf).unwrap()
+        let mut ret = String::new();
+        buf.into_inner().read_to_string(&mut ret).unwrap();
+        ret
     }
 
     /// Log messages have the expected format
@@ -146,9 +122,10 @@ mod tests {
 
         assert_eq!(&buf[..5], "\x1b[35m");
         // Time is difficult to test, assume it's formatted okay
+        // Split on the UTC timezone char
         assert_eq!(
-            &buf[24..],
-            " \x1b[33m[ INFO ]\x1b[0m Test message at INFO\n"
+            buf.split_once("Z ").unwrap().1,
+            "\x1b[33m[ INFO ]\x1b[0m Test message at INFO\n"
         );
     }