Remove log_impl::Output and replace it with Box<dyn Log>

Author: piegamesde

src/builders.rs

@@ -414,79 +414,79 @@ impl Dispatch {
 
         let output = children
             .into_iter()
-            .flat_map(|child| match child {
+            .filter_map(|child| match child {
                 OutputInner::Stdout { stream, line_sep } => {
                     max_child_level = log::LevelFilter::Trace;
-                    Some(log_impl::Output::Stdout(log_impl::Stdout {
+                    Some(Box::new(log_impl::Stdout {
                         stream,
                         line_sep,
-                    }))
+                    }) as Box<dyn Log>)
                 }
                 OutputInner::Stderr { stream, line_sep } => {
                     max_child_level = log::LevelFilter::Trace;
-                    Some(log_impl::Output::Stderr(log_impl::Stderr {
+                    Some(Box::new(log_impl::Stderr {
                         stream,
                         line_sep,
                     }))
                 }
                 OutputInner::File { stream, line_sep } => {
                     max_child_level = log::LevelFilter::Trace;
-                    Some(log_impl::Output::File(log_impl::File {
+                    Some(Box::new(log_impl::File {
                         stream: Mutex::new(io::BufWriter::new(stream)),
                         line_sep,
                     }))
                 }
                 OutputInner::Writer { stream, line_sep } => {
                     max_child_level = log::LevelFilter::Trace;
-                    Some(log_impl::Output::Writer(log_impl::Writer {
+                    Some(Box::new(log_impl::Writer {
                         stream: Mutex::new(stream),
                         line_sep,
                     }))
                 }
                 #[cfg(all(not(windows), feature = "reopen-03"))]
                 OutputInner::Reopen { stream, line_sep } => {
                     max_child_level = log::LevelFilter::Trace;
-                    Some(log_impl::Output::Reopen(log_impl::Reopen {
+                    Some(Box::new(log_impl::Reopen {
                         stream: Mutex::new(stream),
                         line_sep,
                     }))
                 }
                 OutputInner::Sender { stream, line_sep } => {
                     max_child_level = log::LevelFilter::Trace;
-                    Some(log_impl::Output::Sender(log_impl::Sender {
+                    Some(Box::new(log_impl::Sender {
                         stream: Mutex::new(stream),
                         line_sep,
                     }))
                 }
                 #[cfg(all(not(windows), feature = "syslog-3"))]
                 OutputInner::Syslog3(log) => {
                     max_child_level = log::LevelFilter::Trace;
-                    Some(log_impl::Output::Syslog3(log_impl::Syslog3 { inner: log }))
+                    Some(Box::new(log_impl::Syslog3 { inner: log }))
                 }
                 #[cfg(all(not(windows), feature = "syslog-4"))]
                 OutputInner::Syslog4Rfc3164(logger) => {
                     max_child_level = log::LevelFilter::Trace;
-                    Some(log_impl::Output::Syslog4Rfc3164(log_impl::Syslog4Rfc3164 {
+                    Some(Box::new(log_impl::Syslog4Rfc3164 {
                         inner: Mutex::new(logger),
                     }))
                 }
                 #[cfg(all(not(windows), feature = "syslog-4"))]
                 OutputInner::Syslog4Rfc5424 { logger, transform } => {
                     max_child_level = log::LevelFilter::Trace;
-                    Some(log_impl::Output::Syslog4Rfc5424(log_impl::Syslog4Rfc5424 {
+                    Some(Box::new(log_impl::Syslog4Rfc5424 {
                         inner: Mutex::new(logger),
                         transform,
                     }))
                 }
                 OutputInner::Panic => {
                     max_child_level = log::LevelFilter::Trace;
-                    Some(log_impl::Output::Panic(log_impl::Panic))
+                    Some(Box::new(log_impl::Panic))
                 }
                 OutputInner::Dispatch(child_dispatch) => {
                     let (child_level, child) = child_dispatch.into_dispatch();
                     if child_level > log::LevelFilter::Off {
                         max_child_level = cmp::max(max_child_level, child_level);
-                        Some(log_impl::Output::Dispatch(child))
+                        Some(Box::new(child))
                     } else {
                         None
                     }
@@ -499,18 +499,18 @@ impl Dispatch {
 
                     if child_level > log::LevelFilter::Off {
                         max_child_level = cmp::max(max_child_level, child_level);
-                        Some(log_impl::Output::SharedDispatch(child))
+                        Some(Box::new(log_impl::LogWrapper::<_, log_impl::Dispatch>(child, Default::default())))
                     } else {
                         None
                     }
                 }
                 OutputInner::OtherBoxed(child_log) => {
                     max_child_level = log::LevelFilter::Trace;
-                    Some(log_impl::Output::OtherBoxed(child_log))
+                    Some(Box::new(child_log))
                 }
                 OutputInner::OtherStatic(child_log) => {
                     max_child_level = log::LevelFilter::Trace;
-                    Some(log_impl::Output::OtherStatic(child_log))
+                    Some(Box::new(log_impl::LogRef(child_log)))
                 }
                 #[cfg(feature = "date-based")]
                 OutputInner::DateBased { config } => {
@@ -532,7 +532,7 @@ impl Dispatch {
                     // ignore errors - we'll just retry later.
                     let initial_file = config.open_current_log_file(&computed_suffix).ok();
 
-                    Some(log_impl::Output::DateBased(log_impl::DateBased {
+                    Some(Box::new(log_impl::DateBased {
                         config,
                         state: Mutex::new(DateBasedState::new(computed_suffix, initial_file)),
                     }))

src/log_impl.rs

@@ -1,9 +1,10 @@
+use std::borrow::Borrow;
 use std::{
     borrow::Cow,
     collections::HashMap,
     fmt, fs,
     io::{self, BufWriter, Write},
-    sync::{mpsc, Arc, Mutex},
+    sync::{mpsc, Mutex},
 };
 
 #[cfg(feature = "date-based")]
@@ -29,7 +30,7 @@ pub enum LevelConfiguration {
 }
 
 pub struct Dispatch {
-    pub output: Vec<Output>,
+    pub output: Vec<Box<dyn Log>>,
     pub default_level: log::LevelFilter,
     pub levels: LevelConfiguration,
     pub format: Option<Box<Formatter>>,
@@ -57,29 +58,6 @@ pub struct FormatCallback<'a>(InnerFormatCallback<'a>);
 
 struct InnerFormatCallback<'a>(&'a mut bool, &'a Dispatch, &'a log::Record<'a>);
 
-pub enum Output {
-    Stdout(Stdout),
-    Stderr(Stderr),
-    File(File),
-    Sender(Sender),
-    #[cfg(all(not(windows), feature = "syslog-3"))]
-    Syslog3(Syslog3),
-    #[cfg(all(not(windows), feature = "syslog-4"))]
-    Syslog4Rfc3164(Syslog4Rfc3164),
-    #[cfg(all(not(windows), feature = "syslog-4"))]
-    Syslog4Rfc5424(Syslog4Rfc5424),
-    Dispatch(Dispatch),
-    SharedDispatch(Arc<Dispatch>),
-    OtherBoxed(Box<dyn Log>),
-    OtherStatic(&'static dyn Log),
-    Panic(Panic),
-    Writer(Writer),
-    #[cfg(feature = "date-based")]
-    DateBased(DateBased),
-    #[cfg(all(not(windows), feature = "reopen-03"))]
-    Reopen(Reopen),
-}
-
 pub struct Stdout {
     pub stream: io::Stdout,
     pub line_sep: Cow<'static, str>,
@@ -131,6 +109,42 @@ pub struct Syslog4Rfc5424 {
     >,
 }
 
+// TODO this causes an unnecessary double indirect call.
+// See https://github.com/rust-lang/log/issues/458
+pub struct LogRef(pub &'static dyn Log);
+
+impl Log for LogRef {
+    fn enabled(&self, meta: &log::Metadata<'_>) -> bool {
+        self.0.enabled(meta)
+    }
+    fn log(&self, record: &log::Record<'_>) {
+        self.0.log(record)
+    }
+    fn flush(&self) {
+        self.0.flush()
+    }
+}
+
+// TODO this causes an unnecessary double indirect call.
+// See https://github.com/rust-lang/log/issues/458
+pub struct LogWrapper<T: Borrow<R>, R: Log>(pub T, pub std::marker::PhantomData<R>);
+
+impl<R, T> Log for LogWrapper<T, R>
+where
+    T: Borrow<R> + Send + Sync,
+    R: Log,
+{
+    fn enabled(&self, meta: &log::Metadata<'_>) -> bool {
+        self.0.borrow().enabled(meta)
+    }
+    fn log(&self, record: &log::Record<'_>) {
+        self.0.borrow().log(record)
+    }
+    fn flush(&self) {
+        self.0.borrow().flush()
+    }
+}
+
 pub struct Panic;
 
 pub struct Null;
@@ -293,83 +307,6 @@ impl LevelConfiguration {
     }
 }
 
-impl Log for Output {
-    fn enabled(&self, metadata: &log::Metadata) -> bool {
-        match *self {
-            Output::Stdout(ref s) => s.enabled(metadata),
-            Output::Stderr(ref s) => s.enabled(metadata),
-            Output::File(ref s) => s.enabled(metadata),
-            Output::Sender(ref s) => s.enabled(metadata),
-            Output::Dispatch(ref s) => s.enabled(metadata),
-            Output::SharedDispatch(ref s) => s.enabled(metadata),
-            Output::OtherBoxed(ref s) => s.enabled(metadata),
-            Output::OtherStatic(ref s) => s.enabled(metadata),
-            #[cfg(all(not(windows), feature = "syslog-3"))]
-            Output::Syslog3(ref s) => s.enabled(metadata),
-            #[cfg(all(not(windows), feature = "syslog-4"))]
-            Output::Syslog4Rfc3164(ref s) => s.enabled(metadata),
-            #[cfg(all(not(windows), feature = "syslog-4"))]
-            Output::Syslog4Rfc5424(ref s) => s.enabled(metadata),
-            Output::Panic(ref s) => s.enabled(metadata),
-            Output::Writer(ref s) => s.enabled(metadata),
-            #[cfg(feature = "date-based")]
-            Output::DateBased(ref s) => s.enabled(metadata),
-            #[cfg(all(not(windows), feature = "reopen-03"))]
-            Output::Reopen(ref s) => s.enabled(metadata),
-        }
-    }
-
-    fn log(&self, record: &log::Record) {
-        match *self {
-            Output::Stdout(ref s) => s.log(record),
-            Output::Stderr(ref s) => s.log(record),
-            Output::File(ref s) => s.log(record),
-            Output::Sender(ref s) => s.log(record),
-            Output::Dispatch(ref s) => s.log(record),
-            Output::SharedDispatch(ref s) => s.log(record),
-            Output::OtherBoxed(ref s) => s.log(record),
-            Output::OtherStatic(ref s) => s.log(record),
-            #[cfg(all(not(windows), feature = "syslog-3"))]
-            Output::Syslog3(ref s) => s.log(record),
-            #[cfg(all(not(windows), feature = "syslog-4"))]
-            Output::Syslog4Rfc3164(ref s) => s.log(record),
-            #[cfg(all(not(windows), feature = "syslog-4"))]
-            Output::Syslog4Rfc5424(ref s) => s.log(record),
-            Output::Panic(ref s) => s.log(record),
-            Output::Writer(ref s) => s.log(record),
-            #[cfg(feature = "date-based")]
-            Output::DateBased(ref s) => s.log(record),
-            #[cfg(all(not(windows), feature = "reopen-03"))]
-            Output::Reopen(ref s) => s.log(record),
-        }
-    }
-
-    fn flush(&self) {
-        match *self {
-            Output::Stdout(ref s) => s.flush(),
-            Output::Stderr(ref s) => s.flush(),
-            Output::File(ref s) => s.flush(),
-            Output::Sender(ref s) => s.flush(),
-            Output::Dispatch(ref s) => s.flush(),
-            Output::SharedDispatch(ref s) => s.flush(),
-            Output::OtherBoxed(ref s) => s.flush(),
-            Output::OtherStatic(ref s) => s.flush(),
-            #[cfg(all(not(windows), feature = "syslog-3"))]
-            Output::Syslog3(ref s) => s.flush(),
-            #[cfg(all(not(windows), feature = "syslog-4"))]
-            Output::Syslog4Rfc3164(ref s) => s.flush(),
-            #[cfg(all(not(windows), feature = "syslog-4"))]
-            Output::Syslog4Rfc5424(ref s) => s.flush(),
-            Output::Panic(ref s) => s.flush(),
-            Output::Writer(ref s) => s.flush(),
-            #[cfg(feature = "date-based")]
-            Output::DateBased(ref s) => s.flush(),
-            #[cfg(all(not(windows), feature = "reopen-03"))]
-            Output::Reopen(ref s) => s.flush(),
-        }
-    }
-}
-
 impl Log for Null {
     fn enabled(&self, _: &log::Metadata) -> bool {
         false