Support forwarding structured data to log implementation

kv.rs

@@ -1,5 +1,7 @@
 use log::kv::value::Error as ValueError;
-use slog::{Record, Serializer};
+use slog::{Record, Serializer, KV};
+
+use std::fmt::Arguments;
 
 struct Visitor<'s> {
     serializer: &'s mut dyn Serializer,
@@ -60,7 +62,7 @@ impl<'s> log::kv::value::Visit<'s> for KeyVisit<'s> {
     visit_to_emit!(&(dyn std::error::Error + 'static): visit_error -> emit_error);
 }
 
-impl slog::KV for SourceKV<'_> {
+impl KV for SourceKV<'_> {
     fn serialize(&self, _record: &Record, serializer: &mut dyn Serializer) -> slog::Result {
         // Unfortunately, there isn't  a way for use to pass the original error through.
         self.0
@@ -79,4 +81,96 @@ fn to_value_err(err: slog::Error) -> ValueError {
     }
 }
 
-// TODO: support going the other way
+/// Create a [`log::kv::Source`] for the key-value pairs for a slog record.
+pub(crate) fn get_kv_source<'a>(
+    record: &'a slog::Record<'a>,
+    logger_kv: &'a slog::OwnedKVList,
+) -> std::io::Result<Vec<(String, OwnedValue)>> {
+    let mut serialized_source = LogSerializer(vec![]);
+
+    record.kv().serialize(record, &mut serialized_source)?;
+    logger_kv.serialize(record, &mut serialized_source)?;
+    Ok(serialized_source.0)
+}
+
+/// A wrapper around [`log::kv::Value`], that owns the data included.
+///
+/// In particular this is necessary for strings, and large integers (u128, and i128), because the
+/// `Value` type itself only supports references, which must survive for the lifetime of the
+/// visitor.
+pub(crate) enum OwnedValue {
+    Value(log::kv::Value<'static>),
+    Str(String),
+    U128(Box<u128>),
+    I128(Box<i128>),
+}
+
+impl log::kv::value::ToValue for OwnedValue {
+    fn to_value(&self) -> log::kv::Value<'_> {
+        use OwnedValue::*;
+
+        match self {
+            Value(v) => v.to_value(),
+            Str(s) => s.to_value(),
+            U128(v) => v.to_value(),
+            I128(v) => v.to_value(),
+        }
+    }
+}
+
+struct LogSerializer(Vec<(String, OwnedValue)>);
+
+impl LogSerializer {
+    fn add(&mut self, key: slog::Key, val: OwnedValue) -> slog::Result {
+        self.0.push((key.into(), val));
+        Ok(())
+    }
+}
+
+macro_rules! emit_to_value {
+    ($f:ident : $t:ty) => {
+        fn $f(&mut self, key: slog::Key, val: $t) -> slog::Result {
+            self.add(key, OwnedValue::Value(val.into()))
+        }
+    };
+}
+
+impl Serializer for LogSerializer {
+    fn emit_arguments(&mut self, key: slog::Key, val: &Arguments<'_>) -> slog::Result {
+        self.add(key, OwnedValue::Str(val.to_string()))
+    }
+
+    emit_to_value!(emit_usize: usize);
+    emit_to_value!(emit_isize: isize);
+    emit_to_value!(emit_bool: bool);
+    emit_to_value!(emit_char: char);
+    emit_to_value!(emit_u8: u8);
+    emit_to_value!(emit_i8: i8);
+    emit_to_value!(emit_u16: u16);
+    emit_to_value!(emit_i16: i16);
+    emit_to_value!(emit_u32: u32);
+    emit_to_value!(emit_i32: i32);
+    emit_to_value!(emit_f32: f32);
+    emit_to_value!(emit_f64: f64);
+
+    fn emit_u128(&mut self, key: slog::Key, val: u128) -> slog::Result {
+        self.add(key, OwnedValue::U128(Box::new(val)))
+    }
+
+    fn emit_i128(&mut self, key: slog::Key, val: i128) -> slog::Result {
+        self.add(key, OwnedValue::I128(Box::new(val)))
+    }
+
+    fn emit_str(&mut self, key: slog::Key, val: &str) -> slog::Result {
+        self.add(key, OwnedValue::Str(val.to_string()))
+    }
+
+    fn emit_unit(&mut self, key: slog::Key) -> slog::Result {
+        use log::kv::ToValue;
+        self.add(key, OwnedValue::Value(().to_value()))
+    }
+
+    fn emit_none(&mut self, key: slog::Key) -> slog::Result {
+        self.emit_unit(key)
+    }
+}

lib.rs

@@ -251,31 +251,25 @@ impl slog::Drain for StdLog {
 
         let lazy = LazyLogString::new(info, logger_values);
         /*
-         * TODO: Support `log` crate key_values here.
-         *
-         * This requires the log/kv_unstable feature here.
-         *
-         * Not supporting this feature is backwards compatible
-         * and it shouldn't break anything (because we've never had),
-         * but is undesirable from a feature-completeness point of view.
-         *
-         * However, this is most likely not as powerful as slog's own
-         * notion of key/value pairs, so I would humbly suggest using `slog`
-         * directly if this feature is important to you ;)
-         *
          * This avoids using the private log::__private_api_log api function,
          * which is just a thin wrapper around a `RecordBuilder`.
          */
-        log::logger().log(
-            &log::Record::builder()
-                .args(format_args!("{}", lazy))
-                .level(level)
-                .target(target)
-                .module_path_static(Some(info.module()))
-                .file_static(Some(info.file()))
-                .line(Some(info.line()))
-                .build(),
-        );
+        let mut record_builder = log::Record::builder();
+        record_builder
+            .level(level)
+            .target(target)
+            .module_path_static(Some(info.module()))
+            .file_static(Some(info.file()))
+            .line(Some(info.line()));
+        #[cfg(feature = "kv_unstable")]
+        let source = kv::get_kv_source(info, logger_values)?;
+        #[cfg(feature = "kv_unstable")]
+        record_builder.key_values(&source);
+
+        // Due to https://github.com/rust-lang/rust/issues/92698, it is necessary to wait until we
+        // actually call `.build()` to use `format_args`. And we split that out so that we can
+        // conditionally call `key_values` based on the kv_unstable feature flag
+        log::logger().log(&record_builder.args(format_args!("{}", lazy)).build());
 
         Ok(())
     }