T doesn't implement Debug

tracing = "=0.1.44"

use tracing::instrument;

#[instrument]
fn store<T>(key: &str, item: T) {}

fn main() {}

error[E0277]: `T` doesn't implement `Debug`
   --> src/bin/err_generic.rs:3:1
    |
  3 | #[instrument]
    | ^^^^^^^^^^^^^ the trait `Debug` is not implemented for `T`
    |
    = note: required for `&T` to implement `Debug`
note: required by a bound in `debug`
   --> ~/.cargo/registry/.../tracing-core-0.1.36/src/field.rs:379:8
    |
377 | pub fn debug<T>(t: T) -> DebugValue<T>
    |        ----- required by a bound in this function
378 | where
379 |     T: fmt::Debug,
    |        ^^^^^^^^^^ required by this bound in `debug`
    = note: this error originates in the attribute macro `instrument` (in Nightly builds, run with -Z macro-backtrace for more info)
help: consider restricting type parameter `T` with trait `Debug`
    |
  4 | fn store<T: std::fmt::Debug>(key: &str, item: T) {}
    |           +++++++++++++++++

struct Db {
  url: String,
}

impl Db {
  #[instrument]
  fn query(&self, sql: &str) {}
}

error[E0277]: `Db` doesn't implement `Debug`
   --> src/bin/err_self.rs:8:3
    |
  8 |   #[instrument]
    |   ^^^^^^^^^^^^^ the trait `Debug` is not implemented for `Db`
    |
    = note: required for `&Db` to implement `Debug`
    = note: 1 redundant requirement hidden
    = note: required for `&&Db` to implement `Debug`
// ... 以下同上，另有第二个同名错误

#[derive(Debug)]
struct MyError; // 只有 Debug，没有 Display

#[instrument(err)]
fn work() -> Result<(), MyError> {
  Err(MyError)
}

error[E0277]: `MyError` doesn't implement `std::fmt::Display`
   --> src/bin/err_no_display.rs:6:1
    |
  6 | #[instrument(err)]
    | ^^^^^^^^^^^^^^^^^^
    | |
    | unsatisfied trait bound
    | required by a bound introduced by this call
    |
help: the trait `std::fmt::Display` is not implemented for `MyError`
   --> src/bin/err_no_display.rs:4:1
    |
  4 | struct MyError; // 只有 Debug，没有 Display
    | ^^^^^^^^^^^^^^
    = note: required for `&MyError` to implement `std::fmt::Display`
note: required by a bound in `display`
// ...

            .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)),
            })

tracing = "=0.1.44"
tracing-subscriber = { version = "=0.3.23", default-features = false, features = ["fmt", "std"] }

use tracing::instrument;
use tracing_subscriber::fmt::format::FmtSpan;

struct Db {
  url: String,
}

impl Db {
  // 1. 跳过 self，需要的部分用 fields 记
  #[instrument(skip(self), fields(db = %self.url))]
  fn query(&self, sql: &str) {}
}

// 2. 跳过泛型参数，而不是给 T 加 Debug 约束
#[instrument(skip(item))]
fn store<T>(key: &str, item: T) {
  drop(item);
}

struct Conn {
  id: u32,
}

// 3. 全部跳过，只记想要的
#[instrument(skip_all, fields(conn_id = conn.id, len = payload.len()))]
fn send(conn: &Conn, payload: Vec<u8>) {}

// 4. 和参数同名的字段替换掉这个参数
#[instrument(fields(conn = conn.id))]
fn close(conn: &Conn) {}

#[derive(Debug)]
struct MyError;

// 5. 错误类型只有 Debug
#[instrument(err(Debug))]
fn work() -> Result<(), MyError> {
  Err(MyError)
}

fn main() {
  tracing_subscriber::fmt()
    .with_ansi(false)
    .without_time()
    .with_target(false)
    .with_span_events(FmtSpan::NEW)
    .init();

  let db = Db { url: "pg://db1".into() };
  db.query("select 1");
  store("k", vec![std::rc::Rc::new(())]);
  let conn = Conn { id: 7 };
  send(&conn, vec![0; 16]);
  close(&conn);
  let _ = work();
}

 INFO query{sql="select 1" db=pg://db1}: new
 INFO store{key="k"}: new
 INFO send{conn_id=7 len=16}: new
 INFO close{conn=7}: new
 INFO work: new
ERROR work: error=MyError