subscriber: skip RwLock in EnvFilter span callbacks when no dynamic directives

EnvFilter maintains `by_id: RwLock<HashMap<Id, SpanMatcher>>` and
`by_cs: RwLock<HashMap<Identifier, CallsiteMatcher>>` for tracking
per-span field-level match state. These maps are only populated when
`has_dynamics` is true (i.e., when the filter has span/field-level
directives like `my_crate[span_name]=debug`).

However, the span lifecycle callbacks (`on_new_span`, `on_enter`,
`on_exit`, `on_close`, `on_record`) unconditionally acquire the
`by_id` read lock (or write lock for `on_close`) on every call. When
`has_dynamics` is false — which is the common case for pure
target=level configurations like `RUST_LOG=info,hyper=warn` — these
maps are always empty, and the lock acquisition is wasted work.

Under high concurrency this becomes a bottleneck: a GDB backtrace of a
Tokio-based HTTP server under load showed ~25 worker threads contending
on these RwLock acquisitions, with threads in `read_contended` blocked
by `on_close`'s write lock. The contention scales with the number of
EnvFilter instances in the subscriber layer stack (one per layer when
using per-layer filtering).

This commit adds an early `if !self.has_dynamics { return; }` guard to
each of the five span lifecycle methods. This is a pure no-op when
dynamic directives are present (the existing code path runs unchanged),
and completely eliminates the lock traffic for the common static-only
configuration.

Author: Vineeth Rao Kanaparthi

tracing-subscriber/src/filter/env/mod.rs

@@ -566,6 +566,9 @@ impl EnvFilter {
     /// [`Filter::on_new_span`] methods on `EnvFilter`'s implementations of those
     /// traits, but it does not require the trait to be in scope.
     pub fn on_new_span<S>(&self, attrs: &span::Attributes<'_>, id: &span::Id, _: Context<'_, S>) {
+        if !self.has_dynamics {
+            return;
+        }
         let by_cs = try_lock!(self.by_cs.read());
         if let Some(cs) = by_cs.get(&attrs.metadata().callsite()) {
             let span = cs.to_span_match(attrs);
@@ -579,6 +582,9 @@ impl EnvFilter {
     /// [`Filter::on_enter`] methods on `EnvFilter`'s implementations of those
     /// traits, but it does not require the trait to be in scope.
     pub fn on_enter<S>(&self, id: &span::Id, _: Context<'_, S>) {
+        if !self.has_dynamics {
+            return;
+        }
         // XXX: This is where _we_ could push IDs to the stack instead, and use
         // that to allow changing the filter while a span is already entered.
         // But that might be much less efficient...
@@ -593,6 +599,9 @@ impl EnvFilter {
     /// [`Filter::on_exit`] methods on `EnvFilter`'s implementations of those
     /// traits, but it does not require the trait to be in scope.
     pub fn on_exit<S>(&self, id: &span::Id, _: Context<'_, S>) {
+        if !self.has_dynamics {
+            return;
+        }
         if self.cares_about_span(id) {
             self.scope.get_or_default().borrow_mut().pop();
         }
@@ -604,6 +613,9 @@ impl EnvFilter {
     /// [`Filter::on_close`] methods on `EnvFilter`'s implementations of those
     /// traits, but it does not require the trait to be in scope.
     pub fn on_close<S>(&self, id: span::Id, _: Context<'_, S>) {
+        if !self.has_dynamics {
+            return;
+        }
         // If we don't need to acquire a write lock, avoid doing so.
         if !self.cares_about_span(&id) {
             return;
@@ -620,6 +632,9 @@ impl EnvFilter {
     /// [`Filter::on_record`] methods on `EnvFilter`'s implementations of those
     /// traits, but it does not require the trait to be in scope
     pub fn on_record<S>(&self, id: &span::Id, values: &span::Record<'_>, _: Context<'_, S>) {
+        if !self.has_dynamics {
+            return;
+        }
         if let Some(span) = try_lock!(self.by_id.read()).get(id) {
             span.record_update(values);
         }

tracing-subscriber/tests/env_filter/per_layer.rs

@@ -304,3 +304,97 @@ fn multiple_dynamic_filters() {
     handle1.assert_finished();
     handle2.assert_finished();
 }
+
+/// Tests that a static-only `EnvFilter` (no span-name or field-level
+/// directives) correctly filters events inside spans.
+///
+/// This is a regression test for an optimization that skips acquiring the
+/// `by_id` RwLock when `has_dynamics` is false. Without the span lifecycle
+/// callbacks, events inside spans must still be filtered correctly based on
+/// the static target/level directives.
+#[test]
+fn static_filter_events_inside_spans() {
+    let filter: EnvFilter = "info,stuff=debug".parse().expect("filter should parse");
+    let cool_span = expect::span().named("cool_span");
+    let (layer, handle) = layer::mock()
+        .new_span(cool_span.clone())
+        .enter(cool_span.clone())
+        .event(
+            expect::event()
+                .at_level(Level::DEBUG)
+                .with_target("stuff")
+                .in_scope(vec![cool_span.clone()]),
+        )
+        .event(
+            expect::event()
+                .at_level(Level::INFO)
+                .in_scope(vec![cool_span.clone()]),
+        )
+        .exit(cool_span)
+        .only()
+        .run_with_handle();
+
+    let _subscriber = tracing_subscriber::registry()
+        .with(layer.with_filter(filter))
+        .set_default();
+
+    {
+        let _span = tracing::info_span!("cool_span").entered();
+        tracing::debug!(target: "stuff", "target-enabled debug inside span");
+        tracing::trace!("should be disabled even inside span");
+        tracing::info!("info inside span");
+    }
+
+    handle.assert_finished();
+}
+
+/// Tests that a static-only `EnvFilter` (no dynamic directives) used as a
+/// per-layer filter correctly handles span enter/exit/close without
+/// interacting with the `by_id`/`by_cs` RwLocks.
+///
+/// This verifies the optimization is safe: multiple spans can be created,
+/// entered, exited, and dropped with a static-only filter, and events are
+/// filtered purely by target and level.
+#[test]
+fn static_filter_multiple_spans() {
+    let filter: EnvFilter = "info,stuff=debug".parse().expect("filter should parse");
+    let span_a = expect::span().named("span_a");
+    let span_b = expect::span().named("span_b");
+    let (layer, handle) = layer::mock()
+        .new_span(span_a.clone())
+        .enter(span_a.clone())
+        .event(
+            expect::event()
+                .at_level(Level::INFO)
+                .in_scope(vec![span_a.clone()]),
+        )
+        .new_span(span_b.clone())
+        .enter(span_b.clone())
+        .event(
+            expect::event()
+                .at_level(Level::DEBUG)
+                .with_target("stuff")
+                .in_scope(vec![span_b.clone(), span_a.clone()]),
+        )
+        .exit(span_b)
+        .exit(span_a)
+        .only()
+        .run_with_handle();
+
+    let _subscriber = tracing_subscriber::registry()
+        .with(layer.with_filter(filter))
+        .set_default();
+
+    {
+        let _a = tracing::info_span!("span_a").entered();
+        tracing::debug!("should be disabled by default level");
+        tracing::info!("info in span_a");
+        {
+            let _b = tracing::info_span!("span_b").entered();
+            tracing::debug!(target: "stuff", "debug in nested span_b");
+            tracing::trace!(target: "stuff", "trace should be disabled");
+        }
+    }
+
+    handle.assert_finished();
+}