Get structured logging API ready for stabilization

Cargo.toml

@@ -48,7 +48,7 @@ std = []
 
 # requires the latest stable
 # this will have a tighter MSRV before stabilization
-kv_unstable = ["value-bag"]
+kv_unstable = []
 kv_unstable_sval = ["kv_unstable", "value-bag/sval", "sval", "sval_ref"]
 kv_unstable_std = ["std", "kv_unstable", "value-bag/error"]
 kv_unstable_serde = ["kv_unstable_std", "value-bag/serde", "serde"]
@@ -57,14 +57,15 @@ kv_unstable_serde = ["kv_unstable_std", "value-bag/serde", "serde"]
 serde = { version = "1.0", optional = true, default-features = false }
 sval = { version = "2.1", optional = true, default-features = false }
 sval_ref = { version = "2.1", optional = true, default-features = false }
-value-bag = { version = "1.4", optional = true, default-features = false }
+value-bag = { version = "1.7", optional = true, default-features = false, features = ["inline-i128"] }
 
 [dev-dependencies]
 serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
 serde_test = "1.0"
 sval = { version = "2.1" }
 sval_derive = { version = "2.1" }
-value-bag = { version = "1.4", features = ["test"] }
+value-bag = { version = "1.7", features = ["test"] }
 
 # NOTE: log doesn't actually depent on this crate. However our dependencies,
 # serde and sval, dependent on version 1.0 of the crate, which has problem fixed

README.md

@@ -103,10 +103,10 @@ The executable itself may use the `log` crate to log as well.
 If you enable the `kv_unstable` feature, you can associate structured data with your log records:
 
 ```rust
-use log::{info, trace, warn, as_serde, as_error};
+use log::{info, trace, warn};
 
 pub fn shave_the_yak(yak: &mut Yak) {
-    trace!(target = "yak_events", yak = as_serde!(yak); "Commencing yak shaving");
+    trace!(target = "yak_events", yak:serde = yak; "Commencing yak shaving");
 
     loop {
         match find_a_razor() {
@@ -116,7 +116,7 @@ pub fn shave_the_yak(yak: &mut Yak) {
                 break;
             }
             Err(err) => {
-                warn!(err = as_error!(err); "Unable to locate a razor, retrying");
+                warn!(err:error = err; "Unable to locate a razor, retrying");
             }
         }
     }

src/__private_api.rs

@@ -5,31 +5,28 @@ use crate::{Level, Metadata, Record};
 use std::fmt::Arguments;
 pub use std::{file, format_args, line, module_path, stringify};
 
-#[cfg(feature = "kv_unstable")]
-pub type Value<'a> = dyn crate::kv::value::ToValue + 'a;
-
 #[cfg(not(feature = "kv_unstable"))]
-pub type Value<'a> = str;
+pub type Value<'a> = &'a str;
 
 mod sealed {
     /// Types for the `kv` argument.
     pub trait KVs<'a> {
-        fn into_kvs(self) -> Option<&'a [(&'a str, &'a super::Value<'a>)]>;
+        fn into_kvs(self) -> Option<&'a [(&'a str, super::Value<'a>)]>;
     }
 }
 
 // Types for the `kv` argument.
 
-impl<'a> KVs<'a> for &'a [(&'a str, &'a Value<'a>)] {
+impl<'a> KVs<'a> for &'a [(&'a str, Value<'a>)] {
     #[inline]
-    fn into_kvs(self) -> Option<&'a [(&'a str, &'a Value<'a>)]> {
+    fn into_kvs(self) -> Option<&'a [(&'a str, Value<'a>)]> {
         Some(self)
     }
 }
 
 impl<'a> KVs<'a> for () {
     #[inline]
-    fn into_kvs(self) -> Option<&'a [(&'a str, &'a Value<'a>)]> {
+    fn into_kvs(self) -> Option<&'a [(&'a str, Value<'a>)]> {
         None
     }
 }
@@ -41,7 +38,7 @@ fn log_impl(
     level: Level,
     &(target, module_path, file): &(&str, &'static str, &'static str),
     line: u32,
-    kvs: Option<&[(&str, &Value)]>,
+    kvs: Option<&[(&str, Value)]>,
 ) {
     #[cfg(not(feature = "kv_unstable"))]
     if kvs.is_some() {
@@ -87,3 +84,42 @@ pub fn log<'a, K>(
 pub fn enabled(level: Level, target: &str) -> bool {
     crate::logger().enabled(&Metadata::builder().level(level).target(target).build())
 }
+
+#[cfg(feature = "kv_unstable")]
+mod kv_support {
+    use super::*;
+
+    use crate::kv;
+
+    pub type Value<'a> = kv::Value<'a>;
+
+    pub fn capture_to_value<'a, V: kv::value::ToValue + ?Sized>(v: &'a &'a V) -> Value<'a> {
+        v.to_value()
+    }
+
+    pub fn capture_debug<'a, V: core::fmt::Debug + ?Sized>(v: &'a &'a V) -> Value<'a> {
+        Value::from_debug(v)
+    }
+
+    pub fn capture_display<'a, V: core::fmt::Display + ?Sized>(v: &'a &'a V) -> Value<'a> {
+        Value::from_display(v)
+    }
+
+    #[cfg(feature = "kv_unstable_std")]
+    pub fn capture_error<'a>(v: &'a (dyn std::error::Error + 'static)) -> Value<'a> {
+        Value::from_dyn_error(v)
+    }
+
+    #[cfg(feature = "kv_unstable_sval")]
+    pub fn capture_sval<'a, V: sval::Value + ?Sized>(v: &'a &'a V) -> Value<'a> {
+        Value::from_sval(v)
+    }
+
+    #[cfg(feature = "kv_unstable_serde")]
+    pub fn capture_serde<'a, V: serde::Serialize + ?Sized>(v: &'a &'a V) -> Value<'a> {
+        Value::from_serde(v)
+    }
+}
+
+#[cfg(feature = "kv_unstable")]
+pub use self::kv_support::*;

src/kv/error.rs

@@ -11,7 +11,8 @@ enum Inner {
     #[cfg(feature = "std")]
     Boxed(std_support::BoxedError),
     Msg(&'static str),
-    Value(value_bag::Error),
+    #[cfg(feature = "value-bag")]
+    Value(crate::kv::value::inner::Error),
     Fmt,
 }
 
@@ -23,21 +24,23 @@ impl Error {
         }
     }
 
-    // Not public so we don't leak the `value_bag` API
-    pub(super) fn from_value(err: value_bag::Error) -> Self {
+    // Not public so we don't leak the `crate::kv::value::inner` API
+    #[cfg(feature = "value-bag")]
+    pub(super) fn from_value(err: crate::kv::value::inner::Error) -> Self {
         Error {
             inner: Inner::Value(err),
         }
     }
 
-    // Not public so we don't leak the `value_bag` API
-    pub(super) fn into_value(self) -> value_bag::Error {
+    // Not public so we don't leak the `crate::kv::value::inner` API
+    #[cfg(feature = "value-bag")]
+    pub(super) fn into_value(self) -> crate::kv::value::inner::Error {
         match self.inner {
             Inner::Value(err) => err,
             #[cfg(feature = "kv_unstable_std")]
-            _ => value_bag::Error::boxed(self),
+            _ => crate::kv::value::inner::Error::boxed(self),
             #[cfg(not(feature = "kv_unstable_std"))]
-            _ => value_bag::Error::msg("error inspecting a value"),
+            _ => crate::kv::value::inner::Error::msg("error inspecting a value"),
         }
     }
 }
@@ -48,6 +51,7 @@ impl fmt::Display for Error {
         match &self.inner {
             #[cfg(feature = "std")]
             Boxed(err) => err.fmt(f),
+            #[cfg(feature = "value-bag")]
             Value(err) => err.fmt(f),
             Msg(msg) => msg.fmt(f),
             Fmt => fmt::Error.fmt(f),

src/kv/key.rs

@@ -30,7 +30,7 @@ impl ToKey for str {
     }
 }
 
-/// A key in a structured key-value pair.
+/// A key in a key-value.
 // These impls must only be based on the as_str() representation of the key
 // If a new field (such as an optional index) is added to the key they must not affect comparison
 #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]