feat(subscriber): Add with_span_list implementation for all standard formats.

humb1t · humb1t · commit 13c5c56295d3 · 2025-10-27T11:24:41.000Z
diff --git a/tracing-subscriber/src/fmt/fmt_layer.rs b/tracing-subscriber/src/fmt/fmt_layer.rs
@@ -484,6 +484,15 @@ where
         }
     }
 
+    /// Sets whether or not the formatter will include a list (from root to leaf)
+    /// of all currently entered spans in formatted events.
+    pub fn with_span_list(self, display_span_list: bool) -> Self {
+        Layer {
+            fmt_event: self.fmt_event.with_span_list(display_span_list),
+            ..self
+        }
+    }
+
     /// Sets whether or not an event's target is displayed.
     pub fn with_target(self, display_target: bool) -> Layer<S, N, format::Format<L, T>, W> {
         Layer {
@@ -643,21 +652,6 @@ impl<S, T, W> Layer<S, format::JsonFields, format::Format<format::Json, T>, W> {
             ..self
         }
     }
-
-    /// Sets whether or not the formatter will include a list (from root to leaf)
-    /// of all currently entered spans in formatted events.
-    ///
-    /// See [`format::Json`][super::format::Json]
-    pub fn with_span_list(
-        self,
-        display_span_list: bool,
-    ) -> Layer<S, format::JsonFields, format::Format<format::Json, T>, W> {
-        Layer {
-            fmt_event: self.fmt_event.with_span_list(display_span_list),
-            fmt_fields: format::JsonFields::new(),
-            ..self
-        }
-    }
 }
 
 impl<S, N, E, W> Layer<S, N, E, W> {
diff --git a/tracing-subscriber/src/fmt/format/json.rs b/tracing-subscriber/src/fmt/format/json.rs
@@ -92,7 +92,6 @@ use tracing_log::NormalizeEvent;
 pub struct Json {
     pub(crate) flatten_event: bool,
     pub(crate) display_current_span: bool,
-    pub(crate) display_span_list: bool,
 }
 
 impl Json {
@@ -105,12 +104,6 @@ impl Json {
     pub fn with_current_span(&mut self, display_current_span: bool) {
         self.display_current_span = display_current_span;
     }
-
-    /// If set to `false`, formatted events won't contain a list of all currently
-    /// entered spans. Spans are logged in a list from root to leaf.
-    pub fn with_span_list(&mut self, display_span_list: bool) {
-        self.display_span_list = display_span_list;
-    }
 }
 
 struct SerializableContext<'a, 'b, Span, N>(
@@ -252,8 +245,7 @@ where
 
             let format_field_marker: std::marker::PhantomData<N> = std::marker::PhantomData;
 
-            let current_span = if self.format.display_current_span || self.format.display_span_list
-            {
+            let current_span = if self.format.display_current_span || self.display_span_list {
                 event
                     .parent()
                     .and_then(|id| ctx.span(id))
@@ -296,7 +288,7 @@ where
                 }
             }
 
-            if self.format.display_span_list && current_span.is_some() {
+            if self.display_span_list && current_span.is_some() {
                 serializer.serialize_entry(
                     "spans",
                     &SerializableContext(&ctx.ctx, format_field_marker),
@@ -336,7 +328,6 @@ impl Default for Json {
         Json {
             flatten_event: false,
             display_current_span: true,
-            display_span_list: true,
         }
     }
 }
diff --git a/tracing-subscriber/src/fmt/format/mod.rs b/tracing-subscriber/src/fmt/format/mod.rs
@@ -412,6 +412,7 @@ pub struct Format<F = Full, T = SystemTime> {
     pub(crate) display_thread_name: bool,
     pub(crate) display_filename: bool,
     pub(crate) display_line_number: bool,
+    pub(crate) display_span_list: bool,
 }
 
 // === impl Writer ===
@@ -604,6 +605,7 @@ impl Default for Format<Full, SystemTime> {
             display_thread_name: false,
             display_filename: false,
             display_line_number: false,
+            display_span_list: true,
         }
     }
 }
@@ -624,6 +626,7 @@ impl<F, T> Format<F, T> {
             display_thread_name: self.display_thread_name,
             display_filename: self.display_filename,
             display_line_number: self.display_line_number,
+            display_span_list: self.display_line_number,
         }
     }
 
@@ -663,6 +666,7 @@ impl<F, T> Format<F, T> {
             display_thread_name: self.display_thread_name,
             display_filename: true,
             display_line_number: true,
+            display_span_list: self.display_line_number,
         }
     }
 
@@ -694,6 +698,7 @@ impl<F, T> Format<F, T> {
             display_thread_name: self.display_thread_name,
             display_filename: self.display_filename,
             display_line_number: self.display_line_number,
+            display_span_list: self.display_line_number,
         }
     }
 
@@ -723,6 +728,7 @@ impl<F, T> Format<F, T> {
             display_thread_name: self.display_thread_name,
             display_filename: self.display_filename,
             display_line_number: self.display_line_number,
+            display_span_list: self.display_line_number,
         }
     }
 
@@ -739,6 +745,7 @@ impl<F, T> Format<F, T> {
             display_thread_name: self.display_thread_name,
             display_filename: self.display_filename,
             display_line_number: self.display_line_number,
+            display_span_list: self.display_line_number,
         }
     }
 
@@ -820,6 +827,15 @@ impl<F, T> Format<F, T> {
             .with_file(display_location)
     }
 
+    /// If set to `false`, formatted events won't contain a list of all currently
+    /// entered spans. Spans are logged in a list from root to leaf.
+    pub fn with_span_list(self, display_span_list: bool) -> Self {
+        Format {
+            display_span_list,
+            ..self
+        }
+    }
+
     #[inline]
     fn format_timestamp(&self, writer: &mut Writer<'_>) -> fmt::Result
     where
@@ -887,17 +903,6 @@ impl<T> Format<Json, T> {
         self.format.with_current_span(display_current_span);
         self
     }
-
-    /// Sets whether or not the formatter will include a list (from root to
-    /// leaf) of all currently entered spans in formatted events.
-    ///
-    /// See [`format::Json`][Json]
-    #[cfg(feature = "json")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "json")))]
-    pub fn with_span_list(mut self, display_span_list: bool) -> Format<Json, T> {
-        self.format.with_span_list(display_span_list);
-        self
-    }
 }
 
 impl<S, N, T> FormatEvent<S, N> for Format<Full, T>
@@ -963,25 +968,34 @@ where
 
         let dimmed = writer.dimmed();
 
-        if let Some(scope) = ctx.event_scope() {
+        if let Some(mut scope) = ctx.event_scope() {
             let bold = writer.bold();
-
-            let mut seen = false;
-
-            for span in scope.from_root() {
+            if self.display_span_list {
+                let scope_from_root = scope.from_root();
+                let mut seen = false;
+                for span in scope_from_root {
+                    write!(writer, "{}", bold.paint(span.metadata().name()))?;
+                    seen = true;
+                    let ext = span.extensions();
+                    if let Some(fields) = &ext.get::<FormattedFields<N>>() {
+                        if !fields.is_empty() {
+                            write!(writer, "{}{}{}", bold.paint("{"), fields, bold.paint("}"))?;
+                        }
+                    }
+                    write!(writer, "{}", dimmed.paint(":"))?;
+                }
+                if seen {
+                    writer.write_char(' ')?;
+                }
+            } else if let Some(span) = scope.next() {
                 write!(writer, "{}", bold.paint(span.metadata().name()))?;
-                seen = true;
-
                 let ext = span.extensions();
                 if let Some(fields) = &ext.get::<FormattedFields<N>>() {
                     if !fields.is_empty() {
                         write!(writer, "{}{}{}", bold.paint("{"), fields, bold.paint("}"))?;
                     }
                 }
                 write!(writer, "{}", dimmed.paint(":"))?;
-            }
-
-            if seen {
                 writer.write_char(' ')?;
             }
         };
@@ -1092,11 +1106,16 @@ where
         let fmt_ctx = {
             #[cfg(feature = "ansi")]
             {
-                FmtCtx::new(ctx, event.parent(), writer.has_ansi_escapes())
+                FmtCtx::new(
+                    ctx,
+                    event.parent(),
+                    self.display_span_list,
+                    writer.has_ansi_escapes(),
+                )
             }
             #[cfg(not(feature = "ansi"))]
             {
-                FmtCtx::new(&ctx, event.parent())
+                FmtCtx::new(&ctx, event.parent(), self.display_span_list)
             }
         };
         write!(writer, "{}", fmt_ctx)?;
@@ -1144,11 +1163,20 @@ where
 
         ctx.format_fields(writer.by_ref(), event)?;
 
-        for span in ctx
-            .event_scope()
-            .into_iter()
-            .flat_map(crate::registry::Scope::from_root)
-        {
+        if self.display_span_list {
+            for span in ctx
+                .event_scope()
+                .into_iter()
+                .flat_map(crate::registry::Scope::from_root)
+            {
+                let exts = span.extensions();
+                if let Some(fields) = exts.get::<FormattedFields<N>>() {
+                    if !fields.is_empty() {
+                        write!(writer, " {}", dimmed.paint(&fields.fields))?;
+                    }
+                }
+            }
+        } else if let Some(span) = ctx.event_scope().as_mut().and_then(|scope| scope.next()) {
             let exts = span.extensions();
             if let Some(fields) = exts.get::<FormattedFields<N>>() {
                 if !fields.is_empty() {
@@ -1347,6 +1375,7 @@ impl Display for ErrorSourceList<'_> {
 struct FmtCtx<'a, S, N> {
     ctx: &'a FmtContext<'a, S, N>,
     span: Option<&'a span::Id>,
+    display_span_list: bool,
     #[cfg(feature = "ansi")]
     ansi: bool,
 }
@@ -1360,14 +1389,28 @@ where
     pub(crate) fn new(
         ctx: &'a FmtContext<'_, S, N>,
         span: Option<&'a span::Id>,
+        display_span_list: bool,
         ansi: bool,
     ) -> Self {
-        Self { ctx, span, ansi }
+        Self {
+            ctx,
+            span,
+            ansi,
+            display_span_list,
+        }
     }
 
     #[cfg(not(feature = "ansi"))]
-    pub(crate) fn new(ctx: &'a FmtContext<'_, S, N>, span: Option<&'a span::Id>) -> Self {
-        Self { ctx, span }
+    pub(crate) fn new(
+        ctx: &'a FmtContext<'_, S, N>,
+        span: Option<&'a span::Id>,
+        display_span_list: bool,
+    ) -> Self {
+        Self {
+            ctx,
+            span,
+            display_span_list,
+        }
     }
 
     fn bold(&self) -> Style {
@@ -1396,14 +1439,19 @@ where
             .and_then(|id| self.ctx.ctx.span(id))
             .or_else(|| self.ctx.ctx.lookup_current());
 
-        let scope = span.into_iter().flat_map(|span| span.scope().from_root());
+        if self.display_span_list {
+            let scope = span.into_iter().flat_map(|span| span.scope().from_root());
 
-        for span in scope {
-            seen = true;
-            write!(f, "{}:", bold.paint(span.metadata().name()))?;
-        }
+            for span in scope {
+                seen = true;
+                write!(f, "{}:", bold.paint(span.metadata().name()))?;
+            }
 
-        if seen {
+            if seen {
+                f.write_char(' ')?;
+            }
+        } else if let Some(span) = span.iter().next() {
+            write!(f, "{}:", bold.paint(span.metadata().name()))?;
             f.write_char(' ')?;
         }
         Ok(())
diff --git a/tracing-subscriber/src/fmt/format/pretty.rs b/tracing-subscriber/src/fmt/format/pretty.rs
@@ -327,6 +327,9 @@ where
             if !fields.is_empty() {
                 write!(writer, " {} {}", dimmed.paint("with"), fields)?;
             }
+            if !self.display_span_list {
+                break;
+            }
             writer.write_char('\n')?;
         }
 
@@ -478,7 +481,7 @@ impl field::Visit for PrettyVisitor<'_> {
             "message" => {
                 // Escape ANSI characters to prevent malicious patterns (e.g., terminal injection attacks)
                 self.write_padded(&format_args!("{}{:?}", self.style.prefix(), Escape(value)))
-            },
+            }
             // Skip fields that are actually log metadata that have already been handled
             #[cfg(feature = "tracing-log")]
             name if name.starts_with("log.") => self.result = Ok(()),
diff --git a/tracing-subscriber/src/fmt/mod.rs b/tracing-subscriber/src/fmt/mod.rs
@@ -615,6 +615,15 @@ where
         }
     }
 
+    /// Sets whether or not the subscriber being built will include a list (from
+    /// root to leaf) of all currently entered spans in formatted events.
+    pub fn with_span_list(self, display_span_list: bool) -> Self {
+        SubscriberBuilder {
+            inner: self.inner.with_span_list(display_span_list),
+            ..self
+        }
+    }
+
     /// Sets whether or not the formatter emits ANSI terminal escape codes
     /// for colors and other text formatting.
     ///
@@ -808,20 +817,6 @@ impl<T, F, W> SubscriberBuilder<format::JsonFields, format::Format<format::Json,
             inner: self.inner.with_current_span(display_current_span),
         }
     }
-
-    /// Sets whether or not the JSON subscriber being built will include a list (from
-    /// root to leaf) of all currently entered spans in formatted events.
-    ///
-    /// See [`format::Json`] for details.
-    pub fn with_span_list(
-        self,
-        display_span_list: bool,
-    ) -> SubscriberBuilder<format::JsonFields, format::Format<format::Json, T>, F, W> {
-        SubscriberBuilder {
-            filter: self.filter,
-            inner: self.inner.with_span_list(display_span_list),
-        }
-    }
 }
 
 #[cfg(feature = "env-filter")]

Original file line number	Diff line number	Diff line change
`@@ -92,7 +92,6 @@ use tracing_log::NormalizeEvent;`
`92`	`92`	`pub struct Json {`
`93`	`93`	`pub(crate) flatten_event: bool,`
`94`	`94`	`pub(crate) display_current_span: bool,`
`95`		`- pub(crate) display_span_list: bool,`
`96`	`95`	`}`
`97`	`96`
`98`	`97`	`impl Json {`
`@@ -105,12 +104,6 @@ impl Json {`
`105`	`104`	`pub fn with_current_span(&mut self, display_current_span: bool) {`
`106`	`105`	`self.display_current_span = display_current_span;`
`107`	`106`	`}`
`108`		`-`
`109`		- /// If set to `false`, formatted events won't contain a list of all currently
`110`		`- /// entered spans. Spans are logged in a list from root to leaf.`
`111`		`- pub fn with_span_list(&mut self, display_span_list: bool) {`
`112`		`- self.display_span_list = display_span_list;`
`113`		`- }`
`114`	`107`	`}`
`115`	`108`
`116`	`109`	`struct SerializableContext<'a, 'b, Span, N>(`
`@@ -252,8 +245,7 @@ where`
`252`	`245`
`253`	`246`	`let format_field_marker: std::marker::PhantomData<N> = std::marker::PhantomData;`
`254`	`247`
`255`		`- let current_span = if self.format.display_current_span \|\| self.format.display_span_list`
`256`		`- {`
	`248`	`+ let current_span = if self.format.display_current_span \|\| self.display_span_list {`
`257`	`249`	`event`
`258`	`250`	`.parent()`
`259`	`251`	`.and_then(\|id\| ctx.span(id))`
`@@ -296,7 +288,7 @@ where`
`296`	`288`	`}`
`297`	`289`	`}`
`298`	`290`
`299`		`- if self.format.display_span_list && current_span.is_some() {`
	`291`	`+ if self.display_span_list && current_span.is_some() {`
`300`	`292`	`serializer.serialize_entry(`
`301`	`293`	`"spans",`
`302`	`294`	`&SerializableContext(&ctx.ctx, format_field_marker),`
`@@ -336,7 +328,6 @@ impl Default for Json {`
`336`	`328`	`Json {`
`337`	`329`	`flatten_event: false,`
`338`	`330`	`display_current_span: true,`
`339`		`- display_span_list: true,`
`340`	`331`	`}`
`341`	`332`	`}`
`342`	`333`	`}`