字段：Field、Value 与 Visit

pub struct FieldSet {
    /// The names of each field on the described span.
    names: &'static [&'static str],
    /// The callsite where the described span originates.
    callsite: callsite::Identifier,
}

::tracing_core::field::FieldSet::new(
    &[
        "message",
        {
            const NAME: ::tracing::__macro_support::FieldName<
                { ::tracing::__macro_support::FieldName::len("answer") },
            > = ::tracing::__macro_support::FieldName::new("answer");
            NAME.as_str()
        },
        // ... "user"、"p" 同样
    ],
    ::tracing_core::callsite::Identifier(&__CALLSITE),
),

pub struct Field {
    i: usize,
    fields: FieldSet,
}

impl PartialEq for Field {
    fn eq(&self, other: &Self) -> bool {
        self.callsite() == other.callsite() && self.i == other.i
    }
}

pub struct ValueSet<'a> {
    values: Values<'a>,
    fields: &'a FieldSet,
}

enum Values<'a> {
    /// A set of field-value pairs. Fields may be for the wrong field set, some
    /// fields may be missing, and fields may be in any order.
    Explicit(&'a [(&'a Field, Option<&'a (dyn Value + 'a)>)]),
    /// A list of values corresponding exactly to the fields in a `FieldSet`.
    All(&'a [Option<&'a (dyn Value + 'a)>]),
}

__CALLSITE
    .metadata()
    .fields()
    .value_set_all(
        &[
            (::tracing::__macro_support::Option::Some(
                &format_args!("hi {0}", 7) as &dyn ::tracing::field::Value,
            )),
            (::tracing::__macro_support::Option::Some(
                &42 as &dyn ::tracing::field::Value,
            )),
            (::tracing::__macro_support::Option::Some(
                &::tracing::field::display(&name)
                    as &dyn ::tracing::field::Value,
            )),
            (::tracing::__macro_support::Option::Some(
                &::tracing::field::debug(&p) as &dyn ::tracing::field::Value,
            )),
        ],
    )

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

// 节选：分配器、StackVisitor、NoAlloc 的定义略
fn run(label: &str) {
  let name = "alice";
  let p = Point { x: 1, y: 2 };
  // 先跑一次，让调用点注册等一次性工作发生在计数之外
  for round in 0..2 {
    let before = ALLOCS.load(Ordering::Relaxed);
    for i in 0..N {
      tracing::info!(i, name, user = %name, p = ?p, ok = true, "req {} done", i);
    }
    let after = ALLOCS.load(Ordering::Relaxed);
    println!("{label:<10} round {round}: {} allocs for {N} events", after - before);
  }
}

fn main() {
  tracing::subscriber::with_default(NoAlloc, || run("NoAlloc"));
  let fmt_sub = tracing_subscriber::fmt()
    .with_ansi(false)
    .with_writer(std::io::sink)
    .finish();
  tracing::subscriber::with_default(fmt_sub, || run("fmt+sink"));
}

NoAlloc    round 0: 0 allocs for 10000 events
NoAlloc    round 1: 0 allocs for 10000 events
fmt+sink   round 0: 5 allocs for 10000 events
fmt+sink   round 1: 0 allocs for 10000 events

pub trait Value: crate::sealed::Sealed {
    /// Visits this value with the given `Visitor`.
    fn record(&self, key: &Field, visitor: &mut dyn Visit);
}

error[E0277]: the trait bound `Point: tracing_core::sealed::Sealed` is not satisfied
   --> src/bin/sealed.rs:5:16
    |
  5 | impl Value for Point {
    |                ^^^^^ unsatisfied trait bound
...
    = note: `Value` is a "sealed trait", because to implement it you also need to implement `tracing_core::sealed::Sealed`, which is not accessible; this is usually done to force you to use one of the provided types that already implement it

impl<T> Value for DisplayValue<T>
where
    T: fmt::Display,
{
    fn record(&self, key: &Field, visitor: &mut dyn Visit) {
        visitor.record_debug(key, self)
    }
}

impl<T: fmt::Display> fmt::Debug for DisplayValue<T> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt::Display::fmt(self, f)
    }
}

pub trait Visit {
    // ...
    fn record_f64(&mut self, field: &Field, value: f64) {
        self.record_debug(field, &value)
    }

    fn record_i64(&mut self, field: &Field, value: i64) {
        self.record_debug(field, &value)
    }
    // ... record_u64、record_i128、record_u128、record_bool、record_str 同样

    fn record_bytes(&mut self, field: &Field, value: &[u8]) {
        self.record_debug(field, &HexBytes(value))
    }

    #[cfg(feature = "std")]
    #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
    fn record_error(&mut self, field: &Field, value: &(dyn std::error::Error + 'static)) {
        self.record_debug(field, &DisplayValue(value))
    }

    fn record_debug(&mut self, field: &Field, value: &dyn fmt::Debug);
}

tracing = "=0.1.44"

use std::{error::Error, fmt, io};

use tracing::{
  field::{Field, Visit},
  span, Event, Metadata, Subscriber,
};

// 覆盖全部 record_* 方法，只打印「哪个方法被调用了」
struct WhichMethod;

impl Visit for WhichMethod {
  fn record_i64(&mut self, f: &Field, v: i64) {
    println!("  {:<6} record_i64({v})", f.name());
  }
  // ... record_u64、record_f64、record_bool 同样
  fn record_str(&mut self, f: &Field, v: &str) {
    println!("  {:<6} record_str({v:?})", f.name());
  }
  fn record_error(&mut self, f: &Field, v: &(dyn Error + 'static)) {
    println!("  {:<6} record_error({v})", f.name());
  }
  fn record_debug(&mut self, f: &Field, v: &dyn fmt::Debug) {
    println!("  {:<6} record_debug({v:?})", f.name());
  }
}

// 只实现必需的 record_debug，其余全靠默认实现
struct DebugOnly;

impl Visit for DebugOnly {
  fn record_debug(&mut self, f: &Field, v: &dyn fmt::Debug) {
    println!("  {:<6} {v:?}", f.name());
  }
}

struct Printer;

impl Subscriber for Printer {
  fn enabled(&self, _: &Metadata<'_>) -> bool {
    true
  }
  fn new_span(&self, _: &span::Attributes<'_>) -> span::Id {
    span::Id::from_u64(1)
  }
  fn record(&self, _: &span::Id, _: &span::Record<'_>) {}
  fn record_follows_from(&self, _: &span::Id, _: &span::Id) {}
  fn event(&self, event: &Event<'_>) {
    println!("WhichMethod:");
    event.record(&mut WhichMethod);
    println!("DebugOnly:");
    event.record(&mut DebugOnly);
  }
  fn enter(&self, _: &span::Id) {}
  fn exit(&self, _: &span::Id) {}
}

#[derive(Debug)]
#[allow(dead_code)]
struct Point {
  x: i32,
  y: i32,
}

fn main() {
  let owned = String::from("owned");
  let err = io::Error::new(io::ErrorKind::NotFound, "no such file");
  tracing::subscriber::with_default(Printer, || {
    tracing::info!(
      i = -1i64,
      u = 1u64,
      small = 7u8,
      f = 1.5f64,
      b = true,
      s = "lit",
      owned,
      p = ?Point { x: 1, y: 2 },
      disp = %"lit",
      dbg = ?"lit",
      e = &err as &dyn Error,
      "hello {}",
      42
    );
  });
}

WhichMethod:
  message record_debug(hello 42)
  i      record_i64(-1)
  u      record_u64(1)
  small  record_u64(7)
  f      record_f64(1.5)
  b      record_bool(true)
  s      record_str("lit")
  owned  record_str("owned")
  p      record_debug(Point { x: 1, y: 2 })
  disp   record_debug(lit)
  dbg    record_debug("lit")
  e      record_error(no such file)
DebugOnly:
  message hello 42
  i      -1
  u      1
  small  7
  f      1.5
  b      true
  s      "lit"
  owned  "owned"
  p      Point { x: 1, y: 2 }
  disp   lit
  dbg    "lit"
  e      no such file

let span = tracing::info_span!("req", user = tracing::field::Empty);
// ...
span.record("user", "alice");

new_span a: x#0=1
new_span b: x#0=1
ax == bx: false
b_fields.contains(&ax): false
record   (len=1): x#0=3
record   (len=1): y#1="later"
record   (len=1): y#1=20
record   (len=1): y#1=4
record   (len=1): x#0=6
size_of: Field=40 FieldSet=32 ValueSet=32 Option<&dyn Value>=16