tracing_subscriber/fmt/
fmt_layer.rs

1use crate::{
2    field::RecordFields,
3    fmt::{format, FormatEvent, FormatFields, MakeWriter, TestWriter},
4    layer::{self, Context},
5    registry::{self, LookupSpan, SpanRef},
6};
7use format::{FmtSpan, TimingDisplay};
8use std::{
9    any::TypeId, cell::RefCell, env, fmt, io, marker::PhantomData, ops::Deref, time::Instant,
10};
11use tracing_core::{
12    field,
13    span::{Attributes, Current, Id, Record},
14    Event, Metadata, Subscriber,
15};
16
17/// A [`Layer`] that logs formatted representations of `tracing` events.
18///
19/// ## Examples
20///
21/// Constructing a layer with the default configuration:
22///
23/// ```rust
24/// use tracing_subscriber::{fmt, Registry};
25/// use tracing_subscriber::prelude::*;
26///
27/// let subscriber = Registry::default()
28///     .with(fmt::Layer::default());
29///
30/// tracing::subscriber::set_global_default(subscriber).unwrap();
31/// ```
32///
33/// Overriding the layer's behavior:
34///
35/// ```rust
36/// use tracing_subscriber::{fmt, Registry};
37/// use tracing_subscriber::prelude::*;
38///
39/// let fmt_layer = fmt::layer()
40///    .with_target(false) // don't include event targets when logging
41///    .with_level(false); // don't include event levels when logging
42///
43/// let subscriber = Registry::default().with(fmt_layer);
44/// # tracing::subscriber::set_global_default(subscriber).unwrap();
45/// ```
46///
47/// Setting a custom event formatter:
48///
49/// ```rust
50/// use tracing_subscriber::fmt::{self, format, time};
51/// use tracing_subscriber::prelude::*;
52///
53/// let fmt = format().with_timer(time::Uptime::default());
54/// let fmt_layer = fmt::layer()
55///     .event_format(fmt)
56///     .with_target(false);
57/// # let subscriber = fmt_layer.with_subscriber(tracing_subscriber::registry::Registry::default());
58/// # tracing::subscriber::set_global_default(subscriber).unwrap();
59/// ```
60///
61/// [`Layer`]: super::layer::Layer
62#[cfg_attr(docsrs, doc(cfg(all(feature = "fmt", feature = "std"))))]
63#[derive(Debug)]
64pub struct Layer<
65    S,
66    N = format::DefaultFields,
67    E = format::Format<format::Full>,
68    W = fn() -> io::Stdout,
69> {
70    make_writer: W,
71    fmt_fields: N,
72    fmt_event: E,
73    fmt_span: format::FmtSpanConfig,
74    is_ansi: bool,
75    log_internal_errors: bool,
76    _inner: PhantomData<fn(S)>,
77}
78
79impl<S> Layer<S> {
80    /// Returns a new [`Layer`][self::Layer] with the default configuration.
81    pub fn new() -> Self {
82        Self::default()
83    }
84}
85
86// This needs to be a seperate impl block because they place different bounds on the type parameters.
87impl<S, N, E, W> Layer<S, N, E, W>
88where
89    S: Subscriber + for<'a> LookupSpan<'a>,
90    N: for<'writer> FormatFields<'writer> + 'static,
91    W: for<'writer> MakeWriter<'writer> + 'static,
92{
93    /// Sets the [event formatter][`FormatEvent`] that the layer being built will
94    /// use to format events.
95    ///
96    /// The event formatter may be any type implementing the [`FormatEvent`]
97    /// trait, which is implemented for all functions taking a [`FmtContext`], a
98    /// [`Writer`], and an [`Event`].
99    ///
100    /// # Examples
101    ///
102    /// Setting a type implementing [`FormatEvent`] as the formatter:
103    /// ```rust
104    /// use tracing_subscriber::fmt::{self, format};
105    ///
106    /// let layer = fmt::layer()
107    ///     .event_format(format().compact());
108    /// # // this is necessary for type inference.
109    /// # use tracing_subscriber::Layer as _;
110    /// # let _ = layer.with_subscriber(tracing_subscriber::registry::Registry::default());
111    /// ```
112    /// [`FormatEvent`]: format::FormatEvent
113    /// [`Event`]: tracing::Event
114    /// [`Writer`]: format::Writer
115    pub fn event_format<E2>(self, e: E2) -> Layer<S, N, E2, W>
116    where
117        E2: FormatEvent<S, N> + 'static,
118    {
119        Layer {
120            fmt_fields: self.fmt_fields,
121            fmt_event: e,
122            fmt_span: self.fmt_span,
123            make_writer: self.make_writer,
124            is_ansi: self.is_ansi,
125            log_internal_errors: self.log_internal_errors,
126            _inner: self._inner,
127        }
128    }
129
130    /// Updates the event formatter by applying a function to the existing event formatter.
131    ///
132    /// This sets the event formatter that the layer being built will use to record fields.
133    ///
134    /// # Examples
135    ///
136    /// Updating an event formatter:
137    ///
138    /// ```rust
139    /// let layer = tracing_subscriber::fmt::layer()
140    ///     .map_event_format(|e| e.compact());
141    /// # // this is necessary for type inference.
142    /// # use tracing_subscriber::Layer as _;
143    /// # let _ = layer.with_subscriber(tracing_subscriber::registry::Registry::default());
144    /// ```
145    pub fn map_event_format<E2>(self, f: impl FnOnce(E) -> E2) -> Layer<S, N, E2, W>
146    where
147        E2: FormatEvent<S, N> + 'static,
148    {
149        Layer {
150            fmt_fields: self.fmt_fields,
151            fmt_event: f(self.fmt_event),
152            fmt_span: self.fmt_span,
153            make_writer: self.make_writer,
154            is_ansi: self.is_ansi,
155            log_internal_errors: self.log_internal_errors,
156            _inner: self._inner,
157        }
158    }
159}
160
161// This needs to be a seperate impl block because they place different bounds on the type parameters.
162impl<S, N, E, W> Layer<S, N, E, W> {
163    /// Sets the [`MakeWriter`] that the layer being built will use to write events.
164    ///
165    /// # Examples
166    ///
167    /// Using `stderr` rather than `stdout`:
168    ///
169    /// ```rust
170    /// use std::io;
171    /// use tracing_subscriber::fmt;
172    ///
173    /// let layer = fmt::layer()
174    ///     .with_writer(io::stderr);
175    /// # // this is necessary for type inference.
176    /// # use tracing_subscriber::Layer as _;
177    /// # let _ = layer.with_subscriber(tracing_subscriber::registry::Registry::default());
178    /// ```
179    pub fn with_writer<W2>(self, make_writer: W2) -> Layer<S, N, E, W2>
180    where
181        W2: for<'writer> MakeWriter<'writer> + 'static,
182    {
183        Layer {
184            fmt_fields: self.fmt_fields,
185            fmt_event: self.fmt_event,
186            fmt_span: self.fmt_span,
187            is_ansi: self.is_ansi,
188            log_internal_errors: self.log_internal_errors,
189            make_writer,
190            _inner: self._inner,
191        }
192    }
193
194    /// Borrows the [writer] for this [`Layer`].
195    ///
196    /// [writer]: MakeWriter
197    pub fn writer(&self) -> &W {
198        &self.make_writer
199    }
200
201    /// Mutably borrows the [writer] for this [`Layer`].
202    ///
203    /// This method is primarily expected to be used with the
204    /// [`reload::Handle::modify`](crate::reload::Handle::modify) method.
205    ///
206    /// # Examples
207    ///
208    /// ```
209    /// # use tracing::info;
210    /// # use tracing_subscriber::{fmt,reload,Registry,prelude::*};
211    /// # fn non_blocking<T: std::io::Write>(writer: T) -> (fn() -> std::io::Stdout) {
212    /// #   std::io::stdout
213    /// # }
214    /// # fn main() {
215    /// let layer = fmt::layer().with_writer(non_blocking(std::io::stderr()));
216    /// let (layer, reload_handle) = reload::Layer::new(layer);
217    /// #
218    /// # // specifying the Registry type is required
219    /// # let _: &reload::Handle<fmt::Layer<Registry, _, _, _>, Registry> = &reload_handle;
220    /// #
221    /// info!("This will be logged to stderr");
222    /// reload_handle.modify(|layer| *layer.writer_mut() = non_blocking(std::io::stdout()));
223    /// info!("This will be logged to stdout");
224    /// # }
225    /// ```
226    ///
227    /// [writer]: MakeWriter
228    pub fn writer_mut(&mut self) -> &mut W {
229        &mut self.make_writer
230    }
231
232    /// Sets whether this layer should use ANSI terminal formatting
233    /// escape codes (such as colors).
234    ///
235    /// This method is primarily expected to be used with the
236    /// [`reload::Handle::modify`](crate::reload::Handle::modify) method when changing
237    /// the writer.
238    #[cfg(feature = "ansi")]
239    #[cfg_attr(docsrs, doc(cfg(feature = "ansi")))]
240    pub fn set_ansi(&mut self, ansi: bool) {
241        self.is_ansi = ansi;
242    }
243
244    /// Configures the layer to support [`libtest`'s output capturing][capturing] when used in
245    /// unit tests.
246    ///
247    /// See [`TestWriter`] for additional details.
248    ///
249    /// # Examples
250    ///
251    /// Using [`TestWriter`] to let `cargo test` capture test output:
252    ///
253    /// ```rust
254    /// use std::io;
255    /// use tracing_subscriber::fmt;
256    ///
257    /// let layer = fmt::layer()
258    ///     .with_test_writer();
259    /// # // this is necessary for type inference.
260    /// # use tracing_subscriber::Layer as _;
261    /// # let _ = layer.with_subscriber(tracing_subscriber::registry::Registry::default());
262    /// ```
263    /// [capturing]:
264    /// https://doc.rust-lang.org/book/ch11-02-running-tests.html#showing-function-output
265    /// [`TestWriter`]: super::writer::TestWriter
266    pub fn with_test_writer(self) -> Layer<S, N, E, TestWriter> {
267        Layer {
268            fmt_fields: self.fmt_fields,
269            fmt_event: self.fmt_event,
270            fmt_span: self.fmt_span,
271            is_ansi: self.is_ansi,
272            log_internal_errors: self.log_internal_errors,
273            make_writer: TestWriter::default(),
274            _inner: self._inner,
275        }
276    }
277
278    /// Sets whether or not the formatter emits ANSI terminal escape codes
279    /// for colors and other text formatting.
280    ///
281    /// When the "ansi" crate feature flag is enabled, ANSI colors are enabled
282    /// by default unless the [`NO_COLOR`] environment variable is set to
283    /// a non-empty value.  If the [`NO_COLOR`] environment variable is set to
284    /// any non-empty value, then ANSI colors will be suppressed by default.
285    /// The [`with_ansi`] and [`set_ansi`] methods can be used to forcibly
286    /// enable ANSI colors, overriding any [`NO_COLOR`] environment variable.
287    ///
288    /// [`NO_COLOR`]: https://no-color.org/
289    ///
290    /// Enabling ANSI escapes (calling `with_ansi(true)`) requires the "ansi"
291    /// crate feature flag. Calling `with_ansi(true)` without the "ansi"
292    /// feature flag enabled will panic if debug assertions are enabled, or
293    /// print a warning otherwise.
294    ///
295    /// This method itself is still available without the feature flag. This
296    /// is to allow ANSI escape codes to be explicitly *disabled* without
297    /// having to opt-in to the dependencies required to emit ANSI formatting.
298    /// This way, code which constructs a formatter that should never emit
299    /// ANSI escape codes can ensure that they are not used, regardless of
300    /// whether or not other crates in the dependency graph enable the "ansi"
301    /// feature flag.
302    ///
303    /// [`with_ansi`]: Subscriber::with_ansi
304    /// [`set_ansi`]: Subscriber::set_ansi
305    pub fn with_ansi(self, ansi: bool) -> Self {
306        #[cfg(not(feature = "ansi"))]
307        if ansi {
308            const ERROR: &str =
309                "tracing-subscriber: the `ansi` crate feature is required to enable ANSI terminal colors";
310            #[cfg(debug_assertions)]
311            panic!("{}", ERROR);
312            #[cfg(not(debug_assertions))]
313            eprintln!("{}", ERROR);
314        }
315
316        Self {
317            is_ansi: ansi,
318            ..self
319        }
320    }
321
322    /// Sets whether to write errors from [`FormatEvent`] to the writer.
323    /// Defaults to true.
324    ///
325    /// By default, `fmt::Layer` will write any `FormatEvent`-internal errors to
326    /// the writer. These errors are unlikely and will only occur if there is a
327    /// bug in the `FormatEvent` implementation or its dependencies.
328    ///
329    /// If writing to the writer fails, the error message is printed to stderr
330    /// as a fallback.
331    ///
332    /// [`FormatEvent`]: crate::fmt::FormatEvent
333    pub fn log_internal_errors(self, log_internal_errors: bool) -> Self {
334        Self {
335            log_internal_errors,
336            ..self
337        }
338    }
339
340    /// Updates the [`MakeWriter`] by applying a function to the existing [`MakeWriter`].
341    ///
342    /// This sets the [`MakeWriter`] that the layer being built will use to write events.
343    ///
344    /// # Examples
345    ///
346    /// Redirect output to stderr if level is <= WARN:
347    ///
348    /// ```rust
349    /// use tracing::Level;
350    /// use tracing_subscriber::fmt::{self, writer::MakeWriterExt};
351    ///
352    /// let stderr = std::io::stderr.with_max_level(Level::WARN);
353    /// let layer = fmt::layer()
354    ///     .map_writer(move |w| stderr.or_else(w));
355    /// # // this is necessary for type inference.
356    /// # use tracing_subscriber::Layer as _;
357    /// # let _ = layer.with_subscriber(tracing_subscriber::registry::Registry::default());
358    /// ```
359    pub fn map_writer<W2>(self, f: impl FnOnce(W) -> W2) -> Layer<S, N, E, W2>
360    where
361        W2: for<'writer> MakeWriter<'writer> + 'static,
362    {
363        Layer {
364            fmt_fields: self.fmt_fields,
365            fmt_event: self.fmt_event,
366            fmt_span: self.fmt_span,
367            is_ansi: self.is_ansi,
368            log_internal_errors: self.log_internal_errors,
369            make_writer: f(self.make_writer),
370            _inner: self._inner,
371        }
372    }
373}
374
375impl<S, N, L, T, W> Layer<S, N, format::Format<L, T>, W>
376where
377    N: for<'writer> FormatFields<'writer> + 'static,
378{
379    /// Use the given [`timer`] for span and event timestamps.
380    ///
381    /// See the [`time` module] for the provided timer implementations.
382    ///
383    /// Note that using the `"time`"" feature flag enables the
384    /// additional time formatters [`UtcTime`] and [`LocalTime`], which use the
385    /// [`time` crate] to provide more sophisticated timestamp formatting
386    /// options.
387    ///
388    /// [`timer`]: super::time::FormatTime
389    /// [`time` module]: mod@super::time
390    /// [`UtcTime`]: super::time::UtcTime
391    /// [`LocalTime`]: super::time::LocalTime
392    /// [`time` crate]: https://docs.rs/time/0.3
393    pub fn with_timer<T2>(self, timer: T2) -> Layer<S, N, format::Format<L, T2>, W> {
394        Layer {
395            fmt_event: self.fmt_event.with_timer(timer),
396            fmt_fields: self.fmt_fields,
397            fmt_span: self.fmt_span,
398            make_writer: self.make_writer,
399            is_ansi: self.is_ansi,
400            log_internal_errors: self.log_internal_errors,
401            _inner: self._inner,
402        }
403    }
404
405    /// Do not emit timestamps with spans and event.
406    pub fn without_time(self) -> Layer<S, N, format::Format<L, ()>, W> {
407        Layer {
408            fmt_event: self.fmt_event.without_time(),
409            fmt_fields: self.fmt_fields,
410            fmt_span: self.fmt_span.without_time(),
411            make_writer: self.make_writer,
412            is_ansi: self.is_ansi,
413            log_internal_errors: self.log_internal_errors,
414            _inner: self._inner,
415        }
416    }
417
418    /// Configures how synthesized events are emitted at points in the [span
419    /// lifecycle][lifecycle].
420    ///
421    /// The following options are available:
422    ///
423    /// - `FmtSpan::NONE`: No events will be synthesized when spans are
424    ///    created, entered, exited, or closed. Data from spans will still be
425    ///    included as the context for formatted events. This is the default.
426    /// - `FmtSpan::NEW`: An event will be synthesized when spans are created.
427    /// - `FmtSpan::ENTER`: An event will be synthesized when spans are entered.
428    /// - `FmtSpan::EXIT`: An event will be synthesized when spans are exited.
429    /// - `FmtSpan::CLOSE`: An event will be synthesized when a span closes. If
430    ///    [timestamps are enabled][time] for this formatter, the generated
431    ///    event will contain fields with the span's _busy time_ (the total
432    ///    time for which it was entered) and _idle time_ (the total time that
433    ///    the span existed but was not entered).
434    /// - `FmtSpan::ACTIVE`: Events will be synthesized when spans are entered
435    ///    or exited.
436    /// - `FmtSpan::FULL`: Events will be synthesized whenever a span is
437    ///    created, entered, exited, or closed. If timestamps are enabled, the
438    ///    close event will contain the span's busy and idle time, as
439    ///    described above.
440    ///
441    /// The options can be enabled in any combination. For instance, the following
442    /// will synthesize events whenever spans are created and closed:
443    ///
444    /// ```rust
445    /// use tracing_subscriber::fmt;
446    /// use tracing_subscriber::fmt::format::FmtSpan;
447    ///
448    /// let subscriber = fmt()
449    ///     .with_span_events(FmtSpan::NEW | FmtSpan::CLOSE)
450    ///     .finish();
451    /// ```
452    ///
453    /// Note that the generated events will only be part of the log output by
454    /// this formatter; they will not be recorded by other `Subscriber`s or by
455    /// `Layer`s added to this subscriber.
456    ///
457    /// [lifecycle]: https://docs.rs/tracing/latest/tracing/span/index.html#the-span-lifecycle
458    /// [time]: Layer::without_time()
459    pub fn with_span_events(self, kind: FmtSpan) -> Self {
460        Layer {
461            fmt_span: self.fmt_span.with_kind(kind),
462            ..self
463        }
464    }
465
466    /// Sets whether or not an event's target is displayed.
467    pub fn with_target(self, display_target: bool) -> Layer<S, N, format::Format<L, T>, W> {
468        Layer {
469            fmt_event: self.fmt_event.with_target(display_target),
470            ..self
471        }
472    }
473    /// Sets whether or not an event's [source code file path][file] is
474    /// displayed.
475    ///
476    /// [file]: tracing_core::Metadata::file
477    pub fn with_file(self, display_filename: bool) -> Layer<S, N, format::Format<L, T>, W> {
478        Layer {
479            fmt_event: self.fmt_event.with_file(display_filename),
480            ..self
481        }
482    }
483
484    /// Sets whether or not an event's [source code line number][line] is
485    /// displayed.
486    ///
487    /// [line]: tracing_core::Metadata::line
488    pub fn with_line_number(
489        self,
490        display_line_number: bool,
491    ) -> Layer<S, N, format::Format<L, T>, W> {
492        Layer {
493            fmt_event: self.fmt_event.with_line_number(display_line_number),
494            ..self
495        }
496    }
497
498    /// Sets whether or not an event's level is displayed.
499    pub fn with_level(self, display_level: bool) -> Layer<S, N, format::Format<L, T>, W> {
500        Layer {
501            fmt_event: self.fmt_event.with_level(display_level),
502            ..self
503        }
504    }
505
506    /// Sets whether or not the [thread ID] of the current thread is displayed
507    /// when formatting events.
508    ///
509    /// [thread ID]: std::thread::ThreadId
510    pub fn with_thread_ids(self, display_thread_ids: bool) -> Layer<S, N, format::Format<L, T>, W> {
511        Layer {
512            fmt_event: self.fmt_event.with_thread_ids(display_thread_ids),
513            ..self
514        }
515    }
516
517    /// Sets whether or not the [name] of the current thread is displayed
518    /// when formatting events.
519    ///
520    /// [name]: std::thread#naming-threads
521    pub fn with_thread_names(
522        self,
523        display_thread_names: bool,
524    ) -> Layer<S, N, format::Format<L, T>, W> {
525        Layer {
526            fmt_event: self.fmt_event.with_thread_names(display_thread_names),
527            ..self
528        }
529    }
530
531    /// Sets the layer being built to use a [less verbose formatter][super::format::Compact].
532    pub fn compact(self) -> Layer<S, N, format::Format<format::Compact, T>, W>
533    where
534        N: for<'writer> FormatFields<'writer> + 'static,
535    {
536        Layer {
537            fmt_event: self.fmt_event.compact(),
538            fmt_fields: self.fmt_fields,
539            fmt_span: self.fmt_span,
540            make_writer: self.make_writer,
541            is_ansi: self.is_ansi,
542            log_internal_errors: self.log_internal_errors,
543            _inner: self._inner,
544        }
545    }
546
547    /// Sets the layer being built to use an [excessively pretty, human-readable formatter](crate::fmt::format::Pretty).
548    #[cfg(feature = "ansi")]
549    #[cfg_attr(docsrs, doc(cfg(feature = "ansi")))]
550    pub fn pretty(self) -> Layer<S, format::Pretty, format::Format<format::Pretty, T>, W> {
551        Layer {
552            fmt_event: self.fmt_event.pretty(),
553            fmt_fields: format::Pretty::default(),
554            fmt_span: self.fmt_span,
555            make_writer: self.make_writer,
556            is_ansi: self.is_ansi,
557            log_internal_errors: self.log_internal_errors,
558            _inner: self._inner,
559        }
560    }
561
562    /// Sets the layer being built to use a [JSON formatter][super::format::Json].
563    ///
564    /// The full format includes fields from all entered spans.
565    ///
566    /// # Example Output
567    ///
568    /// ```ignore,json
569    /// {"timestamp":"Feb 20 11:28:15.096","level":"INFO","target":"mycrate","fields":{"message":"some message", "key": "value"}}
570    /// ```
571    ///
572    /// # Options
573    ///
574    /// - [`Layer::flatten_event`] can be used to enable flattening event fields into the root
575    /// object.
576    ///
577    /// [`Layer::flatten_event`]: Layer::flatten_event()
578    #[cfg(feature = "json")]
579    #[cfg_attr(docsrs, doc(cfg(feature = "json")))]
580    pub fn json(self) -> Layer<S, format::JsonFields, format::Format<format::Json, T>, W> {
581        Layer {
582            fmt_event: self.fmt_event.json(),
583            fmt_fields: format::JsonFields::new(),
584            fmt_span: self.fmt_span,
585            make_writer: self.make_writer,
586            // always disable ANSI escapes in JSON mode!
587            is_ansi: false,
588            log_internal_errors: self.log_internal_errors,
589            _inner: self._inner,
590        }
591    }
592}
593
594#[cfg(feature = "json")]
595#[cfg_attr(docsrs, doc(cfg(feature = "json")))]
596impl<S, T, W> Layer<S, format::JsonFields, format::Format<format::Json, T>, W> {
597    /// Sets the JSON layer being built to flatten event metadata.
598    ///
599    /// See [`format::Json`][super::format::Json]
600    pub fn flatten_event(
601        self,
602        flatten_event: bool,
603    ) -> Layer<S, format::JsonFields, format::Format<format::Json, T>, W> {
604        Layer {
605            fmt_event: self.fmt_event.flatten_event(flatten_event),
606            fmt_fields: format::JsonFields::new(),
607            ..self
608        }
609    }
610
611    /// Sets whether or not the formatter will include the current span in
612    /// formatted events.
613    ///
614    /// See [`format::Json`][super::format::Json]
615    pub fn with_current_span(
616        self,
617        display_current_span: bool,
618    ) -> Layer<S, format::JsonFields, format::Format<format::Json, T>, W> {
619        Layer {
620            fmt_event: self.fmt_event.with_current_span(display_current_span),
621            fmt_fields: format::JsonFields::new(),
622            ..self
623        }
624    }
625
626    /// Sets whether or not the formatter will include a list (from root to leaf)
627    /// of all currently entered spans in formatted events.
628    ///
629    /// See [`format::Json`][super::format::Json]
630    pub fn with_span_list(
631        self,
632        display_span_list: bool,
633    ) -> Layer<S, format::JsonFields, format::Format<format::Json, T>, W> {
634        Layer {
635            fmt_event: self.fmt_event.with_span_list(display_span_list),
636            fmt_fields: format::JsonFields::new(),
637            ..self
638        }
639    }
640}
641
642impl<S, N, E, W> Layer<S, N, E, W> {
643    /// Sets the field formatter that the layer being built will use to record
644    /// fields.
645    pub fn fmt_fields<N2>(self, fmt_fields: N2) -> Layer<S, N2, E, W>
646    where
647        N2: for<'writer> FormatFields<'writer> + 'static,
648    {
649        Layer {
650            fmt_event: self.fmt_event,
651            fmt_fields,
652            fmt_span: self.fmt_span,
653            make_writer: self.make_writer,
654            is_ansi: self.is_ansi,
655            log_internal_errors: self.log_internal_errors,
656            _inner: self._inner,
657        }
658    }
659
660    /// Updates the field formatter by applying a function to the existing field formatter.
661    ///
662    /// This sets the field formatter that the layer being built will use to record fields.
663    ///
664    /// # Examples
665    ///
666    /// Updating a field formatter:
667    ///
668    /// ```rust
669    /// use tracing_subscriber::field::MakeExt;
670    /// let layer = tracing_subscriber::fmt::layer()
671    ///     .map_fmt_fields(|f| f.debug_alt());
672    /// # // this is necessary for type inference.
673    /// # use tracing_subscriber::Layer as _;
674    /// # let _ = layer.with_subscriber(tracing_subscriber::registry::Registry::default());
675    /// ```
676    pub fn map_fmt_fields<N2>(self, f: impl FnOnce(N) -> N2) -> Layer<S, N2, E, W>
677    where
678        N2: for<'writer> FormatFields<'writer> + 'static,
679    {
680        Layer {
681            fmt_event: self.fmt_event,
682            fmt_fields: f(self.fmt_fields),
683            fmt_span: self.fmt_span,
684            make_writer: self.make_writer,
685            is_ansi: self.is_ansi,
686            log_internal_errors: self.log_internal_errors,
687            _inner: self._inner,
688        }
689    }
690}
691
692impl<S> Default for Layer<S> {
693    fn default() -> Self {
694        // only enable ANSI when the feature is enabled, and the NO_COLOR
695        // environment variable is unset or empty.
696        let ansi = cfg!(feature = "ansi") && env::var("NO_COLOR").map_or(true, |v| v.is_empty());
697
698        Layer {
699            fmt_fields: format::DefaultFields::default(),
700            fmt_event: format::Format::default(),
701            fmt_span: format::FmtSpanConfig::default(),
702            make_writer: io::stdout,
703            is_ansi: ansi,
704            log_internal_errors: false,
705            _inner: PhantomData,
706        }
707    }
708}
709
710impl<S, N, E, W> Layer<S, N, E, W>
711where
712    S: Subscriber + for<'a> LookupSpan<'a>,
713    N: for<'writer> FormatFields<'writer> + 'static,
714    E: FormatEvent<S, N> + 'static,
715    W: for<'writer> MakeWriter<'writer> + 'static,
716{
717    #[inline]
718    fn make_ctx<'a>(&'a self, ctx: Context<'a, S>, event: &'a Event<'a>) -> FmtContext<'a, S, N> {
719        FmtContext {
720            ctx,
721            fmt_fields: &self.fmt_fields,
722            event,
723        }
724    }
725}
726
727/// A formatted representation of a span's fields stored in its [extensions].
728///
729/// Because `FormattedFields` is generic over the type of the formatter that
730/// produced it, multiple versions of a span's formatted fields can be stored in
731/// the [`Extensions`][extensions] type-map. This means that when multiple
732/// formatters are in use, each can store its own formatted representation
733/// without conflicting.
734///
735/// [extensions]: crate::registry::Extensions
736#[derive(Default)]
737pub struct FormattedFields<E: ?Sized> {
738    _format_fields: PhantomData<fn(E)>,
739    was_ansi: bool,
740    /// The formatted fields of a span.
741    pub fields: String,
742}
743
744impl<E: ?Sized> FormattedFields<E> {
745    /// Returns a new `FormattedFields`.
746    pub fn new(fields: String) -> Self {
747        Self {
748            fields,
749            was_ansi: false,
750            _format_fields: PhantomData,
751        }
752    }
753
754    /// Returns a new [`format::Writer`] for writing to this `FormattedFields`.
755    ///
756    /// The returned [`format::Writer`] can be used with the
757    /// [`FormatFields::format_fields`] method.
758    pub fn as_writer(&mut self) -> format::Writer<'_> {
759        format::Writer::new(&mut self.fields).with_ansi(self.was_ansi)
760    }
761}
762
763impl<E: ?Sized> fmt::Debug for FormattedFields<E> {
764    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
765        f.debug_struct("FormattedFields")
766            .field("fields", &self.fields)
767            .field("formatter", &format_args!("{}", std::any::type_name::<E>()))
768            .field("was_ansi", &self.was_ansi)
769            .finish()
770    }
771}
772
773impl<E: ?Sized> fmt::Display for FormattedFields<E> {
774    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
775        fmt::Display::fmt(&self.fields, f)
776    }
777}
778
779impl<E: ?Sized> Deref for FormattedFields<E> {
780    type Target = String;
781    fn deref(&self) -> &Self::Target {
782        &self.fields
783    }
784}
785
786// === impl FmtLayer ===
787
788macro_rules! with_event_from_span {
789    ($id:ident, $span:ident, $($field:literal = $value:expr),*, |$event:ident| $code:block) => {
790        let meta = $span.metadata();
791        let cs = meta.callsite();
792        let fs = field::FieldSet::new(&[$($field),*], cs);
793        #[allow(unused)]
794        let mut iter = fs.iter();
795        let v = [$(
796            (&iter.next().unwrap(), ::core::option::Option::Some(&$value as &dyn field::Value)),
797        )*];
798        let vs = fs.value_set(&v);
799        let $event = Event::new_child_of($id, meta, &vs);
800        $code
801    };
802}
803
804impl<S, N, E, W> layer::Layer<S> for Layer<S, N, E, W>
805where
806    S: Subscriber + for<'a> LookupSpan<'a>,
807    N: for<'writer> FormatFields<'writer> + 'static,
808    E: FormatEvent<S, N> + 'static,
809    W: for<'writer> MakeWriter<'writer> + 'static,
810{
811    fn on_new_span(&self, attrs: &Attributes<'_>, id: &Id, ctx: Context<'_, S>) {
812        let span = ctx.span(id).expect("Span not found, this is a bug");
813        let mut extensions = span.extensions_mut();
814
815        if extensions.get_mut::<FormattedFields<N>>().is_none() {
816            let mut fields = FormattedFields::<N>::new(String::new());
817            if self
818                .fmt_fields
819                .format_fields(fields.as_writer().with_ansi(self.is_ansi), attrs)
820                .is_ok()
821            {
822                fields.was_ansi = self.is_ansi;
823                extensions.insert(fields);
824            } else {
825                eprintln!(
826                    "[tracing-subscriber] Unable to format the following event, ignoring: {:?}",
827                    attrs
828                );
829            }
830        }
831
832        if self.fmt_span.fmt_timing
833            && self.fmt_span.trace_close()
834            && extensions.get_mut::<Timings>().is_none()
835        {
836            extensions.insert(Timings::new());
837        }
838
839        if self.fmt_span.trace_new() {
840            with_event_from_span!(id, span, "message" = "new", |event| {
841                drop(extensions);
842                drop(span);
843                self.on_event(&event, ctx);
844            });
845        }
846    }
847
848    fn on_record(&self, id: &Id, values: &Record<'_>, ctx: Context<'_, S>) {
849        let span = ctx.span(id).expect("Span not found, this is a bug");
850        let mut extensions = span.extensions_mut();
851        if let Some(fields) = extensions.get_mut::<FormattedFields<N>>() {
852            let _ = self.fmt_fields.add_fields(fields, values);
853            return;
854        }
855
856        let mut fields = FormattedFields::<N>::new(String::new());
857        if self
858            .fmt_fields
859            .format_fields(fields.as_writer().with_ansi(self.is_ansi), values)
860            .is_ok()
861        {
862            fields.was_ansi = self.is_ansi;
863            extensions.insert(fields);
864        }
865    }
866
867    fn on_enter(&self, id: &Id, ctx: Context<'_, S>) {
868        if self.fmt_span.trace_enter() || self.fmt_span.trace_close() && self.fmt_span.fmt_timing {
869            let span = ctx.span(id).expect("Span not found, this is a bug");
870            let mut extensions = span.extensions_mut();
871            if let Some(timings) = extensions.get_mut::<Timings>() {
872                let now = Instant::now();
873                timings.idle += (now - timings.last).as_nanos() as u64;
874                timings.last = now;
875            }
876
877            if self.fmt_span.trace_enter() {
878                with_event_from_span!(id, span, "message" = "enter", |event| {
879                    drop(extensions);
880                    drop(span);
881                    self.on_event(&event, ctx);
882                });
883            }
884        }
885    }
886
887    fn on_exit(&self, id: &Id, ctx: Context<'_, S>) {
888        if self.fmt_span.trace_exit() || self.fmt_span.trace_close() && self.fmt_span.fmt_timing {
889            let span = ctx.span(id).expect("Span not found, this is a bug");
890            let mut extensions = span.extensions_mut();
891            if let Some(timings) = extensions.get_mut::<Timings>() {
892                let now = Instant::now();
893                timings.busy += (now - timings.last).as_nanos() as u64;
894                timings.last = now;
895            }
896
897            if self.fmt_span.trace_exit() {
898                with_event_from_span!(id, span, "message" = "exit", |event| {
899                    drop(extensions);
900                    drop(span);
901                    self.on_event(&event, ctx);
902                });
903            }
904        }
905    }
906
907    fn on_close(&self, id: Id, ctx: Context<'_, S>) {
908        if self.fmt_span.trace_close() {
909            let span = ctx.span(&id).expect("Span not found, this is a bug");
910            let extensions = span.extensions();
911            if let Some(timing) = extensions.get::<Timings>() {
912                let Timings {
913                    busy,
914                    mut idle,
915                    last,
916                } = *timing;
917                idle += (Instant::now() - last).as_nanos() as u64;
918
919                let t_idle = field::display(TimingDisplay(idle));
920                let t_busy = field::display(TimingDisplay(busy));
921
922                with_event_from_span!(
923                    id,
924                    span,
925                    "message" = "close",
926                    "time.busy" = t_busy,
927                    "time.idle" = t_idle,
928                    |event| {
929                        drop(extensions);
930                        drop(span);
931                        self.on_event(&event, ctx);
932                    }
933                );
934            } else {
935                with_event_from_span!(id, span, "message" = "close", |event| {
936                    drop(extensions);
937                    drop(span);
938                    self.on_event(&event, ctx);
939                });
940            }
941        }
942    }
943
944    fn on_event(&self, event: &Event<'_>, ctx: Context<'_, S>) {
945        thread_local! {
946            static BUF: RefCell<String> = RefCell::new(String::new());
947        }
948
949        BUF.with(|buf| {
950            let borrow = buf.try_borrow_mut();
951            let mut a;
952            let mut b;
953            let mut buf = match borrow {
954                Ok(buf) => {
955                    a = buf;
956                    &mut *a
957                }
958                _ => {
959                    b = String::new();
960                    &mut b
961                }
962            };
963
964            let ctx = self.make_ctx(ctx, event);
965            if self
966                .fmt_event
967                .format_event(
968                    &ctx,
969                    format::Writer::new(&mut buf).with_ansi(self.is_ansi),
970                    event,
971                )
972                .is_ok()
973            {
974                let mut writer = self.make_writer.make_writer_for(event.metadata());
975                let res = io::Write::write_all(&mut writer, buf.as_bytes());
976                if self.log_internal_errors {
977                    if let Err(e) = res {
978                        eprintln!("[tracing-subscriber] Unable to write an event to the Writer for this Subscriber! Error: {}\n", e);
979                    }
980                }
981            } else if self.log_internal_errors {
982                let err_msg = format!("Unable to format the following event. Name: {}; Fields: {:?}\n",
983                    event.metadata().name(), event.fields());
984                let mut writer = self.make_writer.make_writer_for(event.metadata());
985                let res = io::Write::write_all(&mut writer, err_msg.as_bytes());
986                if let Err(e) = res {
987                    eprintln!("[tracing-subscriber] Unable to write an \"event formatting error\" to the Writer for this Subscriber! Error: {}\n", e);
988                }
989            }
990
991            buf.clear();
992        });
993    }
994
995    unsafe fn downcast_raw(&self, id: TypeId) -> Option<*const ()> {
996        // This `downcast_raw` impl allows downcasting a `fmt` layer to any of
997        // its components (event formatter, field formatter, and `MakeWriter`)
998        // as well as to the layer's type itself. The potential use-cases for
999        // this *may* be somewhat niche, though...
1000        match () {
1001            _ if id == TypeId::of::<Self>() => Some(self as *const Self as *const ()),
1002            _ if id == TypeId::of::<E>() => Some(&self.fmt_event as *const E as *const ()),
1003            _ if id == TypeId::of::<N>() => Some(&self.fmt_fields as *const N as *const ()),
1004            _ if id == TypeId::of::<W>() => Some(&self.make_writer as *const W as *const ()),
1005            _ => None,
1006        }
1007    }
1008}
1009
1010/// Provides the current span context to a formatter.
1011pub struct FmtContext<'a, S, N> {
1012    pub(crate) ctx: Context<'a, S>,
1013    pub(crate) fmt_fields: &'a N,
1014    pub(crate) event: &'a Event<'a>,
1015}
1016
1017impl<'a, S, N> fmt::Debug for FmtContext<'a, S, N> {
1018    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1019        f.debug_struct("FmtContext").finish()
1020    }
1021}
1022
1023impl<'cx, 'writer, S, N> FormatFields<'writer> for FmtContext<'cx, S, N>
1024where
1025    S: Subscriber + for<'lookup> LookupSpan<'lookup>,
1026    N: FormatFields<'writer> + 'static,
1027{
1028    fn format_fields<R: RecordFields>(
1029        &self,
1030        writer: format::Writer<'writer>,
1031        fields: R,
1032    ) -> fmt::Result {
1033        self.fmt_fields.format_fields(writer, fields)
1034    }
1035}
1036
1037impl<'a, S, N> FmtContext<'a, S, N>
1038where
1039    S: Subscriber + for<'lookup> LookupSpan<'lookup>,
1040    N: for<'writer> FormatFields<'writer> + 'static,
1041{
1042    /// Visits every span in the current context with a closure.
1043    ///
1044    /// The provided closure will be called first with the current span,
1045    /// and then with that span's parent, and then that span's parent,
1046    /// and so on until a root span is reached.
1047    pub fn visit_spans<E, F>(&self, mut f: F) -> Result<(), E>
1048    where
1049        F: FnMut(&SpanRef<'_, S>) -> Result<(), E>,
1050    {
1051        // visit all the current spans
1052        if let Some(scope) = self.event_scope() {
1053            for span in scope.from_root() {
1054                f(&span)?;
1055            }
1056        }
1057        Ok(())
1058    }
1059
1060    /// Returns metadata for the span with the given `id`, if it exists.
1061    ///
1062    /// If this returns `None`, then no span exists for that ID (either it has
1063    /// closed or the ID is invalid).
1064    #[inline]
1065    pub fn metadata(&self, id: &Id) -> Option<&'static Metadata<'static>>
1066    where
1067        S: for<'lookup> LookupSpan<'lookup>,
1068    {
1069        self.ctx.metadata(id)
1070    }
1071
1072    /// Returns [stored data] for the span with the given `id`, if it exists.
1073    ///
1074    /// If this returns `None`, then no span exists for that ID (either it has
1075    /// closed or the ID is invalid).
1076    ///
1077    /// [stored data]: crate::registry::SpanRef
1078    #[inline]
1079    pub fn span(&self, id: &Id) -> Option<SpanRef<'_, S>>
1080    where
1081        S: for<'lookup> LookupSpan<'lookup>,
1082    {
1083        self.ctx.span(id)
1084    }
1085
1086    /// Returns `true` if an active span exists for the given `Id`.
1087    #[inline]
1088    pub fn exists(&self, id: &Id) -> bool
1089    where
1090        S: for<'lookup> LookupSpan<'lookup>,
1091    {
1092        self.ctx.exists(id)
1093    }
1094
1095    /// Returns [stored data] for the span that the wrapped subscriber considers
1096    /// to be the current.
1097    ///
1098    /// If this returns `None`, then we are not currently within a span.
1099    ///
1100    /// [stored data]: crate::registry::SpanRef
1101    #[inline]
1102    pub fn lookup_current(&self) -> Option<SpanRef<'_, S>>
1103    where
1104        S: for<'lookup> LookupSpan<'lookup>,
1105    {
1106        self.ctx.lookup_current()
1107    }
1108
1109    /// Returns the current span for this formatter.
1110    pub fn current_span(&self) -> Current {
1111        self.ctx.current_span()
1112    }
1113
1114    /// Returns [stored data] for the parent span of the event currently being
1115    /// formatted.
1116    ///
1117    /// If the event has a contextual parent, this will return the current span. If
1118    /// the event has an explicit parent span, this will return that span. If
1119    /// the event does not have a parent span, this will return `None`.
1120    ///
1121    /// [stored data]: SpanRef
1122    pub fn parent_span(&self) -> Option<SpanRef<'_, S>> {
1123        self.ctx.event_span(self.event)
1124    }
1125
1126    /// Returns an iterator over the [stored data] for all the spans in the
1127    /// current context, starting with the specified span and ending with the
1128    /// root of the trace tree and ending with the current span.
1129    ///
1130    /// This is equivalent to the [`Context::span_scope`] method.
1131    ///
1132    /// <div class="information">
1133    ///     <div class="tooltip ignore" style="">ⓘ<span class="tooltiptext">Note</span></div>
1134    /// </div>
1135    /// <div class="example-wrap" style="display:inline-block">
1136    /// <pre class="ignore" style="white-space:normal;font:inherit;">
1137    /// <strong>Note</strong>: Compared to <a href="#method.scope"><code>scope</code></a> this
1138    /// returns the spans in reverse order (from leaf to root). Use
1139    /// <a href="../registry/struct.Scope.html#method.from_root"><code>Scope::from_root</code></a>
1140    /// in case root-to-leaf ordering is desired.
1141    /// </pre></div>
1142    ///
1143    /// <div class="example-wrap" style="display:inline-block">
1144    /// <pre class="ignore" style="white-space:normal;font:inherit;">
1145    /// <strong>Note</strong>: This requires the wrapped subscriber to implement the
1146    /// <a href="../registry/trait.LookupSpan.html"><code>LookupSpan</code></a> trait.
1147    /// See the documentation on <a href="./struct.Context.html"><code>Context</code>'s
1148    /// declaration</a> for details.
1149    /// </pre></div>
1150    ///
1151    /// [stored data]: crate::registry::SpanRef
1152    pub fn span_scope(&self, id: &Id) -> Option<registry::Scope<'_, S>>
1153    where
1154        S: for<'lookup> LookupSpan<'lookup>,
1155    {
1156        self.ctx.span_scope(id)
1157    }
1158
1159    /// Returns an iterator over the [stored data] for all the spans in the
1160    /// event's span context, starting with its parent span and ending with the
1161    /// root of the trace tree.
1162    ///
1163    /// This is equivalent to calling the [`Context::event_scope`] method and
1164    /// passing the event currently being formatted.
1165    ///
1166    /// <div class="example-wrap" style="display:inline-block">
1167    /// <pre class="ignore" style="white-space:normal;font:inherit;">
1168    /// <strong>Note</strong>: Compared to <a href="#method.scope"><code>scope</code></a> this
1169    /// returns the spans in reverse order (from leaf to root). Use
1170    /// <a href="../registry/struct.Scope.html#method.from_root"><code>Scope::from_root</code></a>
1171    /// in case root-to-leaf ordering is desired.
1172    /// </pre></div>
1173    ///
1174    /// <div class="example-wrap" style="display:inline-block">
1175    /// <pre class="ignore" style="white-space:normal;font:inherit;">
1176    /// <strong>Note</strong>: This requires the wrapped subscriber to implement the
1177    /// <a href="../registry/trait.LookupSpan.html"><code>LookupSpan</code></a> trait.
1178    /// See the documentation on <a href="./struct.Context.html"><code>Context</code>'s
1179    /// declaration</a> for details.
1180    /// </pre></div>
1181    ///
1182    /// [stored data]: crate::registry::SpanRef
1183    pub fn event_scope(&self) -> Option<registry::Scope<'_, S>>
1184    where
1185        S: for<'lookup> registry::LookupSpan<'lookup>,
1186    {
1187        self.ctx.event_scope(self.event)
1188    }
1189
1190    /// Returns the [field formatter] configured by the subscriber invoking
1191    /// `format_event`.
1192    ///
1193    /// The event formatter may use the returned field formatter to format the
1194    /// fields of any events it records.
1195    ///
1196    /// [field formatter]: FormatFields
1197    pub fn field_format(&self) -> &N {
1198        self.fmt_fields
1199    }
1200}
1201
1202struct Timings {
1203    idle: u64,
1204    busy: u64,
1205    last: Instant,
1206}
1207
1208impl Timings {
1209    fn new() -> Self {
1210        Self {
1211            idle: 0,
1212            busy: 0,
1213            last: Instant::now(),
1214        }
1215    }
1216}
1217
1218#[cfg(test)]
1219mod test {
1220    use super::*;
1221    use crate::fmt::{
1222        self,
1223        format::{self, test::MockTime, Format},
1224        layer::Layer as _,
1225        test::{MockMakeWriter, MockWriter},
1226        time,
1227    };
1228    use crate::Registry;
1229    use format::FmtSpan;
1230    use regex::Regex;
1231    use tracing::subscriber::with_default;
1232    use tracing_core::dispatcher::Dispatch;
1233
1234    #[test]
1235    fn impls() {
1236        let f = Format::default().with_timer(time::Uptime::default());
1237        let fmt = fmt::Layer::default().event_format(f);
1238        let subscriber = fmt.with_subscriber(Registry::default());
1239        let _dispatch = Dispatch::new(subscriber);
1240
1241        let f = format::Format::default();
1242        let fmt = fmt::Layer::default().event_format(f);
1243        let subscriber = fmt.with_subscriber(Registry::default());
1244        let _dispatch = Dispatch::new(subscriber);
1245
1246        let f = format::Format::default().compact();
1247        let fmt = fmt::Layer::default().event_format(f);
1248        let subscriber = fmt.with_subscriber(Registry::default());
1249        let _dispatch = Dispatch::new(subscriber);
1250    }
1251
1252    #[test]
1253    fn fmt_layer_downcasts() {
1254        let f = format::Format::default();
1255        let fmt = fmt::Layer::default().event_format(f);
1256        let subscriber = fmt.with_subscriber(Registry::default());
1257
1258        let dispatch = Dispatch::new(subscriber);
1259        assert!(dispatch.downcast_ref::<fmt::Layer<Registry>>().is_some());
1260    }
1261
1262    #[test]
1263    fn fmt_layer_downcasts_to_parts() {
1264        let f = format::Format::default();
1265        let fmt = fmt::Layer::default().event_format(f);
1266        let subscriber = fmt.with_subscriber(Registry::default());
1267        let dispatch = Dispatch::new(subscriber);
1268        assert!(dispatch.downcast_ref::<format::DefaultFields>().is_some());
1269        assert!(dispatch.downcast_ref::<format::Format>().is_some())
1270    }
1271
1272    #[test]
1273    fn is_lookup_span() {
1274        fn assert_lookup_span<T: for<'a> crate::registry::LookupSpan<'a>>(_: T) {}
1275        let fmt = fmt::Layer::default();
1276        let subscriber = fmt.with_subscriber(Registry::default());
1277        assert_lookup_span(subscriber)
1278    }
1279
1280    fn sanitize_timings(s: String) -> String {
1281        let re = Regex::new("time\\.(idle|busy)=([0-9.]+)[mµn]s").unwrap();
1282        re.replace_all(s.as_str(), "timing").to_string()
1283    }
1284
1285    #[test]
1286    fn format_error_print_to_stderr() {
1287        struct AlwaysError;
1288
1289        impl std::fmt::Debug for AlwaysError {
1290            fn fmt(&self, _f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1291                Err(std::fmt::Error)
1292            }
1293        }
1294
1295        let make_writer = MockMakeWriter::default();
1296        let subscriber = crate::fmt::Subscriber::builder()
1297            .with_writer(make_writer.clone())
1298            .with_level(false)
1299            .with_ansi(false)
1300            .with_timer(MockTime)
1301            .finish();
1302
1303        with_default(subscriber, || {
1304            tracing::info!(?AlwaysError);
1305        });
1306        let actual = sanitize_timings(make_writer.get_string());
1307
1308        // Only assert the start because the line number and callsite may change.
1309        let expected = concat!(
1310            "Unable to format the following event. Name: event ",
1311            file!(),
1312            ":"
1313        );
1314        assert!(
1315            actual.as_str().starts_with(expected),
1316            "\nactual = {}\nshould start with expected = {}\n",
1317            actual,
1318            expected
1319        );
1320    }
1321
1322    #[test]
1323    fn format_error_ignore_if_log_internal_errors_is_false() {
1324        struct AlwaysError;
1325
1326        impl std::fmt::Debug for AlwaysError {
1327            fn fmt(&self, _f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1328                Err(std::fmt::Error)
1329            }
1330        }
1331
1332        let make_writer = MockMakeWriter::default();
1333        let subscriber = crate::fmt::Subscriber::builder()
1334            .with_writer(make_writer.clone())
1335            .with_level(false)
1336            .with_ansi(false)
1337            .with_timer(MockTime)
1338            .log_internal_errors(false)
1339            .finish();
1340
1341        with_default(subscriber, || {
1342            tracing::info!(?AlwaysError);
1343        });
1344        let actual = sanitize_timings(make_writer.get_string());
1345        assert_eq!("", actual.as_str());
1346    }
1347
1348    #[test]
1349    fn synthesize_span_none() {
1350        let make_writer = MockMakeWriter::default();
1351        let subscriber = crate::fmt::Subscriber::builder()
1352            .with_writer(make_writer.clone())
1353            .with_level(false)
1354            .with_ansi(false)
1355            .with_timer(MockTime)
1356            // check that FmtSpan::NONE is the default
1357            .finish();
1358
1359        with_default(subscriber, || {
1360            let span1 = tracing::info_span!("span1", x = 42);
1361            let _e = span1.enter();
1362        });
1363        let actual = sanitize_timings(make_writer.get_string());
1364        assert_eq!("", actual.as_str());
1365    }
1366
1367    #[test]
1368    fn synthesize_span_active() {
1369        let make_writer = MockMakeWriter::default();
1370        let subscriber = crate::fmt::Subscriber::builder()
1371            .with_writer(make_writer.clone())
1372            .with_level(false)
1373            .with_ansi(false)
1374            .with_timer(MockTime)
1375            .with_span_events(FmtSpan::ACTIVE)
1376            .finish();
1377
1378        with_default(subscriber, || {
1379            let span1 = tracing::info_span!("span1", x = 42);
1380            let _e = span1.enter();
1381        });
1382        let actual = sanitize_timings(make_writer.get_string());
1383        assert_eq!(
1384            "fake time span1{x=42}: tracing_subscriber::fmt::fmt_layer::test: enter\n\
1385             fake time span1{x=42}: tracing_subscriber::fmt::fmt_layer::test: exit\n",
1386            actual.as_str()
1387        );
1388    }
1389
1390    #[test]
1391    fn synthesize_span_close() {
1392        let make_writer = MockMakeWriter::default();
1393        let subscriber = crate::fmt::Subscriber::builder()
1394            .with_writer(make_writer.clone())
1395            .with_level(false)
1396            .with_ansi(false)
1397            .with_timer(MockTime)
1398            .with_span_events(FmtSpan::CLOSE)
1399            .finish();
1400
1401        with_default(subscriber, || {
1402            let span1 = tracing::info_span!("span1", x = 42);
1403            let _e = span1.enter();
1404        });
1405        let actual = sanitize_timings(make_writer.get_string());
1406        assert_eq!(
1407            "fake time span1{x=42}: tracing_subscriber::fmt::fmt_layer::test: close timing timing\n",
1408            actual.as_str()
1409        );
1410    }
1411
1412    #[test]
1413    fn synthesize_span_close_no_timing() {
1414        let make_writer = MockMakeWriter::default();
1415        let subscriber = crate::fmt::Subscriber::builder()
1416            .with_writer(make_writer.clone())
1417            .with_level(false)
1418            .with_ansi(false)
1419            .with_timer(MockTime)
1420            .without_time()
1421            .with_span_events(FmtSpan::CLOSE)
1422            .finish();
1423
1424        with_default(subscriber, || {
1425            let span1 = tracing::info_span!("span1", x = 42);
1426            let _e = span1.enter();
1427        });
1428        let actual = sanitize_timings(make_writer.get_string());
1429        assert_eq!(
1430            "span1{x=42}: tracing_subscriber::fmt::fmt_layer::test: close\n",
1431            actual.as_str()
1432        );
1433    }
1434
1435    #[test]
1436    fn synthesize_span_full() {
1437        let make_writer = MockMakeWriter::default();
1438        let subscriber = crate::fmt::Subscriber::builder()
1439            .with_writer(make_writer.clone())
1440            .with_level(false)
1441            .with_ansi(false)
1442            .with_timer(MockTime)
1443            .with_span_events(FmtSpan::FULL)
1444            .finish();
1445
1446        with_default(subscriber, || {
1447            let span1 = tracing::info_span!("span1", x = 42);
1448            let _e = span1.enter();
1449        });
1450        let actual = sanitize_timings(make_writer.get_string());
1451        assert_eq!(
1452            "fake time span1{x=42}: tracing_subscriber::fmt::fmt_layer::test: new\n\
1453             fake time span1{x=42}: tracing_subscriber::fmt::fmt_layer::test: enter\n\
1454             fake time span1{x=42}: tracing_subscriber::fmt::fmt_layer::test: exit\n\
1455             fake time span1{x=42}: tracing_subscriber::fmt::fmt_layer::test: close timing timing\n",
1456            actual.as_str()
1457        );
1458    }
1459
1460    #[test]
1461    fn make_writer_based_on_meta() {
1462        struct MakeByTarget {
1463            make_writer1: MockMakeWriter,
1464            make_writer2: MockMakeWriter,
1465        }
1466
1467        impl<'a> MakeWriter<'a> for MakeByTarget {
1468            type Writer = MockWriter;
1469
1470            fn make_writer(&'a self) -> Self::Writer {
1471                self.make_writer1.make_writer()
1472            }
1473
1474            fn make_writer_for(&'a self, meta: &Metadata<'_>) -> Self::Writer {
1475                if meta.target() == "writer2" {
1476                    return self.make_writer2.make_writer();
1477                }
1478                self.make_writer()
1479            }
1480        }
1481
1482        let make_writer1 = MockMakeWriter::default();
1483        let make_writer2 = MockMakeWriter::default();
1484
1485        let make_writer = MakeByTarget {
1486            make_writer1: make_writer1.clone(),
1487            make_writer2: make_writer2.clone(),
1488        };
1489
1490        let subscriber = crate::fmt::Subscriber::builder()
1491            .with_writer(make_writer)
1492            .with_level(false)
1493            .with_target(false)
1494            .with_ansi(false)
1495            .with_timer(MockTime)
1496            .with_span_events(FmtSpan::CLOSE)
1497            .finish();
1498
1499        with_default(subscriber, || {
1500            let span1 = tracing::info_span!("writer1_span", x = 42);
1501            let _e = span1.enter();
1502            tracing::info!(target: "writer2", "hello writer2!");
1503            let span2 = tracing::info_span!(target: "writer2", "writer2_span");
1504            let _e = span2.enter();
1505            tracing::warn!(target: "writer1", "hello writer1!");
1506        });
1507
1508        let actual = sanitize_timings(make_writer1.get_string());
1509        assert_eq!(
1510            "fake time writer1_span{x=42}:writer2_span: hello writer1!\n\
1511             fake time writer1_span{x=42}: close timing timing\n",
1512            actual.as_str()
1513        );
1514        let actual = sanitize_timings(make_writer2.get_string());
1515        assert_eq!(
1516            "fake time writer1_span{x=42}: hello writer2!\n\
1517             fake time writer1_span{x=42}:writer2_span: close timing timing\n",
1518            actual.as_str()
1519        );
1520    }
1521
1522    // Because we need to modify an environment variable for these test cases,
1523    // we do them all in a single test.
1524    #[cfg(feature = "ansi")]
1525    #[test]
1526    fn layer_no_color() {
1527        const NO_COLOR: &str = "NO_COLOR";
1528
1529        // Restores the previous value of the `NO_COLOR` env variable when
1530        // dropped.
1531        //
1532        // This is done in a `Drop` implementation, rather than just resetting
1533        // the value at the end of the test, so that the previous value is
1534        // restored even if the test panics.
1535        struct RestoreEnvVar(Result<String, env::VarError>);
1536        impl Drop for RestoreEnvVar {
1537            fn drop(&mut self) {
1538                match self.0 {
1539                    Ok(ref var) => env::set_var(NO_COLOR, var),
1540                    Err(_) => env::remove_var(NO_COLOR),
1541                }
1542            }
1543        }
1544
1545        let _saved_no_color = RestoreEnvVar(env::var(NO_COLOR));
1546
1547        let cases: Vec<(Option<&str>, bool)> = vec![
1548            (Some("0"), false),   // any non-empty value disables ansi
1549            (Some("off"), false), // any non-empty value disables ansi
1550            (Some("1"), false),
1551            (Some(""), true), // empty value does not disable ansi
1552            (None, true),
1553        ];
1554
1555        for (var, ansi) in cases {
1556            if let Some(value) = var {
1557                env::set_var(NO_COLOR, value);
1558            } else {
1559                env::remove_var(NO_COLOR);
1560            }
1561
1562            let layer: Layer<()> = fmt::Layer::default();
1563            assert_eq!(
1564                layer.is_ansi, ansi,
1565                "NO_COLOR={:?}; Layer::default().is_ansi should be {}",
1566                var, ansi
1567            );
1568
1569            // with_ansi should override any `NO_COLOR` value
1570            let layer: Layer<()> = fmt::Layer::default().with_ansi(true);
1571            assert!(
1572                layer.is_ansi,
1573                "NO_COLOR={:?}; Layer::default().with_ansi(true).is_ansi should be true",
1574                var
1575            );
1576
1577            // set_ansi should override any `NO_COLOR` value
1578            let mut layer: Layer<()> = fmt::Layer::default();
1579            layer.set_ansi(true);
1580            assert!(
1581                layer.is_ansi,
1582                "NO_COLOR={:?}; layer.set_ansi(true); layer.is_ansi should be true",
1583                var
1584            );
1585        }
1586
1587        // dropping `_saved_no_color` will restore the previous value of
1588        // `NO_COLOR`.
1589    }
1590}
tracing_subscriber/fmt/fmt_layer.rs

tracing_subscriber/fmt/
fmt_layer.rs
