Add basic features to CursiveLogger

cursive-core/src/logger.rs

@@ -2,14 +2,107 @@
 
 use lazy_static::lazy_static;
 use std::collections::VecDeque;
+use std::str::FromStr;
 use std::sync::Mutex;
 
 /// Saves all log records in a global deque.
 ///
 /// Uses a `DebugView` to access it.
-pub struct CursiveLogger;
+///
+/// # Examples
+///
+/// Set log levels from env vars
+///
+/// ```
+/// # use cursive_core::logger::CursiveLogger;
+/// CursiveLogger::new()
+///     .with_env()
+///     .init();
+/// ```
+///
+/// Set log levels explicitly.
+///
+/// ```
+/// # use cursive_core::logger::CursiveLogger;
+/// # use log::LevelFilter;
+/// CursiveLogger::new()
+///     .with_int_filter_level(LevelFilter::Warn)
+///     .with_ext_filter_level(LevelFilter::Debug)
+///     .init();
+/// ```
+///
+/// Set log queue size.
+///
+/// ```
+/// # use cursive_core::logger::CursiveLogger;
+/// CursiveLogger::new()
+///     .with_log_size(10_000)
+///     .init();
+/// ```
+pub struct CursiveLogger {
+    // Log filter level for log messages from within cursive
+    int_filter_level: log::LevelFilter,
+    // Log filter level for log messages from sources outside of cursive
+    ext_filter_level: log::LevelFilter,
+    // Size of log queue
+    log_size: usize,
+}
+
+impl CursiveLogger {
+    /// Creates a new CursiveLogger with default log filter levels of `log::LevelFilter::Trace`.
+    /// Remember to call `init()` to install with `log` backend.
+    pub fn new() -> Self {
+        CursiveLogger {
+            int_filter_level: log::LevelFilter::Trace,
+            ext_filter_level: log::LevelFilter::Trace,
+            log_size: 1000,
+        }
+    }
+
+    /// Sets the internal log filter level.
+    pub fn with_int_filter_level(mut self, level: log::LevelFilter) -> Self {
+        self.int_filter_level = level;
+        self
+    }
+
+    /// Sets the external log filter level.
+    pub fn with_ext_filter_level(mut self, level: log::LevelFilter) -> Self {
+        self.ext_filter_level = level;
+        self
+    }
 
-static LOGGER: CursiveLogger = CursiveLogger;
+    /// Sets log filter levels based on environment variables `RUST_LOG` and `CURSIVE_LOG`.
+    /// If `RUST_LOG` is set, then both internal and external log levels are set to match.
+    /// If `CURSIVE_LOG` is set, then the internal log level is set to match with precedence over
+    /// `RUST_LOG`.
+    pub fn with_env(mut self) -> Self {
+        if let Ok(rust_log) = std::env::var("RUST_LOG") {
+            if let Ok(filter_level) = log::LevelFilter::from_str(&rust_log) {
+                self.int_filter_level = filter_level;
+                self.ext_filter_level = filter_level;
+            }
+        }
+        if let Ok(cursive_log) = std::env::var("CURSIVE_LOG") {
+            if let Ok(filter_level) = log::LevelFilter::from_str(&cursive_log) {
+                self.int_filter_level = filter_level;
+            }
+        }
+        self
+    }
+
+    /// Sets the size of the log queue
+    pub fn with_log_size(mut self, log_size: usize) -> Self {
+        self.log_size = log_size;
+        self
+    }
+
+    /// Installs the logger with log. Calling twice will panic.
+    pub fn init(self) {
+        reserve_logs(self.log_size);
+        log::set_logger(Box::leak(Box::new(self))).unwrap();
+        log::set_max_level(log::LevelFilter::Trace);
+    }
+}
 
 /// A log record.
 pub struct Record {
@@ -44,12 +137,18 @@ pub fn log(record: &log::Record) {
 }
 
 impl log::Log for CursiveLogger {
-    fn enabled(&self, _metadata: &log::Metadata) -> bool {
-        true
+    fn enabled(&self, metadata: &log::Metadata) -> bool {
+        if metadata.target().contains("cursive_core") {
+            metadata.level() <= self.int_filter_level
+        } else {
+            metadata.level() <= self.ext_filter_level
+        }
     }
 
     fn log(&self, record: &log::Record) {
-        log(record);
+        if self.enabled(record.metadata()) {
+            log(record);
+        }
     }
 
     fn flush(&self) {}
@@ -62,14 +161,8 @@ impl log::Log for CursiveLogger {
 /// Use a [`DebugView`](crate::views::DebugView) to see the logs, or use
 /// [`Cursive::toggle_debug_console()`](crate::Cursive::toggle_debug_console()).
 pub fn init() {
-    // TODO: Configure the deque size?
-    reserve_logs(1_000);
-
     // This will panic if `set_logger` was already called.
-    log::set_logger(&LOGGER).unwrap();
-
-    // TODO: read the level from env variable? From argument?
-    log::set_max_level(log::LevelFilter::Trace);
+    CursiveLogger::new().init();
 }
 
 /// Return a logger that stores records in cursive's log queue.
@@ -78,8 +171,7 @@ pub fn init() {
 ///
 /// An easier alternative might be to use [`init()`].
 pub fn get_logger() -> CursiveLogger {
-    reserve_logs(1_000);
-    CursiveLogger
+    CursiveLogger::new()
 }
 
 /// Adds `n` more entries to cursive's log queue.