宏展开

tracing = "=0.1.44"

fn main() {
  let x = 1;
  tracing::info!("x = {}", x);
  let _span = tracing::info_span!("req", id = 1);
}

  = note: expanding `info! { "x = {}", x }`
  = note: expanding `event! { target : module_path! (), $crate :: Level :: INFO, "x = {}", x }`
  = note: expanding `event! { target : module_path! (), $crate :: Level :: INFO, { "x = {}", x } }`
  = note: expanding `callsite2! { name : $crate :: __macro_support :: concat!
  = note: expanding `metadata! { name :
  = note: expanding `fieldset! { "x = {}", x }`
  = note: expanding `fieldset! { @ {} "x = {}", x, }`
  = note: expanding `fieldset! { @ { "message", , } }`
  = note: expanding `identify_callsite! { & __CALLSITE }`
  = note: expanding `level_enabled! { $crate :: Level :: INFO }`
  = note: expanding `__tracing_log! { $crate :: Level :: INFO, __CALLSITE, & value_set }`
  = note: expanding `valueset_all! { __CALLSITE.metadata().fields(), "x = {}", x }`
  = note: expanding `valueset_all! { @ {}, "x = {}", x }`
  = note: expanding `valueset_all! { @
  = note: expanding `__tracing_log! { $crate :: Level :: INFO, __CALLSITE, & $crate :: valueset_all!

    {
        use ::tracing::__macro_support::Callsite as _;
        static __CALLSITE: ::tracing::callsite::DefaultCallsite = {
            static META: ::tracing::Metadata<'static> = {
                ::tracing_core::metadata::Metadata::new(
                    "event src/bin/expand_me.rs:3",
                    "expand_me",
                    ::tracing::Level::INFO,
                    ::tracing_core::__macro_support::Option::Some(
                        "src/bin/expand_me.rs",
                    ),
                    ::tracing_core::__macro_support::Option::Some(3u32),
                    ::tracing_core::__macro_support::Option::Some("expand_me"),
                    ::tracing_core::field::FieldSet::new(
                        &["message"],
                        ::tracing_core::callsite::Identifier(&__CALLSITE),
                    ),
                    ::tracing::metadata::Kind::EVENT,
                )
            };
            ::tracing::callsite::DefaultCallsite::new(&META)
        };
        let enabled = ::tracing::Level::INFO
            <= ::tracing::level_filters::STATIC_MAX_LEVEL
            && ::tracing::Level::INFO <= ::tracing::level_filters::LevelFilter::current()
            && {
                let interest = __CALLSITE.interest();
                !interest.is_never()
                    && ::tracing::__macro_support::__is_enabled(
                        __CALLSITE.metadata(),
                        interest,
                    )
            };
        if enabled {
            (|value_set: ::tracing::field::ValueSet| {
                let meta = __CALLSITE.metadata();
                ::tracing::Event::dispatch(meta, &value_set);
            })({
                #[allow(unused_imports)]
                use ::tracing::field::{debug, display, Value};
                __CALLSITE
                    .metadata()
                    .fields()
                    .value_set_all(
                        &[
                            (::tracing::__macro_support::Option::Some(
                                &format_args!("x = {0}", x) as &dyn ::tracing::field::Value,
                            )),
                        ],
                    )
            });
        } else {
        }
    };

    let _span = {
        use ::tracing::__macro_support::Callsite as _;
        static __CALLSITE: ::tracing::callsite::DefaultCallsite = {
            static META: ::tracing::Metadata<'static> = {
                // ... Metadata::new("req", "expand_me", Level::INFO, ...,
                //     FieldSet::new(&[ /* "id" */ ], Identifier(&__CALLSITE)), Kind::SPAN)
            };
            ::tracing::callsite::DefaultCallsite::new(&META)
        };
        let mut interest = ::tracing::subscriber::Interest::never();
        if ::tracing::Level::INFO <= ::tracing::level_filters::STATIC_MAX_LEVEL
            && ::tracing::Level::INFO <= ::tracing::level_filters::LevelFilter::current()
            && {
                interest = __CALLSITE.interest();
                !interest.is_never()
            }
            && ::tracing::__macro_support::__is_enabled(__CALLSITE.metadata(), interest)
        {
            let meta = __CALLSITE.metadata();
            ::tracing::Span::new(
                meta,
                &{
                    #[allow(unused_imports)]
                    use ::tracing::field::{debug, display, Value};
                    meta.fields()
                        .value_set_all(
                            &[
                                (::tracing::__macro_support::Option::Some(
                                    &1 as &dyn ::tracing::field::Value,
                                )),
                            ],
                        )
                },
            )
        } else {
            let span = ::tracing::__macro_support::__disabled_span(
                __CALLSITE.metadata(),
            );
            {};
            span
        }
    };

#[derive(Debug)]
struct User {
  name: &'static str,
}

struct Ip(&'static str);

impl fmt::Display for Ip {
  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    write!(f, "ip:{}", self.0)
  }
}

const KEY: &str = "dyn.key";

fn main() {
  let user = User { name: "ann" };
  let ip = Ip("10.0.0.1");
  let n = 7;
  let r#type = "admin";
  tracing::subscriber::with_default(Print, || {
    tracing::info!(
      a = 1,
      b = ?user,
      c = %ip,
      user.name = user.name,
      "http.status" = 200u16,
      { KEY } = true,
      n,
      user.name,
      ?user,
      %ip,
      r#type,
      "done {}", n
    );
  });
}

fields = {message, a, b, c, user.name, http.status, dyn.key, n, user.name, user, ip, type}
  message      <- record_debug: done 7
  a            <- record_i64: 1
  b            <- record_debug: User { name: "ann" }
  c            <- record_debug: ip:10.0.0.1
  user.name    <- record_str: "ann"
  http.status  <- record_u64: 200
  dyn.key      <- record_bool: true
  n            <- record_i64: 7
  user.name    <- record_str: "ann"
  user         <- record_debug: User { name: "ann" }
  ip           <- record_debug: ip:10.0.0.1
  type         <- record_str: "admin"

    ($fields:expr, $($kvs:tt)+) => {
        {
            #[allow(unused_imports)]
            // This import statement CANNOT be removed as it will break existing use cases.
            // See #831, #2332, #3424 for the last times we tried.
            use $crate::field::{debug, display, Value};
            $fields.value_set_all($crate::valueset_all!(
                @ { },
                $($kvs)+
            ))
        }
    };

tracing = { version = "=0.1.44", features = ["log"] }

        } else {
            if match ::tracing::Level::INFO {
                ::tracing::Level::ERROR => ::tracing::log::Level::Error,
                // ...
                _ => ::tracing::log::Level::Trace,
            } <= ::tracing::log::STATIC_MAX_LEVEL
            {
                if !::tracing::dispatcher::has_been_set() {
                    {
                        use ::tracing::log;
                        // ...
                            if logger.enabled(&log_meta) {
                                ::tracing::__macro_support::__tracing_log(
                                    meta,
                                    logger,
                                    log_meta,
                                    &{
                                        // ... 同样的 value_set_all(&[ format_args!("x = {0}", x) ... ])
                                    },
                                )
                            }
                        // ...
                    }
                } else {
                    {}
                }
            } else {
                {}
            };
        }

error[E0277]: `fn(_) -> DebugValue<_> {debug::<_>}` doesn't implement `Debug`
 --> src/bin/clash.rs:3:26
  |
3 |   tracing::info!("debug: {debug:?}");
  |                          ^^^^^^^^^ `fn(_) -> DebugValue<_> {debug::<_>}` cannot be formatted using `{:?}` because it doesn't implement `Debug`
  |
  = help: the trait `Debug` is not implemented for fn item `fn(_) -> DebugValue<_> {debug::<_>}`
  = note: this error originates in the macro `$crate::__macro_support::format_args` which comes from the expansion of the macro `tracing::info` (in Nightly builds, run with -Z macro-backtrace for more info)

For more information about this error, try `rustc --explain E0277`.
error: could not compile `exp-tracing-macros` (bin "clash") due to 1 previous error