Layer 与 Layered

pub trait Layer<S>
where
    S: Subscriber,
    Self: 'static,
{
    fn on_register_dispatch(&self, subscriber: &Dispatch) { /* ... */ }
    fn on_layer(&mut self, subscriber: &mut S) { /* ... */ }
    fn register_callsite(&self, metadata: &'static Metadata<'static>) -> Interest { /* ... */ }
    fn enabled(&self, metadata: &Metadata<'_>, ctx: Context<'_, S>) -> bool { /* ... */ }
    fn on_new_span(&self, attrs: &span::Attributes<'_>, id: &span::Id, ctx: Context<'_, S>) { /* ... */ }
    #[doc(hidden)]
    fn max_level_hint(&self) -> Option<LevelFilter> { /* ... */ }
    fn on_record(&self, _span: &span::Id, _values: &span::Record<'_>, _ctx: Context<'_, S>) {}
    fn on_follows_from(&self, _span: &span::Id, _follows: &span::Id, _ctx: Context<'_, S>) {}
    fn event_enabled(&self, _event: &Event<'_>, _ctx: Context<'_, S>) -> bool { /* ... */ }
    fn on_event(&self, _event: &Event<'_>, _ctx: Context<'_, S>) {}
    fn on_enter(&self, _id: &span::Id, _ctx: Context<'_, S>) {}
    fn on_exit(&self, _id: &span::Id, _ctx: Context<'_, S>) {}
    fn on_close(&self, _id: span::Id, _ctx: Context<'_, S>) {}
    fn on_id_change(&self, _old: &span::Id, _new: &span::Id, _ctx: Context<'_, S>) {}
    // ... and_then、with_subscriber、with_filter、boxed 等组合方法
    #[doc(hidden)]
    unsafe fn downcast_raw(&self, id: TypeId) -> Option<*const ()> { /* ... */ }
}

pub struct Context<'a, S> {
    subscriber: Option<&'a S>,
    // ...
    #[cfg(all(feature = "registry", feature = "std"))]
    filter: FilterId,
}

    fn ctx(&self) -> Context<'_, S> {
        Context::new(&self.inner)
    }

    fn with<L>(self, layer: L) -> Layered<L, Self>
    where
        L: Layer<Self>,
        Self: Sized,
    {
        layer.with_subscriber(self)
    }

    fn with_subscriber(mut self, mut inner: S) -> Layered<Self, S>
    where
        Self: Sized,
    {
        let inner_has_layer_filter = filter::subscriber_has_plf(&inner);
        self.on_layer(&mut inner);
        Layered::new(self, inner, inner_has_layer_filter)
    }

#[derive(Clone)]
pub struct Layered<L, I, S = I> {
    layer: L,
    inner: I,
    inner_is_registry: bool,
    has_layer_filter: bool,
    inner_has_layer_filter: bool,
    _s: PhantomData<fn(S)>,
}

        let inner_is_registry = TypeId::of::<S>() == TypeId::of::<crate::registry::Registry>();
        // ...
        let inner_has_layer_filter = inner_has_layer_filter || inner_is_registry;
        let has_layer_filter = filter::layer_has_plf(&layer);

    fn enabled(&self, metadata: &Metadata<'_>) -> bool {
        if self.layer.enabled(metadata, self.ctx()) {
            // if the outer layer enables the callsite metadata, ask the subscriber.
            self.inner.enabled(metadata)
        } else {
            // otherwise, the callsite is disabled by the layer
            // ...
            #[cfg(feature = "registry")]
            filter::FilterState::clear_enabled();

            false
        }
    }

    fn new_span(&self, span: &span::Attributes<'_>) -> span::Id {
        let id = self.inner.new_span(span);
        self.layer.on_new_span(span, &id, self.ctx());
        id
    }
    // ...
    fn event(&self, event: &Event<'_>) {
        self.inner.event(event);
        self.layer.on_event(event, self.ctx());
    }

    fn try_close(&self, id: span::Id) -> bool {
        #[cfg(all(feature = "registry", feature = "std"))]
        let subscriber = &self.inner as &dyn Subscriber;
        #[cfg(all(feature = "registry", feature = "std"))]
        let mut guard = subscriber
            .downcast_ref::<Registry>()
            .map(|registry| registry.start_close(id.clone()));
        if self.inner.try_close(id.clone()) {
            // ...
            #[cfg(all(feature = "registry", feature = "std"))]
            {
                if let Some(g) = guard.as_mut() {
                    g.set_closing()
                };
            }

            self.layer.on_close(id, self.ctx());
            true
        } else {
            false
        }
    }

tracing = "=0.1.44"
tracing-core = "=0.1.36"
tracing-subscriber = "=0.3.23"

use tracing::span::{Attributes, Id, Record};
use tracing::{Dispatch, Event, Metadata, Subscriber};
use tracing_core::Interest;
use tracing_subscriber::layer::{Context, Layer, SubscriberExt};

// 一个只打印回调名字的 layer，名字用来区分 A、B、C
struct P(&'static str);

impl<S: Subscriber> Layer<S> for P {
  fn on_register_dispatch(&self, _: &Dispatch) {
    println!("  {} on_register_dispatch", self.0);
  }
  fn register_callsite(&self, meta: &'static Metadata<'static>) -> Interest {
    println!("  {} register_callsite {}", self.0, meta.name());
    Interest::sometimes() // 让 enabled 每次都被问到
  }
  fn enabled(&self, _: &Metadata<'_>, _: Context<'_, S>) -> bool {
    println!("  {} enabled", self.0);
    true
  }
  fn on_new_span(&self, _: &Attributes<'_>, id: &Id, _: Context<'_, S>) {
    println!("  {} on_new_span {:?}", self.0, id);
  }
  fn on_record(&self, _: &Id, _: &Record<'_>, _: Context<'_, S>) {
    println!("  {} on_record", self.0);
  }
  fn on_enter(&self, _: &Id, _: Context<'_, S>) {
    println!("  {} on_enter", self.0);
  }
  fn event_enabled(&self, _: &Event<'_>, _: Context<'_, S>) -> bool {
    println!("  {} event_enabled", self.0);
    true
  }
  fn on_event(&self, _: &Event<'_>, _: Context<'_, S>) {
    println!("  {} on_event", self.0);
  }
  fn on_exit(&self, _: &Id, _: Context<'_, S>) {
    println!("  {} on_exit", self.0);
  }
  fn on_close(&self, _: Id, _: Context<'_, S>) {
    println!("  {} on_close", self.0);
  }
}

fn main() {
  // Layered<C, Layered<B, Layered<A, Registry>>>
  let sub = tracing_subscriber::registry()
    .with(P("A"))
    .with(P("B"))
    .with(P("C"));
  println!("-- Dispatch::new");
  let dispatch = Dispatch::new(sub);
  tracing::dispatcher::with_default(&dispatch, || {
    println!("-- info_span!");
    let span = tracing::info_span!("req", id = tracing::field::Empty);
    println!("-- record");
    span.record("id", 7);
    println!("-- enter");
    let guard = span.enter();
    println!("-- info!");
    tracing::info!("hello");
    println!("-- exit");
    drop(guard);
    println!("-- drop(span)");
    drop(span);
  });
}

-- Dispatch::new
  A on_register_dispatch
  B on_register_dispatch
  C on_register_dispatch
-- info_span!
  C register_callsite req
  B register_callsite req
  A register_callsite req
  C enabled
  B enabled
  A enabled
  A on_new_span Id(1)
  B on_new_span Id(1)
  C on_new_span Id(1)
-- record
  A on_record
  B on_record
  C on_record
-- enter
  A on_enter
  B on_enter
  C on_enter
-- info!
  C register_callsite event src/bin/order.rs:61
  B register_callsite event src/bin/order.rs:61
  A register_callsite event src/bin/order.rs:61
  C enabled
  B enabled
  A enabled
  C event_enabled
  B event_enabled
  A event_enabled
  A on_event
  B on_event
  C on_event
-- exit
  A on_exit
  B on_exit
  C on_exit
-- drop(span)
  A on_close
  B on_close
  C on_close

    fn pick_interest(&self, outer: Interest, inner: impl FnOnce() -> Interest) -> Interest {
        if self.has_layer_filter {
            return inner();
        }

        // If the outer layer has disabled the callsite, return now so that
        // the inner layer/subscriber doesn't get its hopes up.
        if outer.is_never() {
            // ...
            #[cfg(feature = "registry")]
            filter::FilterState::take_interest();

            return outer;
        }

        // The `inner` closure will call `inner.register_callsite()`. We do this
        // before the `if` statement to  ensure that the inner subscriber is
        // informed that the callsite exists regardless of the outer layer's
        // filtering decision.
        let inner = inner();
        if outer.is_sometimes() {
            // if this interest is "sometimes", return "sometimes" to ensure that
            // filters are reevaluated.
            return outer;
        }

        // If there is a per-layer filter in the `inner` stack, and it returns
        // `never`, change the interest to `sometimes`, because the `outer`
        // layer didn't return `never`. This means that _some_ layer still wants
        // ...
        if inner.is_never() && self.inner_has_layer_filter {
            return Interest::sometimes();
        }

        // otherwise, allow the inner subscriber or subscriber to weigh in.
        inner
    }

use tracing::{Metadata, Subscriber};
use tracing_core::callsite::Callsite;
use tracing_core::metadata::Kind;
use tracing_core::{Interest, Level};
use tracing_subscriber::layer::{Layer, SubscriberExt};

// 手写一个静态调用点，拿到 &'static Metadata 直接喂给 register_callsite
struct Cs;
static CS: Cs = Cs;
impl Callsite for Cs {
  fn set_interest(&self, _: Interest) {}
  fn metadata(&self) -> &Metadata<'_> {
    &META
  }
}
static META: Metadata<'static> = tracing_core::metadata! {
  name: "demo",
  target: "demo",
  level: Level::INFO,
  fields: &[],
  callsite: &CS,
  kind: Kind::EVENT,
};

// 对任何调用点都回答同一个 Interest 的 layer
struct Fixed(&'static str, fn() -> Interest);

impl<S: Subscriber> Layer<S> for Fixed {
  fn register_callsite(&self, _: &'static Metadata<'static>) -> Interest {
    print!(" {}问过", self.0);
    (self.1)()
  }
}

fn name(i: &Interest) -> &'static str {
  if i.is_always() {
    "always"
  } else if i.is_sometimes() {
    "sometimes"
  } else {
    "never"
  }
}

fn main() {
  let all: [(&str, fn() -> Interest); 3] = [
    ("never", Interest::never),
    ("sometimes", Interest::sometimes),
    ("always", Interest::always),
  ];
  for (on, o) in all {
    for (inn, i) in all {
      // Layered<外层, Layered<内层, Registry>>
      let stack = tracing_subscriber::registry()
        .with(Fixed("内", i))
        .with(Fixed("外", o));
      print!("外 {on:<9} 内 {inn:<9} |");
      let got = stack.register_callsite(&META);
      println!(" => {}", name(&got));
    }
  }
}

外 never     内 never     | 外问过 => never
外 never     内 sometimes | 外问过 => never
外 never     内 always    | 外问过 => never
外 sometimes 内 never     | 外问过 内问过 => sometimes
外 sometimes 内 sometimes | 外问过 内问过 => sometimes
外 sometimes 内 always    | 外问过 内问过 => sometimes
外 always    内 never     | 外问过 内问过 => never
外 always    内 sometimes | 外问过 内问过 => sometimes
外 always    内 always    | 外问过 内问过 => always

        if self.inner_is_registry {
            return outer_hint;
        }
        // ...
        if super::layer_is_none(&self.layer) {
            return cmp::max(outer_hint, Some(inner_hint?));
        }

        // Similarly, if the layer on the inside is `None` and it returned an
        // `Off` hint, we want to override that with the outer hint.
        if inner_is_none && inner_hint == Some(LevelFilter::OFF) {
            return outer_hint;
        }

        cmp::max(outer_hint, inner_hint)

use tracing::{Event, Subscriber};
use tracing_core::LevelFilter;
use tracing_subscriber::layer::{Context, Layer, SubscriberExt};

struct Print;
impl<S: Subscriber> Layer<S> for Print {
  fn on_event(&self, e: &Event<'_>, _: Context<'_, S>) {
    println!("Print 收到 {}", e.metadata().level());
  }
}

fn main() {
  let sub = tracing_subscriber::registry()
    .with(Print)
    .with(vec![LevelFilter::INFO, LevelFilter::DEBUG]);
  tracing::subscriber::with_default(sub, || {
    tracing::info!("i");
    tracing::debug!("d");
    tracing::trace!("t");
  });
}

Print 收到 INFO
Print 收到 DEBUG

use tracing::{Dispatch, Subscriber};
use tracing_core::LevelFilter;
use tracing_subscriber::layer::{Layer, SubscriberExt};
use tracing_subscriber::registry;

struct Hello(&'static str);
impl<S: Subscriber> Layer<S> for Hello {
  fn on_register_dispatch(&self, _: &Dispatch) {
    println!("    {} 收到 on_register_dispatch", self.0);
  }
}

// 装进 Dispatch，打印此时的全局最大级别
fn show<S: Subscriber + Send + Sync>(label: &str, sub: S) {
  println!("{label}");
  let d = Dispatch::new(sub);
  println!("    LevelFilter::current() = {}", LevelFilter::current());
  drop(d);
}

fn main() {
  show("L", registry().with(Hello("L")));
  show("Box<L>", registry().with(Box::new(Hello("Box"))));
  show("Some(L)", registry().with(Some(Hello("Some"))));
  show("vec![L]", registry().with(vec![Hello("Vec")]));
  show("None", registry().with(None::<Hello>));
  show("INFO + None", registry().with(LevelFilter::INFO).with(None::<Hello>));
  show("L + None", registry().with(Hello("L")).with(None::<Hello>));
  show("vec![INFO, DEBUG]", registry().with(vec![LevelFilter::INFO, LevelFilter::DEBUG]));
  show("vec![]", registry().with(Vec::<LevelFilter>::new()));
}

L
    L 收到 on_register_dispatch
    LevelFilter::current() = trace
Box<L>
    Box 收到 on_register_dispatch
    LevelFilter::current() = trace
Some(L)
    LevelFilter::current() = trace
vec![L]
    LevelFilter::current() = trace
None
    LevelFilter::current() = off
INFO + None
    LevelFilter::current() = info
L + None
    L 收到 on_register_dispatch
    LevelFilter::current() = trace
vec![INFO, DEBUG]
    LevelFilter::current() = debug
vec![]
    LevelFilter::current() = off

Inner on_event
Outer on_event