feat: properly serialize filters & appenders in RawConfig

Author: Creative-Difficulty

src/append/mod.rs

@@ -3,6 +3,7 @@
 use log::{Log, Record};
 #[cfg(feature = "config_parsing")]
 use serde::{de, Deserialize, Deserializer};
+use serde::{Serialize, Serializer};
 #[cfg(feature = "config_parsing")]
 use serde_value::Value;
 #[cfg(feature = "config_parsing")]
@@ -115,7 +116,7 @@ impl<T: Log + fmt::Debug + 'static> Append for T {
 
 /// Configuration for an appender.
 #[cfg(feature = "config_parsing")]
-#[derive(Clone, Eq, PartialEq, Hash, Debug, serde::Serialize)]
+#[derive(Clone, Eq, PartialEq, Hash, Debug)]
 pub struct AppenderConfig {
     /// The appender kind.
     pub kind: String,
@@ -151,6 +152,46 @@ impl<'de> Deserialize<'de> for AppenderConfig {
     }
 }
 
+#[cfg(feature = "config_parsing")]
+impl Serialize for AppenderConfig {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let mut map: BTreeMap<Value, Value> = BTreeMap::new();
+
+        map.insert(
+            Value::String("kind".to_string()),
+            Value::String(self.kind.clone()),
+        );
+
+        // Insert the `filters` field into the map if it's not empty
+        if !self.filters.is_empty() {
+            let filters: Vec<Value> = self
+                .filters
+                .iter()
+                .map(|f| serde_value::to_value(f).unwrap())
+                .collect();
+
+            map.insert(Value::String("filters".to_string()), Value::Seq(filters));
+        } else {
+            map.insert(
+                Value::String("filters".to_string()),
+                Value::String("[]".to_string()),
+            );
+        }
+
+        if let Value::Map(ref config_map) = self.config {
+            for (key, value) in config_map {
+                map.insert(key.clone(), value.clone());
+            }
+        }
+
+        // Serialize the map
+        map.serialize(serializer)
+    }
+}
+
 #[cfg(test)]
 mod test {
     #[cfg(any(feature = "file_appender", feature = "rolling_file_appender"))]

src/config/raw.rs

@@ -94,8 +94,12 @@ use std::{collections::HashMap, fmt, marker::PhantomData, sync::Arc, time::Durat
 use anyhow::anyhow;
 use derive_more::Debug;
 use log::LevelFilter;
-use serde::de::{self, Deserialize as SerdeDeserialize, DeserializeOwned};
+use serde::{
+    de::{self, Deserialize as SerdeDeserialize, DeserializeOwned},
+    ser,
+};
 use serde_value::Value;
+
 use thiserror::Error;
 use typemap_ors::{Key, ShareCloneMap};
 
@@ -322,6 +326,7 @@ pub enum DeserializingConfigError {
 #[serde(deny_unknown_fields)]
 pub struct RawConfig {
     #[serde(deserialize_with = "de_duration", default)]
+    #[serde(serialize_with = "ser_duration")]
     refresh_rate: Option<Duration>,
 
     #[serde(default)]
@@ -403,6 +408,19 @@ impl RawConfig {
     }
 }
 
+fn ser_duration<S>(duration: &Option<Duration>, s: S) -> Result<S::Ok, S::Error>
+where
+    S: ser::Serializer,
+{
+    match duration {
+        Some(duration) => {
+            let duration_str: String = humantime::format_duration(*duration).to_string();
+            s.serialize_some(&duration_str)
+        }
+        None => s.serialize_none(),
+    }
+}
+
 fn de_duration<'de, D>(d: D) -> Result<Option<Duration>, D::Error>
 where
     D: de::Deserializer<'de>,
@@ -481,9 +499,11 @@ mod test {
     use super::*;
     use std::fs;
 
-    const CFG: &'static str = r#"
-refresh_rate: 60 seconds
-
+    const CFG: &'static str = r#"refresh_rate: 1m
+root:
+    level: info
+    appenders:
+        - console
 appenders:
     console:
         kind: console
@@ -495,12 +515,6 @@ appenders:
         path: /tmp/baz.log
         encoder:
             pattern: "%m"
-
-root:
-    appenders:
-        - console
-    level: info
-
 loggers:
     foo::bar::baz:
         level: warn
@@ -524,10 +538,11 @@ loggers:
         let config = ::serde_yaml::from_str::<RawConfig>(CFG).unwrap();
         let errors = config.appenders_lossy(&Deserializers::new()).1;
         println!("{:?}", errors);
+        assert!(errors.is_empty());
 
         let config = ::serde_yaml::to_string::<RawConfig>(&config);
 
-        assert!(config.is_ok())
+        assert_eq!(config.unwrap(), CFG)
     }
 
     #[test]

src/filter/mod.rs

@@ -2,7 +2,7 @@
 
 use log::Record;
 #[cfg(feature = "config_parsing")]
-use serde::de;
+use serde::{de, Serialize, Serializer};
 #[cfg(feature = "config_parsing")]
 use serde_value::Value;
 #[cfg(feature = "config_parsing")]
@@ -52,7 +52,7 @@ pub enum Response {
 
 /// Configuration for a filter.
 #[cfg(feature = "config_parsing")]
-#[derive(Clone, Eq, PartialEq, Hash, Debug, serde::Serialize)]
+#[derive(Clone, Eq, PartialEq, Hash, Debug)]
 pub struct FilterConfig {
     /// The filter kind.
     pub kind: String,
@@ -80,6 +80,29 @@ impl<'de> de::Deserialize<'de> for FilterConfig {
     }
 }
 
+#[cfg(feature = "config_parsing")]
+impl Serialize for FilterConfig {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let mut map = BTreeMap::new();
+
+        map.insert(
+            Value::String("kind".to_owned()),
+            Value::String(self.kind.clone()),
+        );
+
+        if let Value::Map(ref config_map) = self.config {
+            for (key, value) in config_map {
+                map.insert(key.clone(), value.clone());
+            }
+        }
+
+        map.serialize(serializer)
+    }
+}
+
 #[cfg(test)]
 mod test {
     #[cfg(feature = "config_parsing")]