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(())
  }