[tracing-attributes] future-proof the #[instrument] integration with async-trait
This draft PR aims to resolve #1219.

Tell me what you think ;)

It works with both the old and new version of `async-trait` (except for one doc test that failed previously, and that works with the new version). One nice thing is that the code is simpler (e.g.g no `self` renaming to `_self`, which will enable some simplifications in the future).

A minor nitpick is that I disliked the deeply nested pattern matching in `get_async_trait_kind` (previously: `get_async_trait_function`), so I "flattened" that a bit.

Not a bug **yet**, but `async-trait` is working towards changing the way they wrap an async function in a trait impl (see https://github.com/dtolnay/async-trait/pull/143 for more details).
More specifically, they are moving away from a design where they were wrapping the insides of async function into an async function nested inside a "classical" function, and returning the async function, boxing it along the way. Because some code is probably much clearer than anything I can say, this means that the impl of the following code will be translated from:
```rust
#[async_trait]
pub trait FakeTrait {
    async fn foo(&mut self);
}

struct Impl;

#[async_trait]
impl FakeTrait for Impl {
    async fn foo(&mut self) {
    }
}
```
to something like:
```rust
impl FakeTrait for Impl {
    fn foo(&mut self) -> Box<Pin<dyn Future<Output = ()>>> {
      async fn _foo(_self: &mut Self) {}
      Box::pin(_foo(self))
    }
}
```
If it can help to demangle my shoddy explanations above, the support for accepting this kind of expressions was added in #711.

The new version would (from what I understand, please correct me if I'm mistaken !) translate the previous code as:
```rust
impl FakeTrait for Impl {
    fn foo(&mut self) -> Box<Pin<dyn Future<Output = ()>>> {
      Box::pin(async move {})
    }
}
```

While we could support this code in the same fashion as we support the current version of async-trait, I fear this might lead to some confusion if a user deliberately want to instrument a function returning a future and end up instrumented the future instead. Not quite sure what to do here. Maybe we have to consider adding an argument to the `#[instrument]` macro that would  opt-in to instrument the returned closure ?
It could be something like:
```rust
#[async_trait]
impl FakeTrait for Impl {
   #[instrument] // instrument the outer function (foo)
    async fn foo(&mut self) {
    }
}

#[async_trait]
impl FakeTrait for Impl {
   #[instrument(instrument_return_future)] // instrument the return (async move {}) instead of foo (the wrapper)
    async fn foo(&mut self) {
    }
}
```

But that's just some thoughts in the wind :)
Any opinion ?
#[instrument] - Future-proofing async-trait support in tracing-attributes
diff --git a/tracing-attributes/Cargo.toml b/tracing-attributes/Cargo.toml
index d351783e6d..3105ee0935 100644
--- a/tracing-attributes/Cargo.toml
+++ b/tracing-attributes/Cargo.toml
@@ -34,15 +34,14 @@ proc-macro = true
 
 [dependencies]
 proc-macro2 = "1"
-syn = { version = "1", default-features = false, features = ["full", "parsing", "printing", "visit-mut", "clone-impls", "extra-traits", "proc-macro"] }
+syn = { version = "1", default-features = false, features = ["full", "parsing", "printing", "visit", "visit-mut", "clone-impls", "extra-traits", "proc-macro"] }
 quote = "1"
 
-
 [dev-dependencies]
 tracing = { path = "../tracing", version = "0.2" }
 tokio-test = { version = "0.2.0" }
 tracing-core = { path = "../tracing-core", version = "0.2"}
-async-trait = "0.1"
+async-trait = "0.1.44"
 
 [badges]
 maintenance = { status = "experimental" }
diff --git a/tracing-attributes/src/lib.rs b/tracing-attributes/src/lib.rs
index 73e93fd524..54f5efebe5 100644
--- a/tracing-attributes/src/lib.rs
+++ b/tracing-attributes/src/lib.rs
@@ -74,7 +74,6 @@
     patterns_in_fns_without_body,
     private_in_public,
     unconditional_recursion,
-    unused,
     unused_allocation,
     unused_comparisons,
     unused_parens,
@@ -89,9 +88,9 @@ use quote::{quote, quote_spanned, ToTokens};
 use syn::ext::IdentExt as _;
 use syn::parse::{Parse, ParseStream};
 use syn::{
-    punctuated::Punctuated, spanned::Spanned, Block, Expr, ExprCall, FieldPat, FnArg, Ident, Item,
-    ItemFn, LitInt, LitStr, Pat, PatIdent, PatReference, PatStruct, PatTuple, PatTupleStruct,
-    PatType, Path, Signature, Stmt, Token,
+    punctuated::Punctuated, spanned::Spanned, Block, Expr, ExprAsync, ExprCall, FieldPat, FnArg,
+    Ident, Item, ItemFn, LitInt, LitStr, Pat, PatIdent, PatReference, PatStruct, PatTuple,
+    PatTupleStruct, PatType, Path, Signature, Stmt, Token, TypePath,
 };
 /// Instruments a function to create and enter a `tracing` [span] every time
 /// the function is called.
@@ -221,11 +220,12 @@ use syn::{
 /// }
 /// ```
 ///
-/// An interesting note on this subject is that references to the `Self`
-/// type inside the `fields` argument are only allowed when the instrumented
-/// function is a method aka. the function receives `self` as an argument.
-/// For example, this *will not work* because it doesn't receive `self`:
-/// ```compile_fail
+/// Note than on `async-trait` <= 0.1.43, references to the `Self`
+/// type inside the `fields` argument were only allowed when the instrumented
+/// function is a method (i.e., the function receives `self` as an argument).
+/// For example, this *used to not work* because the instrument function
+/// didn't receive `self`:
+/// ```
 /// # use tracing::instrument;
 /// use async_trait::async_trait;
 ///
@@ -244,7 +244,8 @@ use syn::{
 /// }
 /// ```
 /// Instead, you should manually rewrite any `Self` types as the type for
-/// which you implement the trait: `#[instrument(fields(tmp = std::any::type_name::<Bar>()))]`.
+/// which you implement the trait: `#[instrument(fields(tmp = std::any::type_name::<Bar>()))]`
+/// (or maybe you can just bump `async-trait`).
 ///
 /// [span]: https://docs.rs/tracing/latest/tracing/span/index.html
 /// [`tracing`]: https://github.com/tokio-rs/tracing
@@ -254,30 +255,47 @@ pub fn instrument(
     args: proc_macro::TokenStream,
     item: proc_macro::TokenStream,
 ) -> proc_macro::TokenStream {
-    let input: ItemFn = syn::parse_macro_input!(item as ItemFn);
+    let input = syn::parse_macro_input!(item as ItemFn);
     let args = syn::parse_macro_input!(args as InstrumentArgs);
 
     let instrumented_function_name = input.sig.ident.to_string();
 
-    // check for async_trait-like patterns in the block and wrap the
-    // internal function with Instrument instead of wrapping the
-    // async_trait generated wrapper
+    // check for async_trait-like patterns in the block, and instrument
+    // the future instead of the wrapper
     if let Some(internal_fun) = get_async_trait_info(&input.block, input.sig.asyncness.is_some()) {
         // let's rewrite some statements!
-        let mut stmts: Vec<Stmt> = input.block.stmts.to_vec();
-        for stmt in &mut stmts {
-            if let Stmt::Item(Item::Fn(fun)) = stmt {
-                // instrument the function if we considered it as the one we truly want to trace
-                if fun.sig.ident == internal_fun.name {
-                    *stmt = syn::parse2(gen_body(
-                        fun,
-                        args,
-                        instrumented_function_name,
-                        Some(internal_fun),
-                    ))
-                    .unwrap();
-                    break;
+        let mut out_stmts = Vec::with_capacity(input.block.stmts.len());
+        for stmt in &input.block.stmts {
+            if stmt == internal_fun.source_stmt {
+                match internal_fun.kind {
+                    // async-trait <= 0.1.43
+                    AsyncTraitKind::Function(fun) => {
+                        out_stmts.push(gen_function(
+                            fun,
+                            args,
+                            instrumented_function_name,
+                            internal_fun.self_type,
+                        ));
+                    }
+                    // async-trait >= 0.1.44
+                    AsyncTraitKind::Async(async_expr) => {
+                        // fallback if we couldn't find the '__async_trait' binding, might be
+                        // useful for crates exhibiting the same behaviors as async-trait
+                        let instrumented_block = gen_block(
+                            &async_expr.block,
+                            &input.sig.inputs,
+                            true,
+                            args,
+                            instrumented_function_name,
+                            None,
+                        );
+                        let async_attrs = &async_expr.attrs;
+                        out_stmts.push(quote! {
+                            Box::pin(#(#async_attrs) * async move { #instrumented_block })
+                        });
+                    }
                 }
+                break;
             }
         }
 
@@ -287,20 +305,21 @@ pub fn instrument(
         quote!(
             #(#attrs) *
             #vis #sig {
-                #(#stmts) *
+                #(#out_stmts) *
             }
         )
         .into()
     } else {
-        gen_body(&input, args, instrumented_function_name, None).into()
+        gen_function(&input, args, instrumented_function_name, None).into()
     }
 }
 
-fn gen_body(
+/// Given an existing function, generate an instrumented version of that function
+fn gen_function(
     input: &ItemFn,
-    mut args: InstrumentArgs,
+    args: InstrumentArgs,
     instrumented_function_name: String,
-    async_trait_fun: Option<AsyncTraitInfo>,
+    self_type: Option<syn::TypePath>,
 ) -> proc_macro2::TokenStream {
     // these are needed ahead of time, as ItemFn contains the function body _and_
     // isn't representable inside a quote!/quote_spanned! macro
@@ -330,9 +349,39 @@ fn gen_body(
         ..
     } = sig;
 
-    let err = args.err;
     let warnings = args.warnings();
 
+    let body = gen_block(
+        block,
+        params,
+        asyncness.is_some(),
+        args,
+        instrumented_function_name,
+        self_type,
+    );
+
+    quote!(
+        #(#attrs) *
+        #vis #constness #unsafety #asyncness #abi fn #ident<#gen_params>(#params) #return_type
+        #where_clause
+        {
+            #warnings
+            #body
+        }
+    )
+}
+
+/// Instrument a block
+fn gen_block(
+    block: &Block,
+    params: &Punctuated<FnArg, Token![,]>,
+    async_context: bool,
+    mut args: InstrumentArgs,
+    instrumented_function_name: String,
+    self_type: Option<syn::TypePath>,
+) -> proc_macro2::TokenStream {
+    let err = args.err;
+
     // generate the span's name
     let span_name = args
         // did the user override the span's name?
@@ -353,8 +402,8 @@ fn gen_body(
                 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, you can do the following
-            // even though async_trait rewrite "self" as "_self":
+            // names of identifiers. That way, we could do the following
+            // even though async_trait (<=0.1.43) rewrites "self" as "_self":
             // ```
             // #[async_trait]
             // impl Foo for FooImpl {
@@ -363,10 +412,9 @@ fn gen_body(
             // }
             // ```
             .map(|x| {
-                // if we are inside a function generated by async-trait, we
-                // should take care to rewrite "_self" as "self" for
-                // 'user convenience'
-                if async_trait_fun.is_some() && x == "_self" {
+                // 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)
                 } else {
                     (x.clone(), x)
@@ -387,7 +435,7 @@ fn gen_body(
 
         // filter out skipped fields
         let quoted_fields: Vec<_> = param_names
-            .into_iter()
+            .iter()
             .filter(|(param, _)| {
                 if args.skips.contains(param) {
                     return false;
@@ -407,13 +455,19 @@ fn gen_body(
             .map(|(user_name, real_name)| quote!(#user_name = tracing::field::debug(&#real_name)))
             .collect();
 
-        // when async-trait is in use, replace instances of "self" with "_self" inside the fields values
-        if let (Some(ref async_trait_fun), Some(Fields(ref mut fields))) =
-            (async_trait_fun, &mut args.fields)
-        {
-            let mut replacer = SelfReplacer {
-                ty: async_trait_fun.self_type.clone(),
+        // 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,
+                types: Vec::new(),
             };
+
+            // when async-trait <=0.1.43 is in use, replace instances
+            // of the "Self" type inside the fields values
+            if let Some(self_type) = self_type {
+                replacer.types.push(("Self", self_type));
+            }
+
             for e in fields.iter_mut().filter_map(|f| f.value.as_mut()) {
                 syn::visit_mut::visit_expr_mut(&mut replacer, e);
             }
@@ -436,9 +490,9 @@ fn gen_body(
     // which is `instrument`ed using `tracing-futures`. Otherwise, this will
     // enter the span and then perform the rest of the body.
     // If `err` is in args, instrument any resulting `Err`s.
-    let body = if asyncness.is_some() {
+    if async_context {
         if err {
-            quote_spanned! {block.span()=>
+            quote_spanned!(block.span()=>
                 let __tracing_attr_span = #span;
                 tracing::Instrument::instrument(async move {
                     match async move { #block }.await {
@@ -450,7 +504,7 @@ fn gen_body(
                         }
                     }
                 }, __tracing_attr_span).await
-            }
+            )
         } else {
             quote_spanned!(block.span()=>
                 let __tracing_attr_span = #span;
@@ -481,17 +535,7 @@ fn gen_body(
             let __tracing_attr_guard = __tracing_attr_span.enter();
             #block
         )
-    };
-
-    quote!(
-        #(#attrs) *
-        #vis #constness #unsafety #asyncness #abi fn #ident<#gen_params>(#params) #return_type
-        #where_clause
-        {
-            #warnings
-            #body
-        }
-    )
+    }
 }
 
 #[derive(Default, Debug)]
@@ -835,6 +879,20 @@ mod kw {
     syn::custom_keyword!(err);
 }
 
+enum AsyncTraitKind<'a> {
+    // old construction. Contains the function
+    Function(&'a ItemFn),
+    // new construction. Contains a reference to the async block
+    Async(&'a ExprAsync),
+}
+
+struct AsyncTraitInfo<'a> {
+    // statement that must be patched
+    source_stmt: &'a Stmt,
+    kind: AsyncTraitKind<'a>,
+    self_type: Option<syn::TypePath>,
+}
+
 // Get the AST of the inner function we need to hook, if it was generated
 // by async-trait.
 // When we are given a function annotated by async-trait, that function
@@ -842,118 +900,122 @@ mod kw {
 // user logic, and it is that pinned future that needs to be instrumented.
 // Were we to instrument its parent, we would only collect information
 // regarding the allocation of that future, and not its own span of execution.
-// So we inspect the block of the function to find if it matches the pattern
-// `async fn foo<...>(...) {...}; Box::pin(foo<...>(...))` and we return
-// the name `foo` if that is the case. 'gen_body' will then be able
-// to use that information to instrument the proper function.
+// Depending on the version of async-trait, we inspect the block of the function
+// to find if it matches the pattern
+// `async fn foo<...>(...) {...}; Box::pin(foo<...>(...))` (<=0.1.43), or if
+// it matches `Box::pin(async move { ... }) (>=0.1.44). We the return the
+// statement that must be instrumented, along with some other informations.
+// 'gen_body' will then be able to use that information to instrument the
+// proper function/future.
 // (this follows the approach suggested in
 // https://github.com/dtolnay/async-trait/issues/45#issuecomment-571245673)
-fn get_async_trait_function(block: &Block, block_is_async: bool) -> Option<&ItemFn> {
+fn get_async_trait_info(block: &Block, block_is_async: bool) -> Option<AsyncTraitInfo<'_>> {
     // are we in an async context? If yes, this isn't a async_trait-like pattern
     if block_is_async {
         return None;
     }
 
     // list of async functions declared inside the block
-    let mut inside_funs = Vec::new();
-    // last expression declared in the block (it determines the return
-    // value of the block, so that if we are working on a function
-    // whose `trait` or `impl` declaration is annotated by async_trait,
-    // this is quite likely the point where the future is pinned)
-    let mut last_expr = None;
-
-    // obtain the list of direct internal functions and the last
-    // expression of the block
-    for stmt in &block.stmts {
+    let inside_funs = block.stmts.iter().filter_map(|stmt| {
         if let Stmt::Item(Item::Fn(fun)) = &stmt {
-            // is the function declared as async? If so, this is a good
-            // candidate, let's keep it in hand
+            // If the function is async, this is a candidate
             if fun.sig.asyncness.is_some() {
-                inside_funs.push(fun);
+                return Some((stmt, fun));
             }
-        } else if let Stmt::Expr(e) = &stmt {
-            last_expr = Some(e);
         }
-    }
+        None
+    });
 
-    // let's play with (too much) pattern matching
-    // is the last expression a function call?
-    if let Some(Expr::Call(ExprCall {
-        func: outside_func,
-        args: outside_args,
-        ..
-    })) = last_expr
-    {
-        if let Expr::Path(path) = outside_func.as_ref() {
-            // is it a call to `Box::pin()`?
-            if "Box::pin" == path_to_string(&path.path) {
-                // does it takes at least an argument? (if it doesn't,
-                // it's not gonna compile anyway, but that's no reason
-                // to (try to) perform an out of bounds access)
-                if outside_args.is_empty() {
-                    return None;
-                }
-                // is the argument to Box::pin a function call itself?
-                if let Expr::Call(ExprCall { func, .. }) = &outside_args[0] {
-                    if let Expr::Path(inside_path) = func.as_ref() {
-                        // "stringify" the path of the function called
-                        let func_name = path_to_string(&inside_path.path);
-                        // is this function directly defined insided the current block?
-                        for fun in inside_funs {
-                            if fun.sig.ident == func_name {
-                                // we must hook this function now
-                                return Some(fun);
-                            }
-                        }
-                    }
-                }
-            }
+    // last expression of the block (it determines the return value
+    // of the block, so that if we are working on a function whose
+    // `trait` or `impl` declaration is annotated by async_trait,
+    // this is quite likely the point where the future is pinned)
+    let (last_expr_stmt, last_expr) = block.stmts.iter().rev().find_map(|stmt| {
+        if let Stmt::Expr(expr) = stmt {
+            Some((stmt, expr))
+        } else {
+            None
         }
+    })?;
+
+    // is the last expression a function call?
+    let (outside_func, outside_args) = match last_expr {
+        Expr::Call(ExprCall { func, args, .. }) => (func, args),
+        _ => return None,
+    };
+
+    // is it a call to `Box::pin()`?
+    let path = match outside_func.as_ref() {
+        Expr::Path(path) => &path.path,
+        _ => return None,
+    };
+    if !path_to_string(path).ends_with("Box::pin") {
+        return None;
     }
-    None
-}
 
-struct AsyncTraitInfo {
-    name: String,
-    self_type: Option<syn::TypePath>,
-}
+    // Does the call take an argument? If it doesn't,
+    // it's not gonna compile anyway, but that's no reason
+    // to (try to) perform an out of bounds access
+    if outside_args.is_empty() {
+        return None;
+    }
 
-// Return the informations necessary to process a function annotated with async-trait.
-fn get_async_trait_info(block: &Block, block_is_async: bool) -> Option<AsyncTraitInfo> {
-    let fun = get_async_trait_function(block, block_is_async)?;
+    // Is the argument to Box::pin an async block that
+    // captures its arguments?
+    if let Expr::Async(async_expr) = &outside_args[0] {
+        // check that the move 'keyword' is present
+        async_expr.capture?;
 
-    // if "_self" is present as an argument, we store its type to be able to rewrite "Self" (the
+        return Some(AsyncTraitInfo {
+            source_stmt: last_expr_stmt,
+            kind: AsyncTraitKind::Async(async_expr),
+            self_type: None,
+        });
+    }
+
+    // Is the argument to Box::pin a function call itself?
+    let func = match &outside_args[0] {
+        Expr::Call(ExprCall { func, .. }) => func,
+        _ => return None,
+    };
+
+    // "stringify" the path of the function called
+    let func_name = match **func {
+        Expr::Path(ref func_path) => path_to_string(&func_path.path),
+        _ => return None,
+    };
+
+    // Was that function defined inside of the current block?
+    // If so, retrieve the statement where it was declared and the function itself
+    let (stmt_func_declaration, func) = inside_funs
+        .into_iter()
+        .find(|(_, fun)| fun.sig.ident == func_name)?;
+
+    // If "_self" is present as an argument, we store its type to be able to rewrite "Self" (the
     // parameter type) with the type of "_self"
-    let self_type = fun
-        .sig
-        .inputs
-        .iter()
-        .map(|arg| {
-            if let FnArg::Typed(ty) = arg {
-                if let Pat::Ident(PatIdent { ident, .. }) = &*ty.pat {
-                    if ident == "_self" {
-                        let mut ty = &*ty.ty;
-                        // extract the inner type if the argument is "&self" or "&mut self"
-                        if let syn::Type::Reference(syn::TypeReference { elem, .. }) = ty {
-                            ty = &*elem;
-                        }
-                        if let syn::Type::Path(tp) = ty {
-                            return Some(tp.clone());
-                        }
+    let mut self_type = None;
+    for arg in &func.sig.inputs {
+        if let FnArg::Typed(ty) = arg {
+            if let Pat::Ident(PatIdent { ref ident, .. }) = *ty.pat {
+                if ident == "_self" {
+                    let mut ty = *ty.ty.clone();
+                    // extract the inner type if the argument is "&self" or "&mut self"
+                    if let syn::Type::Reference(syn::TypeReference { elem, .. }) = ty {
+                        ty = *elem;
+                    }
+
+                    if let syn::Type::Path(tp) = ty {
+                        self_type = Some(tp);
+                        break;
                     }
                 }
             }
-
-            None
-        })
-        .next();
-    let self_type = match self_type {
-        Some(x) => x,
-        None => None,
-    };
+        }
+    }
 
     Some(AsyncTraitInfo {
-        name: fun.sig.ident.to_string(),
+        source_stmt: stmt_func_declaration,
+        kind: AsyncTraitKind::Function(func),
         self_type,
     })
 }
@@ -973,26 +1035,48 @@ fn path_to_string(path: &Path) -> String {
     res
 }
 
-// A visitor struct replacing the "self" and "Self" tokens in user-supplied fields expressions when
-// the function is generated by async-trait.
-struct SelfReplacer {
-    ty: Option<syn::TypePath>,
+/// A visitor struct to replace idents and types in some piece
+/// of code (e.g. the "self" and "Self" tokens in user-supplied
+/// fields expressions when the function is generated by an old
+/// version of async-trait).
+struct IdentAndTypesRenamer<'a> {
+    types: Vec<(&'a str, TypePath)>,
+    idents: Vec<(Ident, Ident)>,
 }
 
-impl syn::visit_mut::VisitMut for SelfReplacer {
+impl<'a> syn::visit_mut::VisitMut for IdentAndTypesRenamer<'a> {
+    // we deliberately compare strings because we want to ignore the spans
+    // If we apply clippy's lint, the behavior changes
+    #[allow(clippy::cmp_owned)]
     fn visit_ident_mut(&mut self, id: &mut Ident) {
-        if id == "self" {
-            *id = Ident::new("_self", id.span())
+        for (old_ident, new_ident) in &self.idents {
+            if id.to_string() == old_ident.to_string() {
+                *id = new_ident.clone();
+            }
         }
     }
 
     fn visit_type_mut(&mut self, ty: &mut syn::Type) {
-        if let syn::Type::Path(syn::TypePath { ref mut path, .. }) = ty {
-            if path_to_string(path) == "Self" {
-                if let Some(ref true_type) = self.ty {
-                    *path = true_type.path.clone();
+        for (type_name, new_type) in &self.types {
+            if let syn::Type::Path(TypePath { path, .. }) = ty {
+                if path_to_string(path) == *type_name {
+                    *ty = syn::Type::Path(new_type.clone());
                 }
             }
         }
     }
 }
+
+// A visitor struct that replace an async block by its patched version
+struct AsyncTraitBlockReplacer<'a> {
+    block: &'a Block,
+    patched_block: Block,
+}
+
+impl<'a> syn::visit_mut::VisitMut for AsyncTraitBlockReplacer<'a> {
+    fn visit_block_mut(&mut self, i: &mut Block) {
+        if i == self.block {
+            *i = self.patched_block.clone();
+        }
+    }
+}

diff --git a/tracing-attributes/tests/async_fn.rs b/tracing-attributes/tests/async_fn.rs
index 71bafbf994..dcd502f31b 100644
--- a/tracing-attributes/tests/async_fn.rs
+++ b/tracing-attributes/tests/async_fn.rs
@@ -172,18 +172,19 @@ fn async_fn_with_async_trait_and_fields_expressions() {
     #[async_trait]
     impl Test for TestImpl {
         // check that self is correctly handled, even when using async_trait
-        #[instrument(fields(val=self.foo(), test=%v+5))]
-        async fn call(&mut self, v: usize) {}
+        #[instrument(fields(val=self.foo(), val2=Self::clone(self).foo(), test=%_v+5))]
+        async fn call(&mut self, _v: usize) {}
     }
 
     let span = span::mock().named("call");
     let (collector, handle) = collector::mock()
         .new_span(
             span.clone().with_field(
-                field::mock("v")
+                field::mock("_v")
                     .with_value(&tracing::field::debug(5))
                     .and(field::mock("test").with_value(&tracing::field::debug(10)))
-                    .and(field::mock("val").with_value(&42u64)),
+                    .and(field::mock("val").with_value(&42u64))
+                    .and(field::mock("val2").with_value(&42u64)),
             ),
         )
         .enter(span.clone())

{"backtrace::tests::capture_unsupported": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "fmt::format::test::with_ansi_false": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "fmt::format::json::test::json_flattened_event": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "inject_context_into_outgoing_requests": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "fmt::format::test::overridden_parents_in_scope": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "test::info_callsite_is_correct": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "dispatch::test::dispatch_is": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "test::warn_callsite_is_correct": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "fmt::fmt_subscriber::test::synthesize_span_none": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "destructure_structs": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "callsite::tests::linked_list_push_several": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "registry::stack::tests::pop_first_span": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "registry::sharded::tests::spans_are_only_closed_when_the_last_ref_drops": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "registry::stack::tests::pop_last_span": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "field::delimited::test::delimited_new_visitor": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "numeric_levels": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "override_everything": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "test::debug_callsite_is_correct": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "registry::sharded::tests::single_subscriber_can_access_closed_span": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "tests::futures_01_tests::future_enter_exit_is_reasonable": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "fmt::format::test::overridden_parents": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "dispatch::test::events_dont_infinite_loop": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "destructure_nested_tuples": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "capture_supported": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "fields": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "fmt::fmt_subscriber::test::synthesize_span_active": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "test": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "layer::tests::span_kind": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "self_expr_field": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "fmt::format::json::test::json_disabled_span_list_event": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "enter_exit_is_reasonable": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "fmt::fmt_subscriber::test::synthesize_span_close_no_timing": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "fmt::format::json::test::json_no_span": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "fmt::writer::test::custom_writer_closure": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "fmt::writer::test::custom_writer_mutex": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "field::test::sparse_value_sets_are_not_empty": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "fmt::format::test::with_ansi_true": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "subscribe::tests::three_subscribers_are_collector": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "field::test::fields_from_other_callsets_are_skipped": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "tracer::tests::assigns_default_trace_id_if_missing": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "async_fn_with_async_trait": {"run": "FAIL", "test": "FAIL", "fix": "PASS"}, "field::test::empty_value_set_is_empty": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "named_levels": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "test::error_callsite_is_correct": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "backtrace::tests::capture_empty": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "test_async": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "layer::tests::includes_timings": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "fmt::writer::test::custom_writer_struct": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "trace_root_with_children": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "impl_trait_return_type": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "registry::extensions::tests::clear_drops_elements": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "test::trace_callsite_is_correct": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "fmt::format::test::format_nanos": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "field::test::record_debug_fn": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "subscribe::tests::downcasts_to_collector": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "registry::sharded::tests::child_closes_parent": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "trace_with_assigned_otel_context": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "default_name_test": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "subscribe::tests::downcasts_to_subscriber": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "methods": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "destructure_everything": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "metadata::tests::level_filter_reprs": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "callsite::tests::linked_list_push": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "fmt::test::impls": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "fmt::fmt_subscriber::test::impls": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "dispatch::test::dispatch_downcasts": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "metadata_macro_api": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "nested_set_default": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "fmt::format::test::without_level": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "fmt::test::subscriber_downcasts_to_parts": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "field::test::value_sets_with_fields_from_other_callsites_are_empty": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "tests::futures_01_tests::future_error_ends_span": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "field::test::value_set_with_no_values_is_empty": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "clashy_expr_field": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "set_default_dispatch": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "global_dispatch": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "destructure_tuples": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "metadata::tests::level_from_str": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "destructure_refs": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "parameters_with_fields": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "fmt::format::json::test::json": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "can_initialize_log_tracer_with_level": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "subscribe::tests::subscriber_is_collector": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "dispatch::test::spans_dont_infinite_loop": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "fmt::fmt_subscriber::test::synthesize_span_close": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "empty_field": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "skip": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "fmt::fmt_subscriber::test::synthesize_span_full": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "callsite::tests::linked_list_empty": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "custom_targets": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "layer::tests::dynamic_span_names": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "fmt::fmt_subscriber::test::fmt_subscriber_downcasts_to_parts": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "default_targets": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "field::test::empty_fields_are_skipped": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "tracer::tests::sampled_context": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "fmt::fmt_subscriber::test::fmt_subscriber_downcasts": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "metadata::tests::level_filter_is_usize_sized": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "fmt::format::json::test::json_disabled_current_span_event": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "registry::sharded::tests::multiple_subscribers_can_access_closed_span": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "tests::futures_01_tests::stream_enter_exit_is_reasonable": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "registry::extensions::tests::clear_retains_capacity": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "expr_field": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "metadata::tests::filter_level_conversion": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "fmt::format::json::test::json_nested_span": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "fmt::fmt_subscriber::test::is_lookup_span": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "normalized_metadata": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "subscribe::tests::two_subscribers_are_collector": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "registry::extensions::tests::test_extensions": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "two_expr_fields": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "destructure_tuple_structs": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "fmt::format::json::test::record_works": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "test_mut": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "custom_name_no_equals_test": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "custom_name_test": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "fmt::test::is_lookup_span": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "dispatch::test::default_no_collector": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "layer::tests::trace_id_from_existing_context": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "registry::sharded::tests::child_closes_grandparent": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "backtrace::tests::capture_supported": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "dispatch::test::default_dispatch": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "trace_with_active_otel_context": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "fmt::test::subscriber_downcasts": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "generics": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "field::delimited::test::delimited_visitor": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "test_mut_async": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "error_ends_span": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "test_early_return": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "registry::sharded::tests::span_enter_guards_are_dropped_out_of_order": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "tests::futures_01_tests::span_follows_future_onto_threadpool": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "registry::sharded::tests::spans_are_removed_from_registry": {"run": "NONE", "test": "NONE", "fix": "PASS"}}
{"event_outside_of_span": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "rolling::test::write_hourly_log": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "rolling::test::test_round_date_hourly": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "span_with_parent": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "trace_with_parent": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "spans_always_go_to_the_subscriber_that_tagged_them": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "rolling::test::test_round_date_minutely": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "event_macros_dont_infinite_loop": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "trace_span": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "warn_with_parent": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "rolling::test::test_next_date_daily": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "info_root": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "both_shorthands": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "new_span_with_target_and_log_level": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "record_new_values_for_fields": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "rolling::test::test_next_date_minutely": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "trace": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "span_closes_when_exited": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "prefixed_event_macros": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "debug_shorthand": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "event_root": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "contextual_child": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "debug_span_root": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "explicit_child": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "cloning_a_span_calls_clone_span": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "trace_span_root": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "non_blocking::test::backpressure_exerted": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "event_without_message": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "info_with_parent": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "explicit_child_at_levels": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "trace_span_with_parent": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "warn": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "moved_field": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "multiple_max_level_hints": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "dotted_field_name": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "event": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "field_shorthand_only": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "error_root": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "handles_to_different_spans_are_not_equal": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "info_span": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "error_span": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "explicit_child_regardless_of_ctx": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "borrowed_field": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "rolling::test::test_rotation_path_hourly": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "info_span_with_parent": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "explicit_root_span_is_root_regardless_of_ctx": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "event_with_parent": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "debug_span_with_parent": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "clone_and_drop_span_always_go_to_the_subscriber_that_tagged_the_span": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "async_fn_with_async_trait_and_fields_expressions": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "new_span_after_event": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "error": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "explicit_root_span_is_root": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "async_fn_only_enters_for_polls": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "error_with_parent": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "filters_are_reevaluated_for_different_call_sites": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "debug_with_parent": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "filters_are_not_reevaluated_for_the_same_span": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "wrapping_event_without_message": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "entered": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "handles_to_different_spans_with_the_same_metadata_are_not_equal": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "string_message_without_delims": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "non_blocking::test::multi_threaded_writes": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "rolling::test::write_never_log": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "prefixed_span_macros": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "rolling::test::test_join_date_never": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "locals_with_message": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "span_closes_after_event": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "rolling::test::test_next_date_never": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "warn_span": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "info": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "borrow_val_events": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "span": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "move_field_out_of_struct": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "nonzeroi32_event_without_message": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "span_root": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "info_span_root": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "borrow_val_spans": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "locals_no_message": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "rolling::test::test_round_date_daily": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "entered_api": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "event_with_message": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "debug_root": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "contextual_root": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "callsite_macro_api": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "rolling::test::write_minutely_log": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "error_span_with_parent": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "warn_root": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "debug": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "record_new_value_for_field": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "rolling::test::write_daily_log": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "one_with_everything": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "enter": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "rolling::test::test_rotation_path_daily": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "trace_root": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "dropping_a_span_calls_drop_span": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "display_shorthand": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "warn_span_with_parent": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "warn_span_root": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "error_span_root": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "rolling::test::test_rotation_path_minutely": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "max_level_hints": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "message_without_delims": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "spans_always_go_to_the_subscriber_that_tagged_them_even_across_threads": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "filter_caching_is_lexically_scoped": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "handles_to_the_same_span_are_equal": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "debug_span": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "events_dont_leak": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "async_fn_nested": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "span_with_non_rust_symbol": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "async_fn_with_async_trait_and_fields_expressions_with_generic_parameter": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "rolling::test::test_next_date_hourly": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "spans_dont_leak": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "drop_span_when_exiting_dispatchers_context": {"run": "PASS", "test": "PASS", "fix": "PASS"}}
{"async_fn_with_async_trait": {"run": "FAIL", "test": "FAIL", "fix": "PASS"}}
{"backtrace::tests::capture_unsupported": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "fmt::format::test::with_ansi_false": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "fmt::format::json::test::json_flattened_event": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "inject_context_into_outgoing_requests": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "fmt::format::test::overridden_parents_in_scope": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "test::info_callsite_is_correct": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "dispatch::test::dispatch_is": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "test::warn_callsite_is_correct": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "fmt::fmt_subscriber::test::synthesize_span_none": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "destructure_structs": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "callsite::tests::linked_list_push_several": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "registry::stack::tests::pop_first_span": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "registry::sharded::tests::spans_are_only_closed_when_the_last_ref_drops": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "registry::stack::tests::pop_last_span": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "field::delimited::test::delimited_new_visitor": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "numeric_levels": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "override_everything": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "test::debug_callsite_is_correct": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "registry::sharded::tests::single_subscriber_can_access_closed_span": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "tests::futures_01_tests::future_enter_exit_is_reasonable": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "fmt::format::test::overridden_parents": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "dispatch::test::events_dont_infinite_loop": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "destructure_nested_tuples": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "capture_supported": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "fields": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "fmt::fmt_subscriber::test::synthesize_span_active": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "test": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "layer::tests::span_kind": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "self_expr_field": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "fmt::format::json::test::json_disabled_span_list_event": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "enter_exit_is_reasonable": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "fmt::fmt_subscriber::test::synthesize_span_close_no_timing": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "fmt::format::json::test::json_no_span": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "fmt::writer::test::custom_writer_closure": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "fmt::writer::test::custom_writer_mutex": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "field::test::sparse_value_sets_are_not_empty": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "fmt::format::test::with_ansi_true": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "subscribe::tests::three_subscribers_are_collector": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "field::test::fields_from_other_callsets_are_skipped": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "tracer::tests::assigns_default_trace_id_if_missing": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "field::test::empty_value_set_is_empty": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "named_levels": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "test::error_callsite_is_correct": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "backtrace::tests::capture_empty": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "test_async": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "layer::tests::includes_timings": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "fmt::writer::test::custom_writer_struct": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "trace_root_with_children": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "impl_trait_return_type": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "registry::extensions::tests::clear_drops_elements": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "test::trace_callsite_is_correct": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "fmt::format::test::format_nanos": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "field::test::record_debug_fn": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "subscribe::tests::downcasts_to_collector": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "registry::sharded::tests::child_closes_parent": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "trace_with_assigned_otel_context": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "default_name_test": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "subscribe::tests::downcasts_to_subscriber": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "methods": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "destructure_everything": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "metadata::tests::level_filter_reprs": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "callsite::tests::linked_list_push": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "fmt::test::impls": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "fmt::fmt_subscriber::test::impls": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "dispatch::test::dispatch_downcasts": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "metadata_macro_api": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "nested_set_default": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "fmt::format::test::without_level": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "fmt::test::subscriber_downcasts_to_parts": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "field::test::value_sets_with_fields_from_other_callsites_are_empty": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "tests::futures_01_tests::future_error_ends_span": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "field::test::value_set_with_no_values_is_empty": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "clashy_expr_field": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "set_default_dispatch": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "global_dispatch": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "destructure_tuples": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "metadata::tests::level_from_str": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "destructure_refs": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "parameters_with_fields": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "fmt::format::json::test::json": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "can_initialize_log_tracer_with_level": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "subscribe::tests::subscriber_is_collector": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "dispatch::test::spans_dont_infinite_loop": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "fmt::fmt_subscriber::test::synthesize_span_close": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "empty_field": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "skip": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "fmt::fmt_subscriber::test::synthesize_span_full": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "callsite::tests::linked_list_empty": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "custom_targets": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "layer::tests::dynamic_span_names": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "fmt::fmt_subscriber::test::fmt_subscriber_downcasts_to_parts": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "default_targets": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "field::test::empty_fields_are_skipped": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "tracer::tests::sampled_context": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "fmt::fmt_subscriber::test::fmt_subscriber_downcasts": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "metadata::tests::level_filter_is_usize_sized": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "fmt::format::json::test::json_disabled_current_span_event": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "registry::sharded::tests::multiple_subscribers_can_access_closed_span": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "tests::futures_01_tests::stream_enter_exit_is_reasonable": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "registry::extensions::tests::clear_retains_capacity": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "expr_field": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "metadata::tests::filter_level_conversion": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "fmt::format::json::test::json_nested_span": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "fmt::fmt_subscriber::test::is_lookup_span": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "normalized_metadata": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "subscribe::tests::two_subscribers_are_collector": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "registry::extensions::tests::test_extensions": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "two_expr_fields": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "destructure_tuple_structs": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "fmt::format::json::test::record_works": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "test_mut": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "custom_name_no_equals_test": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "custom_name_test": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "fmt::test::is_lookup_span": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "dispatch::test::default_no_collector": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "layer::tests::trace_id_from_existing_context": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "registry::sharded::tests::child_closes_grandparent": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "backtrace::tests::capture_supported": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "dispatch::test::default_dispatch": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "trace_with_active_otel_context": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "fmt::test::subscriber_downcasts": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "generics": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "field::delimited::test::delimited_visitor": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "test_mut_async": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "error_ends_span": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "test_early_return": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "registry::sharded::tests::span_enter_guards_are_dropped_out_of_order": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "tests::futures_01_tests::span_follows_future_onto_threadpool": {"run": "NONE", "test": "NONE", "fix": "PASS"}, "registry::sharded::tests::spans_are_removed_from_registry": {"run": "NONE", "test": "NONE", "fix": "PASS"}}
{"passed_count": 114, "failed_count": 1, "skipped_count": 1, "passed_tests": ["event_outside_of_span", "entered", "handles_to_different_spans_with_the_same_metadata_are_not_equal", "string_message_without_delims", "non_blocking::test::multi_threaded_writes", "rolling::test::write_hourly_log", "rolling::test::test_round_date_hourly", "span_with_parent", "trace_with_parent", "spans_always_go_to_the_subscriber_that_tagged_them", "rolling::test::test_round_date_minutely", "rolling::test::write_never_log", "event_macros_dont_infinite_loop", "prefixed_span_macros", "rolling::test::test_join_date_never", "trace_span", "locals_with_message", "span_closes_after_event", "warn_with_parent", "rolling::test::test_next_date_never", "rolling::test::test_next_date_daily", "warn_span", "info_root", "info", "borrow_val_events", "span", "move_field_out_of_struct", "nonzeroi32_event_without_message", "span_root", "info_span_root", "borrow_val_spans", "locals_no_message", "both_shorthands", "new_span_with_target_and_log_level", "record_new_values_for_fields", "rolling::test::test_round_date_daily", "rolling::test::test_next_date_minutely", "trace", "span_closes_when_exited", "prefixed_event_macros", "entered_api", "debug_shorthand", "event_with_message", "debug_root", "event_root", "contextual_root", "callsite_macro_api", "rolling::test::write_minutely_log", "contextual_child", "error_span_with_parent", "debug_span_root", "cloning_a_span_calls_clone_span", "explicit_child", "warn_root", "trace_span_root", "non_blocking::test::backpressure_exerted", "debug", "record_new_value_for_field", "rolling::test::write_daily_log", "one_with_everything", "event_without_message", "enter", "info_with_parent", "explicit_child_at_levels", "trace_span_with_parent", "warn", "rolling::test::test_rotation_path_daily", "trace_root", "dropping_a_span_calls_drop_span", "moved_field", "display_shorthand", "warn_span_with_parent", "multiple_max_level_hints", "warn_span_root", "dotted_field_name", "event", "field_shorthand_only", "error_span_root", "error_root", "handles_to_different_spans_are_not_equal", "info_span", "rolling::test::test_rotation_path_minutely", "error_span", "explicit_child_regardless_of_ctx", "borrowed_field", "rolling::test::test_rotation_path_hourly", "info_span_with_parent", "explicit_root_span_is_root_regardless_of_ctx", "event_with_parent", "max_level_hints", "message_without_delims", "debug_span_with_parent", "spans_always_go_to_the_subscriber_that_tagged_them_even_across_threads", "filter_caching_is_lexically_scoped", "handles_to_the_same_span_are_equal", "debug_span", "clone_and_drop_span_always_go_to_the_subscriber_that_tagged_the_span", "async_fn_with_async_trait_and_fields_expressions", "events_dont_leak", "new_span_after_event", "error", "explicit_root_span_is_root", "async_fn_nested", "async_fn_only_enters_for_polls", "error_with_parent", "span_with_non_rust_symbol", "filters_are_reevaluated_for_different_call_sites", "async_fn_with_async_trait_and_fields_expressions_with_generic_parameter", "rolling::test::test_next_date_hourly", "debug_with_parent", "filters_are_not_reevaluated_for_the_same_span", "wrapping_event_without_message", "spans_dont_leak", "drop_span_when_exiting_dispatchers_context"], "failed_tests": ["async_fn_with_async_trait"], "skipped_tests": ["non_blocking::test::logs_dropped_if_lossy"]}
{"passed_count": 114, "failed_count": 1, "skipped_count": 1, "passed_tests": ["event_outside_of_span", "entered", "handles_to_different_spans_with_the_same_metadata_are_not_equal", "string_message_without_delims", "non_blocking::test::multi_threaded_writes", "rolling::test::write_hourly_log", "rolling::test::test_round_date_hourly", "span_with_parent", "trace_with_parent", "spans_always_go_to_the_subscriber_that_tagged_them", "rolling::test::test_round_date_minutely", "rolling::test::write_never_log", "event_macros_dont_infinite_loop", "prefixed_span_macros", "rolling::test::test_join_date_never", "trace_span", "locals_with_message", "span_closes_after_event", "warn_with_parent", "rolling::test::test_next_date_never", "rolling::test::test_next_date_daily", "warn_span", "info_root", "info", "borrow_val_events", "span", "move_field_out_of_struct", "nonzeroi32_event_without_message", "span_root", "info_span_root", "borrow_val_spans", "locals_no_message", "both_shorthands", "new_span_with_target_and_log_level", "record_new_values_for_fields", "rolling::test::test_round_date_daily", "rolling::test::test_next_date_minutely", "trace", "span_closes_when_exited", "prefixed_event_macros", "entered_api", "debug_shorthand", "event_with_message", "debug_root", "event_root", "contextual_root", "callsite_macro_api", "rolling::test::write_minutely_log", "contextual_child", "error_span_with_parent", "debug_span_root", "cloning_a_span_calls_clone_span", "explicit_child", "warn_root", "trace_span_root", "non_blocking::test::backpressure_exerted", "debug", "record_new_value_for_field", "rolling::test::write_daily_log", "one_with_everything", "event_without_message", "enter", "info_with_parent", "explicit_child_at_levels", "trace_span_with_parent", "warn", "rolling::test::test_rotation_path_daily", "trace_root", "dropping_a_span_calls_drop_span", "moved_field", "display_shorthand", "warn_span_with_parent", "multiple_max_level_hints", "warn_span_root", "dotted_field_name", "event", "field_shorthand_only", "error_span_root", "error_root", "handles_to_different_spans_are_not_equal", "info_span", "rolling::test::test_rotation_path_minutely", "error_span", "explicit_child_regardless_of_ctx", "borrowed_field", "rolling::test::test_rotation_path_hourly", "info_span_with_parent", "explicit_root_span_is_root_regardless_of_ctx", "event_with_parent", "max_level_hints", "message_without_delims", "debug_span_with_parent", "spans_always_go_to_the_subscriber_that_tagged_them_even_across_threads", "filter_caching_is_lexically_scoped", "handles_to_the_same_span_are_equal", "debug_span", "clone_and_drop_span_always_go_to_the_subscriber_that_tagged_the_span", "async_fn_with_async_trait_and_fields_expressions", "events_dont_leak", "new_span_after_event", "error", "explicit_root_span_is_root", "async_fn_nested", "async_fn_only_enters_for_polls", "error_with_parent", "span_with_non_rust_symbol", "filters_are_reevaluated_for_different_call_sites", "async_fn_with_async_trait_and_fields_expressions_with_generic_parameter", "rolling::test::test_next_date_hourly", "debug_with_parent", "filters_are_not_reevaluated_for_the_same_span", "wrapping_event_without_message", "spans_dont_leak", "drop_span_when_exiting_dispatchers_context"], "failed_tests": ["async_fn_with_async_trait"], "skipped_tests": ["non_blocking::test::logs_dropped_if_lossy"]}
{"passed_count": 244, "failed_count": 26, "skipped_count": 2, "passed_tests": ["event_outside_of_span", "entered", "handles_to_different_spans_with_the_same_metadata_are_not_equal", "string_message_without_delims", "non_blocking::test::multi_threaded_writes", "rolling::test::write_hourly_log", "nested_set_default", "backtrace::tests::capture_unsupported", "fmt::format::test::with_ansi_false", "fmt::format::json::test::json_flattened_event", "inject_context_into_outgoing_requests", "fmt::format::test::without_level", "fmt::format::test::overridden_parents_in_scope", "test::info_callsite_is_correct", "fmt::test::subscriber_downcasts_to_parts", "rolling::test::test_round_date_hourly", "field::test::value_sets_with_fields_from_other_callsites_are_empty", "span_with_parent", "dispatch::test::dispatch_is", "trace_with_parent", "test::warn_callsite_is_correct", "spans_always_go_to_the_subscriber_that_tagged_them", "tests::futures_01_tests::future_error_ends_span", "rolling::test::test_round_date_minutely", "rolling::test::write_never_log", "destructure_structs", "field::test::value_set_with_no_values_is_empty", "callsite::tests::linked_list_push_several", "event_macros_dont_infinite_loop", "registry::stack::tests::pop_first_span", "registry::sharded::tests::spans_are_only_closed_when_the_last_ref_drops", "clashy_expr_field", "prefixed_span_macros", "set_default_dispatch", "global_dispatch", "registry::stack::tests::pop_last_span", "rolling::test::test_join_date_never", "trace_span", "locals_with_message", "destructure_tuples", "metadata::tests::level_from_str", "fmt::fmt_subscriber::test::synthesize_span_none", "span_closes_after_event", "warn_with_parent", "field::delimited::test::delimited_new_visitor", "rolling::test::test_next_date_never", "rolling::test::test_next_date_daily", "destructure_refs", "parameters_with_fields", "warn_span", "info_root", "numeric_levels", "fmt::format::json::test::json", "can_initialize_log_tracer_with_level", "info", "borrow_val_events", "override_everything", "test::debug_callsite_is_correct", "registry::sharded::tests::single_subscriber_can_access_closed_span", "subscribe::tests::subscriber_is_collector", "span", "move_field_out_of_struct", "tests::futures_01_tests::future_enter_exit_is_reasonable", "fmt::format::test::overridden_parents", "dispatch::test::events_dont_infinite_loop", "dispatch::test::spans_dont_infinite_loop", "nonzeroi32_event_without_message", "destructure_nested_tuples", "capture_supported", "span_root", "fields", "info_span_root", "fmt::fmt_subscriber::test::synthesize_span_close", "borrow_val_spans", "test", "fmt::fmt_subscriber::test::synthesize_span_active", "locals_no_message", "layer::tests::span_kind", "both_shorthands", "new_span_with_target_and_log_level", "record_new_values_for_fields", "rolling::test::test_round_date_daily", "self_expr_field", "rolling::test::test_next_date_minutely", "fmt::format::json::test::json_disabled_span_list_event", "enter_exit_is_reasonable", "empty_field", "trace", "skip", "fmt::fmt_subscriber::test::synthesize_span_close_no_timing", "span_closes_when_exited", "fmt::format::json::test::json_no_span", "fmt::writer::test::custom_writer_closure", "prefixed_event_macros", "entered_api", "callsite::tests::linked_list_empty", "fmt::fmt_subscriber::test::synthesize_span_full", "fmt::writer::test::custom_writer_mutex", "custom_targets", "debug_shorthand", "event_with_message", "debug_root", "layer::tests::dynamic_span_names", "fmt::fmt_subscriber::test::fmt_subscriber_downcasts_to_parts", "default_targets", "field::test::sparse_value_sets_are_not_empty", "event_root", "contextual_root", "fmt::format::test::with_ansi_true", "callsite_macro_api", "field::test::empty_fields_are_skipped", "field::test::fields_from_other_callsets_are_skipped", "tracer::tests::sampled_context", "subscribe::tests::three_subscribers_are_collector", "rolling::test::write_minutely_log", "tracer::tests::assigns_default_trace_id_if_missing", "contextual_child", "error_span_with_parent", "async_fn_with_async_trait", "debug_span_root", "cloning_a_span_calls_clone_span", "explicit_child", "warn_root", "trace_span_root", "fmt::fmt_subscriber::test::fmt_subscriber_downcasts", "non_blocking::test::backpressure_exerted", "field::test::empty_value_set_is_empty", "metadata::tests::level_filter_is_usize_sized", "fmt::format::json::test::json_disabled_current_span_event", "named_levels", "test::error_callsite_is_correct", "debug", "record_new_value_for_field", "rolling::test::write_daily_log", "test_async", "backtrace::tests::capture_empty", "one_with_everything", "event_without_message", "enter", "registry::sharded::tests::multiple_subscribers_can_access_closed_span", "tests::futures_01_tests::stream_enter_exit_is_reasonable", "info_with_parent", "registry::extensions::tests::clear_retains_capacity", "layer::tests::includes_timings", "fmt::writer::test::custom_writer_struct", "expr_field", "explicit_child_at_levels", "trace_span_with_parent", "warn", "rolling::test::test_rotation_path_daily", "metadata::tests::filter_level_conversion", "trace_root", "fmt::format::json::test::json_nested_span", "trace_root_with_children", "dropping_a_span_calls_drop_span", "fmt::fmt_subscriber::test::is_lookup_span", "moved_field", "normalized_metadata", "subscribe::tests::two_subscribers_are_collector", "impl_trait_return_type", "registry::extensions::tests::clear_drops_elements", "registry::extensions::tests::test_extensions", "two_expr_fields", "display_shorthand", "destructure_tuple_structs", "fmt::format::json::test::record_works", "warn_span_with_parent", "test_mut", "multiple_max_level_hints", "custom_name_no_equals_test", "custom_name_test", "warn_span_root", "fmt::test::is_lookup_span", "dotted_field_name", "event", "test::trace_callsite_is_correct", "field_shorthand_only", "fmt::format::test::format_nanos", "field::test::record_debug_fn", "subscribe::tests::downcasts_to_collector", "error_span_root", "error_root", "registry::sharded::tests::child_closes_parent", "dispatch::test::default_no_collector", "handles_to_different_spans_are_not_equal", "info_span", "rolling::test::test_rotation_path_minutely", "backtrace::tests::capture_supported", "layer::tests::trace_id_from_existing_context", "registry::sharded::tests::child_closes_grandparent", "error_span", "trace_with_assigned_otel_context", "default_name_test", "explicit_child_regardless_of_ctx", "dispatch::test::default_dispatch", "borrowed_field", "trace_with_active_otel_context", "rolling::test::test_rotation_path_hourly", "info_span_with_parent", "fmt::test::subscriber_downcasts", "explicit_root_span_is_root_regardless_of_ctx", "event_with_parent", "generics", "max_level_hints", "message_without_delims", "debug_span_with_parent", "spans_always_go_to_the_subscriber_that_tagged_them_even_across_threads", "filter_caching_is_lexically_scoped", "handles_to_the_same_span_are_equal", "debug_span", "clone_and_drop_span_always_go_to_the_subscriber_that_tagged_the_span", "field::delimited::test::delimited_visitor", "subscribe::tests::downcasts_to_subscriber", "async_fn_with_async_trait_and_fields_expressions", "events_dont_leak", "test_mut_async", "new_span_after_event", "error", "methods", "error_ends_span", "explicit_root_span_is_root", "destructure_everything", "async_fn_nested", "async_fn_only_enters_for_polls", "metadata::tests::level_filter_reprs", "test_early_return", "error_with_parent", "span_with_non_rust_symbol", "filters_are_reevaluated_for_different_call_sites", "callsite::tests::linked_list_push", "async_fn_with_async_trait_and_fields_expressions_with_generic_parameter", "fmt::test::impls", "registry::sharded::tests::span_enter_guards_are_dropped_out_of_order", "rolling::test::test_next_date_hourly", "debug_with_parent", "filters_are_not_reevaluated_for_the_same_span", "wrapping_event_without_message", "spans_dont_leak", "tests::futures_01_tests::span_follows_future_onto_threadpool", "fmt::fmt_subscriber::test::impls", "drop_span_when_exiting_dispatchers_context", "registry::sharded::tests::spans_are_removed_from_registry", "dispatch::test::dispatch_downcasts", "metadata_macro_api"], "failed_tests": ["filter::env::directive::test::directive_ordering_by_target_len", "filter::env::tests::callsite_enabled_includes_span_directive_field", "filter::env::directive::test::parse_directives_global", "filter::env::tests::roundtrip", "filter::env::directive::test::parse_directives_global_bare_warn_mixed", "filter::env::directive::test::parse_directives_valid", "filter::env::directive::test::parse_directives_ralith", "filter::env::directive::test::parse_directives_global_bare_warn_uc", "filter::env::tests::callsite_enabled_no_span_directive", "filter::env::directive::test::directive_ordering_uses_lexicographic_when_equal", "filter::env::directive::test::directive_ordering_by_span", "filter::env::tests::callsite_off", "filter::env::directive::test::parse_numeric_level_directives", "filter::env::tests::callsite_enabled_includes_span_directive_multiple_fields", "filter::env::directive::test::parse_directives_valid_with_spans", "filter::env::directive::test::parse_level_directives", "filter::env::directive::test::parse_directives_with_dash_in_target_name", "filter::env::directive::test::parse_directives_empty_level", "filter::env::directive::test::parse_directives_global_bare_warn_lc", "filter::env::directive::test::parse_directives_invalid_crate", "filter::env::directive::test::parse_directives_invalid_level", "filter::env::directive::test::parse_uppercase_level_directives", "filter::env::directive::test::parse_directives_ralith_mixed", "filter::env::directive::test::parse_directives_ralith_uc", "filter::env::tests::callsite_enabled_includes_span_directive", "filter::env::directive::test::parse_directives_string_level"], "skipped_tests": ["non_blocking::test::logs_dropped_if_lossy", "filter::env::directive::test::directive_ordering_by_field_num"]}