Support for capturing KV values via sval and serde

Author: SpriteOvO

.github/workflows/ci.yml

@@ -49,7 +49,7 @@ jobs:
       fail-fast: false
       matrix:
         os: ['ubuntu-latest', 'windows-latest', 'macos-latest']
-        fn_features: ['', 'log native libsystemd multi-thread runtime-pattern serde_json']
+        fn_features: ['', 'log native libsystemd multi-thread runtime-pattern serde serde_json sval']
         cfg_feature: ['', 'flexible-string', 'source-location']
     runs-on: ${{ matrix.os }}
     steps:

spdlog/Cargo.toml

@@ -37,7 +37,9 @@ native = []
 libsystemd = ["libsystemd-sys"]
 multi-thread = ["crossbeam"]
 runtime-pattern = ["spdlog-internal"]
-serde_json = ["serde", "dep:serde_json", "value-bag/serde1"]
+serde = ["dep:serde", "value-bag/serde"]
+serde_json = ["serde", "dep:serde_json"]
+sval = ["value-bag/sval"]
 
 [dependencies]
 arc-swap = "1.5.1"
@@ -74,6 +76,8 @@ crossbeam = "0.8.2"
 regex = "1.7.0"
 paste = "1.0.14"
 trybuild = "1.0.90"
+sval = "2.14.0"
+sval_derive = "2.14.0"
 
 # [bench-dependencies]
 log = "=0.4.22"

spdlog/src/kv.rs

@@ -99,6 +99,22 @@ impl<'a> KeyValues<'a> {
         }
     }
 
+    pub fn get(&self, key: Key) -> Option<Value<'a>> {
+        match self.0 {
+            KeyValuesInner::Borrowed(p) => {
+                p.iter()
+                    .find_map(|(k, v)| if k == &key { Some(v.clone()) } else { None })
+            }
+            KeyValuesInner::Owned(p) => p.iter().find_map(|(k, v)| {
+                if k.as_ref() == key {
+                    Some(v.by_ref())
+                } else {
+                    None
+                }
+            }),
+        }
+    }
+
     pub fn iter(&self) -> KeyValuesIter<'a> {
         match &self.0 {
             KeyValuesInner::Borrowed(p) => KeyValuesIter(KeyValuesIterInner::Borrowed(p.iter())),

spdlog/src/log_macros.rs

@@ -193,6 +193,8 @@ macro_rules! __kv {
     (@{$($done:tt)*} $k:ident    $(= $v:expr)? $(,$($rest:tt)*)?) => ($crate::__kv!(@{$($done)* $k [  ] $(= $v)?,} $($($rest)*)?));
     (@{$($done:tt)*} $k:ident :  $(= $v:expr)? $(,$($rest:tt)*)?) => ($crate::__kv!(@{$($done)* $k [: ] $(= $v)?,} $($($rest)*)?));
     (@{$($done:tt)*} $k:ident :? $(= $v:expr)? $(,$($rest:tt)*)?) => ($crate::__kv!(@{$($done)* $k [:?] $(= $v)?,} $($($rest)*)?));
+    (@{$($done:tt)*} $k:ident :sval $(= $v:expr)? $(,$($rest:tt)*)?) => ($crate::__kv!(@{$($done)* $k [:sval] $(= $v)?,} $($($rest)*)?));
+    (@{$($done:tt)*} $k:ident :serde $(= $v:expr)? $(,$($rest:tt)*)?) => ($crate::__kv!(@{$($done)* $k [:serde] $(= $v)?,} $($($rest)*)?));
     (@{$( $k:ident [$($modifier:tt)*] $(= $v:expr)? ),+ $(,)?}) => {
         &[$(($crate::kv::Key::__from_static_str(stringify!($k)), $crate::__kv_value!($k [$($modifier)*] $(= $v)?))),+]
     };
@@ -203,18 +205,28 @@ macro_rules! __kv {
 macro_rules! __kv_value {
     ($k:ident [$($modifier:tt)*]) => { $crate::__kv_value!($k [$($modifier)*] = $k) };
     ($k:ident [  ] = $v:expr) => { $crate::kv::Value::from(&$v) };
-    ($k:ident [: ] = $v:expr) => { $crate::kv::Value::from_display(&$v) };
-    ($k:ident [:?] = $v:expr) => { $crate::kv::Value::from_debug(&$v) };
+    ($k:ident [: ] = $v:expr) => { $crate::kv::Value::capture_display(&$v) };
+    ($k:ident [:?] = $v:expr) => { $crate::kv::Value::capture_debug(&$v) };
+    ($k:ident [:sval] = $v:expr) => { $crate::kv::Value::capture_sval2(&$v) };
+    ($k:ident [:serde] = $v:expr) => { $crate::kv::Value::capture_serde1(&$v) };
 }
 
 #[cfg(test)]
 mod tests {
     use std::{
         fmt::{self, Debug, Display},
         sync::Arc,
+        vec,
     };
 
-    use crate::{kv::KeyInner, prelude::*, test_utils::*};
+    use crate::{
+        formatter::Formatter,
+        kv::{Key, KeyInner},
+        prelude::*,
+        sink::Sink,
+        test_utils::{self, *},
+        ErrorHandler, Record,
+    };
 
     #[test]
     fn syntax_and_records() {
@@ -390,4 +402,68 @@ mod tests {
 
         assert_eq!(check, from_sink);
     }
+
+    #[test]
+    fn kv_types() {
+        struct Asserter;
+
+        impl Sink for Asserter {
+            fn should_log(&self, _: Level) -> bool {
+                true
+            }
+            fn flush(&self) -> crate::Result<()> {
+                Ok(())
+            }
+            fn level_filter(&self) -> LevelFilter {
+                LevelFilter::All
+            }
+            fn set_level_filter(&self, _: LevelFilter) {
+                unimplemented!()
+            }
+            fn set_formatter(&self, _: Box<dyn Formatter>) {
+                unimplemented!()
+            }
+            fn set_error_handler(&self, _: Option<ErrorHandler>) {
+                unimplemented!()
+            }
+
+            fn log(&self, record: &Record) -> crate::Result<()> {
+                let kvs = record.key_values();
+                let value = kvs.get(Key::from_str("v")).unwrap();
+                assert_eq!(kvs.len(), 1);
+
+                match record.payload() {
+                    "1" => assert!(value.to_i64().is_some()),
+                    "2" => assert!(value.to_str().is_some()),
+                    "3" => assert!(value.to_i64().is_some()),
+                    "4" => assert!(value.to_i64().is_some()),
+                    "5" => assert!(value.is::<Vec<i32>>()),
+                    "6" => assert!(value.is::<Data>()),
+                    "7" => assert!(value.is::<Data>()),
+                    _ => panic!(),
+                }
+                Ok(())
+            }
+        }
+
+        let asserter = test_utils::build_test_logger(|b| b.sink(Arc::new(Asserter)));
+
+        #[derive(sval_derive::Value, serde::Serialize)]
+        struct Data {
+            i: i32,
+            v: Vec<i32>,
+        }
+        let data = Data {
+            i: 1,
+            v: vec![1, 2],
+        };
+
+        info!(logger: asserter, "1", kv: { v = 1 });
+        info!(logger: asserter, "2", kv: { v = "string" });
+        info!(logger: asserter, "3", kv: { v: = 1 });
+        info!(logger: asserter, "4", kv: { v:? = 1 });
+        info!(logger: asserter, "5", kv: { v:sval = vec![1, 2] });
+        info!(logger: asserter, "6", kv: { v:sval = data });
+        info!(logger: asserter, "7", kv: { v:serde = data });
+    }
 }