Make pattern_encoder feature less infectious

Cargo.toml

@@ -17,9 +17,9 @@ yaml_format = ["serde_yaml"]
 json_format = ["serde_json"]
 toml_format = ["toml"]
 
-console_appender = ["console_writer", "simple_writer", "pattern_encoder"]
-file_appender = ["parking_lot", "simple_writer", "pattern_encoder"]
-rolling_file_appender = ["parking_lot", "simple_writer", "pattern_encoder"]
+console_appender = ["console_writer", "simple_writer"]
+file_appender = ["parking_lot", "simple_writer"]
+rolling_file_appender = ["parking_lot", "simple_writer"]
 compound_policy = []
 delete_roller = []
 fixed_window_roller = []

benches/rotation.rs

@@ -1,5 +1,7 @@
-use std::thread;
-use std::time::{Duration, Instant};
+use std::{
+    thread,
+    time::{Duration, Instant},
+};
 
 use lazy_static::lazy_static;
 use tempfile::{tempdir, TempDir};
@@ -95,13 +97,14 @@ fn mk_config(file_size: u64, file_count: u32) -> log4rs::config::Config {
 
 #[derive(Debug)]
 struct Stats {
-    min: Duration,
-    max: Duration,
-    median: Duration,
+    _min: Duration,
+    _max: Duration,
+    _median: Duration,
     mean_nanos: u128,
-    variance_nanos: f64,
+    _variance_nanos: f64,
     stddev_nanos: f64,
 }
+
 impl Stats {
     fn new(measurements: &mut [Duration]) -> Self {
         measurements.sort();
@@ -121,11 +124,11 @@ impl Stats {
                 });
 
         Self {
-            min: measurements.first().unwrap().to_owned(),
-            max: measurements.last().unwrap().to_owned(),
-            median: measurements[measurements.len() / 2],
+            _min: measurements.first().unwrap().to_owned(),
+            _max: measurements.last().unwrap().to_owned(),
+            _median: measurements[measurements.len() / 2],
             mean_nanos,
-            variance_nanos,
+            _variance_nanos: variance_nanos,
             stddev_nanos: variance_nanos.sqrt(),
         }
     }

src/append/console.rs

@@ -11,13 +11,14 @@ use std::{
 
 #[cfg(feature = "config_parsing")]
 use crate::config::{Deserialize, Deserializers};
+#[cfg(feature = "pattern_encoder")]
+use crate::encode::pattern::PatternEncoder;
 #[cfg(feature = "config_parsing")]
 use crate::encode::EncoderConfig;
 use crate::{
     append::Append,
     encode::{
         self,
-        pattern::PatternEncoder,
         writer::{
             console::{ConsoleWriter, ConsoleWriterLock},
             simple::SimpleWriter,
@@ -143,6 +144,7 @@ impl ConsoleAppender {
     /// Creates a new `ConsoleAppender` builder.
     pub fn builder() -> ConsoleAppenderBuilder {
         ConsoleAppenderBuilder {
+            #[cfg(feature = "pattern_encoder")]
             encoder: None,
             target: Target::Stdout,
             tty_only: false,
@@ -152,13 +154,15 @@ impl ConsoleAppender {
 
 /// A builder for `ConsoleAppender`s.
 pub struct ConsoleAppenderBuilder {
+    #[cfg(feature = "pattern_encoder")]
     encoder: Option<Box<dyn Encode>>,
     target: Target,
     tty_only: bool,
 }
 
 impl ConsoleAppenderBuilder {
     /// Sets the output encoder for the `ConsoleAppender`.
+    #[cfg(feature = "pattern_encoder")]
     pub fn encoder(mut self, encoder: Box<dyn Encode>) -> ConsoleAppenderBuilder {
         self.encoder = Some(encoder);
         self
@@ -181,8 +185,30 @@ impl ConsoleAppenderBuilder {
     }
 
     /// Consumes the `ConsoleAppenderBuilder`, producing a `ConsoleAppender`.
+    #[cfg(feature = "pattern_encoder")]
     pub fn build(self) -> ConsoleAppender {
-        let writer = match self.target {
+        self.build_internal(|this| {
+            let encoder = this
+                .encoder
+                .unwrap_or_else(|| Box::new(PatternEncoder::default()));
+
+            (encoder, this.target, this.tty_only)
+        })
+    }
+
+    /// Consumes the `ConsoleAppenderBuilder`, producing a `ConsoleAppender`.
+    #[cfg(not(feature = "pattern_encoder"))]
+    pub fn build(self, encoder: Box<dyn Encode>) -> ConsoleAppender {
+        self.build_internal(|this| (encoder, this.target, this.tty_only))
+    }
+
+    fn build_internal<F>(self, destructure: F) -> ConsoleAppender
+    where
+        F: FnOnce(Self) -> (Box<dyn Encode>, Target, bool),
+    {
+        let (encoder, target, tty_only) = destructure(self);
+
+        let writer = match target {
             Target::Stderr => match ConsoleWriter::stderr() {
                 Some(writer) => Writer::Tty(writer),
                 None => Writer::Raw(StdWriter::stderr()),
@@ -193,13 +219,11 @@ impl ConsoleAppenderBuilder {
             },
         };
 
-        let do_write = writer.is_tty() || !self.tty_only;
+        let do_write = writer.is_tty() || !tty_only;
 
         ConsoleAppender {
             writer,
-            encoder: self
-                .encoder
-                .unwrap_or_else(|| Box::new(PatternEncoder::default())),
+            encoder,
             do_write,
         }
     }

src/append/file.rs

@@ -13,12 +13,14 @@ use std::{
 
 #[cfg(feature = "config_parsing")]
 use crate::config::{Deserialize, Deserializers};
+#[cfg(feature = "pattern_encoder")]
+use crate::encode::pattern::PatternEncoder;
 #[cfg(feature = "config_parsing")]
 use crate::encode::EncoderConfig;
 
 use crate::{
     append::Append,
-    encode::{pattern::PatternEncoder, writer::simple::SimpleWriter, Encode},
+    encode::{writer::simple::SimpleWriter, Encode},
 };
 
 /// The file appender's configuration.
@@ -31,13 +33,15 @@ pub struct FileAppenderConfig {
     append: Option<bool>,
 }
 
+type SharedFileWriter = Mutex<SimpleWriter<BufWriter<File>>>;
+
 /// An appender which logs to a file.
 #[derive(Derivative)]
 #[derivative(Debug)]
 pub struct FileAppender {
     path: PathBuf,
     #[derivative(Debug = "ignore")]
-    file: Mutex<SimpleWriter<BufWriter<File>>>,
+    file: SharedFileWriter,
     encoder: Box<dyn Encode>,
 }
 
@@ -88,24 +92,53 @@ impl FileAppenderBuilder {
     /// where 'name_here' will be the name of the environment variable that
     /// will be resolved. Note that if the variable fails to resolve,
     /// $ENV{name_here} will NOT be replaced in the path.
+    #[cfg(feature = "pattern_encoder")]
     pub fn build<P: AsRef<Path>>(self, path: P) -> io::Result<FileAppender> {
-        let path = super::env_util::expand_env_vars(path.as_ref().to_path_buf());
+        self.build_internal(path.as_ref(), |this| {
+            let encoder = this
+                .encoder
+                .unwrap_or_else(|| Box::new(PatternEncoder::default()));
+
+            (encoder, this.append)
+        })
+    }
+
+    /// Consumes the `FileAppenderBuilder`, producing a `FileAppender`.
+    /// The path argument can contain environment variables of the form $ENV{name_here},
+    /// where 'name_here' will be the name of the environment variable that
+    /// will be resolved. Note that if the variable fails to resolve,
+    /// $ENV{name_here} will NOT be replaced in the path.
+    #[cfg(not(feature = "pattern_encoder"))]
+    pub fn build<P: AsRef<Path>>(
+        self,
+        path: P,
+        encoder: Box<dyn Encode>,
+    ) -> io::Result<FileAppender> {
+        self.build_internal(path.as_ref(), |this| (encoder, this.append))
+    }
+
+    fn build_internal<F>(self, path: &Path, destructure: F) -> io::Result<FileAppender>
+    where
+        F: FnOnce(Self) -> (Box<dyn Encode>, bool),
+    {
+        let (encoder, append) = destructure(self);
+
+        let path = super::env_util::expand_env_vars(path.to_path_buf());
         if let Some(parent) = path.parent() {
             fs::create_dir_all(parent)?;
         }
+
         let file = OpenOptions::new()
             .write(true)
-            .append(self.append)
-            .truncate(!self.append)
+            .append(append)
+            .truncate(!append)
             .create(true)
             .open(&path)?;
 
         Ok(FileAppender {
             path,
             file: Mutex::new(SimpleWriter(BufWriter::with_capacity(1024, file))),
-            encoder: self
-                .encoder
-                .unwrap_or_else(|| Box::new(PatternEncoder::default())),
+            encoder,
         })
     }
 }
@@ -166,17 +199,33 @@ mod test {
     fn create_directories() {
         let tempdir = tempfile::tempdir().unwrap();
 
-        FileAppender::builder()
-            .build(tempdir.path().join("foo").join("bar").join("baz.log"))
-            .unwrap();
+        build(
+            FileAppender::builder(),
+            tempdir.path().join("foo").join("bar").join("baz.log"),
+        )
+        .unwrap();
     }
 
     #[test]
     fn append_false() {
         let tempdir = tempfile::tempdir().unwrap();
-        FileAppender::builder()
-            .append(false)
-            .build(tempdir.path().join("foo.log"))
-            .unwrap();
+
+        build(
+            FileAppender::builder().append(false),
+            tempdir.path().join("foo.log"),
+        )
+        .unwrap();
+    }
+
+    #[cfg(feature = "pattern_encoder")]
+    fn build<P: AsRef<Path>>(builder: FileAppenderBuilder, path: P) -> io::Result<FileAppender> {
+        builder.build(path)
+    }
+
+    #[cfg(not(feature = "pattern_encoder"))]
+    fn build<P: AsRef<Path>>(builder: FileAppenderBuilder, path: P) -> io::Result<FileAppender> {
+        use crate::encode::tests::DummyEncoder;
+
+        builder.build(path, Box::new(DummyEncoder))
     }
 }