summaryrefslogtreecommitdiffstats
path: root/vendor/tracing-subscriber-0.3.3/src/fmt
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--vendor/tracing-subscriber-0.3.3/src/fmt/fmt_layer.rs (renamed from vendor/tracing-subscriber/src/fmt/fmt_layer.rs)215
-rw-r--r--vendor/tracing-subscriber-0.3.3/src/fmt/format/json.rs750
-rw-r--r--vendor/tracing-subscriber-0.3.3/src/fmt/format/mod.rs1798
-rw-r--r--vendor/tracing-subscriber-0.3.3/src/fmt/format/pretty.rs415
-rw-r--r--vendor/tracing-subscriber-0.3.3/src/fmt/mod.rs1275
-rw-r--r--vendor/tracing-subscriber-0.3.3/src/fmt/time/datetime.rs (renamed from vendor/tracing-subscriber/src/fmt/time/datetime.rs)0
-rw-r--r--vendor/tracing-subscriber-0.3.3/src/fmt/time/mod.rs134
-rw-r--r--vendor/tracing-subscriber-0.3.3/src/fmt/time/time_crate.rs276
-rw-r--r--vendor/tracing-subscriber-0.3.3/src/fmt/writer.rs (renamed from vendor/tracing-subscriber/src/fmt/writer.rs)28
9 files changed, 4688 insertions, 203 deletions
diff --git a/vendor/tracing-subscriber/src/fmt/fmt_layer.rs b/vendor/tracing-subscriber-0.3.3/src/fmt/fmt_layer.rs
index 21992e780..0e0d5e0eb 100644
--- a/vendor/tracing-subscriber/src/fmt/fmt_layer.rs
+++ b/vendor/tracing-subscriber-0.3.3/src/fmt/fmt_layer.rs
@@ -56,7 +56,7 @@ use tracing_core::{
/// # tracing::subscriber::set_global_default(subscriber).unwrap();
/// ```
///
-/// [`Layer`]: super::layer::Layer
+/// [`Layer`]: ../layer/trait.Layer.html
#[cfg_attr(docsrs, doc(cfg(all(feature = "fmt", feature = "std"))))]
#[derive(Debug)]
pub struct Layer<
@@ -70,11 +70,11 @@ pub struct Layer<
fmt_event: E,
fmt_span: format::FmtSpanConfig,
is_ansi: bool,
- _inner: PhantomData<fn(S)>,
+ _inner: PhantomData<S>,
}
impl<S> Layer<S> {
- /// Returns a new [`Layer`][self::Layer] with the default configuration.
+ /// Returns a new [`Layer`](struct.Layer.html) with the default configuration.
pub fn new() -> Self {
Self::default()
}
@@ -87,8 +87,8 @@ where
N: for<'writer> FormatFields<'writer> + 'static,
W: for<'writer> MakeWriter<'writer> + 'static,
{
- /// Sets the [event formatter][`FormatEvent`] that the layer being built will
- /// use to format events.
+ /// Sets the [event formatter][`FormatEvent`] that the layer will use to
+ /// format events.
///
/// The event formatter may be any type implementing the [`FormatEvent`]
/// trait, which is implemented for all functions taking a [`FmtContext`], a
@@ -108,7 +108,7 @@ where
/// ```
/// [`FormatEvent`]: format::FormatEvent
/// [`Event`]: tracing::Event
- /// [`Writer`]: format::Writer
+ /// [`Writer`]: crate::format::Writer
pub fn event_format<E2>(self, e: E2) -> Layer<S, N, E2, W>
where
E2: FormatEvent<S, N> + 'static,
@@ -122,40 +122,11 @@ where
_inner: self._inner,
}
}
-
- /// Updates the event formatter by applying a function to the existing event formatter.
- ///
- /// This sets the event formatter that the layer being built will use to record fields.
- ///
- /// # Examples
- ///
- /// Updating an event formatter:
- ///
- /// ```rust
- /// let layer = tracing_subscriber::fmt::layer()
- /// .map_event_format(|e| e.compact());
- /// # // this is necessary for type inference.
- /// # use tracing_subscriber::Layer as _;
- /// # let _ = layer.with_subscriber(tracing_subscriber::registry::Registry::default());
- /// ```
- pub fn map_event_format<E2>(self, f: impl FnOnce(E) -> E2) -> Layer<S, N, E2, W>
- where
- E2: FormatEvent<S, N> + 'static,
- {
- Layer {
- fmt_fields: self.fmt_fields,
- fmt_event: f(self.fmt_event),
- fmt_span: self.fmt_span,
- make_writer: self.make_writer,
- is_ansi: self.is_ansi,
- _inner: self._inner,
- }
- }
}
// This needs to be a seperate impl block because they place different bounds on the type parameters.
impl<S, N, E, W> Layer<S, N, E, W> {
- /// Sets the [`MakeWriter`] that the layer being built will use to write events.
+ /// Sets the [`MakeWriter`] that the [`Layer`] being built will use to write events.
///
/// # Examples
///
@@ -171,6 +142,9 @@ impl<S, N, E, W> Layer<S, N, E, W> {
/// # use tracing_subscriber::Layer as _;
/// # let _ = layer.with_subscriber(tracing_subscriber::registry::Registry::default());
/// ```
+ ///
+ /// [`MakeWriter`]: ../fmt/trait.MakeWriter.html
+ /// [`Layer`]: ../layer/trait.Layer.html
pub fn with_writer<W2>(self, make_writer: W2) -> Layer<S, N, E, W2>
where
W2: for<'writer> MakeWriter<'writer> + 'static,
@@ -185,57 +159,7 @@ impl<S, N, E, W> Layer<S, N, E, W> {
}
}
- /// Borrows the [writer] for this [`Layer`].
- ///
- /// [writer]: MakeWriter
- pub fn writer(&self) -> &W {
- &self.make_writer
- }
-
- /// Mutably borrows the [writer] for this [`Layer`].
- ///
- /// This method is primarily expected to be used with the
- /// [`reload::Handle::modify`](crate::reload::Handle::modify) method.
- ///
- /// # Examples
- ///
- /// ```
- /// # use tracing::info;
- /// # use tracing_subscriber::{fmt,reload,Registry,prelude::*};
- /// # fn non_blocking<T: std::io::Write>(writer: T) -> (fn() -> std::io::Stdout) {
- /// # std::io::stdout
- /// # }
- /// # fn main() {
- /// let layer = fmt::layer().with_writer(non_blocking(std::io::stderr()));
- /// let (layer, reload_handle) = reload::Layer::new(layer);
- /// #
- /// # // specifying the Registry type is required
- /// # let _: &reload::Handle<fmt::Layer<Registry, _, _, _>, Registry> = &reload_handle;
- /// #
- /// info!("This will be logged to stderr");
- /// reload_handle.modify(|layer| *layer.writer_mut() = non_blocking(std::io::stdout()));
- /// info!("This will be logged to stdout");
- /// # }
- /// ```
- ///
- /// [writer]: MakeWriter
- pub fn writer_mut(&mut self) -> &mut W {
- &mut self.make_writer
- }
-
- /// Sets whether this layer should use ANSI terminal formatting
- /// escape codes (such as colors).
- ///
- /// This method is primarily expected to be used with the
- /// [`reload::Handle::modify`](crate::reload::Handle::modify) method when changing
- /// the writer.
- #[cfg(feature = "ansi")]
- #[cfg_attr(docsrs, doc(cfg(feature = "ansi")))]
- pub fn set_ansi(&mut self, ansi: bool) {
- self.is_ansi = ansi;
- }
-
- /// Configures the layer to support [`libtest`'s output capturing][capturing] when used in
+ /// Configures the subscriber to support [`libtest`'s output capturing][capturing] when used in
/// unit tests.
///
/// See [`TestWriter`] for additional details.
@@ -256,7 +180,7 @@ impl<S, N, E, W> Layer<S, N, E, W> {
/// ```
/// [capturing]:
/// https://doc.rust-lang.org/book/ch11-02-running-tests.html#showing-function-output
- /// [`TestWriter`]: super::writer::TestWriter
+ /// [`TestWriter`]: writer/struct.TestWriter.html
pub fn with_test_writer(self) -> Layer<S, N, E, TestWriter> {
Layer {
fmt_fields: self.fmt_fields,
@@ -277,39 +201,6 @@ impl<S, N, E, W> Layer<S, N, E, W> {
..self
}
}
-
- /// Updates the [`MakeWriter`] by applying a function to the existing [`MakeWriter`].
- ///
- /// This sets the [`MakeWriter`] that the layer being built will use to write events.
- ///
- /// # Examples
- ///
- /// Redirect output to stderr if level is <= WARN:
- ///
- /// ```rust
- /// use tracing::Level;
- /// use tracing_subscriber::fmt::{self, writer::MakeWriterExt};
- ///
- /// let stderr = std::io::stderr.with_max_level(Level::WARN);
- /// let layer = fmt::layer()
- /// .map_writer(move |w| stderr.or_else(w));
- /// # // this is necessary for type inference.
- /// # use tracing_subscriber::Layer as _;
- /// # let _ = layer.with_subscriber(tracing_subscriber::registry::Registry::default());
- /// ```
- pub fn map_writer<W2>(self, f: impl FnOnce(W) -> W2) -> Layer<S, N, E, W2>
- where
- W2: for<'writer> MakeWriter<'writer> + 'static,
- {
- Layer {
- fmt_fields: self.fmt_fields,
- fmt_event: self.fmt_event,
- fmt_span: self.fmt_span,
- is_ansi: self.is_ansi,
- make_writer: f(self.make_writer),
- _inner: self._inner,
- }
- }
}
impl<S, N, L, T, W> Layer<S, N, format::Format<L, T>, W>
@@ -393,7 +284,7 @@ where
/// `Layer`s added to this subscriber.
///
/// [lifecycle]: https://docs.rs/tracing/latest/tracing/span/index.html#the-span-lifecycle
- /// [time]: Layer::without_time()
+ /// [time]: #method.without_time
pub fn with_span_events(self, kind: FmtSpan) -> Self {
Layer {
fmt_span: self.fmt_span.with_kind(kind),
@@ -408,30 +299,6 @@ where
..self
}
}
- /// Sets whether or not an event's [source code file path][file] is
- /// displayed.
- ///
- /// [file]: tracing_core::Metadata::file
- pub fn with_file(self, display_filename: bool) -> Layer<S, N, format::Format<L, T>, W> {
- Layer {
- fmt_event: self.fmt_event.with_file(display_filename),
- ..self
- }
- }
-
- /// Sets whether or not an event's [source code line number][line] is
- /// displayed.
- ///
- /// [line]: tracing_core::Metadata::line
- pub fn with_line_number(
- self,
- display_line_number: bool,
- ) -> Layer<S, N, format::Format<L, T>, W> {
- Layer {
- fmt_event: self.fmt_event.with_line_number(display_line_number),
- ..self
- }
- }
/// Sets whether or not an event's level is displayed.
pub fn with_level(self, display_level: bool) -> Layer<S, N, format::Format<L, T>, W> {
@@ -442,9 +309,9 @@ where
}
/// Sets whether or not the [thread ID] of the current thread is displayed
- /// when formatting events.
+ /// when formatting events
///
- /// [thread ID]: std::thread::ThreadId
+ /// [thread ID]: https://doc.rust-lang.org/stable/std/thread/struct.ThreadId.html
pub fn with_thread_ids(self, display_thread_ids: bool) -> Layer<S, N, format::Format<L, T>, W> {
Layer {
fmt_event: self.fmt_event.with_thread_ids(display_thread_ids),
@@ -453,9 +320,9 @@ where
}
/// Sets whether or not the [name] of the current thread is displayed
- /// when formatting events.
+ /// when formatting events
///
- /// [name]: std::thread#naming-threads
+ /// [name]: https://doc.rust-lang.org/stable/std/thread/index.html#naming-threads
pub fn with_thread_names(
self,
display_thread_names: bool,
@@ -466,7 +333,7 @@ where
}
}
- /// Sets the layer being built to use a [less verbose formatter][super::format::Compact].
+ /// Sets the layer being built to use a [less verbose formatter](../fmt/format/struct.Compact.html).
pub fn compact(self) -> Layer<S, N, format::Format<format::Compact, T>, W>
where
N: for<'writer> FormatFields<'writer> + 'static,
@@ -495,7 +362,7 @@ where
}
}
- /// Sets the layer being built to use a [JSON formatter][super::format::Json].
+ /// Sets the layer being built to use a [JSON formatter](../fmt/format/struct.Json.html).
///
/// The full format includes fields from all entered spans.
///
@@ -510,7 +377,7 @@ where
/// - [`Layer::flatten_event`] can be used to enable flattening event fields into the root
/// object.
///
- /// [`Layer::flatten_event`]: Layer::flatten_event()
+ /// [`Layer::flatten_event`]: #method.flatten_event
#[cfg(feature = "json")]
#[cfg_attr(docsrs, doc(cfg(feature = "json")))]
pub fn json(self) -> Layer<S, format::JsonFields, format::Format<format::Json, T>, W> {
@@ -531,7 +398,7 @@ where
impl<S, T, W> Layer<S, format::JsonFields, format::Format<format::Json, T>, W> {
/// Sets the JSON layer being built to flatten event metadata.
///
- /// See [`format::Json`][super::format::Json]
+ /// See [`format::Json`](../fmt/format/struct.Json.html)
pub fn flatten_event(
self,
flatten_event: bool,
@@ -546,7 +413,7 @@ impl<S, T, W> Layer<S, format::JsonFields, format::Format<format::Json, T>, W> {
/// Sets whether or not the formatter will include the current span in
/// formatted events.
///
- /// See [`format::Json`][super::format::Json]
+ /// See [`format::Json`](../fmt/format/struct.Json.html)
pub fn with_current_span(
self,
display_current_span: bool,
@@ -561,7 +428,7 @@ impl<S, T, W> Layer<S, format::JsonFields, format::Format<format::Json, T>, W> {
/// 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]
+ /// See [`format::Json`](../fmt/format/struct.Json.html)
pub fn with_span_list(
self,
display_span_list: bool,
@@ -590,36 +457,6 @@ impl<S, N, E, W> Layer<S, N, E, W> {
_inner: self._inner,
}
}
-
- /// Updates the field formatter by applying a function to the existing field formatter.
- ///
- /// This sets the field formatter that the layer being built will use to record fields.
- ///
- /// # Examples
- ///
- /// Updating a field formatter:
- ///
- /// ```rust
- /// use tracing_subscriber::field::MakeExt;
- /// let layer = tracing_subscriber::fmt::layer()
- /// .map_fmt_fields(|f| f.debug_alt());
- /// # // this is necessary for type inference.
- /// # use tracing_subscriber::Layer as _;
- /// # let _ = layer.with_subscriber(tracing_subscriber::registry::Registry::default());
- /// ```
- pub fn map_fmt_fields<N2>(self, f: impl FnOnce(N) -> N2) -> Layer<S, N2, E, W>
- where
- N2: for<'writer> FormatFields<'writer> + 'static,
- {
- Layer {
- fmt_event: self.fmt_event,
- fmt_fields: f(self.fmt_fields),
- fmt_span: self.fmt_span,
- make_writer: self.make_writer,
- is_ansi: self.is_ansi,
- _inner: self._inner,
- }
- }
}
impl<S> Default for Layer<S> {
@@ -660,7 +497,7 @@ where
/// formatters are in use, each can store its own formatted representation
/// without conflicting.
///
-/// [extensions]: crate::registry::Extensions
+/// [extensions]: ../registry/struct.Extensions.html
#[derive(Default)]
pub struct FormattedFields<E: ?Sized> {
_format_fields: PhantomData<fn(E)>,
@@ -984,7 +821,7 @@ where
/// If this returns `None`, then no span exists for that ID (either it has
/// closed or the ID is invalid).
///
- /// [stored data]: crate::registry::SpanRef
+ /// [stored data]: ../registry/struct.SpanRef.html
#[inline]
pub fn span(&self, id: &Id) -> Option<SpanRef<'_, S>>
where
@@ -1007,7 +844,7 @@ where
///
/// If this returns `None`, then we are not currently within a span.
///
- /// [stored data]: crate::registry::SpanRef
+ /// [stored data]: ../registry/struct.SpanRef.html
#[inline]
pub fn lookup_current(&self) -> Option<SpanRef<'_, S>>
where
diff --git a/vendor/tracing-subscriber-0.3.3/src/fmt/format/json.rs b/vendor/tracing-subscriber-0.3.3/src/fmt/format/json.rs
new file mode 100644
index 000000000..cc86f03c7
--- /dev/null
+++ b/vendor/tracing-subscriber-0.3.3/src/fmt/format/json.rs
@@ -0,0 +1,750 @@
+use super::{Format, FormatEvent, FormatFields, FormatTime, Writer};
+use crate::{
+ field::{RecordFields, VisitOutput},
+ fmt::{
+ fmt_layer::{FmtContext, FormattedFields},
+ writer::WriteAdaptor,
+ },
+ registry::LookupSpan,
+};
+use serde::ser::{SerializeMap, Serializer as _};
+use serde_json::Serializer;
+use std::{
+ collections::BTreeMap,
+ fmt::{self, Write},
+};
+use tracing_core::{
+ field::{self, Field},
+ span::Record,
+ Event, Subscriber,
+};
+use tracing_serde::AsSerde;
+
+#[cfg(feature = "tracing-log")]
+use tracing_log::NormalizeEvent;
+
+/// Marker for `Format` that indicates that the verbose JSON log format should be used.
+///
+/// The full format includes fields from all entered spans.
+///
+/// # Example Output
+///
+/// ```json
+/// {
+/// "timestamp":"Feb 20 11:28:15.096",
+/// "level":"INFO",
+/// "fields":{"message":"some message","key":"value"}
+/// "target":"mycrate",
+/// "span":{name":"leaf"},
+/// "spans":[{"name":"root"},{"name":"leaf"}],
+/// }
+/// ```
+///
+/// # Options
+///
+/// - [`Json::flatten_event`] can be used to enable flattening event fields into
+/// the root
+/// - [`Json::with_current_span`] can be used to control logging of the current
+/// span
+/// - [`Json::with_span_list`] can be used to control logging of the span list
+/// object.
+///
+/// By default, event fields are not flattened, and both current span and span
+/// list are logged.
+///
+/// [`Json::flatten_event`]: #method.flatten_event
+/// [`Json::with_current_span`]: #method.with_current_span
+/// [`Json::with_span_list`]: #method.with_span_list
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+pub struct Json {
+ pub(crate) flatten_event: bool,
+ pub(crate) display_current_span: bool,
+ pub(crate) display_span_list: bool,
+}
+
+impl Json {
+ /// If set to `true` event metadata will be flattened into the root object.
+ pub fn flatten_event(&mut self, flatten_event: bool) {
+ self.flatten_event = flatten_event;
+ }
+
+ /// If set to `false`, formatted events won't contain a field for the current span.
+ 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>(
+ &'b crate::layer::Context<'a, Span>,
+ std::marker::PhantomData<N>,
+)
+where
+ Span: Subscriber + for<'lookup> crate::registry::LookupSpan<'lookup>,
+ N: for<'writer> FormatFields<'writer> + 'static;
+
+impl<'a, 'b, Span, N> serde::ser::Serialize for SerializableContext<'a, 'b, Span, N>
+where
+ Span: Subscriber + for<'lookup> crate::registry::LookupSpan<'lookup>,
+ N: for<'writer> FormatFields<'writer> + 'static,
+{
+ fn serialize<Ser>(&self, serializer_o: Ser) -> Result<Ser::Ok, Ser::Error>
+ where
+ Ser: serde::ser::Serializer,
+ {
+ use serde::ser::SerializeSeq;
+ let mut serializer = serializer_o.serialize_seq(None)?;
+
+ if let Some(leaf_span) = self.0.lookup_current() {
+ for span in leaf_span.scope().from_root() {
+ serializer.serialize_element(&SerializableSpan(&span, self.1))?;
+ }
+ }
+
+ serializer.end()
+ }
+}
+
+struct SerializableSpan<'a, 'b, Span, N>(
+ &'b crate::registry::SpanRef<'a, Span>,
+ std::marker::PhantomData<N>,
+)
+where
+ Span: for<'lookup> crate::registry::LookupSpan<'lookup>,
+ N: for<'writer> FormatFields<'writer> + 'static;
+
+impl<'a, 'b, Span, N> serde::ser::Serialize for SerializableSpan<'a, 'b, Span, N>
+where
+ Span: for<'lookup> crate::registry::LookupSpan<'lookup>,
+ N: for<'writer> FormatFields<'writer> + 'static,
+{
+ fn serialize<Ser>(&self, serializer: Ser) -> Result<Ser::Ok, Ser::Error>
+ where
+ Ser: serde::ser::Serializer,
+ {
+ let mut serializer = serializer.serialize_map(None)?;
+
+ let ext = self.0.extensions();
+ let data = ext
+ .get::<FormattedFields<N>>()
+ .expect("Unable to find FormattedFields in extensions; this is a bug");
+
+ // TODO: let's _not_ do this, but this resolves
+ // https://github.com/tokio-rs/tracing/issues/391.
+ // We should probably rework this to use a `serde_json::Value` or something
+ // similar in a JSON-specific layer, but I'd (david)
+ // rather have a uglier fix now rather than shipping broken JSON.
+ match serde_json::from_str::<serde_json::Value>(data) {
+ Ok(serde_json::Value::Object(fields)) => {
+ for field in fields {
+ serializer.serialize_entry(&field.0, &field.1)?;
+ }
+ }
+ // We have fields for this span which are valid JSON but not an object.
+ // This is probably a bug, so panic if we're in debug mode
+ Ok(_) if cfg!(debug_assertions) => panic!(
+ "span '{}' had malformed fields! this is a bug.\n error: invalid JSON object\n fields: {:?}",
+ self.0.metadata().name(),
+ data
+ ),
+ // If we *aren't* in debug mode, it's probably best not to
+ // crash the program, let's log the field found but also an
+ // message saying it's type is invalid
+ Ok(value) => {
+ serializer.serialize_entry("field", &value)?;
+ serializer.serialize_entry("field_error", "field was no a valid object")?
+ }
+ // We have previously recorded fields for this span
+ // should be valid JSON. However, they appear to *not*
+ // be valid JSON. This is almost certainly a bug, so
+ // panic if we're in debug mode
+ Err(e) if cfg!(debug_assertions) => panic!(
+ "span '{}' had malformed fields! this is a bug.\n error: {}\n fields: {:?}",
+ self.0.metadata().name(),
+ e,
+ data
+ ),
+ // If we *aren't* in debug mode, it's probably best not
+ // crash the program, but let's at least make sure it's clear
+ // that the fields are not supposed to be missing.
+ Err(e) => serializer.serialize_entry("field_error", &format!("{}", e))?,
+ };
+ serializer.serialize_entry("name", self.0.metadata().name())?;
+ serializer.end()
+ }
+}
+
+impl<S, N, T> FormatEvent<S, N> for Format<Json, T>
+where
+ S: Subscriber + for<'lookup> LookupSpan<'lookup>,
+ N: for<'writer> FormatFields<'writer> + 'static,
+ T: FormatTime,
+{
+ fn format_event(
+ &self,
+ ctx: &FmtContext<'_, S, N>,
+ mut writer: Writer<'_>,
+ event: &Event<'_>,
+ ) -> fmt::Result
+ where
+ S: Subscriber + for<'a> LookupSpan<'a>,
+ {
+ let mut timestamp = String::new();
+ self.timer.format_time(&mut Writer::new(&mut timestamp))?;
+
+ #[cfg(feature = "tracing-log")]
+ let normalized_meta = event.normalized_metadata();
+ #[cfg(feature = "tracing-log")]
+ let meta = normalized_meta.as_ref().unwrap_or_else(|| event.metadata());
+ #[cfg(not(feature = "tracing-log"))]
+ let meta = event.metadata();
+
+ let mut visit = || {
+ let mut serializer = Serializer::new(WriteAdaptor::new(&mut writer));
+
+ let mut serializer = serializer.serialize_map(None)?;
+
+ if self.display_timestamp {
+ serializer.serialize_entry("timestamp", &timestamp)?;
+ }
+
+ if self.display_level {
+ serializer.serialize_entry("level", &meta.level().as_serde())?;
+ }
+
+ 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
+ {
+ event
+ .parent()
+ .and_then(|id| ctx.span(id))
+ .or_else(|| ctx.lookup_current())
+ } else {
+ None
+ };
+
+ if self.format.flatten_event {
+ let mut visitor = tracing_serde::SerdeMapVisitor::new(serializer);
+ event.record(&mut visitor);
+
+ serializer = visitor.take_serializer()?;
+ } else {
+ use tracing_serde::fields::AsMap;
+ serializer.serialize_entry("fields", &event.field_map())?;
+ };
+
+ if self.display_target {
+ serializer.serialize_entry("target", meta.target())?;
+ }
+
+ if self.format.display_current_span {
+ if let Some(ref span) = current_span {
+ serializer
+ .serialize_entry("span", &SerializableSpan(span, format_field_marker))
+ .unwrap_or(());
+ }
+ }
+
+ if self.format.display_span_list && current_span.is_some() {
+ serializer.serialize_entry(
+ "spans",
+ &SerializableContext(&ctx.ctx, format_field_marker),
+ )?;
+ }
+
+ if self.display_thread_name {
+ let current_thread = std::thread::current();
+ match current_thread.name() {
+ Some(name) => {
+ serializer.serialize_entry("threadName", name)?;
+ }
+ // fall-back to thread id when name is absent and ids are not enabled
+ None if !self.display_thread_id => {
+ serializer
+ .serialize_entry("threadName", &format!("{:?}", current_thread.id()))?;
+ }
+ _ => {}
+ }
+ }
+
+ if self.display_thread_id {
+ serializer
+ .serialize_entry("threadId", &format!("{:?}", std::thread::current().id()))?;
+ }
+
+ serializer.end()
+ };
+
+ visit().map_err(|_| fmt::Error)?;
+ writeln!(writer)
+ }
+}
+
+impl Default for Json {
+ fn default() -> Json {
+ Json {
+ flatten_event: false,
+ display_current_span: true,
+ display_span_list: true,
+ }
+ }
+}
+
+/// The JSON [`FormatFields`] implementation.
+///
+/// [`FormatFields`]: trait.FormatFields.html
+#[derive(Debug)]
+pub struct JsonFields {
+ // reserve the ability to add fields to this without causing a breaking
+ // change in the future.
+ _private: (),
+}
+
+impl JsonFields {
+ /// Returns a new JSON [`FormatFields`] implementation.
+ ///
+ /// [`FormatFields`]: trait.FormatFields.html
+ pub fn new() -> Self {
+ Self { _private: () }
+ }
+}
+
+impl Default for JsonFields {
+ fn default() -> Self {
+ Self::new()
+ }
+}
+
+impl<'a> FormatFields<'a> for JsonFields {
+ /// Format the provided `fields` to the provided `writer`, returning a result.
+ fn format_fields<R: RecordFields>(&self, mut writer: Writer<'_>, fields: R) -> fmt::Result {
+ let mut v = JsonVisitor::new(&mut writer);
+ fields.record(&mut v);
+ v.finish()
+ }
+
+ /// Record additional field(s) on an existing span.
+ ///
+ /// By default, this appends a space to the current set of fields if it is
+ /// non-empty, and then calls `self.format_fields`. If different behavior is
+ /// required, the default implementation of this method can be overridden.
+ fn add_fields(
+ &self,
+ current: &'a mut FormattedFields<Self>,
+ fields: &Record<'_>,
+ ) -> fmt::Result {
+ if current.is_empty() {
+ // If there are no previously recorded fields, we can just reuse the
+ // existing string.
+ let mut writer = current.as_writer();
+ let mut v = JsonVisitor::new(&mut writer);
+ fields.record(&mut v);
+ v.finish()?;
+ return Ok(());
+ }
+
+ // If fields were previously recorded on this span, we need to parse
+ // the current set of fields as JSON, add the new fields, and
+ // re-serialize them. Otherwise, if we just appended the new fields
+ // to a previously serialized JSON object, we would end up with
+ // malformed JSON.
+ //
+ // XXX(eliza): this is far from efficient, but unfortunately, it is
+ // necessary as long as the JSON formatter is implemented on top of
+ // an interface that stores all formatted fields as strings.
+ //
+ // We should consider reimplementing the JSON formatter as a
+ // separate layer, rather than a formatter for the `fmt` layer —
+ // then, we could store fields as JSON values, and add to them
+ // without having to parse and re-serialize.
+ let mut new = String::new();
+ let map: BTreeMap<&'_ str, serde_json::Value> =
+ serde_json::from_str(current).map_err(|_| fmt::Error)?;
+ let mut v = JsonVisitor::new(&mut new);
+ v.values = map;
+ fields.record(&mut v);
+ v.finish()?;
+ current.fields = new;
+
+ Ok(())
+ }
+}
+
+/// The [visitor] produced by [`JsonFields`]'s [`MakeVisitor`] implementation.
+///
+/// [visitor]: ../../field/trait.Visit.html
+/// [`JsonFields`]: struct.JsonFields.html
+/// [`MakeVisitor`]: ../../field/trait.MakeVisitor.html
+pub struct JsonVisitor<'a> {
+ values: BTreeMap<&'a str, serde_json::Value>,
+ writer: &'a mut dyn Write,
+}
+
+impl<'a> fmt::Debug for JsonVisitor<'a> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ f.write_fmt(format_args!("JsonVisitor {{ values: {:?} }}", self.values))
+ }
+}
+
+impl<'a> JsonVisitor<'a> {
+ /// Returns a new default visitor that formats to the provided `writer`.
+ ///
+ /// # Arguments
+ /// - `writer`: the writer to format to.
+ /// - `is_empty`: whether or not any fields have been previously written to
+ /// that writer.
+ pub fn new(writer: &'a mut dyn Write) -> Self {
+ Self {
+ values: BTreeMap::new(),
+ writer,
+ }
+ }
+}
+
+impl<'a> crate::field::VisitFmt for JsonVisitor<'a> {
+ fn writer(&mut self) -> &mut dyn fmt::Write {
+ self.writer
+ }
+}
+
+impl<'a> crate::field::VisitOutput<fmt::Result> for JsonVisitor<'a> {
+ fn finish(self) -> fmt::Result {
+ let inner = || {
+ let mut serializer = Serializer::new(WriteAdaptor::new(self.writer));
+ let mut ser_map = serializer.serialize_map(None)?;
+
+ for (k, v) in self.values {
+ ser_map.serialize_entry(k, &v)?;
+ }
+
+ ser_map.end()
+ };
+
+ if inner().is_err() {
+ Err(fmt::Error)
+ } else {
+ Ok(())
+ }
+ }
+}
+
+impl<'a> field::Visit for JsonVisitor<'a> {
+ /// Visit a double precision floating point value.
+ fn record_f64(&mut self, field: &Field, value: f64) {
+ self.values
+ .insert(field.name(), serde_json::Value::from(value));
+ }
+
+ /// Visit a signed 64-bit integer value.
+ fn record_i64(&mut self, field: &Field, value: i64) {
+ self.values
+ .insert(field.name(), serde_json::Value::from(value));
+ }
+
+ /// Visit an unsigned 64-bit integer value.
+ fn record_u64(&mut self, field: &Field, value: u64) {
+ self.values
+ .insert(field.name(), serde_json::Value::from(value));
+ }
+
+ /// Visit a boolean value.
+ fn record_bool(&mut self, field: &Field, value: bool) {
+ self.values
+ .insert(field.name(), serde_json::Value::from(value));
+ }
+
+ /// Visit a string value.
+ fn record_str(&mut self, field: &Field, value: &str) {
+ self.values
+ .insert(field.name(), serde_json::Value::from(value));
+ }
+
+ fn record_debug(&mut self, field: &Field, value: &dyn fmt::Debug) {
+ match field.name() {
+ // Skip fields that are actually log metadata that have already been handled
+ #[cfg(feature = "tracing-log")]
+ name if name.starts_with("log.") => (),
+ name if name.starts_with("r#") => {
+ self.values
+ .insert(&name[2..], serde_json::Value::from(format!("{:?}", value)));
+ }
+ name => {
+ self.values
+ .insert(name, serde_json::Value::from(format!("{:?}", value)));
+ }
+ };
+ }
+}
+#[cfg(test)]
+mod test {
+ use super::*;
+ use crate::fmt::{format::FmtSpan, test::MockMakeWriter, time::FormatTime, SubscriberBuilder};
+ use tracing::{self, subscriber::with_default};
+
+ use std::fmt;
+
+ struct MockTime;
+ impl FormatTime for MockTime {
+ fn format_time(&self, w: &mut Writer<'_>) -> fmt::Result {
+ write!(w, "fake time")
+ }
+ }
+
+ fn subscriber() -> SubscriberBuilder<JsonFields, Format<Json>> {
+ SubscriberBuilder::default().json()
+ }
+
+ #[test]
+ fn json() {
+ let expected =
+ "{\"timestamp\":\"fake time\",\"level\":\"INFO\",\"span\":{\"answer\":42,\"name\":\"json_span\",\"number\":3},\"spans\":[{\"answer\":42,\"name\":\"json_span\",\"number\":3}],\"target\":\"tracing_subscriber::fmt::format::json::test\",\"fields\":{\"message\":\"some json test\"}}\n";
+ let subscriber = subscriber()
+ .flatten_event(false)
+ .with_current_span(true)
+ .with_span_list(true);
+ test_json(expected, subscriber, || {
+ let span = tracing::span!(tracing::Level::INFO, "json_span", answer = 42, number = 3);
+ let _guard = span.enter();
+ tracing::info!("some json test");
+ });
+ }
+
+ #[test]
+ fn json_flattened_event() {
+ let expected =
+ "{\"timestamp\":\"fake time\",\"level\":\"INFO\",\"span\":{\"answer\":42,\"name\":\"json_span\",\"number\":3},\"spans\":[{\"answer\":42,\"name\":\"json_span\",\"number\":3}],\"target\":\"tracing_subscriber::fmt::format::json::test\",\"message\":\"some json test\"}\n";
+
+ let subscriber = subscriber()
+ .flatten_event(true)
+ .with_current_span(true)
+ .with_span_list(true);
+ test_json(expected, subscriber, || {
+ let span = tracing::span!(tracing::Level::INFO, "json_span", answer = 42, number = 3);
+ let _guard = span.enter();
+ tracing::info!("some json test");
+ });
+ }
+
+ #[test]
+ fn json_disabled_current_span_event() {
+ let expected =
+ "{\"timestamp\":\"fake time\",\"level\":\"INFO\",\"spans\":[{\"answer\":42,\"name\":\"json_span\",\"number\":3}],\"target\":\"tracing_subscriber::fmt::format::json::test\",\"fields\":{\"message\":\"some json test\"}}\n";
+ let subscriber = subscriber()
+ .flatten_event(false)
+ .with_current_span(false)
+ .with_span_list(true);
+ test_json(expected, subscriber, || {
+ let span = tracing::span!(tracing::Level::INFO, "json_span", answer = 42, number = 3);
+ let _guard = span.enter();
+ tracing::info!("some json test");
+ });
+ }
+
+ #[test]
+ fn json_disabled_span_list_event() {
+ let expected =
+ "{\"timestamp\":\"fake time\",\"level\":\"INFO\",\"span\":{\"answer\":42,\"name\":\"json_span\",\"number\":3},\"target\":\"tracing_subscriber::fmt::format::json::test\",\"fields\":{\"message\":\"some json test\"}}\n";
+ let subscriber = subscriber()
+ .flatten_event(false)
+ .with_current_span(true)
+ .with_span_list(false);
+ test_json(expected, subscriber, || {
+ let span = tracing::span!(tracing::Level::INFO, "json_span", answer = 42, number = 3);
+ let _guard = span.enter();
+ tracing::info!("some json test");
+ });
+ }
+
+ #[test]
+ fn json_nested_span() {
+ let expected =
+ "{\"timestamp\":\"fake time\",\"level\":\"INFO\",\"span\":{\"answer\":43,\"name\":\"nested_json_span\",\"number\":4},\"spans\":[{\"answer\":42,\"name\":\"json_span\",\"number\":3},{\"answer\":43,\"name\":\"nested_json_span\",\"number\":4}],\"target\":\"tracing_subscriber::fmt::format::json::test\",\"fields\":{\"message\":\"some json test\"}}\n";
+ let subscriber = subscriber()
+ .flatten_event(false)
+ .with_current_span(true)
+ .with_span_list(true);
+ test_json(expected, subscriber, || {
+ let span = tracing::span!(tracing::Level::INFO, "json_span", answer = 42, number = 3);
+ let _guard = span.enter();
+ let span = tracing::span!(
+ tracing::Level::INFO,
+ "nested_json_span",
+ answer = 43,
+ number = 4
+ );
+ let _guard = span.enter();
+ tracing::info!("some json test");
+ });
+ }
+
+ #[test]
+ fn json_no_span() {
+ let expected =
+ "{\"timestamp\":\"fake time\",\"level\":\"INFO\",\"target\":\"tracing_subscriber::fmt::format::json::test\",\"fields\":{\"message\":\"some json test\"}}\n";
+ let subscriber = subscriber()
+ .flatten_event(false)
+ .with_current_span(true)
+ .with_span_list(true);
+ test_json(expected, subscriber, || {
+ tracing::info!("some json test");
+ });
+ }
+
+ #[test]
+ fn record_works() {
+ // This test reproduces issue #707, where using `Span::record` causes
+ // any events inside the span to be ignored.
+
+ let make_writer = MockMakeWriter::default();
+ let subscriber = crate::fmt()
+ .json()
+ .with_writer(make_writer.clone())
+ .finish();
+
+ with_default(subscriber, || {
+ tracing::info!("an event outside the root span");
+ assert_eq!(
+ parse_as_json(&make_writer)["fields"]["message"],
+ "an event outside the root span"
+ );
+
+ let span = tracing::info_span!("the span", na = tracing::field::Empty);
+ span.record("na", &"value");
+ let _enter = span.enter();
+
+ tracing::info!("an event inside the root span");
+ assert_eq!(
+ parse_as_json(&make_writer)["fields"]["message"],
+ "an event inside the root span"
+ );
+ });
+ }
+
+ #[test]
+ fn json_span_event_show_correct_context() {
+ let buffer = MockMakeWriter::default();
+ let subscriber = subscriber()
+ .with_writer(buffer.clone())
+ .flatten_event(false)
+ .with_current_span(true)
+ .with_span_list(false)
+ .with_span_events(FmtSpan::FULL)
+ .finish();
+
+ with_default(subscriber, || {
+ let context = "parent";
+ let parent_span = tracing::info_span!("parent_span", context);
+
+ let event = parse_as_json(&buffer);
+ assert_eq!(event["fields"]["message"], "new");
+ assert_eq!(event["span"]["context"], "parent");
+
+ let _parent_enter = parent_span.enter();
+ let event = parse_as_json(&buffer);
+ assert_eq!(event["fields"]["message"], "enter");
+ assert_eq!(event["span"]["context"], "parent");
+
+ let context = "child";
+ let child_span = tracing::info_span!("child_span", context);
+ let event = parse_as_json(&buffer);
+ assert_eq!(event["fields"]["message"], "new");
+ assert_eq!(event["span"]["context"], "child");
+
+ let _child_enter = child_span.enter();
+ let event = parse_as_json(&buffer);
+ assert_eq!(event["fields"]["message"], "enter");
+ assert_eq!(event["span"]["context"], "child");
+
+ drop(_child_enter);
+ let event = parse_as_json(&buffer);
+ assert_eq!(event["fields"]["message"], "exit");
+ assert_eq!(event["span"]["context"], "child");
+
+ drop(child_span);
+ let event = parse_as_json(&buffer);
+ assert_eq!(event["fields"]["message"], "close");
+ assert_eq!(event["span"]["context"], "child");
+
+ drop(_parent_enter);
+ let event = parse_as_json(&buffer);
+ assert_eq!(event["fields"]["message"], "exit");
+ assert_eq!(event["span"]["context"], "parent");
+
+ drop(parent_span);
+ let event = parse_as_json(&buffer);
+ assert_eq!(event["fields"]["message"], "close");
+ assert_eq!(event["span"]["context"], "parent");
+ });
+ }
+
+ #[test]
+ fn json_span_event_with_no_fields() {
+ // Check span events serialize correctly.
+ // Discussion: https://github.com/tokio-rs/tracing/issues/829#issuecomment-661984255
+ let buffer = MockMakeWriter::default();
+ let subscriber = subscriber()
+ .with_writer(buffer.clone())
+ .flatten_event(false)
+ .with_current_span(false)
+ .with_span_list(false)
+ .with_span_events(FmtSpan::FULL)
+ .finish();
+
+ with_default(subscriber, || {
+ let span = tracing::info_span!("valid_json");
+ assert_eq!(parse_as_json(&buffer)["fields"]["message"], "new");
+
+ let _enter = span.enter();
+ assert_eq!(parse_as_json(&buffer)["fields"]["message"], "enter");
+
+ drop(_enter);
+ assert_eq!(parse_as_json(&buffer)["fields"]["message"], "exit");
+
+ drop(span);
+ assert_eq!(parse_as_json(&buffer)["fields"]["message"], "close");
+ });
+ }
+
+ fn parse_as_json(buffer: &MockMakeWriter) -> serde_json::Value {
+ let buf = String::from_utf8(buffer.buf().to_vec()).unwrap();
+ let json = buf
+ .lines()
+ .last()
+ .expect("expected at least one line to be written!");
+ match serde_json::from_str(json) {
+ Ok(v) => v,
+ Err(e) => panic!(
+ "assertion failed: JSON shouldn't be malformed\n error: {}\n json: {}",
+ e, json
+ ),
+ }
+ }
+
+ fn test_json<T>(
+ expected: &str,
+ builder: crate::fmt::SubscriberBuilder<JsonFields, Format<Json>>,
+ producer: impl FnOnce() -> T,
+ ) {
+ let make_writer = MockMakeWriter::default();
+ let subscriber = builder
+ .with_writer(make_writer.clone())
+ .with_timer(MockTime)
+ .finish();
+
+ with_default(subscriber, producer);
+
+ let buf = make_writer.buf();
+ let actual = std::str::from_utf8(&buf[..]).unwrap();
+ assert_eq!(
+ serde_json::from_str::<std::collections::HashMap<&str, serde_json::Value>>(expected)
+ .unwrap(),
+ serde_json::from_str(actual).unwrap()
+ );
+ }
+}
diff --git a/vendor/tracing-subscriber-0.3.3/src/fmt/format/mod.rs b/vendor/tracing-subscriber-0.3.3/src/fmt/format/mod.rs
new file mode 100644
index 000000000..9001e102e
--- /dev/null
+++ b/vendor/tracing-subscriber-0.3.3/src/fmt/format/mod.rs
@@ -0,0 +1,1798 @@
+//! Formatters for logging `tracing` events.
+use super::time::{FormatTime, SystemTime};
+use crate::{
+ field::{MakeOutput, MakeVisitor, RecordFields, VisitFmt, VisitOutput},
+ fmt::fmt_layer::FmtContext,
+ fmt::fmt_layer::FormattedFields,
+ registry::LookupSpan,
+};
+
+use std::fmt::{self, Debug, Display, Write};
+use tracing_core::{
+ field::{self, Field, Visit},
+ span, Event, Level, Subscriber,
+};
+
+#[cfg(feature = "tracing-log")]
+use tracing_log::NormalizeEvent;
+
+#[cfg(feature = "ansi")]
+use ansi_term::{Colour, Style};
+
+#[cfg(feature = "json")]
+mod json;
+#[cfg(feature = "json")]
+#[cfg_attr(docsrs, doc(cfg(feature = "json")))]
+pub use json::*;
+
+#[cfg(feature = "ansi")]
+mod pretty;
+#[cfg(feature = "ansi")]
+#[cfg_attr(docsrs, doc(cfg(feature = "ansi")))]
+pub use pretty::*;
+
+/// A type that can format a tracing [`Event`] to a [`Writer`].
+///
+/// `FormatEvent` is primarily used in the context of [`fmt::Subscriber`] or
+/// [`fmt::Layer`]. Each time an event is dispatched to [`fmt::Subscriber`] or
+/// [`fmt::Layer`], the subscriber or layer
+/// forwards it to its associated `FormatEvent` to emit a log message.
+///
+/// This trait is already implemented for function pointers with the same
+/// signature as `format_event`.
+///
+/// # Arguments
+///
+/// The following arguments are passed to `FormatEvent::format_event`:
+///
+/// * A [`FmtContext`]. This is an extension of the [`layer::Context`] type,
+/// which can be used for accessing stored information such as the current
+/// span context an event occurred in.
+///
+/// In addition, [`FmtContext`] exposes access to the [`FormatFields`]
+/// implementation that the subscriber was configured to use via the
+/// [`FmtContext::field_format`] method. This can be used when the
+/// [`FormatEvent`] implementation needs to format the event's fields.
+///
+/// For convenience, [`FmtContext`] also [implements `FormatFields`],
+/// forwarding to the configured [`FormatFields`] type.
+///
+/// * A [`Writer`] to which the formatted representation of the event is
+/// written. This type implements the [`std::fmt::Write`] trait, and therefore
+/// can be used with the [`std::write!`] and [`std::writeln!`] macros, as well
+/// as calling [`std::fmt::Write`] methods directly.
+///
+/// The [`Writer`] type also implements additional methods that provide
+/// information about how the event should be formatted. The
+/// [`Writer::has_ansi_escapes`] method indicates whether [ANSI terminal
+/// escape codes] are supported by the underlying I/O writer that the event
+/// will be written to. If this returns `true`, the formatter is permitted to
+/// use ANSI escape codes to add colors and other text formatting to its
+/// output. If it returns `false`, the event will be written to an output that
+/// does not support ANSI escape codes (such as a log file), and they should
+/// not be emitted.
+///
+/// Crates like [`ansi_term`] and [`owo-colors`] can be used to add ANSI
+/// escape codes to formatted output.
+///
+/// * The actual [`Event`] to be formatted.
+///
+/// # Examples
+///
+/// This example re-implements a simiplified version of this crate's [default
+/// formatter]:
+///
+/// ```rust
+/// use std::fmt;
+/// use tracing_core::{Subscriber, Event};
+/// use tracing_subscriber::fmt::{
+/// format::{self, FormatEvent, FormatFields},
+/// FmtContext,
+/// FormattedFields,
+/// };
+/// use tracing_subscriber::registry::LookupSpan;
+///
+/// struct MyFormatter;
+///
+/// impl<S, N> FormatEvent<S, N> for MyFormatter
+/// where
+/// S: Subscriber + for<'a> LookupSpan<'a>,
+/// N: for<'a> FormatFields<'a> + 'static,
+/// {
+/// fn format_event(
+/// &self,
+/// ctx: &FmtContext<'_, S, N>,
+/// mut writer: format::Writer<'_>,
+/// event: &Event<'_>,
+/// ) -> fmt::Result {
+/// // Format values from the event's's metadata:
+/// let metadata = event.metadata();
+/// write!(&mut writer, "{} {}: ", metadata.level(), metadata.target())?;
+///
+/// // Format all the spans in the event's span context.
+/// if let Some(scope) = ctx.event_scope() {
+/// for span in scope.from_root() {
+/// write!(writer, "{}", span.name())?;
+///
+/// // `FormattedFields` is a formatted representation of the span's
+/// // fields, which is stored in its extensions by the `fmt` layer's
+/// // `new_span` method. The fields will have been formatted
+/// // by the same field formatter that's provided to the event
+/// // formatter in the `FmtContext`.
+/// let ext = span.extensions();
+/// let fields = &ext
+/// .get::<FormattedFields<N>>()
+/// .expect("will never be `None`");
+///
+/// // Skip formatting the fields if the span had no fields.
+/// if !fields.is_empty() {
+/// write!(writer, "{{{}}}", fields)?;
+/// }
+/// write!(writer, ": ")?;
+/// }
+/// }
+///
+/// // Write fields on the event
+/// ctx.field_format().format_fields(writer.by_ref(), event)?;
+///
+/// writeln!(writer)
+/// }
+/// }
+///
+/// let _subscriber = tracing_subscriber::fmt()
+/// .event_format(MyFormatter)
+/// .init();
+///
+/// let _span = tracing::info_span!("my_span", answer = 42).entered();
+/// tracing::info!(question = "life, the universe, and everything", "hello world");
+/// ```
+///
+/// This formatter will print events like this:
+///
+/// ```text
+/// DEBUG yak_shaving::shaver: some-span{field-on-span=foo}: started shaving yak
+/// ```
+///
+/// [`fmt::Layer`]: super::Layer
+/// [`fmt::Subscriber`]: super::Subscriber
+/// [`Event`]: tracing::Event
+/// [implements `FormatFields`]: super::FmtContext#impl-FormatFields<'writer>
+/// [ANSI terminal escape codes]: https://en.wikipedia.org/wiki/ANSI_escape_code
+/// [`Writer::has_ansi_escapes`]: Writer::has_ansi_escapes
+/// [`ansi_term`]: https://crates.io/crates/ansi_term
+/// [`owo-colors`]: https://crates.io/crates/owo-colors
+/// [default formatter]: Full
+pub trait FormatEvent<S, N>
+where
+ S: Subscriber + for<'a> LookupSpan<'a>,
+ N: for<'a> FormatFields<'a> + 'static,
+{
+ /// Write a log message for `Event` in `Context` to the given [`Writer`].
+ fn format_event(
+ &self,
+ ctx: &FmtContext<'_, S, N>,
+ writer: Writer<'_>,
+ event: &Event<'_>,
+ ) -> fmt::Result;
+}
+
+impl<S, N> FormatEvent<S, N>
+ for fn(ctx: &FmtContext<'_, S, N>, Writer<'_>, &Event<'_>) -> fmt::Result
+where
+ S: Subscriber + for<'a> LookupSpan<'a>,
+ N: for<'a> FormatFields<'a> + 'static,
+{
+ fn format_event(
+ &self,
+ ctx: &FmtContext<'_, S, N>,
+ writer: Writer<'_>,
+ event: &Event<'_>,
+ ) -> fmt::Result {
+ (*self)(ctx, writer, event)
+ }
+}
+/// A type that can format a [set of fields] to a [`Writer`].
+///
+/// `FormatFields` is primarily used in the context of [`FmtSubscriber`]. Each
+/// time a span or event with fields is recorded, the subscriber will format
+/// those fields with its associated `FormatFields` implementation.
+///
+/// [set of fields]: ../field/trait.RecordFields.html
+/// [`FmtSubscriber`]: ../fmt/struct.Subscriber.html
+pub trait FormatFields<'writer> {
+ /// Format the provided `fields` to the provided [`Writer`], returning a result.
+ fn format_fields<R: RecordFields>(&self, writer: Writer<'writer>, fields: R) -> fmt::Result;
+
+ /// Record additional field(s) on an existing span.
+ ///
+ /// By default, this appends a space to the current set of fields if it is
+ /// non-empty, and then calls `self.format_fields`. If different behavior is
+ /// required, the default implementation of this method can be overridden.
+ fn add_fields(
+ &self,
+ current: &'writer mut FormattedFields<Self>,
+ fields: &span::Record<'_>,
+ ) -> fmt::Result {
+ if !current.fields.is_empty() {
+ current.fields.push(' ');
+ }
+ self.format_fields(current.as_writer(), fields)
+ }
+}
+
+/// Returns the default configuration for an [event formatter].
+///
+/// Methods on the returned event formatter can be used for further
+/// configuration. For example:
+///
+/// ```rust
+/// let format = tracing_subscriber::fmt::format()
+/// .without_time() // Don't include timestamps
+/// .with_target(false) // Don't include event targets.
+/// .with_level(false) // Don't include event levels.
+/// .compact(); // Use a more compact, abbreviated format.
+///
+/// // Use the configured formatter when building a new subscriber.
+/// tracing_subscriber::fmt()
+/// .event_format(format)
+/// .init();
+/// ```
+pub fn format() -> Format {
+ Format::default()
+}
+
+/// Returns the default configuration for a JSON [event formatter].
+#[cfg(feature = "json")]
+#[cfg_attr(docsrs, doc(cfg(feature = "json")))]
+pub fn json() -> Format<Json> {
+ format().json()
+}
+
+/// Returns a [`FormatFields`] implementation that formats fields using the
+/// provided function or closure.
+///
+/// [`FormatFields`]: trait.FormatFields.html
+pub fn debug_fn<F>(f: F) -> FieldFn<F>
+where
+ F: Fn(&mut Writer<'_>, &Field, &dyn fmt::Debug) -> fmt::Result + Clone,
+{
+ FieldFn(f)
+}
+
+/// A writer to which formatted representations of spans and events are written.
+///
+/// This type is provided as input to the [`FormatEvent::format_event`] and
+/// [`FormatFields::format_fields`] methods, which will write formatted
+/// representations of [`Event`]s and [fields] to the `Writer`.
+///
+/// This type implements the [`std::fmt::Write`] trait, allowing it to be used
+/// with any function that takes an instance of [`std::fmt::Write`].
+/// Additionally, it can be used with the standard library's [`std::write!`] and
+/// [`std::writeln!`] macros.
+///
+/// Additionally, a `Writer` may expose additional `tracing`-specific
+/// information to the formatter implementation.
+pub struct Writer<'writer> {
+ writer: &'writer mut dyn fmt::Write,
+ // TODO(eliza): add ANSI support
+ is_ansi: bool,
+}
+
+/// A [`FormatFields`] implementation that formats fields by calling a function
+/// or closure.
+///
+/// [`FormatFields`]: trait.FormatFields.html
+#[derive(Debug, Clone)]
+pub struct FieldFn<F>(F);
+/// The [visitor] produced by [`FieldFn`]'s [`MakeVisitor`] implementation.
+///
+/// [visitor]: ../../field/trait.Visit.html
+/// [`FieldFn`]: struct.FieldFn.html
+/// [`MakeVisitor`]: ../../field/trait.MakeVisitor.html
+pub struct FieldFnVisitor<'a, F> {
+ f: F,
+ writer: Writer<'a>,
+ result: fmt::Result,
+}
+/// Marker for `Format` that indicates that the compact log format should be used.
+///
+/// The compact format only includes the fields from the most recently entered span.
+#[derive(Default, Debug, Copy, Clone, Eq, PartialEq)]
+pub struct Compact;
+
+/// Marker for `Format` that indicates that the verbose log format should be used.
+///
+/// The full format includes fields from all entered spans.
+#[derive(Default, Debug, Copy, Clone, Eq, PartialEq)]
+pub struct Full;
+
+/// A pre-configured event formatter.
+///
+/// You will usually want to use this as the `FormatEvent` for a `FmtSubscriber`.
+///
+/// The default logging format, [`Full`] includes all fields in each event and its containing
+/// spans. The [`Compact`] logging format includes only the fields from the most-recently-entered
+/// span.
+#[derive(Debug, Clone)]
+pub struct Format<F = Full, T = SystemTime> {
+ format: F,
+ pub(crate) timer: T,
+ pub(crate) ansi: Option<bool>,
+ pub(crate) display_timestamp: bool,
+ pub(crate) display_target: bool,
+ pub(crate) display_level: bool,
+ pub(crate) display_thread_id: bool,
+ pub(crate) display_thread_name: bool,
+}
+
+// === impl Writer ===
+
+impl<'writer> Writer<'writer> {
+ // TODO(eliza): consider making this a public API?
+ // We may not want to do that if we choose to expose specialized
+ // constructors instead (e.g. `from_string` that stores whether the string
+ // is empty...?)
+ pub(crate) fn new(writer: &'writer mut impl fmt::Write) -> Self {
+ Self {
+ writer: writer as &mut dyn fmt::Write,
+ is_ansi: false,
+ }
+ }
+
+ // TODO(eliza): consider making this a public API?
+ pub(crate) fn with_ansi(self, is_ansi: bool) -> Self {
+ Self { is_ansi, ..self }
+ }
+
+ /// Return a new `Writer` that mutably borrows `self`.
+ ///
+ /// This can be used to temporarily borrow a `Writer` to pass a new `Writer`
+ /// to a function that takes a `Writer` by value, allowing the original writer
+ /// to still be used once that function returns.
+ pub fn by_ref(&mut self) -> Writer<'_> {
+ let is_ansi = self.is_ansi;
+ Writer {
+ writer: self as &mut dyn fmt::Write,
+ is_ansi,
+ }
+ }
+
+ /// Writes a string slice into this `Writer`, returning whether the write succeeded.
+ ///
+ /// This method can only succeed if the entire string slice was successfully
+ /// written, and this method will not return until all data has been written
+ /// or an error occurs.
+ ///
+ /// This is identical to calling the [`write_str` method] from the `Writer`'s
+ /// [`std::fmt::Write`] implementation. However, it is also provided as an
+ /// inherent method, so that `Writer`s can be used without needing to import the
+ /// [`std::fmt::Write`] trait.
+ ///
+ /// # Errors
+ ///
+ /// This function will return an instance of [`std::fmt::Error`] on error.
+ ///
+ /// [`write_str` method]: std::fmt::Write::write_str
+ #[inline]
+ pub fn write_str(&mut self, s: &str) -> fmt::Result {
+ self.writer.write_str(s)
+ }
+
+ /// Writes a [`char`] into this writer, returning whether the write succeeded.
+ ///
+ /// A single [`char`] may be encoded as more than one byte.
+ /// This method can only succeed if the entire byte sequence was successfully
+ /// written, and this method will not return until all data has been
+ /// written or an error occurs.
+ ///
+ /// This is identical to calling the [`write_char` method] from the `Writer`'s
+ /// [`std::fmt::Write`] implementation. However, it is also provided as an
+ /// inherent method, so that `Writer`s can be used without needing to import the
+ /// [`std::fmt::Write`] trait.
+ ///
+ /// # Errors
+ ///
+ /// This function will return an instance of [`std::fmt::Error`] on error.
+ ///
+ /// [`write_char` method]: std::fmt::Write::write_char
+ #[inline]
+ pub fn write_char(&mut self, c: char) -> fmt::Result {
+ self.writer.write_char(c)
+ }
+
+ /// Glue for usage of the [`write!`] macro with `Writer`s.
+ ///
+ /// This method should generally not be invoked manually, but rather through
+ /// the [`write!`] macro itself.
+ ///
+ /// This is identical to calling the [`write_fmt` method] from the `Writer`'s
+ /// [`std::fmt::Write`] implementation. However, it is also provided as an
+ /// inherent method, so that `Writer`s can be used with the [`write!` macro]
+ /// without needing to import the
+ /// [`std::fmt::Write`] trait.
+ ///
+ /// [`write_fmt` method]: std::fmt::Write::write_fmt
+ pub fn write_fmt(&mut self, args: fmt::Arguments<'_>) -> fmt::Result {
+ self.writer.write_fmt(args)
+ }
+
+ /// Returns `true` if [ANSI escape codes] may be used to add colors
+ /// and other formatting when writing to this `Writer`.
+ ///
+ /// If this returns `false`, formatters should not emit ANSI escape codes.
+ ///
+ /// [ANSI escape codes]: https://en.wikipedia.org/wiki/ANSI_escape_code
+ pub fn has_ansi_escapes(&self) -> bool {
+ self.is_ansi
+ }
+
+ pub(in crate::fmt::format) fn bold(&self) -> Style {
+ #[cfg(feature = "ansi")]
+ {
+ if self.is_ansi {
+ return Style::new().bold();
+ }
+ }
+
+ Style::new()
+ }
+
+ pub(in crate::fmt::format) fn dimmed(&self) -> Style {
+ #[cfg(feature = "ansi")]
+ {
+ if self.is_ansi {
+ return Style::new().dimmed();
+ }
+ }
+
+ Style::new()
+ }
+
+ pub(in crate::fmt::format) fn italic(&self) -> Style {
+ #[cfg(feature = "ansi")]
+ {
+ if self.is_ansi {
+ return Style::new().italic();
+ }
+ }
+
+ Style::new()
+ }
+}
+
+impl fmt::Write for Writer<'_> {
+ #[inline]
+ fn write_str(&mut self, s: &str) -> fmt::Result {
+ Writer::write_str(self, s)
+ }
+
+ #[inline]
+ fn write_char(&mut self, c: char) -> fmt::Result {
+ Writer::write_char(self, c)
+ }
+
+ #[inline]
+ fn write_fmt(&mut self, args: fmt::Arguments<'_>) -> fmt::Result {
+ Writer::write_fmt(self, args)
+ }
+}
+
+impl fmt::Debug for Writer<'_> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ f.debug_struct("Writer")
+ .field("writer", &format_args!("<&mut dyn fmt::Write>"))
+ .field("is_ansi", &self.is_ansi)
+ .finish()
+ }
+}
+
+// === impl Format ===
+
+impl Default for Format<Full, SystemTime> {
+ fn default() -> Self {
+ Format {
+ format: Full,
+ timer: SystemTime,
+ ansi: None,
+ display_timestamp: true,
+ display_target: true,
+ display_level: true,
+ display_thread_id: false,
+ display_thread_name: false,
+ }
+ }
+}
+
+impl<F, T> Format<F, T> {
+ /// Use a less verbose output format.
+ ///
+ /// See [`Compact`].
+ pub fn compact(self) -> Format<Compact, T> {
+ Format {
+ format: Compact,
+ timer: self.timer,
+ ansi: self.ansi,
+ display_target: self.display_target,
+ display_timestamp: self.display_timestamp,
+ display_level: self.display_level,
+ display_thread_id: self.display_thread_id,
+ display_thread_name: self.display_thread_name,
+ }
+ }
+
+ /// Use an excessively pretty, human-readable output format.
+ ///
+ /// See [`Pretty`].
+ ///
+ /// Note that this requires the "ansi" feature to be enabled.
+ ///
+ /// # Options
+ ///
+ /// [`Format::with_ansi`] can be used to disable ANSI terminal escape codes (which enable
+ /// formatting such as colors, bold, italic, etc) in event formatting. However, a field
+ /// formatter must be manually provided to avoid ANSI in the formatting of parent spans, like
+ /// so:
+ ///
+ /// ```
+ /// # use tracing_subscriber::fmt::format;
+ /// tracing_subscriber::fmt()
+ /// .pretty()
+ /// .with_ansi(false)
+ /// .fmt_fields(format::PrettyFields::new().with_ansi(false))
+ /// // ... other settings ...
+ /// .init();
+ /// ```
+ #[cfg(feature = "ansi")]
+ #[cfg_attr(docsrs, doc(cfg(feature = "ansi")))]
+ pub fn pretty(self) -> Format<Pretty, T> {
+ Format {
+ format: Pretty::default(),
+ timer: self.timer,
+ ansi: self.ansi,
+ display_target: self.display_target,
+ display_timestamp: self.display_timestamp,
+ display_level: self.display_level,
+ display_thread_id: self.display_thread_id,
+ display_thread_name: self.display_thread_name,
+ }
+ }
+
+ /// Use the full JSON format.
+ ///
+ /// The full format includes fields from all entered spans.
+ ///
+ /// # Example Output
+ ///
+ /// ```ignore,json
+ /// {"timestamp":"Feb 20 11:28:15.096","level":"INFO","target":"mycrate","fields":{"message":"some message", "key": "value"}}
+ /// ```
+ ///
+ /// # Options
+ ///
+ /// - [`Format::flatten_event`] can be used to enable flattening event fields into the root
+ /// object.
+ ///
+ /// [`Format::flatten_event`]: #method.flatten_event
+ #[cfg(feature = "json")]
+ #[cfg_attr(docsrs, doc(cfg(feature = "json")))]
+ pub fn json(self) -> Format<Json, T> {
+ Format {
+ format: Json::default(),
+ timer: self.timer,
+ ansi: self.ansi,
+ display_target: self.display_target,
+ display_timestamp: self.display_timestamp,
+ display_level: self.display_level,
+ display_thread_id: self.display_thread_id,
+ display_thread_name: self.display_thread_name,
+ }
+ }
+
+ /// Use the given [`timer`] for log message timestamps.
+ ///
+ /// See [`time` module] for the provided timer implementations.
+ ///
+ /// Note that using the `"time"` feature flag enables the
+ /// additional time formatters [`UtcTime`] and [`LocalTime`], which use the
+ /// [`time` crate] to provide more sophisticated timestamp formatting
+ /// options.
+ ///
+ /// [`timer`]: super::time::FormatTime
+ /// [`time` module]: mod@super::time
+ /// [`UtcTime`]: super::time::UtcTime
+ /// [`LocalTime`]: super::time::LocalTime
+ /// [`time` crate]: https://docs.rs/time/0.3
+ pub fn with_timer<T2>(self, timer: T2) -> Format<F, T2> {
+ Format {
+ format: self.format,
+ timer,
+ ansi: self.ansi,
+ display_target: self.display_target,
+ display_timestamp: self.display_timestamp,
+ display_level: self.display_level,
+ display_thread_id: self.display_thread_id,
+ display_thread_name: self.display_thread_name,
+ }
+ }
+
+ /// Do not emit timestamps with log messages.
+ pub fn without_time(self) -> Format<F, ()> {
+ Format {
+ format: self.format,
+ timer: (),
+ ansi: self.ansi,
+ display_timestamp: false,
+ display_target: self.display_target,
+ display_level: self.display_level,
+ display_thread_id: self.display_thread_id,
+ display_thread_name: self.display_thread_name,
+ }
+ }
+
+ /// Enable ANSI terminal colors for formatted output.
+ pub fn with_ansi(self, ansi: bool) -> Format<F, T> {
+ Format {
+ ansi: Some(ansi),
+ ..self
+ }
+ }
+
+ /// Sets whether or not an event's target is displayed.
+ pub fn with_target(self, display_target: bool) -> Format<F, T> {
+ Format {
+ display_target,
+ ..self
+ }
+ }
+
+ /// Sets whether or not an event's level is displayed.
+ pub fn with_level(self, display_level: bool) -> Format<F, T> {
+ Format {
+ display_level,
+ ..self
+ }
+ }
+
+ /// Sets whether or not the [thread ID] of the current thread is displayed
+ /// when formatting events
+ ///
+ /// [thread ID]: https://doc.rust-lang.org/stable/std/thread/struct.ThreadId.html
+ pub fn with_thread_ids(self, display_thread_id: bool) -> Format<F, T> {
+ Format {
+ display_thread_id,
+ ..self
+ }
+ }
+
+ /// Sets whether or not the [name] of the current thread is displayed
+ /// when formatting events
+ ///
+ /// [name]: https://doc.rust-lang.org/stable/std/thread/index.html#naming-threads
+ pub fn with_thread_names(self, display_thread_name: bool) -> Format<F, T> {
+ Format {
+ display_thread_name,
+ ..self
+ }
+ }
+
+ #[inline]
+ fn format_timestamp(&self, writer: &mut Writer<'_>) -> fmt::Result
+ where
+ T: FormatTime,
+ {
+ // If timestamps are disabled, do nothing.
+ if !self.display_timestamp {
+ return Ok(());
+ }
+
+ // If ANSI color codes are enabled, format the timestamp with ANSI
+ // colors.
+ #[cfg(feature = "ansi")]
+ {
+ if writer.has_ansi_escapes() {
+ let style = Style::new().dimmed();
+ write!(writer, "{}", style.prefix())?;
+ self.timer.format_time(writer)?;
+ write!(writer, "{} ", style.suffix())?;
+ return Ok(());
+ }
+ }
+
+ // Otherwise, just format the timestamp without ANSI formatting.
+ self.timer.format_time(writer)?;
+ writer.write_char(' ')
+ }
+}
+
+#[cfg(feature = "json")]
+#[cfg_attr(docsrs, doc(cfg(feature = "json")))]
+impl<T> Format<Json, T> {
+ /// Use the full JSON format with the event's event fields flattened.
+ ///
+ /// # Example Output
+ ///
+ /// ```ignore,json
+ /// {"timestamp":"Feb 20 11:28:15.096","level":"INFO","target":"mycrate", "message":"some message", "key": "value"}
+ /// ```
+ /// See [`Json`](../format/struct.Json.html).
+ #[cfg(feature = "json")]
+ #[cfg_attr(docsrs, doc(cfg(feature = "json")))]
+ pub fn flatten_event(mut self, flatten_event: bool) -> Format<Json, T> {
+ self.format.flatten_event(flatten_event);
+ self
+ }
+
+ /// Sets whether or not the formatter will include the current span in
+ /// formatted events.
+ ///
+ /// See [`format::Json`](../fmt/format/struct.Json.html)
+ #[cfg(feature = "json")]
+ #[cfg_attr(docsrs, doc(cfg(feature = "json")))]
+ pub fn with_current_span(mut self, display_current_span: bool) -> 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`](../fmt/format/struct.Json.html)
+ #[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>
+where
+ S: Subscriber + for<'a> LookupSpan<'a>,
+ N: for<'a> FormatFields<'a> + 'static,
+ T: FormatTime,
+{
+ fn format_event(
+ &self,
+ ctx: &FmtContext<'_, S, N>,
+ mut writer: Writer<'_>,
+ event: &Event<'_>,
+ ) -> fmt::Result {
+ #[cfg(feature = "tracing-log")]
+ let normalized_meta = event.normalized_metadata();
+ #[cfg(feature = "tracing-log")]
+ let meta = normalized_meta.as_ref().unwrap_or_else(|| event.metadata());
+ #[cfg(not(feature = "tracing-log"))]
+ let meta = event.metadata();
+
+ // if the `Format` struct *also* has an ANSI color configuration,
+ // override the writer...the API for configuring ANSI color codes on the
+ // `Format` struct is deprecated, but we still need to honor those
+ // configurations.
+ if let Some(ansi) = self.ansi {
+ writer = writer.with_ansi(ansi);
+ }
+
+ self.format_timestamp(&mut writer)?;
+
+ if self.display_level {
+ let fmt_level = {
+ #[cfg(feature = "ansi")]
+ {
+ FmtLevel::new(meta.level(), writer.has_ansi_escapes())
+ }
+ #[cfg(not(feature = "ansi"))]
+ {
+ FmtLevel::new(meta.level())
+ }
+ };
+ write!(writer, "{} ", fmt_level)?;
+ }
+
+ if self.display_thread_name {
+ let current_thread = std::thread::current();
+ match current_thread.name() {
+ Some(name) => {
+ write!(writer, "{} ", FmtThreadName::new(name))?;
+ }
+ // fall-back to thread id when name is absent and ids are not enabled
+ None if !self.display_thread_id => {
+ write!(writer, "{:0>2?} ", current_thread.id())?;
+ }
+ _ => {}
+ }
+ }
+
+ if self.display_thread_id {
+ write!(writer, "{:0>2?} ", std::thread::current().id())?;
+ }
+
+ let dimmed = writer.dimmed();
+
+ if let Some(scope) = ctx.event_scope() {
+ let bold = writer.bold();
+
+ 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(' ')?;
+ }
+ };
+
+ if self.display_target {
+ write!(
+ writer,
+ "{}{} ",
+ dimmed.paint(meta.target()),
+ dimmed.paint(":")
+ )?;
+ }
+
+ ctx.format_fields(writer.by_ref(), event)?;
+ writeln!(writer)
+ }
+}
+
+impl<S, N, T> FormatEvent<S, N> for Format<Compact, T>
+where
+ S: Subscriber + for<'a> LookupSpan<'a>,
+ N: for<'a> FormatFields<'a> + 'static,
+ T: FormatTime,
+{
+ fn format_event(
+ &self,
+ ctx: &FmtContext<'_, S, N>,
+ mut writer: Writer<'_>,
+ event: &Event<'_>,
+ ) -> fmt::Result {
+ #[cfg(feature = "tracing-log")]
+ let normalized_meta = event.normalized_metadata();
+ #[cfg(feature = "tracing-log")]
+ let meta = normalized_meta.as_ref().unwrap_or_else(|| event.metadata());
+ #[cfg(not(feature = "tracing-log"))]
+ let meta = event.metadata();
+
+ // if the `Format` struct *also* has an ANSI color configuration,
+ // override the writer...the API for configuring ANSI color codes on the
+ // `Format` struct is deprecated, but we still need to honor those
+ // configurations.
+ if let Some(ansi) = self.ansi {
+ writer = writer.with_ansi(ansi);
+ }
+
+ self.format_timestamp(&mut writer)?;
+
+ if self.display_level {
+ let fmt_level = {
+ #[cfg(feature = "ansi")]
+ {
+ FmtLevel::new(meta.level(), writer.has_ansi_escapes())
+ }
+ #[cfg(not(feature = "ansi"))]
+ {
+ FmtLevel::new(meta.level())
+ }
+ };
+ write!(writer, "{} ", fmt_level)?;
+ }
+
+ if self.display_thread_name {
+ let current_thread = std::thread::current();
+ match current_thread.name() {
+ Some(name) => {
+ write!(writer, "{} ", FmtThreadName::new(name))?;
+ }
+ // fall-back to thread id when name is absent and ids are not enabled
+ None if !self.display_thread_id => {
+ write!(writer, "{:0>2?} ", current_thread.id())?;
+ }
+ _ => {}
+ }
+ }
+
+ if self.display_thread_id {
+ write!(writer, "{:0>2?} ", std::thread::current().id())?;
+ }
+
+ let fmt_ctx = {
+ #[cfg(feature = "ansi")]
+ {
+ FmtCtx::new(ctx, event.parent(), writer.has_ansi_escapes())
+ }
+ #[cfg(not(feature = "ansi"))]
+ {
+ FmtCtx::new(&ctx, event.parent())
+ }
+ };
+ write!(writer, "{}", fmt_ctx)?;
+
+ if self.display_target {
+ write!(
+ writer,
+ "{}{} ",
+ writer.bold().paint(meta.target()),
+ writer.dimmed().paint(":")
+ )?;
+ }
+
+ ctx.format_fields(writer.by_ref(), event)?;
+
+ let dimmed = writer.dimmed();
+ for span in ctx
+ .event_scope()
+ .into_iter()
+ .map(crate::registry::Scope::from_root)
+ .flatten()
+ {
+ let exts = span.extensions();
+ if let Some(fields) = exts.get::<FormattedFields<N>>() {
+ if !fields.is_empty() {
+ write!(writer, " {}", dimmed.paint(&fields.fields))?;
+ }
+ }
+ }
+ writeln!(writer)
+ }
+}
+
+// === impl FormatFields ===
+impl<'writer, M> FormatFields<'writer> for M
+where
+ M: MakeOutput<Writer<'writer>, fmt::Result>,
+ M::Visitor: VisitFmt + VisitOutput<fmt::Result>,
+{
+ fn format_fields<R: RecordFields>(&self, writer: Writer<'writer>, fields: R) -> fmt::Result {
+ let mut v = self.make_visitor(writer);
+ fields.record(&mut v);
+ v.finish()
+ }
+}
+
+/// The default [`FormatFields`] implementation.
+///
+/// [`FormatFields`]: trait.FormatFields.html
+#[derive(Debug)]
+pub struct DefaultFields {
+ // reserve the ability to add fields to this without causing a breaking
+ // change in the future.
+ _private: (),
+}
+
+/// The [visitor] produced by [`DefaultFields`]'s [`MakeVisitor`] implementation.
+///
+/// [visitor]: super::super::field::Visit
+/// [`MakeVisitor`]: super::super::field::MakeVisitor
+#[derive(Debug)]
+pub struct DefaultVisitor<'a> {
+ writer: Writer<'a>,
+ is_empty: bool,
+ result: fmt::Result,
+}
+
+impl DefaultFields {
+ /// Returns a new default [`FormatFields`] implementation.
+ ///
+ /// [`FormatFields`]: trait.FormatFields.html
+ pub fn new() -> Self {
+ Self { _private: () }
+ }
+}
+
+impl Default for DefaultFields {
+ fn default() -> Self {
+ Self::new()
+ }
+}
+
+impl<'a> MakeVisitor<Writer<'a>> for DefaultFields {
+ type Visitor = DefaultVisitor<'a>;
+
+ #[inline]
+ fn make_visitor(&self, target: Writer<'a>) -> Self::Visitor {
+ DefaultVisitor::new(target, true)
+ }
+}
+
+// === impl DefaultVisitor ===
+
+impl<'a> DefaultVisitor<'a> {
+ /// Returns a new default visitor that formats to the provided `writer`.
+ ///
+ /// # Arguments
+ /// - `writer`: the writer to format to.
+ /// - `is_empty`: whether or not any fields have been previously written to
+ /// that writer.
+ pub fn new(writer: Writer<'a>, is_empty: bool) -> Self {
+ Self {
+ writer,
+ is_empty,
+ result: Ok(()),
+ }
+ }
+
+ fn maybe_pad(&mut self) {
+ if self.is_empty {
+ self.is_empty = false;
+ } else {
+ self.result = write!(self.writer, " ");
+ }
+ }
+}
+
+impl<'a> field::Visit for DefaultVisitor<'a> {
+ fn record_str(&mut self, field: &Field, value: &str) {
+ if self.result.is_err() {
+ return;
+ }
+
+ if field.name() == "message" {
+ self.record_debug(field, &format_args!("{}", value))
+ } else {
+ self.record_debug(field, &value)
+ }
+ }
+
+ fn record_error(&mut self, field: &Field, value: &(dyn std::error::Error + 'static)) {
+ if let Some(source) = value.source() {
+ let italic = self.writer.italic();
+ self.record_debug(
+ field,
+ &format_args!(
+ "{} {}{}{}{}",
+ value,
+ italic.paint(field.name()),
+ italic.paint(".sources"),
+ self.writer.dimmed().paint("="),
+ ErrorSourceList(source)
+ ),
+ )
+ } else {
+ self.record_debug(field, &format_args!("{}", value))
+ }
+ }
+
+ fn record_debug(&mut self, field: &Field, value: &dyn fmt::Debug) {
+ if self.result.is_err() {
+ return;
+ }
+
+ self.maybe_pad();
+ self.result = match field.name() {
+ "message" => write!(self.writer, "{:?}", value),
+ // Skip fields that are actually log metadata that have already been handled
+ #[cfg(feature = "tracing-log")]
+ name if name.starts_with("log.") => Ok(()),
+ name if name.starts_with("r#") => write!(
+ self.writer,
+ "{}{}{:?}",
+ self.writer.italic().paint(&name[2..]),
+ self.writer.dimmed().paint("="),
+ value
+ ),
+ name => write!(
+ self.writer,
+ "{}{}{:?}",
+ self.writer.italic().paint(name),
+ self.writer.dimmed().paint("="),
+ value
+ ),
+ };
+ }
+}
+
+impl<'a> crate::field::VisitOutput<fmt::Result> for DefaultVisitor<'a> {
+ fn finish(self) -> fmt::Result {
+ self.result
+ }
+}
+
+impl<'a> crate::field::VisitFmt for DefaultVisitor<'a> {
+ fn writer(&mut self) -> &mut dyn fmt::Write {
+ &mut self.writer
+ }
+}
+
+/// Renders an error into a list of sources, *including* the error
+struct ErrorSourceList<'a>(&'a (dyn std::error::Error + 'static));
+
+impl<'a> Display for ErrorSourceList<'a> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ let mut list = f.debug_list();
+ let mut curr = Some(self.0);
+ while let Some(curr_err) = curr {
+ list.entry(&format_args!("{}", curr_err));
+ curr = curr_err.source();
+ }
+ list.finish()
+ }
+}
+
+struct FmtCtx<'a, S, N> {
+ ctx: &'a FmtContext<'a, S, N>,
+ span: Option<&'a span::Id>,
+ #[cfg(feature = "ansi")]
+ ansi: bool,
+}
+
+impl<'a, S, N: 'a> FmtCtx<'a, S, N>
+where
+ S: Subscriber + for<'lookup> LookupSpan<'lookup>,
+ N: for<'writer> FormatFields<'writer> + 'static,
+{
+ #[cfg(feature = "ansi")]
+ pub(crate) fn new(
+ ctx: &'a FmtContext<'_, S, N>,
+ span: Option<&'a span::Id>,
+ ansi: bool,
+ ) -> Self {
+ Self { ctx, span, ansi }
+ }
+
+ #[cfg(not(feature = "ansi"))]
+ pub(crate) fn new(ctx: &'a FmtContext<'_, S, N>, span: Option<&'a span::Id>) -> Self {
+ Self { ctx, span }
+ }
+
+ fn bold(&self) -> Style {
+ #[cfg(feature = "ansi")]
+ {
+ if self.ansi {
+ return Style::new().bold();
+ }
+ }
+
+ Style::new()
+ }
+}
+
+impl<'a, S, N: 'a> fmt::Display for FmtCtx<'a, S, N>
+where
+ S: Subscriber + for<'lookup> LookupSpan<'lookup>,
+ N: for<'writer> FormatFields<'writer> + 'static,
+{
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ let bold = self.bold();
+ let mut seen = false;
+
+ let span = self
+ .span
+ .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());
+
+ for span in scope {
+ seen = true;
+ write!(f, "{}:", bold.paint(span.metadata().name()))?;
+ }
+
+ if seen {
+ f.write_char(' ')?;
+ }
+ Ok(())
+ }
+}
+
+#[cfg(not(feature = "ansi"))]
+struct Style;
+
+#[cfg(not(feature = "ansi"))]
+impl Style {
+ fn new() -> Self {
+ Style
+ }
+
+ fn bold(self) -> Self {
+ self
+ }
+
+ fn paint(&self, d: impl fmt::Display) -> impl fmt::Display {
+ d
+ }
+}
+
+struct FmtThreadName<'a> {
+ name: &'a str,
+}
+
+impl<'a> FmtThreadName<'a> {
+ pub(crate) fn new(name: &'a str) -> Self {
+ Self { name }
+ }
+}
+
+impl<'a> fmt::Display for FmtThreadName<'a> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ use std::sync::atomic::{
+ AtomicUsize,
+ Ordering::{AcqRel, Acquire, Relaxed},
+ };
+
+ // Track the longest thread name length we've seen so far in an atomic,
+ // so that it can be updated by any thread.
+ static MAX_LEN: AtomicUsize = AtomicUsize::new(0);
+ let len = self.name.len();
+ // Snapshot the current max thread name length.
+ let mut max_len = MAX_LEN.load(Relaxed);
+
+ while len > max_len {
+ // Try to set a new max length, if it is still the value we took a
+ // snapshot of.
+ match MAX_LEN.compare_exchange(max_len, len, AcqRel, Acquire) {
+ // We successfully set the new max value
+ Ok(_) => break,
+ // Another thread set a new max value since we last observed
+ // it! It's possible that the new length is actually longer than
+ // ours, so we'll loop again and check whether our length is
+ // still the longest. If not, we'll just use the newer value.
+ Err(actual) => max_len = actual,
+ }
+ }
+
+ // pad thread name using `max_len`
+ write!(f, "{:>width$}", self.name, width = max_len)
+ }
+}
+
+struct FmtLevel<'a> {
+ level: &'a Level,
+ #[cfg(feature = "ansi")]
+ ansi: bool,
+}
+
+impl<'a> FmtLevel<'a> {
+ #[cfg(feature = "ansi")]
+ pub(crate) fn new(level: &'a Level, ansi: bool) -> Self {
+ Self { level, ansi }
+ }
+
+ #[cfg(not(feature = "ansi"))]
+ pub(crate) fn new(level: &'a Level) -> Self {
+ Self { level }
+ }
+}
+
+const TRACE_STR: &str = "TRACE";
+const DEBUG_STR: &str = "DEBUG";
+const INFO_STR: &str = " INFO";
+const WARN_STR: &str = " WARN";
+const ERROR_STR: &str = "ERROR";
+
+#[cfg(not(feature = "ansi"))]
+impl<'a> fmt::Display for FmtLevel<'a> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ match *self.level {
+ Level::TRACE => f.pad(TRACE_STR),
+ Level::DEBUG => f.pad(DEBUG_STR),
+ Level::INFO => f.pad(INFO_STR),
+ Level::WARN => f.pad(WARN_STR),
+ Level::ERROR => f.pad(ERROR_STR),
+ }
+ }
+}
+
+#[cfg(feature = "ansi")]
+impl<'a> fmt::Display for FmtLevel<'a> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ if self.ansi {
+ match *self.level {
+ Level::TRACE => write!(f, "{}", Colour::Purple.paint(TRACE_STR)),
+ Level::DEBUG => write!(f, "{}", Colour::Blue.paint(DEBUG_STR)),
+ Level::INFO => write!(f, "{}", Colour::Green.paint(INFO_STR)),
+ Level::WARN => write!(f, "{}", Colour::Yellow.paint(WARN_STR)),
+ Level::ERROR => write!(f, "{}", Colour::Red.paint(ERROR_STR)),
+ }
+ } else {
+ match *self.level {
+ Level::TRACE => f.pad(TRACE_STR),
+ Level::DEBUG => f.pad(DEBUG_STR),
+ Level::INFO => f.pad(INFO_STR),
+ Level::WARN => f.pad(WARN_STR),
+ Level::ERROR => f.pad(ERROR_STR),
+ }
+ }
+ }
+}
+
+// === impl FieldFn ===
+
+impl<'a, F> MakeVisitor<Writer<'a>> for FieldFn<F>
+where
+ F: Fn(&mut Writer<'a>, &Field, &dyn fmt::Debug) -> fmt::Result + Clone,
+{
+ type Visitor = FieldFnVisitor<'a, F>;
+
+ fn make_visitor(&self, writer: Writer<'a>) -> Self::Visitor {
+ FieldFnVisitor {
+ writer,
+ f: self.0.clone(),
+ result: Ok(()),
+ }
+ }
+}
+
+impl<'a, F> Visit for FieldFnVisitor<'a, F>
+where
+ F: Fn(&mut Writer<'a>, &Field, &dyn fmt::Debug) -> fmt::Result,
+{
+ fn record_debug(&mut self, field: &Field, value: &dyn fmt::Debug) {
+ if self.result.is_ok() {
+ self.result = (self.f)(&mut self.writer, field, value)
+ }
+ }
+}
+
+impl<'a, F> VisitOutput<fmt::Result> for FieldFnVisitor<'a, F>
+where
+ F: Fn(&mut Writer<'a>, &Field, &dyn fmt::Debug) -> fmt::Result,
+{
+ fn finish(self) -> fmt::Result {
+ self.result
+ }
+}
+
+impl<'a, F> VisitFmt for FieldFnVisitor<'a, F>
+where
+ F: Fn(&mut Writer<'a>, &Field, &dyn fmt::Debug) -> fmt::Result,
+{
+ fn writer(&mut self) -> &mut dyn fmt::Write {
+ &mut self.writer
+ }
+}
+
+impl<'a, F> fmt::Debug for FieldFnVisitor<'a, F> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ f.debug_struct("FieldFnVisitor")
+ .field("f", &format_args!("{}", std::any::type_name::<F>()))
+ .field("writer", &self.writer)
+ .field("result", &self.result)
+ .finish()
+ }
+}
+
+// === printing synthetic Span events ===
+
+/// Configures what points in the span lifecycle are logged as events.
+///
+/// See also [`with_span_events`](../struct.SubscriberBuilder.html#method.with_span_events).
+#[derive(Clone, Eq, PartialEq, Ord, PartialOrd)]
+pub struct FmtSpan(u8);
+
+impl FmtSpan {
+ /// one event when span is created
+ pub const NEW: FmtSpan = FmtSpan(1 << 0);
+ /// one event per enter of a span
+ pub const ENTER: FmtSpan = FmtSpan(1 << 1);
+ /// one event per exit of a span
+ pub const EXIT: FmtSpan = FmtSpan(1 << 2);
+ /// one event when the span is dropped
+ pub const CLOSE: FmtSpan = FmtSpan(1 << 3);
+
+ /// spans are ignored (this is the default)
+ pub const NONE: FmtSpan = FmtSpan(0);
+ /// one event per enter/exit of a span
+ pub const ACTIVE: FmtSpan = FmtSpan(FmtSpan::ENTER.0 | FmtSpan::EXIT.0);
+ /// events at all points (new, enter, exit, drop)
+ pub const FULL: FmtSpan =
+ FmtSpan(FmtSpan::NEW.0 | FmtSpan::ENTER.0 | FmtSpan::EXIT.0 | FmtSpan::CLOSE.0);
+
+ /// Check whether or not a certain flag is set for this [`FmtSpan`]
+ fn contains(&self, other: FmtSpan) -> bool {
+ self.clone() & other.clone() == other
+ }
+}
+
+macro_rules! impl_fmt_span_bit_op {
+ ($trait:ident, $func:ident, $op:tt) => {
+ impl std::ops::$trait for FmtSpan {
+ type Output = FmtSpan;
+
+ fn $func(self, rhs: Self) -> Self::Output {
+ FmtSpan(self.0 $op rhs.0)
+ }
+ }
+ };
+}
+
+macro_rules! impl_fmt_span_bit_assign_op {
+ ($trait:ident, $func:ident, $op:tt) => {
+ impl std::ops::$trait for FmtSpan {
+ fn $func(&mut self, rhs: Self) {
+ *self = FmtSpan(self.0 $op rhs.0)
+ }
+ }
+ };
+}
+
+impl_fmt_span_bit_op!(BitAnd, bitand, &);
+impl_fmt_span_bit_op!(BitOr, bitor, |);
+impl_fmt_span_bit_op!(BitXor, bitxor, ^);
+
+impl_fmt_span_bit_assign_op!(BitAndAssign, bitand_assign, &);
+impl_fmt_span_bit_assign_op!(BitOrAssign, bitor_assign, |);
+impl_fmt_span_bit_assign_op!(BitXorAssign, bitxor_assign, ^);
+
+impl Debug for FmtSpan {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ let mut wrote_flag = false;
+ let mut write_flags = |flag, flag_str| -> fmt::Result {
+ if self.contains(flag) {
+ if wrote_flag {
+ f.write_str(" | ")?;
+ }
+
+ f.write_str(flag_str)?;
+ wrote_flag = true;
+ }
+
+ Ok(())
+ };
+
+ if FmtSpan::NONE | self.clone() == FmtSpan::NONE {
+ f.write_str("FmtSpan::NONE")?;
+ } else {
+ write_flags(FmtSpan::NEW, "FmtSpan::NEW")?;
+ write_flags(FmtSpan::ENTER, "FmtSpan::ENTER")?;
+ write_flags(FmtSpan::EXIT, "FmtSpan::EXIT")?;
+ write_flags(FmtSpan::CLOSE, "FmtSpan::CLOSE")?;
+ }
+
+ Ok(())
+ }
+}
+
+pub(super) struct FmtSpanConfig {
+ pub(super) kind: FmtSpan,
+ pub(super) fmt_timing: bool,
+}
+
+impl FmtSpanConfig {
+ pub(super) fn without_time(self) -> Self {
+ Self {
+ kind: self.kind,
+ fmt_timing: false,
+ }
+ }
+ pub(super) fn with_kind(self, kind: FmtSpan) -> Self {
+ Self {
+ kind,
+ fmt_timing: self.fmt_timing,
+ }
+ }
+ pub(super) fn trace_new(&self) -> bool {
+ self.kind.contains(FmtSpan::NEW)
+ }
+ pub(super) fn trace_enter(&self) -> bool {
+ self.kind.contains(FmtSpan::ENTER)
+ }
+ pub(super) fn trace_exit(&self) -> bool {
+ self.kind.contains(FmtSpan::EXIT)
+ }
+ pub(super) fn trace_close(&self) -> bool {
+ self.kind.contains(FmtSpan::CLOSE)
+ }
+}
+
+impl Debug for FmtSpanConfig {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ self.kind.fmt(f)
+ }
+}
+
+impl Default for FmtSpanConfig {
+ fn default() -> Self {
+ Self {
+ kind: FmtSpan::NONE,
+ fmt_timing: true,
+ }
+ }
+}
+
+pub(super) struct TimingDisplay(pub(super) u64);
+impl Display for TimingDisplay {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ let mut t = self.0 as f64;
+ for unit in ["ns", "µs", "ms", "s"].iter() {
+ if t < 10.0 {
+ return write!(f, "{:.2}{}", t, unit);
+ } else if t < 100.0 {
+ return write!(f, "{:.1}{}", t, unit);
+ } else if t < 1000.0 {
+ return write!(f, "{:.0}{}", t, unit);
+ }
+ t /= 1000.0;
+ }
+ write!(f, "{:.0}s", t * 1000.0)
+ }
+}
+
+#[cfg(test)]
+pub(super) mod test {
+ use crate::fmt::{test::MockMakeWriter, time::FormatTime};
+ use tracing::{
+ self,
+ dispatcher::{set_default, Dispatch},
+ subscriber::with_default,
+ };
+
+ use super::*;
+ use std::fmt;
+
+ pub(crate) struct MockTime;
+ impl FormatTime for MockTime {
+ fn format_time(&self, w: &mut Writer<'_>) -> fmt::Result {
+ write!(w, "fake time")
+ }
+ }
+
+ #[test]
+ fn disable_everything() {
+ // This test reproduces https://github.com/tokio-rs/tracing/issues/1354
+ let make_writer = MockMakeWriter::default();
+ let subscriber = crate::fmt::Subscriber::builder()
+ .with_writer(make_writer.clone())
+ .without_time()
+ .with_level(false)
+ .with_target(false)
+ .with_thread_ids(false)
+ .with_thread_names(false);
+ #[cfg(feature = "ansi")]
+ let subscriber = subscriber.with_ansi(false);
+ run_test(subscriber, make_writer, "hello\n")
+ }
+
+ fn test_ansi<T>(
+ is_ansi: bool,
+ expected: &str,
+ builder: crate::fmt::SubscriberBuilder<DefaultFields, Format<T>>,
+ ) where
+ Format<T, MockTime>: FormatEvent<crate::Registry, DefaultFields>,
+ T: Send + Sync + 'static,
+ {
+ let make_writer = MockMakeWriter::default();
+ let subscriber = builder
+ .with_writer(make_writer.clone())
+ .with_ansi(is_ansi)
+ .with_timer(MockTime);
+ run_test(subscriber, make_writer, expected)
+ }
+
+ #[cfg(not(feature = "ansi"))]
+ fn test_without_ansi<T>(
+ expected: &str,
+ builder: crate::fmt::SubscriberBuilder<DefaultFields, Format<T>>,
+ ) where
+ Format<T, MockTime>: FormatEvent<crate::Registry, DefaultFields>,
+ T: Send + Sync,
+ {
+ let make_writer = MockMakeWriter::default();
+ let subscriber = builder.with_writer(make_writer).with_timer(MockTime);
+ run_test(subscriber, make_writer, expected)
+ }
+
+ fn test_without_level<T>(
+ expected: &str,
+ builder: crate::fmt::SubscriberBuilder<DefaultFields, Format<T>>,
+ ) where
+ Format<T, MockTime>: FormatEvent<crate::Registry, DefaultFields>,
+ T: Send + Sync + 'static,
+ {
+ let make_writer = MockMakeWriter::default();
+ let subscriber = builder
+ .with_writer(make_writer.clone())
+ .with_level(false)
+ .with_ansi(false)
+ .with_timer(MockTime);
+ run_test(subscriber, make_writer, expected);
+ }
+
+ fn test_overridden_parents<T>(
+ expected: &str,
+ builder: crate::fmt::SubscriberBuilder<DefaultFields, Format<T>>,
+ ) where
+ Format<T, MockTime>: FormatEvent<crate::Registry, DefaultFields>,
+ T: Send + Sync + 'static,
+ {
+ let make_writer = MockMakeWriter::default();
+ let collector = builder
+ .with_writer(make_writer.clone())
+ .with_level(false)
+ .with_ansi(false)
+ .with_timer(MockTime)
+ .finish();
+
+ with_default(collector, || {
+ let span1 = tracing::info_span!("span1", span = 1);
+ let span2 = tracing::info_span!(parent: &span1, "span2", span = 2);
+ tracing::info!(parent: &span2, "hello");
+ });
+ assert_eq!(expected, make_writer.get_string());
+ }
+
+ fn test_overridden_parents_in_scope<T>(
+ expected1: &str,
+ expected2: &str,
+ builder: crate::fmt::SubscriberBuilder<DefaultFields, Format<T>>,
+ ) where
+ Format<T, MockTime>: FormatEvent<crate::Registry, DefaultFields>,
+ T: Send + Sync + 'static,
+ {
+ let make_writer = MockMakeWriter::default();
+ let subscriber = builder
+ .with_writer(make_writer.clone())
+ .with_level(false)
+ .with_ansi(false)
+ .with_timer(MockTime)
+ .finish();
+
+ with_default(subscriber, || {
+ let span1 = tracing::info_span!("span1", span = 1);
+ let span2 = tracing::info_span!(parent: &span1, "span2", span = 2);
+ let span3 = tracing::info_span!("span3", span = 3);
+ let _e3 = span3.enter();
+
+ tracing::info!("hello");
+ assert_eq!(expected1, make_writer.get_string().as_str());
+
+ tracing::info!(parent: &span2, "hello");
+ assert_eq!(expected2, make_writer.get_string().as_str());
+ });
+ }
+
+ fn run_test(subscriber: impl Into<Dispatch>, buf: MockMakeWriter, expected: &str) {
+ let _default = set_default(&subscriber.into());
+ tracing::info!("hello");
+ assert_eq!(expected, buf.get_string())
+ }
+
+ mod default {
+ use super::*;
+ #[cfg(feature = "ansi")]
+ #[test]
+ fn with_ansi_true() {
+ let expected = "\u{1b}[2mfake time\u{1b}[0m \u{1b}[32m INFO\u{1b}[0m \u{1b}[2mtracing_subscriber::fmt::format::test\u{1b}[0m\u{1b}[2m:\u{1b}[0m hello\n";
+ test_ansi(true, expected, crate::fmt::Subscriber::builder());
+ }
+
+ #[cfg(feature = "ansi")]
+ #[test]
+ fn with_ansi_false() {
+ let expected = "fake time INFO tracing_subscriber::fmt::format::test: hello\n";
+ test_ansi(false, expected, crate::fmt::Subscriber::builder());
+ }
+
+ #[cfg(not(feature = "ansi"))]
+ #[test]
+ fn without_ansi() {
+ let expected = "fake time INFO tracing_subscriber::fmt::format::test: hello\n";
+ test_without_ansi(expected, crate::fmt::Subscriber::builder())
+ }
+
+ #[test]
+ fn without_level() {
+ let expected = "fake time tracing_subscriber::fmt::format::test: hello\n";
+ test_without_level(expected, crate::fmt::Subscriber::builder())
+ }
+
+ #[test]
+ fn overridden_parents() {
+ let expected = "fake time span1{span=1}:span2{span=2}: tracing_subscriber::fmt::format::test: hello\n";
+ test_overridden_parents(expected, crate::fmt::Subscriber::builder())
+ }
+
+ #[test]
+ fn overridden_parents_in_scope() {
+ test_overridden_parents_in_scope(
+ "fake time span3{span=3}: tracing_subscriber::fmt::format::test: hello\n",
+ "fake time span1{span=1}:span2{span=2}: tracing_subscriber::fmt::format::test: hello\n",
+ crate::fmt::Subscriber::builder(),
+ )
+ }
+ }
+
+ mod compact {
+ use super::*;
+
+ #[cfg(feature = "ansi")]
+ #[test]
+ fn with_ansi_true() {
+ let expected = "\u{1b}[2mfake time\u{1b}[0m \u{1b}[32m INFO\u{1b}[0m \u{1b}[1mtracing_subscriber::fmt::format::test\u{1b}[0m\u{1b}[2m:\u{1b}[0m hello\n";
+ test_ansi(true, expected, crate::fmt::Subscriber::builder().compact())
+ }
+
+ #[cfg(feature = "ansi")]
+ #[test]
+ fn with_ansi_false() {
+ let expected = "fake time INFO tracing_subscriber::fmt::format::test: hello\n";
+ test_ansi(false, expected, crate::fmt::Subscriber::builder().compact());
+ }
+
+ #[cfg(not(feature = "ansi"))]
+ #[test]
+ fn without_ansi() {
+ let expected = "fake time INFO tracing_subscriber::fmt::format::test: hello\n";
+ test_without_ansi(expected, crate::fmt::Subscriber::builder().compact())
+ }
+
+ #[test]
+ fn without_level() {
+ let expected = "fake time tracing_subscriber::fmt::format::test: hello\n";
+ test_without_level(expected, crate::fmt::Subscriber::builder().compact());
+ }
+
+ #[test]
+ fn overridden_parents() {
+ let expected = "fake time span1:span2: tracing_subscriber::fmt::format::test: hello span=1 span=2\n";
+ test_overridden_parents(expected, crate::fmt::Subscriber::builder().compact())
+ }
+
+ #[test]
+ fn overridden_parents_in_scope() {
+ test_overridden_parents_in_scope(
+ "fake time span3: tracing_subscriber::fmt::format::test: hello span=3\n",
+ "fake time span1:span2: tracing_subscriber::fmt::format::test: hello span=1 span=2\n",
+ crate::fmt::Subscriber::builder().compact(),
+ )
+ }
+ }
+
+ #[test]
+ fn format_nanos() {
+ fn fmt(t: u64) -> String {
+ TimingDisplay(t).to_string()
+ }
+
+ assert_eq!(fmt(1), "1.00ns");
+ assert_eq!(fmt(12), "12.0ns");
+ assert_eq!(fmt(123), "123ns");
+ assert_eq!(fmt(1234), "1.23µs");
+ assert_eq!(fmt(12345), "12.3µs");
+ assert_eq!(fmt(123456), "123µs");
+ assert_eq!(fmt(1234567), "1.23ms");
+ assert_eq!(fmt(12345678), "12.3ms");
+ assert_eq!(fmt(123456789), "123ms");
+ assert_eq!(fmt(1234567890), "1.23s");
+ assert_eq!(fmt(12345678901), "12.3s");
+ assert_eq!(fmt(123456789012), "123s");
+ assert_eq!(fmt(1234567890123), "1235s");
+ }
+
+ #[test]
+ fn fmt_span_combinations() {
+ let f = FmtSpan::NONE;
+ assert!(!f.contains(FmtSpan::NEW));
+ assert!(!f.contains(FmtSpan::ENTER));
+ assert!(!f.contains(FmtSpan::EXIT));
+ assert!(!f.contains(FmtSpan::CLOSE));
+
+ let f = FmtSpan::ACTIVE;
+ assert!(!f.contains(FmtSpan::NEW));
+ assert!(f.contains(FmtSpan::ENTER));
+ assert!(f.contains(FmtSpan::EXIT));
+ assert!(!f.contains(FmtSpan::CLOSE));
+
+ let f = FmtSpan::FULL;
+ assert!(f.contains(FmtSpan::NEW));
+ assert!(f.contains(FmtSpan::ENTER));
+ assert!(f.contains(FmtSpan::EXIT));
+ assert!(f.contains(FmtSpan::CLOSE));
+
+ let f = FmtSpan::NEW | FmtSpan::CLOSE;
+ assert!(f.contains(FmtSpan::NEW));
+ assert!(!f.contains(FmtSpan::ENTER));
+ assert!(!f.contains(FmtSpan::EXIT));
+ assert!(f.contains(FmtSpan::CLOSE));
+ }
+}
diff --git a/vendor/tracing-subscriber-0.3.3/src/fmt/format/pretty.rs b/vendor/tracing-subscriber-0.3.3/src/fmt/format/pretty.rs
new file mode 100644
index 000000000..3e47e2d93
--- /dev/null
+++ b/vendor/tracing-subscriber-0.3.3/src/fmt/format/pretty.rs
@@ -0,0 +1,415 @@
+use super::*;
+use crate::{
+ field::{VisitFmt, VisitOutput},
+ fmt::fmt_layer::{FmtContext, FormattedFields},
+ registry::LookupSpan,
+};
+
+use std::fmt;
+use tracing_core::{
+ field::{self, Field},
+ Event, Level, Subscriber,
+};
+
+#[cfg(feature = "tracing-log")]
+use tracing_log::NormalizeEvent;
+
+use ansi_term::{Colour, Style};
+
+/// An excessively pretty, human-readable event formatter.
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct Pretty {
+ display_location: bool,
+}
+
+/// The [visitor] produced by [`Pretty`]'s [`MakeVisitor`] implementation.
+///
+/// [visitor]: field::Visit
+/// [`MakeVisitor`]: crate::field::MakeVisitor
+#[derive(Debug)]
+pub struct PrettyVisitor<'a> {
+ writer: Writer<'a>,
+ is_empty: bool,
+ style: Style,
+ result: fmt::Result,
+}
+
+/// An excessively pretty, human-readable [`MakeVisitor`] implementation.
+///
+/// [`MakeVisitor`]: crate::field::MakeVisitor
+#[derive(Debug)]
+pub struct PrettyFields {
+ /// A value to override the provided `Writer`'s ANSI formatting
+ /// configuration.
+ ///
+ /// If this is `Some`, we override the `Writer`'s ANSI setting. This is
+ /// necessary in order to continue supporting the deprecated
+ /// `PrettyFields::with_ansi` method. If it is `None`, we don't override the
+ /// ANSI formatting configuration (because the deprecated method was not
+ /// called).
+ // TODO: when `PrettyFields::with_ansi` is removed, we can get rid
+ // of this entirely.
+ ansi: Option<bool>,
+}
+
+// === impl Pretty ===
+
+impl Default for Pretty {
+ fn default() -> Self {
+ Self {
+ display_location: true,
+ }
+ }
+}
+
+impl Pretty {
+ fn style_for(level: &Level) -> Style {
+ match *level {
+ Level::TRACE => Style::new().fg(Colour::Purple),
+ Level::DEBUG => Style::new().fg(Colour::Blue),
+ Level::INFO => Style::new().fg(Colour::Green),
+ Level::WARN => Style::new().fg(Colour::Yellow),
+ Level::ERROR => Style::new().fg(Colour::Red),
+ }
+ }
+
+ /// Sets whether the event's source code location is displayed.
+ ///
+ /// This defaults to `true`.
+ pub fn with_source_location(self, display_location: bool) -> Self {
+ Self {
+ display_location,
+ ..self
+ }
+ }
+}
+
+impl<T> Format<Pretty, T> {
+ /// Sets whether or not the source code location from which an event
+ /// originated is displayed.
+ ///
+ /// This defaults to `true`.
+ pub fn with_source_location(mut self, display_location: bool) -> Self {
+ self.format = self.format.with_source_location(display_location);
+ self
+ }
+}
+
+impl<C, N, T> FormatEvent<C, N> for Format<Pretty, T>
+where
+ C: Subscriber + for<'a> LookupSpan<'a>,
+ N: for<'a> FormatFields<'a> + 'static,
+ T: FormatTime,
+{
+ fn format_event(
+ &self,
+ ctx: &FmtContext<'_, C, N>,
+ mut writer: Writer<'_>,
+ event: &Event<'_>,
+ ) -> fmt::Result {
+ #[cfg(feature = "tracing-log")]
+ let normalized_meta = event.normalized_metadata();
+ #[cfg(feature = "tracing-log")]
+ let meta = normalized_meta.as_ref().unwrap_or_else(|| event.metadata());
+ #[cfg(not(feature = "tracing-log"))]
+ let meta = event.metadata();
+ write!(&mut writer, " ")?;
+
+ // if the `Format` struct *also* has an ANSI color configuration,
+ // override the writer...the API for configuring ANSI color codes on the
+ // `Format` struct is deprecated, but we still need to honor those
+ // configurations.
+ if let Some(ansi) = self.ansi {
+ writer = writer.with_ansi(ansi);
+ }
+
+ self.format_timestamp(&mut writer)?;
+
+ let style = if self.display_level && writer.has_ansi_escapes() {
+ Pretty::style_for(meta.level())
+ } else {
+ Style::new()
+ };
+
+ if self.display_level {
+ write!(
+ writer,
+ "{} ",
+ super::FmtLevel::new(meta.level(), writer.has_ansi_escapes())
+ )?;
+ }
+
+ if self.display_target {
+ let target_style = if writer.has_ansi_escapes() {
+ style.bold()
+ } else {
+ style
+ };
+ write!(
+ writer,
+ "{}{}{}: ",
+ target_style.prefix(),
+ meta.target(),
+ target_style.infix(style)
+ )?;
+ }
+ let mut v = PrettyVisitor::new(writer.by_ref(), true).with_style(style);
+ event.record(&mut v);
+ v.finish()?;
+ writer.write_char('\n')?;
+
+ let dimmed = if writer.has_ansi_escapes() {
+ Style::new().dimmed().italic()
+ } else {
+ Style::new()
+ };
+ let thread = self.display_thread_name || self.display_thread_id;
+ if let (true, Some(file), Some(line)) =
+ (self.format.display_location, meta.file(), meta.line())
+ {
+ write!(
+ writer,
+ " {} {}:{}{}",
+ dimmed.paint("at"),
+ file,
+ line,
+ dimmed.paint(if thread { " " } else { "\n" })
+ )?;
+ } else if thread {
+ write!(writer, " ")?;
+ }
+
+ if thread {
+ write!(writer, "{} ", dimmed.paint("on"))?;
+ let thread = std::thread::current();
+ if self.display_thread_name {
+ if let Some(name) = thread.name() {
+ write!(writer, "{}", name)?;
+ if self.display_thread_id {
+ write!(writer, " ({:?})", thread.id())?;
+ }
+ } else if !self.display_thread_id {
+ write!(writer, " {:?}", thread.id())?;
+ }
+ } else if self.display_thread_id {
+ write!(writer, " {:?}", thread.id())?;
+ }
+ writer.write_char('\n')?;
+ }
+
+ let bold = writer.bold();
+ let span = event
+ .parent()
+ .and_then(|id| ctx.span(id))
+ .or_else(|| ctx.lookup_current());
+
+ let scope = span.into_iter().flat_map(|span| span.scope());
+
+ for span in scope {
+ let meta = span.metadata();
+ if self.display_target {
+ write!(
+ writer,
+ " {} {}::{}",
+ dimmed.paint("in"),
+ meta.target(),
+ bold.paint(meta.name()),
+ )?;
+ } else {
+ write!(
+ writer,
+ " {} {}",
+ dimmed.paint("in"),
+ bold.paint(meta.name()),
+ )?;
+ }
+
+ let ext = span.extensions();
+ let fields = &ext
+ .get::<FormattedFields<N>>()
+ .expect("Unable to find FormattedFields in extensions; this is a bug");
+ if !fields.is_empty() {
+ write!(writer, " {} {}", dimmed.paint("with"), fields)?;
+ }
+ writer.write_char('\n')?;
+ }
+
+ writer.write_char('\n')
+ }
+}
+
+impl<'writer> FormatFields<'writer> for Pretty {
+ fn format_fields<R: RecordFields>(&self, writer: Writer<'writer>, fields: R) -> fmt::Result {
+ let mut v = PrettyVisitor::new(writer, false);
+ fields.record(&mut v);
+ v.finish()
+ }
+
+ fn add_fields(
+ &self,
+ current: &'writer mut FormattedFields<Self>,
+ fields: &span::Record<'_>,
+ ) -> fmt::Result {
+ let empty = current.is_empty();
+ let writer = current.as_writer();
+ let mut v = PrettyVisitor::new(writer, empty);
+ fields.record(&mut v);
+ v.finish()
+ }
+}
+
+// === impl PrettyFields ===
+
+impl Default for PrettyFields {
+ fn default() -> Self {
+ Self::new()
+ }
+}
+
+impl PrettyFields {
+ /// Returns a new default [`PrettyFields`] implementation.
+ pub fn new() -> Self {
+ // By default, don't override the `Writer`'s ANSI colors
+ // configuration. We'll only do this if the user calls the
+ // deprecated `PrettyFields::with_ansi` method.
+ Self { ansi: None }
+ }
+
+ /// Enable ANSI encoding for formatted fields.
+ #[deprecated(
+ since = "0.3.3",
+ note = "Use `fmt::Subscriber::with_ansi` or `fmt::Layer::with_ansi` instead."
+ )]
+ pub fn with_ansi(self, ansi: bool) -> Self {
+ Self {
+ ansi: Some(ansi),
+ ..self
+ }
+ }
+}
+
+impl<'a> MakeVisitor<Writer<'a>> for PrettyFields {
+ type Visitor = PrettyVisitor<'a>;
+
+ #[inline]
+ fn make_visitor(&self, mut target: Writer<'a>) -> Self::Visitor {
+ if let Some(ansi) = self.ansi {
+ target = target.with_ansi(ansi);
+ }
+ PrettyVisitor::new(target, true)
+ }
+}
+
+// === impl PrettyVisitor ===
+
+impl<'a> PrettyVisitor<'a> {
+ /// Returns a new default visitor that formats to the provided `writer`.
+ ///
+ /// # Arguments
+ /// - `writer`: the writer to format to.
+ /// - `is_empty`: whether or not any fields have been previously written to
+ /// that writer.
+ pub fn new(writer: Writer<'a>, is_empty: bool) -> Self {
+ Self {
+ writer,
+ is_empty,
+ style: Style::default(),
+ result: Ok(()),
+ }
+ }
+
+ pub(crate) fn with_style(self, style: Style) -> Self {
+ Self { style, ..self }
+ }
+
+ fn write_padded(&mut self, value: &impl fmt::Debug) {
+ let padding = if self.is_empty {
+ self.is_empty = false;
+ ""
+ } else {
+ ", "
+ };
+ self.result = write!(self.writer, "{}{:?}", padding, value);
+ }
+
+ fn bold(&self) -> Style {
+ if self.writer.has_ansi_escapes() {
+ self.style.bold()
+ } else {
+ Style::new()
+ }
+ }
+}
+
+impl<'a> field::Visit for PrettyVisitor<'a> {
+ fn record_str(&mut self, field: &Field, value: &str) {
+ if self.result.is_err() {
+ return;
+ }
+
+ if field.name() == "message" {
+ self.record_debug(field, &format_args!("{}", value))
+ } else {
+ self.record_debug(field, &value)
+ }
+ }
+
+ fn record_error(&mut self, field: &Field, value: &(dyn std::error::Error + 'static)) {
+ if let Some(source) = value.source() {
+ let bold = self.bold();
+ self.record_debug(
+ field,
+ &format_args!(
+ "{}, {}{}.sources{}: {}",
+ value,
+ bold.prefix(),
+ field,
+ bold.infix(self.style),
+ ErrorSourceList(source),
+ ),
+ )
+ } else {
+ self.record_debug(field, &format_args!("{}", value))
+ }
+ }
+
+ fn record_debug(&mut self, field: &Field, value: &dyn fmt::Debug) {
+ if self.result.is_err() {
+ return;
+ }
+ let bold = self.bold();
+ match field.name() {
+ "message" => self.write_padded(&format_args!("{}{:?}", self.style.prefix(), 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(()),
+ name if name.starts_with("r#") => self.write_padded(&format_args!(
+ "{}{}{}: {:?}",
+ bold.prefix(),
+ &name[2..],
+ bold.infix(self.style),
+ value
+ )),
+ name => self.write_padded(&format_args!(
+ "{}{}{}: {:?}",
+ bold.prefix(),
+ name,
+ bold.infix(self.style),
+ value
+ )),
+ };
+ }
+}
+
+impl<'a> VisitOutput<fmt::Result> for PrettyVisitor<'a> {
+ fn finish(mut self) -> fmt::Result {
+ write!(&mut self.writer, "{}", self.style.suffix())?;
+ self.result
+ }
+}
+
+impl<'a> VisitFmt for PrettyVisitor<'a> {
+ fn writer(&mut self) -> &mut dyn fmt::Write {
+ &mut self.writer
+ }
+}
diff --git a/vendor/tracing-subscriber-0.3.3/src/fmt/mod.rs b/vendor/tracing-subscriber-0.3.3/src/fmt/mod.rs
new file mode 100644
index 000000000..d5deb8f0c
--- /dev/null
+++ b/vendor/tracing-subscriber-0.3.3/src/fmt/mod.rs
@@ -0,0 +1,1275 @@
+//! A `Subscriber` for formatting and logging `tracing` data.
+//!
+//! # Overview
+//!
+//! [`tracing`] is a framework for instrumenting Rust programs with context-aware,
+//! structured, event-based diagnostic information. This crate provides an
+//! implementation of the [`Subscriber`] trait that records `tracing`'s `Event`s
+//! and `Span`s by formatting them as text and logging them to stdout.
+//!
+//! # Usage
+//!
+//! First, add this to your `Cargo.toml` file:
+//!
+//! ```toml
+//! [dependencies]
+//! tracing-subscriber = "0.2"
+//! ```
+//!
+//! *Compiler support: requires rustc 1.39+*
+//!
+//! Add the following to your executable to initialize the default subscriber:
+//! ```rust
+//! use tracing_subscriber;
+//!
+//! tracing_subscriber::fmt::init();
+//! ```
+//!
+//! ## Filtering Events with Environment Variables
+//!
+//! The default subscriber installed by `init` enables you to filter events
+//! at runtime using environment variables (using the [`EnvFilter`]).
+//!
+//! The filter syntax is a superset of the [`env_logger`] syntax.
+//!
+//! For example:
+//! - Setting `RUST_LOG=debug` enables all `Span`s and `Event`s
+//! set to the log level `DEBUG` or higher
+//! - Setting `RUST_LOG=my_crate=trace` enables `Span`s and `Event`s
+//! in `my_crate` at all log levels
+//!
+//! **Note**: This should **not** be called by libraries. Libraries should use
+//! [`tracing`] to publish `tracing` `Event`s.
+//!
+//! # Configuration
+//!
+//! You can configure a subscriber instead of using the defaults with
+//! the following functions:
+//!
+//! ### Subscriber
+//!
+//! The [`FmtSubscriber`] formats and records `tracing` events as line-oriented logs.
+//! You can create one by calling:
+//!
+//! ```rust
+//! let subscriber = tracing_subscriber::fmt()
+//! // ... add configuration
+//! .finish();
+//! ```
+//!
+//! You can find the configuration methods for [`FmtSubscriber`] in
+//! [`SubscriberBuilder`].
+//!
+//! ## Formatters
+//!
+//! The output format used by the layer and subscriber in this module is
+//! represented by implementing the [`FormatEvent`] trait, and can be
+//! customized. This module provides a number of formatter implementations:
+//!
+//! * [`format::Full`]: The default formatter. This emits human-readable,
+//! single-line logs for each event that occurs, with the current span context
+//! displayed before the formatted representation of the event.
+//!
+//! For example:
+//! <pre><font color="#4E9A06"><b> Finished</b></font> dev [unoptimized + debuginfo] target(s) in 1.59s
+//! <font color="#4E9A06"><b> Running</b></font> `target/debug/examples/fmt`
+//! <font color="#AAAAAA">Oct 24 12:55:47.814 </font><font color="#4E9A06"> INFO</font> fmt: preparing to shave yaks number_of_yaks=3
+//! <font color="#AAAAAA">Oct 24 12:55:47.814 </font><font color="#4E9A06"> INFO</font> <b>shaving_yaks{</b>yaks=3<b>}</b>: fmt::yak_shave: shaving yaks
+//! <font color="#AAAAAA">Oct 24 12:55:47.814 </font><font color="#75507B">TRACE</font> <b>shaving_yaks{</b>yaks=3<b>}</b>:<b>shave{</b>yak=1<b>}</b>: fmt::yak_shave: hello! I&apos;m gonna shave a yak excitement=&quot;yay!&quot;
+//! <font color="#AAAAAA">Oct 24 12:55:47.814 </font><font color="#75507B">TRACE</font> <b>shaving_yaks{</b>yaks=3<b>}</b>:<b>shave{</b>yak=1<b>}</b>: fmt::yak_shave: yak shaved successfully
+//! <font color="#AAAAAA">Oct 24 12:55:47.814 </font><font color="#3465A4">DEBUG</font> <b>shaving_yaks{</b>yaks=3<b>}</b>: yak_events: yak=1 shaved=true
+//! <font color="#AAAAAA">Oct 24 12:55:47.814 </font><font color="#75507B">TRACE</font> <b>shaving_yaks{</b>yaks=3<b>}</b>: fmt::yak_shave: yaks_shaved=1
+//! <font color="#AAAAAA">Oct 24 12:55:47.815 </font><font color="#75507B">TRACE</font> <b>shaving_yaks{</b>yaks=3<b>}</b>:<b>shave{</b>yak=2<b>}</b>: fmt::yak_shave: hello! I&apos;m gonna shave a yak excitement=&quot;yay!&quot;
+//! <font color="#AAAAAA">Oct 24 12:55:47.815 </font><font color="#75507B">TRACE</font> <b>shaving_yaks{</b>yaks=3<b>}</b>:<b>shave{</b>yak=2<b>}</b>: fmt::yak_shave: yak shaved successfully
+//! <font color="#AAAAAA">Oct 24 12:55:47.815 </font><font color="#3465A4">DEBUG</font> <b>shaving_yaks{</b>yaks=3<b>}</b>: yak_events: yak=2 shaved=true
+//! <font color="#AAAAAA">Oct 24 12:55:47.815 </font><font color="#75507B">TRACE</font> <b>shaving_yaks{</b>yaks=3<b>}</b>: fmt::yak_shave: yaks_shaved=2
+//! <font color="#AAAAAA">Oct 24 12:55:47.815 </font><font color="#75507B">TRACE</font> <b>shaving_yaks{</b>yaks=3<b>}</b>:<b>shave{</b>yak=3<b>}</b>: fmt::yak_shave: hello! I&apos;m gonna shave a yak excitement=&quot;yay!&quot;
+//! <font color="#AAAAAA">Oct 24 12:55:47.815 </font><font color="#C4A000"> WARN</font> <b>shaving_yaks{</b>yaks=3<b>}</b>:<b>shave{</b>yak=3<b>}</b>: fmt::yak_shave: could not locate yak
+//! <font color="#AAAAAA">Oct 24 12:55:47.815 </font><font color="#3465A4">DEBUG</font> <b>shaving_yaks{</b>yaks=3<b>}</b>: yak_events: yak=3 shaved=false
+//! <font color="#AAAAAA">Oct 24 12:55:47.815 </font><font color="#CC0000">ERROR</font> <b>shaving_yaks{</b>yaks=3<b>}</b>: fmt::yak_shave: failed to shave yak yak=3 error=missing yak
+//! <font color="#AAAAAA">Oct 24 12:55:47.815 </font><font color="#75507B">TRACE</font> <b>shaving_yaks{</b>yaks=3<b>}</b>: fmt::yak_shave: yaks_shaved=2
+//! <font color="#AAAAAA">Oct 24 12:55:47.815 </font><font color="#4E9A06"> INFO</font> fmt: yak shaving completed all_yaks_shaved=false
+//! </pre>
+//!
+//! * [`format::Pretty`]: Emits excessively pretty, multi-line logs, optimized
+//! for human readability. This is primarily intended to be used in local
+//! development and debugging, or for command-line applications, where
+//! automated analysis and compact storage of logs is less of a priority than
+//! readability and visual appeal.
+//!
+//! For example:
+//! <pre><font color="#4E9A06"><b> Finished</b></font> dev [unoptimized + debuginfo] target(s) in 1.61s
+//! <font color="#4E9A06"><b> Running</b></font> `target/debug/examples/fmt-pretty`
+//! Oct 24 12:57:29.386 <font color="#4E9A06"><b>fmt_pretty</b></font><font color="#4E9A06">: preparing to shave yaks, </font><font color="#4E9A06"><b>number_of_yaks</b></font><font color="#4E9A06">: 3</font>
+//! <font color="#AAAAAA"><i>at</i></font> examples/examples/fmt-pretty.rs:16<font color="#AAAAAA"><i> on</i></font> main
+//!
+//! Oct 24 12:57:29.386 <font color="#4E9A06"><b>fmt_pretty::yak_shave</b></font><font color="#4E9A06">: shaving yaks</font>
+//! <font color="#AAAAAA"><i>at</i></font> examples/examples/fmt/yak_shave.rs:38<font color="#AAAAAA"><i> on</i></font> main
+//! <font color="#AAAAAA"><i>in</i></font> fmt_pretty::yak_shave::<b>shaving_yaks</b> <font color="#AAAAAA"><i>with</i></font> <b>yaks</b>: 3
+//!
+//! Oct 24 12:57:29.387 <font color="#75507B"><b>fmt_pretty::yak_shave</b></font><font color="#75507B">: hello! I&apos;m gonna shave a yak, </font><font color="#75507B"><b>excitement</b></font><font color="#75507B">: &quot;yay!&quot;</font>
+//! <font color="#AAAAAA"><i>at</i></font> examples/examples/fmt/yak_shave.rs:14<font color="#AAAAAA"><i> on</i></font> main
+//! <font color="#AAAAAA"><i>in</i></font> fmt_pretty::yak_shave::<b>shave</b> <font color="#AAAAAA"><i>with</i></font> <b>yak</b>: 1
+//! <font color="#AAAAAA"><i>in</i></font> fmt_pretty::yak_shave::<b>shaving_yaks</b> <font color="#AAAAAA"><i>with</i></font> <b>yaks</b>: 3
+//!
+//! Oct 24 12:57:29.387 <font color="#75507B"><b>fmt_pretty::yak_shave</b></font><font color="#75507B">: yak shaved successfully</font>
+//! <font color="#AAAAAA"><i>at</i></font> examples/examples/fmt/yak_shave.rs:22<font color="#AAAAAA"><i> on</i></font> main
+//! <font color="#AAAAAA"><i>in</i></font> fmt_pretty::yak_shave::<b>shave</b> <font color="#AAAAAA"><i>with</i></font> <b>yak</b>: 1
+//! <font color="#AAAAAA"><i>in</i></font> fmt_pretty::yak_shave::<b>shaving_yaks</b> <font color="#AAAAAA"><i>with</i></font> <b>yaks</b>: 3
+//!
+//! Oct 24 12:57:29.387 <font color="#3465A4"><b>yak_events</b></font><font color="#3465A4">: </font><font color="#3465A4"><b>yak</b></font><font color="#3465A4">: 1, </font><font color="#3465A4"><b>shaved</b></font><font color="#3465A4">: true</font>
+//! <font color="#AAAAAA"><i>at</i></font> examples/examples/fmt/yak_shave.rs:43<font color="#AAAAAA"><i> on</i></font> main
+//! <font color="#AAAAAA"><i>in</i></font> fmt_pretty::yak_shave::<b>shaving_yaks</b> <font color="#AAAAAA"><i>with</i></font> <b>yaks</b>: 3
+//!
+//! Oct 24 12:57:29.387 <font color="#75507B"><b>fmt_pretty::yak_shave</b></font><font color="#75507B">: </font><font color="#75507B"><b>yaks_shaved</b></font><font color="#75507B">: 1</font>
+//! <font color="#AAAAAA"><i>at</i></font> examples/examples/fmt/yak_shave.rs:52<font color="#AAAAAA"><i> on</i></font> main
+//! <font color="#AAAAAA"><i>in</i></font> fmt_pretty::yak_shave::<b>shaving_yaks</b> <font color="#AAAAAA"><i>with</i></font> <b>yaks</b>: 3
+//!
+//! Oct 24 12:57:29.387 <font color="#75507B"><b>fmt_pretty::yak_shave</b></font><font color="#75507B">: hello! I&apos;m gonna shave a yak, </font><font color="#75507B"><b>excitement</b></font><font color="#75507B">: &quot;yay!&quot;</font>
+//! <font color="#AAAAAA"><i>at</i></font> examples/examples/fmt/yak_shave.rs:14<font color="#AAAAAA"><i> on</i></font> main
+//! <font color="#AAAAAA"><i>in</i></font> fmt_pretty::yak_shave::<b>shave</b> <font color="#AAAAAA"><i>with</i></font> <b>yak</b>: 2
+//! <font color="#AAAAAA"><i>in</i></font> fmt_pretty::yak_shave::<b>shaving_yaks</b> <font color="#AAAAAA"><i>with</i></font> <b>yaks</b>: 3
+//!
+//! Oct 24 12:57:29.387 <font color="#75507B"><b>fmt_pretty::yak_shave</b></font><font color="#75507B">: yak shaved successfully</font>
+//! <font color="#AAAAAA"><i>at</i></font> examples/examples/fmt/yak_shave.rs:22<font color="#AAAAAA"><i> on</i></font> main
+//! <font color="#AAAAAA"><i>in</i></font> fmt_pretty::yak_shave::<b>shave</b> <font color="#AAAAAA"><i>with</i></font> <b>yak</b>: 2
+//! <font color="#AAAAAA"><i>in</i></font> fmt_pretty::yak_shave::<b>shaving_yaks</b> <font color="#AAAAAA"><i>with</i></font> <b>yaks</b>: 3
+//!
+//! Oct 24 12:57:29.387 <font color="#3465A4"><b>yak_events</b></font><font color="#3465A4">: </font><font color="#3465A4"><b>yak</b></font><font color="#3465A4">: 2, </font><font color="#3465A4"><b>shaved</b></font><font color="#3465A4">: true</font>
+//! <font color="#AAAAAA"><i>at</i></font> examples/examples/fmt/yak_shave.rs:43<font color="#AAAAAA"><i> on</i></font> main
+//! <font color="#AAAAAA"><i>in</i></font> fmt_pretty::yak_shave::<b>shaving_yaks</b> <font color="#AAAAAA"><i>with</i></font> <b>yaks</b>: 3
+//!
+//! Oct 24 12:57:29.387 <font color="#75507B"><b>fmt_pretty::yak_shave</b></font><font color="#75507B">: </font><font color="#75507B"><b>yaks_shaved</b></font><font color="#75507B">: 2</font>
+//! <font color="#AAAAAA"><i>at</i></font> examples/examples/fmt/yak_shave.rs:52<font color="#AAAAAA"><i> on</i></font> main
+//! <font color="#AAAAAA"><i>in</i></font> fmt_pretty::yak_shave::<b>shaving_yaks</b> <font color="#AAAAAA"><i>with</i></font> <b>yaks</b>: 3
+//!
+//! Oct 24 12:57:29.387 <font color="#75507B"><b>fmt_pretty::yak_shave</b></font><font color="#75507B">: hello! I&apos;m gonna shave a yak, </font><font color="#75507B"><b>excitement</b></font><font color="#75507B">: &quot;yay!&quot;</font>
+//! <font color="#AAAAAA"><i>at</i></font> examples/examples/fmt/yak_shave.rs:14<font color="#AAAAAA"><i> on</i></font> main
+//! <font color="#AAAAAA"><i>in</i></font> fmt_pretty::yak_shave::<b>shave</b> <font color="#AAAAAA"><i>with</i></font> <b>yak</b>: 3
+//! <font color="#AAAAAA"><i>in</i></font> fmt_pretty::yak_shave::<b>shaving_yaks</b> <font color="#AAAAAA"><i>with</i></font> <b>yaks</b>: 3
+//!
+//! Oct 24 12:57:29.387 <font color="#C4A000"><b>fmt_pretty::yak_shave</b></font><font color="#C4A000">: could not locate yak</font>
+//! <font color="#AAAAAA"><i>at</i></font> examples/examples/fmt/yak_shave.rs:16<font color="#AAAAAA"><i> on</i></font> main
+//! <font color="#AAAAAA"><i>in</i></font> fmt_pretty::yak_shave::<b>shave</b> <font color="#AAAAAA"><i>with</i></font> <b>yak</b>: 3
+//! <font color="#AAAAAA"><i>in</i></font> fmt_pretty::yak_shave::<b>shaving_yaks</b> <font color="#AAAAAA"><i>with</i></font> <b>yaks</b>: 3
+//!
+//! Oct 24 12:57:29.387 <font color="#3465A4"><b>yak_events</b></font><font color="#3465A4">: </font><font color="#3465A4"><b>yak</b></font><font color="#3465A4">: 3, </font><font color="#3465A4"><b>shaved</b></font><font color="#3465A4">: false</font>
+//! <font color="#AAAAAA"><i>at</i></font> examples/examples/fmt/yak_shave.rs:43<font color="#AAAAAA"><i> on</i></font> main
+//! <font color="#AAAAAA"><i>in</i></font> fmt_pretty::yak_shave::<b>shaving_yaks</b> <font color="#AAAAAA"><i>with</i></font> <b>yaks</b>: 3
+//!
+//! Oct 24 12:57:29.387 <font color="#CC0000"><b>fmt_pretty::yak_shave</b></font><font color="#CC0000">: failed to shave yak, </font><font color="#CC0000"><b>yak</b></font><font color="#CC0000">: 3, </font><font color="#CC0000"><b>error</b></font><font color="#CC0000">: missing yak</font>
+//! <font color="#AAAAAA"><i>at</i></font> examples/examples/fmt/yak_shave.rs:48<font color="#AAAAAA"><i> on</i></font> main
+//! <font color="#AAAAAA"><i>in</i></font> fmt_pretty::yak_shave::<b>shaving_yaks</b> <font color="#AAAAAA"><i>with</i></font> <b>yaks</b>: 3
+//!
+//! Oct 24 12:57:29.387 <font color="#75507B"><b>fmt_pretty::yak_shave</b></font><font color="#75507B">: </font><font color="#75507B"><b>yaks_shaved</b></font><font color="#75507B">: 2</font>
+//! <font color="#AAAAAA"><i>at</i></font> examples/examples/fmt/yak_shave.rs:52<font color="#AAAAAA"><i> on</i></font> main
+//! <font color="#AAAAAA"><i>in</i></font> fmt_pretty::yak_shave::<b>shaving_yaks</b> <font color="#AAAAAA"><i>with</i></font> <b>yaks</b>: 3
+//!
+//! Oct 24 12:57:29.387 <font color="#4E9A06"><b>fmt_pretty</b></font><font color="#4E9A06">: yak shaving completed, </font><font color="#4E9A06"><b>all_yaks_shaved</b></font><font color="#4E9A06">: false</font>
+//! <font color="#AAAAAA"><i>at</i></font> examples/examples/fmt-pretty.rs:19<font color="#AAAAAA"><i> on</i></font> main
+//! </pre>
+//!
+//! * [`format::Json`]: Outputs newline-delimited JSON logs. This is intended
+//! for production use with systems where structured logs are consumed as JSON
+//! by analysis and viewing tools. The JSON output, as seen below, is *not*
+//! optimized for human readability.
+//!
+//! For example:
+//! <pre><font color="#4E9A06"><b> Finished</b></font> dev [unoptimized + debuginfo] target(s) in 1.58s
+//! <font color="#4E9A06"><b> Running</b></font> `target/debug/examples/fmt-json`
+//! {&quot;timestamp&quot;:&quot;Oct 24 13:00:00.873&quot;,&quot;level&quot;:&quot;INFO&quot;,&quot;fields&quot;:{&quot;message&quot;:&quot;preparing to shave yaks&quot;,&quot;number_of_yaks&quot;:3},&quot;target&quot;:&quot;fmt_json&quot;}
+//! {&quot;timestamp&quot;:&quot;Oct 24 13:00:00.874&quot;,&quot;level&quot;:&quot;INFO&quot;,&quot;fields&quot;:{&quot;message&quot;:&quot;shaving yaks&quot;},&quot;target&quot;:&quot;fmt_json::yak_shave&quot;,&quot;spans&quot;:[{&quot;yaks&quot;:3,&quot;name&quot;:&quot;shaving_yaks&quot;}]}
+//! {&quot;timestamp&quot;:&quot;Oct 24 13:00:00.874&quot;,&quot;level&quot;:&quot;TRACE&quot;,&quot;fields&quot;:{&quot;message&quot;:&quot;hello! I&apos;m gonna shave a yak&quot;,&quot;excitement&quot;:&quot;yay!&quot;},&quot;target&quot;:&quot;fmt_json::yak_shave&quot;,&quot;spans&quot;:[{&quot;yaks&quot;:3,&quot;name&quot;:&quot;shaving_yaks&quot;},{&quot;yak&quot;:&quot;1&quot;,&quot;name&quot;:&quot;shave&quot;}]}
+//! {&quot;timestamp&quot;:&quot;Oct 24 13:00:00.874&quot;,&quot;level&quot;:&quot;TRACE&quot;,&quot;fields&quot;:{&quot;message&quot;:&quot;yak shaved successfully&quot;},&quot;target&quot;:&quot;fmt_json::yak_shave&quot;,&quot;spans&quot;:[{&quot;yaks&quot;:3,&quot;name&quot;:&quot;shaving_yaks&quot;},{&quot;yak&quot;:&quot;1&quot;,&quot;name&quot;:&quot;shave&quot;}]}
+//! {&quot;timestamp&quot;:&quot;Oct 24 13:00:00.874&quot;,&quot;level&quot;:&quot;DEBUG&quot;,&quot;fields&quot;:{&quot;yak&quot;:1,&quot;shaved&quot;:true},&quot;target&quot;:&quot;yak_events&quot;,&quot;spans&quot;:[{&quot;yaks&quot;:3,&quot;name&quot;:&quot;shaving_yaks&quot;}]}
+//! {&quot;timestamp&quot;:&quot;Oct 24 13:00:00.874&quot;,&quot;level&quot;:&quot;TRACE&quot;,&quot;fields&quot;:{&quot;yaks_shaved&quot;:1},&quot;target&quot;:&quot;fmt_json::yak_shave&quot;,&quot;spans&quot;:[{&quot;yaks&quot;:3,&quot;name&quot;:&quot;shaving_yaks&quot;}]}
+//! {&quot;timestamp&quot;:&quot;Oct 24 13:00:00.874&quot;,&quot;level&quot;:&quot;TRACE&quot;,&quot;fields&quot;:{&quot;message&quot;:&quot;hello! I&apos;m gonna shave a yak&quot;,&quot;excitement&quot;:&quot;yay!&quot;},&quot;target&quot;:&quot;fmt_json::yak_shave&quot;,&quot;spans&quot;:[{&quot;yaks&quot;:3,&quot;name&quot;:&quot;shaving_yaks&quot;},{&quot;yak&quot;:&quot;2&quot;,&quot;name&quot;:&quot;shave&quot;}]}
+//! {&quot;timestamp&quot;:&quot;Oct 24 13:00:00.874&quot;,&quot;level&quot;:&quot;TRACE&quot;,&quot;fields&quot;:{&quot;message&quot;:&quot;yak shaved successfully&quot;},&quot;target&quot;:&quot;fmt_json::yak_shave&quot;,&quot;spans&quot;:[{&quot;yaks&quot;:3,&quot;name&quot;:&quot;shaving_yaks&quot;},{&quot;yak&quot;:&quot;2&quot;,&quot;name&quot;:&quot;shave&quot;}]}
+//! {&quot;timestamp&quot;:&quot;Oct 24 13:00:00.874&quot;,&quot;level&quot;:&quot;DEBUG&quot;,&quot;fields&quot;:{&quot;yak&quot;:2,&quot;shaved&quot;:true},&quot;target&quot;:&quot;yak_events&quot;,&quot;spans&quot;:[{&quot;yaks&quot;:3,&quot;name&quot;:&quot;shaving_yaks&quot;}]}
+//! {&quot;timestamp&quot;:&quot;Oct 24 13:00:00.874&quot;,&quot;level&quot;:&quot;TRACE&quot;,&quot;fields&quot;:{&quot;yaks_shaved&quot;:2},&quot;target&quot;:&quot;fmt_json::yak_shave&quot;,&quot;spans&quot;:[{&quot;yaks&quot;:3,&quot;name&quot;:&quot;shaving_yaks&quot;}]}
+//! {&quot;timestamp&quot;:&quot;Oct 24 13:00:00.874&quot;,&quot;level&quot;:&quot;TRACE&quot;,&quot;fields&quot;:{&quot;message&quot;:&quot;hello! I&apos;m gonna shave a yak&quot;,&quot;excitement&quot;:&quot;yay!&quot;},&quot;target&quot;:&quot;fmt_json::yak_shave&quot;,&quot;spans&quot;:[{&quot;yaks&quot;:3,&quot;name&quot;:&quot;shaving_yaks&quot;},{&quot;yak&quot;:&quot;3&quot;,&quot;name&quot;:&quot;shave&quot;}]}
+//! {&quot;timestamp&quot;:&quot;Oct 24 13:00:00.875&quot;,&quot;level&quot;:&quot;WARN&quot;,&quot;fields&quot;:{&quot;message&quot;:&quot;could not locate yak&quot;},&quot;target&quot;:&quot;fmt_json::yak_shave&quot;,&quot;spans&quot;:[{&quot;yaks&quot;:3,&quot;name&quot;:&quot;shaving_yaks&quot;},{&quot;yak&quot;:&quot;3&quot;,&quot;name&quot;:&quot;shave&quot;}]}
+//! {&quot;timestamp&quot;:&quot;Oct 24 13:00:00.875&quot;,&quot;level&quot;:&quot;DEBUG&quot;,&quot;fields&quot;:{&quot;yak&quot;:3,&quot;shaved&quot;:false},&quot;target&quot;:&quot;yak_events&quot;,&quot;spans&quot;:[{&quot;yaks&quot;:3,&quot;name&quot;:&quot;shaving_yaks&quot;}]}
+//! {&quot;timestamp&quot;:&quot;Oct 24 13:00:00.875&quot;,&quot;level&quot;:&quot;ERROR&quot;,&quot;fields&quot;:{&quot;message&quot;:&quot;failed to shave yak&quot;,&quot;yak&quot;:3,&quot;error&quot;:&quot;missing yak&quot;},&quot;target&quot;:&quot;fmt_json::yak_shave&quot;,&quot;spans&quot;:[{&quot;yaks&quot;:3,&quot;name&quot;:&quot;shaving_yaks&quot;}]}
+//! {&quot;timestamp&quot;:&quot;Oct 24 13:00:00.875&quot;,&quot;level&quot;:&quot;TRACE&quot;,&quot;fields&quot;:{&quot;yaks_shaved&quot;:2},&quot;target&quot;:&quot;fmt_json::yak_shave&quot;,&quot;spans&quot;:[{&quot;yaks&quot;:3,&quot;name&quot;:&quot;shaving_yaks&quot;}]}
+//! {&quot;timestamp&quot;:&quot;Oct 24 13:00:00.875&quot;,&quot;level&quot;:&quot;INFO&quot;,&quot;fields&quot;:{&quot;message&quot;:&quot;yak shaving completed&quot;,&quot;all_yaks_shaved&quot;:false},&quot;target&quot;:&quot;fmt_json&quot;}
+//! </pre>
+//!
+//! ### Customizing Formatters
+//!
+//! The formatting of log lines for spans and events is controlled by two
+//! traits, [`FormatEvent`] and [`FormatFields`]. The [`FormatEvent`] trait
+//! determines the overall formatting of the log line, such as what information
+//! from the event's metadata and span context is included and in what order.
+//! The [`FormatFields`] trait determines how fields &mdash; both the event's
+//! fields and fields on spans &mdash; are formatted.
+//!
+//! The [`fmt::format`] module provides several types which implement these traits,
+//! many of which expose additional configuration options to customize their
+//! output. The [`format::Format`] type implements common configuration used by
+//! all the formatters provided in this crate, and can be used as a builder to
+//! set specific formatting settings. For example:
+//!
+//! ```
+//! use tracing_subscriber::fmt;
+//!
+//! // Configure a custom event formatter
+//! let format = fmt::format()
+//! .with_level(false) // don't include levels in formatted output
+//! .with_target(false) // don't include targets
+//! .with_thread_ids(true) // include the thread ID of the current thread
+//! .with_thread_names(true) // include the name of the current thread
+//! .compact(); // use the `Compact` formatting style.
+//!
+//! // Create a `fmt` collector that uses our custom event format, and set it
+//! // as the default.
+//! tracing_subscriber::fmt()
+//! .event_format(format)
+//! .init();
+//! ```
+//!
+//! However, if a specific output format is needed, other crates can
+//! also implement [`FormatEvent`] and [`FormatFields`]. See those traits'
+//! documentation for details on how to implement them.
+//!
+//! ## Filters
+//!
+//! If you want to filter the `tracing` `Events` based on environment
+//! variables, you can use the [`EnvFilter`] as follows:
+//!
+//! ```rust
+//! use tracing_subscriber::EnvFilter;
+//!
+//! let filter = EnvFilter::from_default_env();
+//! ```
+//!
+//! As mentioned above, the [`EnvFilter`] allows `Span`s and `Event`s to
+//! be filtered at runtime by setting the `RUST_LOG` environment variable.
+//!
+//! You can find the other available [`filter`]s in the documentation.
+//!
+//! ### Using Your Subscriber
+//!
+//! Finally, once you have configured your `Subscriber`, you need to
+//! configure your executable to use it.
+//!
+//! A subscriber can be installed globally using:
+//! ```rust
+//! use tracing;
+//! use tracing_subscriber::FmtSubscriber;
+//!
+//! let subscriber = FmtSubscriber::new();
+//!
+//! tracing::subscriber::set_global_default(subscriber)
+//! .map_err(|_err| eprintln!("Unable to set global default subscriber"));
+//! // Note this will only fail if you try to set the global default
+//! // subscriber multiple times
+//! ```
+//!
+//! ### Composing Layers
+//!
+//! Composing an [`EnvFilter`] `Layer` and a [format `Layer`](../fmt/struct.Layer.html):
+//!
+//! ```rust
+//! use tracing_subscriber::{fmt, EnvFilter};
+//! use tracing_subscriber::prelude::*;
+//!
+//! let fmt_layer = fmt::layer()
+//! .with_target(false);
+//! let filter_layer = EnvFilter::try_from_default_env()
+//! .or_else(|_| EnvFilter::try_new("info"))
+//! .unwrap();
+//!
+//! tracing_subscriber::registry()
+//! .with(filter_layer)
+//! .with(fmt_layer)
+//! .init();
+//! ```
+//!
+//! [`EnvFilter`]: ../filter/struct.EnvFilter.html
+//! [`env_logger`]: https://docs.rs/env_logger/
+//! [`filter`]: ../filter/index.html
+//! [`SubscriberBuilder`]: ./struct.SubscriberBuilder.html
+//! [`FmtSubscriber`]: ./struct.Subscriber.html
+//! [`Subscriber`]:
+//! https://docs.rs/tracing/latest/tracing/trait.Subscriber.html
+//! [`tracing`]: https://crates.io/crates/tracing
+//! [`fmt::format`]: mod@crate::fmt::format
+use std::{any::TypeId, error::Error, io};
+use tracing_core::{span, subscriber::Interest, Event, Metadata};
+
+mod fmt_layer;
+#[cfg_attr(docsrs, doc(cfg(all(feature = "fmt", feature = "std"))))]
+pub mod format;
+#[cfg_attr(docsrs, doc(cfg(all(feature = "fmt", feature = "std"))))]
+pub mod time;
+#[cfg_attr(docsrs, doc(cfg(all(feature = "fmt", feature = "std"))))]
+pub mod writer;
+
+pub use fmt_layer::{FmtContext, FormattedFields, Layer};
+
+use crate::layer::Layer as _;
+use crate::{
+ filter::LevelFilter,
+ layer,
+ registry::{LookupSpan, Registry},
+};
+
+#[doc(inline)]
+pub use self::{
+ format::{format, FormatEvent, FormatFields},
+ time::time,
+ writer::{MakeWriter, TestWriter},
+};
+
+/// A `Subscriber` that logs formatted representations of `tracing` events.
+///
+/// This consists of an inner `Formatter` wrapped in a layer that performs filtering.
+#[cfg_attr(docsrs, doc(cfg(all(feature = "fmt", feature = "std"))))]
+#[derive(Debug)]
+pub struct Subscriber<
+ N = format::DefaultFields,
+ E = format::Format<format::Full>,
+ F = LevelFilter,
+ W = fn() -> io::Stdout,
+> {
+ inner: layer::Layered<F, Formatter<N, E, W>>,
+}
+
+/// A `Subscriber` that logs formatted representations of `tracing` events.
+/// This type only logs formatted events; it does not perform any filtering.
+#[cfg_attr(docsrs, doc(cfg(all(feature = "fmt", feature = "std"))))]
+pub type Formatter<
+ N = format::DefaultFields,
+ E = format::Format<format::Full>,
+ W = fn() -> io::Stdout,
+> = layer::Layered<fmt_layer::Layer<Registry, N, E, W>, Registry>;
+
+/// Configures and constructs `Subscriber`s.
+#[cfg_attr(docsrs, doc(cfg(all(feature = "fmt", feature = "std"))))]
+#[derive(Debug)]
+pub struct SubscriberBuilder<
+ N = format::DefaultFields,
+ E = format::Format<format::Full>,
+ F = LevelFilter,
+ W = fn() -> io::Stdout,
+> {
+ filter: F,
+ inner: Layer<Registry, N, E, W>,
+}
+
+/// Returns a new [`SubscriberBuilder`] for configuring a [formatting subscriber].
+///
+/// This is essentially shorthand for [`SubscriberBuilder::default()]`.
+///
+/// # Examples
+///
+/// Using [`init`] to set the default subscriber:
+///
+/// ```rust
+/// tracing_subscriber::fmt().init();
+/// ```
+///
+/// Configuring the output format:
+///
+/// ```rust
+///
+/// tracing_subscriber::fmt()
+/// // Configure formatting settings.
+/// .with_target(false)
+/// .with_timer(tracing_subscriber::fmt::time::uptime())
+/// .with_level(true)
+/// // Set the subscriber as the default.
+/// .init();
+/// ```
+///
+/// [`try_init`] returns an error if the default subscriber could not be set:
+///
+/// ```rust
+/// use std::error::Error;
+///
+/// fn init_subscriber() -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
+/// tracing_subscriber::fmt()
+/// // Configure the subscriber to emit logs in JSON format.
+/// .json()
+/// // Configure the subscriber to flatten event fields in the output JSON objects.
+/// .flatten_event(true)
+/// // Set the subscriber as the default, returning an error if this fails.
+/// .try_init()?;
+///
+/// Ok(())
+/// }
+/// ```
+///
+/// Rather than setting the subscriber as the default, [`finish`] _returns_ the
+/// constructed subscriber, which may then be passed to other functions:
+///
+/// ```rust
+/// let subscriber = tracing_subscriber::fmt()
+/// .with_max_level(tracing::Level::DEBUG)
+/// .compact()
+/// .finish();
+///
+/// tracing::subscriber::with_default(subscriber, || {
+/// // the subscriber will only be set as the default
+/// // inside this closure...
+/// })
+/// ```
+///
+/// [formatting subscriber]: Subscriber
+/// [`SubscriberBuilder::default()`]: SubscriberBuilder::default()
+/// [`init`]: SubscriberBuilder::init()
+/// [`try_init`]: SubscriberBuilder::try_init()
+/// [`finish`]: SubscriberBuilder::finish()
+#[cfg_attr(docsrs, doc(cfg(all(feature = "fmt", feature = "std"))))]
+pub fn fmt() -> SubscriberBuilder {
+ SubscriberBuilder::default()
+}
+
+/// Returns a new [formatting layer] that can be [composed] with other layers to
+/// construct a [`Subscriber`].
+///
+/// This is a shorthand for the equivalent [`Layer::default`] function.
+///
+/// [formatting layer]: Layer
+/// [composed]: crate::layer
+#[cfg_attr(docsrs, doc(cfg(all(feature = "fmt", feature = "std"))))]
+pub fn layer<S>() -> Layer<S> {
+ Layer::default()
+}
+
+impl Subscriber {
+ /// The maximum [verbosity level] that is enabled by a `Subscriber` by
+ /// default.
+ ///
+ /// This can be overridden with the [`SubscriberBuilder::with_max_level`] method.
+ ///
+ /// [verbosity level]: https://docs.rs/tracing-core/0.1.5/tracing_core/struct.Level.html
+ /// [`SubscriberBuilder::with_max_level`]: struct.SubscriberBuilder.html#method.with_max_level
+ pub const DEFAULT_MAX_LEVEL: LevelFilter = LevelFilter::INFO;
+
+ /// Returns a new `SubscriberBuilder` for configuring a format subscriber.
+ pub fn builder() -> SubscriberBuilder {
+ SubscriberBuilder::default()
+ }
+
+ /// Returns a new format subscriber with the default configuration.
+ pub fn new() -> Self {
+ Default::default()
+ }
+}
+
+impl Default for Subscriber {
+ fn default() -> Self {
+ SubscriberBuilder::default().finish()
+ }
+}
+
+// === impl Subscriber ===
+
+impl<N, E, F, W> tracing_core::Subscriber for Subscriber<N, E, F, W>
+where
+ N: for<'writer> FormatFields<'writer> + 'static,
+ E: FormatEvent<Registry, N> + 'static,
+ F: layer::Layer<Formatter<N, E, W>> + 'static,
+ W: for<'writer> MakeWriter<'writer> + 'static,
+ layer::Layered<F, Formatter<N, E, W>>: tracing_core::Subscriber,
+ fmt_layer::Layer<Registry, N, E, W>: layer::Layer<Registry>,
+{
+ #[inline]
+ fn register_callsite(&self, meta: &'static Metadata<'static>) -> Interest {
+ self.inner.register_callsite(meta)
+ }
+
+ #[inline]
+ fn enabled(&self, meta: &Metadata<'_>) -> bool {
+ self.inner.enabled(meta)
+ }
+
+ #[inline]
+ fn new_span(&self, attrs: &span::Attributes<'_>) -> span::Id {
+ self.inner.new_span(attrs)
+ }
+
+ #[inline]
+ fn record(&self, span: &span::Id, values: &span::Record<'_>) {
+ self.inner.record(span, values)
+ }
+
+ #[inline]
+ fn record_follows_from(&self, span: &span::Id, follows: &span::Id) {
+ self.inner.record_follows_from(span, follows)
+ }
+
+ #[inline]
+ fn event(&self, event: &Event<'_>) {
+ self.inner.event(event);
+ }
+
+ #[inline]
+ fn enter(&self, id: &span::Id) {
+ // TODO: add on_enter hook
+ self.inner.enter(id);
+ }
+
+ #[inline]
+ fn exit(&self, id: &span::Id) {
+ self.inner.exit(id);
+ }
+
+ #[inline]
+ fn current_span(&self) -> span::Current {
+ self.inner.current_span()
+ }
+
+ #[inline]
+ fn clone_span(&self, id: &span::Id) -> span::Id {
+ self.inner.clone_span(id)
+ }
+
+ #[inline]
+ fn try_close(&self, id: span::Id) -> bool {
+ self.inner.try_close(id)
+ }
+
+ #[inline]
+ fn max_level_hint(&self) -> Option<tracing_core::LevelFilter> {
+ self.inner.max_level_hint()
+ }
+
+ unsafe fn downcast_raw(&self, id: TypeId) -> Option<*const ()> {
+ if id == TypeId::of::<Self>() {
+ Some(self as *const Self as *const ())
+ } else {
+ self.inner.downcast_raw(id)
+ }
+ }
+}
+
+impl<'a, N, E, F, W> LookupSpan<'a> for Subscriber<N, E, F, W>
+where
+ layer::Layered<F, Formatter<N, E, W>>: LookupSpan<'a>,
+{
+ type Data = <layer::Layered<F, Formatter<N, E, W>> as LookupSpan<'a>>::Data;
+
+ fn span_data(&'a self, id: &span::Id) -> Option<Self::Data> {
+ self.inner.span_data(id)
+ }
+}
+
+// ===== impl SubscriberBuilder =====
+
+impl Default for SubscriberBuilder {
+ fn default() -> Self {
+ SubscriberBuilder {
+ filter: Subscriber::DEFAULT_MAX_LEVEL,
+ inner: Default::default(),
+ }
+ }
+}
+
+impl<N, E, F, W> SubscriberBuilder<N, E, F, W>
+where
+ N: for<'writer> FormatFields<'writer> + 'static,
+ E: FormatEvent<Registry, N> + 'static,
+ W: for<'writer> MakeWriter<'writer> + 'static,
+ F: layer::Layer<Formatter<N, E, W>> + Send + Sync + 'static,
+ fmt_layer::Layer<Registry, N, E, W>: layer::Layer<Registry> + Send + Sync + 'static,
+{
+ /// Finish the builder, returning a new `FmtSubscriber`.
+ pub fn finish(self) -> Subscriber<N, E, F, W> {
+ let subscriber = self.inner.with_subscriber(Registry::default());
+ Subscriber {
+ inner: self.filter.with_subscriber(subscriber),
+ }
+ }
+
+ /// Install this Subscriber as the global default if one is
+ /// not already set.
+ ///
+ /// If the `tracing-log` feature is enabled, this will also install
+ /// the LogTracer to convert `Log` records into `tracing` `Event`s.
+ ///
+ /// # Errors
+ /// Returns an Error if the initialization was unsuccessful, likely
+ /// because a global subscriber was already installed by another
+ /// call to `try_init`.
+ pub fn try_init(self) -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
+ use crate::util::SubscriberInitExt;
+ self.finish().try_init()?;
+
+ Ok(())
+ }
+
+ /// Install this Subscriber as the global default.
+ ///
+ /// If the `tracing-log` feature is enabled, this will also install
+ /// the LogTracer to convert `Log` records into `tracing` `Event`s.
+ ///
+ /// # Panics
+ /// Panics if the initialization was unsuccessful, likely because a
+ /// global subscriber was already installed by another call to `try_init`.
+ pub fn init(self) {
+ self.try_init()
+ .expect("Unable to install global subscriber")
+ }
+}
+
+impl<N, E, F, W> From<SubscriberBuilder<N, E, F, W>> for tracing_core::Dispatch
+where
+ N: for<'writer> FormatFields<'writer> + 'static,
+ E: FormatEvent<Registry, N> + 'static,
+ W: for<'writer> MakeWriter<'writer> + 'static,
+ F: layer::Layer<Formatter<N, E, W>> + Send + Sync + 'static,
+ fmt_layer::Layer<Registry, N, E, W>: layer::Layer<Registry> + Send + Sync + 'static,
+{
+ fn from(builder: SubscriberBuilder<N, E, F, W>) -> tracing_core::Dispatch {
+ tracing_core::Dispatch::new(builder.finish())
+ }
+}
+
+impl<N, L, T, F, W> SubscriberBuilder<N, format::Format<L, T>, F, W>
+where
+ N: for<'writer> FormatFields<'writer> + 'static,
+{
+ /// Use the given [`timer`] for log message timestamps.
+ ///
+ /// See the [`time` module] for the provided timer implementations.
+ ///
+ /// Note that using the `"time`"" feature flag enables the
+ /// additional time formatters [`UtcTime`] and [`LocalTime`], which use the
+ /// [`time` crate] to provide more sophisticated timestamp formatting
+ /// options.
+ ///
+ /// [`timer`]: time::FormatTime
+ /// [`time` module]: mod@time
+ /// [`UtcTime`]: time::UtcTime
+ /// [`LocalTime`]: time::LocalTime
+ /// [`time` crate]: https://docs.rs/time/0.3
+ pub fn with_timer<T2>(self, timer: T2) -> SubscriberBuilder<N, format::Format<L, T2>, F, W> {
+ SubscriberBuilder {
+ filter: self.filter,
+ inner: self.inner.with_timer(timer),
+ }
+ }
+
+ /// Do not emit timestamps with log messages.
+ pub fn without_time(self) -> SubscriberBuilder<N, format::Format<L, ()>, F, W> {
+ SubscriberBuilder {
+ filter: self.filter,
+ inner: self.inner.without_time(),
+ }
+ }
+
+ /// Configures how synthesized events are emitted at points in the [span
+ /// lifecycle][lifecycle].
+ ///
+ /// The following options are available:
+ ///
+ /// - `FmtSpan::NONE`: No events will be synthesized when spans are
+ /// created, entered, exited, or closed. Data from spans will still be
+ /// included as the context for formatted events. This is the default.
+ /// - `FmtSpan::NEW`: An event will be synthesized when spans are created.
+ /// - `FmtSpan::ENTER`: An event will be synthesized when spans are entered.
+ /// - `FmtSpan::EXIT`: An event will be synthesized when spans are exited.
+ /// - `FmtSpan::CLOSE`: An event will be synthesized when a span closes. If
+ /// [timestamps are enabled][time] for this formatter, the generated
+ /// event will contain fields with the span's _busy time_ (the total
+ /// time for which it was entered) and _idle time_ (the total time that
+ /// the span existed but was not entered).
+ /// - `FmtSpan::ACTIVE`: An event will be synthesized when spans are entered
+ /// or exited.
+ /// - `FmtSpan::FULL`: Events will be synthesized whenever a span is
+ /// created, entered, exited, or closed. If timestamps are enabled, the
+ /// close event will contain the span's busy and idle time, as
+ /// described above.
+ ///
+ /// The options can be enabled in any combination. For instance, the following
+ /// will synthesize events whenever spans are created and closed:
+ ///
+ /// ```rust
+ /// use tracing_subscriber::fmt::format::FmtSpan;
+ /// use tracing_subscriber::fmt;
+ ///
+ /// let subscriber = fmt()
+ /// .with_span_events(FmtSpan::NEW | FmtSpan::CLOSE)
+ /// .finish();
+ /// ```
+ ///
+ /// Note that the generated events will only be part of the log output by
+ /// this formatter; they will not be recorded by other `Subscriber`s or by
+ /// `Layer`s added to this subscriber.
+ ///
+ /// [lifecycle]: https://docs.rs/tracing/latest/tracing/span/index.html#the-span-lifecycle
+ /// [time]: #method.without_time
+ pub fn with_span_events(self, kind: format::FmtSpan) -> Self {
+ SubscriberBuilder {
+ inner: self.inner.with_span_events(kind),
+ ..self
+ }
+ }
+
+ /// Enable ANSI encoding for formatted events.
+ #[cfg(feature = "ansi")]
+ #[cfg_attr(docsrs, doc(cfg(feature = "ansi")))]
+ pub fn with_ansi(self, ansi: bool) -> SubscriberBuilder<N, format::Format<L, T>, F, W> {
+ SubscriberBuilder {
+ inner: self.inner.with_ansi(ansi),
+ ..self
+ }
+ }
+
+ /// Sets whether or not an event's target is displayed.
+ pub fn with_target(
+ self,
+ display_target: bool,
+ ) -> SubscriberBuilder<N, format::Format<L, T>, F, W> {
+ SubscriberBuilder {
+ inner: self.inner.with_target(display_target),
+ ..self
+ }
+ }
+
+ /// Sets whether or not an event's level is displayed.
+ pub fn with_level(
+ self,
+ display_level: bool,
+ ) -> SubscriberBuilder<N, format::Format<L, T>, F, W> {
+ SubscriberBuilder {
+ inner: self.inner.with_level(display_level),
+ ..self
+ }
+ }
+
+ /// Sets whether or not the [name] of the current thread is displayed
+ /// when formatting events
+ ///
+ /// [name]: https://doc.rust-lang.org/stable/std/thread/index.html#naming-threads
+ pub fn with_thread_names(
+ self,
+ display_thread_names: bool,
+ ) -> SubscriberBuilder<N, format::Format<L, T>, F, W> {
+ SubscriberBuilder {
+ inner: self.inner.with_thread_names(display_thread_names),
+ ..self
+ }
+ }
+
+ /// Sets whether or not the [thread ID] of the current thread is displayed
+ /// when formatting events
+ ///
+ /// [thread ID]: https://doc.rust-lang.org/stable/std/thread/struct.ThreadId.html
+ pub fn with_thread_ids(
+ self,
+ display_thread_ids: bool,
+ ) -> SubscriberBuilder<N, format::Format<L, T>, F, W> {
+ SubscriberBuilder {
+ inner: self.inner.with_thread_ids(display_thread_ids),
+ ..self
+ }
+ }
+
+ /// Sets the subscriber being built to use a less verbose formatter.
+ ///
+ /// See [`format::Compact`].
+ pub fn compact(self) -> SubscriberBuilder<N, format::Format<format::Compact, T>, F, W>
+ where
+ N: for<'writer> FormatFields<'writer> + 'static,
+ {
+ SubscriberBuilder {
+ filter: self.filter,
+ inner: self.inner.compact(),
+ }
+ }
+
+ /// Sets the subscriber being built to use an [excessively pretty, human-readable formatter](crate::fmt::format::Pretty).
+ #[cfg(feature = "ansi")]
+ #[cfg_attr(docsrs, doc(cfg(feature = "ansi")))]
+ pub fn pretty(
+ self,
+ ) -> SubscriberBuilder<format::Pretty, format::Format<format::Pretty, T>, F, W> {
+ SubscriberBuilder {
+ filter: self.filter,
+ inner: self.inner.pretty(),
+ }
+ }
+
+ /// Sets the subscriber being built to use a JSON formatter.
+ ///
+ /// See [`format::Json`](../fmt/format/struct.Json.html)
+ #[cfg(feature = "json")]
+ #[cfg_attr(docsrs, doc(cfg(feature = "json")))]
+ pub fn json(
+ self,
+ ) -> SubscriberBuilder<format::JsonFields, format::Format<format::Json, T>, F, W>
+ where
+ N: for<'writer> FormatFields<'writer> + 'static,
+ {
+ SubscriberBuilder {
+ filter: self.filter,
+ inner: self.inner.json(),
+ }
+ }
+}
+
+#[cfg(feature = "json")]
+#[cfg_attr(docsrs, doc(cfg(feature = "json")))]
+impl<T, F, W> SubscriberBuilder<format::JsonFields, format::Format<format::Json, T>, F, W> {
+ /// Sets the json subscriber being built to flatten event metadata.
+ ///
+ /// See [`format::Json`](../fmt/format/struct.Json.html)
+ pub fn flatten_event(
+ self,
+ flatten_event: bool,
+ ) -> SubscriberBuilder<format::JsonFields, format::Format<format::Json, T>, F, W> {
+ SubscriberBuilder {
+ filter: self.filter,
+ inner: self.inner.flatten_event(flatten_event),
+ }
+ }
+
+ /// Sets whether or not the JSON subscriber being built will include the current span
+ /// in formatted events.
+ ///
+ /// See [`format::Json`](../fmt/format/struct.Json.html)
+ pub fn with_current_span(
+ self,
+ display_current_span: bool,
+ ) -> SubscriberBuilder<format::JsonFields, format::Format<format::Json, T>, F, W> {
+ SubscriberBuilder {
+ filter: self.filter,
+ 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`](../fmt/format/struct.Json.html)
+ 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")]
+#[cfg_attr(docsrs, doc(cfg(feature = "env-filter")))]
+impl<N, E, W> SubscriberBuilder<N, E, crate::EnvFilter, W>
+where
+ Formatter<N, E, W>: tracing_core::Subscriber + 'static,
+{
+ /// Configures the subscriber being built to allow filter reloading at
+ /// runtime.
+ pub fn with_filter_reloading(
+ self,
+ ) -> SubscriberBuilder<N, E, crate::reload::Layer<crate::EnvFilter, Formatter<N, E, W>>, W>
+ {
+ let (filter, _) = crate::reload::Layer::new(self.filter);
+ SubscriberBuilder {
+ filter,
+ inner: self.inner,
+ }
+ }
+}
+
+#[cfg(feature = "env-filter")]
+#[cfg_attr(docsrs, doc(cfg(feature = "env-filter")))]
+impl<N, E, W> SubscriberBuilder<N, E, crate::reload::Layer<crate::EnvFilter, Formatter<N, E, W>>, W>
+where
+ Formatter<N, E, W>: tracing_core::Subscriber + 'static,
+{
+ /// Returns a `Handle` that may be used to reload the constructed subscriber's
+ /// filter.
+ pub fn reload_handle(&self) -> crate::reload::Handle<crate::EnvFilter, Formatter<N, E, W>> {
+ self.filter.handle()
+ }
+}
+
+impl<N, E, F, W> SubscriberBuilder<N, E, F, W> {
+ /// Sets the Visitor that the subscriber being built will use to record
+ /// fields.
+ ///
+ /// For example:
+ /// ```rust
+ /// use tracing_subscriber::fmt::format;
+ /// use tracing_subscriber::prelude::*;
+ ///
+ /// let formatter =
+ /// // Construct a custom formatter for `Debug` fields
+ /// format::debug_fn(|writer, field, value| write!(writer, "{}: {:?}", field, value))
+ /// // Use the `tracing_subscriber::MakeFmtExt` trait to wrap the
+ /// // formatter so that a delimiter is added between fields.
+ /// .delimited(", ");
+ ///
+ /// let subscriber = tracing_subscriber::fmt()
+ /// .fmt_fields(formatter)
+ /// .finish();
+ /// # drop(subscriber)
+ /// ```
+ pub fn fmt_fields<N2>(self, fmt_fields: N2) -> SubscriberBuilder<N2, E, F, W>
+ where
+ N2: for<'writer> FormatFields<'writer> + 'static,
+ {
+ SubscriberBuilder {
+ filter: self.filter,
+ inner: self.inner.fmt_fields(fmt_fields),
+ }
+ }
+
+ /// Sets the [`EnvFilter`] that the subscriber will use to determine if
+ /// a span or event is enabled.
+ ///
+ /// Note that this method requires the "env-filter" feature flag to be enabled.
+ ///
+ /// If a filter was previously set, or a maximum level was set by the
+ /// [`with_max_level`] method, that value is replaced by the new filter.
+ ///
+ /// # Examples
+ ///
+ /// Setting a filter based on the value of the `RUST_LOG` environment
+ /// variable:
+ /// ```rust
+ /// use tracing_subscriber::{fmt, EnvFilter};
+ ///
+ /// fmt()
+ /// .with_env_filter(EnvFilter::from_default_env())
+ /// .init();
+ /// ```
+ ///
+ /// Setting a filter based on a pre-set filter directive string:
+ /// ```rust
+ /// use tracing_subscriber::fmt;
+ ///
+ /// fmt()
+ /// .with_env_filter("my_crate=info,my_crate::my_mod=debug,[my_span]=trace")
+ /// .init();
+ /// ```
+ ///
+ /// Adding additional directives to a filter constructed from an env var:
+ /// ```rust
+ /// use tracing_subscriber::{fmt, filter::{EnvFilter, LevelFilter}};
+ ///
+ /// # fn filter() -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
+ /// let filter = EnvFilter::try_from_env("MY_CUSTOM_FILTER_ENV_VAR")?
+ /// // Set the base level when not matched by other directives to WARN.
+ /// .add_directive(LevelFilter::WARN.into())
+ /// // Set the max level for `my_crate::my_mod` to DEBUG, overriding
+ /// // any directives parsed from the env variable.
+ /// .add_directive("my_crate::my_mod=debug".parse()?);
+ ///
+ /// fmt()
+ /// .with_env_filter(filter)
+ /// .try_init()?;
+ /// # Ok(())}
+ /// ```
+ /// [`EnvFilter`]: ../filter/struct.EnvFilter.html
+ /// [`with_max_level`]: #method.with_max_level
+ #[cfg(feature = "env-filter")]
+ #[cfg_attr(docsrs, doc(cfg(feature = "env-filter")))]
+ pub fn with_env_filter(
+ self,
+ filter: impl Into<crate::EnvFilter>,
+ ) -> SubscriberBuilder<N, E, crate::EnvFilter, W>
+ where
+ Formatter<N, E, W>: tracing_core::Subscriber + 'static,
+ {
+ let filter = filter.into();
+ SubscriberBuilder {
+ filter,
+ inner: self.inner,
+ }
+ }
+
+ /// Sets the maximum [verbosity level] that will be enabled by the
+ /// subscriber.
+ ///
+ /// If the max level has already been set, or a [`EnvFilter`] was added by
+ /// [`with_filter`], this replaces that configuration with the new
+ /// maximum level.
+ ///
+ /// # Examples
+ ///
+ /// Enable up to the `DEBUG` verbosity level:
+ /// ```rust
+ /// use tracing_subscriber::fmt;
+ /// use tracing::Level;
+ ///
+ /// fmt()
+ /// .with_max_level(Level::DEBUG)
+ /// .init();
+ /// ```
+ /// This subscriber won't record any spans or events!
+ /// ```rust
+ /// use tracing_subscriber::{fmt, filter::LevelFilter};
+ ///
+ /// let subscriber = fmt()
+ /// .with_max_level(LevelFilter::OFF)
+ /// .finish();
+ /// ```
+ /// [verbosity level]: https://docs.rs/tracing-core/0.1.5/tracing_core/struct.Level.html
+ /// [`EnvFilter`]: ../filter/struct.EnvFilter.html
+ /// [`with_filter`]: #method.with_filter
+ pub fn with_max_level(
+ self,
+ filter: impl Into<LevelFilter>,
+ ) -> SubscriberBuilder<N, E, LevelFilter, W> {
+ let filter = filter.into();
+ SubscriberBuilder {
+ filter,
+ inner: self.inner,
+ }
+ }
+
+ /// Sets the function that the subscriber being built should use to format
+ /// events that occur.
+ pub fn event_format<E2>(self, fmt_event: E2) -> SubscriberBuilder<N, E2, F, W>
+ where
+ E2: FormatEvent<Registry, N> + 'static,
+ N: for<'writer> FormatFields<'writer> + 'static,
+ W: for<'writer> MakeWriter<'writer> + 'static,
+ {
+ SubscriberBuilder {
+ filter: self.filter,
+ inner: self.inner.event_format(fmt_event),
+ }
+ }
+
+ /// Sets the [`MakeWriter`] that the subscriber being built will use to write events.
+ ///
+ /// # Examples
+ ///
+ /// Using `stderr` rather than `stdout`:
+ ///
+ /// ```rust
+ /// use tracing_subscriber::fmt;
+ /// use std::io;
+ ///
+ /// fmt()
+ /// .with_writer(io::stderr)
+ /// .init();
+ /// ```
+ ///
+ /// [`MakeWriter`]: trait.MakeWriter.html
+ pub fn with_writer<W2>(self, make_writer: W2) -> SubscriberBuilder<N, E, F, W2>
+ where
+ W2: for<'writer> MakeWriter<'writer> + 'static,
+ {
+ SubscriberBuilder {
+ filter: self.filter,
+ inner: self.inner.with_writer(make_writer),
+ }
+ }
+
+ /// Configures the subscriber to support [`libtest`'s output capturing][capturing] when used in
+ /// unit tests.
+ ///
+ /// See [`TestWriter`] for additional details.
+ ///
+ /// # Examples
+ ///
+ /// Using [`TestWriter`] to let `cargo test` capture test output. Note that we do not install it
+ /// globally as it may cause conflicts.
+ ///
+ /// ```rust
+ /// use tracing_subscriber::fmt;
+ /// use tracing::subscriber;
+ ///
+ /// subscriber::set_default(
+ /// fmt()
+ /// .with_test_writer()
+ /// .finish()
+ /// );
+ /// ```
+ ///
+ /// [capturing]:
+ /// https://doc.rust-lang.org/book/ch11-02-running-tests.html#showing-function-output
+ /// [`TestWriter`]: writer/struct.TestWriter.html
+ pub fn with_test_writer(self) -> SubscriberBuilder<N, E, F, TestWriter> {
+ SubscriberBuilder {
+ filter: self.filter,
+ inner: self.inner.with_writer(TestWriter::default()),
+ }
+ }
+}
+
+/// Install a global tracing subscriber that listens for events and
+/// filters based on the value of the [`RUST_LOG` environment variable],
+/// if one is not already set.
+///
+/// If the `tracing-log` feature is enabled, this will also install
+/// the [`LogTracer`] to convert `log` records into `tracing` `Event`s.
+///
+/// This is shorthand for
+///
+/// ```rust
+/// # fn doc() -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
+/// tracing_subscriber::fmt().try_init()
+/// # }
+/// ```
+///
+///
+/// # Errors
+///
+/// Returns an Error if the initialization was unsuccessful,
+/// likely because a global subscriber was already installed by another
+/// call to `try_init`.
+///
+/// [`LogTracer`]:
+/// https://docs.rs/tracing-log/0.1.0/tracing_log/struct.LogTracer.html
+/// [`RUST_LOG` environment variable]:
+/// ../filter/struct.EnvFilter.html#associatedconstant.DEFAULT_ENV
+pub fn try_init() -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
+ let builder = Subscriber::builder();
+
+ #[cfg(feature = "env-filter")]
+ let builder = builder.with_env_filter(crate::EnvFilter::from_default_env());
+
+ builder.try_init()
+}
+
+/// Install a global tracing subscriber that listens for events and
+/// filters based on the value of the [`RUST_LOG` environment variable].
+///
+/// If the `tracing-log` feature is enabled, this will also install
+/// the LogTracer to convert `Log` records into `tracing` `Event`s.
+///
+/// This is shorthand for
+///
+/// ```rust
+/// tracing_subscriber::fmt().init()
+/// ```
+///
+/// # Panics
+/// Panics if the initialization was unsuccessful, likely because a
+/// global subscriber was already installed by another call to `try_init`.
+///
+/// [`RUST_LOG` environment variable]:
+/// ../filter/struct.EnvFilter.html#associatedconstant.DEFAULT_ENV
+pub fn init() {
+ try_init().expect("Unable to install global subscriber")
+}
+
+#[cfg(test)]
+mod test {
+ use crate::{
+ filter::LevelFilter,
+ fmt::{
+ format::{self, Format},
+ time,
+ writer::MakeWriter,
+ Subscriber,
+ },
+ };
+ use std::{
+ io,
+ sync::{Arc, Mutex, MutexGuard, TryLockError},
+ };
+ use tracing_core::dispatcher::Dispatch;
+
+ pub(crate) struct MockWriter {
+ buf: Arc<Mutex<Vec<u8>>>,
+ }
+
+ impl MockWriter {
+ pub(crate) fn new(buf: Arc<Mutex<Vec<u8>>>) -> Self {
+ Self { buf }
+ }
+
+ pub(crate) fn map_error<Guard>(err: TryLockError<Guard>) -> io::Error {
+ match err {
+ TryLockError::WouldBlock => io::Error::from(io::ErrorKind::WouldBlock),
+ TryLockError::Poisoned(_) => io::Error::from(io::ErrorKind::Other),
+ }
+ }
+
+ pub(crate) fn buf(&self) -> io::Result<MutexGuard<'_, Vec<u8>>> {
+ self.buf.try_lock().map_err(Self::map_error)
+ }
+ }
+
+ impl io::Write for MockWriter {
+ fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+ self.buf()?.write(buf)
+ }
+
+ fn flush(&mut self) -> io::Result<()> {
+ self.buf()?.flush()
+ }
+ }
+
+ #[derive(Clone, Default)]
+ pub(crate) struct MockMakeWriter {
+ buf: Arc<Mutex<Vec<u8>>>,
+ }
+
+ impl MockMakeWriter {
+ pub(crate) fn new(buf: Arc<Mutex<Vec<u8>>>) -> Self {
+ Self { buf }
+ }
+
+ #[cfg(feature = "json")]
+ pub(crate) fn buf(&self) -> MutexGuard<'_, Vec<u8>> {
+ self.buf.lock().unwrap()
+ }
+
+ pub(crate) fn get_string(&self) -> String {
+ let mut buf = self.buf.lock().expect("lock shouldn't be poisoned");
+ let string = std::str::from_utf8(&buf[..])
+ .expect("formatter should not have produced invalid utf-8")
+ .to_owned();
+ buf.clear();
+ string
+ }
+ }
+
+ impl<'a> MakeWriter<'a> for MockMakeWriter {
+ type Writer = MockWriter;
+
+ fn make_writer(&'a self) -> Self::Writer {
+ MockWriter::new(self.buf.clone())
+ }
+ }
+
+ #[test]
+ fn impls() {
+ let f = Format::default().with_timer(time::Uptime::default());
+ let subscriber = Subscriber::builder().event_format(f).finish();
+ let _dispatch = Dispatch::new(subscriber);
+
+ let f = format::Format::default();
+ let subscriber = Subscriber::builder().event_format(f).finish();
+ let _dispatch = Dispatch::new(subscriber);
+
+ let f = format::Format::default().compact();
+ let subscriber = Subscriber::builder().event_format(f).finish();
+ let _dispatch = Dispatch::new(subscriber);
+ }
+
+ #[test]
+ fn subscriber_downcasts() {
+ let subscriber = Subscriber::builder().finish();
+ let dispatch = Dispatch::new(subscriber);
+ assert!(dispatch.downcast_ref::<Subscriber>().is_some());
+ }
+
+ #[test]
+ fn subscriber_downcasts_to_parts() {
+ let subscriber = Subscriber::new();
+ let dispatch = Dispatch::new(subscriber);
+ assert!(dispatch.downcast_ref::<format::DefaultFields>().is_some());
+ assert!(dispatch.downcast_ref::<LevelFilter>().is_some());
+ assert!(dispatch.downcast_ref::<format::Format>().is_some())
+ }
+
+ #[test]
+ fn is_lookup_span() {
+ fn assert_lookup_span<T: for<'a> crate::registry::LookupSpan<'a>>(_: T) {}
+ let subscriber = Subscriber::new();
+ assert_lookup_span(subscriber)
+ }
+}
diff --git a/vendor/tracing-subscriber/src/fmt/time/datetime.rs b/vendor/tracing-subscriber-0.3.3/src/fmt/time/datetime.rs
index 531331687..531331687 100644
--- a/vendor/tracing-subscriber/src/fmt/time/datetime.rs
+++ b/vendor/tracing-subscriber-0.3.3/src/fmt/time/datetime.rs
diff --git a/vendor/tracing-subscriber-0.3.3/src/fmt/time/mod.rs b/vendor/tracing-subscriber-0.3.3/src/fmt/time/mod.rs
new file mode 100644
index 000000000..621df16e4
--- /dev/null
+++ b/vendor/tracing-subscriber-0.3.3/src/fmt/time/mod.rs
@@ -0,0 +1,134 @@
+//! Formatters for event timestamps.
+use crate::fmt::format::Writer;
+use std::fmt;
+use std::time::Instant;
+
+mod datetime;
+
+#[cfg(feature = "time")]
+mod time_crate;
+#[cfg(feature = "time")]
+#[cfg_attr(docsrs, doc(cfg(feature = "time")))]
+pub use time_crate::UtcTime;
+
+#[cfg(feature = "local-time")]
+#[cfg_attr(docsrs, doc(cfg(feature = "local-time")))]
+pub use time_crate::LocalTime;
+
+/// A type that can measure and format the current time.
+///
+/// This trait is used by `Format` to include a timestamp with each `Event` when it is logged.
+///
+/// Notable default implementations of this trait are `SystemTime` and `()`. The former prints the
+/// current time as reported by `std::time::SystemTime`, and the latter does not print the current
+/// time at all. `FormatTime` is also automatically implemented for any function pointer with the
+/// appropriate signature.
+///
+/// The full list of provided implementations can be found in [`time`].
+///
+/// [`time`]: ./index.html
+pub trait FormatTime {
+ /// Measure and write out the current time.
+ ///
+ /// When `format_time` is called, implementors should get the current time using their desired
+ /// mechanism, and write it out to the given `fmt::Write`. Implementors must insert a trailing
+ /// space themselves if they wish to separate the time from subsequent log message text.
+ fn format_time(&self, w: &mut Writer<'_>) -> fmt::Result;
+}
+
+/// Returns a new `SystemTime` timestamp provider.
+///
+/// This can then be configured further to determine how timestamps should be
+/// configured.
+///
+/// This is equivalent to calling
+/// ```rust
+/// # fn timer() -> tracing_subscriber::fmt::time::SystemTime {
+/// tracing_subscriber::fmt::time::SystemTime::default()
+/// # }
+/// ```
+pub fn time() -> SystemTime {
+ SystemTime::default()
+}
+
+/// Returns a new `Uptime` timestamp provider.
+///
+/// With this timer, timestamps will be formatted with the amount of time
+/// elapsed since the timestamp provider was constructed.
+///
+/// This can then be configured further to determine how timestamps should be
+/// configured.
+///
+/// This is equivalent to calling
+/// ```rust
+/// # fn timer() -> tracing_subscriber::fmt::time::Uptime {
+/// tracing_subscriber::fmt::time::Uptime::default()
+/// # }
+/// ```
+pub fn uptime() -> Uptime {
+ Uptime::default()
+}
+
+impl<'a, F> FormatTime for &'a F
+where
+ F: FormatTime,
+{
+ fn format_time(&self, w: &mut Writer<'_>) -> fmt::Result {
+ (*self).format_time(w)
+ }
+}
+
+impl FormatTime for () {
+ fn format_time(&self, _: &mut Writer<'_>) -> fmt::Result {
+ Ok(())
+ }
+}
+
+impl FormatTime for fn(&mut Writer<'_>) -> fmt::Result {
+ fn format_time(&self, w: &mut Writer<'_>) -> fmt::Result {
+ (*self)(w)
+ }
+}
+
+/// Retrieve and print the current wall-clock time.
+#[derive(Debug, Clone, Copy, Eq, PartialEq, Default)]
+pub struct SystemTime;
+
+/// Retrieve and print the relative elapsed wall-clock time since an epoch.
+///
+/// The `Default` implementation for `Uptime` makes the epoch the current time.
+#[derive(Debug, Clone, Copy, Eq, PartialEq)]
+pub struct Uptime {
+ epoch: Instant,
+}
+
+impl Default for Uptime {
+ fn default() -> Self {
+ Uptime {
+ epoch: Instant::now(),
+ }
+ }
+}
+
+impl From<Instant> for Uptime {
+ fn from(epoch: Instant) -> Self {
+ Uptime { epoch }
+ }
+}
+
+impl FormatTime for SystemTime {
+ fn format_time(&self, w: &mut Writer<'_>) -> fmt::Result {
+ write!(
+ w,
+ "{}",
+ datetime::DateTime::from(std::time::SystemTime::now())
+ )
+ }
+}
+
+impl FormatTime for Uptime {
+ fn format_time(&self, w: &mut Writer<'_>) -> fmt::Result {
+ let e = self.epoch.elapsed();
+ write!(w, "{:4}.{:09}s", e.as_secs(), e.subsec_nanos())
+ }
+}
diff --git a/vendor/tracing-subscriber-0.3.3/src/fmt/time/time_crate.rs b/vendor/tracing-subscriber-0.3.3/src/fmt/time/time_crate.rs
new file mode 100644
index 000000000..64d274365
--- /dev/null
+++ b/vendor/tracing-subscriber-0.3.3/src/fmt/time/time_crate.rs
@@ -0,0 +1,276 @@
+use crate::fmt::{format::Writer, time::FormatTime, writer::WriteAdaptor};
+use std::fmt;
+use time::{format_description::well_known, formatting::Formattable, OffsetDateTime};
+
+/// Formats the current [local time] using a [formatter] from the [`time` crate].
+///
+/// To format the current [UTC time] instead, use the [`UtcTime`] type.
+///
+/// [local time]: https://docs.rs/time/0.3/time/struct.OffsetDateTime.html#method.now_local
+/// [UTC time]: https://docs.rs/time/0.3/time/struct.OffsetDateTime.html#method.now_utc
+/// [formatter]: https://docs.rs/time/0.3/time/formatting/trait.Formattable.html
+/// [`time` crate]: https://docs.rs/time/0.3/time/
+#[derive(Clone, Debug)]
+#[cfg_attr(docsrs, doc(cfg(all(feature = "time", feature = "local-time"))))]
+#[cfg(feature = "local-time")]
+pub struct LocalTime<F> {
+ format: F,
+}
+
+/// Formats the current [UTC time] using a [formatter] from the [`time` crate].
+///
+/// To format the current [local time] instead, use the [`LocalTime`] type.
+///
+/// [local time]: https://docs.rs/time/0.3/time/struct.OffsetDateTime.html#method.now_local
+/// [UTC time]: https://docs.rs/time/0.3/time/struct.OffsetDateTime.html#method.now_utc
+/// [formatter]: https://docs.rs/time/0.3/time/formatting/trait.Formattable.html
+/// [`time` crate]: https://docs.rs/time/0.3/time/
+#[cfg_attr(docsrs, doc(cfg(feature = "time")))]
+#[derive(Clone, Debug)]
+pub struct UtcTime<F> {
+ format: F,
+}
+
+// === impl LocalTime ===
+
+#[cfg(feature = "local-time")]
+impl LocalTime<well_known::Rfc3339> {
+ /// Returns a formatter that formats the current [local time] in the
+ /// [RFC 3339] format (a subset of the [ISO 8601] timestamp format).
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use tracing_subscriber::fmt::{self, time};
+ ///
+ /// let collector = tracing_subscriber::fmt()
+ /// .with_timer(time::LocalTime::rfc_3339());
+ /// # drop(collector);
+ /// ```
+ ///
+ /// [local time]: https://docs.rs/time/0.3/time/struct.OffsetDateTime.html#method.now_local
+ /// [RFC 3339]: https://datatracker.ietf.org/doc/html/rfc3339
+ /// [ISO 8601]: https://en.wikipedia.org/wiki/ISO_8601
+ pub fn rfc_3339() -> Self {
+ Self::new(well_known::Rfc3339)
+ }
+}
+
+#[cfg(feature = "local-time")]
+impl<F: Formattable> LocalTime<F> {
+ /// Returns a formatter that formats the current [local time] using the
+ /// [`time` crate] with the provided provided format. The format may be any
+ /// type that implements the [`Formattable`] trait.
+ ///
+ /// Typically, the format will be a format description string, or one of the
+ /// `time` crate's [well-known formats].
+ ///
+ /// If the format description is statically known, then the
+ /// [`format_description!`] macro should be used. This is identical to the
+ /// [`time::format_description::parse`] method, but runs at compile-time,
+ /// throwing an error if the format description is invalid. If the desired format
+ /// is not known statically (e.g., a user is providing a format string), then the
+ /// [`time::format_description::parse`] method should be used. Note that this
+ /// method is fallible.
+ ///
+ /// See the [`time` book] for details on the format description syntax.
+ ///
+ /// # Examples
+ ///
+ /// Using the [`format_description!`] macro:
+ ///
+ /// ```
+ /// use tracing_subscriber::fmt::{self, time::LocalTime};
+ /// use time::macros::format_description;
+ ///
+ /// let timer = LocalTime::new(format_description!("[hour]:[minute]:[second]"));
+ /// let collector = tracing_subscriber::fmt()
+ /// .with_timer(timer);
+ /// # drop(collector);
+ /// ```
+ ///
+ /// Using [`time::format_description::parse`]:
+ ///
+ /// ```
+ /// use tracing_subscriber::fmt::{self, time::LocalTime};
+ ///
+ /// let time_format = time::format_description::parse("[hour]:[minute]:[second]")
+ /// .expect("format string should be valid!");
+ /// let timer = LocalTime::new(time_format);
+ /// let collector = tracing_subscriber::fmt()
+ /// .with_timer(timer);
+ /// # drop(collector);
+ /// ```
+ ///
+ /// Using the [`format_description!`] macro requires enabling the `time`
+ /// crate's "macros" feature flag.
+ ///
+ /// Using a [well-known format][well-known formats] (this is equivalent to
+ /// [`LocalTime::rfc_3339`]):
+ ///
+ /// ```
+ /// use tracing_subscriber::fmt::{self, time::LocalTime};
+ ///
+ /// let timer = LocalTime::new(time::format_description::well_known::Rfc3339);
+ /// let collector = tracing_subscriber::fmt()
+ /// .with_timer(timer);
+ /// # drop(collector);
+ /// ```
+ ///
+ /// [local time]: https://docs.rs/time/latest/time/struct.OffsetDateTime.html#method.now_local
+ /// [`time` crate]: https://docs.rs/time/0.3/time/
+ /// [`Formattable`]: https://docs.rs/time/0.3/time/formatting/trait.Formattable.html
+ /// [well-known formats]: https://docs.rs/time/0.3/time/format_description/well_known/index.html
+ /// [`format_description!`]: https://docs.rs/time/0.3/time/macros/macro.format_description.html
+ /// [`time::format_description::parse`]: https://docs.rs/time/0.3/time/format_description/fn.parse.html
+ /// [`time` book]: https://time-rs.github.io/book/api/format-description.html
+ pub fn new(format: F) -> Self {
+ Self { format }
+ }
+}
+
+#[cfg(feature = "local-time")]
+impl<F> FormatTime for LocalTime<F>
+where
+ F: Formattable,
+{
+ fn format_time(&self, w: &mut Writer<'_>) -> fmt::Result {
+ let now = OffsetDateTime::now_local().map_err(|_| fmt::Error)?;
+ format_datetime(now, w, &self.format)
+ }
+}
+
+#[cfg(feature = "local-time")]
+impl<F> Default for LocalTime<F>
+where
+ F: Formattable + Default,
+{
+ fn default() -> Self {
+ Self::new(F::default())
+ }
+}
+
+// === impl UtcTime ===
+
+impl UtcTime<well_known::Rfc3339> {
+ /// Returns a formatter that formats the current [UTC time] in the
+ /// [RFC 3339] format, which is a subset of the [ISO 8601] timestamp format.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use tracing_subscriber::fmt::{self, time};
+ ///
+ /// let collector = tracing_subscriber::fmt()
+ /// .with_timer(time::UtcTime::rfc_3339());
+ /// # drop(collector);
+ /// ```
+ ///
+ /// [local time]: https://docs.rs/time/0.3/time/struct.OffsetDateTime.html#method.now_utc
+ /// [RFC 3339]: https://datatracker.ietf.org/doc/html/rfc3339
+ /// [ISO 8601]: https://en.wikipedia.org/wiki/ISO_8601
+ pub fn rfc_3339() -> Self {
+ Self::new(well_known::Rfc3339)
+ }
+}
+
+impl<F: Formattable> UtcTime<F> {
+ /// Returns a formatter that formats the current [UTC time] using the
+ /// [`time` crate], with the provided provided format. The format may be any
+ /// type that implements the [`Formattable`] trait.
+ ///
+ /// Typically, the format will be a format description string, or one of the
+ /// `time` crate's [well-known formats].
+ ///
+ /// If the format description is statically known, then the
+ /// [`format_description!`] macro should be used. This is identical to the
+ /// [`time::format_description::parse`] method, but runs at compile-time,
+ /// failing an error if the format description is invalid. If the desired format
+ /// is not known statically (e.g., a user is providing a format string), then the
+ /// [`time::format_description::parse`] method should be used. Note that this
+ /// method is fallible.
+ ///
+ /// See the [`time` book] for details on the format description syntax.
+ ///
+ /// # Examples
+ ///
+ /// Using the [`format_description!`] macro:
+ ///
+ /// ```
+ /// use tracing_subscriber::fmt::{self, time::UtcTime};
+ /// use time::macros::format_description;
+ ///
+ /// let timer = UtcTime::new(format_description!("[hour]:[minute]:[second]"));
+ /// let collector = tracing_subscriber::fmt()
+ /// .with_timer(timer);
+ /// # drop(collector);
+ /// ```
+ ///
+ /// Using the [`format_description!`] macro requires enabling the `time`
+ /// crate's "macros" feature flag.
+ ///
+ /// Using [`time::format_description::parse`]:
+ ///
+ /// ```
+ /// use tracing_subscriber::fmt::{self, time::UtcTime};
+ ///
+ /// let time_format = time::format_description::parse("[hour]:[minute]:[second]")
+ /// .expect("format string should be valid!");
+ /// let timer = UtcTime::new(time_format);
+ /// let collector = tracing_subscriber::fmt()
+ /// .with_timer(timer);
+ /// # drop(collector);
+ /// ```
+ ///
+ /// Using a [well-known format][well-known formats] (this is equivalent to
+ /// [`UtcTime::rfc_3339`]):
+ ///
+ /// ```
+ /// use tracing_subscriber::fmt::{self, time::UtcTime};
+ ///
+ /// let timer = UtcTime::new(time::format_description::well_known::Rfc3339);
+ /// let collector = tracing_subscriber::fmt()
+ /// .with_timer(timer);
+ /// # drop(collector);
+ /// ```
+ ///
+ /// [UTC time]: https://docs.rs/time/latest/time/struct.OffsetDateTime.html#method.now_utc
+ /// [`time` crate]: https://docs.rs/time/0.3/time/
+ /// [`Formattable`]: https://docs.rs/time/0.3/time/formatting/trait.Formattable.html
+ /// [well-known formats]: https://docs.rs/time/0.3/time/format_description/well_known/index.html
+ /// [`format_description!`]: https://docs.rs/time/0.3/time/macros/macro.format_description.html
+ /// [`time::format_description::parse`]: https://docs.rs/time/0.3/time/format_description/fn.parse.html
+ /// [`time` book]: https://time-rs.github.io/book/api/format-description.html
+ pub fn new(format: F) -> Self {
+ Self { format }
+ }
+}
+
+impl<F> FormatTime for UtcTime<F>
+where
+ F: Formattable,
+{
+ fn format_time(&self, w: &mut Writer<'_>) -> fmt::Result {
+ format_datetime(OffsetDateTime::now_utc(), w, &self.format)
+ }
+}
+
+impl<F> Default for UtcTime<F>
+where
+ F: Formattable + Default,
+{
+ fn default() -> Self {
+ Self::new(F::default())
+ }
+}
+
+fn format_datetime(
+ now: OffsetDateTime,
+ into: &mut Writer<'_>,
+ fmt: &impl Formattable,
+) -> fmt::Result {
+ let mut into = WriteAdaptor::new(into);
+ now.format_into(&mut into, fmt)
+ .map_err(|_| fmt::Error)
+ .map(|_| ())
+}
diff --git a/vendor/tracing-subscriber/src/fmt/writer.rs b/vendor/tracing-subscriber-0.3.3/src/fmt/writer.rs
index 4aacd6d54..0974891f7 100644
--- a/vendor/tracing-subscriber/src/fmt/writer.rs
+++ b/vendor/tracing-subscriber-0.3.3/src/fmt/writer.rs
@@ -1,6 +1,6 @@
//! Abstractions for creating [`io::Write`] instances.
//!
-//! [`io::Write`]: std::io::Write
+//! [`io::Write`]: https://doc.rust-lang.org/std/io/trait.Write.html
use std::{
fmt,
io::{self, Write},
@@ -96,8 +96,8 @@ use tracing_core::Metadata;
pub trait MakeWriter<'a> {
/// The concrete [`io::Write`] implementation returned by [`make_writer`].
///
- /// [`io::Write`]: std::io::Write
- /// [`make_writer`]: MakeWriter::make_writer
+ /// [`io::Write`]: https://doc.rust-lang.org/std/io/trait.Write.html
+ /// [`make_writer`]: #tymethod.make_writer
type Writer: io::Write;
/// Returns an instance of [`Writer`].
@@ -109,7 +109,7 @@ pub trait MakeWriter<'a> {
/// creating a [`io::Write`] instance is expensive, be sure to cache it when implementing
/// [`MakeWriter`] to improve performance.
///
- /// [`Writer`]: MakeWriter::Writer
+ /// [`Writer`]: #associatedtype.Writer
/// [`fmt::Layer`]: crate::fmt::Layer
/// [`fmt::Subscriber`]: crate::fmt::Subscriber
/// [`io::Write`]: std::io::Write
@@ -501,13 +501,13 @@ pub trait MakeWriterExt<'a>: MakeWriter<'a> {
/// Writing to [`io::stdout`] and [`io::stderr`] produces the same results as using
/// [`libtest`'s `--nocapture` option][nocapture] which may make the results look unreadable.
///
-/// [`fmt::Subscriber`]: super::Subscriber
-/// [`fmt::Layer`]: super::Layer
+/// [`fmt::Subscriber`]: ../struct.Subscriber.html
+/// [`fmt::Layer`]: ../struct.Layer.html
/// [capturing]: https://doc.rust-lang.org/book/ch11-02-running-tests.html#showing-function-output
/// [nocapture]: https://doc.rust-lang.org/cargo/commands/cargo-test.html
-/// [`io::stdout`]: std::io::stdout
-/// [`io::stderr`]: std::io::stderr
-/// [`print!`]: std::print!
+/// [`io::stdout`]: https://doc.rust-lang.org/std/io/fn.stdout.html
+/// [`io::stderr`]: https://doc.rust-lang.org/std/io/fn.stderr.html
+/// [`print!`]: https://doc.rust-lang.org/std/macro.print.html
#[derive(Default, Debug)]
pub struct TestWriter {
_p: (),
@@ -646,9 +646,10 @@ pub struct Tee<A, B> {
/// requires the `Writer` type to implement [`io::Write`], it's necessary to add
/// a newtype that forwards the trait implementation.
///
-/// [`io::Write`]: std::io::Write
-/// [`MutexGuard`]: std::sync::MutexGuard
-/// [`Mutex`]: std::sync::Mutex
+/// [`io::Write`]: https://doc.rust-lang.org/std/io/trait.Write.html
+/// [`MutexGuard`]: https://doc.rust-lang.org/std/sync/struct.MutexGuard.html
+/// [`Mutex`]: https://doc.rust-lang.org/std/sync/struct.Mutex.html
+/// [`MakeWriter`]: trait.MakeWriter.html
#[derive(Debug)]
pub struct MutexGuardWriter<'a, W>(MutexGuard<'a, W>);
@@ -733,6 +734,7 @@ impl<'a> MakeWriter<'a> for TestWriter {
impl BoxMakeWriter {
/// Constructs a `BoxMakeWriter` wrapping a type implementing [`MakeWriter`].
///
+ /// [`MakeWriter`]: trait.MakeWriter.html
pub fn new<M>(make_writer: M) -> Self
where
M: for<'a> MakeWriter<'a> + Send + Sync + 'static,
@@ -1023,8 +1025,6 @@ impl<A, B> Tee<A, B> {
/// outputs.
///
/// See the documentation for [`MakeWriterExt::and`] for details.
- ///
- /// [writers]: std::io::Write
pub fn new(a: A, b: B) -> Self {
Self { a, b }
}
generated by cgit v1.2.3 (git 2.39.1) at 2024-07-23 22:12:46 +0000