tracing::instrument args by autoref specialization

Author: CAD97

tracing-attributes/src/expand.rs

@@ -92,17 +92,12 @@ fn gen_block<B: ToTokens>(
     let span = (|| {
         // Pull out the arguments-to-be-skipped first, so we can filter results
         // below.
-        let param_names: Vec<(Ident, (Ident, RecordType))> = params
+        let param_names: Vec<(Ident, Ident)> = params
             .clone()
             .into_iter()
             .flat_map(|param| match param {
-                FnArg::Typed(PatType { pat, ty, .. }) => {
-                    param_names(*pat, RecordType::parse_from_ty(&*ty))
-                }
-                FnArg::Receiver(_) => Box::new(iter::once((
-                    Ident::new("self", param.span()),
-                    RecordType::Debug,
-                ))),
+                FnArg::Typed(PatType { pat, .. }) => param_names(*pat),
+                FnArg::Receiver(_) => Box::new(iter::once(Ident::new("self", param.span()))),
             })
             // Little dance with new (user-exposed) names and old (internal)
             // names of identifiers. That way, we could do the following
@@ -114,13 +109,13 @@ fn gen_block<B: ToTokens>(
             //     async fn foo(&self, v: usize) {}
             // }
             // ```
-            .map(|(x, record_type)| {
+            .map(|x| {
                 // if we are inside a function generated by async-trait <=0.1.43, we need to
                 // take care to rewrite "_self" as "self" for 'user convenience'
                 if self_type.is_some() && x == "_self" {
-                    (Ident::new("self", x.span()), (x, record_type))
+                    (Ident::new("self", x.span()), x)
                 } else {
-                    (x.clone(), (x, record_type))
+                    (x.clone(), x)
                 }
             })
             .collect();
@@ -154,16 +149,13 @@ fn gen_block<B: ToTokens>(
                     true
                 }
             })
-            .map(|(user_name, (real_name, record_type))| match record_type {
-                RecordType::Value => quote!(#user_name = #real_name),
-                RecordType::Debug => quote!(#user_name = tracing::field::debug(&#real_name)),
-            })
+            .map(|(user_name, real_name)| quote!(#user_name = tracing::__tracing_capture_value!(#real_name)))
             .collect();
 
         // replace every use of a variable with its original name
         if let Some(Fields(ref mut fields)) = args.fields {
             let mut replacer = IdentAndTypesRenamer {
-                idents: param_names.into_iter().map(|(a, (b, _))| (a, b)).collect(),
+                idents: param_names,
                 types: Vec::new(),
             };
 
@@ -284,95 +276,24 @@ fn gen_block<B: ToTokens>(
     )
 }
 
-/// Indicates whether a field should be recorded as `Value` or `Debug`.
-enum RecordType {
-    /// The field should be recorded using its `Value` implementation.
-    Value,
-    /// The field should be recorded using `tracing::field::debug()`.
-    Debug,
-}
-
-impl RecordType {
-    /// Array of primitive types which should be recorded as [RecordType::Value].
-    const TYPES_FOR_VALUE: &'static [&'static str] = &[
-        "bool",
-        "str",
-        "u8",
-        "i8",
-        "u16",
-        "i16",
-        "u32",
-        "i32",
-        "u64",
-        "i64",
-        "f32",
-        "f64",
-        "usize",
-        "isize",
-        "NonZeroU8",
-        "NonZeroI8",
-        "NonZeroU16",
-        "NonZeroI16",
-        "NonZeroU32",
-        "NonZeroI32",
-        "NonZeroU64",
-        "NonZeroI64",
-        "NonZeroUsize",
-        "NonZeroIsize",
-        "Wrapping",
-    ];
-
-    /// Parse `RecordType` from [syn::Type] by looking up
-    /// the [RecordType::TYPES_FOR_VALUE] array.
-    fn parse_from_ty(ty: &syn::Type) -> Self {
-        match ty {
-            syn::Type::Path(syn::TypePath { path, .. })
-                if path
-                    .segments
-                    .iter()
-                    .last()
-                    .map(|path_segment| {
-                        let ident = path_segment.ident.to_string();
-                        Self::TYPES_FOR_VALUE.iter().any(|&t| t == ident)
-                    })
-                    .unwrap_or(false) =>
-            {
-                RecordType::Value
-            }
-            syn::Type::Reference(syn::TypeReference { elem, .. }) => {
-                RecordType::parse_from_ty(&*elem)
-            }
-            _ => RecordType::Debug,
-        }
-    }
-}
-
-fn param_names(pat: Pat, record_type: RecordType) -> Box<dyn Iterator<Item = (Ident, RecordType)>> {
+fn param_names(pat: Pat) -> Box<dyn Iterator<Item = Ident>> {
     match pat {
-        Pat::Ident(PatIdent { ident, .. }) => Box::new(iter::once((ident, record_type))),
-        Pat::Reference(PatReference { pat, .. }) => param_names(*pat, record_type),
+        Pat::Ident(PatIdent { ident, .. }) => Box::new(iter::once(ident)),
+        Pat::Reference(PatReference { pat, .. }) => param_names(*pat),
         // We can't get the concrete type of fields in the struct/tuple
         // patterns by using `syn`. e.g. `fn foo(Foo { x, y }: Foo) {}`.
         // Therefore, the struct/tuple patterns in the arguments will just
         // always be recorded as `RecordType::Debug`.
         Pat::Struct(PatStruct { fields, .. }) => Box::new(
             fields
                 .into_iter()
-                .flat_map(|FieldPat { pat, .. }| param_names(*pat, RecordType::Debug)),
-        ),
-        Pat::Tuple(PatTuple { elems, .. }) => Box::new(
-            elems
-                .into_iter()
-                .flat_map(|p| param_names(p, RecordType::Debug)),
+                .flat_map(|FieldPat { pat, .. }| param_names(*pat)),
         ),
+        Pat::Tuple(PatTuple { elems, .. }) => Box::new(elems.into_iter().flat_map(param_names)),
         Pat::TupleStruct(PatTupleStruct {
             pat: PatTuple { elems, .. },
             ..
-        }) => Box::new(
-            elems
-                .into_iter()
-                .flat_map(|p| param_names(p, RecordType::Debug)),
-        ),
+        }) => Box::new(elems.into_iter().flat_map(param_names)),
 
         // The above *should* cover all cases of irrefutable patterns,
         // but we purposefully don't do any funny business here

tracing-attributes/tests/destructuring.rs

@@ -15,8 +15,8 @@ fn destructure_tuples() {
         .new_span(
             span.clone().with_field(
                 field::mock("arg1")
-                    .with_value(&format_args!("1"))
-                    .and(field::mock("arg2").with_value(&format_args!("2")))
+                    .with_value(&1usize)
+                    .and(field::mock("arg2").with_value(&2usize))
                     .only(),
             ),
         )
@@ -44,10 +44,10 @@ fn destructure_nested_tuples() {
         .new_span(
             span.clone().with_field(
                 field::mock("arg1")
-                    .with_value(&format_args!("1"))
-                    .and(field::mock("arg2").with_value(&format_args!("2")))
-                    .and(field::mock("arg3").with_value(&format_args!("3")))
-                    .and(field::mock("arg4").with_value(&format_args!("4")))
+                    .with_value(&1usize)
+                    .and(field::mock("arg2").with_value(&2usize))
+                    .and(field::mock("arg3").with_value(&3usize))
+                    .and(field::mock("arg4").with_value(&4usize))
                     .only(),
             ),
         )
@@ -102,8 +102,8 @@ fn destructure_tuple_structs() {
         .new_span(
             span.clone().with_field(
                 field::mock("arg1")
-                    .with_value(&format_args!("1"))
-                    .and(field::mock("arg2").with_value(&format_args!("2")))
+                    .with_value(&1usize)
+                    .and(field::mock("arg2").with_value(&2usize))
                     .only(),
             ),
         )
@@ -143,8 +143,8 @@ fn destructure_structs() {
         .new_span(
             span.clone().with_field(
                 field::mock("arg1")
-                    .with_value(&format_args!("1"))
-                    .and(field::mock("arg2").with_value(&format_args!("2")))
+                    .with_value(&1usize)
+                    .and(field::mock("arg2").with_value(&2usize))
                     .only(),
             ),
         )
@@ -188,10 +188,10 @@ fn destructure_everything() {
         .new_span(
             span.clone().with_field(
                 field::mock("arg1")
-                    .with_value(&format_args!("1"))
-                    .and(field::mock("arg2").with_value(&format_args!("2")))
-                    .and(field::mock("arg3").with_value(&format_args!("3")))
-                    .and(field::mock("arg4").with_value(&format_args!("4")))
+                    .with_value(&1usize)
+                    .and(field::mock("arg2").with_value(&2usize))
+                    .and(field::mock("arg3").with_value(&3usize))
+                    .and(field::mock("arg4").with_value(&4usize))
                     .only(),
             ),
         )

tracing-core/src/field.rs

@@ -238,10 +238,12 @@ pub trait Value: crate::sealed::Sealed {
 /// Uses `record_debug` in the `Value` implementation to
 /// avoid an unnecessary evaluation.
 #[derive(Clone)]
+#[repr(transparent)]
 pub struct DisplayValue<T: fmt::Display>(T);
 
 /// A `Value` which serializes as a string using `fmt::Debug`.
 #[derive(Clone)]
+#[repr(transparent)]
 pub struct DebugValue<T: fmt::Debug>(T);
 
 /// Wraps a type implementing `fmt::Display` as a `Value` that can be
@@ -262,6 +264,16 @@ where
     DebugValue(t)
 }
 
+/// Wraps a type implementing `fmt::Debug` as a `Value` that can be
+/// recorded using its `Debug` implementation.
+pub fn debug_ref<T>(t: &T) -> &DebugValue<T>
+where
+    T: fmt::Debug,
+{
+    // SAFETY: DebugValue is a repr(transparent) wrapper of T
+    unsafe { &*(t as *const T as *const DebugValue<T>) }
+}
+
 // ===== impl Visit =====
 
 impl<'a, 'b> Visit for fmt::DebugStruct<'a, 'b> {

tracing/src/lib.rs

@@ -964,7 +964,8 @@ pub use self::span::Span;
 pub use tracing_attributes::instrument;
 
 #[macro_use]
-mod macros;
+#[doc(hidden)]
+pub mod macros;
 
 pub mod collect;
 pub mod dispatch;

tracing/src/macros.rs

@@ -2134,6 +2134,40 @@ macro_rules! fieldset {
 
 }
 
+// autoref specialization level 0
+#[doc(hidden)]
+pub trait TracingCaptureValueByValue {
+    fn __tracing_capture_value(&self) -> &dyn crate::field::Value;
+}
+
+impl<T: crate::field::Value> TracingCaptureValueByValue for T {
+    fn __tracing_capture_value(&self) -> &dyn crate::field::Value {
+        self
+    }
+}
+
+// autoref specialization level 1
+#[doc(hidden)]
+pub trait TracingCaptureValueByDebug {
+    fn __tracing_capture_value(&self) -> &dyn crate::field::Value;
+}
+
+impl<T: core::fmt::Debug> TracingCaptureValueByDebug for &T {
+    fn __tracing_capture_value(&self) -> &dyn crate::field::Value {
+        crate::field::debug_ref(self)
+    }
+}
+
+#[doc(hidden)]
+#[macro_export]
+macro_rules! __tracing_capture_value {
+    ($e:expr) => {{
+        #[allow(unused_imports)]
+        use $crate::macros::{TracingCaptureValueByDebug, TracingCaptureValueByValue};
+        (&$e).__tracing_capture_value()
+    }};
+}
+
 #[cfg(feature = "log")]
 #[doc(hidden)]
 #[macro_export]