init simplification

lrlna · May 18, 2020 · aa1fd83 · aa1fd83
1 parent d75ee53
commit aa1fd83
Show file tree

Hide file tree

Showing 8 changed files with 102 additions and 173 deletions.
diff --git a/examples/log_pretty.rs → examples/log.rs b/examples/log_pretty.rs → examples/log.rs
@@ -1,8 +1,7 @@
 use kv_log_macro as log;
+
 fn main() {
-    femme::pretty::Logger::new()
-        .start(::log::LevelFilter::Trace)
-        .unwrap();
+    femme::with_filter(femme::LevelFilter::Trace, Some("log"));
     log::error!("Buffer has to be 16 bytes in length");
     log::warn!("Unauthorized access attempt", { route: "/login", user_id: "827756627", });
     log::info!("Server listening", { port: "8080" });

diff --git a/examples/log_clean.rs b/examples/log_clean.rs
diff --git a/examples/log_ndjson.rs b/examples/log_ndjson.rs
diff --git a/src/clean.rs b/src/clean.rs
diff --git a/src/lib.rs b/src/lib.rs
@@ -4,22 +4,21 @@
 //!
 //! ## Examples
 //! ```
-//! femme::start(log::LevelFilter::Trace)?;
+//! femme::start();
 //! log::warn!("Unauthorized access attempt on /login");
 //! log::info!("Listening on port 8080");
 //! ```
 
-#[cfg(not(target_arch = "wasm32"))]
-pub mod ndjson;
+pub use log::LevelFilter;
 
 #[cfg(not(target_arch = "wasm32"))]
-pub mod pretty;
+mod ndjson;
 
 #[cfg(not(target_arch = "wasm32"))]
-pub mod clean;
+mod pretty;
 
 #[cfg(target_arch = "wasm32")]
-pub mod wasm;
+mod wasm;
 
 /// Starts logging depending on current environment.
 ///
@@ -32,22 +31,55 @@ pub mod wasm;
 /// # Examples
 ///
 /// ```
-/// femme::start(log::LevelFilter::Trace).unwrap();
+/// femme::start();
 /// log::warn!("Unauthorized access attempt on /login");
 /// log::info!("Listening on port 8080");
 /// ```
-pub fn start(filter: log::LevelFilter) -> Result<(), log::SetLoggerError> {
+pub fn start() {
+    with_level(LevelFilter::Info);
+}
+
+/// Start logging with a log level.
+///
+/// All messages under the specified log level will statically be filtered out.
+///
+/// # Examples
+/// ```
+/// femme::start(log::LevelFilter::Trace);
+/// ```
+pub fn with_level(level: log::LevelFilter) {
     #[cfg(target_arch = "wasm32")]
-    wasm::Logger::new().start(filter)?;
+    wasm::start(level, None);
 
     #[cfg(not(target_arch = "wasm32"))]
     {
+        // Use ndjson in release mode, pretty logging while debugging.
         if cfg!(debug_assertions) {
-            pretty::Logger::new().start(filter)?;
+            // pretty::start(level, None);
+            todo!();
         } else {
-            ndjson::Logger::new().start(filter)?;
+            ndjson::start(level, None);
         }
     }
+}
 
-    Ok(())
+/// Start logging with a log level and a filter.
+///
+/// If `None` is passed all messages are passed.
+pub fn with_filter<F>(level: log::LevelFilter, filter: Option<F>)
+where
+    F: Fn(&log::Record) -> bool + Send + Sync + 'static,
+{
+    #[cfg(target_arch = "wasm32")]
+    wasm::start(level, filter);
+
+    #[cfg(not(target_arch = "wasm32"))]
+    {
+        // Use ndjson in release mode, pretty logging while debugging.
+        if cfg!(debug_assertions) {
+            // pretty::start(level, filter);
+        } else {
+            ndjson::start(level, filter);
+        }
+    }
 }
diff --git a/src/ndjson.rs b/src/ndjson.rs
@@ -5,8 +5,23 @@ use serde_json::Value;
 use std::collections::HashMap;
 use std::time;
 
+/// Start logging.
+pub(crate) fn start<F>(level: LevelFilter, filter: Option<F>)
+where
+    F: Fn(&Record) -> bool + Send + Sync + 'static,
+{
+    let logger = Box::new(Logger { filter });
+    log::set_boxed_logger(logger).expect("Could not start logging");
+    log::set_max_level(level);
+}
+
 #[derive(Debug)]
-pub struct Logger {}
+pub(crate) struct Logger<F>
+where
+    F: Fn(&log::Record) -> bool,
+{
+    filter: Option<F>,
+}
 
 #[derive(serde_derive::Serialize)]
 struct Msg {
@@ -17,45 +32,34 @@ struct Msg {
     key_values: Option<HashMap<String, Value>>,
 }
 
-impl Logger {
-    pub fn new() -> Self {
-        Self {}
-    }
-
-    /// Start logging.
-    pub fn start(self, filter: LevelFilter) -> Result<(), log::SetLoggerError> {
-        let res = log::set_boxed_logger(Box::new(self));
-        if res.is_ok() {
-            log::set_max_level(filter);
-        }
-        res
-    }
-}
-
-impl Log for Logger {
+impl<F> Log for Logger<F>
+where
+    F: Fn(&Record) -> bool + Send + 'static + Sync,
+{
     fn enabled(&self, metadata: &Metadata<'_>) -> bool {
         metadata.level() <= log::max_level()
     }
 
     fn log(&self, record: &Record<'_>) {
         if self.enabled(record.metadata()) {
-            print_ndjson(record)
+            if let Some(filter) = &self.filter {
+                if !filter(&record) {
+                    return;
+                }
+            }
+            // TODO: implement key_values mapping
+            let msg = Msg {
+                level: get_level(record.level()),
+                key_values: format_kv_pairs(&record),
+                time: time::UNIX_EPOCH.elapsed().unwrap().as_millis(),
+                msg: record.args().to_string(),
+            };
+            println!("{}", serde_json::to_string(&msg).unwrap())
         }
     }
     fn flush(&self) {}
 }
 
-// TODO: implement key_values mapping
-fn print_ndjson(record: &Record<'_>) {
-    let msg = Msg {
-        level: get_level(record.level()),
-        key_values: format_kv_pairs(&record),
-        time: time::UNIX_EPOCH.elapsed().unwrap().as_millis(),
-        msg: record.args().to_string(),
-    };
-    println!("{}", serde_json::to_string(&msg).unwrap())
-}
-
 fn get_level(level: log::Level) -> u8 {
     use log::Level::*;
     match level {

diff --git a/src/pretty.rs b/src/pretty.rs
@@ -3,22 +3,17 @@
 use console::style;
 use log::{kv, Level, LevelFilter, Log, Metadata, Record};
 
-#[derive(Debug)]
-pub struct Logger {}
-
-impl Logger {
-    pub fn new() -> Self {
-        Self {}
-    }
+/// Start logging.
+pub(crate) fn start(level: LevelFilter, filter: Option<&str>) {
+    let filter = filter.map(|s| s.to_owned());
+    let logger = Box::new(Logger { filter });
+    log::set_boxed_logger(logger).expect("Could not start logging");
+    log::set_max_level(level);
+}
 
-    /// Start logging.
-    pub fn start(self, filter: LevelFilter) -> Result<(), log::SetLoggerError> {
-        let res = log::set_boxed_logger(Box::new(self));
-        if res.is_ok() {
-            log::set_max_level(filter);
-        }
-        res
-    }
+#[derive(Debug)]
+pub(crate) struct Logger {
+    filter: Option<String>,
 }
 
 impl Log for Logger {
@@ -28,6 +23,11 @@ impl Log for Logger {
 
     fn log(&self, record: &Record<'_>) {
         if self.enabled(record.metadata()) {
+            if let Some(filter) = &self.filter {
+                if !record.target().contains(filter) {
+                    return;
+                }
+            }
             println!(
                 "{} {}{}",
                 format_src(&record),

diff --git a/src/wasm.rs b/src/wasm.rs
@@ -6,24 +6,16 @@ use wasm_bindgen::prelude::*;
 
 use std::collections::HashMap;
 
+/// Start logging.
+pub(crate) fn start(level: LevelFilter, filter: Option<&str>) {
+    let logger = Box::new(Logger {});
+    log::set_boxed_logger(logger).expect("Could not start logging");
+    log::set_max_level(level);
+}
+
 /// A WASM logger for the browser.
 #[derive(Debug)]
-pub struct Logger {}
-
-impl Logger {
-    pub fn new() -> Self {
-        Self {}
-    }
-
-    /// Start logging.
-    pub fn start(self, filter: LevelFilter) -> Result<(), log::SetLoggerError> {
-        let res = log::set_boxed_logger(Box::new(self));
-        if res.is_ok() {
-            log::set_max_level(filter);
-        }
-        res
-    }
-}
+struct Logger {}
 
 impl Log for Logger {
     fn enabled(&self, metadata: &Metadata<'_>) -> bool {