span 与 Event 的数据

#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct Id(NonZeroU64);

pub struct Attributes<'a> {
    metadata: &'static Metadata<'static>,
    values: &'a field::ValueSet<'a>,
    parent: Parent,
}

pub struct Record<'a> {
    values: &'a field::ValueSet<'a>,
}

#[derive(Debug)]
pub(crate) enum Parent {
    /// The new span will be a root span.
    Root,
    /// The new span will be rooted in the current span.
    Current,
    /// The new span has an explicitly-specified parent.
    Explicit(Id),
}

let parent = match parent.into() {
    Some(p) => Parent::Explicit(p),
    None => Parent::Root,
};

let new_span = match parent.into() {
    Some(parent) => Attributes::child_of(parent, meta, values),
    None => Attributes::new_root(meta, values),
};

impl<'a> From<&'a Span> for Option<Id> {
    fn from(span: &'a Span) -> Self {
        span.inner.as_ref().map(Inner::id)
    }
}

fn new_span(&self, attrs: &span::Attributes<'_>) -> span::Id {
    let parent = if attrs.is_root() {
        None
    } else if attrs.is_contextual() {
        self.current_span().id().map(|id| self.clone_span(id))
    } else {
        attrs.parent().map(|id| self.clone_span(id))
    };
    // ...

if event.is_root() {
    None
} else if event.is_contextual() {
    self.lookup_current()
} else {
    // TODO(eliza): this should handle parent IDs
    event.parent().and_then(|id| self.span(id))
}

tracing = "=0.1.44"

use std::{
  cell::RefCell,
  sync::atomic::{AtomicU64, Ordering},
};

use tracing::{span, Event, Level, Metadata, Subscriber};

// 最小的打印 subscriber：自己分配 Id、自己维护「当前 span」栈
struct Printer {
  next_id: AtomicU64,
}

thread_local! {
  static STACK: RefCell<Vec<u64>> = const { RefCell::new(Vec::new()) };
}

fn current() -> Option<u64> {
  STACK.with(|s| s.borrow().last().copied())
}

fn kind(is_root: bool, is_contextual: bool, parent: Option<&span::Id>) -> String {
  match (is_root, is_contextual, parent) {
    (true, _, _) => "root".to_string(),
    (_, true, _) => format!("contextual -> current = {:?}", current()),
    (_, _, Some(p)) => format!("explicit({})", p.into_u64()),
    _ => unreachable!("Parent 只有三种"),
  }
}

impl Subscriber for Printer {
  fn enabled(&self, meta: &Metadata<'_>) -> bool {
    // DEBUG 及更详细的 span/事件一律关掉
    *meta.level() <= Level::INFO
  }
  fn new_span(&self, attrs: &span::Attributes<'_>) -> span::Id {
    let id = self.next_id.fetch_add(1, Ordering::Relaxed);
    println!(
      "new_span {:<8} id={id}  {}",
      attrs.metadata().name(),
      kind(attrs.is_root(), attrs.is_contextual(), attrs.parent()),
    );
    span::Id::from_u64(id)
  }
  fn record(&self, _: &span::Id, _: &span::Record<'_>) {}
  fn record_follows_from(&self, _: &span::Id, _: &span::Id) {}
  fn event(&self, event: &Event<'_>) {
    let mut msg = String::new();
    event.record(&mut |_: &tracing::field::Field, v: &dyn std::fmt::Debug| {
      msg = format!("{v:?}");
    });
    println!(
      "event    {msg:<8}       {}",
      kind(event.is_root(), event.is_contextual(), event.parent()),
    );
  }
  fn enter(&self, id: &span::Id) {
    STACK.with(|s| s.borrow_mut().push(id.into_u64()));
  }
  fn exit(&self, _: &span::Id) {
    STACK.with(|s| s.borrow_mut().pop());
  }
}

fn main() {
  let sub = Printer { next_id: AtomicU64::new(1) };
  tracing::subscriber::with_default(sub, || {
    let outer = tracing::info_span!("outer");
    tracing::info!("e0");
    let _g = outer.enter();
    let ctx = tracing::info_span!("ctx");
    let root = tracing::info_span!(parent: None, "root");
    let off = tracing::debug_span!("off");
    let child = tracing::info_span!(parent: &root, "child");
    let orphan = tracing::info_span!(parent: &off, "orphan");
    tracing::info!("e1");
    tracing::info!(parent: None, "e2");
    tracing::info!(parent: &root, "e3");
    tracing::info!(parent: &off, "e4");
    drop((ctx, child, orphan));
  });
  println!(
    "size_of: Id={} Option<Id>={}",
    std::mem::size_of::<span::Id>(),
    std::mem::size_of::<Option<span::Id>>(),
  );
}

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

use tracing::{span, Event, Subscriber};
use tracing_subscriber::{
  filter::LevelFilter, layer::Context, prelude::*, registry::LookupSpan, Layer,
};

// 让 Registry 去解析父 span，这个 layer 只负责把结果打印出来
struct ShowParent;

impl<S> Layer<S> for ShowParent
where
  S: Subscriber + for<'a> LookupSpan<'a>,
{
  fn on_new_span(&self, _: &span::Attributes<'_>, id: &span::Id, ctx: Context<'_, S>) {
    let span = ctx.span(id).expect("刚创建的 span 一定在 Registry 里");
    let parent = span.parent().map(|p| p.name());
    println!("new_span {:<8} parent = {parent:?}", span.name());
  }
  fn on_event(&self, event: &Event<'_>, ctx: Context<'_, S>) {
    let mut msg = String::new();
    event.record(&mut |_: &tracing::field::Field, v: &dyn std::fmt::Debug| {
      msg = format!("{v:?}");
    });
    let parent = ctx.event_span(event).map(|s| s.name());
    println!("event    {msg:<8} parent = {parent:?}");
  }
}

fn main() {
  let sub = tracing_subscriber::registry().with(LevelFilter::INFO).with(ShowParent);
  tracing::subscriber::with_default(sub, || {
    // ... 与上一个程序相同的 span 和事件
  });
}

enum CurrentInner {
    Current {
        id: Id,
        metadata: &'static Metadata<'static>,
    },
    None,
    Unknown,
}

pub struct Event<'a> {
    fields: &'a field::ValueSet<'a>,
    metadata: &'static Metadata<'static>,
    parent: Parent,
}

pub fn dispatch(metadata: &'static Metadata<'static>, fields: &'a field::ValueSet<'_>) {
    let event = Event::new(metadata, fields);
    crate::dispatcher::get_default(|current| {
        current.event(&event);
    });
}

pub fn event(&self, event: &Event<'_>) {
    let subscriber = self.subscriber();
    if subscriber.event_enabled(event) {
        subscriber.event(event);
    }
}

new_span outer    id=1  contextual -> current = None
event    e0             contextual -> current = None
new_span ctx      id=2  contextual -> current = Some(1)
new_span root     id=3  root
new_span child    id=4  explicit(3)
new_span orphan   id=5  root
event    e1             contextual -> current = Some(1)
event    e2             root
event    e3             explicit(3)
event    e4             root
size_of: Id=8 Option<Id>=8

new_span outer    parent = None
event    e0       parent = None
new_span ctx      parent = Some("outer")
new_span root     parent = None
new_span child    parent = Some("root")
new_span orphan   parent = None
event    e1       parent = Some("outer")
event    e2       parent = None
event    e3       parent = Some("root")
event    e4       parent = None