Implement logger adapter

Author: kstrafe

Cargo.toml

@@ -34,6 +34,7 @@ env_logger = { version = "0.6", optional = true }
 [dev-dependencies]
 bincode = "1.0"
 criterion = "0.2"
+fast-logger = "0.5.0"
 serde = "1.0"
 serde_derive = "1.0"
 quickcheck = "0.8"

src/config.rs

@@ -1,5 +1,6 @@
+use crate::log;
 use crate::net::constants::{DEFAULT_MTU, FRAGMENT_SIZE_DEFAULT, MAX_FRAGMENTS_DEFAULT};
-use std::{default::Default, time::Duration};
+use std::{default::Default, rc::Rc, time::Duration};
 
 #[derive(Clone, Debug)]
 /// Contains the configuration options to configure laminar for special use-cases.
@@ -54,6 +55,8 @@ pub struct Config {
     /// When we send a reliable packet, it is stored locally until an acknowledgement comes back to
     /// us, if that store grows to a size
     pub max_packets_in_flight: u16,
+    /// Logger used for this instance of laminar. See [log::LaminarLogger] for more details.
+    pub logger: Rc<dyn log::LaminarLogger>,
 }
 
 impl Default for Config {
@@ -72,6 +75,7 @@ impl Default for Config {
             socket_event_buffer_size: 1024,
             socket_polling_timeout: Some(Duration::from_millis(1)),
             max_packets_in_flight: 512,
+            logger: Rc::new(log::DefaultLogger),
         }
     }
 }

src/lib.rs

@@ -26,6 +26,7 @@ mod config;
 mod either;
 mod error;
 mod infrastructure;
+pub mod log;
 mod net;
 mod packet;
 mod protocol_version;

src/log.rs

@@ -0,0 +1,104 @@
+//! Logging adapter for Laminar
+//!
+//! This module implements a simple, threaded-logger-friendly logging adapter. Logging adapters are
+//! used to attach an arbitrary logger into Laminar.
+use std::fmt;
+use std::sync::Arc;
+
+/// Logger trait for laminar
+///
+/// Any user of Laminar can implement this trait to attach their favorite logger to an instance of
+/// laminar. The log levels correspond to the same log levels as in the `log` crate.
+pub trait LaminarLogger {
+    /// Log a trace message
+    fn trace(&self, disp: Displayer);
+    /// Log a debug message
+    fn debug(&self, disp: Displayer);
+    /// Log an info message
+    fn info(&self, disp: Displayer);
+    /// Log a warning message
+    fn warn(&self, disp: Displayer);
+    /// Log an error message
+    fn error(&self, disp: Displayer);
+}
+
+// ---
+
+/// Holds a handle to a formatter function while implementing the [fmt::Display] trait.
+pub struct Displayer {
+    data: Arc<dyn Fn(&mut ::std::fmt::Formatter) -> ::std::fmt::Result + Send + Sync>,
+}
+
+impl Displayer {
+    pub(crate) fn new(
+        delegate: Arc<dyn Fn(&mut ::std::fmt::Formatter) -> ::std::fmt::Result + Send + Sync>,
+    ) -> Self {
+        Self { data: delegate }
+    }
+}
+
+impl fmt::Display for Displayer {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        (self.data)(f)
+    }
+}
+
+// ---
+
+pub(crate) struct DefaultLogger;
+
+impl LaminarLogger for DefaultLogger {
+    fn trace(&self, _: Displayer) {}
+    fn debug(&self, _: Displayer) {}
+    fn info(&self, _: Displayer) {}
+    fn warn(&self, _: Displayer) {}
+    fn error(&self, _: Displayer) {}
+}
+
+impl fmt::Debug for dyn LaminarLogger {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write![f, "LaminarLogger"]
+    }
+}
+
+// ---
+
+/// Format-friendly form of [log::LaminarLogger::trace]
+#[macro_export]
+macro_rules! trace {
+    ($logger:expr, $($fmt:expr),* $(,)?) => {{
+        $logger.trace($crate::log::Displayer::new(::std::sync::Arc::new(move |f: &mut ::std::fmt::Formatter| { write![f, $($fmt),*] }) ));
+    }};
+}
+
+/// Format-friendly form of [log::LaminarLogger::debug]
+#[macro_export]
+macro_rules! debug {
+    ($logger:expr, $($fmt:expr),* $(,)?) => {{
+        $logger.debug($crate::log::Displayer::new(::std::sync::Arc::new(move |f: &mut ::std::fmt::Formatter| { write![f, $($fmt),*] }) ));
+    }};
+}
+
+/// Format-friendly form of [log::LaminarLogger::info]
+#[macro_export]
+macro_rules! info {
+    ($logger:expr, $($fmt:expr),* $(,)?) => {{
+        $logger.info($crate::log::Displayer::new(::std::sync::Arc::new(move |f: &mut ::std::fmt::Formatter| { write![f, $($fmt),*] }) ));
+    }};
+}
+
+/// Format-friendly form of [log::LaminarLogger::warn]
+#[macro_export]
+macro_rules! warn {
+    ($logger:expr, $($fmt:expr),* $(,)?) => {{
+        $logger.warn($crate::log::Displayer::new(::std::sync::Arc::new(move |f: &mut ::std::fmt::Formatter| { write![f, $($fmt),*] }) ));
+    }};
+}
+
+/// Format-friendly form of [log::LaminarLogger::error]
+#[macro_export]
+macro_rules! error {
+    ($logger:expr, $($fmt:expr),* $(,)?) => {{
+        $logger.error($crate::log::Displayer::new(::std::sync::Arc::new(move |f: &mut ::std::fmt::Formatter| { write![f, $($fmt),*] }) ));
+    }};
+}

src/net/socket.rs

@@ -1204,4 +1204,44 @@ mod tests {
 
         assert_eq!["99999", last_payload];
     }
+
+    #[test]
+    fn log_adapter() {
+        use crate::log::{Displayer, LaminarLogger};
+        use fast_logger::Logger;
+        use std::{cell::RefCell, rc::Rc};
+
+        let mut cfg = Config::default();
+
+        struct MyAdapter {
+            logger: RefCell<Logger<Displayer>>,
+        }
+
+        impl LaminarLogger for MyAdapter {
+            fn trace(&self, disp: Displayer) {
+                self.logger.borrow_mut().trace(disp);
+            }
+            fn debug(&self, disp: Displayer) {
+                self.logger.borrow_mut().debug(disp);
+            }
+            fn info(&self, disp: Displayer) {
+                self.logger.borrow_mut().info(disp);
+            }
+            fn warn(&self, disp: Displayer) {
+                self.logger.borrow_mut().warn(disp);
+            }
+            fn error(&self, disp: Displayer) {
+                self.logger.borrow_mut().error(disp);
+            }
+        }
+
+        let mut logger = Logger::<Displayer>::spawn("laminar");
+        logger.set_colorize(true);
+
+        cfg.logger = Rc::new(MyAdapter {
+            logger: RefCell::new(logger),
+        });
+
+        Socket::bind_any_with_config(cfg).unwrap();
+    }
 }