Merging upstream version 1.66.0+dfsg1.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

36 files changed, 18351 insertions, 0 deletions

diff --git a/vendor/tracing-subscriber-0.3.3/src/field/debug.rs b/vendor/tracing-subscriber-0.3.3/src/field/debug.rs
new file mode 100644
index 000000000..cc67d29fe
--- /dev/null
+++ b/vendor/tracing-subscriber-0.3.3/src/field/debug.rs
@@ -0,0 +1,111 @@
+//! `MakeVisitor` wrappers for working with `fmt::Debug` fields.
+use super::{MakeVisitor, VisitFmt, VisitOutput};
+use tracing_core::field::{Field, Visit};
+
+use core::fmt;
+
+/// A visitor wrapper that ensures any `fmt::Debug` fields are formatted using
+/// the alternate (`:#`) formatter.
+#[derive(Debug, Clone)]
+pub struct Alt<V>(V);
+
+// TODO(eliza): When `error` as a primitive type is stable, add a
+// `DisplayErrors` wrapper...
+
+// === impl Alt ===
+//
+impl<V> Alt<V> {
+    /// Wraps the provided visitor so that any `fmt::Debug` fields are formatted
+    /// using the alternative (`:#`) formatter.
+    pub fn new(inner: V) -> Self {
+        Alt(inner)
+    }
+}
+
+impl<T, V> MakeVisitor<T> for Alt<V>
+where
+    V: MakeVisitor<T>,
+{
+    type Visitor = Alt<V::Visitor>;
+
+    #[inline]
+    fn make_visitor(&self, target: T) -> Self::Visitor {
+        Alt(self.0.make_visitor(target))
+    }
+}
+
+impl<V> Visit for Alt<V>
+where
+    V: Visit,
+{
+    #[inline]
+    fn record_f64(&mut self, field: &Field, value: f64) {
+        self.0.record_f64(field, value)
+    }
+
+    #[inline]
+    fn record_i64(&mut self, field: &Field, value: i64) {
+        self.0.record_i64(field, value)
+    }
+
+    #[inline]
+    fn record_u64(&mut self, field: &Field, value: u64) {
+        self.0.record_u64(field, value)
+    }
+
+    #[inline]
+    fn record_bool(&mut self, field: &Field, value: bool) {
+        self.0.record_bool(field, value)
+    }
+
+    /// Visit a string value.
+    fn record_str(&mut self, field: &Field, value: &str) {
+        self.0.record_str(field, value)
+    }
+
+    // TODO(eliza): add RecordError when stable
+    // fn record_error(&mut self, field: &Field, value: &(dyn std::error::Error + 'static)) {
+    //     self.record_debug(field, &format_args!("{}", value))
+    // }
+
+    #[inline]
+    fn record_debug(&mut self, field: &Field, value: &dyn fmt::Debug) {
+        self.0.record_debug(field, &format_args!("{:#?}", value))
+    }
+}
+
+impl<V, O> VisitOutput<O> for Alt<V>
+where
+    V: VisitOutput<O>,
+{
+    #[inline]
+    fn finish(self) -> O {
+        self.0.finish()
+    }
+}
+
+feature! {
+    #![feature = "std"]
+    use super::VisitWrite;
+    use std::io;
+
+    impl<V> VisitWrite for Alt<V>
+    where
+        V: VisitWrite,
+    {
+        #[inline]
+        fn writer(&mut self) -> &mut dyn io::Write {
+            self.0.writer()
+        }
+    }
+}
+
+impl<V> VisitFmt for Alt<V>
+where
+    V: VisitFmt,
+{
+    #[inline]
+    fn writer(&mut self) -> &mut dyn fmt::Write {
+        self.0.writer()
+    }
+}
diff --git a/vendor/tracing-subscriber-0.3.3/src/field/delimited.rs b/vendor/tracing-subscriber-0.3.3/src/field/delimited.rs
new file mode 100644
index 000000000..8c78c4b20
--- /dev/null
+++ b/vendor/tracing-subscriber-0.3.3/src/field/delimited.rs
@@ -0,0 +1,184 @@
+//! A `MakeVisitor` wrapper that separates formatted fields with a delimiter.
+use super::{MakeVisitor, VisitFmt, VisitOutput};
+
+use core::fmt;
+use tracing_core::field::{Field, Visit};
+
+/// A `MakeVisitor` wrapper that wraps a visitor that writes formatted output so
+/// that a delimiter is inserted between writing formatted field values.
+#[derive(Debug, Clone)]
+pub struct Delimited<D, V> {
+    delimiter: D,
+    inner: V,
+}
+
+/// A visitor wrapper that inserts a delimiter after the wrapped visitor formats
+/// a field value.
+#[derive(Debug)]
+pub struct VisitDelimited<D, V> {
+    delimiter: D,
+    seen: bool,
+    inner: V,
+    err: fmt::Result,
+}
+
+// === impl Delimited ===
+
+impl<D, V, T> MakeVisitor<T> for Delimited<D, V>
+where
+    D: AsRef<str> + Clone,
+    V: MakeVisitor<T>,
+    V::Visitor: VisitFmt,
+{
+    type Visitor = VisitDelimited<D, V::Visitor>;
+    fn make_visitor(&self, target: T) -> Self::Visitor {
+        let inner = self.inner.make_visitor(target);
+        VisitDelimited::new(self.delimiter.clone(), inner)
+    }
+}
+
+impl<D, V> Delimited<D, V> {
+    /// Returns a new [`MakeVisitor`] implementation that wraps `inner` so that
+    /// it will format each visited field separated by the provided `delimiter`.
+    ///
+    /// [`MakeVisitor`]: ../trait.MakeVisitor.html
+    pub fn new(delimiter: D, inner: V) -> Self {
+        Self { delimiter, inner }
+    }
+}
+
+// === impl VisitDelimited ===
+
+impl<D, V> VisitDelimited<D, V> {
+    /// Returns a new [`Visit`] implementation that wraps `inner` so that
+    /// each formatted field is separated by the provided `delimiter`.
+    ///
+    /// [`Visit`]: https://docs.rs/tracing-core/0.1.6/tracing_core/field/trait.Visit.html
+    pub fn new(delimiter: D, inner: V) -> Self {
+        Self {
+            delimiter,
+            inner,
+            seen: false,
+            err: Ok(()),
+        }
+    }
+
+    fn delimit(&mut self)
+    where
+        V: VisitFmt,
+        D: AsRef<str>,
+    {
+        if self.err.is_err() {
+            return;
+        }
+
+        if self.seen {
+            self.err = self.inner.writer().write_str(self.delimiter.as_ref());
+        }
+
+        self.seen = true;
+    }
+}
+
+impl<D, V> Visit for VisitDelimited<D, V>
+where
+    V: VisitFmt,
+    D: AsRef<str>,
+{
+    fn record_i64(&mut self, field: &Field, value: i64) {
+        self.delimit();
+        self.inner.record_i64(field, value);
+    }
+
+    fn record_u64(&mut self, field: &Field, value: u64) {
+        self.delimit();
+        self.inner.record_u64(field, value);
+    }
+
+    fn record_bool(&mut self, field: &Field, value: bool) {
+        self.delimit();
+        self.inner.record_bool(field, value);
+    }
+
+    fn record_str(&mut self, field: &Field, value: &str) {
+        self.delimit();
+        self.inner.record_str(field, value);
+    }
+
+    fn record_debug(&mut self, field: &Field, value: &dyn fmt::Debug) {
+        self.delimit();
+        self.inner.record_debug(field, value);
+    }
+}
+
+impl<D, V> VisitOutput<fmt::Result> for VisitDelimited<D, V>
+where
+    V: VisitFmt,
+    D: AsRef<str>,
+{
+    fn finish(self) -> fmt::Result {
+        self.err?;
+        self.inner.finish()
+    }
+}
+
+impl<D, V> VisitFmt for VisitDelimited<D, V>
+where
+    V: VisitFmt,
+    D: AsRef<str>,
+{
+    fn writer(&mut self) -> &mut dyn fmt::Write {
+        self.inner.writer()
+    }
+}
+
+#[cfg(test)]
+#[cfg(all(test, feature = "alloc"))]
+mod test {
+    use super::*;
+    use crate::field::test_util::*;
+
+    #[test]
+    fn delimited_visitor() {
+        let mut s = String::new();
+        let visitor = DebugVisitor::new(&mut s);
+        let mut visitor = VisitDelimited::new(", ", visitor);
+
+        TestAttrs1::with(|attrs| attrs.record(&mut visitor));
+        visitor.finish().unwrap();
+
+        assert_eq!(
+            s.as_str(),
+            "question=\"life, the universe, and everything\", tricky=true, can_you_do_it=true"
+        );
+    }
+
+    #[test]
+    fn delimited_new_visitor() {
+        let make = Delimited::new("; ", MakeDebug);
+
+        TestAttrs1::with(|attrs| {
+            let mut s = String::new();
+            {
+                let mut v = make.make_visitor(&mut s);
+                attrs.record(&mut v);
+            }
+            assert_eq!(
+                s.as_str(),
+                "question=\"life, the universe, and everything\"; tricky=true; can_you_do_it=true"
+            );
+        });
+
+        TestAttrs2::with(|attrs| {
+            let mut s = String::new();
+            {
+                let mut v = make.make_visitor(&mut s);
+                attrs.record(&mut v);
+            }
+            assert_eq!(
+                s.as_str(),
+                "question=None; question.answer=42; tricky=true; can_you_do_it=false"
+            );
+        });
+    }
+}
diff --git a/vendor/tracing-subscriber-0.3.3/src/field/display.rs b/vendor/tracing-subscriber-0.3.3/src/field/display.rs
new file mode 100644
index 000000000..e0bbc55ed
--- /dev/null
+++ b/vendor/tracing-subscriber-0.3.3/src/field/display.rs
@@ -0,0 +1,117 @@
+//! `MakeVisitor` wrappers for working with `fmt::Display` fields.
+use super::{MakeVisitor, VisitFmt, VisitOutput};
+use tracing_core::field::{Field, Visit};
+
+use core::fmt;
+
+/// A visitor wrapper that ensures any strings named "message" are formatted
+/// using `fmt::Display`
+#[derive(Debug, Clone)]
+pub struct Messages<V>(V);
+
+// TODO(eliza): When `error` as a primitive type is stable, add a
+// `DisplayErrors` wrapper...
+
+// === impl Messages ===
+//
+impl<V> Messages<V> {
+    /// Returns a new [`MakeVisitor`] implementation that will wrap `inner` so
+    /// that any strings named `message` are formatted using `fmt::Display`.
+    ///
+    /// [`MakeVisitor`]: ../trait.MakeVisitor.html
+    pub fn new(inner: V) -> Self {
+        Messages(inner)
+    }
+}
+
+impl<T, V> MakeVisitor<T> for Messages<V>
+where
+    V: MakeVisitor<T>,
+{
+    type Visitor = Messages<V::Visitor>;
+
+    #[inline]
+    fn make_visitor(&self, target: T) -> Self::Visitor {
+        Messages(self.0.make_visitor(target))
+    }
+}
+
+impl<V> Visit for Messages<V>
+where
+    V: Visit,
+{
+    #[inline]
+    fn record_f64(&mut self, field: &Field, value: f64) {
+        self.0.record_f64(field, value)
+    }
+
+    #[inline]
+    fn record_i64(&mut self, field: &Field, value: i64) {
+        self.0.record_i64(field, value)
+    }
+
+    #[inline]
+    fn record_u64(&mut self, field: &Field, value: u64) {
+        self.0.record_u64(field, value)
+    }
+
+    #[inline]
+    fn record_bool(&mut self, field: &Field, value: bool) {
+        self.0.record_bool(field, value)
+    }
+
+    /// Visit a string value.
+    fn record_str(&mut self, field: &Field, value: &str) {
+        if field.name() == "message" {
+            self.0.record_debug(field, &format_args!("{}", value))
+        } else {
+            self.0.record_str(field, value)
+        }
+    }
+
+    // TODO(eliza): add RecordError when stable
+    // fn record_error(&mut self, field: &Field, value: &(dyn std::error::Error + 'static)) {
+    //     self.record_debug(field, &format_args!("{}", value))
+    // }
+
+    #[inline]
+    fn record_debug(&mut self, field: &Field, value: &dyn fmt::Debug) {
+        self.0.record_debug(field, value)
+    }
+}
+
+impl<V, O> VisitOutput<O> for Messages<V>
+where
+    V: VisitOutput<O>,
+{
+    #[inline]
+    fn finish(self) -> O {
+        self.0.finish()
+    }
+}
+
+feature! {
+    #![feature = "std"]
+    use super::VisitWrite;
+    use std::io;
+
+    impl<V> VisitWrite for Messages<V>
+    where
+        V: VisitWrite,
+    {
+        #[inline]
+        fn writer(&mut self) -> &mut dyn io::Write {
+            self.0.writer()
+        }
+    }
+}
+
+impl<V> VisitFmt for Messages<V>
+where
+    V: VisitFmt,
+{
+    #[inline]
+    fn writer(&mut self) -> &mut dyn fmt::Write {
+        self.0.writer()
+    }
+}
diff --git a/vendor/tracing-subscriber-0.3.3/src/field/mod.rs b/vendor/tracing-subscriber-0.3.3/src/field/mod.rs
new file mode 100644
index 000000000..f7d03f2cc
--- /dev/null
+++ b/vendor/tracing-subscriber-0.3.3/src/field/mod.rs
@@ -0,0 +1,366 @@
+//! Utilities for working with [fields] and [field visitors].
+//!
+//! [fields]: tracing_core::field
+//! [field visitors]: tracing_core::field::Visit
+use core::{fmt, marker::PhantomData};
+pub use tracing_core::field::Visit;
+use tracing_core::{
+    span::{Attributes, Record},
+    Event,
+};
+pub mod debug;
+pub mod delimited;
+pub mod display;
+
+/// Creates new [visitors].
+///
+/// A type implementing `MakeVisitor` represents a composable factory for types
+/// implementing the [`Visit` trait][visitors]. The `MakeVisitor` trait defines
+/// a single function, `make_visitor`, which takes in a `T`-typed `target` and
+/// returns a type implementing `Visit` configured for that target. A target may
+/// be a string, output stream, or data structure that the visitor will record
+/// data to, configuration variables that determine the visitor's behavior, or
+/// `()` when no input is required to produce a visitor.
+///
+/// [visitors]: https://docs.rs/tracing-core/latest/tracing_core/field/trait.Visit.html
+pub trait MakeVisitor<T> {
+    /// The visitor type produced by this `MakeVisitor`.
+    type Visitor: Visit;
+
+    /// Make a new visitor for the provided `target`.
+    fn make_visitor(&self, target: T) -> Self::Visitor;
+}
+
+/// A [visitor] that produces output once it has visited a set of fields.
+///
+/// [visitor]: https://docs.rs/tracing-core/latest/tracing_core/field/trait.Visit.html
+pub trait VisitOutput<Out>: Visit {
+    /// Completes the visitor, returning any output.
+    ///
+    /// This is called once a full set of fields has been visited.
+    fn finish(self) -> Out;
+
+    /// Visit a set of fields, and return the output of finishing the visitor
+    /// once the fields have been visited.
+    fn visit<R>(mut self, fields: &R) -> Out
+    where
+        R: RecordFields,
+        Self: Sized,
+    {
+        fields.record(&mut self);
+        self.finish()
+    }
+}
+
+/// Extension trait implemented by types which can be recorded by a [visitor].
+///
+/// This allows writing code that is generic over `tracing_core`'s
+/// [`span::Attributes`][attr], [`span::Record`][rec], and [`Event`][event]
+/// types. These types all provide inherent `record` methods that allow a
+/// visitor to record their fields, but there is no common trait representing this.
+///
+/// With `RecordFields`, we can write code like this:
+/// ```
+/// use tracing_core::field::Visit;
+/// # use tracing_core::field::Field;
+/// use tracing_subscriber::field::RecordFields;
+///
+/// struct MyVisitor {
+///     // ...
+/// }
+/// # impl MyVisitor { fn new() -> Self { Self{} } }
+/// impl Visit for MyVisitor {
+///     // ...
+/// # fn record_debug(&mut self, _: &Field, _: &dyn std::fmt::Debug) {}
+/// }
+///
+/// fn record_with_my_visitor<R>(r: R)
+/// where
+///     R: RecordFields,
+/// {
+///     let mut visitor = MyVisitor::new();
+///     r.record(&mut visitor);
+/// }
+/// ```
+/// [visitor]: https://docs.rs/tracing-core/latest/tracing_core/field/trait.Visit.html
+/// [attr]: https://docs.rs/tracing-core/latest/tracing_core/span/struct.Attributes.html
+/// [rec]: https://docs.rs/tracing-core/latest/tracing_core/span/struct.Record.html
+/// [event]: https://docs.rs/tracing-core/latest/tracing_core/event/struct.Event.html
+pub trait RecordFields: crate::sealed::Sealed<RecordFieldsMarker> {
+    /// Record all the fields in `self` with the provided `visitor`.
+    fn record(&self, visitor: &mut dyn Visit);
+}
+
+/// Extension trait implemented for all `MakeVisitor` implementations that
+/// produce a visitor implementing `VisitOutput`.
+pub trait MakeOutput<T, Out>
+where
+    Self: MakeVisitor<T> + crate::sealed::Sealed<(T, Out)>,
+    Self::Visitor: VisitOutput<Out>,
+{
+    /// Visits all fields in `fields` with a new visitor constructed from
+    /// `target`.
+    fn visit_with<F>(&self, target: T, fields: &F) -> Out
+    where
+        F: RecordFields,
+    {
+        self.make_visitor(target).visit(fields)
+    }
+}
+
+feature! {
+    #![feature = "std"]
+    use std::io;
+
+    /// Extension trait implemented by visitors to indicate that they write to an
+    /// `io::Write` instance, and allow access to that writer.
+    pub trait VisitWrite: VisitOutput<Result<(), io::Error>> {
+        /// Returns the writer that this visitor writes to.
+        fn writer(&mut self) -> &mut dyn io::Write;
+    }
+}
+
+/// Extension trait implemented by visitors to indicate that they write to a
+/// `fmt::Write` instance, and allow access to that writer.
+pub trait VisitFmt: VisitOutput<fmt::Result> {
+    /// Returns the formatter that this visitor writes to.
+    fn writer(&mut self) -> &mut dyn fmt::Write;
+}
+
+/// Extension trait providing `MakeVisitor` combinators.
+pub trait MakeExt<T>
+where
+    Self: MakeVisitor<T> + Sized,
+    Self: crate::sealed::Sealed<MakeExtMarker<T>>,
+{
+    /// Wraps `self` so that any `fmt::Debug` fields are recorded using the
+    /// alternate formatter (`{:#?}`).
+    fn debug_alt(self) -> debug::Alt<Self> {
+        debug::Alt::new(self)
+    }
+
+    /// Wraps `self` so that any string fields named "message" are recorded
+    /// using `fmt::Display`.
+    fn display_messages(self) -> display::Messages<Self> {
+        display::Messages::new(self)
+    }
+
+    /// Wraps `self` so that when fields are formatted to a writer, they are
+    /// separated by the provided `delimiter`.
+    fn delimited<D>(self, delimiter: D) -> delimited::Delimited<D, Self>
+    where
+        D: AsRef<str> + Clone,
+        Self::Visitor: VisitFmt,
+    {
+        delimited::Delimited::new(delimiter, self)
+    }
+}
+
+// === impl RecordFields ===
+
+impl<'a> crate::sealed::Sealed<RecordFieldsMarker> for Event<'a> {}
+impl<'a> RecordFields for Event<'a> {
+    fn record(&self, visitor: &mut dyn Visit) {
+        Event::record(self, visitor)
+    }
+}
+
+impl<'a> crate::sealed::Sealed<RecordFieldsMarker> for Attributes<'a> {}
+impl<'a> RecordFields for Attributes<'a> {
+    fn record(&self, visitor: &mut dyn Visit) {
+        Attributes::record(self, visitor)
+    }
+}
+
+impl<'a> crate::sealed::Sealed<RecordFieldsMarker> for Record<'a> {}
+impl<'a> RecordFields for Record<'a> {
+    fn record(&self, visitor: &mut dyn Visit) {
+        Record::record(self, visitor)
+    }
+}
+
+impl<'a, F> crate::sealed::Sealed<RecordFieldsMarker> for &'a F where F: RecordFields {}
+impl<'a, F> RecordFields for &'a F
+where
+    F: RecordFields,
+{
+    fn record(&self, visitor: &mut dyn Visit) {
+        F::record(*self, visitor)
+    }
+}
+
+// === blanket impls ===
+
+impl<T, V, F> MakeVisitor<T> for F
+where
+    F: Fn(T) -> V,
+    V: Visit,
+{
+    type Visitor = V;
+    fn make_visitor(&self, target: T) -> Self::Visitor {
+        (self)(target)
+    }
+}
+
+impl<T, Out, M> crate::sealed::Sealed<(T, Out)> for M
+where
+    M: MakeVisitor<T>,
+    M::Visitor: VisitOutput<Out>,
+{
+}
+
+impl<T, Out, M> MakeOutput<T, Out> for M
+where
+    M: MakeVisitor<T>,
+    M::Visitor: VisitOutput<Out>,
+{
+}
+
+impl<T, M> crate::sealed::Sealed<MakeExtMarker<T>> for M where M: MakeVisitor<T> + Sized {}
+
+impl<T, M> MakeExt<T> for M
+where
+    M: MakeVisitor<T> + Sized,
+    M: crate::sealed::Sealed<MakeExtMarker<T>>,
+{
+}
+
+#[derive(Debug)]
+#[doc(hidden)]
+pub struct MakeExtMarker<T> {
+    _p: PhantomData<T>,
+}
+
+#[derive(Debug)]
+#[doc(hidden)]
+pub struct RecordFieldsMarker {
+    _p: (),
+}
+
+#[cfg(all(test, feature = "alloc"))]
+#[macro_use]
+pub(in crate::field) mod test_util {
+    use super::*;
+    pub(in crate::field) use alloc::string::String;
+    use tracing_core::{
+        callsite::Callsite,
+        field::{Field, Value},
+        metadata::{Kind, Level, Metadata},
+    };
+
+    pub(crate) struct TestAttrs1;
+    pub(crate) struct TestAttrs2;
+
+    impl TestAttrs1 {
+        pub(crate) fn with<T>(f: impl FnOnce(Attributes<'_>) -> T) -> T {
+            let fieldset = TEST_META_1.fields();
+            let values = &[
+                (
+                    &fieldset.field("question").unwrap(),
+                    Some(&"life, the universe, and everything" as &dyn Value),
+                ),
+                (&fieldset.field("question.answer").unwrap(), None),
+                (
+                    &fieldset.field("tricky").unwrap(),
+                    Some(&true as &dyn Value),
+                ),
+                (
+                    &fieldset.field("can_you_do_it").unwrap(),
+                    Some(&true as &dyn Value),
+                ),
+            ];
+            let valueset = fieldset.value_set(values);
+            let attrs = tracing_core::span::Attributes::new(&TEST_META_1, &valueset);
+            f(attrs)
+        }
+    }
+
+    impl TestAttrs2 {
+        pub(crate) fn with<T>(f: impl FnOnce(Attributes<'_>) -> T) -> T {
+            let fieldset = TEST_META_1.fields();
+            let none = tracing_core::field::debug(&Option::<&str>::None);
+            let values = &[
+                (
+                    &fieldset.field("question").unwrap(),
+                    Some(&none as &dyn Value),
+                ),
+                (
+                    &fieldset.field("question.answer").unwrap(),
+                    Some(&42 as &dyn Value),
+                ),
+                (
+                    &fieldset.field("tricky").unwrap(),
+                    Some(&true as &dyn Value),
+                ),
+                (
+                    &fieldset.field("can_you_do_it").unwrap(),
+                    Some(&false as &dyn Value),
+                ),
+            ];
+            let valueset = fieldset.value_set(values);
+            let attrs = tracing_core::span::Attributes::new(&TEST_META_1, &valueset);
+            f(attrs)
+        }
+    }
+
+    struct TestCallsite1;
+    static TEST_CALLSITE_1: &'static dyn Callsite = &TestCallsite1;
+    static TEST_META_1: Metadata<'static> = tracing_core::metadata! {
+        name: "field_test1",
+        target: module_path!(),
+        level: Level::INFO,
+        fields: &["question", "question.answer", "tricky", "can_you_do_it"],
+        callsite: TEST_CALLSITE_1,
+        kind: Kind::SPAN,
+    };
+
+    impl Callsite for TestCallsite1 {
+        fn set_interest(&self, _: tracing_core::subscriber::Interest) {
+            unimplemented!()
+        }
+
+        fn metadata(&self) -> &Metadata<'_> {
+            &TEST_META_1
+        }
+    }
+
+    pub(crate) struct MakeDebug;
+    pub(crate) struct DebugVisitor<'a> {
+        writer: &'a mut dyn fmt::Write,
+        err: fmt::Result,
+    }
+
+    impl<'a> DebugVisitor<'a> {
+        pub(crate) fn new(writer: &'a mut dyn fmt::Write) -> Self {
+            Self {
+                writer,
+                err: Ok(()),
+            }
+        }
+    }
+
+    impl<'a> Visit for DebugVisitor<'a> {
+        fn record_debug(&mut self, field: &Field, value: &dyn fmt::Debug) {
+            write!(&mut self.writer, "{}={:?}", field, value).unwrap();
+        }
+    }
+
+    impl<'a> VisitOutput<fmt::Result> for DebugVisitor<'a> {
+        fn finish(self) -> fmt::Result {
+            self.err
+        }
+    }
+
+    impl<'a> VisitFmt for DebugVisitor<'a> {
+        fn writer(&mut self) -> &mut dyn fmt::Write {
+            self.writer
+        }
+    }
+
+    impl<'a> MakeVisitor<&'a mut dyn fmt::Write> for MakeDebug {
+        type Visitor = DebugVisitor<'a>;
+        fn make_visitor(&self, w: &'a mut dyn fmt::Write) -> DebugVisitor<'a> {
+            DebugVisitor::new(w)
+        }
+    }
+}
diff --git a/vendor/tracing-subscriber-0.3.3/src/filter/directive.rs b/vendor/tracing-subscriber-0.3.3/src/filter/directive.rs
new file mode 100644
index 000000000..dd6b063c4
--- /dev/null
+++ b/vendor/tracing-subscriber-0.3.3/src/filter/directive.rs
@@ -0,0 +1,424 @@
+use crate::filter::level::{self, LevelFilter};
+#[cfg(not(feature = "smallvec"))]
+use alloc::vec;
+#[cfg(not(feature = "std"))]
+use alloc::{string::String, vec::Vec};
+
+use core::{cmp::Ordering, fmt, iter::FromIterator, slice, str::FromStr};
+use tracing_core::Metadata;
+/// Indicates that a string could not be parsed as a filtering directive.
+#[derive(Debug)]
+pub struct ParseError {
+    kind: ParseErrorKind,
+}
+
+/// A directive which will statically enable or disable a given callsite.
+///
+/// Unlike a dynamic directive, this can be cached by the callsite.
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub(crate) struct StaticDirective {
+    pub(in crate::filter) target: Option<String>,
+    pub(in crate::filter) field_names: Vec<String>,
+    pub(in crate::filter) level: LevelFilter,
+}
+
+#[cfg(feature = "smallvec")]
+pub(crate) type FilterVec<T> = smallvec::SmallVec<[T; 8]>;
+#[cfg(not(feature = "smallvec"))]
+pub(crate) type FilterVec<T> = Vec<T>;
+
+#[derive(Debug, PartialEq, Clone)]
+pub(in crate::filter) struct DirectiveSet<T> {
+    directives: FilterVec<T>,
+    pub(in crate::filter) max_level: LevelFilter,
+}
+
+pub(in crate::filter) trait Match {
+    fn cares_about(&self, meta: &Metadata<'_>) -> bool;
+    fn level(&self) -> &LevelFilter;
+}
+
+#[derive(Debug)]
+enum ParseErrorKind {
+    #[cfg(feature = "std")]
+    Field(Box<dyn std::error::Error + Send + Sync>),
+    Level(level::ParseError),
+    Other(Option<&'static str>),
+}
+
+// === impl DirectiveSet ===
+
+impl<T> DirectiveSet<T> {
+    #[cfg(feature = "env-filter")]
+    pub(crate) fn is_empty(&self) -> bool {
+        self.directives.is_empty()
+    }
+
+    pub(crate) fn iter(&self) -> slice::Iter<'_, T> {
+        self.directives.iter()
+    }
+}
+
+impl<T: Ord> Default for DirectiveSet<T> {
+    fn default() -> Self {
+        Self {
+            directives: FilterVec::new(),
+            max_level: LevelFilter::OFF,
+        }
+    }
+}
+
+impl<T: Match + Ord> DirectiveSet<T> {
+    pub(crate) fn directives(&self) -> impl Iterator<Item = &T> {
+        self.directives.iter()
+    }
+
+    pub(crate) fn directives_for<'a>(
+        &'a self,
+        metadata: &'a Metadata<'a>,
+    ) -> impl Iterator<Item = &'a T> + 'a {
+        self.directives().filter(move |d| d.cares_about(metadata))
+    }
+
+    pub(crate) fn add(&mut self, directive: T) {
+        // does this directive enable a more verbose level than the current
+        // max? if so, update the max level.
+        let level = *directive.level();
+        if level > self.max_level {
+            self.max_level = level;
+        }
+        // insert the directive into the vec of directives, ordered by
+        // specificity (length of target + number of field filters). this
+        // ensures that, when finding a directive to match a span or event, we
+        // search the directive set in most specific first order.
+        match self.directives.binary_search(&directive) {
+            Ok(i) => self.directives[i] = directive,
+            Err(i) => self.directives.insert(i, directive),
+        }
+    }
+
+    #[cfg(test)]
+    pub(in crate::filter) fn into_vec(self) -> FilterVec<T> {
+        self.directives
+    }
+}
+
+impl<T: Match + Ord> FromIterator<T> for DirectiveSet<T> {
+    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
+        let mut this = Self::default();
+        this.extend(iter);
+        this
+    }
+}
+
+impl<T: Match + Ord> Extend<T> for DirectiveSet<T> {
+    fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
+        for directive in iter.into_iter() {
+            self.add(directive);
+        }
+    }
+}
+
+impl<T> IntoIterator for DirectiveSet<T> {
+    type Item = T;
+
+    #[cfg(feature = "smallvec")]
+    type IntoIter = smallvec::IntoIter<[T; 8]>;
+    #[cfg(not(feature = "smallvec"))]
+    type IntoIter = vec::IntoIter<T>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.directives.into_iter()
+    }
+}
+
+// === impl Statics ===
+
+impl DirectiveSet<StaticDirective> {
+    pub(crate) fn enabled(&self, meta: &Metadata<'_>) -> bool {
+        let level = meta.level();
+        match self.directives_for(meta).next() {
+            Some(d) => d.level >= *level,
+            None => false,
+        }
+    }
+}
+
+// === impl StaticDirective ===
+
+impl StaticDirective {
+    pub(in crate::filter) fn new(
+        target: Option<String>,
+        field_names: Vec<String>,
+        level: LevelFilter,
+    ) -> Self {
+        Self {
+            target,
+            field_names,
+            level,
+        }
+    }
+}
+
+impl Ord for StaticDirective {
+    fn cmp(&self, other: &StaticDirective) -> Ordering {
+        // We attempt to order directives by how "specific" they are. This
+        // ensures that we try the most specific directives first when
+        // attempting to match a piece of metadata.
+
+        // First, we compare based on whether a target is specified, and the
+        // lengths of those targets if both have targets.
+        let ordering = self
+            .target
+            .as_ref()
+            .map(String::len)
+            .cmp(&other.target.as_ref().map(String::len))
+            // Then we compare how many field names are matched by each directive.
+            .then_with(|| self.field_names.len().cmp(&other.field_names.len()))
+            // Finally, we fall back to lexicographical ordering if the directives are
+            // equally specific. Although this is no longer semantically important,
+            // we need to define a total ordering to determine the directive's place
+            // in the BTreeMap.
+            .then_with(|| {
+                self.target
+                    .cmp(&other.target)
+                    .then_with(|| self.field_names[..].cmp(&other.field_names[..]))
+            })
+            .reverse();
+
+        #[cfg(debug_assertions)]
+        {
+            if ordering == Ordering::Equal {
+                debug_assert_eq!(
+                    self.target, other.target,
+                    "invariant violated: Ordering::Equal must imply a.target == b.target"
+                );
+                debug_assert_eq!(
+                    self.field_names, other.field_names,
+                    "invariant violated: Ordering::Equal must imply a.field_names == b.field_names"
+                );
+            }
+        }
+
+        ordering
+    }
+}
+
+impl PartialOrd for StaticDirective {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Match for StaticDirective {
+    fn cares_about(&self, meta: &Metadata<'_>) -> bool {
+        // Does this directive have a target filter, and does it match the
+        // metadata's target?
+        if let Some(ref target) = self.target {
+            if !meta.target().starts_with(&target[..]) {
+                return false;
+            }
+        }
+
+        if meta.is_event() && !self.field_names.is_empty() {
+            let fields = meta.fields();
+            for name in &self.field_names {
+                if fields.field(name).is_none() {
+                    return false;
+                }
+            }
+        }
+
+        true
+    }
+
+    fn level(&self) -> &LevelFilter {
+        &self.level
+    }
+}
+
+impl Default for StaticDirective {
+    fn default() -> Self {
+        StaticDirective {
+            target: None,
+            field_names: Vec::new(),
+            level: LevelFilter::ERROR,
+        }
+    }
+}
+
+impl fmt::Display for StaticDirective {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let mut wrote_any = false;
+        if let Some(ref target) = self.target {
+            fmt::Display::fmt(target, f)?;
+            wrote_any = true;
+        }
+
+        if !self.field_names.is_empty() {
+            f.write_str("[")?;
+
+            let mut fields = self.field_names.iter();
+            if let Some(field) = fields.next() {
+                write!(f, "{{{}", field)?;
+                for field in fields {
+                    write!(f, ",{}", field)?;
+                }
+                f.write_str("}")?;
+            }
+
+            f.write_str("]")?;
+            wrote_any = true;
+        }
+
+        if wrote_any {
+            f.write_str("=")?;
+        }
+
+        fmt::Display::fmt(&self.level, f)
+    }
+}
+
+impl FromStr for StaticDirective {
+    type Err = ParseError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        // This method parses a filtering directive in one of the following
+        // forms:
+        //
+        // * `foo=trace` (TARGET=LEVEL)
+        // * `foo[{bar,baz}]=info` (TARGET[{FIELD,+}]=LEVEL)
+        // * `trace` (bare LEVEL)
+        // * `foo` (bare TARGET)
+        let mut split = s.split('=');
+        let part0 = split
+            .next()
+            .ok_or_else(|| ParseError::msg("string must not be empty"))?;
+
+        // Directive includes an `=`:
+        // * `foo=trace`
+        // * `foo[{bar}]=trace`
+        // * `foo[{bar,baz}]=trace`
+        if let Some(part1) = split.next() {
+            if split.next().is_some() {
+                return Err(ParseError::msg(
+                    "too many '=' in filter directive, expected 0 or 1",
+                ));
+            }
+
+            let mut split = part0.split("[{");
+            let target = split.next().map(String::from);
+            let mut field_names = Vec::new();
+            // Directive includes fields:
+            // * `foo[{bar}]=trace`
+            // * `foo[{bar,baz}]=trace`
+            if let Some(maybe_fields) = split.next() {
+                if split.next().is_some() {
+                    return Err(ParseError::msg(
+                        "too many '[{' in filter directive, expected 0 or 1",
+                    ));
+                }
+
+                if !maybe_fields.ends_with("}]") {
+                    return Err(ParseError::msg("expected fields list to end with '}]'"));
+                }
+
+                let fields = maybe_fields
+                    .trim_end_matches("}]")
+                    .split(',')
+                    .filter_map(|s| {
+                        if s.is_empty() {
+                            None
+                        } else {
+                            Some(String::from(s))
+                        }
+                    });
+                field_names.extend(fields);
+            };
+            let level = part1.parse()?;
+            return Ok(Self {
+                level,
+                field_names,
+                target,
+            });
+        }
+
+        // Okay, the part after the `=` was empty, the directive is either a
+        // bare level or a bare target.
+        // * `foo`
+        // * `info`
+        Ok(match part0.parse::<LevelFilter>() {
+            Ok(level) => Self {
+                level,
+                target: None,
+                field_names: Vec::new(),
+            },
+            Err(_) => Self {
+                target: Some(String::from(part0)),
+                level: LevelFilter::TRACE,
+                field_names: Vec::new(),
+            },
+        })
+    }
+}
+
+// === impl ParseError ===
+
+impl ParseError {
+    #[cfg(feature = "env-filter")]
+    pub(crate) fn new() -> Self {
+        ParseError {
+            kind: ParseErrorKind::Other(None),
+        }
+    }
+
+    pub(crate) fn msg(s: &'static str) -> Self {
+        ParseError {
+            kind: ParseErrorKind::Other(Some(s)),
+        }
+    }
+}
+
+impl fmt::Display for ParseError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self.kind {
+            ParseErrorKind::Other(None) => f.pad("invalid filter directive"),
+            ParseErrorKind::Other(Some(msg)) => write!(f, "invalid filter directive: {}", msg),
+            ParseErrorKind::Level(ref l) => l.fmt(f),
+            #[cfg(feature = "std")]
+            ParseErrorKind::Field(ref e) => write!(f, "invalid field filter: {}", e),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for ParseError {
+    fn description(&self) -> &str {
+        "invalid filter directive"
+    }
+
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match self.kind {
+            ParseErrorKind::Other(_) => None,
+            ParseErrorKind::Level(ref l) => Some(l),
+            ParseErrorKind::Field(ref n) => Some(n.as_ref()),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl From<Box<dyn std::error::Error + Send + Sync>> for ParseError {
+    fn from(e: Box<dyn std::error::Error + Send + Sync>) -> Self {
+        Self {
+            kind: ParseErrorKind::Field(e),
+        }
+    }
+}
+
+impl From<level::ParseError> for ParseError {
+    fn from(l: level::ParseError) -> Self {
+        Self {
+            kind: ParseErrorKind::Level(l),
+        }
+    }
+}
diff --git a/vendor/tracing-subscriber-0.3.3/src/filter/env/directive.rs b/vendor/tracing-subscriber-0.3.3/src/filter/env/directive.rs
new file mode 100644
index 000000000..66ca23dc4
--- /dev/null
+++ b/vendor/tracing-subscriber-0.3.3/src/filter/env/directive.rs
@@ -0,0 +1,846 @@
+pub(crate) use crate::filter::directive::{FilterVec, ParseError, StaticDirective};
+use crate::filter::{
+    directive::{DirectiveSet, Match},
+    env::{field, FieldMap},
+    level::LevelFilter,
+};
+use lazy_static::lazy_static;
+use regex::Regex;
+use std::{cmp::Ordering, fmt, iter::FromIterator, str::FromStr};
+use tracing_core::{span, Level, Metadata};
+
+/// A single filtering directive.
+// TODO(eliza): add a builder for programmatically constructing directives?
+#[derive(Debug, Eq, PartialEq)]
+#[cfg_attr(docsrs, doc(cfg(feature = "env-filter")))]
+pub struct Directive {
+    in_span: Option<String>,
+    fields: Vec<field::Match>,
+    pub(crate) target: Option<String>,
+    pub(crate) level: LevelFilter,
+}
+
+/// A set of dynamic filtering directives.
+pub(super) type Dynamics = DirectiveSet<Directive>;
+
+/// A set of static filtering directives.
+pub(super) type Statics = DirectiveSet<StaticDirective>;
+
+pub(crate) type CallsiteMatcher = MatchSet<field::CallsiteMatch>;
+pub(crate) type SpanMatcher = MatchSet<field::SpanMatch>;
+
+#[derive(Debug, PartialEq, Eq)]
+pub(crate) struct MatchSet<T> {
+    field_matches: FilterVec<T>,
+    base_level: LevelFilter,
+}
+
+impl Directive {
+    pub(super) fn has_name(&self) -> bool {
+        self.in_span.is_some()
+    }
+
+    pub(super) fn has_fields(&self) -> bool {
+        !self.fields.is_empty()
+    }
+
+    pub(super) fn to_static(&self) -> Option<StaticDirective> {
+        if !self.is_static() {
+            return None;
+        }
+
+        // TODO(eliza): these strings are all immutable; we should consider
+        // `Arc`ing them to make this more efficient...
+        let field_names = self.fields.iter().map(field::Match::name).collect();
+
+        Some(StaticDirective::new(
+            self.target.clone(),
+            field_names,
+            self.level,
+        ))
+    }
+
+    fn is_static(&self) -> bool {
+        !self.has_name() && !self.fields.iter().any(field::Match::has_value)
+    }
+
+    pub(super) fn is_dynamic(&self) -> bool {
+        self.has_name() || self.has_fields()
+    }
+
+    pub(crate) fn field_matcher(&self, meta: &Metadata<'_>) -> Option<field::CallsiteMatch> {
+        let fieldset = meta.fields();
+        let fields = self
+            .fields
+            .iter()
+            .filter_map(
+                |field::Match {
+                     ref name,
+                     ref value,
+                 }| {
+                    if let Some(field) = fieldset.field(name) {
+                        let value = value.as_ref().cloned()?;
+                        Some(Ok((field, value)))
+                    } else {
+                        Some(Err(()))
+                    }
+                },
+            )
+            .collect::<Result<FieldMap<_>, ()>>()
+            .ok()?;
+        Some(field::CallsiteMatch {
+            fields,
+            level: self.level,
+        })
+    }
+
+    pub(super) fn make_tables(
+        directives: impl IntoIterator<Item = Directive>,
+    ) -> (Dynamics, Statics) {
+        // TODO(eliza): this could be made more efficient...
+        let (dyns, stats): (Vec<Directive>, Vec<Directive>) =
+            directives.into_iter().partition(Directive::is_dynamic);
+        let statics = stats
+            .into_iter()
+            .filter_map(|d| d.to_static())
+            .chain(dyns.iter().filter_map(Directive::to_static))
+            .collect();
+        (Dynamics::from_iter(dyns), statics)
+    }
+}
+
+impl Match for Directive {
+    fn cares_about(&self, meta: &Metadata<'_>) -> bool {
+        // Does this directive have a target filter, and does it match the
+        // metadata's target?
+        if let Some(ref target) = self.target {
+            if !meta.target().starts_with(&target[..]) {
+                return false;
+            }
+        }
+
+        // Do we have a name filter, and does it match the metadata's name?
+        // TODO(eliza): put name globbing here?
+        if let Some(ref name) = self.in_span {
+            if name != meta.name() {
+                return false;
+            }
+        }
+
+        // Does the metadata define all the fields that this directive cares about?
+        let fields = meta.fields();
+        for field in &self.fields {
+            if fields.field(&field.name).is_none() {
+                return false;
+            }
+        }
+
+        true
+    }
+
+    fn level(&self) -> &LevelFilter {
+        &self.level
+    }
+}
+
+impl FromStr for Directive {
+    type Err = ParseError;
+    fn from_str(from: &str) -> Result<Self, Self::Err> {
+        lazy_static! {
+            static ref DIRECTIVE_RE: Regex = Regex::new(
+                r"(?x)
+                ^(?P<global_level>(?i:trace|debug|info|warn|error|off|[0-5]))$ |
+                 #                 ^^^.
+                 #                     `note: we match log level names case-insensitively
+                ^
+                (?: # target name or span name
+                    (?P<target>[\w:-]+)|(?P<span>\[[^\]]*\])
+                ){1,2}
+                (?: # level or nothing
+                    =(?P<level>(?i:trace|debug|info|warn|error|off|[0-5]))?
+                     #          ^^^.
+                     #              `note: we match log level names case-insensitively
+                )?
+                $
+                "
+            )
+            .unwrap();
+            static ref SPAN_PART_RE: Regex =
+                Regex::new(r#"(?P<name>[^\]\{]+)?(?:\{(?P<fields>[^\}]*)\})?"#).unwrap();
+            static ref FIELD_FILTER_RE: Regex =
+                // TODO(eliza): this doesn't _currently_ handle value matchers that include comma
+                // characters. We should fix that.
+                Regex::new(r#"(?x)
+                    (
+                        # field name
+                        [[:word:]][[[:word:]]\.]*
+                        # value part (optional)
+                        (?:=[^,]+)?
+                    )
+                    # trailing comma or EOS
+                    (?:,\s?|$)
+                "#).unwrap();
+        }
+
+        let caps = DIRECTIVE_RE.captures(from).ok_or_else(ParseError::new)?;
+
+        if let Some(level) = caps
+            .name("global_level")
+            .and_then(|s| s.as_str().parse().ok())
+        {
+            return Ok(Directive {
+                level,
+                ..Default::default()
+            });
+        }
+
+        let target = caps.name("target").and_then(|c| {
+            let s = c.as_str();
+            if s.parse::<LevelFilter>().is_ok() {
+                None
+            } else {
+                Some(s.to_owned())
+            }
+        });
+
+        let (in_span, fields) = caps
+            .name("span")
+            .and_then(|cap| {
+                let cap = cap.as_str().trim_matches(|c| c == '[' || c == ']');
+                let caps = SPAN_PART_RE.captures(cap)?;
+                let span = caps.name("name").map(|c| c.as_str().to_owned());
+                let fields = caps
+                    .name("fields")
+                    .map(|c| {
+                        FIELD_FILTER_RE
+                            .find_iter(c.as_str())
+                            .map(|c| c.as_str().parse())
+                            .collect::<Result<Vec<_>, _>>()
+                    })
+                    .unwrap_or_else(|| Ok(Vec::new()));
+                Some((span, fields))
+            })
+            .unwrap_or_else(|| (None, Ok(Vec::new())));
+
+        let level = caps
+            .name("level")
+            .and_then(|l| l.as_str().parse().ok())
+            // Setting the target without the level enables every level for that target
+            .unwrap_or(LevelFilter::TRACE);
+
+        Ok(Directive {
+            level,
+            target,
+            in_span,
+            fields: fields?,
+        })
+    }
+}
+
+impl Default for Directive {
+    fn default() -> Self {
+        Directive {
+            level: LevelFilter::OFF,
+            target: None,
+            in_span: None,
+            fields: Vec::new(),
+        }
+    }
+}
+
+impl PartialOrd for Directive {
+    fn partial_cmp(&self, other: &Directive) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for Directive {
+    fn cmp(&self, other: &Directive) -> Ordering {
+        // We attempt to order directives by how "specific" they are. This
+        // ensures that we try the most specific directives first when
+        // attempting to match a piece of metadata.
+
+        // First, we compare based on whether a target is specified, and the
+        // lengths of those targets if both have targets.
+        let ordering = self
+            .target
+            .as_ref()
+            .map(String::len)
+            .cmp(&other.target.as_ref().map(String::len))
+            // Next compare based on the presence of span names.
+            .then_with(|| self.in_span.is_some().cmp(&other.in_span.is_some()))
+            // Then we compare how many fields are defined by each
+            // directive.
+            .then_with(|| self.fields.len().cmp(&other.fields.len()))
+            // Finally, we fall back to lexicographical ordering if the directives are
+            // equally specific. Although this is no longer semantically important,
+            // we need to define a total ordering to determine the directive's place
+            // in the BTreeMap.
+            .then_with(|| {
+                self.target
+                    .cmp(&other.target)
+                    .then_with(|| self.in_span.cmp(&other.in_span))
+                    .then_with(|| self.fields[..].cmp(&other.fields[..]))
+            })
+            .reverse();
+
+        #[cfg(debug_assertions)]
+        {
+            if ordering == Ordering::Equal {
+                debug_assert_eq!(
+                    self.target, other.target,
+                    "invariant violated: Ordering::Equal must imply a.target == b.target"
+                );
+                debug_assert_eq!(
+                    self.in_span, other.in_span,
+                    "invariant violated: Ordering::Equal must imply a.in_span == b.in_span"
+                );
+                debug_assert_eq!(
+                    self.fields, other.fields,
+                    "invariant violated: Ordering::Equal must imply a.fields == b.fields"
+                );
+            }
+        }
+
+        ordering
+    }
+}
+
+impl fmt::Display for Directive {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let mut wrote_any = false;
+        if let Some(ref target) = self.target {
+            fmt::Display::fmt(target, f)?;
+            wrote_any = true;
+        }
+
+        if self.in_span.is_some() || !self.fields.is_empty() {
+            f.write_str("[")?;
+
+            if let Some(ref span) = self.in_span {
+                fmt::Display::fmt(span, f)?;
+            }
+
+            let mut fields = self.fields.iter();
+            if let Some(field) = fields.next() {
+                write!(f, "{{{}", field)?;
+                for field in fields {
+                    write!(f, ",{}", field)?;
+                }
+                f.write_str("}")?;
+            }
+
+            f.write_str("]")?;
+            wrote_any = true;
+        }
+
+        if wrote_any {
+            f.write_str("=")?;
+        }
+
+        fmt::Display::fmt(&self.level, f)
+    }
+}
+
+impl From<LevelFilter> for Directive {
+    fn from(level: LevelFilter) -> Self {
+        Self {
+            level,
+            ..Self::default()
+        }
+    }
+}
+
+impl From<Level> for Directive {
+    fn from(level: Level) -> Self {
+        LevelFilter::from_level(level).into()
+    }
+}
+
+// === impl Dynamics ===
+
+impl Dynamics {
+    pub(crate) fn matcher(&self, metadata: &Metadata<'_>) -> Option<CallsiteMatcher> {
+        let mut base_level = None;
+        let field_matches = self
+            .directives_for(metadata)
+            .filter_map(|d| {
+                if let Some(f) = d.field_matcher(metadata) {
+                    return Some(f);
+                }
+                match base_level {
+                    Some(ref b) if d.level > *b => base_level = Some(d.level),
+                    None => base_level = Some(d.level),
+                    _ => {}
+                }
+                None
+            })
+            .collect();
+
+        if let Some(base_level) = base_level {
+            Some(CallsiteMatcher {
+                field_matches,
+                base_level,
+            })
+        } else if !field_matches.is_empty() {
+            Some(CallsiteMatcher {
+                field_matches,
+                base_level: base_level.unwrap_or(LevelFilter::OFF),
+            })
+        } else {
+            None
+        }
+    }
+
+    pub(crate) fn has_value_filters(&self) -> bool {
+        self.directives()
+            .any(|d| d.fields.iter().any(|f| f.value.is_some()))
+    }
+}
+
+// ===== impl DynamicMatch =====
+
+impl CallsiteMatcher {
+    /// Create a new `SpanMatch` for a given instance of the matched callsite.
+    pub(crate) fn to_span_match(&self, attrs: &span::Attributes<'_>) -> SpanMatcher {
+        let field_matches = self
+            .field_matches
+            .iter()
+            .map(|m| {
+                let m = m.to_span_match();
+                attrs.record(&mut m.visitor());
+                m
+            })
+            .collect();
+        SpanMatcher {
+            field_matches,
+            base_level: self.base_level,
+        }
+    }
+}
+
+impl SpanMatcher {
+    /// Returns the level currently enabled for this callsite.
+    pub(crate) fn level(&self) -> LevelFilter {
+        self.field_matches
+            .iter()
+            .filter_map(field::SpanMatch::filter)
+            .max()
+            .unwrap_or(self.base_level)
+    }
+
+    pub(crate) fn record_update(&self, record: &span::Record<'_>) {
+        for m in &self.field_matches {
+            record.record(&mut m.visitor())
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    fn parse_directives(dirs: impl AsRef<str>) -> Vec<Directive> {
+        dirs.as_ref()
+            .split(',')
+            .filter_map(|s| s.parse().ok())
+            .collect()
+    }
+
+    fn expect_parse(dirs: impl AsRef<str>) -> Vec<Directive> {
+        dirs.as_ref()
+            .split(',')
+            .map(|s| {
+                s.parse()
+                    .unwrap_or_else(|err| panic!("directive '{:?}' should parse: {}", s, err))
+            })
+            .collect()
+    }
+
+    #[test]
+    fn directive_ordering_by_target_len() {
+        // TODO(eliza): it would be nice to have a property-based test for this
+        // instead.
+        let mut dirs = expect_parse(
+            "foo::bar=debug,foo::bar::baz=trace,foo=info,a_really_long_name_with_no_colons=warn",
+        );
+        dirs.sort_unstable();
+
+        let expected = vec![
+            "a_really_long_name_with_no_colons",
+            "foo::bar::baz",
+            "foo::bar",
+            "foo",
+        ];
+        let sorted = dirs
+            .iter()
+            .map(|d| d.target.as_ref().unwrap())
+            .collect::<Vec<_>>();
+
+        assert_eq!(expected, sorted);
+    }
+    #[test]
+    fn directive_ordering_by_span() {
+        // TODO(eliza): it would be nice to have a property-based test for this
+        // instead.
+        let mut dirs = expect_parse("bar[span]=trace,foo=debug,baz::quux=info,a[span]=warn");
+        dirs.sort_unstable();
+
+        let expected = vec!["baz::quux", "bar", "foo", "a"];
+        let sorted = dirs
+            .iter()
+            .map(|d| d.target.as_ref().unwrap())
+            .collect::<Vec<_>>();
+
+        assert_eq!(expected, sorted);
+    }
+
+    #[test]
+    fn directive_ordering_uses_lexicographic_when_equal() {
+        // TODO(eliza): it would be nice to have a property-based test for this
+        // instead.
+        let mut dirs = expect_parse("span[b]=debug,b=debug,a=trace,c=info,span[a]=info");
+        dirs.sort_unstable();
+
+        let expected = vec![
+            ("span", Some("b")),
+            ("span", Some("a")),
+            ("c", None),
+            ("b", None),
+            ("a", None),
+        ];
+        let sorted = dirs
+            .iter()
+            .map(|d| {
+                (
+                    d.target.as_ref().unwrap().as_ref(),
+                    d.in_span.as_ref().map(String::as_ref),
+                )
+            })
+            .collect::<Vec<_>>();
+
+        assert_eq!(expected, sorted);
+    }
+
+    // TODO: this test requires the parser to support directives with multiple
+    // fields, which it currently can't handle. We should enable this test when
+    // that's implemented.
+    #[test]
+    #[ignore]
+    fn directive_ordering_by_field_num() {
+        // TODO(eliza): it would be nice to have a property-based test for this
+        // instead.
+        let mut dirs = expect_parse(
+            "b[{foo,bar}]=info,c[{baz,quuux,quuux}]=debug,a[{foo}]=warn,bar[{field}]=trace,foo=debug,baz::quux=info"
+        );
+        dirs.sort_unstable();
+
+        let expected = vec!["baz::quux", "bar", "foo", "c", "b", "a"];
+        let sorted = dirs
+            .iter()
+            .map(|d| d.target.as_ref().unwrap())
+            .collect::<Vec<_>>();
+
+        assert_eq!(expected, sorted);
+    }
+
+    #[test]
+    fn parse_directives_ralith() {
+        let dirs = parse_directives("common=trace,server=trace");
+        assert_eq!(dirs.len(), 2, "\nparsed: {:#?}", dirs);
+        assert_eq!(dirs[0].target, Some("common".to_string()));
+        assert_eq!(dirs[0].level, LevelFilter::TRACE);
+        assert_eq!(dirs[0].in_span, None);
+
+        assert_eq!(dirs[1].target, Some("server".to_string()));
+        assert_eq!(dirs[1].level, LevelFilter::TRACE);
+        assert_eq!(dirs[1].in_span, None);
+    }
+
+    #[test]
+    fn parse_directives_ralith_uc() {
+        let dirs = parse_directives("common=INFO,server=DEBUG");
+        assert_eq!(dirs.len(), 2, "\nparsed: {:#?}", dirs);
+        assert_eq!(dirs[0].target, Some("common".to_string()));
+        assert_eq!(dirs[0].level, LevelFilter::INFO);
+        assert_eq!(dirs[0].in_span, None);
+
+        assert_eq!(dirs[1].target, Some("server".to_string()));
+        assert_eq!(dirs[1].level, LevelFilter::DEBUG);
+        assert_eq!(dirs[1].in_span, None);
+    }
+
+    #[test]
+    fn parse_directives_ralith_mixed() {
+        let dirs = parse_directives("common=iNfo,server=dEbUg");
+        assert_eq!(dirs.len(), 2, "\nparsed: {:#?}", dirs);
+        assert_eq!(dirs[0].target, Some("common".to_string()));
+        assert_eq!(dirs[0].level, LevelFilter::INFO);
+        assert_eq!(dirs[0].in_span, None);
+
+        assert_eq!(dirs[1].target, Some("server".to_string()));
+        assert_eq!(dirs[1].level, LevelFilter::DEBUG);
+        assert_eq!(dirs[1].in_span, None);
+    }
+
+    #[test]
+    fn parse_directives_valid() {
+        let dirs = parse_directives("crate1::mod1=error,crate1::mod2,crate2=debug,crate3=off");
+        assert_eq!(dirs.len(), 4, "\nparsed: {:#?}", dirs);
+        assert_eq!(dirs[0].target, Some("crate1::mod1".to_string()));
+        assert_eq!(dirs[0].level, LevelFilter::ERROR);
+        assert_eq!(dirs[0].in_span, None);
+
+        assert_eq!(dirs[1].target, Some("crate1::mod2".to_string()));
+        assert_eq!(dirs[1].level, LevelFilter::TRACE);
+        assert_eq!(dirs[1].in_span, None);
+
+        assert_eq!(dirs[2].target, Some("crate2".to_string()));
+        assert_eq!(dirs[2].level, LevelFilter::DEBUG);
+        assert_eq!(dirs[2].in_span, None);
+
+        assert_eq!(dirs[3].target, Some("crate3".to_string()));
+        assert_eq!(dirs[3].level, LevelFilter::OFF);
+        assert_eq!(dirs[3].in_span, None);
+    }
+
+    #[test]
+
+    fn parse_level_directives() {
+        let dirs = parse_directives(
+            "crate1::mod1=error,crate1::mod2=warn,crate1::mod2::mod3=info,\
+             crate2=debug,crate3=trace,crate3::mod2::mod1=off",
+        );
+        assert_eq!(dirs.len(), 6, "\nparsed: {:#?}", dirs);
+        assert_eq!(dirs[0].target, Some("crate1::mod1".to_string()));
+        assert_eq!(dirs[0].level, LevelFilter::ERROR);
+        assert_eq!(dirs[0].in_span, None);
+
+        assert_eq!(dirs[1].target, Some("crate1::mod2".to_string()));
+        assert_eq!(dirs[1].level, LevelFilter::WARN);
+        assert_eq!(dirs[1].in_span, None);
+
+        assert_eq!(dirs[2].target, Some("crate1::mod2::mod3".to_string()));
+        assert_eq!(dirs[2].level, LevelFilter::INFO);
+        assert_eq!(dirs[2].in_span, None);
+
+        assert_eq!(dirs[3].target, Some("crate2".to_string()));
+        assert_eq!(dirs[3].level, LevelFilter::DEBUG);
+        assert_eq!(dirs[3].in_span, None);
+
+        assert_eq!(dirs[4].target, Some("crate3".to_string()));
+        assert_eq!(dirs[4].level, LevelFilter::TRACE);
+        assert_eq!(dirs[4].in_span, None);
+
+        assert_eq!(dirs[5].target, Some("crate3::mod2::mod1".to_string()));
+        assert_eq!(dirs[5].level, LevelFilter::OFF);
+        assert_eq!(dirs[5].in_span, None);
+    }
+
+    #[test]
+    fn parse_uppercase_level_directives() {
+        let dirs = parse_directives(
+            "crate1::mod1=ERROR,crate1::mod2=WARN,crate1::mod2::mod3=INFO,\
+             crate2=DEBUG,crate3=TRACE,crate3::mod2::mod1=OFF",
+        );
+        assert_eq!(dirs.len(), 6, "\nparsed: {:#?}", dirs);
+        assert_eq!(dirs[0].target, Some("crate1::mod1".to_string()));
+        assert_eq!(dirs[0].level, LevelFilter::ERROR);
+        assert_eq!(dirs[0].in_span, None);
+
+        assert_eq!(dirs[1].target, Some("crate1::mod2".to_string()));
+        assert_eq!(dirs[1].level, LevelFilter::WARN);
+        assert_eq!(dirs[1].in_span, None);
+
+        assert_eq!(dirs[2].target, Some("crate1::mod2::mod3".to_string()));
+        assert_eq!(dirs[2].level, LevelFilter::INFO);
+        assert_eq!(dirs[2].in_span, None);
+
+        assert_eq!(dirs[3].target, Some("crate2".to_string()));
+        assert_eq!(dirs[3].level, LevelFilter::DEBUG);
+        assert_eq!(dirs[3].in_span, None);
+
+        assert_eq!(dirs[4].target, Some("crate3".to_string()));
+        assert_eq!(dirs[4].level, LevelFilter::TRACE);
+        assert_eq!(dirs[4].in_span, None);
+
+        assert_eq!(dirs[5].target, Some("crate3::mod2::mod1".to_string()));
+        assert_eq!(dirs[5].level, LevelFilter::OFF);
+        assert_eq!(dirs[5].in_span, None);
+    }
+
+    #[test]
+    fn parse_numeric_level_directives() {
+        let dirs = parse_directives(
+            "crate1::mod1=1,crate1::mod2=2,crate1::mod2::mod3=3,crate2=4,\
+             crate3=5,crate3::mod2::mod1=0",
+        );
+        assert_eq!(dirs.len(), 6, "\nparsed: {:#?}", dirs);
+        assert_eq!(dirs[0].target, Some("crate1::mod1".to_string()));
+        assert_eq!(dirs[0].level, LevelFilter::ERROR);
+        assert_eq!(dirs[0].in_span, None);
+
+        assert_eq!(dirs[1].target, Some("crate1::mod2".to_string()));
+        assert_eq!(dirs[1].level, LevelFilter::WARN);
+        assert_eq!(dirs[1].in_span, None);
+
+        assert_eq!(dirs[2].target, Some("crate1::mod2::mod3".to_string()));
+        assert_eq!(dirs[2].level, LevelFilter::INFO);
+        assert_eq!(dirs[2].in_span, None);
+
+        assert_eq!(dirs[3].target, Some("crate2".to_string()));
+        assert_eq!(dirs[3].level, LevelFilter::DEBUG);
+        assert_eq!(dirs[3].in_span, None);
+
+        assert_eq!(dirs[4].target, Some("crate3".to_string()));
+        assert_eq!(dirs[4].level, LevelFilter::TRACE);
+        assert_eq!(dirs[4].in_span, None);
+
+        assert_eq!(dirs[5].target, Some("crate3::mod2::mod1".to_string()));
+        assert_eq!(dirs[5].level, LevelFilter::OFF);
+        assert_eq!(dirs[5].in_span, None);
+    }
+
+    #[test]
+    fn parse_directives_invalid_crate() {
+        // test parse_directives with multiple = in specification
+        let dirs = parse_directives("crate1::mod1=warn=info,crate2=debug");
+        assert_eq!(dirs.len(), 1, "\nparsed: {:#?}", dirs);
+        assert_eq!(dirs[0].target, Some("crate2".to_string()));
+        assert_eq!(dirs[0].level, LevelFilter::DEBUG);
+        assert_eq!(dirs[0].in_span, None);
+    }
+
+    #[test]
+    fn parse_directives_invalid_level() {
+        // test parse_directives with 'noNumber' as log level
+        let dirs = parse_directives("crate1::mod1=noNumber,crate2=debug");
+        assert_eq!(dirs.len(), 1, "\nparsed: {:#?}", dirs);
+        assert_eq!(dirs[0].target, Some("crate2".to_string()));
+        assert_eq!(dirs[0].level, LevelFilter::DEBUG);
+        assert_eq!(dirs[0].in_span, None);
+    }
+
+    #[test]
+    fn parse_directives_string_level() {
+        // test parse_directives with 'warn' as log level
+        let dirs = parse_directives("crate1::mod1=wrong,crate2=warn");
+        assert_eq!(dirs.len(), 1, "\nparsed: {:#?}", dirs);
+        assert_eq!(dirs[0].target, Some("crate2".to_string()));
+        assert_eq!(dirs[0].level, LevelFilter::WARN);
+        assert_eq!(dirs[0].in_span, None);
+    }
+
+    #[test]
+    fn parse_directives_empty_level() {
+        // test parse_directives with '' as log level
+        let dirs = parse_directives("crate1::mod1=wrong,crate2=");
+        assert_eq!(dirs.len(), 1, "\nparsed: {:#?}", dirs);
+        assert_eq!(dirs[0].target, Some("crate2".to_string()));
+        assert_eq!(dirs[0].level, LevelFilter::TRACE);
+        assert_eq!(dirs[0].in_span, None);
+    }
+
+    #[test]
+    fn parse_directives_global() {
+        // test parse_directives with no crate
+        let dirs = parse_directives("warn,crate2=debug");
+        assert_eq!(dirs.len(), 2, "\nparsed: {:#?}", dirs);
+        assert_eq!(dirs[0].target, None);
+        assert_eq!(dirs[0].level, LevelFilter::WARN);
+        assert_eq!(dirs[1].in_span, None);
+
+        assert_eq!(dirs[1].target, Some("crate2".to_string()));
+        assert_eq!(dirs[1].level, LevelFilter::DEBUG);
+        assert_eq!(dirs[1].in_span, None);
+    }
+
+    // helper function for tests below
+    fn test_parse_bare_level(directive_to_test: &str, level_expected: LevelFilter) {
+        let dirs = parse_directives(directive_to_test);
+        assert_eq!(
+            dirs.len(),
+            1,
+            "\ninput: \"{}\"; parsed: {:#?}",
+            directive_to_test,
+            dirs
+        );
+        assert_eq!(dirs[0].target, None);
+        assert_eq!(dirs[0].level, level_expected);
+        assert_eq!(dirs[0].in_span, None);
+    }
+
+    #[test]
+    fn parse_directives_global_bare_warn_lc() {
+        // test parse_directives with no crate, in isolation, all lowercase
+        test_parse_bare_level("warn", LevelFilter::WARN);
+    }
+
+    #[test]
+    fn parse_directives_global_bare_warn_uc() {
+        // test parse_directives with no crate, in isolation, all uppercase
+        test_parse_bare_level("WARN", LevelFilter::WARN);
+    }
+
+    #[test]
+    fn parse_directives_global_bare_warn_mixed() {
+        // test parse_directives with no crate, in isolation, mixed case
+        test_parse_bare_level("wArN", LevelFilter::WARN);
+    }
+
+    #[test]
+    fn parse_directives_valid_with_spans() {
+        let dirs = parse_directives("crate1::mod1[foo]=error,crate1::mod2[bar],crate2[baz]=debug");
+        assert_eq!(dirs.len(), 3, "\nparsed: {:#?}", dirs);
+        assert_eq!(dirs[0].target, Some("crate1::mod1".to_string()));
+        assert_eq!(dirs[0].level, LevelFilter::ERROR);
+        assert_eq!(dirs[0].in_span, Some("foo".to_string()));
+
+        assert_eq!(dirs[1].target, Some("crate1::mod2".to_string()));
+        assert_eq!(dirs[1].level, LevelFilter::TRACE);
+        assert_eq!(dirs[1].in_span, Some("bar".to_string()));
+
+        assert_eq!(dirs[2].target, Some("crate2".to_string()));
+        assert_eq!(dirs[2].level, LevelFilter::DEBUG);
+        assert_eq!(dirs[2].in_span, Some("baz".to_string()));
+    }
+
+    #[test]
+    fn parse_directives_with_dash_in_target_name() {
+        let dirs = parse_directives("target-name=info");
+        assert_eq!(dirs.len(), 1, "\nparsed: {:#?}", dirs);
+        assert_eq!(dirs[0].target, Some("target-name".to_string()));
+        assert_eq!(dirs[0].level, LevelFilter::INFO);
+        assert_eq!(dirs[0].in_span, None);
+    }
+
+    #[test]
+    fn parse_directives_with_dash_in_span_name() {
+        // Reproduces https://github.com/tokio-rs/tracing/issues/1367
+
+        let dirs = parse_directives("target[span-name]=info");
+        assert_eq!(dirs.len(), 1, "\nparsed: {:#?}", dirs);
+        assert_eq!(dirs[0].target, Some("target".to_string()));
+        assert_eq!(dirs[0].level, LevelFilter::INFO);
+        assert_eq!(dirs[0].in_span, Some("span-name".to_string()));
+    }
+
+    #[test]
+    fn parse_directives_with_special_characters_in_span_name() {
+        let span_name = "!\"#$%&'()*+-./:;<=>?@^_`|~[}";
+
+        let dirs = parse_directives(format!("target[{}]=info", span_name));
+        assert_eq!(dirs.len(), 1, "\nparsed: {:#?}", dirs);
+        assert_eq!(dirs[0].target, Some("target".to_string()));
+        assert_eq!(dirs[0].level, LevelFilter::INFO);
+        assert_eq!(dirs[0].in_span, Some(span_name.to_string()));
+    }
+
+    #[test]
+    fn parse_directives_with_invalid_span_chars() {
+        let invalid_span_name = "]{";
+
+        let dirs = parse_directives(format!("target[{}]=info", invalid_span_name));
+        assert_eq!(dirs.len(), 0, "\nparsed: {:#?}", dirs);
+    }
+}
diff --git a/vendor/tracing-subscriber-0.3.3/src/filter/env/field.rs b/vendor/tracing-subscriber-0.3.3/src/filter/env/field.rs
new file mode 100644
index 000000000..970850f92
--- /dev/null
+++ b/vendor/tracing-subscriber-0.3.3/src/filter/env/field.rs
@@ -0,0 +1,416 @@
+use matchers::Pattern;
+use std::{
+    cmp::Ordering,
+    error::Error,
+    fmt,
+    str::FromStr,
+    sync::{
+        atomic::{AtomicBool, Ordering::*},
+        Arc,
+    },
+};
+
+use super::{FieldMap, LevelFilter};
+use tracing_core::field::{Field, Visit};
+
+#[derive(Debug, Eq, PartialEq)]
+pub(crate) struct Match {
+    pub(crate) name: String, // TODO: allow match patterns for names?
+    pub(crate) value: Option<ValueMatch>,
+}
+
+#[derive(Debug, Eq, PartialEq)]
+pub(crate) struct CallsiteMatch {
+    pub(crate) fields: FieldMap<ValueMatch>,
+    pub(crate) level: LevelFilter,
+}
+
+#[derive(Debug)]
+pub(crate) struct SpanMatch {
+    fields: FieldMap<(ValueMatch, AtomicBool)>,
+    level: LevelFilter,
+    has_matched: AtomicBool,
+}
+
+pub(crate) struct MatchVisitor<'a> {
+    inner: &'a SpanMatch,
+}
+
+#[derive(Debug, Clone)]
+pub(crate) enum ValueMatch {
+    Bool(bool),
+    F64(f64),
+    U64(u64),
+    I64(i64),
+    NaN,
+    Pat(Box<MatchPattern>),
+}
+
+impl Eq for ValueMatch {}
+
+impl PartialEq for ValueMatch {
+    fn eq(&self, other: &Self) -> bool {
+        use ValueMatch::*;
+        match (self, other) {
+            (Bool(a), Bool(b)) => a.eq(b),
+            (F64(a), F64(b)) => {
+                debug_assert!(!a.is_nan());
+                debug_assert!(!b.is_nan());
+
+                a.eq(b)
+            }
+            (U64(a), U64(b)) => a.eq(b),
+            (I64(a), I64(b)) => a.eq(b),
+            (NaN, NaN) => true,
+            (Pat(a), Pat(b)) => a.eq(b),
+            _ => false,
+        }
+    }
+}
+
+impl Ord for ValueMatch {
+    fn cmp(&self, other: &Self) -> Ordering {
+        use ValueMatch::*;
+        match (self, other) {
+            (Bool(this), Bool(that)) => this.cmp(that),
+            (Bool(_), _) => Ordering::Less,
+
+            (F64(this), F64(that)) => this
+                .partial_cmp(that)
+                .expect("`ValueMatch::F64` may not contain `NaN` values"),
+            (F64(_), Bool(_)) => Ordering::Greater,
+            (F64(_), _) => Ordering::Less,
+
+            (NaN, NaN) => Ordering::Equal,
+            (NaN, Bool(_)) | (NaN, F64(_)) => Ordering::Greater,
+            (NaN, _) => Ordering::Less,
+
+            (U64(this), U64(that)) => this.cmp(that),
+            (U64(_), Bool(_)) | (U64(_), F64(_)) | (U64(_), NaN) => Ordering::Greater,
+            (U64(_), _) => Ordering::Less,
+
+            (I64(this), I64(that)) => this.cmp(that),
+            (I64(_), Bool(_)) | (I64(_), F64(_)) | (I64(_), NaN) | (I64(_), U64(_)) => {
+                Ordering::Greater
+            }
+            (I64(_), _) => Ordering::Less,
+
+            (Pat(this), Pat(that)) => this.cmp(that),
+            (Pat(_), _) => Ordering::Greater,
+        }
+    }
+}
+
+impl PartialOrd for ValueMatch {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+#[derive(Debug, Clone)]
+pub(crate) struct MatchPattern {
+    pub(crate) matcher: Pattern,
+    pattern: Arc<str>,
+}
+
+/// Indicates that a field name specified in a filter directive was invalid.
+#[derive(Clone, Debug)]
+#[cfg_attr(docsrs, doc(cfg(feature = "env-filter")))]
+pub struct BadName {
+    name: String,
+}
+
+// === impl Match ===
+
+impl FromStr for Match {
+    type Err = Box<dyn Error + Send + Sync>;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let mut parts = s.split('=');
+        let name = parts
+            .next()
+            .ok_or_else(|| BadName {
+                name: "".to_string(),
+            })?
+            // TODO: validate field name
+            .to_string();
+        let value = parts.next().map(ValueMatch::from_str).transpose()?;
+        Ok(Match { name, value })
+    }
+}
+
+impl Match {
+    pub(crate) fn has_value(&self) -> bool {
+        self.value.is_some()
+    }
+
+    // TODO: reference count these strings?
+    pub(crate) fn name(&self) -> String {
+        self.name.clone()
+    }
+}
+
+impl fmt::Display for Match {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(&self.name, f)?;
+        if let Some(ref value) = self.value {
+            write!(f, "={}", value)?;
+        }
+        Ok(())
+    }
+}
+
+impl Ord for Match {
+    fn cmp(&self, other: &Self) -> Ordering {
+        // Ordering for `Match` directives is based first on _whether_ a value
+        // is matched or not. This is semantically meaningful --- we would
+        // prefer to check directives that match values first as they are more
+        // specific.
+        let has_value = match (self.value.as_ref(), other.value.as_ref()) {
+            (Some(_), None) => Ordering::Greater,
+            (None, Some(_)) => Ordering::Less,
+            _ => Ordering::Equal,
+        };
+        // If both directives match a value, we fall back to the field names in
+        // length + lexicographic ordering, and if these are equal as well, we
+        // compare the match directives.
+        //
+        // This ordering is no longer semantically meaningful but is necessary
+        // so that the directives can be stored in the `BTreeMap` in a defined
+        // order.
+        has_value
+            .then_with(|| self.name.cmp(&other.name))
+            .then_with(|| self.value.cmp(&other.value))
+    }
+}
+
+impl PartialOrd for Match {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+// === impl ValueMatch ===
+
+fn value_match_f64(v: f64) -> ValueMatch {
+    if v.is_nan() {
+        ValueMatch::NaN
+    } else {
+        ValueMatch::F64(v)
+    }
+}
+
+impl FromStr for ValueMatch {
+    type Err = matchers::Error;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        s.parse::<bool>()
+            .map(ValueMatch::Bool)
+            .or_else(|_| s.parse::<u64>().map(ValueMatch::U64))
+            .or_else(|_| s.parse::<i64>().map(ValueMatch::I64))
+            .or_else(|_| s.parse::<f64>().map(value_match_f64))
+            .or_else(|_| {
+                s.parse::<MatchPattern>()
+                    .map(|p| ValueMatch::Pat(Box::new(p)))
+            })
+    }
+}
+
+impl fmt::Display for ValueMatch {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            ValueMatch::Bool(ref inner) => fmt::Display::fmt(inner, f),
+            ValueMatch::F64(ref inner) => fmt::Display::fmt(inner, f),
+            ValueMatch::NaN => fmt::Display::fmt(&std::f64::NAN, f),
+            ValueMatch::I64(ref inner) => fmt::Display::fmt(inner, f),
+            ValueMatch::U64(ref inner) => fmt::Display::fmt(inner, f),
+            ValueMatch::Pat(ref inner) => fmt::Display::fmt(inner, f),
+        }
+    }
+}
+
+// === impl MatchPattern ===
+
+impl FromStr for MatchPattern {
+    type Err = matchers::Error;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let matcher = s.parse::<Pattern>()?;
+        Ok(Self {
+            matcher,
+            pattern: s.to_owned().into(),
+        })
+    }
+}
+
+impl fmt::Display for MatchPattern {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(&*self.pattern, f)
+    }
+}
+
+impl AsRef<str> for MatchPattern {
+    #[inline]
+    fn as_ref(&self) -> &str {
+        self.pattern.as_ref()
+    }
+}
+
+impl MatchPattern {
+    #[inline]
+    fn str_matches(&self, s: &impl AsRef<str>) -> bool {
+        self.matcher.matches(s)
+    }
+
+    #[inline]
+    fn debug_matches(&self, d: &impl fmt::Debug) -> bool {
+        self.matcher.debug_matches(d)
+    }
+}
+
+impl PartialEq for MatchPattern {
+    #[inline]
+    fn eq(&self, other: &Self) -> bool {
+        self.pattern == other.pattern
+    }
+}
+
+impl Eq for MatchPattern {}
+
+impl PartialOrd for MatchPattern {
+    #[inline]
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.pattern.cmp(&other.pattern))
+    }
+}
+
+impl Ord for MatchPattern {
+    #[inline]
+    fn cmp(&self, other: &Self) -> Ordering {
+        self.pattern.cmp(&other.pattern)
+    }
+}
+
+// === impl BadName ===
+
+impl Error for BadName {}
+
+impl fmt::Display for BadName {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "invalid field name `{}`", self.name)
+    }
+}
+
+impl CallsiteMatch {
+    pub(crate) fn to_span_match(&self) -> SpanMatch {
+        let fields = self
+            .fields
+            .iter()
+            .map(|(k, v)| (k.clone(), (v.clone(), AtomicBool::new(false))))
+            .collect();
+        SpanMatch {
+            fields,
+            level: self.level,
+            has_matched: AtomicBool::new(false),
+        }
+    }
+}
+
+impl SpanMatch {
+    pub(crate) fn visitor(&self) -> MatchVisitor<'_> {
+        MatchVisitor { inner: self }
+    }
+
+    #[inline]
+    pub(crate) fn is_matched(&self) -> bool {
+        if self.has_matched.load(Acquire) {
+            return true;
+        }
+        self.is_matched_slow()
+    }
+
+    #[inline(never)]
+    fn is_matched_slow(&self) -> bool {
+        let matched = self
+            .fields
+            .values()
+            .all(|(_, matched)| matched.load(Acquire));
+        if matched {
+            self.has_matched.store(true, Release);
+        }
+        matched
+    }
+
+    #[inline]
+    pub(crate) fn filter(&self) -> Option<LevelFilter> {
+        if self.is_matched() {
+            Some(self.level)
+        } else {
+            None
+        }
+    }
+}
+
+impl<'a> Visit for MatchVisitor<'a> {
+    fn record_f64(&mut self, field: &Field, value: f64) {
+        match self.inner.fields.get(field) {
+            Some((ValueMatch::NaN, ref matched)) if value.is_nan() => {
+                matched.store(true, Release);
+            }
+            Some((ValueMatch::F64(ref e), ref matched))
+                if (value - *e).abs() < std::f64::EPSILON =>
+            {
+                matched.store(true, Release);
+            }
+            _ => {}
+        }
+    }
+
+    fn record_i64(&mut self, field: &Field, value: i64) {
+        use std::convert::TryInto;
+
+        match self.inner.fields.get(field) {
+            Some((ValueMatch::I64(ref e), ref matched)) if value == *e => {
+                matched.store(true, Release);
+            }
+            Some((ValueMatch::U64(ref e), ref matched)) if Ok(value) == (*e).try_into() => {
+                matched.store(true, Release);
+            }
+            _ => {}
+        }
+    }
+
+    fn record_u64(&mut self, field: &Field, value: u64) {
+        match self.inner.fields.get(field) {
+            Some((ValueMatch::U64(ref e), ref matched)) if value == *e => {
+                matched.store(true, Release);
+            }
+            _ => {}
+        }
+    }
+
+    fn record_bool(&mut self, field: &Field, value: bool) {
+        match self.inner.fields.get(field) {
+            Some((ValueMatch::Bool(ref e), ref matched)) if value == *e => {
+                matched.store(true, Release);
+            }
+            _ => {}
+        }
+    }
+
+    fn record_str(&mut self, field: &Field, value: &str) {
+        match self.inner.fields.get(field) {
+            Some((ValueMatch::Pat(ref e), ref matched)) if e.str_matches(&value) => {
+                matched.store(true, Release);
+            }
+            _ => {}
+        }
+    }
+
+    fn record_debug(&mut self, field: &Field, value: &dyn fmt::Debug) {
+        match self.inner.fields.get(field) {
+            Some((ValueMatch::Pat(ref e), ref matched)) if e.debug_matches(&value) => {
+                matched.store(true, Release);
+            }
+            _ => {}
+        }
+    }
+}
diff --git a/vendor/tracing-subscriber-0.3.3/src/filter/env/mod.rs b/vendor/tracing-subscriber-0.3.3/src/filter/env/mod.rs
new file mode 100644
index 000000000..81fe0e62d
--- /dev/null
+++ b/vendor/tracing-subscriber-0.3.3/src/filter/env/mod.rs
@@ -0,0 +1,738 @@
+//! A `Layer` that enables or disables spans and events based on a set of
+//! filtering directives.
+
+// these are publicly re-exported, but the compiler doesn't realize
+// that for some reason.
+#[allow(unreachable_pub)]
+pub use self::{directive::Directive, field::BadName as BadFieldName};
+mod directive;
+mod field;
+
+use crate::{
+    filter::LevelFilter,
+    layer::{Context, Layer},
+    sync::RwLock,
+};
+use directive::ParseError;
+use std::{cell::RefCell, collections::HashMap, env, error::Error, fmt, str::FromStr};
+use tracing_core::{
+    callsite,
+    field::Field,
+    span,
+    subscriber::{Interest, Subscriber},
+    Metadata,
+};
+
+/// A [`Layer`] which filters spans and events based on a set of filter
+/// directives.
+///
+/// # Directives
+///
+/// A filter consists of one or more comma-separated directives which match on [`Span`]s and [`Event`]s.
+/// Each directive may have a corresponding maximum verbosity [`level`] which
+/// enables (e.g., _selects for_) spans and events that match. Like `log`,
+/// `tracing` considers less exclusive levels (like `trace` or `info`) to be more
+/// verbose than more exclusive levels (like `error` or `warn`).
+///
+/// The directive syntax is similar to that of [`env_logger`]'s. At a high level, the syntax for directives
+/// consists of several parts:
+///
+/// ```text
+/// target[span{field=value}]=level
+/// ```
+///
+/// Each component (`target`, `span`, `field`, `value`, and `level`) will be covered in turn.
+///
+/// - `target` matches the event or span's target. In general, this is the module path and/or crate name.
+///    Examples of targets `h2`, `tokio::net`, or `tide::server`. For more information on targets,
+///    please refer to [`Metadata`]'s documentation.
+/// - `span` matches on the span's name. If a `span` directive is provided alongside a `target`,
+///    the `span` directive will match on spans _within_ the `target`.
+/// - `field` matches on [fields] within spans. Field names can also be supplied without a `value`
+///    and will match on any [`Span`] or [`Event`] that has a field with that name.
+///    For example: `[span{field=\"value\"}]=debug`, `[{field}]=trace`.
+/// - `value` matches on the value of a span's field. If a value is a numeric literal or a bool,
+///    it will match _only_ on that value. Otherwise, this filter acts as a regex on
+///    the `std::fmt::Debug` output from the value.
+/// - `level` sets a maximum verbosity level accepted by this directive.
+///
+/// ## Usage Notes
+///
+/// - The portion of the directive which is included within the square brackets is `tracing`-specific.
+/// - Any portion of the directive can be omitted.
+///     - The sole exception are the `field` and `value` directives. If a `value` is provided,
+///       a `field` must _also_ be provided. However, the converse does not hold, as fields can
+///       be matched without a value.
+/// - If only a level is provided, it will set the maximum level for all `Span`s and `Event`s
+///   that are not enabled by other filters.
+/// - A directive without a level will enable anything that it matches. This is equivalent to `=trace`.
+/// - When a crate has a dash in its name, the default target for events will be the
+///   crate's module path as it appears in Rust. This means every dash will be replaced
+///   with an underscore.
+/// - A dash in a target will only appear when being specified explicitly:
+///   `tracing::info!(target: "target-name", ...);`
+///
+/// ## Examples
+///
+/// - `tokio::net=info` will enable all spans or events that:
+///    - have the `tokio::net` target,
+///    - at the level `info` or above.
+/// - `warn,tokio::net=info` will enable all spans and events that:
+///    - are at the level `warn` or above, *or*
+///    - have the `tokio::net` target at the level `info` or above.
+/// - `my_crate[span_a]=trace` will enable all spans and events that:
+///    - are within the `span_a` span or named `span_a` _if_ `span_a` has the target `my_crate`,
+///    - at the level `trace` or above.
+/// - `[span_b{name=\"bob\"}]` will enable all spans or event that:
+///    - have _any_ target,
+///    - are inside a span named `span_b`,
+///    - which has a field named `name` with value `bob`,
+///    - at _any_ level.
+///
+/// The [`Targets`] type implements a similar form of filtering, but without the
+/// ability to dynamically enable events based on the current span context, and
+/// without filtering on field values. When these features are not required,
+/// [`Targets`] provides a lighter-weight alternative to [`EnvFilter`].
+///
+/// [`Span`]: tracing_core::span
+/// [fields]: tracing_core::Field
+/// [`Event`]: tracing_core::Event
+/// [`level`]: tracing_core::Level
+/// [`Metadata`]: tracing_core::Metadata
+/// [`Targets`]: crate::filter::Targets
+#[cfg_attr(docsrs, doc(cfg(all(feature = "env-filter", feature = "std"))))]
+#[derive(Debug)]
+pub struct EnvFilter {
+    statics: directive::Statics,
+    dynamics: directive::Dynamics,
+    has_dynamics: bool,
+    by_id: RwLock<HashMap<span::Id, directive::SpanMatcher>>,
+    by_cs: RwLock<HashMap<callsite::Identifier, directive::CallsiteMatcher>>,
+}
+
+thread_local! {
+    static SCOPE: RefCell<Vec<LevelFilter>> = RefCell::new(Vec::new());
+}
+
+type FieldMap<T> = HashMap<Field, T>;
+
+/// Indicates that an error occurred while parsing a `EnvFilter` from an
+/// environment variable.
+#[cfg_attr(docsrs, doc(cfg(all(feature = "env-filter", feature = "std"))))]
+#[derive(Debug)]
+pub struct FromEnvError {
+    kind: ErrorKind,
+}
+
+#[derive(Debug)]
+enum ErrorKind {
+    Parse(ParseError),
+    Env(env::VarError),
+}
+
+impl EnvFilter {
+    /// `RUST_LOG` is the default environment variable used by
+    /// [`EnvFilter::from_default_env`] and [`EnvFilter::try_from_default_env`].
+    ///
+    /// [`EnvFilter::from_default_env`]: #method.from_default_env
+    /// [`EnvFilter::try_from_default_env`]: #method.try_from_default_env
+    pub const DEFAULT_ENV: &'static str = "RUST_LOG";
+
+    /// Returns a new `EnvFilter` from the value of the `RUST_LOG` environment
+    /// variable, ignoring any invalid filter directives.
+    pub fn from_default_env() -> Self {
+        Self::from_env(Self::DEFAULT_ENV)
+    }
+
+    /// Returns a new `EnvFilter` from the value of the given environment
+    /// variable, ignoring any invalid filter directives.
+    pub fn from_env<A: AsRef<str>>(env: A) -> Self {
+        env::var(env.as_ref()).map(Self::new).unwrap_or_default()
+    }
+
+    /// Returns a new `EnvFilter` from the directives in the given string,
+    /// ignoring any that are invalid.
+    pub fn new<S: AsRef<str>>(dirs: S) -> Self {
+        let directives = dirs.as_ref().split(',').filter_map(|s| match s.parse() {
+            Ok(d) => Some(d),
+            Err(err) => {
+                eprintln!("ignoring `{}`: {}", s, err);
+                None
+            }
+        });
+        Self::from_directives(directives)
+    }
+
+    /// Returns a new `EnvFilter` from the directives in the given string,
+    /// or an error if any are invalid.
+    pub fn try_new<S: AsRef<str>>(dirs: S) -> Result<Self, directive::ParseError> {
+        let directives = dirs
+            .as_ref()
+            .split(',')
+            .map(|s| s.parse())
+            .collect::<Result<Vec<_>, _>>()?;
+        Ok(Self::from_directives(directives))
+    }
+
+    /// Returns a new `EnvFilter` from the value of the `RUST_LOG` environment
+    /// variable, or an error if the environment variable contains any invalid
+    /// filter directives.
+    pub fn try_from_default_env() -> Result<Self, FromEnvError> {
+        Self::try_from_env(Self::DEFAULT_ENV)
+    }
+
+    /// Returns a new `EnvFilter` from the value of the given environment
+    /// variable, or an error if the environment variable is unset or contains
+    /// any invalid filter directives.
+    pub fn try_from_env<A: AsRef<str>>(env: A) -> Result<Self, FromEnvError> {
+        env::var(env.as_ref())?.parse().map_err(Into::into)
+    }
+
+    /// Add a filtering directive to this `EnvFilter`.
+    ///
+    /// The added directive will be used in addition to any previously set
+    /// directives, either added using this method or provided when the filter
+    /// is constructed.
+    ///
+    /// Filters may be created from [`LevelFilter`] or [`Level`], which will
+    /// enable all traces at or below a certain verbosity level, or
+    /// parsed from a string specifying a directive.
+    ///
+    /// If a filter directive is inserted that matches exactly the same spans
+    /// and events as a previous filter, but sets a different level for those
+    /// spans and events, the previous directive is overwritten.
+    ///
+    /// [`LevelFilter`]: ../filter/struct.LevelFilter.html
+    /// [`Level`]: https://docs.rs/tracing-core/latest/tracing_core/struct.Level.html
+    ///
+    /// # Examples
+    ///
+    /// From [`LevelFilter`]:
+    ////
+    /// ```rust
+    /// use tracing_subscriber::filter::{EnvFilter, LevelFilter};
+    /// let mut filter = EnvFilter::from_default_env()
+    ///     .add_directive(LevelFilter::INFO.into());
+    /// ```
+    ///
+    /// Or from [`Level`]:
+    ///
+    /// ```rust
+    /// # use tracing_subscriber::filter::{EnvFilter, LevelFilter};
+    /// # use tracing::Level;
+    /// let mut filter = EnvFilter::from_default_env()
+    ///     .add_directive(Level::INFO.into());
+    /// ```
+    ////
+    /// Parsed from a string:
+    ////
+    /// ```rust
+    /// use tracing_subscriber::filter::{EnvFilter, Directive};
+    ///
+    /// # fn try_mk_filter() -> Result<(), Box<dyn ::std::error::Error>> {
+    /// let mut filter = EnvFilter::try_from_default_env()?
+    ///     .add_directive("my_crate::module=trace".parse()?)
+    ///     .add_directive("my_crate::my_other_module::something=info".parse()?);
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn add_directive(mut self, directive: Directive) -> Self {
+        if let Some(stat) = directive.to_static() {
+            self.statics.add(stat)
+        } else {
+            self.has_dynamics = true;
+            self.dynamics.add(directive);
+        }
+        self
+    }
+
+    fn from_directives(directives: impl IntoIterator<Item = Directive>) -> Self {
+        use tracing::level_filters::STATIC_MAX_LEVEL;
+        use tracing::Level;
+
+        let directives: Vec<_> = directives.into_iter().collect();
+
+        let disabled: Vec<_> = directives
+            .iter()
+            .filter(|directive| directive.level > STATIC_MAX_LEVEL)
+            .collect();
+
+        if !disabled.is_empty() {
+            #[cfg(feature = "ansi_term")]
+            use ansi_term::{Color, Style};
+            // NOTE: We can't use a configured `MakeWriter` because the EnvFilter
+            // has no knowledge of any underlying subscriber or subscriber, which
+            // may or may not use a `MakeWriter`.
+            let warn = |msg: &str| {
+                #[cfg(not(feature = "ansi_term"))]
+                let msg = format!("warning: {}", msg);
+                #[cfg(feature = "ansi_term")]
+                let msg = {
+                    let bold = Style::new().bold();
+                    let mut warning = Color::Yellow.paint("warning");
+                    warning.style_ref_mut().is_bold = true;
+                    format!("{}{} {}", warning, bold.paint(":"), bold.paint(msg))
+                };
+                eprintln!("{}", msg);
+            };
+            let ctx_prefixed = |prefix: &str, msg: &str| {
+                #[cfg(not(feature = "ansi_term"))]
+                let msg = format!("note: {}", msg);
+                #[cfg(feature = "ansi_term")]
+                let msg = {
+                    let mut equal = Color::Fixed(21).paint("="); // dark blue
+                    equal.style_ref_mut().is_bold = true;
+                    format!(" {} {} {}", equal, Style::new().bold().paint(prefix), msg)
+                };
+                eprintln!("{}", msg);
+            };
+            let ctx_help = |msg| ctx_prefixed("help:", msg);
+            let ctx_note = |msg| ctx_prefixed("note:", msg);
+            let ctx = |msg: &str| {
+                #[cfg(not(feature = "ansi_term"))]
+                let msg = format!("note: {}", msg);
+                #[cfg(feature = "ansi_term")]
+                let msg = {
+                    let mut pipe = Color::Fixed(21).paint("|");
+                    pipe.style_ref_mut().is_bold = true;
+                    format!(" {} {}", pipe, msg)
+                };
+                eprintln!("{}", msg);
+            };
+            warn("some trace filter directives would enable traces that are disabled statically");
+            for directive in disabled {
+                let target = if let Some(target) = &directive.target {
+                    format!("the `{}` target", target)
+                } else {
+                    "all targets".into()
+                };
+                let level = directive
+                    .level
+                    .into_level()
+                    .expect("=off would not have enabled any filters");
+                ctx(&format!(
+                    "`{}` would enable the {} level for {}",
+                    directive, level, target
+                ));
+            }
+            ctx_note(&format!("the static max level is `{}`", STATIC_MAX_LEVEL));
+            let help_msg = || {
+                let (feature, filter) = match STATIC_MAX_LEVEL.into_level() {
+                    Some(Level::TRACE) => unreachable!(
+                        "if the max level is trace, no static filtering features are enabled"
+                    ),
+                    Some(Level::DEBUG) => ("max_level_debug", Level::TRACE),
+                    Some(Level::INFO) => ("max_level_info", Level::DEBUG),
+                    Some(Level::WARN) => ("max_level_warn", Level::INFO),
+                    Some(Level::ERROR) => ("max_level_error", Level::WARN),
+                    None => return ("max_level_off", String::new()),
+                };
+                (feature, format!("{} ", filter))
+            };
+            let (feature, earlier_level) = help_msg();
+            ctx_help(&format!(
+                "to enable {}logging, remove the `{}` feature",
+                earlier_level, feature
+            ));
+        }
+
+        let (dynamics, mut statics) = Directive::make_tables(directives);
+        let has_dynamics = !dynamics.is_empty();
+
+        if statics.is_empty() && !has_dynamics {
+            statics.add(directive::StaticDirective::default());
+        }
+
+        Self {
+            statics,
+            dynamics,
+            has_dynamics,
+            by_id: RwLock::new(HashMap::new()),
+            by_cs: RwLock::new(HashMap::new()),
+        }
+    }
+
+    fn cares_about_span(&self, span: &span::Id) -> bool {
+        let spans = try_lock!(self.by_id.read(), else return false);
+        spans.contains_key(span)
+    }
+
+    fn base_interest(&self) -> Interest {
+        if self.has_dynamics {
+            Interest::sometimes()
+        } else {
+            Interest::never()
+        }
+    }
+}
+
+impl<S: Subscriber> Layer<S> for EnvFilter {
+    fn register_callsite(&self, metadata: &'static Metadata<'static>) -> Interest {
+        if self.has_dynamics && metadata.is_span() {
+            // If this metadata describes a span, first, check if there is a
+            // dynamic filter that should be constructed for it. If so, it
+            // should always be enabled, since it influences filtering.
+            if let Some(matcher) = self.dynamics.matcher(metadata) {
+                let mut by_cs = try_lock!(self.by_cs.write(), else return self.base_interest());
+                by_cs.insert(metadata.callsite(), matcher);
+                return Interest::always();
+            }
+        }
+
+        // Otherwise, check if any of our static filters enable this metadata.
+        if self.statics.enabled(metadata) {
+            Interest::always()
+        } else {
+            self.base_interest()
+        }
+    }
+
+    fn max_level_hint(&self) -> Option<LevelFilter> {
+        if self.dynamics.has_value_filters() {
+            // If we perform any filtering on span field *values*, we will
+            // enable *all* spans, because their field values are not known
+            // until recording.
+            return Some(LevelFilter::TRACE);
+        }
+        std::cmp::max(
+            self.statics.max_level.into(),
+            self.dynamics.max_level.into(),
+        )
+    }
+
+    fn enabled(&self, metadata: &Metadata<'_>, _: Context<'_, S>) -> bool {
+        let level = metadata.level();
+
+        // is it possible for a dynamic filter directive to enable this event?
+        // if not, we can avoid the thread local access + iterating over the
+        // spans in the current scope.
+        if self.has_dynamics && self.dynamics.max_level >= *level {
+            if metadata.is_span() {
+                // If the metadata is a span, see if we care about its callsite.
+                let enabled_by_cs = self
+                    .by_cs
+                    .read()
+                    .ok()
+                    .map(|by_cs| by_cs.contains_key(&metadata.callsite()))
+                    .unwrap_or(false);
+                if enabled_by_cs {
+                    return true;
+                }
+            }
+
+            let enabled_by_scope = SCOPE.with(|scope| {
+                for filter in scope.borrow().iter() {
+                    if filter >= level {
+                        return true;
+                    }
+                }
+                false
+            });
+            if enabled_by_scope {
+                return true;
+            }
+        }
+
+        // is it possible for a static filter directive to enable this event?
+        if self.statics.max_level >= *level {
+            // Otherwise, fall back to checking if the callsite is
+            // statically enabled.
+            return self.statics.enabled(metadata);
+        }
+
+        false
+    }
+
+    fn on_new_span(&self, attrs: &span::Attributes<'_>, id: &span::Id, _: Context<'_, S>) {
+        let by_cs = try_lock!(self.by_cs.read());
+        if let Some(cs) = by_cs.get(&attrs.metadata().callsite()) {
+            let span = cs.to_span_match(attrs);
+            try_lock!(self.by_id.write()).insert(id.clone(), span);
+        }
+    }
+
+    fn on_record(&self, id: &span::Id, values: &span::Record<'_>, _: Context<'_, S>) {
+        if let Some(span) = try_lock!(self.by_id.read()).get(id) {
+            span.record_update(values);
+        }
+    }
+
+    fn on_enter(&self, id: &span::Id, _: Context<'_, S>) {
+        // XXX: This is where _we_ could push IDs to the stack instead, and use
+        // that to allow changing the filter while a span is already entered.
+        // But that might be much less efficient...
+        if let Some(span) = try_lock!(self.by_id.read()).get(id) {
+            SCOPE.with(|scope| scope.borrow_mut().push(span.level()));
+        }
+    }
+
+    fn on_exit(&self, id: &span::Id, _: Context<'_, S>) {
+        if self.cares_about_span(id) {
+            SCOPE.with(|scope| scope.borrow_mut().pop());
+        }
+    }
+
+    fn on_close(&self, id: span::Id, _: Context<'_, S>) {
+        // If we don't need to acquire a write lock, avoid doing so.
+        if !self.cares_about_span(&id) {
+            return;
+        }
+
+        let mut spans = try_lock!(self.by_id.write());
+        spans.remove(&id);
+    }
+}
+
+impl FromStr for EnvFilter {
+    type Err = directive::ParseError;
+
+    fn from_str(spec: &str) -> Result<Self, Self::Err> {
+        Self::try_new(spec)
+    }
+}
+
+impl<S> From<S> for EnvFilter
+where
+    S: AsRef<str>,
+{
+    fn from(s: S) -> Self {
+        Self::new(s)
+    }
+}
+
+impl Default for EnvFilter {
+    fn default() -> Self {
+        Self::from_directives(std::iter::empty())
+    }
+}
+
+impl fmt::Display for EnvFilter {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let mut statics = self.statics.iter();
+        let wrote_statics = if let Some(next) = statics.next() {
+            fmt::Display::fmt(next, f)?;
+            for directive in statics {
+                write!(f, ",{}", directive)?;
+            }
+            true
+        } else {
+            false
+        };
+
+        let mut dynamics = self.dynamics.iter();
+        if let Some(next) = dynamics.next() {
+            if wrote_statics {
+                f.write_str(",")?;
+            }
+            fmt::Display::fmt(next, f)?;
+            for directive in dynamics {
+                write!(f, ",{}", directive)?;
+            }
+        }
+        Ok(())
+    }
+}
+
+// ===== impl FromEnvError =====
+
+impl From<directive::ParseError> for FromEnvError {
+    fn from(p: directive::ParseError) -> Self {
+        Self {
+            kind: ErrorKind::Parse(p),
+        }
+    }
+}
+
+impl From<env::VarError> for FromEnvError {
+    fn from(v: env::VarError) -> Self {
+        Self {
+            kind: ErrorKind::Env(v),
+        }
+    }
+}
+
+impl fmt::Display for FromEnvError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self.kind {
+            ErrorKind::Parse(ref p) => p.fmt(f),
+            ErrorKind::Env(ref e) => e.fmt(f),
+        }
+    }
+}
+
+impl Error for FromEnvError {
+    fn source(&self) -> Option<&(dyn Error + 'static)> {
+        match self.kind {
+            ErrorKind::Parse(ref p) => Some(p),
+            ErrorKind::Env(ref e) => Some(e),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tracing_core::field::FieldSet;
+    use tracing_core::*;
+
+    struct NoSubscriber;
+    impl Subscriber for NoSubscriber {
+        #[inline]
+        fn register_callsite(&self, _: &'static Metadata<'static>) -> subscriber::Interest {
+            subscriber::Interest::always()
+        }
+        fn new_span(&self, _: &span::Attributes<'_>) -> span::Id {
+            span::Id::from_u64(0xDEAD)
+        }
+        fn event(&self, _event: &Event<'_>) {}
+        fn record(&self, _span: &span::Id, _values: &span::Record<'_>) {}
+        fn record_follows_from(&self, _span: &span::Id, _follows: &span::Id) {}
+
+        #[inline]
+        fn enabled(&self, _metadata: &Metadata<'_>) -> bool {
+            true
+        }
+        fn enter(&self, _span: &span::Id) {}
+        fn exit(&self, _span: &span::Id) {}
+    }
+
+    struct Cs;
+    impl Callsite for Cs {
+        fn set_interest(&self, _interest: Interest) {}
+        fn metadata(&self) -> &Metadata<'_> {
+            unimplemented!()
+        }
+    }
+
+    #[test]
+    fn callsite_enabled_no_span_directive() {
+        let filter = EnvFilter::new("app=debug").with_subscriber(NoSubscriber);
+        static META: &Metadata<'static> = &Metadata::new(
+            "mySpan",
+            "app",
+            Level::TRACE,
+            None,
+            None,
+            None,
+            FieldSet::new(&[], identify_callsite!(&Cs)),
+            Kind::SPAN,
+        );
+
+        let interest = filter.register_callsite(META);
+        assert!(interest.is_never());
+    }
+
+    #[test]
+    fn callsite_off() {
+        let filter = EnvFilter::new("app=off").with_subscriber(NoSubscriber);
+        static META: &Metadata<'static> = &Metadata::new(
+            "mySpan",
+            "app",
+            Level::ERROR,
+            None,
+            None,
+            None,
+            FieldSet::new(&[], identify_callsite!(&Cs)),
+            Kind::SPAN,
+        );
+
+        let interest = filter.register_callsite(META);
+        assert!(interest.is_never());
+    }
+
+    #[test]
+    fn callsite_enabled_includes_span_directive() {
+        let filter = EnvFilter::new("app[mySpan]=debug").with_subscriber(NoSubscriber);
+        static META: &Metadata<'static> = &Metadata::new(
+            "mySpan",
+            "app",
+            Level::TRACE,
+            None,
+            None,
+            None,
+            FieldSet::new(&[], identify_callsite!(&Cs)),
+            Kind::SPAN,
+        );
+
+        let interest = filter.register_callsite(META);
+        assert!(interest.is_always());
+    }
+
+    #[test]
+    fn callsite_enabled_includes_span_directive_field() {
+        let filter =
+            EnvFilter::new("app[mySpan{field=\"value\"}]=debug").with_subscriber(NoSubscriber);
+        static META: &Metadata<'static> = &Metadata::new(
+            "mySpan",
+            "app",
+            Level::TRACE,
+            None,
+            None,
+            None,
+            FieldSet::new(&["field"], identify_callsite!(&Cs)),
+            Kind::SPAN,
+        );
+
+        let interest = filter.register_callsite(META);
+        assert!(interest.is_always());
+    }
+
+    #[test]
+    fn callsite_enabled_includes_span_directive_multiple_fields() {
+        let filter = EnvFilter::new("app[mySpan{field=\"value\",field2=2}]=debug")
+            .with_subscriber(NoSubscriber);
+        static META: &Metadata<'static> = &Metadata::new(
+            "mySpan",
+            "app",
+            Level::TRACE,
+            None,
+            None,
+            None,
+            FieldSet::new(&["field"], identify_callsite!(&Cs)),
+            Kind::SPAN,
+        );
+
+        let interest = filter.register_callsite(META);
+        assert!(interest.is_never());
+    }
+
+    #[test]
+    fn roundtrip() {
+        let f1: EnvFilter =
+            "[span1{foo=1}]=error,[span2{bar=2 baz=false}],crate2[{quux=\"quuux\"}]=debug"
+                .parse()
+                .unwrap();
+        let f2: EnvFilter = format!("{}", f1).parse().unwrap();
+        assert_eq!(f1.statics, f2.statics);
+        assert_eq!(f1.dynamics, f2.dynamics);
+    }
+
+    #[test]
+    fn size_of_filters() {
+        fn print_sz(s: &str) {
+            let filter = s.parse::<EnvFilter>().expect("filter should parse");
+            println!(
+                "size_of_val({:?})\n -> {}B",
+                s,
+                std::mem::size_of_val(&filter)
+            );
+        }
+
+        print_sz("info");
+
+        print_sz("foo=debug");
+
+        print_sz(
+            "crate1::mod1=error,crate1::mod2=warn,crate1::mod2::mod3=info,\
+            crate2=debug,crate3=trace,crate3::mod2::mod1=off",
+        );
+
+        print_sz("[span1{foo=1}]=error,[span2{bar=2 baz=false}],crate2[{quux=\"quuux\"}]=debug");
+
+        print_sz(
+            "crate1::mod1=error,crate1::mod2=warn,crate1::mod2::mod3=info,\
+            crate2=debug,crate3=trace,crate3::mod2::mod1=off,[span1{foo=1}]=error,\
+            [span2{bar=2 baz=false}],crate2[{quux=\"quuux\"}]=debug",
+        );
+    }
+}
diff --git a/vendor/tracing-subscriber-0.3.3/src/filter/filter_fn.rs b/vendor/tracing-subscriber-0.3.3/src/filter/filter_fn.rs
new file mode 100644
index 000000000..332bf860a
--- /dev/null
+++ b/vendor/tracing-subscriber-0.3.3/src/filter/filter_fn.rs
@@ -0,0 +1,749 @@
+use crate::{
+    filter::LevelFilter,
+    layer::{Context, Layer},
+};
+use core::{any::type_name, fmt, marker::PhantomData};
+use tracing_core::{Interest, Metadata, Subscriber};
+
+/// A filter implemented by a closure or function pointer that
+/// determines whether a given span or event is enabled, based on its
+/// [`Metadata`].
+///
+/// This type can be used for both [per-layer filtering][plf] (using its
+/// [`Filter`] implementation) and [global filtering][global] (using its
+/// [`Layer`] implementation).
+///
+/// See the [documentation on filtering with layers][filtering] for details.
+///
+/// [`Metadata`]: tracing_core::Metadata
+/// [`Filter`]: crate::layer::Filter
+/// [`Layer`]: crate::layer::Layer
+/// [plf]: crate::layer#per-layer-filtering
+/// [global]: crate::layer#global-filtering
+/// [filtering]: crate::layer#filtering-with-layers
+#[derive(Clone)]
+pub struct FilterFn<F = fn(&Metadata<'_>) -> bool> {
+    enabled: F,
+    max_level_hint: Option<LevelFilter>,
+}
+
+/// A filter implemented by a closure or function pointer that
+/// determines whether a given span or event is enabled _dynamically_,
+/// potentially based on the current [span context].
+///
+/// This type can be used for both [per-layer filtering][plf] (using its
+/// [`Filter`] implementation) and [global filtering][global] (using its
+/// [`Layer`] implementation).
+///
+/// See the [documentation on filtering with layers][filtering] for details.
+///
+/// [span context]: crate::layer::Context
+/// [`Filter`]: crate::layer::Filter
+/// [`Layer`]: crate::layer::Layer
+/// [plf]: crate::layer#per-layer-filtering
+/// [global]: crate::layer#global-filtering
+/// [filtering]: crate::layer#filtering-with-layers
+pub struct DynFilterFn<
+    S,
+    // TODO(eliza): should these just be boxed functions?
+    F = fn(&Metadata<'_>, &Context<'_, S>) -> bool,
+    R = fn(&'static Metadata<'static>) -> Interest,
+> {
+    enabled: F,
+    register_callsite: Option<R>,
+    max_level_hint: Option<LevelFilter>,
+    _s: PhantomData<fn(S)>,
+}
+
+// === impl FilterFn ===
+
+/// Constructs a [`FilterFn`], from a function or closure that returns `true` if
+/// a span or event should be enabled, based on its [`Metadata`].
+///
+/// The returned [`FilterFn`] can be used for both [per-layer filtering][plf]
+/// (using its [`Filter`] implementation) and [global filtering][global] (using
+/// its  [`Layer`] implementation).
+///
+/// See the [documentation on filtering with layers][filtering] for details.
+///
+/// This is equivalent to calling [`FilterFn::new`].
+///
+/// [`Metadata`]: tracing_core::Metadata
+/// [`Filter`]: crate::layer::Filter
+/// [`Layer`]: crate::layer::Layer
+/// [plf]: crate::layer#per-layer-filtering
+/// [global]: crate::layer#global-filtering
+/// [filtering]: crate::layer#filtering-with-layers
+///
+/// # Examples
+///
+/// ```
+/// use tracing_subscriber::{
+///     layer::{Layer, SubscriberExt},
+///     filter,
+///     util::SubscriberInitExt,
+/// };
+///
+/// let my_filter = filter::filter_fn(|metadata| {
+///     // Only enable spans or events with the target "interesting_things"
+///     metadata.target() == "interesting_things"
+/// });
+///
+/// let my_layer = tracing_subscriber::fmt::layer();
+///
+/// tracing_subscriber::registry()
+///     .with(my_layer.with_filter(my_filter))
+///     .init();
+///
+/// // This event will not be enabled.
+/// tracing::warn!("something important but uninteresting happened!");
+///
+/// // This event will be enabled.
+/// tracing::debug!(target: "interesting_things", "an interesting minor detail...");
+/// ```
+pub fn filter_fn<F>(f: F) -> FilterFn<F>
+where
+    F: Fn(&Metadata<'_>) -> bool,
+{
+    FilterFn::new(f)
+}
+
+/// Constructs a [`DynFilterFn`] from a function or closure that returns `true`
+/// if a span or event should be enabled within a particular [span context][`Context`].
+///
+/// This is equivalent to calling [`DynFilterFn::new`].
+///
+/// Unlike [`filter_fn`], this function takes a closure or function pointer
+/// taking the [`Metadata`] for a span or event *and* the current [`Context`].
+/// This means that a [`DynFilterFn`] can choose whether to enable spans or
+/// events based on information about the _current_ span (or its parents).
+///
+/// If this is *not* necessary, use [`filter_fn`] instead.
+///
+/// The returned [`DynFilterFn`] can be used for both [per-layer filtering][plf]
+/// (using its [`Filter`] implementation) and [global filtering][global] (using
+/// its  [`Layer`] implementation).
+///
+/// See the [documentation on filtering with layers][filtering] for details.
+///
+/// # Examples
+///
+/// ```
+/// use tracing_subscriber::{
+///     layer::{Layer, SubscriberExt},
+///     filter,
+///     util::SubscriberInitExt,
+/// };
+///
+/// // Only enable spans or events within a span named "interesting_span".
+/// let my_filter = filter::dynamic_filter_fn(|metadata, cx| {
+///     // If this *is* "interesting_span", make sure to enable it.
+///     if metadata.is_span() && metadata.name() == "interesting_span" {
+///         return true;
+///     }
+///
+///     // Otherwise, are we in an interesting span?
+///     if let Some(current_span) = cx.lookup_current() {
+///         return current_span.name() == "interesting_span";
+///     }
+///
+///     false
+/// });
+///
+/// let my_layer = tracing_subscriber::fmt::layer();
+///
+/// tracing_subscriber::registry()
+///     .with(my_layer.with_filter(my_filter))
+///     .init();
+///
+/// // This event will not be enabled.
+/// tracing::info!("something happened");
+///
+/// tracing::info_span!("interesting_span").in_scope(|| {
+///     // This event will be enabled.
+///     tracing::debug!("something else happened");
+/// });
+/// ```
+///
+/// [`Filter`]: crate::layer::Filter
+/// [`Layer`]: crate::layer::Layer
+/// [plf]: crate::layer#per-layer-filtering
+/// [global]: crate::layer#global-filtering
+/// [filtering]: crate::layer#filtering-with-layers
+/// [`Context`]: crate::layer::Context
+/// [`Metadata`]: tracing_core::Metadata
+pub fn dynamic_filter_fn<S, F>(f: F) -> DynFilterFn<S, F>
+where
+    F: Fn(&Metadata<'_>, &Context<'_, S>) -> bool,
+{
+    DynFilterFn::new(f)
+}
+
+impl<F> FilterFn<F>
+where
+    F: Fn(&Metadata<'_>) -> bool,
+{
+    /// Constructs a [`FilterFn`] from a function or closure that returns `true`
+    /// if a span or event should be enabled, based on its [`Metadata`].
+    ///
+    /// If determining whether a span or event should be enabled also requires
+    /// information about the current span context, use [`DynFilterFn`] instead.
+    ///
+    /// See the [documentation on per-layer filtering][plf] for details on using
+    /// [`Filter`]s.
+    ///
+    /// [`Filter`]: crate::layer::Filter
+    /// [plf]: crate::layer#per-layer-filtering
+    /// [`Metadata`]: tracing_core::Metadata
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use tracing_subscriber::{
+    ///     layer::{Layer, SubscriberExt},
+    ///     filter::FilterFn,
+    ///     util::SubscriberInitExt,
+    /// };
+    ///
+    /// let my_filter = FilterFn::new(|metadata| {
+    ///     // Only enable spans or events with the target "interesting_things"
+    ///     metadata.target() == "interesting_things"
+    /// });
+    ///
+    /// let my_layer = tracing_subscriber::fmt::layer();
+    ///
+    /// tracing_subscriber::registry()
+    ///     .with(my_layer.with_filter(my_filter))
+    ///     .init();
+    ///
+    /// // This event will not be enabled.
+    /// tracing::warn!("something important but uninteresting happened!");
+    ///
+    /// // This event will be enabled.
+    /// tracing::debug!(target: "interesting_things", "an interesting minor detail...");
+    /// ```
+    pub fn new(enabled: F) -> Self {
+        Self {
+            enabled,
+            max_level_hint: None,
+        }
+    }
+
+    /// Sets the highest verbosity [`Level`] the filter function will enable.
+    ///
+    /// The value passed to this method will be returned by this `FilterFn`'s
+    /// [`Filter::max_level_hint`] method.
+    ///
+    /// If the provided function will not enable all levels, it is recommended
+    /// to call this method to configure it with the most verbose level it will
+    /// enable.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use tracing_subscriber::{
+    ///     layer::{Layer, SubscriberExt},
+    ///     filter::{filter_fn, LevelFilter},
+    ///     util::SubscriberInitExt,
+    /// };
+    /// use tracing_core::Level;
+    ///
+    /// let my_filter = filter_fn(|metadata| {
+    ///     // Only enable spans or events with targets starting with `my_crate`
+    ///     // and levels at or below `INFO`.
+    ///     metadata.level() <= &Level::INFO && metadata.target().starts_with("my_crate")
+    /// })
+    ///     // Since the filter closure will only enable the `INFO` level and
+    ///     // below, set the max level hint
+    ///     .with_max_level_hint(LevelFilter::INFO);
+    ///
+    /// let my_layer = tracing_subscriber::fmt::layer();
+    ///
+    /// tracing_subscriber::registry()
+    ///     .with(my_layer.with_filter(my_filter))
+    ///     .init();
+    /// ```
+    ///
+    /// [`Level`]: tracing_core::Level
+    /// [`Filter::max_level_hint`]: crate::layer::Filter::max_level_hint
+    pub fn with_max_level_hint(self, max_level_hint: impl Into<LevelFilter>) -> Self {
+        Self {
+            max_level_hint: Some(max_level_hint.into()),
+            ..self
+        }
+    }
+
+    #[inline]
+    pub(in crate::filter) fn is_enabled(&self, metadata: &Metadata<'_>) -> bool {
+        let enabled = (self.enabled)(metadata);
+        debug_assert!(
+            !enabled || self.is_below_max_level(metadata),
+            "FilterFn<{}> claimed it would only enable {:?} and below, \
+            but it enabled metadata with the {:?} level\nmetadata={:#?}",
+            type_name::<F>(),
+            self.max_level_hint.unwrap(),
+            metadata.level(),
+            metadata,
+        );
+
+        enabled
+    }
+
+    #[inline]
+    pub(in crate::filter) fn is_callsite_enabled(
+        &self,
+        metadata: &'static Metadata<'static>,
+    ) -> Interest {
+        // Because `self.enabled` takes a `Metadata` only (and no `Context`
+        // parameter), we can reasonably assume its results are cachable, and
+        // just return `Interest::always`/`Interest::never`.
+        if (self.enabled)(metadata) {
+            debug_assert!(
+                self.is_below_max_level(metadata),
+                "FilterFn<{}> claimed it was only interested in {:?} and below, \
+                but it enabled metadata with the {:?} level\nmetadata={:#?}",
+                type_name::<F>(),
+                self.max_level_hint.unwrap(),
+                metadata.level(),
+                metadata,
+            );
+            return Interest::always();
+        }
+
+        Interest::never()
+    }
+
+    fn is_below_max_level(&self, metadata: &Metadata<'_>) -> bool {
+        self.max_level_hint
+            .as_ref()
+            .map(|hint| metadata.level() <= hint)
+            .unwrap_or(true)
+    }
+}
+
+impl<S, F> Layer<S> for FilterFn<F>
+where
+    F: Fn(&Metadata<'_>) -> bool + 'static,
+    S: Subscriber,
+{
+    fn enabled(&self, metadata: &Metadata<'_>, _: Context<'_, S>) -> bool {
+        self.is_enabled(metadata)
+    }
+
+    fn register_callsite(&self, metadata: &'static Metadata<'static>) -> Interest {
+        self.is_callsite_enabled(metadata)
+    }
+
+    fn max_level_hint(&self) -> Option<LevelFilter> {
+        self.max_level_hint
+    }
+}
+
+impl<F> From<F> for FilterFn<F>
+where
+    F: Fn(&Metadata<'_>) -> bool,
+{
+    fn from(enabled: F) -> Self {
+        Self::new(enabled)
+    }
+}
+
+impl<F> fmt::Debug for FilterFn<F> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("FilterFn")
+            .field("enabled", &format_args!("{}", type_name::<F>()))
+            .field("max_level_hint", &self.max_level_hint)
+            .finish()
+    }
+}
+
+// === impl DynFilterFn ==
+
+impl<S, F> DynFilterFn<S, F>
+where
+    F: Fn(&Metadata<'_>, &Context<'_, S>) -> bool,
+{
+    /// Constructs a [`Filter`] from a function or closure that returns `true`
+    /// if a span or event should be enabled in the current [span
+    /// context][`Context`].
+    ///
+    /// Unlike [`FilterFn`], a `DynFilterFn` is constructed from a closure or
+    /// function pointer that takes both the [`Metadata`] for a span or event
+    /// *and* the current [`Context`]. This means that a [`DynFilterFn`] can
+    /// choose whether to enable spans or events based on information about the
+    /// _current_ span (or its parents).
+    ///
+    /// If this is *not* necessary, use [`FilterFn`] instead.
+    ///
+    /// See the [documentation on per-layer filtering][plf] for details on using
+    /// [`Filter`]s.
+    ///
+    /// [`Filter`]: crate::layer::Filter
+    /// [plf]: crate::layer#per-layer-filtering
+    /// [`Context`]: crate::layer::Context
+    /// [`Metadata`]: tracing_core::Metadata
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use tracing_subscriber::{
+    ///     layer::{Layer, SubscriberExt},
+    ///     filter::DynFilterFn,
+    ///     util::SubscriberInitExt,
+    /// };
+    ///
+    /// // Only enable spans or events within a span named "interesting_span".
+    /// let my_filter = DynFilterFn::new(|metadata, cx| {
+    ///     // If this *is* "interesting_span", make sure to enable it.
+    ///     if metadata.is_span() && metadata.name() == "interesting_span" {
+    ///         return true;
+    ///     }
+    ///
+    ///     // Otherwise, are we in an interesting span?
+    ///     if let Some(current_span) = cx.lookup_current() {
+    ///         return current_span.name() == "interesting_span";
+    ///     }
+    ///
+    ///     false
+    /// });
+    ///
+    /// let my_layer = tracing_subscriber::fmt::layer();
+    ///
+    /// tracing_subscriber::registry()
+    ///     .with(my_layer.with_filter(my_filter))
+    ///     .init();
+    ///
+    /// // This event will not be enabled.
+    /// tracing::info!("something happened");
+    ///
+    /// tracing::info_span!("interesting_span").in_scope(|| {
+    ///     // This event will be enabled.
+    ///     tracing::debug!("something else happened");
+    /// });
+    /// ```
+    pub fn new(enabled: F) -> Self {
+        Self {
+            enabled,
+            register_callsite: None,
+            max_level_hint: None,
+            _s: PhantomData,
+        }
+    }
+}
+
+impl<S, F, R> DynFilterFn<S, F, R>
+where
+    F: Fn(&Metadata<'_>, &Context<'_, S>) -> bool,
+{
+    /// Sets the highest verbosity [`Level`] the filter function will enable.
+    ///
+    /// The value passed to this method will be returned by this `DynFilterFn`'s
+    /// [`Filter::max_level_hint`] method.
+    ///
+    /// If the provided function will not enable all levels, it is recommended
+    /// to call this method to configure it with the most verbose level it will
+    /// enable.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use tracing_subscriber::{
+    ///     layer::{Layer, SubscriberExt},
+    ///     filter::{DynFilterFn, LevelFilter},
+    ///     util::SubscriberInitExt,
+    /// };
+    /// use tracing_core::Level;
+    ///
+    /// // Only enable spans or events with levels at or below `INFO`, if
+    /// // we are inside a span called "interesting_span".
+    /// let my_filter = DynFilterFn::new(|metadata, cx| {
+    ///     // If the level is greater than INFO, disable it.
+    ///     if metadata.level() > &Level::INFO {
+    ///         return false;
+    ///     }
+    ///
+    ///     // If any span in the current scope is named "interesting_span",
+    ///     // enable this span or event.
+    ///     for span in cx.lookup_current().iter().flat_map(|span| span.scope()) {
+    ///         if span.name() == "interesting_span" {
+    ///             return true;
+    ///          }
+    ///     }
+    ///
+    ///     // Otherwise, disable it.
+    ///     false
+    /// })
+    ///     // Since the filter closure will only enable the `INFO` level and
+    ///     // below, set the max level hint
+    ///     .with_max_level_hint(LevelFilter::INFO);
+    ///
+    /// let my_layer = tracing_subscriber::fmt::layer();
+    ///
+    /// tracing_subscriber::registry()
+    ///     .with(my_layer.with_filter(my_filter))
+    ///     .init();
+    /// ```
+    ///
+    /// [`Level`]: tracing_core::Level
+    /// [`Filter::max_level_hint`]: crate::layer::Filter::max_level_hint
+    pub fn with_max_level_hint(self, max_level_hint: impl Into<LevelFilter>) -> Self {
+        Self {
+            max_level_hint: Some(max_level_hint.into()),
+            ..self
+        }
+    }
+
+    /// Adds a function for filtering callsites to this filter.
+    ///
+    /// When this filter's [`Filter::callsite_enabled`][cse] method is called,
+    /// the provided function will be used rather than the default.
+    ///
+    /// By default, `DynFilterFn` assumes that, because the filter _may_ depend
+    /// dynamically on the current [span context], its result should never be
+    /// cached. However, some filtering strategies may require dynamic information
+    /// from the current span context in *some* cases, but are able to make
+    /// static filtering decisions from [`Metadata`] alone in others.
+    ///
+    /// For example, consider the filter given in the example for
+    /// [`DynFilterFn::new`]. That filter enables all spans named
+    /// "interesting_span", and any events and spans that occur inside of an
+    /// interesting span. Since the span's name is part of its static
+    /// [`Metadata`], the "interesting_span" can be enabled in
+    /// [`callsite_enabled`][cse]:
+    ///
+    /// ```
+    /// use tracing_subscriber::{
+    ///     layer::{Layer, SubscriberExt},
+    ///     filter::DynFilterFn,
+    ///     util::SubscriberInitExt,
+    /// };
+    /// use tracing_core::subscriber::Interest;
+    ///
+    /// // Only enable spans or events within a span named "interesting_span".
+    /// let my_filter = DynFilterFn::new(|metadata, cx| {
+    ///     // If this *is* "interesting_span", make sure to enable it.
+    ///     if metadata.is_span() && metadata.name() == "interesting_span" {
+    ///         return true;
+    ///     }
+    ///
+    ///     // Otherwise, are we in an interesting span?
+    ///     if let Some(current_span) = cx.lookup_current() {
+    ///         return current_span.name() == "interesting_span";
+    ///     }
+    ///
+    ///     false
+    /// }).with_callsite_filter(|metadata| {
+    ///     // If this is an "interesting_span", we know we will always
+    ///     // enable it.
+    ///     if metadata.is_span() && metadata.name() == "interesting_span" {
+    ///         return Interest::always();
+    ///     }
+    ///
+    ///     // Otherwise, it depends on whether or not we're in an interesting
+    ///     // span. You'll have to ask us again for each span/event!
+    ///     Interest::sometimes()
+    /// });
+    ///
+    /// let my_layer = tracing_subscriber::fmt::layer();
+    ///
+    /// tracing_subscriber::registry()
+    ///     .with(my_layer.with_filter(my_filter))
+    ///     .init();
+    /// ```
+    ///
+    /// [cse]: crate::layer::Filter::callsite_enabled
+    /// [`enabled`]: crate::layer::Filter::enabled
+    /// [`Metadata`]: tracing_core::Metadata
+    /// [span context]: crate::layer::Context
+    pub fn with_callsite_filter<R2>(self, callsite_enabled: R2) -> DynFilterFn<S, F, R2>
+    where
+        R2: Fn(&'static Metadata<'static>) -> Interest,
+    {
+        let register_callsite = Some(callsite_enabled);
+        let DynFilterFn {
+            enabled,
+            max_level_hint,
+            _s,
+            ..
+        } = self;
+        DynFilterFn {
+            enabled,
+            register_callsite,
+            max_level_hint,
+            _s,
+        }
+    }
+
+    fn default_callsite_enabled(&self, metadata: &Metadata<'_>) -> Interest {
+        // If it's below the configured max level, assume that `enabled` will
+        // never enable it...
+        if !is_below_max_level(&self.max_level_hint, metadata) {
+            debug_assert!(
+                !(self.enabled)(metadata, &Context::none()),
+                "DynFilterFn<{}> claimed it would only enable {:?} and below, \
+                but it enabled metadata with the {:?} level\nmetadata={:#?}",
+                type_name::<F>(),
+                self.max_level_hint.unwrap(),
+                metadata.level(),
+                metadata,
+            );
+            return Interest::never();
+        }
+
+        // Otherwise, since this `enabled` function is dynamic and depends on
+        // the current context, we don't know whether this span or event will be
+        // enabled or not. Ask again every time it's recorded!
+        Interest::sometimes()
+    }
+}
+
+impl<S, F, R> DynFilterFn<S, F, R>
+where
+    F: Fn(&Metadata<'_>, &Context<'_, S>) -> bool,
+    R: Fn(&'static Metadata<'static>) -> Interest,
+{
+    #[inline]
+    fn is_enabled(&self, metadata: &Metadata<'_>, cx: &Context<'_, S>) -> bool {
+        let enabled = (self.enabled)(metadata, cx);
+        debug_assert!(
+            !enabled || is_below_max_level(&self.max_level_hint, metadata),
+            "DynFilterFn<{}> claimed it would only enable {:?} and below, \
+            but it enabled metadata with the {:?} level\nmetadata={:#?}",
+            type_name::<F>(),
+            self.max_level_hint.unwrap(),
+            metadata.level(),
+            metadata,
+        );
+
+        enabled
+    }
+
+    #[inline]
+    fn is_callsite_enabled(&self, metadata: &'static Metadata<'static>) -> Interest {
+        let interest = self
+            .register_callsite
+            .as_ref()
+            .map(|callsite_enabled| callsite_enabled(metadata))
+            .unwrap_or_else(|| self.default_callsite_enabled(metadata));
+        debug_assert!(
+            interest.is_never() || is_below_max_level(&self.max_level_hint, metadata),
+            "DynFilterFn<{}, {}> claimed it was only interested in {:?} and below, \
+            but it enabled metadata with the {:?} level\nmetadata={:#?}",
+            type_name::<F>(),
+            type_name::<R>(),
+            self.max_level_hint.unwrap(),
+            metadata.level(),
+            metadata,
+        );
+
+        interest
+    }
+}
+
+impl<S, F, R> Layer<S> for DynFilterFn<S, F, R>
+where
+    F: Fn(&Metadata<'_>, &Context<'_, S>) -> bool + 'static,
+    R: Fn(&'static Metadata<'static>) -> Interest + 'static,
+    S: Subscriber,
+{
+    fn enabled(&self, metadata: &Metadata<'_>, cx: Context<'_, S>) -> bool {
+        self.is_enabled(metadata, &cx)
+    }
+
+    fn register_callsite(&self, metadata: &'static Metadata<'static>) -> Interest {
+        self.is_callsite_enabled(metadata)
+    }
+
+    fn max_level_hint(&self) -> Option<LevelFilter> {
+        self.max_level_hint
+    }
+}
+
+impl<S, F, R> fmt::Debug for DynFilterFn<S, F, R> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let mut s = f.debug_struct("DynFilterFn");
+        s.field("enabled", &format_args!("{}", type_name::<F>()));
+        if self.register_callsite.is_some() {
+            s.field(
+                "register_callsite",
+                &format_args!("Some({})", type_name::<R>()),
+            );
+        } else {
+            s.field("register_callsite", &format_args!("None"));
+        }
+
+        s.field("max_level_hint", &self.max_level_hint).finish()
+    }
+}
+
+impl<S, F, R> Clone for DynFilterFn<S, F, R>
+where
+    F: Clone,
+    R: Clone,
+{
+    fn clone(&self) -> Self {
+        Self {
+            enabled: self.enabled.clone(),
+            register_callsite: self.register_callsite.clone(),
+            max_level_hint: self.max_level_hint,
+            _s: PhantomData,
+        }
+    }
+}
+
+impl<F, S> From<F> for DynFilterFn<S, F>
+where
+    F: Fn(&Metadata<'_>, &Context<'_, S>) -> bool,
+{
+    fn from(f: F) -> Self {
+        Self::new(f)
+    }
+}
+
+// === PLF impls ===
+
+feature! {
+    #![all(feature = "registry", feature = "std")]
+    use crate::layer::Filter;
+
+    impl<S, F> Filter<S> for FilterFn<F>
+    where
+        F: Fn(&Metadata<'_>) -> bool,
+    {
+        fn enabled(&self, metadata: &Metadata<'_>, _: &Context<'_, S>) -> bool {
+            self.is_enabled(metadata)
+        }
+
+        fn callsite_enabled(&self, metadata: &'static Metadata<'static>) -> Interest {
+            self.is_callsite_enabled(metadata)
+        }
+
+        fn max_level_hint(&self) -> Option<LevelFilter> {
+            self.max_level_hint
+        }
+    }
+
+    impl<S, F, R> Filter<S> for DynFilterFn<S, F, R>
+    where
+        F: Fn(&Metadata<'_>, &Context<'_, S>) -> bool,
+        R: Fn(&'static Metadata<'static>) -> Interest,
+    {
+        fn enabled(&self, metadata: &Metadata<'_>, cx: &Context<'_, S>) -> bool {
+            self.is_enabled(metadata, cx)
+        }
+
+        fn callsite_enabled(&self, metadata: &'static Metadata<'static>) -> Interest {
+            self.is_callsite_enabled(metadata)
+        }
+
+        fn max_level_hint(&self) -> Option<LevelFilter> {
+            self.max_level_hint
+        }
+    }
+}
+
+fn is_below_max_level(hint: &Option<LevelFilter>, metadata: &Metadata<'_>) -> bool {
+    hint.as_ref()
+        .map(|hint| metadata.level() <= hint)
+        .unwrap_or(true)
+}
diff --git a/vendor/tracing-subscriber-0.3.3/src/filter/layer_filters.rs b/vendor/tracing-subscriber-0.3.3/src/filter/layer_filters.rs
new file mode 100644
index 000000000..e77fd3751
--- /dev/null
+++ b/vendor/tracing-subscriber-0.3.3/src/filter/layer_filters.rs
@@ -0,0 +1,830 @@
+//! ## Per-Layer Filtering
+//!
+//! Per-layer filters permit individual `Layer`s to have their own filter
+//! configurations without interfering with other `Layer`s.
+//!
+//! This module is not public; the public APIs defined in this module are
+//! re-exported in the top-level `filter` module. Therefore, this documentation
+//! primarily concerns the internal implementation details. For the user-facing
+//! public API documentation, see the individual public types in this module, as
+//! well as the, see the `Layer` trait documentation's [per-layer filtering
+//! section]][1].
+//!
+//! ## How does per-layer filtering work?
+//!
+//! As described in the API documentation, the [`Filter`] trait defines a
+//! filtering strategy for a per-layer filter. We expect there will be a variety
+//! of implementations of [`Filter`], both in `tracing-subscriber` and in user
+//! code.
+//!
+//! To actually *use* a [`Filter`] implementation, it is combined with a
+//! [`Layer`] by the [`Filtered`] struct defined in this module. [`Filtered`]
+//! implements [`Layer`] by calling into the wrapped [`Layer`], or not, based on
+//! the filtering strategy. While there will be a variety of types that implement
+//! [`Filter`], all actual *uses* of per-layer filtering will occur through the
+//! [`Filtered`] struct. Therefore, most of the implementation details live
+//! there.
+//!
+//! [1]: crate::layer#per-layer-filtering
+//! [`Filter`]: crate::layer::Filter
+use crate::{
+    filter::LevelFilter,
+    layer::{self, Context, Layer},
+    registry,
+};
+use std::{
+    any::TypeId,
+    cell::{Cell, RefCell},
+    fmt,
+    marker::PhantomData,
+    sync::Arc,
+    thread_local,
+};
+use tracing_core::{
+    span,
+    subscriber::{Interest, Subscriber},
+    Event, Metadata,
+};
+
+/// A [`Layer`] that wraps an inner [`Layer`] and adds a [`Filter`] which
+/// controls what spans and events are enabled for that layer.
+///
+/// This is returned by the [`Layer::with_filter`] method. See the
+/// [documentation on per-layer filtering][plf] for details.
+///
+/// [`Filter`]: crate::layer::Filter
+/// [plf]: crate::layer#per-layer-filtering
+#[cfg_attr(docsrs, doc(cfg(feature = "registry")))]
+#[derive(Clone)]
+pub struct Filtered<L, F, S> {
+    filter: F,
+    layer: L,
+    id: MagicPlfDowncastMarker,
+    _s: PhantomData<fn(S)>,
+}
+
+/// Uniquely identifies an individual [`Filter`] instance in the context of
+/// a [`Subscriber`].
+///
+/// When adding a [`Filtered`] [`Layer`] to a [`Subscriber`], the [`Subscriber`]
+/// generates a `FilterId` for that [`Filtered`] layer. The [`Filtered`] layer
+/// will then use the generated ID to query whether a particular span was
+/// previously enabled by that layer's [`Filter`].
+///
+/// **Note**: Currently, the [`Registry`] type provided by this crate is the
+/// **only** [`Subscriber`] implementation capable of participating in per-layer
+/// filtering. Therefore, the `FilterId` type cannot currently be constructed by
+/// code outside of `tracing-subscriber`. In the future, new APIs will be added to `tracing-subscriber` to
+/// allow non-Registry [`Subscriber`]s to also participate in per-layer
+/// filtering. When those APIs are added, subscribers will be responsible
+/// for generating and assigning `FilterId`s.
+///
+/// [`Filter`]: crate::layer::Filter
+/// [`Subscriber`]: tracing_core::Subscriber
+/// [`Layer`]: crate::layer::Layer
+/// [`Registry`]: crate::registry::Registry
+#[cfg(feature = "registry")]
+#[cfg_attr(docsrs, doc(cfg(feature = "registry")))]
+#[derive(Copy, Clone)]
+pub struct FilterId(u64);
+
+/// A bitmap tracking which [`FilterId`]s have enabled a given span or
+/// event.
+///
+/// This is currently a private type that's used exclusively by the
+/// [`Registry`]. However, in the future, this may become a public API, in order
+/// to allow user subscribers to host [`Filter`]s.
+///
+/// [`Registry`]: crate::Registry
+/// [`Filter`]: crate::layer::Filter
+#[derive(Default, Copy, Clone, Eq, PartialEq)]
+pub(crate) struct FilterMap {
+    bits: u64,
+}
+
+/// The current state of `enabled` calls to per-layer filters on this
+/// thread.
+///
+/// When `Filtered::enabled` is called, the filter will set the bit
+/// corresponding to its ID if the filter will disable the event/span being
+/// filtered. When the event or span is recorded, the per-layer filter will
+/// check its bit to determine if it disabled that event or span, and skip
+/// forwarding the event or span to the inner layer if the bit is set. Once
+/// a span or event has been skipped by a per-layer filter, it unsets its
+/// bit, so that the `FilterMap` has been cleared for the next set of
+/// `enabled` calls.
+///
+/// FilterState is also read by the `Registry`, for two reasons:
+///
+/// 1. When filtering a span, the Registry must store the `FilterMap`
+///    generated by `Filtered::enabled` calls for that span as part of the
+///    span's per-span data. This allows `Filtered` layers to determine
+///    whether they had previously disabled a given span, and avoid showing it
+///    to the wrapped layer if it was disabled.
+///
+///    This allows `Filtered` layers to also filter out the spans they
+///    disable from span traversals (such as iterating over parents, etc).
+/// 2. If all the bits are set, then every per-layer filter has decided it
+///    doesn't want to enable that span or event. In that case, the
+///    `Registry`'s `enabled` method will return `false`, so that
+///     recording a span or event can be skipped entirely.
+#[derive(Debug)]
+pub(crate) struct FilterState {
+    enabled: Cell<FilterMap>,
+    // TODO(eliza): `Interest`s should _probably_ be `Copy`. The only reason
+    // they're not is our Obsessive Commitment to Forwards-Compatibility. If
+    // this changes in tracing-core`, we can make this a `Cell` rather than
+    // `RefCell`...
+    interest: RefCell<Option<Interest>>,
+
+    #[cfg(debug_assertions)]
+    counters: DebugCounters,
+}
+
+/// Extra counters added to `FilterState` used only to make debug assertions.
+#[cfg(debug_assertions)]
+#[derive(Debug, Default)]
+struct DebugCounters {
+    /// How many per-layer filters have participated in the current `enabled`
+    /// call?
+    in_filter_pass: Cell<usize>,
+
+    /// How many per-layer filters have participated in the current `register_callsite`
+    /// call?
+    in_interest_pass: Cell<usize>,
+}
+
+thread_local! {
+    pub(crate) static FILTERING: FilterState = FilterState::new();
+}
+
+// === impl Filter ===
+#[cfg(feature = "registry")]
+#[cfg_attr(docsrs, doc(cfg(feature = "registry")))]
+impl<S> layer::Filter<S> for LevelFilter {
+    fn enabled(&self, meta: &Metadata<'_>, _: &Context<'_, S>) -> bool {
+        meta.level() <= self
+    }
+
+    fn callsite_enabled(&self, meta: &'static Metadata<'static>) -> Interest {
+        if meta.level() <= self {
+            Interest::always()
+        } else {
+            Interest::never()
+        }
+    }
+
+    fn max_level_hint(&self) -> Option<LevelFilter> {
+        Some(*self)
+    }
+}
+
+impl<S> layer::Filter<S> for Arc<dyn layer::Filter<S> + Send + Sync + 'static> {
+    #[inline]
+    fn enabled(&self, meta: &Metadata<'_>, cx: &Context<'_, S>) -> bool {
+        (**self).enabled(meta, cx)
+    }
+
+    #[inline]
+    fn callsite_enabled(&self, meta: &'static Metadata<'static>) -> Interest {
+        (**self).callsite_enabled(meta)
+    }
+
+    #[inline]
+    fn max_level_hint(&self) -> Option<LevelFilter> {
+        (**self).max_level_hint()
+    }
+}
+
+impl<S> layer::Filter<S> for Box<dyn layer::Filter<S> + Send + Sync + 'static> {
+    #[inline]
+    fn enabled(&self, meta: &Metadata<'_>, cx: &Context<'_, S>) -> bool {
+        (**self).enabled(meta, cx)
+    }
+
+    #[inline]
+    fn callsite_enabled(&self, meta: &'static Metadata<'static>) -> Interest {
+        (**self).callsite_enabled(meta)
+    }
+
+    #[inline]
+    fn max_level_hint(&self) -> Option<LevelFilter> {
+        (**self).max_level_hint()
+    }
+}
+
+// === impl Filtered ===
+
+impl<L, F, S> Filtered<L, F, S> {
+    /// Wraps the provided [`Layer`] so that it is filtered by the given
+    /// [`Filter`].
+    ///
+    /// This is equivalent to calling the [`Layer::with_filter`] method.
+    ///
+    /// See the [documentation on per-layer filtering][plf] for details.
+    ///
+    /// [`Filter`]: crate::layer::Filter
+    /// [plf]: crate::layer#per-layer-filtering
+    pub fn new(layer: L, filter: F) -> Self {
+        Self {
+            layer,
+            filter,
+            id: MagicPlfDowncastMarker(FilterId::disabled()),
+            _s: PhantomData,
+        }
+    }
+
+    #[inline(always)]
+    fn id(&self) -> FilterId {
+        debug_assert!(
+            !self.id.0.is_disabled(),
+            "a `Filtered` layer was used, but it had no `FilterId`; \
+            was it registered with the subscriber?"
+        );
+        self.id.0
+    }
+
+    fn did_enable(&self, f: impl FnOnce()) {
+        FILTERING.with(|filtering| filtering.did_enable(self.id(), f))
+    }
+}
+
+impl<S, L, F> Layer<S> for Filtered<L, F, S>
+where
+    S: Subscriber + for<'span> registry::LookupSpan<'span> + 'static,
+    F: layer::Filter<S> + 'static,
+    L: Layer<S>,
+{
+    fn on_layer(&mut self, subscriber: &mut S) {
+        self.id = MagicPlfDowncastMarker(subscriber.register_filter());
+        self.layer.on_layer(subscriber);
+    }
+
+    // TODO(eliza): can we figure out a nice way to make the `Filtered` layer
+    // not call `is_enabled_for` in hooks that the inner layer doesn't actually
+    // have real implementations of? probably not...
+    //
+    // it would be cool if there was some wild rust reflection way of checking
+    // if a trait impl has the default impl of a trait method or not, but that's
+    // almsot certainly impossible...right?
+
+    fn register_callsite(&self, metadata: &'static Metadata<'static>) -> Interest {
+        let interest = self.filter.callsite_enabled(metadata);
+
+        // If the filter didn't disable the callsite, allow the inner layer to
+        // register it — since `register_callsite` is also used for purposes
+        // such as reserving/caching per-callsite data, we want the inner layer
+        // to be able to perform any other registration steps. However, we'll
+        // ignore its `Interest`.
+        if !interest.is_never() {
+            self.layer.register_callsite(metadata);
+        }
+
+        // Add our `Interest` to the current sum of per-layer filter `Interest`s
+        // for this callsite.
+        FILTERING.with(|filtering| filtering.add_interest(interest));
+
+        // don't short circuit! if the stack consists entirely of `Layer`s with
+        // per-layer filters, the `Registry` will return the actual `Interest`
+        // value that's the sum of all the `register_callsite` calls to those
+        // per-layer filters. if we returned an actual `never` interest here, a
+        // `Layered` layer would short-circuit and not allow any `Filtered`
+        // layers below us if _they_ are interested in the callsite.
+        Interest::always()
+    }
+
+    fn enabled(&self, metadata: &Metadata<'_>, cx: Context<'_, S>) -> bool {
+        let cx = cx.with_filter(self.id());
+        let enabled = self.filter.enabled(metadata, &cx);
+        FILTERING.with(|filtering| filtering.set(self.id(), enabled));
+
+        if enabled {
+            // If the filter enabled this metadata, ask the wrapped layer if
+            // _it_ wants it --- it might have a global filter.
+            self.layer.enabled(metadata, cx)
+        } else {
+            // Otherwise, return `true`. The _per-layer_ filter disabled this
+            // metadata, but returning `false` in `Layer::enabled` will
+            // short-circuit and globally disable the span or event. This is
+            // *not* what we want for per-layer filters, as other layers may
+            // still want this event. Returning `true` here means we'll continue
+            // asking the next layer in the stack.
+            //
+            // Once all per-layer filters have been evaluated, the `Registry`
+            // at the root of the stack will return `false` from its `enabled`
+            // method if *every* per-layer  filter disabled this metadata.
+            // Otherwise, the individual per-layer filters will skip the next
+            // `new_span` or `on_event` call for their layer if *they* disabled
+            // the span or event, but it was not globally disabled.
+            true
+        }
+    }
+
+    fn on_new_span(&self, attrs: &span::Attributes<'_>, id: &span::Id, cx: Context<'_, S>) {
+        self.did_enable(|| {
+            self.layer.on_new_span(attrs, id, cx.with_filter(self.id()));
+        })
+    }
+
+    #[doc(hidden)]
+    fn max_level_hint(&self) -> Option<LevelFilter> {
+        self.filter.max_level_hint()
+    }
+
+    fn on_record(&self, span: &span::Id, values: &span::Record<'_>, cx: Context<'_, S>) {
+        if let Some(cx) = cx.if_enabled_for(span, self.id()) {
+            self.layer.on_record(span, values, cx)
+        }
+    }
+
+    fn on_follows_from(&self, span: &span::Id, follows: &span::Id, cx: Context<'_, S>) {
+        // only call `on_follows_from` if both spans are enabled by us
+        if cx.is_enabled_for(span, self.id()) && cx.is_enabled_for(follows, self.id()) {
+            self.layer
+                .on_follows_from(span, follows, cx.with_filter(self.id()))
+        }
+    }
+
+    fn on_event(&self, event: &Event<'_>, cx: Context<'_, S>) {
+        self.did_enable(|| {
+            self.layer.on_event(event, cx.with_filter(self.id()));
+        })
+    }
+
+    fn on_enter(&self, id: &span::Id, cx: Context<'_, S>) {
+        if let Some(cx) = cx.if_enabled_for(id, self.id()) {
+            self.layer.on_enter(id, cx)
+        }
+    }
+
+    fn on_exit(&self, id: &span::Id, cx: Context<'_, S>) {
+        if let Some(cx) = cx.if_enabled_for(id, self.id()) {
+            self.layer.on_exit(id, cx)
+        }
+    }
+
+    fn on_close(&self, id: span::Id, cx: Context<'_, S>) {
+        if let Some(cx) = cx.if_enabled_for(&id, self.id()) {
+            self.layer.on_close(id, cx)
+        }
+    }
+
+    // XXX(eliza): the existence of this method still makes me sad...
+    fn on_id_change(&self, old: &span::Id, new: &span::Id, cx: Context<'_, S>) {
+        if let Some(cx) = cx.if_enabled_for(old, self.id()) {
+            self.layer.on_id_change(old, new, cx)
+        }
+    }
+
+    #[doc(hidden)]
+    #[inline]
+    unsafe fn downcast_raw(&self, id: TypeId) -> Option<*const ()> {
+        match id {
+            id if id == TypeId::of::<Self>() => Some(self as *const _ as *const ()),
+            id if id == TypeId::of::<L>() => Some(&self.layer as *const _ as *const ()),
+            id if id == TypeId::of::<F>() => Some(&self.filter as *const _ as *const ()),
+            id if id == TypeId::of::<MagicPlfDowncastMarker>() => {
+                Some(&self.id as *const _ as *const ())
+            }
+            _ => self.layer.downcast_raw(id),
+        }
+    }
+}
+
+impl<F, L, S> fmt::Debug for Filtered<F, L, S>
+where
+    F: fmt::Debug,
+    L: fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Filtered")
+            .field("filter", &self.filter)
+            .field("layer", &self.layer)
+            .field("id", &self.id)
+            .finish()
+    }
+}
+
+// === impl FilterId ===
+
+impl FilterId {
+    const fn disabled() -> Self {
+        Self(std::u64::MAX)
+    }
+
+    /// Returns a `FilterId` that will consider _all_ spans enabled.
+    pub(crate) const fn none() -> Self {
+        Self(0)
+    }
+
+    pub(crate) fn new(id: u8) -> Self {
+        assert!(id < 64, "filter IDs may not be greater than 64");
+        Self(1 << id as usize)
+    }
+
+    /// Combines two `FilterId`s, returning a new `FilterId` that will match a
+    /// [`FilterMap`] where the span was disabled by _either_ this `FilterId`
+    /// *or* the combined `FilterId`.
+    ///
+    /// This method is called by [`Context`]s when adding the `FilterId` of a
+    /// [`Filtered`] layer to the context.
+    ///
+    /// This is necessary for cases where we have a tree of nested [`Filtered`]
+    /// layers, like this:
+    ///
+    /// ```text
+    /// Filtered {
+    ///     filter1,
+    ///     Layered {
+    ///         layer1,
+    ///         Filtered {
+    ///              filter2,
+    ///              layer2,
+    ///         },
+    /// }
+    /// ```
+    ///
+    /// We want `layer2` to be affected by both `filter1` _and_ `filter2`.
+    /// Without combining `FilterId`s, this works fine when filtering
+    /// `on_event`/`new_span`, because the outer `Filtered` layer (`filter1`)
+    /// won't call the inner layer's `on_event` or `new_span` callbacks if it
+    /// disabled the event/span.
+    ///
+    /// However, it _doesn't_ work when filtering span lookups and traversals
+    /// (e.g. `scope`). This is because the [`Context`] passed to `layer2`
+    /// would set its filter ID to the filter ID of `filter2`, and would skip
+    /// spans that were disabled by `filter2`. However, what if a span was
+    /// disabled by `filter1`? We wouldn't see it in `new_span`, but we _would_
+    /// see it in lookups and traversals...which we don't want.
+    ///
+    /// When a [`Filtered`] layer adds its ID to a [`Context`], it _combines_ it
+    /// with any previous filter ID that the context had, rather than replacing
+    /// it. That way, `layer2`'s context will check if a span was disabled by
+    /// `filter1` _or_ `filter2`. The way we do this, instead of representing
+    /// `FilterId`s as a number number that we shift a 1 over by to get a mask,
+    /// we just store the actual mask,so we can combine them with a bitwise-OR.
+    ///
+    /// For example, if we consider the following case (pretending that the
+    /// masks are 8 bits instead of 64 just so i don't have to write out a bunch
+    /// of extra zeroes):
+    ///
+    /// - `filter1` has the filter id 1 (`0b0000_0001`)
+    /// - `filter2` has the filter id 2 (`0b0000_0010`)
+    ///
+    /// A span that gets disabled by filter 1 would have the [`FilterMap`] with
+    /// bits `0b0000_0001`.
+    ///
+    /// If the `FilterId` was internally represented as `(bits to shift + 1),
+    /// when `layer2`'s [`Context`] checked if it enabled the  span, it would
+    /// make the mask `0b0000_0010` (`1 << 1`). That bit would not be set in the
+    /// [`FilterMap`], so it would see that it _didn't_ disable  the span. Which
+    /// is *true*, it just doesn't reflect the tree-like shape of the actual
+    /// subscriber.
+    ///
+    /// By having the IDs be masks instead of shifts, though, when the
+    /// [`Filtered`] with `filter2` gets the [`Context`] with `filter1`'s filter ID,
+    /// instead of replacing it, it ors them together:
+    ///
+    /// ```ignore
+    /// 0b0000_0001 | 0b0000_0010 == 0b0000_0011;
+    /// ```
+    ///
+    /// We then test if the span was disabled by  seeing if _any_ bits in the
+    /// mask are `1`:
+    ///
+    /// ```ignore
+    /// filtermap & mask != 0;
+    /// 0b0000_0001 & 0b0000_0011 != 0;
+    /// 0b0000_0001 != 0;
+    /// true;
+    /// ```
+    ///
+    /// [`Context`]: crate::layer::Context
+    pub(crate) fn and(self, FilterId(other): Self) -> Self {
+        // If this mask is disabled, just return the other --- otherwise, we
+        // would always see that every span is disabled.
+        if self.0 == Self::disabled().0 {
+            return Self(other);
+        }
+
+        Self(self.0 | other)
+    }
+
+    fn is_disabled(self) -> bool {
+        self.0 == Self::disabled().0
+    }
+}
+
+impl fmt::Debug for FilterId {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        // don't print a giant set of the numbers 0..63 if the filter ID is disabled.
+        if self.0 == Self::disabled().0 {
+            return f
+                .debug_tuple("FilterId")
+                .field(&format_args!("DISABLED"))
+                .finish();
+        }
+
+        if f.alternate() {
+            f.debug_struct("FilterId")
+                .field("ids", &format_args!("{:?}", FmtBitset(self.0)))
+                .field("bits", &format_args!("{:b}", self.0))
+                .finish()
+        } else {
+            f.debug_tuple("FilterId").field(&FmtBitset(self.0)).finish()
+        }
+    }
+}
+
+impl fmt::Binary for FilterId {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_tuple("FilterId")
+            .field(&format_args!("{:b}", self.0))
+            .finish()
+    }
+}
+
+// === impl FilterMap ===
+
+impl FilterMap {
+    pub(crate) fn set(self, FilterId(mask): FilterId, enabled: bool) -> Self {
+        if mask == std::u64::MAX {
+            return self;
+        }
+
+        if enabled {
+            Self {
+                bits: self.bits & (!mask),
+            }
+        } else {
+            Self {
+                bits: self.bits | mask,
+            }
+        }
+    }
+
+    #[inline]
+    pub(crate) fn is_enabled(self, FilterId(mask): FilterId) -> bool {
+        self.bits & mask == 0
+    }
+
+    #[inline]
+    pub(crate) fn any_enabled(self) -> bool {
+        self.bits != std::u64::MAX
+    }
+}
+
+impl fmt::Debug for FilterMap {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let alt = f.alternate();
+        let mut s = f.debug_struct("FilterMap");
+        s.field("disabled_by", &format_args!("{:?}", &FmtBitset(self.bits)));
+
+        if alt {
+            s.field("bits", &format_args!("{:b}", self.bits));
+        }
+
+        s.finish()
+    }
+}
+
+impl fmt::Binary for FilterMap {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("FilterMap")
+            .field("bits", &format_args!("{:b}", self.bits))
+            .finish()
+    }
+}
+
+// === impl FilterState ===
+
+impl FilterState {
+    fn new() -> Self {
+        Self {
+            enabled: Cell::new(FilterMap::default()),
+            interest: RefCell::new(None),
+
+            #[cfg(debug_assertions)]
+            counters: DebugCounters::default(),
+        }
+    }
+
+    fn set(&self, filter: FilterId, enabled: bool) {
+        #[cfg(debug_assertions)]
+        {
+            let in_current_pass = self.counters.in_filter_pass.get();
+            if in_current_pass == 0 {
+                debug_assert_eq!(self.enabled.get(), FilterMap::default());
+            }
+            self.counters.in_filter_pass.set(in_current_pass + 1);
+            debug_assert_eq!(
+                self.counters.in_interest_pass.get(),
+                0,
+                "if we are in or starting a filter pass, we must not be in an interest pass."
+            )
+        }
+
+        self.enabled.set(self.enabled.get().set(filter, enabled))
+    }
+
+    fn add_interest(&self, interest: Interest) {
+        let mut curr_interest = self.interest.borrow_mut();
+
+        #[cfg(debug_assertions)]
+        {
+            let in_current_pass = self.counters.in_interest_pass.get();
+            if in_current_pass == 0 {
+                debug_assert!(curr_interest.is_none());
+            }
+            self.counters.in_interest_pass.set(in_current_pass + 1);
+        }
+
+        if let Some(curr_interest) = curr_interest.as_mut() {
+            if (curr_interest.is_always() && !interest.is_always())
+                || (curr_interest.is_never() && !interest.is_never())
+            {
+                *curr_interest = Interest::sometimes();
+            }
+            // If the two interests are the same, do nothing. If the current
+            // interest is `sometimes`, stay sometimes.
+        } else {
+            *curr_interest = Some(interest);
+        }
+    }
+
+    pub(crate) fn event_enabled() -> bool {
+        FILTERING
+            .try_with(|this| {
+                let enabled = this.enabled.get().any_enabled();
+                #[cfg(debug_assertions)]
+                {
+                    if this.counters.in_filter_pass.get() == 0 {
+                        debug_assert_eq!(this.enabled.get(), FilterMap::default());
+                    }
+
+                    // Nothing enabled this event, we won't tick back down the
+                    // counter in `did_enable`. Reset it.
+                    if !enabled {
+                        this.counters.in_filter_pass.set(0);
+                    }
+                }
+                enabled
+            })
+            .unwrap_or(true)
+    }
+
+    /// Executes a closure if the filter with the provided ID did not disable
+    /// the current span/event.
+    ///
+    /// This is used to implement the `on_event` and `new_span` methods for
+    /// `Filtered`.
+    fn did_enable(&self, filter: FilterId, f: impl FnOnce()) {
+        let map = self.enabled.get();
+        if map.is_enabled(filter) {
+            // If the filter didn't disable the current span/event, run the
+            // callback.
+            f();
+        } else {
+            // Otherwise, if this filter _did_ disable the span or event
+            // currently being processed, clear its bit from this thread's
+            // `FilterState`. The bit has already been "consumed" by skipping
+            // this callback, and we need to ensure that the `FilterMap` for
+            // this thread is reset when the *next* `enabled` call occurs.
+            self.enabled.set(map.set(filter, true));
+        }
+        #[cfg(debug_assertions)]
+        {
+            let in_current_pass = self.counters.in_filter_pass.get();
+            if in_current_pass <= 1 {
+                debug_assert_eq!(self.enabled.get(), FilterMap::default());
+            }
+            self.counters
+                .in_filter_pass
+                .set(in_current_pass.saturating_sub(1));
+            debug_assert_eq!(
+                self.counters.in_interest_pass.get(),
+                0,
+                "if we are in a filter pass, we must not be in an interest pass."
+            )
+        }
+    }
+
+    /// Clears the current in-progress filter state.
+    ///
+    /// This resets the [`FilterMap`] and current [`Interest`] as well as
+    /// clearing the debug counters.
+    pub(crate) fn clear_enabled() {
+        // Drop the `Result` returned by `try_with` --- if we are in the middle
+        // a panic and the thread-local has been torn down, that's fine, just
+        // ignore it ratehr than panicking.
+        let _ = FILTERING.try_with(|filtering| {
+            filtering.enabled.set(FilterMap::default());
+
+            #[cfg(debug_assertions)]
+            filtering.counters.in_filter_pass.set(0);
+        });
+    }
+
+    pub(crate) fn take_interest() -> Option<Interest> {
+        FILTERING
+            .try_with(|filtering| {
+                #[cfg(debug_assertions)]
+                {
+                    if filtering.counters.in_interest_pass.get() == 0 {
+                        debug_assert!(filtering.interest.try_borrow().ok()?.is_none());
+                    }
+                    filtering.counters.in_interest_pass.set(0);
+                }
+                filtering.interest.try_borrow_mut().ok()?.take()
+            })
+            .ok()?
+    }
+
+    pub(crate) fn filter_map(&self) -> FilterMap {
+        let map = self.enabled.get();
+        #[cfg(debug_assertions)]
+        {
+            if self.counters.in_filter_pass.get() == 0 {
+                debug_assert_eq!(map, FilterMap::default());
+            }
+        }
+
+        map
+    }
+}
+/// This is a horrible and bad abuse of the downcasting system to expose
+/// *internally* whether a layer has per-layer filtering, within
+/// `tracing-subscriber`, without exposing a public API for it.
+///
+/// If a `Layer` has per-layer filtering, it will downcast to a
+/// `MagicPlfDowncastMarker`. Since layers which contain other layers permit
+/// downcasting to recurse to their children, this will do the Right Thing with
+/// layers like Reload, Option, etc.
+///
+/// Why is this a wrapper around the `FilterId`, you may ask? Because
+/// downcasting works by returning a pointer, and we don't want to risk
+/// introducing UB by  constructing pointers that _don't_ point to a valid
+/// instance of the type they claim to be. In this case, we don't _intend_ for
+/// this pointer to be dereferenced, so it would actually be fine to return one
+/// that isn't a valid pointer...but we can't guarantee that the caller won't
+/// (accidentally) dereference it, so it's better to be safe than sorry. We
+/// could, alternatively, add an additional field to the type that's used only
+/// for returning pointers to as as part of the evil downcasting hack, but I
+/// thought it was nicer to just add a `repr(transparent)` wrapper to the
+/// existing `FilterId` field, since it won't make the struct any bigger.
+///
+/// Don't worry, this isn't on the test. :)
+#[derive(Clone, Copy)]
+#[repr(transparent)]
+struct MagicPlfDowncastMarker(FilterId);
+impl fmt::Debug for MagicPlfDowncastMarker {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        // Just pretend that `MagicPlfDowncastMarker` doesn't exist for
+        // `fmt::Debug` purposes...if no one *sees* it in their `Debug` output,
+        // they don't have to know I thought this code would be a good idea.
+        fmt::Debug::fmt(&self.0, f)
+    }
+}
+
+pub(crate) fn is_plf_downcast_marker(type_id: TypeId) -> bool {
+    type_id == TypeId::of::<MagicPlfDowncastMarker>()
+}
+
+/// Does a type implementing `Subscriber` contain any per-layer filters?
+pub(crate) fn subscriber_has_plf<S>(subscriber: &S) -> bool
+where
+    S: Subscriber,
+{
+    (subscriber as &dyn Subscriber).is::<MagicPlfDowncastMarker>()
+}
+
+/// Does a type implementing `Layer` contain any per-layer filters?
+pub(crate) fn layer_has_plf<L, S>(layer: &L) -> bool
+where
+    L: Layer<S>,
+    S: Subscriber,
+{
+    unsafe {
+        // Safety: we're not actually *doing* anything with this pointer --- we
+        // only care about the `Option`, which we're turning into a `bool`. So
+        // even if the layer decides to be evil and give us some kind of invalid
+        // pointer, we don't ever dereference it, so this is always safe.
+        layer.downcast_raw(TypeId::of::<MagicPlfDowncastMarker>())
+    }
+    .is_some()
+}
+
+struct FmtBitset(u64);
+
+impl fmt::Debug for FmtBitset {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let mut set = f.debug_set();
+        for bit in 0..64 {
+            // if the `bit`-th bit is set, add it to the debug set
+            if self.0 & (1 << bit) != 0 {
+                set.entry(&bit);
+            }
+        }
+        set.finish()
+    }
+}
diff --git a/vendor/tracing-subscriber-0.3.3/src/filter/level.rs b/vendor/tracing-subscriber-0.3.3/src/filter/level.rs
new file mode 100644
index 000000000..0fa601260
--- /dev/null
+++ b/vendor/tracing-subscriber-0.3.3/src/filter/level.rs
@@ -0,0 +1,27 @@
+use tracing_core::{
+    subscriber::{Interest, Subscriber},
+    Metadata,
+};
+
+#[allow(unreachable_pub)] // https://github.com/rust-lang/rust/issues/57411
+pub use tracing_core::metadata::{LevelFilter, ParseLevelFilterError as ParseError};
+
+// === impl LevelFilter ===
+
+impl<S: Subscriber> crate::Layer<S> for LevelFilter {
+    fn register_callsite(&self, metadata: &'static Metadata<'static>) -> Interest {
+        if self >= metadata.level() {
+            Interest::always()
+        } else {
+            Interest::never()
+        }
+    }
+
+    fn enabled(&self, metadata: &Metadata<'_>, _: crate::layer::Context<'_, S>) -> bool {
+        self >= metadata.level()
+    }
+
+    fn max_level_hint(&self) -> Option<LevelFilter> {
+        Some(*self)
+    }
+}
diff --git a/vendor/tracing-subscriber-0.3.3/src/filter/mod.rs b/vendor/tracing-subscriber-0.3.3/src/filter/mod.rs
new file mode 100644
index 000000000..000a27195
--- /dev/null
+++ b/vendor/tracing-subscriber-0.3.3/src/filter/mod.rs
@@ -0,0 +1,66 @@
+//! [`Layer`]s that control which spans and events are enabled by the wrapped
+//! subscriber.
+//!
+//! This module contains a number of types that provide implementations of
+//! various strategies for filtering which spans and events are enabled. For
+//! details on filtering spans and events using [`Layer`]s, see the
+//! [`layer` module's documentation].
+//!
+//! [`layer` module's documentation]: crate::layer#filtering-with-layers
+//! [`Layer`]: crate::layer
+mod filter_fn;
+
+feature! {
+    #![all(feature = "env-filter", feature = "std")]
+    mod env;
+    pub use self::env::*;
+}
+
+feature! {
+    #![all(feature = "registry", feature = "std")]
+    mod layer_filters;
+    pub use self::layer_filters::*;
+}
+
+mod level;
+
+pub use self::filter_fn::*;
+pub use self::level::{LevelFilter, ParseError as LevelParseError};
+
+#[cfg(not(all(feature = "registry", feature = "std")))]
+pub(crate) use self::has_plf_stubs::*;
+
+feature! {
+    #![any(feature = "std", feature = "alloc")]
+    pub mod targets;
+    pub use self::targets::Targets;
+
+    mod directive;
+    pub use self::directive::ParseError;
+}
+
+/// Stub implementations of the per-layer-fitler detection functions for when the
+/// `registry` feature is disabled.
+#[cfg(not(all(feature = "registry", feature = "std")))]
+mod has_plf_stubs {
+    pub(crate) fn is_plf_downcast_marker(_: core::any::TypeId) -> bool {
+        false
+    }
+
+    /// Does a type implementing `Subscriber` contain any per-layer filters?
+    pub(crate) fn subscriber_has_plf<S>(_: &S) -> bool
+    where
+        S: tracing_core::Subscriber,
+    {
+        false
+    }
+
+    /// Does a type implementing `Layer` contain any per-layer filters?
+    pub(crate) fn layer_has_plf<L, S>(_: &L) -> bool
+    where
+        L: crate::Layer<S>,
+        S: tracing_core::Subscriber,
+    {
+        false
+    }
+}
diff --git a/vendor/tracing-subscriber-0.3.3/src/filter/targets.rs b/vendor/tracing-subscriber-0.3.3/src/filter/targets.rs
new file mode 100644
index 000000000..e0c7fcf82
--- /dev/null
+++ b/vendor/tracing-subscriber-0.3.3/src/filter/targets.rs
@@ -0,0 +1,681 @@
+//! A [filter] that enables or disables spans and events based on their [target] and [level].
+//!
+//! See [`Targets`] for details.
+//!
+//! [target]: tracing_core::Metadata::target
+//! [level]: tracing_core::Level
+//! [filter]: crate::layer#filtering-with-layers
+
+use crate::{
+    filter::{
+        directive::{DirectiveSet, ParseError, StaticDirective},
+        LevelFilter,
+    },
+    layer,
+};
+#[cfg(not(feature = "std"))]
+use alloc::string::String;
+use core::{
+    iter::{Extend, FilterMap, FromIterator},
+    slice,
+    str::FromStr,
+};
+use tracing_core::{Interest, Metadata, Subscriber};
+
+/// A filter that enables or disables spans and events based on their [target]
+/// and [level].
+///
+/// Targets are typically equal to the Rust module path of the code where the
+/// span or event was recorded, although they may be overridden.
+///
+/// This type can be used for both [per-layer filtering][plf] (using its
+/// [`Filter`] implementation) and [global filtering][global] (using its
+/// [`Layer`] implementation).
+///
+/// See the [documentation on filtering with layers][filtering] for details.
+///
+/// # Filtering With `Targets`
+///
+/// A `Targets` filter consists of one or more [target] prefixes, paired with
+/// [`LevelFilter`]s. If a span or event's [target] begins with one of those
+/// prefixes, and its [level] is at or below the [`LevelFilter`] enabled for
+/// that prefix, then the span or event will be enabled.
+///
+/// This is similar to the behavior implemented by the [`env_logger` crate] in
+/// the `log` ecosystem.
+///
+/// The [`EnvFilter`] type also provided by this crate is very similar to `Targets`,
+/// but is capable of a more sophisticated form of filtering where events may
+/// also be enabled or disabled based on the span they are recorded in.
+/// `Targets` can be thought of as a lighter-weight form of [`EnvFilter`] that
+/// can be used instead when this dynamic filtering is not required.
+///
+/// # Examples
+///
+/// A `Targets` filter can be constructed by programmatically adding targets and
+/// levels to enable:
+///
+/// ```
+/// use tracing_subscriber::{filter, prelude::*};
+/// use tracing_core::Level;
+///
+/// let filter = filter::Targets::new()
+///     // Enable the `INFO` level for anything in `my_crate`
+///     .with_target("my_crate", Level::INFO)
+///     // Enable the `DEBUG` level for a specific module.
+///     .with_target("my_crate::interesting_module", Level::DEBUG);
+///
+/// // Build a new subscriber with the `fmt` layer using the `Targets`
+/// // filter we constructed above.
+/// tracing_subscriber::registry()
+///     .with(tracing_subscriber::fmt::layer())
+///     .with(filter)
+///     .init();
+/// ```
+///
+/// [`LevelFilter::OFF`] can be used to disable a particular target:
+/// ```
+/// use tracing_subscriber::filter::{Targets, LevelFilter};
+/// use tracing_core::Level;
+///
+/// let filter = Targets::new()
+///     .with_target("my_crate", Level::INFO)
+///     // Disable all traces from `annoying_module`.
+///     .with_target("my_crate::annoying_module", LevelFilter::OFF);
+/// # drop(filter);
+/// ```
+///
+/// Alternatively, `Targets` implements [`std::str::FromStr`], allowing it to be
+/// parsed from a comma-delimited list of `target=level` pairs. For example:
+///
+/// ```rust
+/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
+/// use tracing_subscriber::filter;
+/// use tracing_core::Level;
+///
+/// let filter = "my_crate=info,my_crate::interesting_module=trace,other_crate=debug"
+///     .parse::<filter::Targets>()?;
+///
+/// // The parsed filter is identical to a filter constructed using `with_target`:
+/// assert_eq!(
+///     filter,
+///     filter::Targets::new()
+///         .with_target("my_crate", Level::INFO)
+///         .with_target("my_crate::interesting_module", Level::TRACE)
+///         .with_target("other_crate", Level::DEBUG)
+/// );
+/// # Ok(()) }
+/// ```
+///
+/// This is particularly useful when the list of enabled targets is configurable
+/// by the user at runtime.
+///
+/// The `Targets` filter can be used as a [per-layer filter][plf] *and* as a
+/// [global filter]:
+///
+/// ```rust
+/// use tracing_subscriber::{
+///     fmt,
+///     filter::{Targets, LevelFilter},
+///     prelude::*,
+/// };
+/// use tracing_core::Level;
+/// use std::{sync::Arc, fs::File};
+/// # fn docs() -> Result<(), Box<dyn std::error::Error>> {
+///
+/// // A layer that logs events to stdout using the human-readable "pretty"
+/// // format.
+/// let stdout_log = fmt::layer().pretty();
+///
+/// // A layer that logs events to a file, using the JSON format.
+/// let file = File::create("debug_log.json")?;
+/// let debug_log = fmt::layer()
+///     .with_writer(Arc::new(file))
+///     .json();
+///
+/// tracing_subscriber::registry()
+///     // Only log INFO and above to stdout, unless the span or event
+///     // has the `my_crate::cool_module` target prefix.
+///     .with(stdout_log
+///         .with_filter(
+///             Targets::default()
+///                 .with_target("my_crate::cool_module", Level::DEBUG)
+///                 .with_default(Level::INFO)
+///        )
+///     )
+///     // Log everything enabled by the global filter to `debug_log.json`.
+///     .with(debug_log)
+///     // Configure a global filter for the whole subscriber stack. This will
+///     // control what spans and events are recorded by both the `debug_log`
+///     // and the `stdout_log` layers, and `stdout_log` will *additionally* be
+///     // filtered by its per-layer filter.
+///     .with(
+///         Targets::default()
+///             .with_target("my_crate", Level::TRACE)
+///             .with_target("other_crate", Level::INFO)
+///             .with_target("other_crate::annoying_module", LevelFilter::OFF)
+///             .with_target("third_crate", Level::DEBUG)
+///     ).init();
+/// # Ok(()) }
+///```
+///
+/// [target]: tracing_core::Metadata::target
+/// [level]: tracing_core::Level
+/// [`Filter`]: crate::layer::Filter
+/// [`Layer`]: crate::layer::Layer
+/// [plf]: crate::layer#per-layer-filtering
+/// [global]: crate::layer#global-filtering
+/// [filtering]: crate::layer#filtering-with-layers
+/// [`env_logger` crate]: https://docs.rs/env_logger/0.9.0/env_logger/index.html#enabling-logging
+/// [`EnvFilter`]: crate::filter::EnvFilter
+#[derive(Debug, Default, Clone, PartialEq)]
+pub struct Targets(DirectiveSet<StaticDirective>);
+
+impl Targets {
+    /// Returns a new `Targets` filter.
+    ///
+    /// This filter will enable no targets. Call [`with_target`] or [`with_targets`]
+    /// to add enabled targets, and [`with_default`] to change the default level
+    /// enabled for spans and events that didn't match any of the provided targets.
+    ///
+    /// [`with_target`]: Targets::with_target
+    /// [`with_targets`]: Targets::with_targets
+    /// [`with_default`]: Targets::with_default
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Enables spans and events with [target]s starting with the provided target
+    /// prefix if they are at or below the provided [`LevelFilter`].
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use tracing_subscriber::filter;
+    /// use tracing_core::Level;
+    ///
+    /// let filter = filter::Targets::new()
+    ///     // Enable the `INFO` level for anything in `my_crate`
+    ///     .with_target("my_crate", Level::INFO)
+    ///     // Enable the `DEBUG` level for a specific module.
+    ///     .with_target("my_crate::interesting_module", Level::DEBUG);
+    /// # drop(filter);
+    /// ```
+    ///
+    /// [`LevelFilter::OFF`] can be used to disable a particular target:
+    /// ```
+    /// use tracing_subscriber::filter::{Targets, LevelFilter};
+    /// use tracing_core::Level;
+    ///
+    /// let filter = Targets::new()
+    ///     .with_target("my_crate", Level::INFO)
+    ///     // Disable all traces from `annoying_module`.
+    ///     .with_target("my_crate::interesting_module", LevelFilter::OFF);
+    /// # drop(filter);
+    /// ```
+    ///
+    /// [target]: tracing_core::Metadata::target
+    pub fn with_target(mut self, target: impl Into<String>, level: impl Into<LevelFilter>) -> Self {
+        self.0.add(StaticDirective::new(
+            Some(target.into()),
+            Default::default(),
+            level.into(),
+        ));
+        self
+    }
+    /// Adds [target]s from an iterator of [target]-[`LevelFilter`] pairs to this filter.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use tracing_subscriber::filter;
+    /// use tracing_core::Level;
+    ///
+    /// let filter = filter::Targets::new()
+    ///     .with_targets(vec![
+    ///         ("my_crate", Level::INFO),
+    ///         ("my_crate::some_module", Level::DEBUG),
+    ///         ("my_crate::other_module::cool_stuff", Level::TRACE),
+    ///         ("other_crate", Level::WARN)
+    ///     ]);
+    /// # drop(filter);
+    /// ```
+    ///
+    /// [`LevelFilter::OFF`] can be used to disable a particular target:
+    /// ```
+    /// use tracing_subscriber::filter::{Targets, LevelFilter};
+    /// use tracing_core::Level;
+    ///
+    /// let filter = Targets::new()
+    ///     .with_target("my_crate", Level::INFO)
+    ///     // Disable all traces from `annoying_module`.
+    ///     .with_target("my_crate::interesting_module", LevelFilter::OFF);
+    /// # drop(filter);
+    /// ```
+    ///
+    /// [target]: tracing_core::Metadata::target
+    pub fn with_targets<T, L>(mut self, targets: impl IntoIterator<Item = (T, L)>) -> Self
+    where
+        String: From<T>,
+        LevelFilter: From<L>,
+    {
+        self.extend(targets);
+        self
+    }
+
+    /// Sets the default level to enable for spans and events whose targets did
+    /// not match any of the configured prefixes.
+    ///
+    /// By default, this is [`LevelFilter::OFF`]. This means that spans and
+    /// events will only be enabled if they match one of the configured target
+    /// prefixes. If this is changed to a different [`LevelFilter`], spans and
+    /// events with targets that did not match any of the configured prefixes
+    /// will be enabled if their level is at or below the provided level.
+    pub fn with_default(mut self, level: impl Into<LevelFilter>) -> Self {
+        self.0
+            .add(StaticDirective::new(None, Default::default(), level.into()));
+        self
+    }
+
+    /// Returns an iterator over the [target]-[`LevelFilter`] pairs in this filter.
+    ///
+    /// The order of iteration is undefined.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use tracing_subscriber::filter::{Targets, LevelFilter};
+    /// use tracing_core::Level;
+    ///
+    /// let filter = Targets::new()
+    ///     .with_target("my_crate", Level::INFO)
+    ///     .with_target("my_crate::interesting_module", Level::DEBUG);
+    ///
+    /// let mut targets: Vec<_> = filter.iter().collect();
+    /// targets.sort();
+    ///
+    /// assert_eq!(targets, vec![
+    ///     ("my_crate", LevelFilter::INFO),
+    ///     ("my_crate::interesting_module", LevelFilter::DEBUG),
+    /// ]);
+    /// ```
+    ///
+    /// [target]: tracing_core::Metadata::target
+    pub fn iter(&self) -> Iter<'_> {
+        self.into_iter()
+    }
+
+    #[inline]
+    fn interested(&self, metadata: &'static Metadata<'static>) -> Interest {
+        if self.0.enabled(metadata) {
+            Interest::always()
+        } else {
+            Interest::never()
+        }
+    }
+}
+
+impl<T, L> Extend<(T, L)> for Targets
+where
+    T: Into<String>,
+    L: Into<LevelFilter>,
+{
+    fn extend<I: IntoIterator<Item = (T, L)>>(&mut self, iter: I) {
+        let iter = iter.into_iter().map(|(target, level)| {
+            StaticDirective::new(Some(target.into()), Default::default(), level.into())
+        });
+        self.0.extend(iter);
+    }
+}
+
+impl<T, L> FromIterator<(T, L)> for Targets
+where
+    T: Into<String>,
+    L: Into<LevelFilter>,
+{
+    fn from_iter<I: IntoIterator<Item = (T, L)>>(iter: I) -> Self {
+        let mut this = Self::default();
+        this.extend(iter);
+        this
+    }
+}
+
+impl FromStr for Targets {
+    type Err = ParseError;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        s.split(',')
+            .map(StaticDirective::from_str)
+            .collect::<Result<_, _>>()
+            .map(Self)
+    }
+}
+
+impl<S> layer::Layer<S> for Targets
+where
+    S: Subscriber,
+{
+    fn enabled(&self, metadata: &Metadata<'_>, _: layer::Context<'_, S>) -> bool {
+        self.0.enabled(metadata)
+    }
+
+    fn register_callsite(&self, metadata: &'static Metadata<'static>) -> Interest {
+        self.interested(metadata)
+    }
+
+    fn max_level_hint(&self) -> Option<LevelFilter> {
+        Some(self.0.max_level)
+    }
+}
+
+#[cfg(feature = "registry")]
+#[cfg_attr(docsrs, doc(cfg(feature = "registry")))]
+impl<S> layer::Filter<S> for Targets {
+    fn enabled(&self, metadata: &Metadata<'_>, _: &layer::Context<'_, S>) -> bool {
+        self.0.enabled(metadata)
+    }
+
+    fn callsite_enabled(&self, metadata: &'static Metadata<'static>) -> Interest {
+        self.interested(metadata)
+    }
+
+    fn max_level_hint(&self) -> Option<LevelFilter> {
+        Some(self.0.max_level)
+    }
+}
+
+impl IntoIterator for Targets {
+    type Item = (String, LevelFilter);
+
+    type IntoIter = IntoIter;
+
+    fn into_iter(self) -> Self::IntoIter {
+        IntoIter::new(self)
+    }
+}
+
+impl<'a> IntoIterator for &'a Targets {
+    type Item = (&'a str, LevelFilter);
+
+    type IntoIter = Iter<'a>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        Iter::new(self)
+    }
+}
+
+/// An owning iterator over the [target]-[level] pairs of a `Targets` filter.
+///
+/// This struct is created by the `IntoIterator` trait implementation of [`Targets`].
+///
+/// # Examples
+///
+/// Merge the targets from one `Targets` with another:
+///
+/// ```
+/// use tracing_subscriber::filter::Targets;
+/// use tracing_core::Level;
+///
+/// let mut filter = Targets::new().with_target("my_crate", Level::INFO);
+/// let overrides = Targets::new().with_target("my_crate::interesting_module", Level::DEBUG);
+///
+/// filter.extend(overrides);
+/// # drop(filter);
+/// ```
+///
+/// [target]: tracing_core::Metadata::target
+/// [level]: tracing_core::Level
+#[derive(Debug)]
+pub struct IntoIter(
+    #[allow(clippy::type_complexity)] // alias indirection would probably make this more confusing
+    FilterMap<
+        <DirectiveSet<StaticDirective> as IntoIterator>::IntoIter,
+        fn(StaticDirective) -> Option<(String, LevelFilter)>,
+    >,
+);
+
+impl IntoIter {
+    fn new(targets: Targets) -> Self {
+        Self(targets.0.into_iter().filter_map(|directive| {
+            let level = directive.level;
+            directive.target.map(|target| (target, level))
+        }))
+    }
+}
+
+impl Iterator for IntoIter {
+    type Item = (String, LevelFilter);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.0.next()
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.0.size_hint()
+    }
+}
+
+/// A borrowing iterator over the [target]-[level] pairs of a `Targets` filter.
+///
+/// This struct is created by [`iter`] method of [`Targets`], or from the `IntoIterator`
+/// implementation for `&Targets`.
+///
+/// [target]: tracing_core::Metadata::target
+/// [level]: tracing_core::Level
+/// [`iter`]: Targets::iter
+#[derive(Debug)]
+pub struct Iter<'a>(
+    FilterMap<
+        slice::Iter<'a, StaticDirective>,
+        fn(&'a StaticDirective) -> Option<(&'a str, LevelFilter)>,
+    >,
+);
+
+impl<'a> Iter<'a> {
+    fn new(targets: &'a Targets) -> Self {
+        Self(targets.0.iter().filter_map(|directive| {
+            directive
+                .target
+                .as_deref()
+                .map(|target| (target, directive.level))
+        }))
+    }
+}
+
+impl<'a> Iterator for Iter<'a> {
+    type Item = (&'a str, LevelFilter);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.0.next()
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.0.size_hint()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    feature! {
+        #![not(feature = "std")]
+        use alloc::{vec, vec::Vec, string::ToString};
+
+        // `dbg!` is only available with `libstd`; just nop it out when testing
+        // with alloc only.
+        macro_rules! dbg {
+            ($x:expr) => { $x }
+        }
+    }
+
+    fn expect_parse(s: &str) -> Targets {
+        match dbg!(s).parse::<Targets>() {
+            Err(e) => panic!("string {:?} did not parse successfully: {}", s, e),
+            Ok(e) => e,
+        }
+    }
+
+    fn expect_parse_ralith(s: &str) {
+        let dirs = expect_parse(s).0.into_vec();
+        assert_eq!(dirs.len(), 2, "\nparsed: {:#?}", dirs);
+        assert_eq!(dirs[0].target, Some("server".to_string()));
+        assert_eq!(dirs[0].level, LevelFilter::DEBUG);
+        assert_eq!(dirs[0].field_names, Vec::<String>::new());
+
+        assert_eq!(dirs[1].target, Some("common".to_string()));
+        assert_eq!(dirs[1].level, LevelFilter::INFO);
+        assert_eq!(dirs[1].field_names, Vec::<String>::new());
+    }
+
+    fn expect_parse_level_directives(s: &str) {
+        let dirs = expect_parse(s).0.into_vec();
+        assert_eq!(dirs.len(), 6, "\nparsed: {:#?}", dirs);
+
+        assert_eq!(dirs[0].target, Some("crate3::mod2::mod1".to_string()));
+        assert_eq!(dirs[0].level, LevelFilter::OFF);
+        assert_eq!(dirs[0].field_names, Vec::<String>::new());
+
+        assert_eq!(dirs[1].target, Some("crate1::mod2::mod3".to_string()));
+        assert_eq!(dirs[1].level, LevelFilter::INFO);
+        assert_eq!(dirs[1].field_names, Vec::<String>::new());
+
+        assert_eq!(dirs[2].target, Some("crate1::mod2".to_string()));
+        assert_eq!(dirs[2].level, LevelFilter::WARN);
+        assert_eq!(dirs[2].field_names, Vec::<String>::new());
+
+        assert_eq!(dirs[3].target, Some("crate1::mod1".to_string()));
+        assert_eq!(dirs[3].level, LevelFilter::ERROR);
+        assert_eq!(dirs[3].field_names, Vec::<String>::new());
+
+        assert_eq!(dirs[4].target, Some("crate3".to_string()));
+        assert_eq!(dirs[4].level, LevelFilter::TRACE);
+        assert_eq!(dirs[4].field_names, Vec::<String>::new());
+
+        assert_eq!(dirs[5].target, Some("crate2".to_string()));
+        assert_eq!(dirs[5].level, LevelFilter::DEBUG);
+        assert_eq!(dirs[5].field_names, Vec::<String>::new());
+    }
+
+    #[test]
+    fn parse_ralith() {
+        expect_parse_ralith("common=info,server=debug");
+    }
+
+    #[test]
+    fn parse_ralith_uc() {
+        expect_parse_ralith("common=INFO,server=DEBUG");
+    }
+
+    #[test]
+    fn parse_ralith_mixed() {
+        expect_parse("common=iNfo,server=dEbUg");
+    }
+
+    #[test]
+    fn expect_parse_valid() {
+        let dirs = expect_parse("crate1::mod1=error,crate1::mod2,crate2=debug,crate3=off")
+            .0
+            .into_vec();
+        assert_eq!(dirs.len(), 4, "\nparsed: {:#?}", dirs);
+        assert_eq!(dirs[0].target, Some("crate1::mod2".to_string()));
+        assert_eq!(dirs[0].level, LevelFilter::TRACE);
+        assert_eq!(dirs[0].field_names, Vec::<String>::new());
+
+        assert_eq!(dirs[1].target, Some("crate1::mod1".to_string()));
+        assert_eq!(dirs[1].level, LevelFilter::ERROR);
+        assert_eq!(dirs[1].field_names, Vec::<String>::new());
+
+        assert_eq!(dirs[2].target, Some("crate3".to_string()));
+        assert_eq!(dirs[2].level, LevelFilter::OFF);
+        assert_eq!(dirs[2].field_names, Vec::<String>::new());
+
+        assert_eq!(dirs[3].target, Some("crate2".to_string()));
+        assert_eq!(dirs[3].level, LevelFilter::DEBUG);
+        assert_eq!(dirs[3].field_names, Vec::<String>::new());
+    }
+
+    #[test]
+    fn parse_level_directives() {
+        expect_parse_level_directives(
+            "crate1::mod1=error,crate1::mod2=warn,crate1::mod2::mod3=info,\
+             crate2=debug,crate3=trace,crate3::mod2::mod1=off",
+        )
+    }
+
+    #[test]
+    fn parse_uppercase_level_directives() {
+        expect_parse_level_directives(
+            "crate1::mod1=ERROR,crate1::mod2=WARN,crate1::mod2::mod3=INFO,\
+             crate2=DEBUG,crate3=TRACE,crate3::mod2::mod1=OFF",
+        )
+    }
+
+    #[test]
+    fn parse_numeric_level_directives() {
+        expect_parse_level_directives(
+            "crate1::mod1=1,crate1::mod2=2,crate1::mod2::mod3=3,crate2=4,\
+             crate3=5,crate3::mod2::mod1=0",
+        )
+    }
+
+    #[test]
+    fn targets_iter() {
+        let filter = expect_parse("crate1::mod1=error,crate1::mod2,crate2=debug,crate3=off")
+            .with_default(LevelFilter::WARN);
+
+        let mut targets: Vec<_> = filter.iter().collect();
+        targets.sort();
+
+        assert_eq!(
+            targets,
+            vec![
+                ("crate1::mod1", LevelFilter::ERROR),
+                ("crate1::mod2", LevelFilter::TRACE),
+                ("crate2", LevelFilter::DEBUG),
+                ("crate3", LevelFilter::OFF),
+            ]
+        );
+    }
+
+    #[test]
+    fn targets_into_iter() {
+        let filter = expect_parse("crate1::mod1=error,crate1::mod2,crate2=debug,crate3=off")
+            .with_default(LevelFilter::WARN);
+
+        let mut targets: Vec<_> = filter.into_iter().collect();
+        targets.sort();
+
+        assert_eq!(
+            targets,
+            vec![
+                ("crate1::mod1".to_string(), LevelFilter::ERROR),
+                ("crate1::mod2".to_string(), LevelFilter::TRACE),
+                ("crate2".to_string(), LevelFilter::DEBUG),
+                ("crate3".to_string(), LevelFilter::OFF),
+            ]
+        );
+    }
+
+    #[test]
+    // `println!` is only available with `libstd`.
+    #[cfg(feature = "std")]
+    fn size_of_filters() {
+        fn print_sz(s: &str) {
+            let filter = s.parse::<Targets>().expect("filter should parse");
+            println!(
+                "size_of_val({:?})\n -> {}B",
+                s,
+                std::mem::size_of_val(&filter)
+            );
+        }
+
+        print_sz("info");
+
+        print_sz("foo=debug");
+
+        print_sz(
+            "crate1::mod1=error,crate1::mod2=warn,crate1::mod2::mod3=info,\
+            crate2=debug,crate3=trace,crate3::mod2::mod1=off",
+        );
+    }
+}
diff --git a/vendor/tracing-subscriber-0.3.3/src/fmt/fmt_layer.rs b/vendor/tracing-subscriber-0.3.3/src/fmt/fmt_layer.rs
new file mode 100644
index 000000000..0e0d5e0eb
--- /dev/null
+++ b/vendor/tracing-subscriber-0.3.3/src/fmt/fmt_layer.rs
@@ -0,0 +1,1205 @@
+use crate::{
+    field::RecordFields,
+    fmt::{format, FormatEvent, FormatFields, MakeWriter, TestWriter},
+    layer::{self, Context},
+    registry::{self, LookupSpan, SpanRef},
+};
+use format::{FmtSpan, TimingDisplay};
+use std::{any::TypeId, cell::RefCell, fmt, io, marker::PhantomData, ops::Deref, time::Instant};
+use tracing_core::{
+    field,
+    span::{Attributes, Current, Id, Record},
+    Event, Metadata, Subscriber,
+};
+
+/// A [`Layer`] that logs formatted representations of `tracing` events.
+///
+/// ## Examples
+///
+/// Constructing a layer with the default configuration:
+///
+/// ```rust
+/// use tracing_subscriber::{fmt, Registry};
+/// use tracing_subscriber::prelude::*;
+///
+/// let subscriber = Registry::default()
+///     .with(fmt::Layer::default());
+///
+/// tracing::subscriber::set_global_default(subscriber).unwrap();
+/// ```
+///
+/// Overriding the layer's behavior:
+///
+/// ```rust
+/// use tracing_subscriber::{fmt, Registry};
+/// use tracing_subscriber::prelude::*;
+///
+/// let fmt_layer = fmt::layer()
+///    .with_target(false) // don't include event targets when logging
+///    .with_level(false); // don't include event levels when logging
+///
+/// let subscriber = Registry::default().with(fmt_layer);
+/// # tracing::subscriber::set_global_default(subscriber).unwrap();
+/// ```
+///
+/// Setting a custom event formatter:
+///
+/// ```rust
+/// use tracing_subscriber::fmt::{self, format, time};
+/// use tracing_subscriber::prelude::*;
+///
+/// let fmt = format().with_timer(time::Uptime::default());
+/// let fmt_layer = fmt::layer()
+///     .event_format(fmt)
+///     .with_target(false);
+/// # let subscriber = fmt_layer.with_subscriber(tracing_subscriber::registry::Registry::default());
+/// # tracing::subscriber::set_global_default(subscriber).unwrap();
+/// ```
+///
+/// [`Layer`]: ../layer/trait.Layer.html
+#[cfg_attr(docsrs, doc(cfg(all(feature = "fmt", feature = "std"))))]
+#[derive(Debug)]
+pub struct Layer<
+    S,
+    N = format::DefaultFields,
+    E = format::Format<format::Full>,
+    W = fn() -> io::Stdout,
+> {
+    make_writer: W,
+    fmt_fields: N,
+    fmt_event: E,
+    fmt_span: format::FmtSpanConfig,
+    is_ansi: bool,
+    _inner: PhantomData<S>,
+}
+
+impl<S> Layer<S> {
+    /// Returns a new [`Layer`](struct.Layer.html) with the default configuration.
+    pub fn new() -> Self {
+        Self::default()
+    }
+}
+
+// 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>
+where
+    S: Subscriber + for<'a> LookupSpan<'a>,
+    N: for<'writer> FormatFields<'writer> + 'static,
+    W: for<'writer> MakeWriter<'writer> + 'static,
+{
+    /// 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
+    /// [`Writer`], and an [`Event`].
+    ///
+    /// # Examples
+    ///
+    /// Setting a type implementing [`FormatEvent`] as the formatter:
+    /// ```rust
+    /// use tracing_subscriber::fmt::{self, format};
+    ///
+    /// let layer = fmt::layer()
+    ///     .event_format(format().compact());
+    /// # // this is necessary for type inference.
+    /// # use tracing_subscriber::Layer as _;
+    /// # let _ = layer.with_subscriber(tracing_subscriber::registry::Registry::default());
+    /// ```
+    /// [`FormatEvent`]: format::FormatEvent
+    /// [`Event`]: tracing::Event
+    /// [`Writer`]: crate::format::Writer
+    pub fn event_format<E2>(self, e: E2) -> Layer<S, N, E2, W>
+    where
+        E2: FormatEvent<S, N> + 'static,
+    {
+        Layer {
+            fmt_fields: self.fmt_fields,
+            fmt_event: e,
+            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.
+    ///
+    /// # Examples
+    ///
+    /// Using `stderr` rather than `stdout`:
+    ///
+    /// ```rust
+    /// use std::io;
+    /// use tracing_subscriber::fmt;
+    ///
+    /// let layer = fmt::layer()
+    ///     .with_writer(io::stderr);
+    /// # // this is necessary for type inference.
+    /// # 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,
+    {
+        Layer {
+            fmt_fields: self.fmt_fields,
+            fmt_event: self.fmt_event,
+            fmt_span: self.fmt_span,
+            is_ansi: self.is_ansi,
+            make_writer,
+            _inner: self._inner,
+        }
+    }
+
+    /// 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:
+    ///
+    /// ```rust
+    /// use std::io;
+    /// use tracing_subscriber::fmt;
+    ///
+    /// let layer = fmt::layer()
+    ///     .with_test_writer();
+    /// # // this is necessary for type inference.
+    /// # use tracing_subscriber::Layer as _;
+    /// # let _ = layer.with_subscriber(tracing_subscriber::registry::Registry::default());
+    /// ```
+    /// [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) -> Layer<S, N, E, TestWriter> {
+        Layer {
+            fmt_fields: self.fmt_fields,
+            fmt_event: self.fmt_event,
+            fmt_span: self.fmt_span,
+            is_ansi: self.is_ansi,
+            make_writer: TestWriter::default(),
+            _inner: self._inner,
+        }
+    }
+
+    /// Enable ANSI terminal colors for formatted output.
+    #[cfg(feature = "ansi")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "ansi")))]
+    pub fn with_ansi(self, ansi: bool) -> Self {
+        Self {
+            is_ansi: ansi,
+            ..self
+        }
+    }
+}
+
+impl<S, N, L, T, W> Layer<S, N, format::Format<L, T>, W>
+where
+    N: for<'writer> FormatFields<'writer> + 'static,
+{
+    /// Use the given [`timer`] for span and event 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`]: 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) -> Layer<S, N, format::Format<L, T2>, W> {
+        Layer {
+            fmt_event: self.fmt_event.with_timer(timer),
+            fmt_fields: self.fmt_fields,
+            fmt_span: self.fmt_span,
+            make_writer: self.make_writer,
+            is_ansi: self.is_ansi,
+            _inner: self._inner,
+        }
+    }
+
+    /// Do not emit timestamps with spans and event.
+    pub fn without_time(self) -> Layer<S, N, format::Format<L, ()>, W> {
+        Layer {
+            fmt_event: self.fmt_event.without_time(),
+            fmt_fields: self.fmt_fields,
+            fmt_span: self.fmt_span.without_time(),
+            make_writer: self.make_writer,
+            is_ansi: self.is_ansi,
+            _inner: self._inner,
+        }
+    }
+
+    /// 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`: Events 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;
+    /// use tracing_subscriber::fmt::format::FmtSpan;
+    ///
+    /// 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: FmtSpan) -> Self {
+        Layer {
+            fmt_span: self.fmt_span.with_kind(kind),
+            ..self
+        }
+    }
+
+    /// Sets whether or not an event's target is displayed.
+    pub fn with_target(self, display_target: bool) -> Layer<S, N, format::Format<L, T>, W> {
+        Layer {
+            fmt_event: self.fmt_event.with_target(display_target),
+            ..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> {
+        Layer {
+            fmt_event: self.fmt_event.with_level(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_ids: bool) -> Layer<S, N, format::Format<L, T>, W> {
+        Layer {
+            fmt_event: self.fmt_event.with_thread_ids(display_thread_ids),
+            ..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,
+    ) -> Layer<S, N, format::Format<L, T>, W> {
+        Layer {
+            fmt_event: self.fmt_event.with_thread_names(display_thread_names),
+            ..self
+        }
+    }
+
+    /// 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,
+    {
+        Layer {
+            fmt_event: self.fmt_event.compact(),
+            fmt_fields: self.fmt_fields,
+            fmt_span: self.fmt_span,
+            make_writer: self.make_writer,
+            is_ansi: self.is_ansi,
+            _inner: self._inner,
+        }
+    }
+
+    /// Sets the layer 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) -> Layer<S, format::Pretty, format::Format<format::Pretty, T>, W> {
+        Layer {
+            fmt_event: self.fmt_event.pretty(),
+            fmt_fields: format::Pretty::default(),
+            fmt_span: self.fmt_span,
+            make_writer: self.make_writer,
+            is_ansi: self.is_ansi,
+            _inner: self._inner,
+        }
+    }
+
+    /// Sets the layer being built to use a [JSON formatter](../fmt/format/struct.Json.html).
+    ///
+    /// 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
+    ///
+    /// - [`Layer::flatten_event`] can be used to enable flattening event fields into the root
+    /// object.
+    ///
+    /// [`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> {
+        Layer {
+            fmt_event: self.fmt_event.json(),
+            fmt_fields: format::JsonFields::new(),
+            fmt_span: self.fmt_span,
+            make_writer: self.make_writer,
+            // always disable ANSI escapes in JSON mode!
+            is_ansi: false,
+            _inner: self._inner,
+        }
+    }
+}
+
+#[cfg(feature = "json")]
+#[cfg_attr(docsrs, doc(cfg(feature = "json")))]
+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`](../fmt/format/struct.Json.html)
+    pub fn flatten_event(
+        self,
+        flatten_event: bool,
+    ) -> Layer<S, format::JsonFields, format::Format<format::Json, T>, W> {
+        Layer {
+            fmt_event: self.fmt_event.flatten_event(flatten_event),
+            fmt_fields: format::JsonFields::new(),
+            ..self
+        }
+    }
+
+    /// Sets whether or not the formatter 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,
+    ) -> Layer<S, format::JsonFields, format::Format<format::Json, T>, W> {
+        Layer {
+            fmt_event: self.fmt_event.with_current_span(display_current_span),
+            fmt_fields: format::JsonFields::new(),
+            ..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)
+    pub fn with_span_list(
+        self,
+        display_span_list: bool,
+    ) -> Layer<S, format::JsonFields, format::Format<format::Json, T>, W> {
+        Layer {
+            fmt_event: self.fmt_event.with_span_list(display_span_list),
+            fmt_fields: format::JsonFields::new(),
+            ..self
+        }
+    }
+}
+
+impl<S, N, E, W> Layer<S, N, E, W> {
+    /// Sets the field formatter that the layer being built will use to record
+    /// fields.
+    pub fn fmt_fields<N2>(self, fmt_fields: N2) -> Layer<S, N2, E, W>
+    where
+        N2: for<'writer> FormatFields<'writer> + 'static,
+    {
+        Layer {
+            fmt_event: self.fmt_event,
+            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> {
+    fn default() -> Self {
+        Layer {
+            fmt_fields: format::DefaultFields::default(),
+            fmt_event: format::Format::default(),
+            fmt_span: format::FmtSpanConfig::default(),
+            make_writer: io::stdout,
+            is_ansi: cfg!(feature = "ansi"),
+            _inner: PhantomData,
+        }
+    }
+}
+
+impl<S, N, E, W> Layer<S, N, E, W>
+where
+    S: Subscriber + for<'a> LookupSpan<'a>,
+    N: for<'writer> FormatFields<'writer> + 'static,
+    E: FormatEvent<S, N> + 'static,
+    W: for<'writer> MakeWriter<'writer> + 'static,
+{
+    #[inline]
+    fn make_ctx<'a>(&'a self, ctx: Context<'a, S>, event: &'a Event<'a>) -> FmtContext<'a, S, N> {
+        FmtContext {
+            ctx,
+            fmt_fields: &self.fmt_fields,
+            event,
+        }
+    }
+}
+
+/// A formatted representation of a span's fields stored in its [extensions].
+///
+/// Because `FormattedFields` is generic over the type of the formatter that
+/// produced it, multiple versions of a span's formatted fields can be stored in
+/// the [`Extensions`][extensions] type-map. This means that when multiple
+/// formatters are in use, each can store its own formatted representation
+/// without conflicting.
+///
+/// [extensions]: ../registry/struct.Extensions.html
+#[derive(Default)]
+pub struct FormattedFields<E: ?Sized> {
+    _format_fields: PhantomData<fn(E)>,
+    was_ansi: bool,
+    /// The formatted fields of a span.
+    pub fields: String,
+}
+
+impl<E: ?Sized> FormattedFields<E> {
+    /// Returns a new `FormattedFields`.
+    pub fn new(fields: String) -> Self {
+        Self {
+            fields,
+            was_ansi: false,
+            _format_fields: PhantomData,
+        }
+    }
+
+    /// Returns a new [`format::Writer`] for writing to this `FormattedFields`.
+    ///
+    /// The returned [`format::Writer`] can be used with the
+    /// [`FormatFields::format_fields`] method.
+    pub fn as_writer(&mut self) -> format::Writer<'_> {
+        format::Writer::new(&mut self.fields).with_ansi(self.was_ansi)
+    }
+}
+
+impl<E: ?Sized> fmt::Debug for FormattedFields<E> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("FormattedFields")
+            .field("fields", &self.fields)
+            .field("formatter", &format_args!("{}", std::any::type_name::<E>()))
+            .field("was_ansi", &self.was_ansi)
+            .finish()
+    }
+}
+
+impl<E: ?Sized> fmt::Display for FormattedFields<E> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(&self.fields, f)
+    }
+}
+
+impl<E: ?Sized> Deref for FormattedFields<E> {
+    type Target = String;
+    fn deref(&self) -> &Self::Target {
+        &self.fields
+    }
+}
+
+// === impl FmtLayer ===
+
+macro_rules! with_event_from_span {
+    ($id:ident, $span:ident, $($field:literal = $value:expr),*, |$event:ident| $code:block) => {
+        let meta = $span.metadata();
+        let cs = meta.callsite();
+        let fs = field::FieldSet::new(&[$($field),*], cs);
+        #[allow(unused)]
+        let mut iter = fs.iter();
+        let v = [$(
+            (&iter.next().unwrap(), Some(&$value as &dyn field::Value)),
+        )*];
+        let vs = fs.value_set(&v);
+        let $event = Event::new_child_of($id, meta, &vs);
+        $code
+    };
+}
+
+impl<S, N, E, W> layer::Layer<S> for Layer<S, N, E, W>
+where
+    S: Subscriber + for<'a> LookupSpan<'a>,
+    N: for<'writer> FormatFields<'writer> + 'static,
+    E: FormatEvent<S, N> + 'static,
+    W: for<'writer> MakeWriter<'writer> + 'static,
+{
+    fn on_new_span(&self, attrs: &Attributes<'_>, id: &Id, ctx: Context<'_, S>) {
+        let span = ctx.span(id).expect("Span not found, this is a bug");
+        let mut extensions = span.extensions_mut();
+
+        if extensions.get_mut::<FormattedFields<N>>().is_none() {
+            let mut fields = FormattedFields::<N>::new(String::new());
+            if self
+                .fmt_fields
+                .format_fields(fields.as_writer().with_ansi(self.is_ansi), attrs)
+                .is_ok()
+            {
+                fields.was_ansi = self.is_ansi;
+                extensions.insert(fields);
+            }
+        }
+
+        if self.fmt_span.fmt_timing
+            && self.fmt_span.trace_close()
+            && extensions.get_mut::<Timings>().is_none()
+        {
+            extensions.insert(Timings::new());
+        }
+
+        if self.fmt_span.trace_new() {
+            with_event_from_span!(id, span, "message" = "new", |event| {
+                drop(extensions);
+                drop(span);
+                self.on_event(&event, ctx);
+            });
+        }
+    }
+
+    fn on_record(&self, id: &Id, values: &Record<'_>, ctx: Context<'_, S>) {
+        let span = ctx.span(id).expect("Span not found, this is a bug");
+        let mut extensions = span.extensions_mut();
+        if let Some(fields) = extensions.get_mut::<FormattedFields<N>>() {
+            let _ = self.fmt_fields.add_fields(fields, values);
+            return;
+        }
+
+        let mut fields = FormattedFields::<N>::new(String::new());
+        if self
+            .fmt_fields
+            .format_fields(fields.as_writer().with_ansi(self.is_ansi), values)
+            .is_ok()
+        {
+            fields.was_ansi = self.is_ansi;
+            extensions.insert(fields);
+        }
+    }
+
+    fn on_enter(&self, id: &Id, ctx: Context<'_, S>) {
+        if self.fmt_span.trace_enter() || self.fmt_span.trace_close() && self.fmt_span.fmt_timing {
+            let span = ctx.span(id).expect("Span not found, this is a bug");
+            let mut extensions = span.extensions_mut();
+            if let Some(timings) = extensions.get_mut::<Timings>() {
+                let now = Instant::now();
+                timings.idle += (now - timings.last).as_nanos() as u64;
+                timings.last = now;
+            }
+
+            if self.fmt_span.trace_enter() {
+                with_event_from_span!(id, span, "message" = "enter", |event| {
+                    drop(extensions);
+                    drop(span);
+                    self.on_event(&event, ctx);
+                });
+            }
+        }
+    }
+
+    fn on_exit(&self, id: &Id, ctx: Context<'_, S>) {
+        if self.fmt_span.trace_exit() || self.fmt_span.trace_close() && self.fmt_span.fmt_timing {
+            let span = ctx.span(id).expect("Span not found, this is a bug");
+            let mut extensions = span.extensions_mut();
+            if let Some(timings) = extensions.get_mut::<Timings>() {
+                let now = Instant::now();
+                timings.busy += (now - timings.last).as_nanos() as u64;
+                timings.last = now;
+            }
+
+            if self.fmt_span.trace_exit() {
+                with_event_from_span!(id, span, "message" = "exit", |event| {
+                    drop(extensions);
+                    drop(span);
+                    self.on_event(&event, ctx);
+                });
+            }
+        }
+    }
+
+    fn on_close(&self, id: Id, ctx: Context<'_, S>) {
+        if self.fmt_span.trace_close() {
+            let span = ctx.span(&id).expect("Span not found, this is a bug");
+            let extensions = span.extensions();
+            if let Some(timing) = extensions.get::<Timings>() {
+                let Timings {
+                    busy,
+                    mut idle,
+                    last,
+                } = *timing;
+                idle += (Instant::now() - last).as_nanos() as u64;
+
+                let t_idle = field::display(TimingDisplay(idle));
+                let t_busy = field::display(TimingDisplay(busy));
+
+                with_event_from_span!(
+                    id,
+                    span,
+                    "message" = "close",
+                    "time.busy" = t_busy,
+                    "time.idle" = t_idle,
+                    |event| {
+                        drop(extensions);
+                        drop(span);
+                        self.on_event(&event, ctx);
+                    }
+                );
+            } else {
+                with_event_from_span!(id, span, "message" = "close", |event| {
+                    drop(extensions);
+                    drop(span);
+                    self.on_event(&event, ctx);
+                });
+            }
+        }
+    }
+
+    fn on_event(&self, event: &Event<'_>, ctx: Context<'_, S>) {
+        thread_local! {
+            static BUF: RefCell<String> = RefCell::new(String::new());
+        }
+
+        BUF.with(|buf| {
+            let borrow = buf.try_borrow_mut();
+            let mut a;
+            let mut b;
+            let mut buf = match borrow {
+                Ok(buf) => {
+                    a = buf;
+                    &mut *a
+                }
+                _ => {
+                    b = String::new();
+                    &mut b
+                }
+            };
+
+            let ctx = self.make_ctx(ctx, event);
+            if self
+                .fmt_event
+                .format_event(
+                    &ctx,
+                    format::Writer::new(&mut buf).with_ansi(self.is_ansi),
+                    event,
+                )
+                .is_ok()
+            {
+                let mut writer = self.make_writer.make_writer_for(event.metadata());
+                let _ = io::Write::write_all(&mut writer, buf.as_bytes());
+            }
+
+            buf.clear();
+        });
+    }
+
+    unsafe fn downcast_raw(&self, id: TypeId) -> Option<*const ()> {
+        // This `downcast_raw` impl allows downcasting a `fmt` layer to any of
+        // its components (event formatter, field formatter, and `MakeWriter`)
+        // as well as to the layer's type itself. The potential use-cases for
+        // this *may* be somewhat niche, though...
+        match () {
+            _ if id == TypeId::of::<Self>() => Some(self as *const Self as *const ()),
+            _ if id == TypeId::of::<E>() => Some(&self.fmt_event as *const E as *const ()),
+            _ if id == TypeId::of::<N>() => Some(&self.fmt_fields as *const N as *const ()),
+            _ if id == TypeId::of::<W>() => Some(&self.make_writer as *const W as *const ()),
+            _ => None,
+        }
+    }
+}
+
+/// Provides the current span context to a formatter.
+pub struct FmtContext<'a, S, N> {
+    pub(crate) ctx: Context<'a, S>,
+    pub(crate) fmt_fields: &'a N,
+    pub(crate) event: &'a Event<'a>,
+}
+
+impl<'a, S, N> fmt::Debug for FmtContext<'a, S, N> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("FmtContext").finish()
+    }
+}
+
+impl<'cx, 'writer, S, N> FormatFields<'writer> for FmtContext<'cx, S, N>
+where
+    S: Subscriber + for<'lookup> LookupSpan<'lookup>,
+    N: FormatFields<'writer> + 'static,
+{
+    fn format_fields<R: RecordFields>(
+        &self,
+        writer: format::Writer<'writer>,
+        fields: R,
+    ) -> fmt::Result {
+        self.fmt_fields.format_fields(writer, fields)
+    }
+}
+
+impl<'a, S, N> FmtContext<'a, S, N>
+where
+    S: Subscriber + for<'lookup> LookupSpan<'lookup>,
+    N: for<'writer> FormatFields<'writer> + 'static,
+{
+    /// Visits every span in the current context with a closure.
+    ///
+    /// The provided closure will be called first with the current span,
+    /// and then with that span's parent, and then that span's parent,
+    /// and so on until a root span is reached.
+    pub fn visit_spans<E, F>(&self, mut f: F) -> Result<(), E>
+    where
+        F: FnMut(&SpanRef<'_, S>) -> Result<(), E>,
+    {
+        // visit all the current spans
+        if let Some(scope) = self.event_scope() {
+            for span in scope.from_root() {
+                f(&span)?;
+            }
+        }
+        Ok(())
+    }
+
+    /// Returns metadata for the span with the given `id`, if it exists.
+    ///
+    /// If this returns `None`, then no span exists for that ID (either it has
+    /// closed or the ID is invalid).
+    #[inline]
+    pub fn metadata(&self, id: &Id) -> Option<&'static Metadata<'static>>
+    where
+        S: for<'lookup> LookupSpan<'lookup>,
+    {
+        self.ctx.metadata(id)
+    }
+
+    /// Returns [stored data] for the span with the given `id`, if it exists.
+    ///
+    /// If this returns `None`, then no span exists for that ID (either it has
+    /// closed or the ID is invalid).
+    ///
+    /// [stored data]: ../registry/struct.SpanRef.html
+    #[inline]
+    pub fn span(&self, id: &Id) -> Option<SpanRef<'_, S>>
+    where
+        S: for<'lookup> LookupSpan<'lookup>,
+    {
+        self.ctx.span(id)
+    }
+
+    /// Returns `true` if an active span exists for the given `Id`.
+    #[inline]
+    pub fn exists(&self, id: &Id) -> bool
+    where
+        S: for<'lookup> LookupSpan<'lookup>,
+    {
+        self.ctx.exists(id)
+    }
+
+    /// Returns [stored data] for the span that the wrapped subscriber considers
+    /// to be the current.
+    ///
+    /// If this returns `None`, then we are not currently within a span.
+    ///
+    /// [stored data]: ../registry/struct.SpanRef.html
+    #[inline]
+    pub fn lookup_current(&self) -> Option<SpanRef<'_, S>>
+    where
+        S: for<'lookup> LookupSpan<'lookup>,
+    {
+        self.ctx.lookup_current()
+    }
+
+    /// Returns the current span for this formatter.
+    pub fn current_span(&self) -> Current {
+        self.ctx.current_span()
+    }
+
+    /// Returns [stored data] for the parent span of the event currently being
+    /// formatted.
+    ///
+    /// If the event has a contextual parent, this will return the current span. If
+    /// the event has an explicit parent span, this will return that span. If
+    /// the event does not have a parent span, this will return `None`.
+    ///
+    /// [stored data]: SpanRef
+    pub fn parent_span(&self) -> Option<SpanRef<'_, S>> {
+        self.ctx.event_span(self.event)
+    }
+
+    /// Returns an iterator over the [stored data] for all the spans in the
+    /// current context, starting with the specified span and ending with the
+    /// root of the trace tree and ending with the current span.
+    ///
+    /// This is equivalent to the [`Context::span_scope`] method.
+    ///
+    /// <div class="information">
+    ///     <div class="tooltip ignore" style="">ⓘ<span class="tooltiptext">Note</span></div>
+    /// </div>
+    /// <div class="example-wrap" style="display:inline-block">
+    /// <pre class="ignore" style="white-space:normal;font:inherit;">
+    /// <strong>Note</strong>: Compared to <a href="#method.scope"><code>scope</code></a> this
+    /// returns the spans in reverse order (from leaf to root). Use
+    /// <a href="../registry/struct.Scope.html#method.from_root"><code>Scope::from_root</code></a>
+    /// in case root-to-leaf ordering is desired.
+    /// </pre></div>
+    ///
+    /// <div class="example-wrap" style="display:inline-block">
+    /// <pre class="ignore" style="white-space:normal;font:inherit;">
+    /// <strong>Note</strong>: This requires the wrapped subscriber to implement the
+    /// <a href="../registry/trait.LookupSpan.html"><code>LookupSpan</code></a> trait.
+    /// See the documentation on <a href="./struct.Context.html"><code>Context</code>'s
+    /// declaration</a> for details.
+    /// </pre></div>
+    ///
+    /// [stored data]: crate::registry::SpanRef
+    pub fn span_scope(&self, id: &Id) -> Option<registry::Scope<'_, S>>
+    where
+        S: for<'lookup> LookupSpan<'lookup>,
+    {
+        self.ctx.span_scope(id)
+    }
+
+    /// Returns an iterator over the [stored data] for all the spans in the
+    /// event's span context, starting with its parent span and ending with the
+    /// root of the trace tree.
+    ///
+    /// This is equivalent to calling the [`Context::event_scope`] method and
+    /// passing the event currently being formatted.
+    ///
+    /// <div class="example-wrap" style="display:inline-block">
+    /// <pre class="ignore" style="white-space:normal;font:inherit;">
+    /// <strong>Note</strong>: Compared to <a href="#method.scope"><code>scope</code></a> this
+    /// returns the spans in reverse order (from leaf to root). Use
+    /// <a href="../registry/struct.Scope.html#method.from_root"><code>Scope::from_root</code></a>
+    /// in case root-to-leaf ordering is desired.
+    /// </pre></div>
+    ///
+    /// <div class="example-wrap" style="display:inline-block">
+    /// <pre class="ignore" style="white-space:normal;font:inherit;">
+    /// <strong>Note</strong>: This requires the wrapped subscriber to implement the
+    /// <a href="../registry/trait.LookupSpan.html"><code>LookupSpan</code></a> trait.
+    /// See the documentation on <a href="./struct.Context.html"><code>Context</code>'s
+    /// declaration</a> for details.
+    /// </pre></div>
+    ///
+    /// [stored data]: crate::registry::SpanRef
+    pub fn event_scope(&self) -> Option<registry::Scope<'_, S>>
+    where
+        S: for<'lookup> registry::LookupSpan<'lookup>,
+    {
+        self.ctx.event_scope(self.event)
+    }
+
+    /// Returns the [field formatter] configured by the subscriber invoking
+    /// `format_event`.
+    ///
+    /// The event formatter may use the returned field formatter to format the
+    /// fields of any events it records.
+    ///
+    /// [field formatter]: FormatFields
+    pub fn field_format(&self) -> &N {
+        self.fmt_fields
+    }
+}
+
+struct Timings {
+    idle: u64,
+    busy: u64,
+    last: Instant,
+}
+
+impl Timings {
+    fn new() -> Self {
+        Self {
+            idle: 0,
+            busy: 0,
+            last: Instant::now(),
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::fmt::{
+        self,
+        format::{self, test::MockTime, Format},
+        layer::Layer as _,
+        test::{MockMakeWriter, MockWriter},
+        time,
+    };
+    use crate::Registry;
+    use format::FmtSpan;
+    use regex::Regex;
+    use tracing::subscriber::with_default;
+    use tracing_core::dispatcher::Dispatch;
+
+    #[test]
+    fn impls() {
+        let f = Format::default().with_timer(time::Uptime::default());
+        let fmt = fmt::Layer::default().event_format(f);
+        let subscriber = fmt.with_subscriber(Registry::default());
+        let _dispatch = Dispatch::new(subscriber);
+
+        let f = format::Format::default();
+        let fmt = fmt::Layer::default().event_format(f);
+        let subscriber = fmt.with_subscriber(Registry::default());
+        let _dispatch = Dispatch::new(subscriber);
+
+        let f = format::Format::default().compact();
+        let fmt = fmt::Layer::default().event_format(f);
+        let subscriber = fmt.with_subscriber(Registry::default());
+        let _dispatch = Dispatch::new(subscriber);
+    }
+
+    #[test]
+    fn fmt_layer_downcasts() {
+        let f = format::Format::default();
+        let fmt = fmt::Layer::default().event_format(f);
+        let subscriber = fmt.with_subscriber(Registry::default());
+
+        let dispatch = Dispatch::new(subscriber);
+        assert!(dispatch.downcast_ref::<fmt::Layer<Registry>>().is_some());
+    }
+
+    #[test]
+    fn fmt_layer_downcasts_to_parts() {
+        let f = format::Format::default();
+        let fmt = fmt::Layer::default().event_format(f);
+        let subscriber = fmt.with_subscriber(Registry::default());
+        let dispatch = Dispatch::new(subscriber);
+        assert!(dispatch.downcast_ref::<format::DefaultFields>().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 fmt = fmt::Layer::default();
+        let subscriber = fmt.with_subscriber(Registry::default());
+        assert_lookup_span(subscriber)
+    }
+
+    fn sanitize_timings(s: String) -> String {
+        let re = Regex::new("time\\.(idle|busy)=([0-9.]+)[mµn]s").unwrap();
+        re.replace_all(s.as_str(), "timing").to_string()
+    }
+
+    #[test]
+    fn synthesize_span_none() {
+        let make_writer = MockMakeWriter::default();
+        let subscriber = crate::fmt::Subscriber::builder()
+            .with_writer(make_writer.clone())
+            .with_level(false)
+            .with_ansi(false)
+            .with_timer(MockTime)
+            // check that FmtSpan::NONE is the default
+            .finish();
+
+        with_default(subscriber, || {
+            let span1 = tracing::info_span!("span1", x = 42);
+            let _e = span1.enter();
+        });
+        let actual = sanitize_timings(make_writer.get_string());
+        assert_eq!("", actual.as_str());
+    }
+
+    #[test]
+    fn synthesize_span_active() {
+        let make_writer = MockMakeWriter::default();
+        let subscriber = crate::fmt::Subscriber::builder()
+            .with_writer(make_writer.clone())
+            .with_level(false)
+            .with_ansi(false)
+            .with_timer(MockTime)
+            .with_span_events(FmtSpan::ACTIVE)
+            .finish();
+
+        with_default(subscriber, || {
+            let span1 = tracing::info_span!("span1", x = 42);
+            let _e = span1.enter();
+        });
+        let actual = sanitize_timings(make_writer.get_string());
+        assert_eq!(
+            "fake time span1{x=42}: tracing_subscriber::fmt::fmt_layer::test: enter\n\
+             fake time span1{x=42}: tracing_subscriber::fmt::fmt_layer::test: exit\n",
+            actual.as_str()
+        );
+    }
+
+    #[test]
+    fn synthesize_span_close() {
+        let make_writer = MockMakeWriter::default();
+        let subscriber = crate::fmt::Subscriber::builder()
+            .with_writer(make_writer.clone())
+            .with_level(false)
+            .with_ansi(false)
+            .with_timer(MockTime)
+            .with_span_events(FmtSpan::CLOSE)
+            .finish();
+
+        with_default(subscriber, || {
+            let span1 = tracing::info_span!("span1", x = 42);
+            let _e = span1.enter();
+        });
+        let actual = sanitize_timings(make_writer.get_string());
+        assert_eq!(
+            "fake time span1{x=42}: tracing_subscriber::fmt::fmt_layer::test: close timing timing\n",
+            actual.as_str()
+        );
+    }
+
+    #[test]
+    fn synthesize_span_close_no_timing() {
+        let make_writer = MockMakeWriter::default();
+        let subscriber = crate::fmt::Subscriber::builder()
+            .with_writer(make_writer.clone())
+            .with_level(false)
+            .with_ansi(false)
+            .with_timer(MockTime)
+            .without_time()
+            .with_span_events(FmtSpan::CLOSE)
+            .finish();
+
+        with_default(subscriber, || {
+            let span1 = tracing::info_span!("span1", x = 42);
+            let _e = span1.enter();
+        });
+        let actual = sanitize_timings(make_writer.get_string());
+        assert_eq!(
+            "span1{x=42}: tracing_subscriber::fmt::fmt_layer::test: close\n",
+            actual.as_str()
+        );
+    }
+
+    #[test]
+    fn synthesize_span_full() {
+        let make_writer = MockMakeWriter::default();
+        let subscriber = crate::fmt::Subscriber::builder()
+            .with_writer(make_writer.clone())
+            .with_level(false)
+            .with_ansi(false)
+            .with_timer(MockTime)
+            .with_span_events(FmtSpan::FULL)
+            .finish();
+
+        with_default(subscriber, || {
+            let span1 = tracing::info_span!("span1", x = 42);
+            let _e = span1.enter();
+        });
+        let actual = sanitize_timings(make_writer.get_string());
+        assert_eq!(
+            "fake time span1{x=42}: tracing_subscriber::fmt::fmt_layer::test: new\n\
+             fake time span1{x=42}: tracing_subscriber::fmt::fmt_layer::test: enter\n\
+             fake time span1{x=42}: tracing_subscriber::fmt::fmt_layer::test: exit\n\
+             fake time span1{x=42}: tracing_subscriber::fmt::fmt_layer::test: close timing timing\n",
+            actual.as_str()
+        );
+    }
+
+    #[test]
+    fn make_writer_based_on_meta() {
+        struct MakeByTarget {
+            make_writer1: MockMakeWriter,
+            make_writer2: MockMakeWriter,
+        }
+
+        impl<'a> MakeWriter<'a> for MakeByTarget {
+            type Writer = MockWriter;
+
+            fn make_writer(&'a self) -> Self::Writer {
+                self.make_writer1.make_writer()
+            }
+
+            fn make_writer_for(&'a self, meta: &Metadata<'_>) -> Self::Writer {
+                if meta.target() == "writer2" {
+                    return self.make_writer2.make_writer();
+                }
+                self.make_writer()
+            }
+        }
+
+        let make_writer1 = MockMakeWriter::default();
+        let make_writer2 = MockMakeWriter::default();
+
+        let make_writer = MakeByTarget {
+            make_writer1: make_writer1.clone(),
+            make_writer2: make_writer2.clone(),
+        };
+
+        let subscriber = crate::fmt::Subscriber::builder()
+            .with_writer(make_writer)
+            .with_level(false)
+            .with_target(false)
+            .with_ansi(false)
+            .with_timer(MockTime)
+            .with_span_events(FmtSpan::CLOSE)
+            .finish();
+
+        with_default(subscriber, || {
+            let span1 = tracing::info_span!("writer1_span", x = 42);
+            let _e = span1.enter();
+            tracing::info!(target: "writer2", "hello writer2!");
+            let span2 = tracing::info_span!(target: "writer2", "writer2_span");
+            let _e = span2.enter();
+            tracing::warn!(target: "writer1", "hello writer1!");
+        });
+
+        let actual = sanitize_timings(make_writer1.get_string());
+        assert_eq!(
+            "fake time writer1_span{x=42}:writer2_span: hello writer1!\n\
+             fake time writer1_span{x=42}: close timing timing\n",
+            actual.as_str()
+        );
+        let actual = sanitize_timings(make_writer2.get_string());
+        assert_eq!(
+            "fake time writer1_span{x=42}: hello writer2!\n\
+             fake time writer1_span{x=42}:writer2_span: close timing timing\n",
+            actual.as_str()
+        );
+    }
+}
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-0.3.3/src/fmt/time/datetime.rs b/vendor/tracing-subscriber-0.3.3/src/fmt/time/datetime.rs
new file mode 100644
index 000000000..531331687
--- /dev/null
+++ b/vendor/tracing-subscriber-0.3.3/src/fmt/time/datetime.rs
@@ -0,0 +1,410 @@
+// musl as a whole is licensed under the following standard MIT license:
+//
+// ----------------------------------------------------------------------
+// Copyright © 2005-2020 Rich Felker, et al.
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+// SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+// ----------------------------------------------------------------------
+//
+// Authors/contributors include:
+//
+// A. Wilcox
+// Ada Worcester
+// Alex Dowad
+// Alex Suykov
+// Alexander Monakov
+// Andre McCurdy
+// Andrew Kelley
+// Anthony G. Basile
+// Aric Belsito
+// Arvid Picciani
+// Bartosz Brachaczek
+// Benjamin Peterson
+// Bobby Bingham
+// Boris Brezillon
+// Brent Cook
+// Chris Spiegel
+// Clément Vasseur
+// Daniel Micay
+// Daniel Sabogal
+// Daurnimator
+// David Carlier
+// David Edelsohn
+// Denys Vlasenko
+// Dmitry Ivanov
+// Dmitry V. Levin
+// Drew DeVault
+// Emil Renner Berthing
+// Fangrui Song
+// Felix Fietkau
+// Felix Janda
+// Gianluca Anzolin
+// Hauke Mehrtens
+// He X
+// Hiltjo Posthuma
+// Isaac Dunham
+// Jaydeep Patil
+// Jens Gustedt
+// Jeremy Huntwork
+// Jo-Philipp Wich
+// Joakim Sindholt
+// John Spencer
+// Julien Ramseier
+// Justin Cormack
+// Kaarle Ritvanen
+// Khem Raj
+// Kylie McClain
+// Leah Neukirchen
+// Luca Barbato
+// Luka Perkov
+// M Farkas-Dyck (Strake)
+// Mahesh Bodapati
+// Markus Wichmann
+// Masanori Ogino
+// Michael Clark
+// Michael Forney
+// Mikhail Kremnyov
+// Natanael Copa
+// Nicholas J. Kain
+// orc
+// Pascal Cuoq
+// Patrick Oppenlander
+// Petr Hosek
+// Petr Skocik
+// Pierre Carrier
+// Reini Urban
+// Rich Felker
+// Richard Pennington
+// Ryan Fairfax
+// Samuel Holland
+// Segev Finer
+// Shiz
+// sin
+// Solar Designer
+// Stefan Kristiansson
+// Stefan O'Rear
+// Szabolcs Nagy
+// Timo Teräs
+// Trutz Behn
+// Valentin Ochs
+// Will Dietz
+// William Haddon
+// William Pitcock
+//
+// Portions of this software are derived from third-party works licensed
+// under terms compatible with the above MIT license:
+//
+// The TRE regular expression implementation (src/regex/reg* and
+// src/regex/tre*) is Copyright © 2001-2008 Ville Laurikari and licensed
+// under a 2-clause BSD license (license text in the source files). The
+// included version has been heavily modified by Rich Felker in 2012, in
+// the interests of size, simplicity, and namespace cleanliness.
+//
+// Much of the math library code (src/math/* and src/complex/*) is
+// Copyright © 1993,2004 Sun Microsystems or
+// Copyright © 2003-2011 David Schultz or
+// Copyright © 2003-2009 Steven G. Kargl or
+// Copyright © 2003-2009 Bruce D. Evans or
+// Copyright © 2008 Stephen L. Moshier or
+// Copyright © 2017-2018 Arm Limited
+// and labelled as such in comments in the individual source files. All
+// have been licensed under extremely permissive terms.
+//
+// The ARM memcpy code (src/string/arm/memcpy.S) is Copyright © 2008
+// The Android Open Source Project and is licensed under a two-clause BSD
+// license. It was taken from Bionic libc, used on Android.
+//
+// The AArch64 memcpy and memset code (src/string/aarch64/*) are
+// Copyright © 1999-2019, Arm Limited.
+//
+// The implementation of DES for crypt (src/crypt/crypt_des.c) is
+// Copyright © 1994 David Burren. It is licensed under a BSD license.
+//
+// The implementation of blowfish crypt (src/crypt/crypt_blowfish.c) was
+// originally written by Solar Designer and placed into the public
+// domain. The code also comes with a fallback permissive license for use
+// in jurisdictions that may not recognize the public domain.
+//
+// The smoothsort implementation (src/stdlib/qsort.c) is Copyright © 2011
+// Valentin Ochs and is licensed under an MIT-style license.
+//
+// The x86_64 port was written by Nicholas J. Kain and is licensed under
+// the standard MIT terms.
+//
+// The mips and microblaze ports were originally written by Richard
+// Pennington for use in the ellcc project. The original code was adapted
+// by Rich Felker for build system and code conventions during upstream
+// integration. It is licensed under the standard MIT terms.
+//
+// The mips64 port was contributed by Imagination Technologies and is
+// licensed under the standard MIT terms.
+//
+// The powerpc port was also originally written by Richard Pennington,
+// and later supplemented and integrated by John Spencer. It is licensed
+// under the standard MIT terms.
+//
+// All other files which have no copyright comments are original works
+// produced specifically for use as part of this library, written either
+// by Rich Felker, the main author of the library, or by one or more
+// contibutors listed above. Details on authorship of individual files
+// can be found in the git version control history of the project. The
+// omission of copyright and license comments in each file is in the
+// interest of source tree size.
+//
+// In addition, permission is hereby granted for all public header files
+// (include/* and arch/*/bits/*) and crt files intended to be linked into
+// applications (crt/*, ldso/dlstart.c, and arch/*/crt_arch.h) to omit
+// the copyright notice and permission notice otherwise required by the
+// license, and to use these files without any requirement of
+// attribution. These files include substantial contributions from:
+//
+// Bobby Bingham
+// John Spencer
+// Nicholas J. Kain
+// Rich Felker
+// Richard Pennington
+// Stefan Kristiansson
+// Szabolcs Nagy
+//
+// all of whom have explicitly granted such permission.
+//
+// This file previously contained text expressing a belief that most of
+// the files covered by the above exception were sufficiently trivial not
+// to be subject to copyright, resulting in confusion over whether it
+// negated the permissions granted in the license. In the spirit of
+// permissive licensing, and of not having licensing issues being an
+// obstacle to adoption, that text has been removed.
+
+
+use std::fmt;
+
+/// A date/time type which exists primarily to convert `SystemTime` timestamps into an ISO 8601
+/// formatted string.
+///
+/// Yes, this exists. Before you have a heart attack, understand that the meat of this is musl's
+/// [`__secs_to_tm`][1] converted to Rust via [c2rust][2] and then cleaned up by hand as part of
+/// the [kudu-rs project][3], [released under MIT][4].
+///
+/// [1] http://git.musl-libc.org/cgit/musl/tree/src/time/__secs_to_tm.c
+/// [2] https://c2rust.com/
+/// [3] https://github.com/danburkert/kudu-rs/blob/c9660067e5f4c1a54143f169b5eeb49446f82e54/src/timestamp.rs#L5-L18
+/// [4] https://github.com/tokio-rs/tracing/issues/1644#issuecomment-963888244
+///
+/// All existing `strftime`-like APIs I found were unable to handle the full range of timestamps representable
+/// by `SystemTime`, including `strftime` itself, since tm.tm_year is an int.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) struct DateTime {
+    year: i64,
+    month: u8,
+    day: u8,
+    hour: u8,
+    minute: u8,
+    second: u8,
+    nanos: u32,
+}
+
+impl fmt::Display for DateTime {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if self.year > 9999 {
+            write!(f, "+{}", self.year)?;
+        } else if self.year < 0 {
+            write!(f, "{:05}", self.year)?;
+        } else {
+            write!(f, "{:04}", self.year)?;
+        }
+
+        write!(
+            f,
+            "-{:02}-{:02}T{:02}:{:02}:{:02}.{:06}Z",
+            self.month,
+            self.day,
+            self.hour,
+            self.minute,
+            self.second,
+            self.nanos / 1_000
+        )
+    }
+}
+
+impl From<std::time::SystemTime> for DateTime {
+    fn from(timestamp: std::time::SystemTime) -> DateTime {
+        let (t, nanos) = match timestamp.duration_since(std::time::UNIX_EPOCH) {
+            Ok(duration) => {
+                debug_assert!(duration.as_secs() <= std::i64::MAX as u64);
+                (duration.as_secs() as i64, duration.subsec_nanos())
+            }
+            Err(error) => {
+                let duration = error.duration();
+                debug_assert!(duration.as_secs() <= std::i64::MAX as u64);
+                let (secs, nanos) = (duration.as_secs() as i64, duration.subsec_nanos());
+                if nanos == 0 {
+                    (-secs, 0)
+                } else {
+                    (-secs - 1, 1_000_000_000 - nanos)
+                }
+            }
+        };
+
+        // 2000-03-01 (mod 400 year, immediately after feb29
+        const LEAPOCH: i64 = 946_684_800 + 86400 * (31 + 29);
+        const DAYS_PER_400Y: i32 = 365 * 400 + 97;
+        const DAYS_PER_100Y: i32 = 365 * 100 + 24;
+        const DAYS_PER_4Y: i32 = 365 * 4 + 1;
+        static DAYS_IN_MONTH: [i8; 12] = [31, 30, 31, 30, 31, 31, 30, 31, 30, 31, 31, 29];
+
+        // Note(dcb): this bit is rearranged slightly to avoid integer overflow.
+        let mut days: i64 = (t / 86_400) - (LEAPOCH / 86_400);
+        let mut remsecs: i32 = (t % 86_400) as i32;
+        if remsecs < 0i32 {
+            remsecs += 86_400;
+            days -= 1
+        }
+
+        let mut qc_cycles: i32 = (days / i64::from(DAYS_PER_400Y)) as i32;
+        let mut remdays: i32 = (days % i64::from(DAYS_PER_400Y)) as i32;
+        if remdays < 0 {
+            remdays += DAYS_PER_400Y;
+            qc_cycles -= 1;
+        }
+
+        let mut c_cycles: i32 = remdays / DAYS_PER_100Y;
+        if c_cycles == 4 {
+            c_cycles -= 1;
+        }
+        remdays -= c_cycles * DAYS_PER_100Y;
+
+        let mut q_cycles: i32 = remdays / DAYS_PER_4Y;
+        if q_cycles == 25 {
+            q_cycles -= 1;
+        }
+        remdays -= q_cycles * DAYS_PER_4Y;
+
+        let mut remyears: i32 = remdays / 365;
+        if remyears == 4 {
+            remyears -= 1;
+        }
+        remdays -= remyears * 365;
+
+        let mut years: i64 = i64::from(remyears)
+            + 4 * i64::from(q_cycles)
+            + 100 * i64::from(c_cycles)
+            + 400 * i64::from(qc_cycles);
+
+        let mut months: i32 = 0;
+        while i32::from(DAYS_IN_MONTH[months as usize]) <= remdays {
+            remdays -= i32::from(DAYS_IN_MONTH[months as usize]);
+            months += 1
+        }
+
+        if months >= 10 {
+            months -= 12;
+            years += 1;
+        }
+
+        DateTime {
+            year: years + 2000,
+            month: (months + 3) as u8,
+            day: (remdays + 1) as u8,
+            hour: (remsecs / 3600) as u8,
+            minute: (remsecs / 60 % 60) as u8,
+            second: (remsecs % 60) as u8,
+            nanos,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::i32;
+    use std::time::{Duration, UNIX_EPOCH};
+
+    use super::*;
+
+    #[test]
+    fn test_datetime() {
+        let case = |expected: &str, secs: i64, micros: u32| {
+            let timestamp = if secs >= 0 {
+                UNIX_EPOCH + Duration::new(secs as u64, micros * 1_000)
+            } else {
+                (UNIX_EPOCH - Duration::new(!secs as u64 + 1, 0)) + Duration::new(0, micros * 1_000)
+            };
+            assert_eq!(
+                expected,
+                format!("{}", DateTime::from(timestamp)),
+                "secs: {}, micros: {}",
+                secs,
+                micros
+            )
+        };
+
+        // Mostly generated with:
+        //  - date -jur <secs> +"%Y-%m-%dT%H:%M:%S.000000Z"
+        //  - http://unixtimestamp.50x.eu/
+
+        case("1970-01-01T00:00:00.000000Z", 0, 0);
+
+        case("1970-01-01T00:00:00.000001Z", 0, 1);
+        case("1970-01-01T00:00:00.500000Z", 0, 500_000);
+        case("1970-01-01T00:00:01.000001Z", 1, 1);
+        case("1970-01-01T00:01:01.000001Z", 60 + 1, 1);
+        case("1970-01-01T01:01:01.000001Z", 60 * 60 + 60 + 1, 1);
+        case(
+            "1970-01-02T01:01:01.000001Z",
+            24 * 60 * 60 + 60 * 60 + 60 + 1,
+            1,
+        );
+
+        case("1969-12-31T23:59:59.000000Z", -1, 0);
+        case("1969-12-31T23:59:59.000001Z", -1, 1);
+        case("1969-12-31T23:59:59.500000Z", -1, 500_000);
+        case("1969-12-31T23:58:59.000001Z", -60 - 1, 1);
+        case("1969-12-31T22:58:59.000001Z", -60 * 60 - 60 - 1, 1);
+        case(
+            "1969-12-30T22:58:59.000001Z",
+            -24 * 60 * 60 - 60 * 60 - 60 - 1,
+            1,
+        );
+
+        case("2038-01-19T03:14:07.000000Z", std::i32::MAX as i64, 0);
+        case("2038-01-19T03:14:08.000000Z", std::i32::MAX as i64 + 1, 0);
+        case("1901-12-13T20:45:52.000000Z", i32::MIN as i64, 0);
+        case("1901-12-13T20:45:51.000000Z", i32::MIN as i64 - 1, 0);
+
+        // Skipping these tests on windows as std::time::SysteTime range is low
+        // on Windows compared with that of Unix which can cause the following
+        // high date value tests to panic
+        #[cfg(not(target_os = "windows"))]
+        {
+            case("+292277026596-12-04T15:30:07.000000Z", std::i64::MAX, 0);
+            case("+292277026596-12-04T15:30:06.000000Z", std::i64::MAX - 1, 0);
+            case("-292277022657-01-27T08:29:53.000000Z", i64::MIN + 1, 0);
+        }
+
+        case("1900-01-01T00:00:00.000000Z", -2208988800, 0);
+        case("1899-12-31T23:59:59.000000Z", -2208988801, 0);
+        case("0000-01-01T00:00:00.000000Z", -62167219200, 0);
+        case("-0001-12-31T23:59:59.000000Z", -62167219201, 0);
+
+        case("1234-05-06T07:08:09.000000Z", -23215049511, 0);
+        case("-1234-05-06T07:08:09.000000Z", -101097651111, 0);
+        case("2345-06-07T08:09:01.000000Z", 11847456541, 0);
+        case("-2345-06-07T08:09:01.000000Z", -136154620259, 0);
+    }
+}
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-0.3.3/src/fmt/writer.rs b/vendor/tracing-subscriber-0.3.3/src/fmt/writer.rs
new file mode 100644
index 000000000..0974891f7
--- /dev/null
+++ b/vendor/tracing-subscriber-0.3.3/src/fmt/writer.rs
@@ -0,0 +1,1464 @@
+//! Abstractions for creating [`io::Write`] instances.
+//!
+//! [`io::Write`]: https://doc.rust-lang.org/std/io/trait.Write.html
+use std::{
+    fmt,
+    io::{self, Write},
+    sync::{Arc, Mutex, MutexGuard},
+};
+use tracing_core::Metadata;
+
+/// A type that can create [`io::Write`] instances.
+///
+/// `MakeWriter` is used by [`fmt::Layer`] or [`fmt::Subscriber`] to print
+/// formatted text representations of [`Event`]s.
+///
+/// This trait is already implemented for function pointers and
+/// immutably-borrowing closures that return an instance of [`io::Write`], such
+/// as [`io::stdout`] and [`io::stderr`]. Additionally, it is implemented for
+/// [`std::sync::Mutex`][mutex] when the tyoe inside the mutex implements
+/// [`io::Write`].
+///
+/// # Examples
+///
+/// The simplest usage is to pass in a named function that returns a writer. For
+/// example, to log all events to stderr, we could write:
+/// ```
+/// let subscriber = tracing_subscriber::fmt()
+///     .with_writer(std::io::stderr)
+///     .finish();
+/// # drop(subscriber);
+/// ```
+///
+/// Any function that returns a writer can be used:
+///
+/// ```
+/// fn make_my_great_writer() -> impl std::io::Write {
+///     // ...
+///     # std::io::stdout()
+/// }
+///
+/// let subscriber = tracing_subscriber::fmt()
+///     .with_writer(make_my_great_writer)
+///     .finish();
+/// # drop(subscriber);
+/// ```
+///
+/// A closure can be used to introduce arbitrary logic into how the writer is
+/// created. Consider the (admittedly rather silly) example of sending every 5th
+/// event to stderr, and all other events to stdout:
+///
+/// ```
+/// use std::io;
+/// use std::sync::atomic::{AtomicUsize, Ordering::Relaxed};
+///
+/// let n = AtomicUsize::new(0);
+/// let subscriber = tracing_subscriber::fmt()
+///     .with_writer(move || -> Box<dyn io::Write> {
+///         if n.fetch_add(1, Relaxed) % 5 == 0 {
+///             Box::new(io::stderr())
+///         } else {
+///             Box::new(io::stdout())
+///        }
+///     })
+///     .finish();
+/// # drop(subscriber);
+/// ```
+///
+/// A single instance of a type implementing [`io::Write`] may be used as a
+/// `MakeWriter` by wrapping it in a [`Mutex`][mutex]. For example, we could
+/// write to a file like so:
+///
+/// ```
+/// use std::{fs::File, sync::Mutex};
+///
+/// # fn docs() -> Result<(), Box<dyn std::error::Error>> {
+/// let log_file = File::create("my_cool_trace.log")?;
+/// let subscriber = tracing_subscriber::fmt()
+///     .with_writer(Mutex::new(log_file))
+///     .finish();
+/// # drop(subscriber);
+/// # Ok(())
+/// # }
+/// ```
+///
+/// [`io::Write`]: std::io::Write
+/// [`fmt::Layer`]: crate::fmt::Layer
+/// [`fmt::Subscriber`]: crate::fmt::Subscriber
+/// [`Event`]: tracing_core::event::Event
+/// [`io::stdout`]: std::io::stdout()
+/// [`io::stderr`]: std::io::stderr()
+/// [mutex]: std::sync::Mutex
+/// [`MakeWriter::make_writer_for`]: MakeWriter::make_writer_for
+/// [`Metadata`]: tracing_core::Metadata
+/// [levels]: tracing_core::Level
+/// [targets]: tracing_core::Metadata::target
+pub trait MakeWriter<'a> {
+    /// The concrete [`io::Write`] implementation returned by [`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`].
+    ///
+    /// # Implementer notes
+    ///
+    /// [`fmt::Layer`] or [`fmt::Subscriber`] will call this method each time an event is recorded. Ensure any state
+    /// that must be saved across writes is not lost when the [`Writer`] instance is dropped. If
+    /// creating a [`io::Write`] instance is expensive, be sure to cache it when implementing
+    /// [`MakeWriter`] to improve performance.
+    ///
+    /// [`Writer`]: #associatedtype.Writer
+    /// [`fmt::Layer`]: crate::fmt::Layer
+    /// [`fmt::Subscriber`]: crate::fmt::Subscriber
+    /// [`io::Write`]: std::io::Write
+    fn make_writer(&'a self) -> Self::Writer;
+
+    /// Returns a [`Writer`] for writing data from the span or event described
+    /// by the provided [`Metadata`].
+    ///
+    /// By default, this calls [`self.make_writer()`][make_writer], ignoring
+    /// the provided metadata, but implementations can override this to provide
+    /// metadata-specific behaviors.
+    ///
+    /// This method allows `MakeWriter` implementations to implement different
+    /// behaviors based on the span or event being written. The `MakeWriter`
+    /// type might return different writers based on the provided metadata, or
+    /// might write some values to the writer before or after providing it to
+    /// the caller.
+    ///
+    /// For example, we might want to write data from spans and events at the
+    /// [`ERROR`] and [`WARN`] levels to `stderr`, and data from spans or events
+    /// at lower levels to stdout:
+    ///
+    /// ```
+    /// use std::io::{self, Stdout, Stderr, StdoutLock, StderrLock};
+    /// use tracing_subscriber::fmt::writer::MakeWriter;
+    /// use tracing_core::{Metadata, Level};
+    ///
+    /// pub struct MyMakeWriter {
+    ///     stdout: Stdout,
+    ///     stderr: Stderr,
+    /// }
+    ///
+    /// /// A lock on either stdout or stderr, depending on the verbosity level
+    /// /// of the event being written.
+    /// pub enum StdioLock<'a> {
+    ///     Stdout(StdoutLock<'a>),
+    ///     Stderr(StderrLock<'a>),
+    /// }
+    ///
+    /// impl<'a> io::Write for StdioLock<'a> {
+    ///     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+    ///         match self {
+    ///             StdioLock::Stdout(lock) => lock.write(buf),
+    ///             StdioLock::Stderr(lock) => lock.write(buf),
+    ///         }
+    ///     }
+    ///
+    ///     fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
+    ///         // ...
+    ///         # match self {
+    ///         #     StdioLock::Stdout(lock) => lock.write_all(buf),
+    ///         #     StdioLock::Stderr(lock) => lock.write_all(buf),
+    ///         # }
+    ///     }
+    ///
+    ///     fn flush(&mut self) -> io::Result<()> {
+    ///         // ...
+    ///         # match self {
+    ///         #     StdioLock::Stdout(lock) => lock.flush(),
+    ///         #     StdioLock::Stderr(lock) => lock.flush(),
+    ///         # }
+    ///     }
+    /// }
+    ///
+    /// impl<'a> MakeWriter<'a> for MyMakeWriter {
+    ///     type Writer = StdioLock<'a>;
+    ///
+    ///     fn make_writer(&'a self) -> Self::Writer {
+    ///         // We must have an implementation of `make_writer` that makes
+    ///         // a "default" writer without any configuring metadata. Let's
+    ///         // just return stdout in that case.
+    ///         StdioLock::Stdout(self.stdout.lock())
+    ///     }
+    ///
+    ///     fn make_writer_for(&'a self, meta: &Metadata<'_>) -> Self::Writer {
+    ///         // Here's where we can implement our special behavior. We'll
+    ///         // check if the metadata's verbosity level is WARN or ERROR,
+    ///         // and return stderr in that case.
+    ///         if meta.level() <= &Level::WARN {
+    ///             return StdioLock::Stderr(self.stderr.lock());
+    ///         }
+    ///
+    ///         // Otherwise, we'll return stdout.
+    ///         StdioLock::Stdout(self.stdout.lock())
+    ///     }
+    /// }
+    /// ```
+    ///
+    /// [`Writer`]: MakeWriter::Writer
+    /// [`Metadata`]: tracing_core::Metadata
+    /// [make_writer]: MakeWriter::make_writer
+    /// [`WARN`]: tracing_core::Level::WARN
+    /// [`ERROR`]: tracing_core::Level::ERROR
+    fn make_writer_for(&'a self, meta: &Metadata<'_>) -> Self::Writer {
+        let _ = meta;
+        self.make_writer()
+    }
+}
+
+/// Extension trait adding combinators for working with types implementing
+/// [`MakeWriter`].
+///
+/// This is not intended to be implemented directly for user-defined
+/// [`MakeWriter`]s; instead, it should be imported when the desired methods are
+/// used.
+pub trait MakeWriterExt<'a>: MakeWriter<'a> {
+    /// Wraps `self` and returns a [`MakeWriter`] that will only write output
+    /// for events at or below the provided verbosity [`Level`]. For instance,
+    /// `Level::TRACE` is considered to be _more verbose` than `Level::INFO`.
+    ///
+    /// Events whose level is more verbose than `level` will be ignored, and no
+    /// output will be written.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use tracing::Level;
+    /// use tracing_subscriber::fmt::writer::MakeWriterExt;
+    ///
+    /// // Construct a writer that outputs events to `stderr` only if the span or
+    /// // event's level is >= WARN (WARN and ERROR).
+    /// let mk_writer = std::io::stderr.with_max_level(Level::WARN);
+    ///
+    /// tracing_subscriber::fmt().with_writer(mk_writer).init();
+    /// ```
+    ///
+    /// Writing the `ERROR` and `WARN` levels to `stderr`, and everything else
+    /// to `stdout`:
+    ///
+    /// ```
+    /// # use tracing::Level;
+    /// # use tracing_subscriber::fmt::writer::MakeWriterExt;
+    ///
+    /// let mk_writer = std::io::stderr
+    ///     .with_max_level(Level::WARN)
+    ///     .or_else(std::io::stdout);
+    ///
+    /// tracing_subscriber::fmt().with_writer(mk_writer).init();
+    /// ```
+    ///
+    /// Writing the `ERROR` level to `stderr`, the `INFO` and `WARN` levels to
+    /// `stdout`, and the `INFO` and DEBUG` levels to a file:
+    ///
+    /// ```
+    /// # use tracing::Level;
+    /// # use tracing_subscriber::fmt::writer::MakeWriterExt;
+    /// use std::{sync::Arc, fs::File};
+    /// # // don't actually create the file when running the tests.
+    /// # fn docs() -> std::io::Result<()> {
+    /// let debug_log = Arc::new(File::create("debug.log")?);
+    ///
+    /// let mk_writer = std::io::stderr
+    ///     .with_max_level(Level::ERROR)
+    ///     .or_else(std::io::stdout
+    ///         .with_max_level(Level::INFO)
+    ///         .and(debug_log.with_max_level(Level::DEBUG))
+    ///     );
+    ///
+    /// tracing_subscriber::fmt().with_writer(mk_writer).init();
+    /// # Ok(()) }
+    /// ```
+    ///
+    /// [`Level`]: tracing_core::Level
+    /// [`io::Write`]: std::io::Write
+    fn with_max_level(self, level: tracing_core::Level) -> WithMaxLevel<Self>
+    where
+        Self: Sized,
+    {
+        WithMaxLevel::new(self, level)
+    }
+
+    /// Wraps `self` and returns a [`MakeWriter`] that will only write output
+    /// for events at or above the provided verbosity [`Level`].
+    ///
+    /// Events whose level is less verbose than `level` will be ignored, and no
+    /// output will be written.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use tracing::Level;
+    /// use tracing_subscriber::fmt::writer::MakeWriterExt;
+    ///
+    /// // Construct a writer that outputs events to `stdout` only if the span or
+    /// // event's level is <= DEBUG (DEBUG and TRACE).
+    /// let mk_writer = std::io::stdout.with_min_level(Level::DEBUG);
+    ///
+    /// tracing_subscriber::fmt().with_writer(mk_writer).init();
+    /// ```
+    /// This can be combined with [`MakeWriterExt::with_max_level`] to write
+    /// only within a range of levels:
+    ///
+    /// ```
+    /// # use tracing::Level;
+    /// # use tracing_subscriber::fmt::writer::MakeWriterExt;
+    /// // Only write the `DEBUG` and `INFO` levels to stdout.
+    /// let mk_writer = std::io::stdout
+    ///     .with_max_level(Level::DEBUG)
+    ///     .with_min_level(Level::INFO)
+    ///     // Write the `WARN` and `ERROR` levels to stderr.
+    ///     .and(std::io::stderr.with_min_level(Level::WARN));
+    ///
+    /// tracing_subscriber::fmt().with_writer(mk_writer).init();
+    /// ```
+    /// [`Level`]: tracing_core::Level
+    /// [`io::Write`]: std::io::Write
+    fn with_min_level(self, level: tracing_core::Level) -> WithMinLevel<Self>
+    where
+        Self: Sized,
+    {
+        WithMinLevel::new(self, level)
+    }
+
+    /// Wraps `self` with a predicate that takes a span or event's [`Metadata`]
+    /// and returns a `bool`. The returned [`MakeWriter`]'s
+    /// [`MakeWriter::make_writer_for`][mwf] method will check the predicate to
+    /// determine if  a writer should be produced for a given span or event.
+    ///
+    /// If the predicate returns `false`, the wrapped [`MakeWriter`]'s
+    /// [`make_writer_for`][mwf] will return [`OptionalWriter::none`][own].
+    /// Otherwise, it calls the wrapped [`MakeWriter`]'s
+    /// [`make_writer_for`][mwf] method, and returns the produced writer.
+    ///
+    /// This can be used to filter an output based on arbitrary [`Metadata`]
+    /// parameters.
+    ///
+    /// # Examples
+    ///
+    /// Writing events with a specific target to an HTTP access log, and other
+    /// events to stdout:
+    ///
+    /// ```
+    /// use tracing_subscriber::fmt::writer::MakeWriterExt;
+    /// use std::{sync::Arc, fs::File};
+    /// # // don't actually create the file when running the tests.
+    /// # fn docs() -> std::io::Result<()> {
+    /// let access_log = Arc::new(File::create("access.log")?);
+    ///
+    /// let mk_writer = access_log
+    ///     // Only write events with the target "http::access_log" to the
+    ///     // access log file.
+    ///     .with_filter(|meta| meta.target() == "http::access_log")
+    ///     // Write events with all other targets to stdout.
+    ///     .or_else(std::io::stdout);
+    ///
+    /// tracing_subscriber::fmt().with_writer(mk_writer).init();
+    /// # Ok(())
+    /// # }
+    /// ```
+    ///
+    /// Conditionally enabling or disabling a log file:
+    /// ```
+    /// use tracing_subscriber::fmt::writer::MakeWriterExt;
+    /// use std::{
+    ///     sync::{Arc, atomic::{AtomicBool, Ordering}},
+    ///     fs::File,
+    /// };
+    ///
+    /// static DEBUG_LOG_ENABLED: AtomicBool = AtomicBool::new(false);
+    ///
+    /// # // don't actually create the file when running the tests.
+    /// # fn docs() -> std::io::Result<()> {
+    /// // Create the debug log file
+    /// let debug_file = Arc::new(File::create("debug.log")?)
+    ///     // Enable the debug log only if the flag is enabled.
+    ///     .with_filter(|_| DEBUG_LOG_ENABLED.load(Ordering::Acquire));
+    ///
+    /// // Always write to stdout
+    /// let mk_writer = std::io::stdout
+    ///     // Write to the debug file if it's enabled
+    ///     .and(debug_file);
+    ///
+    /// tracing_subscriber::fmt().with_writer(mk_writer).init();
+    ///
+    /// // ...
+    ///
+    /// // Later, we can toggle on or off the debug log file.
+    /// DEBUG_LOG_ENABLED.store(true, Ordering::Release);
+    /// # Ok(())
+    /// # }
+    /// ```
+    ///
+    /// [`Metadata`]: tracing_core::Metadata
+    /// [mwf]: MakeWriter::make_writer_for
+    /// [own]: EitherWriter::none
+    fn with_filter<F>(self, filter: F) -> WithFilter<Self, F>
+    where
+        Self: Sized,
+        F: Fn(&Metadata<'_>) -> bool,
+    {
+        WithFilter::new(self, filter)
+    }
+
+    /// Combines `self` with another type implementing [`MakeWriter`], returning
+    /// a new [`MakeWriter`] that produces [writers] that write to *both*
+    /// outputs.
+    ///
+    /// If writing to either writer returns an error, the returned writer will
+    /// return that error. However, both writers will still be written to before
+    /// the error is returned, so it is possible for one writer to fail while
+    /// the other is written to successfully.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use tracing_subscriber::fmt::writer::MakeWriterExt;
+    ///
+    /// // Construct a writer that outputs events to `stdout` *and* `stderr`.
+    /// let mk_writer = std::io::stdout.and(std::io::stderr);
+    ///
+    /// tracing_subscriber::fmt().with_writer(mk_writer).init();
+    /// ```
+    ///
+    /// `and` can be used in conjunction with filtering combinators. For
+    /// example, if we want to write to a number of outputs depending on the
+    /// level of an event, we could write:
+    ///
+    /// ```
+    /// use tracing::Level;
+    /// # use tracing_subscriber::fmt::writer::MakeWriterExt;
+    /// use std::{sync::Arc, fs::File};
+    /// # // don't actually create the file when running the tests.
+    /// # fn docs() -> std::io::Result<()> {
+    /// let debug_log = Arc::new(File::create("debug.log")?);
+    ///
+    /// // Write everything to the debug log.
+    /// let mk_writer = debug_log
+    ///     // Write the `ERROR` and `WARN` levels to stderr.
+    ///     .and(std::io::stderr.with_max_level(Level::WARN))
+    ///     // Write `INFO` to `stdout`.
+    ///     .and(std::io::stdout
+    ///         .with_max_level(Level::INFO)
+    ///         .with_min_level(Level::INFO)
+    ///     );
+    ///
+    /// tracing_subscriber::fmt().with_writer(mk_writer).init();
+    /// # Ok(()) }
+    /// ```
+    ///
+    /// [writers]: std::io::Write
+    fn and<B>(self, other: B) -> Tee<Self, B>
+    where
+        Self: Sized,
+        B: MakeWriter<'a> + Sized,
+    {
+        Tee::new(self, other)
+    }
+
+    /// Combines `self` with another type implementing [`MakeWriter`], returning
+    /// a new [`MakeWriter`] that calls `other`'s [`make_writer`] if `self`'s
+    /// `make_writer` returns [`OptionalWriter::none`][own].
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use tracing::Level;
+    /// use tracing_subscriber::fmt::writer::MakeWriterExt;
+    ///
+    /// // Produces a writer that writes to `stderr` if the level is >= WARN,
+    /// // or returns `OptionalWriter::none()` otherwise.
+    /// let stderr = std::io::stderr.with_max_level(Level::WARN);
+    ///
+    /// // If the `stderr` `MakeWriter` is disabled by the max level filter,
+    /// // write to stdout instead:
+    /// let mk_writer = stderr.or_else(std::io::stdout);
+    ///
+    /// tracing_subscriber::fmt().with_writer(mk_writer).init();
+    /// ```
+    ///
+    /// [`make_writer`]: MakeWriter::make_writer
+    /// [own]: EitherWriter::none
+    fn or_else<W, B>(self, other: B) -> OrElse<Self, B>
+    where
+        Self: MakeWriter<'a, Writer = OptionalWriter<W>> + Sized,
+        B: MakeWriter<'a> + Sized,
+        W: Write,
+    {
+        OrElse::new(self, other)
+    }
+}
+
+/// A writer intended to support [`libtest`'s output capturing][capturing] for use in unit tests.
+///
+/// `TestWriter` is used by [`fmt::Subscriber`] or [`fmt::Layer`] to enable capturing support.
+///
+/// `cargo test` can only capture output from the standard library's [`print!`] macro. See
+/// [`libtest`'s output capturing][capturing] for more details about output capturing.
+///
+/// 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`]: ../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`]: 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: (),
+}
+
+/// A writer that erases the specific [`io::Write`] and [`MakeWriter`] types being used.
+///
+/// This is useful in cases where the concrete type of the writer cannot be known
+/// until runtime.
+///
+/// # Examples
+///
+/// A function that returns a [`Subscriber`] that will write to either stdout or stderr:
+///
+/// ```rust
+/// # use tracing::Subscriber;
+/// # use tracing_subscriber::fmt::writer::BoxMakeWriter;
+///
+/// fn dynamic_writer(use_stderr: bool) -> impl Subscriber {
+///     let writer = if use_stderr {
+///         BoxMakeWriter::new(std::io::stderr)
+///     } else {
+///         BoxMakeWriter::new(std::io::stdout)
+///     };
+///
+///     tracing_subscriber::fmt().with_writer(writer).finish()
+/// }
+/// ```
+///
+/// [`Subscriber`]: tracing::Subscriber
+/// [`io::Write`]: std::io::Write
+pub struct BoxMakeWriter {
+    inner: Box<dyn for<'a> MakeWriter<'a, Writer = Box<dyn Write + 'a>> + Send + Sync>,
+    name: &'static str,
+}
+
+/// A [writer] that is one of two types implementing [`io::Write`][writer].
+///
+/// This may be used by [`MakeWriter`] implementations that may conditionally
+/// return one of two writers.
+///
+/// [writer]: std::io::Write
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub enum EitherWriter<A, B> {
+    /// A writer of type `A`.
+    A(A),
+    /// A writer of type `B`.
+    B(B),
+}
+
+/// A [writer] which may or may not be enabled.
+///
+/// This may be used by [`MakeWriter`] implementations that wish to
+/// conditionally enable or disable the returned writer based on a span or
+/// event's [`Metadata`].
+///
+/// [writer]: std::io::Write
+pub type OptionalWriter<T> = EitherWriter<T, std::io::Sink>;
+
+/// A [`MakeWriter`] combinator that only returns an enabled [writer] for spans
+/// and events with metadata at or below a specified verbosity [`Level`].
+///
+/// This is returned by the [`MakeWriterExt::with_max_level`] method. See the
+/// method documentation for details.
+///
+/// [writer]: std::io::Write
+/// [`Level`]: tracing_core::Level
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub struct WithMaxLevel<M> {
+    make: M,
+    level: tracing_core::Level,
+}
+
+/// A [`MakeWriter`] combinator that only returns an enabled [writer] for spans
+/// and events with metadata at or above a specified verbosity [`Level`].
+///
+/// This is returned by the [`MakeWriterExt::with_min_level`] method. See the
+/// method documentation for details.
+///
+/// [writer]: std::io::Write
+/// [`Level`]: tracing_core::Level
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub struct WithMinLevel<M> {
+    make: M,
+    level: tracing_core::Level,
+}
+
+/// A [`MakeWriter`] combinator that wraps a [`MakeWriter`] with a predicate for
+/// span and event [`Metadata`], so that the [`MakeWriter::make_writer_for`]
+/// method returns [`OptionalWriter::some`][ows] when the predicate returns `true`,
+/// and [`OptionalWriter::none`][own] when the predicate returns `false`.
+///
+/// This is returned by the [`MakeWriterExt::with_filter`] method. See the
+/// method documentation for details.
+///
+/// [`Metadata`]: tracing_core::Metadata
+/// [ows]: EitherWriter::some
+/// [own]: EitherWriter::none
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub struct WithFilter<M, F> {
+    make: M,
+    filter: F,
+}
+
+/// Combines a [`MakeWriter`] that returns an [`OptionalWriter`] with another
+/// [`MakeWriter`], so that the second [`MakeWriter`] is used when the first
+/// [`MakeWriter`] returns [`OptionalWriter::none`][own].
+///
+/// This is returned by the [`MakeWriterExt::or_else] method. See the
+/// method documentation for details.
+///
+/// [own]: EitherWriter::none
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub struct OrElse<A, B> {
+    inner: A,
+    or_else: B,
+}
+
+/// Combines two types implementing [`MakeWriter`] (or [`std::io::Write`]) to
+/// produce a writer that writes to both [`MakeWriter`]'s returned writers.
+///
+/// This is returned by the [`MakeWriterExt::and`] method. See the method
+/// documentation for details.
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub struct Tee<A, B> {
+    a: A,
+    b: B,
+}
+
+/// A type implementing [`io::Write`] for a [`MutexGuard`] where the type
+/// inside the [`Mutex`] implements [`io::Write`].
+///
+/// This is used by the [`MakeWriter`] implementation for [`Mutex`], because
+/// [`MutexGuard`] itself will not implement [`io::Write`] — instead, it
+/// _dereferences_ to a type implementing [`io::Write`]. Because [`MakeWriter`]
+/// requires the `Writer` type to implement [`io::Write`], it's necessary to add
+/// a newtype that forwards the trait implementation.
+///
+/// [`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>);
+
+/// Implements [`std::io::Write`] for an [`Arc`]<W> where `&W: Write`.
+///
+/// This is an implementation detail of the [`MakeWriter`] impl for [`Arc`].
+#[derive(Clone, Debug)]
+pub struct ArcWriter<W>(Arc<W>);
+
+/// A bridge between `fmt::Write` and `io::Write`.
+///
+/// This is used by the timestamp formatting implementation for the `time`
+/// crate and by the JSON formatter. In both cases, this is needed because
+/// `tracing-subscriber`'s `FormatEvent`/`FormatTime` traits expect a
+/// `fmt::Write` implementation, while `serde_json::Serializer` and `time`'s
+/// `format_into` methods expect an `io::Write`.
+#[cfg(any(feature = "json", feature = "time"))]
+pub(in crate::fmt) struct WriteAdaptor<'a> {
+    fmt_write: &'a mut dyn fmt::Write,
+}
+
+impl<'a, F, W> MakeWriter<'a> for F
+where
+    F: Fn() -> W,
+    W: io::Write,
+{
+    type Writer = W;
+
+    fn make_writer(&'a self) -> Self::Writer {
+        (self)()
+    }
+}
+
+impl<'a, W> MakeWriter<'a> for Arc<W>
+where
+    &'a W: io::Write + 'a,
+{
+    type Writer = &'a W;
+    fn make_writer(&'a self) -> Self::Writer {
+        &*self
+    }
+}
+
+impl<'a> MakeWriter<'a> for std::fs::File {
+    type Writer = &'a std::fs::File;
+    fn make_writer(&'a self) -> Self::Writer {
+        self
+    }
+}
+
+// === impl TestWriter ===
+
+impl TestWriter {
+    /// Returns a new `TestWriter` with the default configuration.
+    pub fn new() -> Self {
+        Self::default()
+    }
+}
+
+impl io::Write for TestWriter {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        let out_str = String::from_utf8_lossy(buf);
+        print!("{}", out_str);
+        Ok(buf.len())
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+impl<'a> MakeWriter<'a> for TestWriter {
+    type Writer = Self;
+
+    fn make_writer(&'a self) -> Self::Writer {
+        Self::default()
+    }
+}
+
+// === impl BoxMakeWriter ===
+
+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,
+    {
+        Self {
+            inner: Box::new(Boxed(make_writer)),
+            name: std::any::type_name::<M>(),
+        }
+    }
+}
+
+impl fmt::Debug for BoxMakeWriter {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_tuple("BoxMakeWriter")
+            .field(&format_args!("<{}>", self.name))
+            .finish()
+    }
+}
+
+impl<'a> MakeWriter<'a> for BoxMakeWriter {
+    type Writer = Box<dyn Write + 'a>;
+
+    #[inline]
+    fn make_writer(&'a self) -> Self::Writer {
+        self.inner.make_writer()
+    }
+
+    #[inline]
+    fn make_writer_for(&'a self, meta: &Metadata<'_>) -> Self::Writer {
+        self.inner.make_writer_for(meta)
+    }
+}
+
+struct Boxed<M>(M);
+
+impl<'a, M> MakeWriter<'a> for Boxed<M>
+where
+    M: MakeWriter<'a>,
+{
+    type Writer = Box<dyn Write + 'a>;
+
+    fn make_writer(&'a self) -> Self::Writer {
+        let w = self.0.make_writer();
+        Box::new(w)
+    }
+
+    fn make_writer_for(&'a self, meta: &Metadata<'_>) -> Self::Writer {
+        let w = self.0.make_writer_for(meta);
+        Box::new(w)
+    }
+}
+
+// === impl Mutex/MutexGuardWriter ===
+
+impl<'a, W> MakeWriter<'a> for Mutex<W>
+where
+    W: io::Write + 'a,
+{
+    type Writer = MutexGuardWriter<'a, W>;
+
+    fn make_writer(&'a self) -> Self::Writer {
+        MutexGuardWriter(self.lock().expect("lock poisoned"))
+    }
+}
+
+impl<'a, W> io::Write for MutexGuardWriter<'a, W>
+where
+    W: io::Write,
+{
+    #[inline]
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        self.0.write(buf)
+    }
+
+    #[inline]
+    fn flush(&mut self) -> io::Result<()> {
+        self.0.flush()
+    }
+
+    #[inline]
+    fn write_vectored(&mut self, bufs: &[io::IoSlice<'_>]) -> io::Result<usize> {
+        self.0.write_vectored(bufs)
+    }
+
+    #[inline]
+    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
+        self.0.write_all(buf)
+    }
+
+    #[inline]
+    fn write_fmt(&mut self, fmt: std::fmt::Arguments<'_>) -> io::Result<()> {
+        self.0.write_fmt(fmt)
+    }
+}
+
+// === impl EitherWriter ===
+
+impl<A, B> io::Write for EitherWriter<A, B>
+where
+    A: io::Write,
+    B: io::Write,
+{
+    #[inline]
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        match self {
+            EitherWriter::A(a) => a.write(buf),
+            EitherWriter::B(b) => b.write(buf),
+        }
+    }
+
+    #[inline]
+    fn flush(&mut self) -> io::Result<()> {
+        match self {
+            EitherWriter::A(a) => a.flush(),
+            EitherWriter::B(b) => b.flush(),
+        }
+    }
+
+    #[inline]
+    fn write_vectored(&mut self, bufs: &[io::IoSlice<'_>]) -> io::Result<usize> {
+        match self {
+            EitherWriter::A(a) => a.write_vectored(bufs),
+            EitherWriter::B(b) => b.write_vectored(bufs),
+        }
+    }
+
+    #[inline]
+    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
+        match self {
+            EitherWriter::A(a) => a.write_all(buf),
+            EitherWriter::B(b) => b.write_all(buf),
+        }
+    }
+
+    #[inline]
+    fn write_fmt(&mut self, fmt: std::fmt::Arguments<'_>) -> io::Result<()> {
+        match self {
+            EitherWriter::A(a) => a.write_fmt(fmt),
+            EitherWriter::B(b) => b.write_fmt(fmt),
+        }
+    }
+}
+
+impl<T> OptionalWriter<T> {
+    /// Returns a [disabled writer].
+    ///
+    /// Any bytes written to the returned writer are discarded.
+    ///
+    /// This is equivalent to returning [`Option::None`].
+    ///
+    /// [disabled writer]: std::io::sink
+    #[inline]
+    pub fn none() -> Self {
+        EitherWriter::B(std::io::sink())
+    }
+
+    /// Returns an enabled writer of type `T`.
+    ///
+    /// This is equivalent to returning [`Option::Some`].
+    #[inline]
+    pub fn some(t: T) -> Self {
+        EitherWriter::A(t)
+    }
+}
+
+impl<T> From<Option<T>> for OptionalWriter<T> {
+    #[inline]
+    fn from(opt: Option<T>) -> Self {
+        match opt {
+            Some(writer) => Self::some(writer),
+            None => Self::none(),
+        }
+    }
+}
+
+// === impl WithMaxLevel ===
+
+impl<M> WithMaxLevel<M> {
+    /// Wraps the provided [`MakeWriter`] with a maximum [`Level`], so that it
+    /// returns [`OptionalWriter::none`] for spans and events whose level is
+    /// more verbose than the maximum level.
+    ///
+    /// See [`MakeWriterExt::with_max_level`] for details.
+    ///
+    /// [`Level`]: tracing_core::Level
+    pub fn new(make: M, level: tracing_core::Level) -> Self {
+        Self { make, level }
+    }
+}
+
+impl<'a, M: MakeWriter<'a>> MakeWriter<'a> for WithMaxLevel<M> {
+    type Writer = OptionalWriter<M::Writer>;
+
+    #[inline]
+    fn make_writer(&'a self) -> Self::Writer {
+        // If we don't know the level, assume it's disabled.
+        OptionalWriter::none()
+    }
+
+    #[inline]
+    fn make_writer_for(&'a self, meta: &Metadata<'_>) -> Self::Writer {
+        if meta.level() <= &self.level {
+            return OptionalWriter::some(self.make.make_writer_for(meta));
+        }
+        OptionalWriter::none()
+    }
+}
+
+// === impl WithMinLevel ===
+
+impl<M> WithMinLevel<M> {
+    /// Wraps the provided [`MakeWriter`] with a minimum [`Level`], so that it
+    /// returns [`OptionalWriter::none`] for spans and events whose level is
+    /// less verbose than the maximum level.
+    ///
+    /// See [`MakeWriterExt::with_min_level`] for details.
+    ///
+    /// [`Level`]: tracing_core::Level
+    pub fn new(make: M, level: tracing_core::Level) -> Self {
+        Self { make, level }
+    }
+}
+
+impl<'a, M: MakeWriter<'a>> MakeWriter<'a> for WithMinLevel<M> {
+    type Writer = OptionalWriter<M::Writer>;
+
+    #[inline]
+    fn make_writer(&'a self) -> Self::Writer {
+        // If we don't know the level, assume it's disabled.
+        OptionalWriter::none()
+    }
+
+    #[inline]
+    fn make_writer_for(&'a self, meta: &Metadata<'_>) -> Self::Writer {
+        if meta.level() >= &self.level {
+            return OptionalWriter::some(self.make.make_writer_for(meta));
+        }
+        OptionalWriter::none()
+    }
+}
+
+// ==== impl WithFilter ===
+
+impl<M, F> WithFilter<M, F> {
+    /// Wraps `make` with the provided `filter`, returning a [`MakeWriter`] that
+    /// will call `make.make_writer_for()` when `filter` returns `true` for a
+    /// span or event's [`Metadata`], and returns a [`sink`] otherwise.
+    ///
+    /// See [`MakeWriterExt::with_filter`] for details.
+    ///
+    /// [`Metadata`]: tracing_core::Metadata
+    /// [`sink`]: std::io::sink
+    pub fn new(make: M, filter: F) -> Self
+    where
+        F: Fn(&Metadata<'_>) -> bool,
+    {
+        Self { make, filter }
+    }
+}
+
+impl<'a, M, F> MakeWriter<'a> for WithFilter<M, F>
+where
+    M: MakeWriter<'a>,
+    F: Fn(&Metadata<'_>) -> bool,
+{
+    type Writer = OptionalWriter<M::Writer>;
+
+    #[inline]
+    fn make_writer(&'a self) -> Self::Writer {
+        OptionalWriter::some(self.make.make_writer())
+    }
+
+    #[inline]
+    fn make_writer_for(&'a self, meta: &Metadata<'_>) -> Self::Writer {
+        if (self.filter)(meta) {
+            OptionalWriter::some(self.make.make_writer_for(meta))
+        } else {
+            OptionalWriter::none()
+        }
+    }
+}
+
+// === impl Tee ===
+
+impl<A, B> Tee<A, B> {
+    /// Combines two types implementing [`MakeWriter`], returning
+    /// a new [`MakeWriter`] that produces [writers] that write to *both*
+    /// outputs.
+    ///
+    /// See the documentation for [`MakeWriterExt::and`] for details.
+    pub fn new(a: A, b: B) -> Self {
+        Self { a, b }
+    }
+}
+
+impl<'a, A, B> MakeWriter<'a> for Tee<A, B>
+where
+    A: MakeWriter<'a>,
+    B: MakeWriter<'a>,
+{
+    type Writer = Tee<A::Writer, B::Writer>;
+
+    #[inline]
+    fn make_writer(&'a self) -> Self::Writer {
+        Tee::new(self.a.make_writer(), self.b.make_writer())
+    }
+
+    #[inline]
+    fn make_writer_for(&'a self, meta: &Metadata<'_>) -> Self::Writer {
+        Tee::new(self.a.make_writer_for(meta), self.b.make_writer_for(meta))
+    }
+}
+
+macro_rules! impl_tee {
+    ($self_:ident.$f:ident($($arg:ident),*)) => {
+        {
+            let res_a = $self_.a.$f($($arg),*);
+            let res_b = $self_.b.$f($($arg),*);
+            (res_a?, res_b?)
+        }
+    }
+}
+
+impl<A, B> io::Write for Tee<A, B>
+where
+    A: io::Write,
+    B: io::Write,
+{
+    #[inline]
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        let (a, b) = impl_tee!(self.write(buf));
+        Ok(std::cmp::max(a, b))
+    }
+
+    #[inline]
+    fn flush(&mut self) -> io::Result<()> {
+        impl_tee!(self.flush());
+        Ok(())
+    }
+
+    #[inline]
+    fn write_vectored(&mut self, bufs: &[io::IoSlice<'_>]) -> io::Result<usize> {
+        let (a, b) = impl_tee!(self.write_vectored(bufs));
+        Ok(std::cmp::max(a, b))
+    }
+
+    #[inline]
+    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
+        impl_tee!(self.write_all(buf));
+        Ok(())
+    }
+
+    #[inline]
+    fn write_fmt(&mut self, fmt: std::fmt::Arguments<'_>) -> io::Result<()> {
+        impl_tee!(self.write_fmt(fmt));
+        Ok(())
+    }
+}
+
+// === impl OrElse ===
+
+impl<A, B> OrElse<A, B> {
+    /// Combines
+    pub fn new<'a, W>(inner: A, or_else: B) -> Self
+    where
+        A: MakeWriter<'a, Writer = OptionalWriter<W>>,
+        B: MakeWriter<'a>,
+        W: Write,
+    {
+        Self { inner, or_else }
+    }
+}
+
+impl<'a, A, B, W> MakeWriter<'a> for OrElse<A, B>
+where
+    A: MakeWriter<'a, Writer = OptionalWriter<W>>,
+    B: MakeWriter<'a>,
+    W: io::Write,
+{
+    type Writer = EitherWriter<W, B::Writer>;
+
+    #[inline]
+    fn make_writer(&'a self) -> Self::Writer {
+        match self.inner.make_writer() {
+            EitherWriter::A(writer) => EitherWriter::A(writer),
+            EitherWriter::B(_) => EitherWriter::B(self.or_else.make_writer()),
+        }
+    }
+
+    #[inline]
+    fn make_writer_for(&'a self, meta: &Metadata<'_>) -> Self::Writer {
+        match self.inner.make_writer_for(meta) {
+            EitherWriter::A(writer) => EitherWriter::A(writer),
+            EitherWriter::B(_) => EitherWriter::B(self.or_else.make_writer_for(meta)),
+        }
+    }
+}
+
+// === impl ArcWriter ===
+
+impl<W> io::Write for ArcWriter<W>
+where
+    for<'a> &'a W: io::Write,
+{
+    #[inline]
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        (&*self.0).write(buf)
+    }
+
+    #[inline]
+    fn flush(&mut self) -> io::Result<()> {
+        (&*self.0).flush()
+    }
+
+    #[inline]
+    fn write_vectored(&mut self, bufs: &[io::IoSlice<'_>]) -> io::Result<usize> {
+        (&*self.0).write_vectored(bufs)
+    }
+
+    #[inline]
+    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
+        (&*self.0).write_all(buf)
+    }
+
+    #[inline]
+    fn write_fmt(&mut self, fmt: std::fmt::Arguments<'_>) -> io::Result<()> {
+        (&*self.0).write_fmt(fmt)
+    }
+}
+
+// === impl WriteAdaptor ===
+
+#[cfg(any(feature = "json", feature = "time"))]
+impl<'a> WriteAdaptor<'a> {
+    pub(in crate::fmt) fn new(fmt_write: &'a mut dyn fmt::Write) -> Self {
+        Self { fmt_write }
+    }
+}
+#[cfg(any(feature = "json", feature = "time"))]
+impl<'a> io::Write for WriteAdaptor<'a> {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        let s =
+            std::str::from_utf8(buf).map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?;
+
+        self.fmt_write
+            .write_str(s)
+            .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
+
+        Ok(s.as_bytes().len())
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+#[cfg(any(feature = "json", feature = "time"))]
+impl<'a> fmt::Debug for WriteAdaptor<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.pad("WriteAdaptor { .. }")
+    }
+}
+// === blanket impls ===
+
+impl<'a, M> MakeWriterExt<'a> for M where M: MakeWriter<'a> {}
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::fmt::format::Format;
+    use crate::fmt::test::{MockMakeWriter, MockWriter};
+    use crate::fmt::Subscriber;
+    use std::sync::atomic::{AtomicBool, Ordering};
+    use std::sync::{Arc, Mutex};
+    use tracing::{debug, error, info, trace, warn, Level};
+    use tracing_core::dispatcher::{self, Dispatch};
+
+    fn test_writer<T>(make_writer: T, msg: &str, buf: &Mutex<Vec<u8>>)
+    where
+        T: for<'writer> MakeWriter<'writer> + Send + Sync + 'static,
+    {
+        let subscriber = {
+            #[cfg(feature = "ansi")]
+            let f = Format::default().without_time().with_ansi(false);
+            #[cfg(not(feature = "ansi"))]
+            let f = Format::default().without_time();
+            Subscriber::builder()
+                .event_format(f)
+                .with_writer(make_writer)
+                .finish()
+        };
+        let dispatch = Dispatch::from(subscriber);
+
+        dispatcher::with_default(&dispatch, || {
+            error!("{}", msg);
+        });
+
+        let expected = format!("ERROR {}: {}\n", module_path!(), msg);
+        let actual = String::from_utf8(buf.try_lock().unwrap().to_vec()).unwrap();
+        assert!(actual.contains(expected.as_str()));
+    }
+
+    fn has_lines(buf: &Mutex<Vec<u8>>, msgs: &[(tracing::Level, &str)]) {
+        let actual = String::from_utf8(buf.try_lock().unwrap().to_vec()).unwrap();
+        let mut expected_lines = msgs.iter();
+        for line in actual.lines() {
+            let line = dbg!(line).trim();
+            let (level, msg) = expected_lines
+                .next()
+                .unwrap_or_else(|| panic!("expected no more lines, but got: {:?}", line));
+            let expected = format!("{} {}: {}", level, module_path!(), msg);
+            assert_eq!(line, expected.as_str());
+        }
+    }
+
+    #[test]
+    fn custom_writer_closure() {
+        let buf = Arc::new(Mutex::new(Vec::new()));
+        let buf2 = buf.clone();
+        let make_writer = move || MockWriter::new(buf2.clone());
+        let msg = "my custom writer closure error";
+        test_writer(make_writer, msg, &buf);
+    }
+
+    #[test]
+    fn custom_writer_struct() {
+        let buf = Arc::new(Mutex::new(Vec::new()));
+        let make_writer = MockMakeWriter::new(buf.clone());
+        let msg = "my custom writer struct error";
+        test_writer(make_writer, msg, &buf);
+    }
+
+    #[test]
+    fn custom_writer_mutex() {
+        let buf = Arc::new(Mutex::new(Vec::new()));
+        let writer = MockWriter::new(buf.clone());
+        let make_writer = Mutex::new(writer);
+        let msg = "my mutex writer error";
+        test_writer(make_writer, msg, &buf);
+    }
+
+    #[test]
+    fn combinators_level_filters() {
+        let info_buf = Arc::new(Mutex::new(Vec::new()));
+        let info = MockMakeWriter::new(info_buf.clone());
+
+        let debug_buf = Arc::new(Mutex::new(Vec::new()));
+        let debug = MockMakeWriter::new(debug_buf.clone());
+
+        let warn_buf = Arc::new(Mutex::new(Vec::new()));
+        let warn = MockMakeWriter::new(warn_buf.clone());
+
+        let err_buf = Arc::new(Mutex::new(Vec::new()));
+        let err = MockMakeWriter::new(err_buf.clone());
+
+        let make_writer = info
+            .with_max_level(Level::INFO)
+            .and(debug.with_max_level(Level::DEBUG))
+            .and(warn.with_max_level(Level::WARN))
+            .and(err.with_max_level(Level::ERROR));
+
+        let c = {
+            #[cfg(feature = "ansi")]
+            let f = Format::default().without_time().with_ansi(false);
+            #[cfg(not(feature = "ansi"))]
+            let f = Format::default().without_time();
+            Subscriber::builder()
+                .event_format(f)
+                .with_writer(make_writer)
+                .with_max_level(Level::TRACE)
+                .finish()
+        };
+
+        let _s = tracing::subscriber::set_default(c);
+
+        trace!("trace");
+        debug!("debug");
+        info!("info");
+        warn!("warn");
+        error!("error");
+
+        let all_lines = [
+            (Level::TRACE, "trace"),
+            (Level::DEBUG, "debug"),
+            (Level::INFO, "info"),
+            (Level::WARN, "warn"),
+            (Level::ERROR, "error"),
+        ];
+
+        println!("max level debug");
+        has_lines(&debug_buf, &all_lines[1..]);
+
+        println!("max level info");
+        has_lines(&info_buf, &all_lines[2..]);
+
+        println!("max level warn");
+        has_lines(&warn_buf, &all_lines[3..]);
+
+        println!("max level error");
+        has_lines(&err_buf, &all_lines[4..]);
+    }
+
+    #[test]
+    fn combinators_or_else() {
+        let some_buf = Arc::new(Mutex::new(Vec::new()));
+        let some = MockMakeWriter::new(some_buf.clone());
+
+        let or_else_buf = Arc::new(Mutex::new(Vec::new()));
+        let or_else = MockMakeWriter::new(or_else_buf.clone());
+
+        let return_some = AtomicBool::new(true);
+        let make_writer = move || {
+            if return_some.swap(false, Ordering::Relaxed) {
+                OptionalWriter::some(some.make_writer())
+            } else {
+                OptionalWriter::none()
+            }
+        };
+        let make_writer = make_writer.or_else(or_else);
+        let c = {
+            #[cfg(feature = "ansi")]
+            let f = Format::default().without_time().with_ansi(false);
+            #[cfg(not(feature = "ansi"))]
+            let f = Format::default().without_time();
+            Subscriber::builder()
+                .event_format(f)
+                .with_writer(make_writer)
+                .with_max_level(Level::TRACE)
+                .finish()
+        };
+
+        let _s = tracing::subscriber::set_default(c);
+        info!("hello");
+        info!("world");
+        info!("goodbye");
+
+        has_lines(&some_buf, &[(Level::INFO, "hello")]);
+        has_lines(
+            &or_else_buf,
+            &[(Level::INFO, "world"), (Level::INFO, "goodbye")],
+        );
+    }
+
+    #[test]
+    fn combinators_or_else_chain() {
+        let info_buf = Arc::new(Mutex::new(Vec::new()));
+        let info = MockMakeWriter::new(info_buf.clone());
+
+        let debug_buf = Arc::new(Mutex::new(Vec::new()));
+        let debug = MockMakeWriter::new(debug_buf.clone());
+
+        let warn_buf = Arc::new(Mutex::new(Vec::new()));
+        let warn = MockMakeWriter::new(warn_buf.clone());
+
+        let err_buf = Arc::new(Mutex::new(Vec::new()));
+        let err = MockMakeWriter::new(err_buf.clone());
+
+        let make_writer = err.with_max_level(Level::ERROR).or_else(
+            warn.with_max_level(Level::WARN).or_else(
+                info.with_max_level(Level::INFO)
+                    .or_else(debug.with_max_level(Level::DEBUG)),
+            ),
+        );
+
+        let c = {
+            #[cfg(feature = "ansi")]
+            let f = Format::default().without_time().with_ansi(false);
+            #[cfg(not(feature = "ansi"))]
+            let f = Format::default().without_time();
+            Subscriber::builder()
+                .event_format(f)
+                .with_writer(make_writer)
+                .with_max_level(Level::TRACE)
+                .finish()
+        };
+
+        let _s = tracing::subscriber::set_default(c);
+
+        trace!("trace");
+        debug!("debug");
+        info!("info");
+        warn!("warn");
+        error!("error");
+
+        println!("max level debug");
+        has_lines(&debug_buf, &[(Level::DEBUG, "debug")]);
+
+        println!("max level info");
+        has_lines(&info_buf, &[(Level::INFO, "info")]);
+
+        println!("max level warn");
+        has_lines(&warn_buf, &[(Level::WARN, "warn")]);
+
+        println!("max level error");
+        has_lines(&err_buf, &[(Level::ERROR, "error")]);
+    }
+
+    #[test]
+    fn combinators_and() {
+        let a_buf = Arc::new(Mutex::new(Vec::new()));
+        let a = MockMakeWriter::new(a_buf.clone());
+
+        let b_buf = Arc::new(Mutex::new(Vec::new()));
+        let b = MockMakeWriter::new(b_buf.clone());
+
+        let lines = &[(Level::INFO, "hello"), (Level::INFO, "world")];
+
+        let make_writer = a.and(b);
+        let c = {
+            #[cfg(feature = "ansi")]
+            let f = Format::default().without_time().with_ansi(false);
+            #[cfg(not(feature = "ansi"))]
+            let f = Format::default().without_time();
+            Subscriber::builder()
+                .event_format(f)
+                .with_writer(make_writer)
+                .with_max_level(Level::TRACE)
+                .finish()
+        };
+
+        let _s = tracing::subscriber::set_default(c);
+        info!("hello");
+        info!("world");
+
+        has_lines(&a_buf, &lines[..]);
+        has_lines(&b_buf, &lines[..]);
+    }
+}
diff --git a/vendor/tracing-subscriber-0.3.3/src/layer/context.rs b/vendor/tracing-subscriber-0.3.3/src/layer/context.rs
new file mode 100644
index 000000000..e11959526
--- /dev/null
+++ b/vendor/tracing-subscriber-0.3.3/src/layer/context.rs
@@ -0,0 +1,434 @@
+use tracing_core::{metadata::Metadata, span, subscriber::Subscriber, Event};
+
+use crate::registry::{self, LookupSpan, SpanRef};
+
+#[cfg(all(feature = "registry", feature = "std"))]
+use crate::{filter::FilterId, registry::Registry};
+/// Represents information about the current context provided to [`Layer`]s by the
+/// wrapped [`Subscriber`].
+///
+/// To access [stored data] keyed by a span ID, implementors of the `Layer`
+/// trait should ensure that the `Subscriber` type parameter is *also* bound by the
+/// [`LookupSpan`]:
+///
+/// ```rust
+/// use tracing::Subscriber;
+/// use tracing_subscriber::{Layer, registry::LookupSpan};
+///
+/// pub struct MyLayer;
+///
+/// impl<S> Layer<S> for MyLayer
+/// where
+///     S: Subscriber + for<'a> LookupSpan<'a>,
+/// {
+///     // ...
+/// }
+/// ```
+///
+/// [`Layer`]: ../layer/trait.Layer.html
+/// [`Subscriber`]: https://docs.rs/tracing-core/latest/tracing_core/trait.Subscriber.html
+/// [stored data]: ../registry/struct.SpanRef.html
+/// [`LookupSpan`]: "../registry/trait.LookupSpan.html
+#[derive(Debug)]
+pub struct Context<'a, S> {
+    subscriber: Option<&'a S>,
+    /// The bitmask of all [`Filtered`] layers that currently apply in this
+    /// context. If there is only a single [`Filtered`] wrapping the layer that
+    /// produced this context, then this is that filter's ID. Otherwise, if we
+    /// are in a nested tree with multiple filters, this is produced by
+    /// [`and`]-ing together the [`FilterId`]s of each of the filters that wrap
+    /// the current layer.
+    ///
+    /// [`Filtered`]: crate::filter::Filtered
+    /// [`FilterId`]: crate::filter::FilterId
+    /// [`and`]: crate::filter::FilterId::and
+    #[cfg(all(feature = "registry", feature = "std"))]
+    filter: FilterId,
+}
+
+// === impl Context ===
+
+impl<'a, S> Context<'a, S>
+where
+    S: Subscriber,
+{
+    pub(super) fn new(subscriber: &'a S) -> Self {
+        Self {
+            subscriber: Some(subscriber),
+
+            #[cfg(feature = "registry")]
+            filter: FilterId::none(),
+        }
+    }
+
+    /// Returns the wrapped subscriber's view of the current span.
+    #[inline]
+    pub fn current_span(&self) -> span::Current {
+        self.subscriber
+            .map(Subscriber::current_span)
+            // TODO: this would be more correct as "unknown", so perhaps
+            // `tracing-core` should make `Current::unknown()` public?
+            .unwrap_or_else(span::Current::none)
+    }
+
+    /// Returns whether the wrapped subscriber would enable the current span.
+    #[inline]
+    pub fn enabled(&self, metadata: &Metadata<'_>) -> bool {
+        self.subscriber
+            .map(|subscriber| subscriber.enabled(metadata))
+            // If this context is `None`, we are registering a callsite, so
+            // return `true` so that the layer does not incorrectly assume that
+            // the inner subscriber has disabled this metadata.
+            // TODO(eliza): would it be more correct for this to return an `Option`?
+            .unwrap_or(true)
+    }
+
+    /// Records the provided `event` with the wrapped subscriber.
+    ///
+    /// # Notes
+    ///
+    /// - The subscriber is free to expect that the event's callsite has been
+    ///   [registered][register], and may panic or fail to observe the event if this is
+    ///   not the case. The `tracing` crate's macros ensure that all events are
+    ///   registered, but if the event is constructed through other means, the
+    ///   user is responsible for ensuring that [`register_callsite`][register]
+    ///   has been called prior to calling this method.
+    /// - This does _not_ call [`enabled`] on the inner subscriber. If the
+    ///   caller wishes to apply the wrapped subscriber's filter before choosing
+    ///   whether to record the event, it may first call [`Context::enabled`] to
+    ///   check whether the event would be enabled. This allows `Layer`s to
+    ///   elide constructing the event if it would not be recorded.
+    ///
+    /// [register]: https://docs.rs/tracing-core/latest/tracing_core/subscriber/trait.Subscriber.html#method.register_callsite
+    /// [`enabled`]: https://docs.rs/tracing-core/latest/tracing_core/subscriber/trait.Subscriber.html#method.enabled
+    /// [`Context::enabled`]: #method.enabled
+    #[inline]
+    pub fn event(&self, event: &Event<'_>) {
+        if let Some(subscriber) = self.subscriber {
+            subscriber.event(event);
+        }
+    }
+
+    /// Returns a [`SpanRef`] for the parent span of the given [`Event`], if
+    /// it has a parent.
+    ///
+    /// If the event has an explicitly overridden parent, this method returns
+    /// a reference to that span. If the event's parent is the current span,
+    /// this returns a reference to the current span, if there is one. If this
+    /// returns `None`, then either the event's parent was explicitly set to
+    /// `None`, or the event's parent was defined contextually, but no span
+    /// is currently entered.
+    ///
+    /// Compared to [`Context::current_span`] and [`Context::lookup_current`],
+    /// this respects overrides provided by the [`Event`].
+    ///
+    /// Compared to [`Event::parent`], this automatically falls back to the contextual
+    /// span, if required.
+    ///
+    /// ```rust
+    /// use tracing::{Event, Subscriber};
+    /// use tracing_subscriber::{
+    ///     layer::{Context, Layer},
+    ///     prelude::*,
+    ///     registry::LookupSpan,
+    /// };
+    ///
+    /// struct PrintingLayer;
+    /// impl<S> Layer<S> for PrintingLayer
+    /// where
+    ///     S: Subscriber + for<'lookup> LookupSpan<'lookup>,
+    /// {
+    ///     fn on_event(&self, event: &Event, ctx: Context<S>) {
+    ///         let span = ctx.event_span(event);
+    ///         println!("Event in span: {:?}", span.map(|s| s.name()));
+    ///     }
+    /// }
+    ///
+    /// tracing::subscriber::with_default(tracing_subscriber::registry().with(PrintingLayer), || {
+    ///     tracing::info!("no span");
+    ///     // Prints: Event in span: None
+    ///
+    ///     let span = tracing::info_span!("span");
+    ///     tracing::info!(parent: &span, "explicitly specified");
+    ///     // Prints: Event in span: Some("span")
+    ///
+    ///     let _guard = span.enter();
+    ///     tracing::info!("contextual span");
+    ///     // Prints: Event in span: Some("span")
+    /// });
+    /// ```
+    ///
+    /// <pre class="ignore" style="white-space:normal;font:inherit;">
+    ///     <strong>Note</strong>: This requires the wrapped subscriber to
+    ///     implement the <a href="../registry/trait.LookupSpan.html"><code>
+    ///     LookupSpan</code></a> trait. See the documentation on
+    ///     <a href="./struct.Context.html"><code>Context</code>'s
+    ///     declaration</a> for details.
+    /// </pre>
+    #[inline]
+    pub fn event_span(&self, event: &Event<'_>) -> Option<SpanRef<'_, S>>
+    where
+        S: for<'lookup> LookupSpan<'lookup>,
+    {
+        if event.is_root() {
+            None
+        } else if event.is_contextual() {
+            self.lookup_current()
+        } else {
+            // TODO(eliza): this should handle parent IDs
+            event.parent().and_then(|id| self.span(id))
+        }
+    }
+
+    /// Returns metadata for the span with the given `id`, if it exists.
+    ///
+    /// If this returns `None`, then no span exists for that ID (either it has
+    /// closed or the ID is invalid).
+    #[inline]
+    pub fn metadata(&self, id: &span::Id) -> Option<&'static Metadata<'static>>
+    where
+        S: for<'lookup> LookupSpan<'lookup>,
+    {
+        let span = self.span(id)?;
+        Some(span.metadata())
+    }
+
+    /// Returns [stored data] for the span with the given `id`, if it exists.
+    ///
+    /// If this returns `None`, then no span exists for that ID (either it has
+    /// closed or the ID is invalid).
+    ///
+    /// <pre class="ignore" style="white-space:normal;font:inherit;">
+    ///     <strong>Note</strong>: This requires the wrapped subscriber to
+    ///     implement the <a href="../registry/trait.LookupSpan.html"><code>
+    ///     LookupSpan</code></a> trait. See the documentation on
+    ///     <a href="./struct.Context.html"><code>Context</code>'s
+    ///     declaration</a> for details.
+    /// </pre>
+    ///
+    /// [stored data]: ../registry/struct.SpanRef.html
+    #[inline]
+    pub fn span(&self, id: &span::Id) -> Option<registry::SpanRef<'_, S>>
+    where
+        S: for<'lookup> LookupSpan<'lookup>,
+    {
+        let span = self.subscriber.as_ref()?.span(id)?;
+
+        #[cfg(all(feature = "registry", feature = "std"))]
+        return span.try_with_filter(self.filter);
+
+        #[cfg(not(feature = "registry"))]
+        Some(span)
+    }
+
+    /// Returns `true` if an active span exists for the given `Id`.
+    ///
+    /// <pre class="ignore" style="white-space:normal;font:inherit;">
+    ///     <strong>Note</strong>: This requires the wrapped subscriber to
+    ///     implement the <a href="../registry/trait.LookupSpan.html"><code>
+    ///     LookupSpan</code></a> trait. See the documentation on
+    ///     <a href="./struct.Context.html"><code>Context</code>'s
+    ///     declaration</a> for details.
+    /// </pre>
+    #[inline]
+    pub fn exists(&self, id: &span::Id) -> bool
+    where
+        S: for<'lookup> LookupSpan<'lookup>,
+    {
+        self.subscriber.as_ref().and_then(|s| s.span(id)).is_some()
+    }
+
+    /// Returns [stored data] for the span that the wrapped subscriber considers
+    /// to be the current.
+    ///
+    /// If this returns `None`, then we are not currently within a span.
+    ///
+    /// <pre class="ignore" style="white-space:normal;font:inherit;">
+    ///     <strong>Note</strong>: This requires the wrapped subscriber to
+    ///     implement the <a href="../registry/trait.LookupSpan.html"><code>
+    ///     LookupSpan</code></a> trait. See the documentation on
+    ///     <a href="./struct.Context.html"><code>Context</code>'s
+    ///     declaration</a> for details.
+    /// </pre>
+    ///
+    /// [stored data]: ../registry/struct.SpanRef.html
+    #[inline]
+    pub fn lookup_current(&self) -> Option<registry::SpanRef<'_, S>>
+    where
+        S: for<'lookup> LookupSpan<'lookup>,
+    {
+        let subscriber = *self.subscriber.as_ref()?;
+        let current = subscriber.current_span();
+        let id = current.id()?;
+        let span = subscriber.span(id);
+        debug_assert!(
+            span.is_some(),
+            "the subscriber should have data for the current span ({:?})!",
+            id,
+        );
+
+        // If we found a span, and our per-layer filter enables it, return that
+        // span!
+        #[cfg(all(feature = "registry", feature = "std"))]
+        {
+            if let Some(span) = span?.try_with_filter(self.filter) {
+                Some(span)
+            } else {
+                // Otherwise, the span at the *top* of the stack is disabled by
+                // per-layer filtering, but there may be additional spans in the stack.
+                //
+                // Currently, `LookupSpan` doesn't have a nice way of exposing access to
+                // the whole span stack. However, if we can downcast the innermost
+                // subscriber to a a `Registry`, we can iterate over its current span
+                // stack.
+                //
+                // TODO(eliza): when https://github.com/tokio-rs/tracing/issues/1459 is
+                // implemented, change this to use that instead...
+                self.lookup_current_filtered(subscriber)
+            }
+        }
+
+        #[cfg(not(feature = "registry"))]
+        span
+    }
+
+    /// Slow path for when the current span is disabled by PLF and we have a
+    /// registry.
+    // This is called by `lookup_current` in the case that per-layer filtering
+    // is in use. `lookup_current` is allowed to be inlined, but this method is
+    // factored out to prevent the loop and (potentially-recursive) subscriber
+    // downcasting from being inlined if `lookup_current` is inlined.
+    #[inline(never)]
+    #[cfg(all(feature = "registry", feature = "std"))]
+    fn lookup_current_filtered<'lookup>(
+        &self,
+        subscriber: &'lookup S,
+    ) -> Option<registry::SpanRef<'lookup, S>>
+    where
+        S: LookupSpan<'lookup>,
+    {
+        let registry = (subscriber as &dyn Subscriber).downcast_ref::<Registry>()?;
+        registry
+            .span_stack()
+            .iter()
+            .find_map(|id| subscriber.span(id)?.try_with_filter(self.filter))
+    }
+
+    /// Returns an iterator over the [stored data] for all the spans in the
+    /// current context, starting with the specified span and ending with the
+    /// root of the trace tree and ending with the current span.
+    ///
+    /// <pre class="ignore" style="white-space:normal;font:inherit;">
+    /// <strong>Note</strong>: Compared to <a href="#method.scope"><code>scope</code></a> this
+    /// returns the spans in reverse order (from leaf to root). Use
+    /// <a href="../registry/struct.Scope.html#method.from_root"><code>Scope::from_root</code></a>
+    /// in case root-to-leaf ordering is desired.
+    /// </pre>
+    ///
+    /// <pre class="ignore" style="white-space:normal;font:inherit;">
+    ///     <strong>Note</strong>: This requires the wrapped subscriber to
+    ///     implement the <a href="../registry/trait.LookupSpan.html"><code>
+    ///     LookupSpan</code></a> trait. See the documentation on
+    ///     <a href="./struct.Context.html"><code>Context</code>'s
+    ///     declaration</a> for details.
+    /// </pre>
+    ///
+    /// [stored data]: ../registry/struct.SpanRef.html
+    pub fn span_scope(&self, id: &span::Id) -> Option<registry::Scope<'_, S>>
+    where
+        S: for<'lookup> LookupSpan<'lookup>,
+    {
+        Some(self.span(id)?.scope())
+    }
+
+    /// Returns an iterator over the [stored data] for all the spans in the
+    /// current context, starting with the parent span of the specified event,
+    /// and ending with the root of the trace tree and ending with the current span.
+    ///
+    /// <pre class="ignore" style="white-space:normal;font:inherit;">
+    /// <strong>Note</strong>: Compared to <a href="#method.scope"><code>scope</code></a> this
+    /// returns the spans in reverse order (from leaf to root). Use
+    /// <a href="../registry/struct.Scope.html#method.from_root"><code>Scope::from_root</code></a>
+    /// in case root-to-leaf ordering is desired.
+    /// </pre>
+    ///
+    /// <pre class="ignore" style="white-space:normal;font:inherit;">
+    ///     <strong>Note</strong>: This requires the wrapped subscriber to
+    ///     implement the <a href="../registry/trait.LookupSpan.html"><code>
+    ///     LookupSpan</code></a> trait. See the documentation on
+    ///     <a href="./struct.Context.html"><code>Context</code>'s
+    ///     declaration</a> for details.
+    /// </pre>
+    ///
+    /// [stored data]: ../registry/struct.SpanRef.html
+    pub fn event_scope(&self, event: &Event<'_>) -> Option<registry::Scope<'_, S>>
+    where
+        S: for<'lookup> LookupSpan<'lookup>,
+    {
+        Some(self.event_span(event)?.scope())
+    }
+
+    #[cfg(all(feature = "registry", feature = "std"))]
+    pub(crate) fn with_filter(self, filter: FilterId) -> Self {
+        // If we already have our own `FilterId`, combine it with the provided
+        // one. That way, the new `FilterId` will consider a span to be disabled
+        // if it was disabled by the given `FilterId` *or* any `FilterId`s for
+        // layers "above" us in the stack.
+        //
+        // See the doc comment for `FilterId::and` for details.
+        let filter = self.filter.and(filter);
+        Self { filter, ..self }
+    }
+
+    #[cfg(all(feature = "registry", feature = "std"))]
+    pub(crate) fn is_enabled_for(&self, span: &span::Id, filter: FilterId) -> bool
+    where
+        S: for<'lookup> LookupSpan<'lookup>,
+    {
+        self.is_enabled_inner(span, filter).unwrap_or(false)
+    }
+
+    #[cfg(all(feature = "registry", feature = "std"))]
+    pub(crate) fn if_enabled_for(self, span: &span::Id, filter: FilterId) -> Option<Self>
+    where
+        S: for<'lookup> LookupSpan<'lookup>,
+    {
+        if self.is_enabled_inner(span, filter)? {
+            Some(self.with_filter(filter))
+        } else {
+            None
+        }
+    }
+
+    #[cfg(all(feature = "registry", feature = "std"))]
+    fn is_enabled_inner(&self, span: &span::Id, filter: FilterId) -> Option<bool>
+    where
+        S: for<'lookup> LookupSpan<'lookup>,
+    {
+        Some(self.span(span)?.is_enabled_for(filter))
+    }
+}
+
+impl<'a, S> Context<'a, S> {
+    pub(crate) fn none() -> Self {
+        Self {
+            subscriber: None,
+
+            #[cfg(feature = "registry")]
+            filter: FilterId::none(),
+        }
+    }
+}
+
+impl<'a, S> Clone for Context<'a, S> {
+    #[inline]
+    fn clone(&self) -> Self {
+        let subscriber = self.subscriber.as_ref().copied();
+        Context {
+            subscriber,
+
+            #[cfg(all(feature = "registry", feature = "std"))]
+            filter: self.filter,
+        }
+    }
+}
diff --git a/vendor/tracing-subscriber-0.3.3/src/layer/layered.rs b/vendor/tracing-subscriber-0.3.3/src/layer/layered.rs
new file mode 100644
index 000000000..c690764ad
--- /dev/null
+++ b/vendor/tracing-subscriber-0.3.3/src/layer/layered.rs
@@ -0,0 +1,471 @@
+use tracing_core::{
+    metadata::Metadata,
+    span,
+    subscriber::{Interest, Subscriber},
+    Event, LevelFilter,
+};
+
+use crate::{
+    filter,
+    layer::{Context, Layer},
+    registry::LookupSpan,
+};
+#[cfg(all(feature = "registry", feature = "std"))]
+use crate::{filter::FilterId, registry::Registry};
+use core::{any::TypeId, cmp, fmt, marker::PhantomData};
+
+/// A [`Subscriber`] composed of a `Subscriber` wrapped by one or more
+/// [`Layer`]s.
+///
+/// [`Layer`]: crate::Layer
+/// [`Subscriber`]: https://docs.rs/tracing-core/latest/tracing_core/trait.Subscriber.html
+#[derive(Clone)]
+pub struct Layered<L, I, S = I> {
+    /// The layer.
+    layer: L,
+
+    /// The inner value that `self.layer` was layered onto.
+    ///
+    /// If this is also a `Layer`, then this `Layered` will implement `Layer`.
+    /// If this is a `Subscriber`, then this `Layered` will implement
+    /// `Subscriber` instead.
+    inner: I,
+
+    // These booleans are used to determine how to combine `Interest`s and max
+    // level hints when per-layer filters are in use.
+    /// Is `self.inner` a `Registry`?
+    ///
+    /// If so, when combining `Interest`s, we want to "bubble up" its
+    /// `Interest`.
+    inner_is_registry: bool,
+
+    /// Does `self.layer` have per-layer filters?
+    ///
+    /// This will be true if:
+    /// - `self.inner` is a `Filtered`.
+    /// - `self.inner` is a tree of `Layered`s where _all_ arms of those
+    ///   `Layered`s have per-layer filters.
+    ///
+    /// Otherwise, if it's a `Layered` with one per-layer filter in one branch,
+    /// but a non-per-layer-filtered layer in the other branch, this will be
+    /// _false_, because the `Layered` is already handling the combining of
+    /// per-layer filter `Interest`s and max level hints with its non-filtered
+    /// `Layer`.
+    has_layer_filter: bool,
+
+    /// Does `self.inner` have per-layer filters?
+    ///
+    /// This is determined according to the same rules as
+    /// `has_layer_filter` above.
+    inner_has_layer_filter: bool,
+    _s: PhantomData<fn(S)>,
+}
+
+// === impl Layered ===
+
+impl<L, S> Subscriber for Layered<L, S>
+where
+    L: Layer<S>,
+    S: Subscriber,
+{
+    fn register_callsite(&self, metadata: &'static Metadata<'static>) -> Interest {
+        self.pick_interest(self.layer.register_callsite(metadata), || {
+            self.inner.register_callsite(metadata)
+        })
+    }
+
+    fn enabled(&self, metadata: &Metadata<'_>) -> bool {
+        if self.layer.enabled(metadata, self.ctx()) {
+            // if the outer layer enables the callsite metadata, ask the subscriber.
+            self.inner.enabled(metadata)
+        } else {
+            // otherwise, the callsite is disabled by the layer
+
+            // If per-layer filters are in use, and we are short-circuiting
+            // (rather than calling into the inner type), clear the current
+            // per-layer filter `enabled` state.
+            #[cfg(feature = "registry")]
+            filter::FilterState::clear_enabled();
+
+            false
+        }
+    }
+
+    fn max_level_hint(&self) -> Option<LevelFilter> {
+        self.pick_level_hint(self.layer.max_level_hint(), self.inner.max_level_hint())
+    }
+
+    fn new_span(&self, span: &span::Attributes<'_>) -> span::Id {
+        let id = self.inner.new_span(span);
+        self.layer.on_new_span(span, &id, self.ctx());
+        id
+    }
+
+    fn record(&self, span: &span::Id, values: &span::Record<'_>) {
+        self.inner.record(span, values);
+        self.layer.on_record(span, values, self.ctx());
+    }
+
+    fn record_follows_from(&self, span: &span::Id, follows: &span::Id) {
+        self.inner.record_follows_from(span, follows);
+        self.layer.on_follows_from(span, follows, self.ctx());
+    }
+
+    fn event(&self, event: &Event<'_>) {
+        self.inner.event(event);
+        self.layer.on_event(event, self.ctx());
+    }
+
+    fn enter(&self, span: &span::Id) {
+        self.inner.enter(span);
+        self.layer.on_enter(span, self.ctx());
+    }
+
+    fn exit(&self, span: &span::Id) {
+        self.inner.exit(span);
+        self.layer.on_exit(span, self.ctx());
+    }
+
+    fn clone_span(&self, old: &span::Id) -> span::Id {
+        let new = self.inner.clone_span(old);
+        if &new != old {
+            self.layer.on_id_change(old, &new, self.ctx())
+        };
+        new
+    }
+
+    #[inline]
+    fn drop_span(&self, id: span::Id) {
+        self.try_close(id);
+    }
+
+    fn try_close(&self, id: span::Id) -> bool {
+        #[cfg(all(feature = "registry", feature = "std"))]
+        let subscriber = &self.inner as &dyn Subscriber;
+        #[cfg(all(feature = "registry", feature = "std"))]
+        let mut guard = subscriber
+            .downcast_ref::<Registry>()
+            .map(|registry| registry.start_close(id.clone()));
+        if self.inner.try_close(id.clone()) {
+            // If we have a registry's close guard, indicate that the span is
+            // closing.
+            #[cfg(all(feature = "registry", feature = "std"))]
+            {
+                if let Some(g) = guard.as_mut() {
+                    g.is_closing()
+                };
+            }
+
+            self.layer.on_close(id, self.ctx());
+            true
+        } else {
+            false
+        }
+    }
+
+    #[inline]
+    fn current_span(&self) -> span::Current {
+        self.inner.current_span()
+    }
+
+    #[doc(hidden)]
+    unsafe fn downcast_raw(&self, id: TypeId) -> Option<*const ()> {
+        // Unlike the implementation of `Layer` for `Layered`, we don't have to
+        // handle the "magic PLF downcast marker" here. If a `Layered`
+        // implements `Subscriber`, we already know that the `inner` branch is
+        // going to contain something that doesn't have per-layer filters (the
+        // actual root `Subscriber`). Thus, a `Layered` that implements
+        // `Subscriber` will always be propagating the root subscriber's
+        // `Interest`/level hint, even if it includes a `Layer` that has
+        // per-layer filters, because it will only ever contain layers where
+        // _one_ child has per-layer filters.
+        //
+        // The complex per-layer filter detection logic is only relevant to
+        // *trees* of layers, which involve the `Layer` implementation for
+        // `Layered`, not *lists* of layers, where every `Layered` implements
+        // `Subscriber`. Of course, a linked list can be thought of as a
+        // degenerate tree...but luckily, we are able to make a type-level
+        // distinction between individual `Layered`s that are definitely
+        // list-shaped (their inner child implements `Subscriber`), and
+        // `Layered`s that might be tree-shaped (the inner child is also a
+        // `Layer`).
+
+        // If downcasting to `Self`, return a pointer to `self`.
+        if id == TypeId::of::<Self>() {
+            return Some(self as *const _ as *const ());
+        }
+
+        self.layer
+            .downcast_raw(id)
+            .or_else(|| self.inner.downcast_raw(id))
+    }
+}
+
+impl<S, A, B> Layer<S> for Layered<A, B, S>
+where
+    A: Layer<S>,
+    B: Layer<S>,
+    S: Subscriber,
+{
+    fn on_layer(&mut self, subscriber: &mut S) {
+        self.layer.on_layer(subscriber);
+        self.inner.on_layer(subscriber);
+    }
+
+    fn register_callsite(&self, metadata: &'static Metadata<'static>) -> Interest {
+        self.pick_interest(self.layer.register_callsite(metadata), || {
+            self.inner.register_callsite(metadata)
+        })
+    }
+
+    fn enabled(&self, metadata: &Metadata<'_>, ctx: Context<'_, S>) -> bool {
+        if self.layer.enabled(metadata, ctx.clone()) {
+            // if the outer subscriber enables the callsite metadata, ask the inner layer.
+            self.inner.enabled(metadata, ctx)
+        } else {
+            // otherwise, the callsite is disabled by this layer
+            false
+        }
+    }
+
+    fn max_level_hint(&self) -> Option<LevelFilter> {
+        self.pick_level_hint(self.layer.max_level_hint(), self.inner.max_level_hint())
+    }
+
+    #[inline]
+    fn on_new_span(&self, attrs: &span::Attributes<'_>, id: &span::Id, ctx: Context<'_, S>) {
+        self.inner.on_new_span(attrs, id, ctx.clone());
+        self.layer.on_new_span(attrs, id, ctx);
+    }
+
+    #[inline]
+    fn on_record(&self, span: &span::Id, values: &span::Record<'_>, ctx: Context<'_, S>) {
+        self.inner.on_record(span, values, ctx.clone());
+        self.layer.on_record(span, values, ctx);
+    }
+
+    #[inline]
+    fn on_follows_from(&self, span: &span::Id, follows: &span::Id, ctx: Context<'_, S>) {
+        self.inner.on_follows_from(span, follows, ctx.clone());
+        self.layer.on_follows_from(span, follows, ctx);
+    }
+
+    #[inline]
+    fn on_event(&self, event: &Event<'_>, ctx: Context<'_, S>) {
+        self.inner.on_event(event, ctx.clone());
+        self.layer.on_event(event, ctx);
+    }
+
+    #[inline]
+    fn on_enter(&self, id: &span::Id, ctx: Context<'_, S>) {
+        self.inner.on_enter(id, ctx.clone());
+        self.layer.on_enter(id, ctx);
+    }
+
+    #[inline]
+    fn on_exit(&self, id: &span::Id, ctx: Context<'_, S>) {
+        self.inner.on_exit(id, ctx.clone());
+        self.layer.on_exit(id, ctx);
+    }
+
+    #[inline]
+    fn on_close(&self, id: span::Id, ctx: Context<'_, S>) {
+        self.inner.on_close(id.clone(), ctx.clone());
+        self.layer.on_close(id, ctx);
+    }
+
+    #[inline]
+    fn on_id_change(&self, old: &span::Id, new: &span::Id, ctx: Context<'_, S>) {
+        self.inner.on_id_change(old, new, ctx.clone());
+        self.layer.on_id_change(old, new, ctx);
+    }
+
+    #[doc(hidden)]
+    unsafe fn downcast_raw(&self, id: TypeId) -> Option<*const ()> {
+        match id {
+            // If downcasting to `Self`, return a pointer to `self`.
+            id if id == TypeId::of::<Self>() => Some(self as *const _ as *const ()),
+
+            // Oh, we're looking for per-layer filters!
+            //
+            // This should only happen if we are inside of another `Layered`,
+            // and it's trying to determine how it should combine `Interest`s
+            // and max level hints.
+            //
+            // In that case, this `Layered` should be considered to be
+            // "per-layer filtered" if *both* the outer layer and the inner
+            // layer/subscriber have per-layer filters. Otherwise, this `Layered
+            // should *not* be considered per-layer filtered (even if one or the
+            // other has per layer filters). If only one `Layer` is per-layer
+            // filtered, *this* `Layered` will handle aggregating the `Interest`
+            // and level hints on behalf of its children, returning the
+            // aggregate (which is the value from the &non-per-layer-filtered*
+            // child).
+            //
+            // Yes, this rule *is* slightly counter-intuitive, but it's
+            // necessary due to a weird edge case that can occur when two
+            // `Layered`s where one side is per-layer filtered and the other
+            // isn't are `Layered` together to form a tree. If we didn't have
+            // this rule, we would actually end up *ignoring* `Interest`s from
+            // the non-per-layer-filtered layers, since both branches would
+            // claim to have PLF.
+            //
+            // If you don't understand this...that's fine, just don't mess with
+            // it. :)
+            id if filter::is_plf_downcast_marker(id) => {
+                self.layer.downcast_raw(id).and(self.inner.downcast_raw(id))
+            }
+
+            // Otherwise, try to downcast both branches normally...
+            _ => self
+                .layer
+                .downcast_raw(id)
+                .or_else(|| self.inner.downcast_raw(id)),
+        }
+    }
+}
+
+impl<'a, L, S> LookupSpan<'a> for Layered<L, S>
+where
+    S: Subscriber + LookupSpan<'a>,
+{
+    type Data = S::Data;
+
+    fn span_data(&'a self, id: &span::Id) -> Option<Self::Data> {
+        self.inner.span_data(id)
+    }
+
+    #[cfg(all(feature = "registry", feature = "std"))]
+    fn register_filter(&mut self) -> FilterId {
+        self.inner.register_filter()
+    }
+}
+
+impl<L, S> Layered<L, S>
+where
+    S: Subscriber,
+{
+    fn ctx(&self) -> Context<'_, S> {
+        Context::new(&self.inner)
+    }
+}
+
+impl<A, B, S> Layered<A, B, S>
+where
+    A: Layer<S>,
+    S: Subscriber,
+{
+    pub(super) fn new(layer: A, inner: B, inner_has_layer_filter: bool) -> Self {
+        #[cfg(all(feature = "registry", feature = "std"))]
+        let inner_is_registry = TypeId::of::<S>() == TypeId::of::<crate::registry::Registry>();
+
+        #[cfg(not(all(feature = "registry", feature = "std")))]
+        let inner_is_registry = false;
+
+        let inner_has_layer_filter = inner_has_layer_filter || inner_is_registry;
+        let has_layer_filter = filter::layer_has_plf(&layer);
+        Self {
+            layer,
+            inner,
+            has_layer_filter,
+            inner_has_layer_filter,
+            inner_is_registry,
+            _s: PhantomData,
+        }
+    }
+
+    fn pick_interest(&self, outer: Interest, inner: impl FnOnce() -> Interest) -> Interest {
+        if self.has_layer_filter {
+            return inner();
+        }
+
+        // If the outer layer has disabled the callsite, return now so that
+        // the inner layer/subscriber doesn't get its hopes up.
+        if outer.is_never() {
+            // If per-layer filters are in use, and we are short-circuiting
+            // (rather than calling into the inner type), clear the current
+            // per-layer filter interest state.
+            #[cfg(feature = "registry")]
+            drop(filter::FilterState::take_interest());
+
+            return outer;
+        }
+
+        // The `inner` closure will call `inner.register_callsite()`. We do this
+        // before the `if` statement to  ensure that the inner subscriber is
+        // informed that the callsite exists regardless of the outer layer's
+        // filtering decision.
+        let inner = inner();
+        if outer.is_sometimes() {
+            // if this interest is "sometimes", return "sometimes" to ensure that
+            // filters are reevaluated.
+            return outer;
+        }
+
+        // If there is a per-layer filter in the `inner` stack, and it returns
+        // `never`, change the interest to `sometimes`, because the `outer`
+        // layer didn't return `never`. This means that _some_ layer still wants
+        // to see that callsite, even though the inner stack's per-layer filter
+        // didn't want it. Therefore, returning `sometimes` will ensure
+        // `enabled` is called so that the per-layer filter can skip that
+        // span/event, while the `outer` layer still gets to see it.
+        if inner.is_never() && self.inner_has_layer_filter {
+            return Interest::sometimes();
+        }
+
+        // otherwise, allow the inner subscriber or collector to weigh in.
+        inner
+    }
+
+    fn pick_level_hint(
+        &self,
+        outer_hint: Option<LevelFilter>,
+        inner_hint: Option<LevelFilter>,
+    ) -> Option<LevelFilter> {
+        if self.inner_is_registry {
+            return outer_hint;
+        }
+
+        if self.has_layer_filter && self.inner_has_layer_filter {
+            return Some(cmp::max(outer_hint?, inner_hint?));
+        }
+
+        if self.has_layer_filter && inner_hint.is_none() {
+            return None;
+        }
+
+        if self.inner_has_layer_filter && outer_hint.is_none() {
+            return None;
+        }
+
+        cmp::max(outer_hint, inner_hint)
+    }
+}
+
+impl<A, B, S> fmt::Debug for Layered<A, B, S>
+where
+    A: fmt::Debug,
+    B: fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        #[cfg(all(feature = "registry", feature = "std"))]
+        let alt = f.alternate();
+        let mut s = f.debug_struct("Layered");
+        // These additional fields are more verbose and usually only necessary
+        // for internal debugging purposes, so only print them if alternate mode
+        // is enabled.
+
+        #[cfg(all(feature = "registry", feature = "std"))]
+        {
+            if alt {
+                s.field("inner_is_registry", &self.inner_is_registry)
+                    .field("has_layer_filter", &self.has_layer_filter)
+                    .field("inner_has_layer_filter", &self.inner_has_layer_filter);
+            }
+        }
+
+        s.field("layer", &self.layer)
+            .field("inner", &self.inner)
+            .finish()
+    }
+}
diff --git a/vendor/tracing-subscriber-0.3.3/src/layer/mod.rs b/vendor/tracing-subscriber-0.3.3/src/layer/mod.rs
new file mode 100644
index 000000000..f3f994490
--- /dev/null
+++ b/vendor/tracing-subscriber-0.3.3/src/layer/mod.rs
@@ -0,0 +1,1285 @@
+//! The [`Layer`] trait, a composable abstraction for building [`Subscriber`]s.
+//!
+//! The [`Subscriber`] trait in `tracing-core` represents the _complete_ set of
+//! functionality required to consume `tracing` instrumentation. This means that
+//! a single `Subscriber` instance is a self-contained implementation of a
+//! complete strategy for collecting traces; but it _also_ means that the
+//! `Subscriber` trait cannot easily be composed with other `Subscriber`s.
+//!
+//! In particular, [`Subscriber`]s are responsible for generating [span IDs] and
+//! assigning them to spans. Since these IDs must uniquely identify a span
+//! within the context of the current trace, this means that there may only be
+//! a single `Subscriber` for a given thread at any point in time &mdash;
+//! otherwise, there would be no authoritative source of span IDs.
+//!
+//! On the other hand, the majority of the [`Subscriber`] trait's functionality
+//! is composable: any number of subscribers may _observe_ events, span entry
+//! and exit, and so on, provided that there is a single authoritative source of
+//! span IDs. The [`Layer`] trait represents this composable subset of the
+//! [`Subscriber`] behavior; it can _observe_ events and spans, but does not
+//! assign IDs.
+//!
+//! ## Composing Layers
+//!
+//! Since a [`Layer`] does not implement a complete strategy for collecting
+//! traces, it must be composed with a `Subscriber` in order to be used. The
+//! [`Layer`] trait is generic over a type parameter (called `S` in the trait
+//! definition), representing the types of `Subscriber` they can be composed
+//! with. Thus, a [`Layer`] may be implemented that will only compose with a
+//! particular `Subscriber` implementation, or additional trait bounds may be
+//! added to constrain what types implementing `Subscriber` a `Layer` can wrap.
+//!
+//! `Layer`s may be added to a `Subscriber` by using the [`SubscriberExt::with`]
+//! method, which is provided by `tracing-subscriber`'s [prelude]. This method
+//! returns a [`Layered`] struct that implements `Subscriber` by composing the
+//! `Layer` with the `Subscriber`.
+//!
+//! For example:
+//! ```rust
+//! use tracing_subscriber::Layer;
+//! use tracing_subscriber::prelude::*;
+//! use tracing::Subscriber;
+//!
+//! pub struct MyLayer {
+//!     // ...
+//! }
+//!
+//! impl<S: Subscriber> Layer<S> for MyLayer {
+//!     // ...
+//! }
+//!
+//! pub struct MySubscriber {
+//!     // ...
+//! }
+//!
+//! # use tracing_core::{span::{Id, Attributes, Record}, Metadata, Event};
+//! impl Subscriber for MySubscriber {
+//!     // ...
+//! #   fn new_span(&self, _: &Attributes) -> Id { Id::from_u64(1) }
+//! #   fn record(&self, _: &Id, _: &Record) {}
+//! #   fn event(&self, _: &Event) {}
+//! #   fn record_follows_from(&self, _: &Id, _: &Id) {}
+//! #   fn enabled(&self, _: &Metadata) -> bool { false }
+//! #   fn enter(&self, _: &Id) {}
+//! #   fn exit(&self, _: &Id) {}
+//! }
+//! # impl MyLayer {
+//! # fn new() -> Self { Self {} }
+//! # }
+//! # impl MySubscriber {
+//! # fn new() -> Self { Self { }}
+//! # }
+//!
+//! let subscriber = MySubscriber::new()
+//!     .with(MyLayer::new());
+//!
+//! tracing::subscriber::set_global_default(subscriber);
+//! ```
+//!
+//! Multiple `Layer`s may be composed in the same manner:
+//! ```rust
+//! # use tracing_subscriber::{Layer, layer::SubscriberExt};
+//! # use tracing::Subscriber;
+//! pub struct MyOtherLayer {
+//!     // ...
+//! }
+//!
+//! impl<S: Subscriber> Layer<S> for MyOtherLayer {
+//!     // ...
+//! }
+//!
+//! pub struct MyThirdLayer {
+//!     // ...
+//! }
+//!
+//! impl<S: Subscriber> Layer<S> for MyThirdLayer {
+//!     // ...
+//! }
+//! # pub struct MyLayer {}
+//! # impl<S: Subscriber> Layer<S> for MyLayer {}
+//! # pub struct MySubscriber { }
+//! # use tracing_core::{span::{Id, Attributes, Record}, Metadata, Event};
+//! # impl Subscriber for MySubscriber {
+//! #   fn new_span(&self, _: &Attributes) -> Id { Id::from_u64(1) }
+//! #   fn record(&self, _: &Id, _: &Record) {}
+//! #   fn event(&self, _: &Event) {}
+//! #   fn record_follows_from(&self, _: &Id, _: &Id) {}
+//! #   fn enabled(&self, _: &Metadata) -> bool { false }
+//! #   fn enter(&self, _: &Id) {}
+//! #   fn exit(&self, _: &Id) {}
+//! }
+//! # impl MyLayer {
+//! # fn new() -> Self { Self {} }
+//! # }
+//! # impl MyOtherLayer {
+//! # fn new() -> Self { Self {} }
+//! # }
+//! # impl MyThirdLayer {
+//! # fn new() -> Self { Self {} }
+//! # }
+//! # impl MySubscriber {
+//! # fn new() -> Self { Self { }}
+//! # }
+//!
+//! let subscriber = MySubscriber::new()
+//!     .with(MyLayer::new())
+//!     .with(MyOtherLayer::new())
+//!     .with(MyThirdLayer::new());
+//!
+//! tracing::subscriber::set_global_default(subscriber);
+//! ```
+//!
+//! The [`Layer::with_subscriber`] constructs the [`Layered`] type from a
+//! [`Layer`] and [`Subscriber`], and is called by [`SubscriberExt::with`]. In
+//! general, it is more idiomatic to use [`SubscriberExt::with`], and treat
+//! [`Layer::with_subscriber`] as an implementation detail, as `with_subscriber`
+//! calls must be nested, leading to less clear code for the reader.
+//!
+//! [prelude]: crate::prelude
+//!
+//! ## Recording Traces
+//!
+//! The [`Layer`] trait defines a set of methods for consuming notifications from
+//! tracing instrumentation, which are generally equivalent to the similarly
+//! named methods on [`Subscriber`]. Unlike [`Subscriber`], the methods on
+//! `Layer` are additionally passed a [`Context`] type, which exposes additional
+//! information provided by the wrapped subscriber (such as [the current span])
+//! to the layer.
+//!
+//! ## Filtering with `Layer`s
+//!
+//! As well as strategies for handling trace events, the `Layer` trait may also
+//! be used to represent composable _filters_. This allows the determination of
+//! what spans and events should be recorded to be decoupled from _how_ they are
+//! recorded: a filtering layer can be applied to other layers or
+//! subscribers. `Layer`s can be used to implement _global filtering_, where a
+//! `Layer` provides a filtering strategy for the entire subscriber.
+//! Additionally, individual recording `Layer`s or sets of `Layer`s may be
+//! combined with _per-layer filters_ that control what spans and events are
+//! recorded by those layers.
+//!
+//! ### Global Filtering
+//!
+//! A `Layer` that implements a filtering strategy should override the
+//! [`register_callsite`] and/or [`enabled`] methods. It may also choose to implement
+//! methods such as [`on_enter`], if it wishes to filter trace events based on
+//! the current span context.
+//!
+//! Note that the [`Layer::register_callsite`] and [`Layer::enabled`] methods
+//! determine whether a span or event is enabled *globally*. Thus, they should
+//! **not** be used to indicate whether an individual layer wishes to record a
+//! particular span or event. Instead, if a layer is only interested in a subset
+//! of trace data, but does *not* wish to disable other spans and events for the
+//! rest of the layer stack should ignore those spans and events in its
+//! notification methods.
+//!
+//! The filtering methods on a stack of `Layer`s are evaluated in a top-down
+//! order, starting with the outermost `Layer` and ending with the wrapped
+//! [`Subscriber`]. If any layer returns `false` from its [`enabled`] method, or
+//! [`Interest::never()`] from its [`register_callsite`] method, filter
+//! evaluation will short-circuit and the span or event will be disabled.
+//!
+//! ### Per-Layer Filtering
+//!
+//! **Note**: per-layer filtering APIs currently require the [`"registry"` crate
+//! feature flag][feat] to be enabled.
+//!
+//! Sometimes, it may be desirable for one `Layer` to record a particular subset
+//! of spans and events, while a different subset of spans and events are
+//! recorded by other `Layer`s. For example:
+//!
+//! - A layer that records metrics may wish to observe only events including
+//!   particular tracked values, while a logging layer ignores those events.
+//! - If recording a distributed trace is expensive, it might be desirable to
+//!   only send spans with `INFO` and lower verbosity to the distributed tracing
+//!   system, while logging more verbose spans to a file.
+//! - Spans and events with a particular target might be recorded differently
+//!   from others, such as by generating an HTTP access log from a span that
+//!   tracks the lifetime of an HTTP request.
+//!
+//! The [`Filter`] trait is used to control what spans and events are
+//! observed by an individual `Layer`, while still allowing other `Layer`s to
+//! potentially record them. The [`Layer::with_filter`] method combines a
+//! `Layer` with a [`Filter`], returning a [`Filtered`] layer.
+//!
+//! This crate's [`filter`] module provides a number of types which implement
+//! the [`Filter`] trait, such as [`LevelFilter`], [`Targets`], and
+//! [`FilterFn`]. These [`Filter`]s provide ready-made implementations of
+//! common forms of filtering. For custom filtering policies, the [`FilterFn`]
+//! and [`DynFilterFn`] types allow implementing a [`Filter`] with a closure or
+//! function pointer. In addition, when more control is required, the [`Filter`]
+//! trait may also be implemented for user-defined types.
+//!
+//! <pre class="compile_fail" style="white-space:normal;font:inherit;">
+//!     <strong>Warning</strong>: Currently, the <a href="../struct.Registry.html">
+//!     <code>Registry</code></a> type defined in this crate is the only root
+//!     <code>Subscriber</code> capable of supporting <code>Layer</code>s with
+//!     per-layer filters. In the future, new APIs will be added to allow other
+//!     root <code>Subscriber</code>s to support per-layer filters.
+//! </pre>
+//!
+//! For example, to generate an HTTP access log based on spans with
+//! the `http_access` target, while logging other spans and events to
+//! standard out, a [`Filter`] can be added to the access log layer:
+//!
+//! ```
+//! use tracing_subscriber::{filter, prelude::*};
+//!
+//! // Generates an HTTP access log.
+//! let access_log = // ...
+//!     # filter::LevelFilter::INFO;
+//!
+//! // Add a filter to the access log layer so that it only observes
+//! // spans and events with the `http_access` target.
+//! let access_log = access_log.with_filter(filter::filter_fn(|metadata| {
+//!     // Returns `true` if and only if the span or event's target is
+//!     // "http_access".
+//!     metadata.target() == "http_access"
+//! }));
+//!
+//! // A general-purpose logging layer.
+//! let fmt_layer = tracing_subscriber::fmt::layer();
+//!
+//! // Build a subscriber that combines the access log and stdout log
+//! // layers.
+//! tracing_subscriber::registry()
+//!     .with(fmt_layer)
+//!     .with(access_log)
+//!     .init();
+//! ```
+//!
+//! Multiple layers can have their own, separate per-layer filters. A span or
+//! event will be recorded if it is enabled by _any_ per-layer filter, but it
+//! will be skipped by the layers whose filters did not enable it. Building on
+//! the previous example:
+//!
+//! ```
+//! use tracing_subscriber::{filter::{filter_fn, LevelFilter}, prelude::*};
+//!
+//! let access_log = // ...
+//!     # LevelFilter::INFO;
+//! let fmt_layer = tracing_subscriber::fmt::layer();
+//!
+//! tracing_subscriber::registry()
+//!     // Add the filter for the "http_access" target to the access
+//!     // log layer, like before.
+//!     .with(access_log.with_filter(filter_fn(|metadata| {
+//!         metadata.target() == "http_access"
+//!     })))
+//!     // Add a filter for spans and events with the INFO level
+//!     // and below to the logging layer.
+//!     .with(fmt_layer.with_filter(LevelFilter::INFO))
+//!     .init();
+//!
+//! // Neither layer will observe this event
+//! tracing::debug!(does_anyone_care = false, "a tree fell in the forest");
+//!
+//! // This event will be observed by the logging layer, but not
+//! // by the access log layer.
+//! tracing::warn!(dose_roentgen = %3.8, "not great, but not terrible");
+//!
+//! // This event will be observed only by the access log layer.
+//! tracing::trace!(target: "http_access", "HTTP request started");
+//!
+//! // Both layers will observe this event.
+//! tracing::error!(target: "http_access", "HTTP request failed with a very bad error!");
+//! ```
+//!
+//! A per-layer filter can be applied to multiple [`Layer`]s at a time, by
+//! combining them into a [`Layered`] layer using [`Layer::and_then`], and then
+//! calling [`Layer::with_filter`] on the resulting [`Layered`] layer.
+//!
+//! Consider the following:
+//! - `layer_a` and `layer_b`, which should only receive spans and events at
+//!    the [`INFO`] [level] and above.
+//! - A third layer, `layer_c`, which should receive spans and events at
+//!    the [`DEBUG`] [level] as well.
+//! The layers and filters would be composed thusly:
+//!
+//! ```
+//! use tracing_subscriber::{filter::LevelFilter, prelude::*};
+//!
+//! let layer_a = // ...
+//! # LevelFilter::INFO;
+//! let layer_b =  // ...
+//! # LevelFilter::INFO;
+//! let layer_c =  // ...
+//! # LevelFilter::INFO;
+//!
+//! let info_layers = layer_a
+//!     // Combine `layer_a` and `layer_b` into a `Layered` layer:
+//!     .and_then(layer_b)
+//!     // ...and then add an `INFO` `LevelFilter` to that layer:
+//!     .with_filter(LevelFilter::INFO);
+//!
+//! tracing_subscriber::registry()
+//!     // Add `layer_c` with a `DEBUG` filter.
+//!     .with(layer_c.with_filter(LevelFilter::DEBUG))
+//!     .with(info_layers)
+//!     .init();
+//!```
+//!
+//! If a [`Filtered`] [`Layer`] is combined with another [`Layer`]
+//! [`Layer::and_then`], and a filter is added to the [`Layered`] layer, that
+//! layer will be filtered by *both* the inner filter and the outer filter.
+//! Only spans and events that are enabled by *both* filters will be
+//! observed by that layer. This can be used to implement complex filtering
+//! trees.
+//!
+//! As an example, consider the following constraints:
+//! - Suppose that a particular [target] is used to indicate events that
+//!   should be counted as part of a metrics system, which should be only
+//!   observed by a layer that collects metrics.
+//! - A log of high-priority events ([`INFO`] and above) should be logged
+//!   to stdout, while more verbose events should be logged to a debugging log file.
+//! - Metrics-focused events should *not* be included in either log output.
+//!
+//! In that case, it is possible to apply a filter to both logging layers to
+//! exclude the metrics events, while additionally adding a [`LevelFilter`]
+//! to the stdout log:
+//!
+//! ```
+//! # // wrap this in a function so we don't actually create `debug.log` when
+//! # // running the doctests..
+//! # fn docs() -> Result<(), Box<dyn std::error::Error + 'static>> {
+//! use tracing_subscriber::{filter, prelude::*};
+//! use std::{fs::File, sync::Arc};
+//!
+//! // A layer that logs events to stdout using the human-readable "pretty"
+//! // format.
+//! let stdout_log = tracing_subscriber::fmt::layer()
+//!     .pretty();
+//!
+//! // A layer that logs events to a file.
+//! let file = File::create("debug.log")?;
+//! let debug_log = tracing_subscriber::fmt::layer()
+//!     .with_writer(Arc::new(file));
+//!
+//! // A layer that collects metrics using specific events.
+//! let metrics_layer = /* ... */ filter::LevelFilter::INFO;
+//!
+//! tracing_subscriber::registry()
+//!     .with(
+//!         stdout_log
+//!             // Add an `INFO` filter to the stdout logging layer
+//!             .with_filter(filter::LevelFilter::INFO)
+//!             // Combine the filtered `stdout_log` layer with the
+//!             // `debug_log` layer, producing a new `Layered` layer.
+//!             .and_then(debug_log)
+//!             // Add a filter to *both* layers that rejects spans and
+//!             // events whose targets start with `metrics`.
+//!             .with_filter(filter::filter_fn(|metadata| {
+//!                 !metadata.target().starts_with("metrics")
+//!             }))
+//!     )
+//!     .with(
+//!         // Add a filter to the metrics label that *only* enables
+//!         // events whose targets start with `metrics`.
+//!         metrics_layer.with_filter(filter::filter_fn(|metadata| {
+//!             metadata.target().starts_with("metrics")
+//!         }))
+//!     )
+//!     .init();
+//!
+//! // This event will *only* be recorded by the metrics layer.
+//! tracing::info!(target: "metrics::cool_stuff_count", value = 42);
+//!
+//! // This event will only be seen by the debug log file layer:
+//! tracing::debug!("this is a message, and part of a system of messages");
+//!
+//! // This event will be seen by both the stdout log layer *and*
+//! // the debug log file layer, but not by the metrics layer.
+//! tracing::warn!("the message is a warning about danger!");
+//! # Ok(()) }
+//! ```
+//!
+//! ## Runtime Configuration With Layers
+//!
+//! In some cases, a particular [`Layer`] may be enabled or disabled based on
+//! runtime configuration. This can introduce challenges, because the type of a
+//! layered [`Subscriber`] depends on which layers are added to it: if an `if`
+//! or `match` expression adds some [`Layer`]s in one branch and other layers
+//! in another, the [`Subscriber`] values returned by those branches will have
+//! different types. For example, the following _will not_ work:
+//!
+//! ```compile_fail
+//! # fn docs() -> Result<(), Box<dyn std::error::Error + 'static>> {
+//! # struct Config {
+//! #    is_prod: bool,
+//! #    path: &'static str,
+//! # }
+//! # let cfg = Config { is_prod: false, path: "debug.log" };
+//! use std::{fs::File, sync::Arc};
+//! use tracing_subscriber::{Registry, prelude::*};
+//!
+//! let stdout_log = tracing_subscriber::fmt::layer().pretty();
+//! let subscriber = Registry::default().with(stdout_log);
+//!
+//! // The compile error will occur here because the if and else
+//! // branches have different (and therefore incompatible) types.
+//! let subscriber = if cfg.is_prod {
+//!     let file = File::create(cfg.path)?;
+//!     let layer = tracing_subscriber::fmt::layer()
+//!         .json()
+//!         .with_writer(Arc::new(file));
+//!     subscriber.with(layer)
+//! } else {
+//!     subscriber
+//! };
+//!
+//! tracing::subscriber::set_global_default(subscriber)
+//!     .expect("Unable to set global subscriber");
+//! # Ok(()) }
+//! ```
+//!
+//! However, a [`Layer`] wrapped in an [`Option`] [also implements the `Layer`
+//! trait][option-impl]. This allows individual layers to be enabled or disabled at
+//! runtime while always producing a [`Subscriber`] of the same type. For
+//! example:
+//!
+//! ```
+//! # fn docs() -> Result<(), Box<dyn std::error::Error + 'static>> {
+//! # struct Config {
+//! #    is_prod: bool,
+//! #    path: &'static str,
+//! # }
+//! # let cfg = Config { is_prod: false, path: "debug.log" };
+//! use std::{fs::File, sync::Arc};
+//! use tracing_subscriber::{Registry, prelude::*};
+//!
+//! let stdout_log = tracing_subscriber::fmt::layer().pretty();
+//! let subscriber = Registry::default().with(stdout_log);
+//!
+//! // if `cfg.is_prod` is true, also log JSON-formatted logs to a file.
+//! let json_log = if cfg.is_prod {
+//!     let file = File::create(cfg.path)?;
+//!     let json_log = tracing_subscriber::fmt::layer()
+//!         .json()
+//!         .with_writer(Arc::new(file));
+//!     Some(json_log)
+//! } else {   
+//!     None
+//! };
+//!
+//! // If `cfg.is_prod` is false, then `json` will be `None`, and this layer
+//! // will do nothing. However, the subscriber will still have the same type
+//! // regardless of whether the `Option`'s value is `None` or `Some`.
+//! let subscriber = subscriber.with(json_log);
+//!
+//! tracing::subscriber::set_global_default(subscriber)
+//!    .expect("Unable to set global subscriber");
+//! # Ok(()) }
+//! ```
+//!
+//! [`Subscriber`]: https://docs.rs/tracing-core/latest/tracing_core/subscriber/trait.Subscriber.html
+//! [span IDs]: https://docs.rs/tracing-core/latest/tracing_core/span/struct.Id.html
+//! [the current span]: Context::current_span
+//! [`register_callsite`]: Layer::register_callsite
+//! [`enabled`]: Layer::enabled
+//! [`on_enter`]: Layer::on_enter
+//! [`Layer::register_callsite`]: Layer::register_callsite
+//! [`Layer::enabled`]: Layer::enabled
+//! [`Interest::never()`]: https://docs.rs/tracing-core/latest/tracing_core/subscriber/struct.Interest.html#method.never
+//! [option-impl]: crate::layer::Layer#impl-Layer<S>-for-Option<L>
+//! [`Filtered`]: crate::filter::Filtered
+//! [`filter`]: crate::filter
+//! [`Targets`]: crate::filter::Targets
+//! [`FilterFn`]: crate::filter::FilterFn
+//! [`DynFilterFn`]: crate::filter::DynFilterFn
+//! [level]: tracing_core::Level
+//! [`INFO`]: tracing_core::Level::INFO
+//! [`DEBUG`]: tracing_core::Level::DEBUG
+//! [target]: tracing_core::Metadata::target
+//! [`LevelFilter`]: crate::filter::LevelFilter
+//! [feat]: crate#feature-flags
+use crate::filter;
+
+use tracing_core::{
+    metadata::Metadata,
+    span,
+    subscriber::{Interest, Subscriber},
+    Event, LevelFilter,
+};
+
+use core::any::TypeId;
+
+feature! {
+    #![feature = "alloc"]
+    use alloc::boxed::Box;
+    use core::ops::{Deref, DerefMut};
+}
+
+mod context;
+mod layered;
+pub use self::{context::*, layered::*};
+
+// The `tests` module is `pub(crate)` because it contains test utilities used by
+// other modules.
+#[cfg(test)]
+pub(crate) mod tests;
+
+/// A composable handler for `tracing` events.
+///
+/// A `Layer` implements a behavior for recording or collecting traces that can
+/// be composed together with other `Layer`s to build a [`Subscriber`]. See the
+/// [module-level documentation](crate::layer) for details.
+///
+/// [`Subscriber`]: tracing_core::Subscriber
+#[cfg_attr(docsrs, doc(notable_trait))]
+pub trait Layer<S>
+where
+    S: Subscriber,
+    Self: 'static,
+{
+    /// Performs late initialization when attaching a `Layer` to a
+    /// [`Subscriber`].
+    ///
+    /// This is a callback that is called when the `Layer` is added to a
+    /// [`Subscriber`] (e.g. in [`Layer::with_subscriber`] and
+    /// [`SubscriberExt::with`]). Since this can only occur before the
+    /// [`Subscriber`] has been set as the default, both the `Layer` and
+    /// [`Subscriber`] are passed to this method _mutably_. This gives the
+    /// `Layer` the opportunity to set any of its own fields with values
+    /// recieved by method calls on the [`Subscriber`].
+    ///
+    /// For example, [`Filtered`] layers implement `on_layer` to call the
+    /// [`Subscriber`]'s [`register_filter`] method, and store the returned
+    /// [`FilterId`] as a field.
+    ///
+    /// **Note** In most cases, `Layer` implementations will not need to
+    /// implement this method. However, in cases where a type implementing
+    /// `Layer` wraps one or more other types that implement `Layer`, like the
+    /// [`Layered`] and [`Filtered`] types in this crate, that type MUST ensure
+    /// that the inner `Layer`s' `on_layer` methods are called. Otherwise,
+    /// functionality that relies on `on_layer`, such as [per-layer filtering],
+    /// may not work correctly.
+    ///
+    /// [`Filtered`]: crate::filter::Filtered
+    /// [`register_filter`]: crate::registry::LookupSpan::register_filter
+    /// [per-layer filtering]: #per-layer-filtering
+    /// [`FilterId`]: crate::filter::FilterId
+    fn on_layer(&mut self, subscriber: &mut S) {
+        let _ = subscriber;
+    }
+
+    /// Registers a new callsite with this layer, returning whether or not
+    /// the layer is interested in being notified about the callsite, similarly
+    /// to [`Subscriber::register_callsite`].
+    ///
+    /// By default, this returns [`Interest::always()`] if [`self.enabled`] returns
+    /// true, or [`Interest::never()`] if it returns false.
+    ///
+    /// <pre class="ignore" style="white-space:normal;font:inherit;">
+    /// <strong>Note</strong>: This method (and <a href="#method.enabled">
+    /// <code>Layer::enabled</code></a>) determine whether a span or event is
+    /// globally enabled, <em>not</em> whether the individual layer will be
+    /// notified about that span or event. This is intended to be used
+    /// by layers that implement filtering for the entire stack. Layers which do
+    /// not wish to be notified about certain spans or events but do not wish to
+    /// globally disable them should ignore those spans or events in their
+    /// <a href="#method.on_event"><code>on_event</code></a>,
+    /// <a href="#method.on_enter"><code>on_enter</code></a>,
+    /// <a href="#method.on_exit"><code>on_exit</code></a>, and other notification
+    /// methods.
+    /// </pre>
+    ///
+    /// See [the trait-level documentation] for more information on filtering
+    /// with `Layer`s.
+    ///
+    /// Layers may also implement this method to perform any behaviour that
+    /// should be run once per callsite. If the layer wishes to use
+    /// `register_callsite` for per-callsite behaviour, but does not want to
+    /// globally enable or disable those callsites, it should always return
+    /// [`Interest::always()`].
+    ///
+    /// [`Interest`]: https://docs.rs/tracing-core/latest/tracing_core/struct.Interest.html
+    /// [`Subscriber::register_callsite`]: https://docs.rs/tracing-core/latest/tracing_core/trait.Subscriber.html#method.register_callsite
+    /// [`Interest::never()`]: https://docs.rs/tracing-core/latest/tracing_core/subscriber/struct.Interest.html#method.never
+    /// [`Interest::always()`]: https://docs.rs/tracing-core/latest/tracing_core/subscriber/struct.Interest.html#method.always
+    /// [`self.enabled`]: #method.enabled
+    /// [`Layer::enabled`]: #method.enabled
+    /// [`on_event`]: #method.on_event
+    /// [`on_enter`]: #method.on_enter
+    /// [`on_exit`]: #method.on_exit
+    /// [the trait-level documentation]: #filtering-with-layers
+    fn register_callsite(&self, metadata: &'static Metadata<'static>) -> Interest {
+        if self.enabled(metadata, Context::none()) {
+            Interest::always()
+        } else {
+            Interest::never()
+        }
+    }
+
+    /// Returns `true` if this layer is interested in a span or event with the
+    /// given `metadata` in the current [`Context`], similarly to
+    /// [`Subscriber::enabled`].
+    ///
+    /// By default, this always returns `true`, allowing the wrapped subscriber
+    /// to choose to disable the span.
+    ///
+    /// <pre class="ignore" style="white-space:normal;font:inherit;">
+    /// <strong>Note</strong>: This method (and <a href="#method.register_callsite">
+    /// <code>Layer::register_callsite</code></a>) determine whether a span or event is
+    /// globally enabled, <em>not</em> whether the individual layer will be
+    /// notified about that span or event. This is intended to be used
+    /// by layers that implement filtering for the entire stack. Layers which do
+    /// not wish to be notified about certain spans or events but do not wish to
+    /// globally disable them should ignore those spans or events in their
+    /// <a href="#method.on_event"><code>on_event</code></a>,
+    /// <a href="#method.on_enter"><code>on_enter</code></a>,
+    /// <a href="#method.on_exit"><code>on_exit</code></a>, and other notification
+    /// methods.
+    /// </pre>
+    ///
+    ///
+    /// See [the trait-level documentation] for more information on filtering
+    /// with `Layer`s.
+    ///
+    /// [`Interest`]: https://docs.rs/tracing-core/latest/tracing_core/struct.Interest.html
+    /// [`Context`]: ../struct.Context.html
+    /// [`Subscriber::enabled`]: https://docs.rs/tracing-core/latest/tracing_core/trait.Subscriber.html#method.enabled
+    /// [`Layer::register_callsite`]: #method.register_callsite
+    /// [`on_event`]: #method.on_event
+    /// [`on_enter`]: #method.on_enter
+    /// [`on_exit`]: #method.on_exit
+    /// [the trait-level documentation]: #filtering-with-layers
+    fn enabled(&self, metadata: &Metadata<'_>, ctx: Context<'_, S>) -> bool {
+        let _ = (metadata, ctx);
+        true
+    }
+
+    /// Notifies this layer that a new span was constructed with the given
+    /// `Attributes` and `Id`.
+    fn on_new_span(&self, attrs: &span::Attributes<'_>, id: &span::Id, ctx: Context<'_, S>) {
+        let _ = (attrs, id, ctx);
+    }
+
+    // TODO(eliza): do we want this to be a public API? If we end up moving
+    // filtering layers to a separate trait, we may no longer want `Layer`s to
+    // be able to participate in max level hinting...
+    #[doc(hidden)]
+    fn max_level_hint(&self) -> Option<LevelFilter> {
+        None
+    }
+
+    /// Notifies this layer that a span with the given `Id` recorded the given
+    /// `values`.
+    // Note: it's unclear to me why we'd need the current span in `record` (the
+    // only thing the `Context` type currently provides), but passing it in anyway
+    // seems like a good future-proofing measure as it may grow other methods later...
+    fn on_record(&self, _span: &span::Id, _values: &span::Record<'_>, _ctx: Context<'_, S>) {}
+
+    /// Notifies this layer that a span with the ID `span` recorded that it
+    /// follows from the span with the ID `follows`.
+    // Note: it's unclear to me why we'd need the current span in `record` (the
+    // only thing the `Context` type currently provides), but passing it in anyway
+    // seems like a good future-proofing measure as it may grow other methods later...
+    fn on_follows_from(&self, _span: &span::Id, _follows: &span::Id, _ctx: Context<'_, S>) {}
+
+    /// Notifies this layer that an event has occurred.
+    fn on_event(&self, _event: &Event<'_>, _ctx: Context<'_, S>) {}
+
+    /// Notifies this layer that a span with the given ID was entered.
+    fn on_enter(&self, _id: &span::Id, _ctx: Context<'_, S>) {}
+
+    /// Notifies this layer that the span with the given ID was exited.
+    fn on_exit(&self, _id: &span::Id, _ctx: Context<'_, S>) {}
+
+    /// Notifies this layer that the span with the given ID has been closed.
+    fn on_close(&self, _id: span::Id, _ctx: Context<'_, S>) {}
+
+    /// Notifies this layer that a span ID has been cloned, and that the
+    /// subscriber returned a different ID.
+    fn on_id_change(&self, _old: &span::Id, _new: &span::Id, _ctx: Context<'_, S>) {}
+
+    /// Composes this layer around the given `Layer`, returning a `Layered`
+    /// struct implementing `Layer`.
+    ///
+    /// The returned `Layer` will call the methods on this `Layer` and then
+    /// those of the new `Layer`, before calling the methods on the subscriber
+    /// it wraps. For example:
+    ///
+    /// ```rust
+    /// # use tracing_subscriber::layer::Layer;
+    /// # use tracing_core::Subscriber;
+    /// pub struct FooLayer {
+    ///     // ...
+    /// }
+    ///
+    /// pub struct BarLayer {
+    ///     // ...
+    /// }
+    ///
+    /// pub struct MySubscriber {
+    ///     // ...
+    /// }
+    ///
+    /// impl<S: Subscriber> Layer<S> for FooLayer {
+    ///     // ...
+    /// }
+    ///
+    /// impl<S: Subscriber> Layer<S> for BarLayer {
+    ///     // ...
+    /// }
+    ///
+    /// # impl FooLayer {
+    /// # fn new() -> Self { Self {} }
+    /// # }
+    /// # impl BarLayer {
+    /// # fn new() -> Self { Self { }}
+    /// # }
+    /// # impl MySubscriber {
+    /// # fn new() -> Self { Self { }}
+    /// # }
+    /// # use tracing_core::{span::{Id, Attributes, Record}, Metadata, Event};
+    /// # impl tracing_core::Subscriber for MySubscriber {
+    /// #   fn new_span(&self, _: &Attributes) -> Id { Id::from_u64(1) }
+    /// #   fn record(&self, _: &Id, _: &Record) {}
+    /// #   fn event(&self, _: &Event) {}
+    /// #   fn record_follows_from(&self, _: &Id, _: &Id) {}
+    /// #   fn enabled(&self, _: &Metadata) -> bool { false }
+    /// #   fn enter(&self, _: &Id) {}
+    /// #   fn exit(&self, _: &Id) {}
+    /// # }
+    /// let subscriber = FooLayer::new()
+    ///     .and_then(BarLayer::new())
+    ///     .with_subscriber(MySubscriber::new());
+    /// ```
+    ///
+    /// Multiple layers may be composed in this manner:
+    ///
+    /// ```rust
+    /// # use tracing_subscriber::layer::Layer;
+    /// # use tracing_core::Subscriber;
+    /// # pub struct FooLayer {}
+    /// # pub struct BarLayer {}
+    /// # pub struct MySubscriber {}
+    /// # impl<S: Subscriber> Layer<S> for FooLayer {}
+    /// # impl<S: Subscriber> Layer<S> for BarLayer {}
+    /// # impl FooLayer {
+    /// # fn new() -> Self { Self {} }
+    /// # }
+    /// # impl BarLayer {
+    /// # fn new() -> Self { Self { }}
+    /// # }
+    /// # impl MySubscriber {
+    /// # fn new() -> Self { Self { }}
+    /// # }
+    /// # use tracing_core::{span::{Id, Attributes, Record}, Metadata, Event};
+    /// # impl tracing_core::Subscriber for MySubscriber {
+    /// #   fn new_span(&self, _: &Attributes) -> Id { Id::from_u64(1) }
+    /// #   fn record(&self, _: &Id, _: &Record) {}
+    /// #   fn event(&self, _: &Event) {}
+    /// #   fn record_follows_from(&self, _: &Id, _: &Id) {}
+    /// #   fn enabled(&self, _: &Metadata) -> bool { false }
+    /// #   fn enter(&self, _: &Id) {}
+    /// #   fn exit(&self, _: &Id) {}
+    /// # }
+    /// pub struct BazLayer {
+    ///     // ...
+    /// }
+    ///
+    /// impl<S: Subscriber> Layer<S> for BazLayer {
+    ///     // ...
+    /// }
+    /// # impl BazLayer { fn new() -> Self { BazLayer {} } }
+    ///
+    /// let subscriber = FooLayer::new()
+    ///     .and_then(BarLayer::new())
+    ///     .and_then(BazLayer::new())
+    ///     .with_subscriber(MySubscriber::new());
+    /// ```
+    fn and_then<L>(self, layer: L) -> Layered<L, Self, S>
+    where
+        L: Layer<S>,
+        Self: Sized,
+    {
+        let inner_has_layer_filter = filter::layer_has_plf(&self);
+        Layered::new(layer, self, inner_has_layer_filter)
+    }
+
+    /// Composes this `Layer` with the given [`Subscriber`], returning a
+    /// `Layered` struct that implements [`Subscriber`].
+    ///
+    /// The returned `Layered` subscriber will call the methods on this `Layer`
+    /// and then those of the wrapped subscriber.
+    ///
+    /// For example:
+    /// ```rust
+    /// # use tracing_subscriber::layer::Layer;
+    /// # use tracing_core::Subscriber;
+    /// pub struct FooLayer {
+    ///     // ...
+    /// }
+    ///
+    /// pub struct MySubscriber {
+    ///     // ...
+    /// }
+    ///
+    /// impl<S: Subscriber> Layer<S> for FooLayer {
+    ///     // ...
+    /// }
+    ///
+    /// # impl FooLayer {
+    /// # fn new() -> Self { Self {} }
+    /// # }
+    /// # impl MySubscriber {
+    /// # fn new() -> Self { Self { }}
+    /// # }
+    /// # use tracing_core::{span::{Id, Attributes, Record}, Metadata};
+    /// # impl tracing_core::Subscriber for MySubscriber {
+    /// #   fn new_span(&self, _: &Attributes) -> Id { Id::from_u64(0) }
+    /// #   fn record(&self, _: &Id, _: &Record) {}
+    /// #   fn event(&self, _: &tracing_core::Event) {}
+    /// #   fn record_follows_from(&self, _: &Id, _: &Id) {}
+    /// #   fn enabled(&self, _: &Metadata) -> bool { false }
+    /// #   fn enter(&self, _: &Id) {}
+    /// #   fn exit(&self, _: &Id) {}
+    /// # }
+    /// let subscriber = FooLayer::new()
+    ///     .with_subscriber(MySubscriber::new());
+    ///```
+    ///
+    /// [`Subscriber`]: https://docs.rs/tracing-core/latest/tracing_core/trait.Subscriber.html
+    fn with_subscriber(mut self, mut inner: S) -> Layered<Self, S>
+    where
+        Self: Sized,
+    {
+        let inner_has_layer_filter = filter::subscriber_has_plf(&inner);
+        self.on_layer(&mut inner);
+        Layered::new(self, inner, inner_has_layer_filter)
+    }
+
+    /// Combines `self` with a [`Filter`], returning a [`Filtered`] layer.
+    ///
+    /// The [`Filter`] will control which spans and events are enabled for
+    /// this layer. See [the trait-level documentation][plf] for details on
+    /// per-layer filtering.
+    ///
+    /// [`Filtered`]: crate::filter::Filtered
+    /// [plf]: #per-layer-filtering
+    #[cfg(all(feature = "registry", feature = "std"))]
+    #[cfg_attr(docsrs, doc(cfg(all(feature = "registry", feature = "std"))))]
+    fn with_filter<F>(self, filter: F) -> filter::Filtered<Self, F, S>
+    where
+        Self: Sized,
+        F: Filter<S>,
+    {
+        filter::Filtered::new(self, filter)
+    }
+
+    #[doc(hidden)]
+    unsafe fn downcast_raw(&self, id: TypeId) -> Option<*const ()> {
+        if id == TypeId::of::<Self>() {
+            Some(self as *const _ as *const ())
+        } else {
+            None
+        }
+    }
+}
+
+feature! {
+    #![all(feature = "registry", feature = "std")]
+    /// A per-[`Layer`] filter that determines whether a span or event is enabled
+    /// for an individual layer.
+    ///
+    /// See [the module-level documentation][plf] for details on using [`Filter`]s.
+    ///
+    /// [plf]: crate::layer#per-layer-filtering
+    #[cfg_attr(docsrs, doc(notable_trait))]
+    pub trait Filter<S> {
+        /// Returns `true` if this layer is interested in a span or event with the
+        /// given [`Metadata`] in the current [`Context`], similarly to
+        /// [`Subscriber::enabled`].
+        ///
+        /// If this returns `false`, the span or event will be disabled _for the
+        /// wrapped [`Layer`]_. Unlike [`Layer::enabled`], the span or event will
+        /// still be recorded if any _other_ layers choose to enable it. However,
+        /// the layer [filtered] by this filter will skip recording that span or
+        /// event.
+        ///
+        /// If all layers indicate that they do not wish to see this span or event,
+        /// it will be disabled.
+        ///
+        /// [`metadata`]: tracing_core::Metadata
+        /// [`Subscriber::enabled`]: tracing_core::Subscriber::enabled
+        /// [filtered]: crate::filter::Filtered
+        fn enabled(&self, meta: &Metadata<'_>, cx: &Context<'_, S>) -> bool;
+
+        /// Returns an [`Interest`] indicating whether this layer will [always],
+        /// [sometimes], or [never] be interested in the given [`Metadata`].
+        ///
+        /// When a given callsite will [always] or [never] be enabled, the results
+        /// of evaluating the filter may be cached for improved performance.
+        /// Therefore, if a filter is capable of determining that it will always or
+        /// never enable a particular callsite, providing an implementation of this
+        /// function is recommended.
+        ///
+        /// <pre class="ignore" style="white-space:normal;font:inherit;">
+        /// <strong>Note</strong>: If a <code>Filter</code> will perform
+        /// <em>dynamic filtering</em> that depends on the current context in which
+        /// a span or event was observered (e.g. only enabling an event when it
+        /// occurs within a particular span), it <strong>must</strong> return
+        /// <code>Interest::sometimes()</code> from this method. If it returns
+        /// <code>Interest::always()</code> or <code>Interest::never()</code>, the
+        /// <code>enabled</code> method may not be called when a particular instance
+        /// of that span or event is recorded.
+        /// </pre>
+        ///
+        /// This method is broadly similar to [`Subscriber::register_callsite`];
+        /// however, since the returned value represents only the interest of
+        /// *this* layer, the resulting behavior is somewhat different.
+        ///
+        /// If a [`Subscriber`] returns [`Interest::always()`][always] or
+        /// [`Interest::never()`][never] for a given [`Metadata`], its [`enabled`]
+        /// method is then *guaranteed* to never be called for that callsite. On the
+        /// other hand, when a `Filter` returns [`Interest::always()`][always] or
+        /// [`Interest::never()`][never] for a callsite, _other_ [`Layer`]s may have
+        /// differing interests in that callsite. If this is the case, the callsite
+        /// will recieve [`Interest::sometimes()`][sometimes], and the [`enabled`]
+        /// method will still be called for that callsite when it records a span or
+        /// event.
+        ///
+        /// Returning [`Interest::always()`][always] or [`Interest::never()`][never] from
+        /// `Filter::callsite_enabled` will permanently enable or disable a
+        /// callsite (without requiring subsequent calls to [`enabled`]) if and only
+        /// if the following is true:
+        ///
+        /// - all [`Layer`]s that comprise the subscriber include `Filter`s
+        ///   (this includes a tree of [`Layered`] layers that share the same
+        ///   `Filter`)
+        /// - all those `Filter`s return the same [`Interest`].
+        ///
+        /// For example, if a [`Subscriber`] consists of two [`Filtered`] layers,
+        /// and both of those layers return [`Interest::never()`][never], that
+        /// callsite *will* never be enabled, and the [`enabled`] methods of those
+        /// [`Filter`]s will not be called.
+        ///
+        /// ## Default Implementation
+        ///
+        /// The default implementation of this method assumes that the
+        /// `Filter`'s [`enabled`] method _may_ perform dynamic filtering, and
+        /// returns [`Interest::sometimes()`][sometimes], to ensure that [`enabled`]
+        /// is called to determine whether a particular _instance_ of the callsite
+        /// is enabled in the current context. If this is *not* the case, and the
+        /// `Filter`'s [`enabled`] method will always return the same result
+        /// for a particular [`Metadata`], this method can be overridden as
+        /// follows:
+        ///
+        /// ```
+        /// use tracing_subscriber::layer;
+        /// use tracing_core::{Metadata, subscriber::Interest};
+        ///
+        /// struct MyFilter {
+        ///     // ...
+        /// }
+        ///
+        /// impl MyFilter {
+        ///     // The actual logic for determining whether a `Metadata` is enabled
+        ///     // must be factored out from the `enabled` method, so that it can be
+        ///     // called without a `Context` (which is not provided to the
+        ///     // `callsite_enabled` method).
+        ///     fn is_enabled(&self, metadata: &Metadata<'_>) -> bool {
+        ///         // ...
+        ///         # drop(metadata); true
+        ///     }
+        /// }
+        ///
+        /// impl<S> layer::Filter<S> for MyFilter {
+        ///     fn enabled(&self, metadata: &Metadata<'_>, _: &layer::Context<'_, S>) -> bool {
+        ///         // Even though we are implementing `callsite_enabled`, we must still provide a
+        ///         // working implementation of `enabled`, as returning `Interest::always()` or
+        ///         // `Interest::never()` will *allow* caching, but will not *guarantee* it.
+        ///         // Other filters may still return `Interest::sometimes()`, so we may be
+        ///         // asked again in `enabled`.
+        ///         self.is_enabled(metadata)
+        ///     }
+        ///
+        ///     fn callsite_enabled(&self, metadata: &'static Metadata<'static>) -> Interest {
+        ///         // The result of `self.enabled(metadata, ...)` will always be
+        ///         // the same for any given `Metadata`, so we can convert it into
+        ///         // an `Interest`:
+        ///         if self.is_enabled(metadata) {
+        ///             Interest::always()
+        ///         } else {
+        ///             Interest::never()
+        ///         }
+        ///     }
+        /// }
+        /// ```
+        ///
+        /// [`Metadata`]: tracing_core::Metadata
+        /// [`Interest`]: tracing_core::Interest
+        /// [always]: tracing_core::Interest::always
+        /// [sometimes]: tracing_core::Interest::sometimes
+        /// [never]: tracing_core::Interest::never
+        /// [`Subscriber::register_callsite`]: tracing_core::Subscriber::register_callsite
+        /// [`Subscriber`]: tracing_core::Subscriber
+        /// [`enabled`]: Filter::enabled
+        /// [`Filtered`]: crate::filter::Filtered
+        fn callsite_enabled(&self, meta: &'static Metadata<'static>) -> Interest {
+            let _ = meta;
+            Interest::sometimes()
+        }
+
+        /// Returns an optional hint of the highest [verbosity level][level] that
+        /// this `Filter` will enable.
+        ///
+        /// If this method returns a [`LevelFilter`], it will be used as a hint to
+        /// determine the most verbose level that will be enabled. This will allow
+        /// spans and events which are more verbose than that level to be skipped
+        /// more efficiently. An implementation of this method is optional, but
+        /// strongly encouraged.
+        ///
+        /// If the maximum level the `Filter` will enable can change over the
+        /// course of its lifetime, it is free to return a different value from
+        /// multiple invocations of this method. However, note that changes in the
+        /// maximum level will **only** be reflected after the callsite [`Interest`]
+        /// cache is rebuilt, by calling the
+        /// [`tracing_core::callsite::rebuild_interest_cache`][rebuild] function.
+        /// Therefore, if the `Filter will change the value returned by this
+        /// method, it is responsible for ensuring that
+        /// [`rebuild_interest_cache`][rebuild] is called after the value of the max
+        /// level changes.
+        ///
+        /// ## Default Implementation
+        ///
+        /// By default, this method returns `None`, indicating that the maximum
+        /// level is unknown.
+        ///
+        /// [level]: tracing_core::metadata::Level
+        /// [`LevelFilter`]: crate::filter::LevelFilter
+        /// [`Interest`]: tracing_core::subscriber::Interest
+        /// [rebuild]: tracing_core::callsite::rebuild_interest_cache
+        fn max_level_hint(&self) -> Option<LevelFilter> {
+            None
+        }
+    }
+}
+
+/// Extension trait adding a `with(Layer)` combinator to `Subscriber`s.
+pub trait SubscriberExt: Subscriber + crate::sealed::Sealed {
+    /// Wraps `self` with the provided `layer`.
+    fn with<L>(self, layer: L) -> Layered<L, Self>
+    where
+        L: Layer<Self>,
+        Self: Sized,
+    {
+        layer.with_subscriber(self)
+    }
+}
+
+/// A layer that does nothing.
+#[derive(Clone, Debug, Default)]
+pub struct Identity {
+    _p: (),
+}
+
+// === impl Layer ===
+
+impl<L, S> Layer<S> for Option<L>
+where
+    L: Layer<S>,
+    S: Subscriber,
+{
+    fn on_layer(&mut self, subscriber: &mut S) {
+        if let Some(ref mut layer) = self {
+            layer.on_layer(subscriber)
+        }
+    }
+
+    #[inline]
+    fn on_new_span(&self, attrs: &span::Attributes<'_>, id: &span::Id, ctx: Context<'_, S>) {
+        if let Some(ref inner) = self {
+            inner.on_new_span(attrs, id, ctx)
+        }
+    }
+
+    #[inline]
+    fn register_callsite(&self, metadata: &'static Metadata<'static>) -> Interest {
+        match self {
+            Some(ref inner) => inner.register_callsite(metadata),
+            None => Interest::always(),
+        }
+    }
+
+    #[inline]
+    fn enabled(&self, metadata: &Metadata<'_>, ctx: Context<'_, S>) -> bool {
+        match self {
+            Some(ref inner) => inner.enabled(metadata, ctx),
+            None => true,
+        }
+    }
+
+    #[inline]
+    fn max_level_hint(&self) -> Option<LevelFilter> {
+        match self {
+            Some(ref inner) => inner.max_level_hint(),
+            None => None,
+        }
+    }
+
+    #[inline]
+    fn on_record(&self, span: &span::Id, values: &span::Record<'_>, ctx: Context<'_, S>) {
+        if let Some(ref inner) = self {
+            inner.on_record(span, values, ctx);
+        }
+    }
+
+    #[inline]
+    fn on_follows_from(&self, span: &span::Id, follows: &span::Id, ctx: Context<'_, S>) {
+        if let Some(ref inner) = self {
+            inner.on_follows_from(span, follows, ctx);
+        }
+    }
+
+    #[inline]
+    fn on_event(&self, event: &Event<'_>, ctx: Context<'_, S>) {
+        if let Some(ref inner) = self {
+            inner.on_event(event, ctx);
+        }
+    }
+
+    #[inline]
+    fn on_enter(&self, id: &span::Id, ctx: Context<'_, S>) {
+        if let Some(ref inner) = self {
+            inner.on_enter(id, ctx);
+        }
+    }
+
+    #[inline]
+    fn on_exit(&self, id: &span::Id, ctx: Context<'_, S>) {
+        if let Some(ref inner) = self {
+            inner.on_exit(id, ctx);
+        }
+    }
+
+    #[inline]
+    fn on_close(&self, id: span::Id, ctx: Context<'_, S>) {
+        if let Some(ref inner) = self {
+            inner.on_close(id, ctx);
+        }
+    }
+
+    #[inline]
+    fn on_id_change(&self, old: &span::Id, new: &span::Id, ctx: Context<'_, S>) {
+        if let Some(ref inner) = self {
+            inner.on_id_change(old, new, ctx)
+        }
+    }
+
+    #[doc(hidden)]
+    #[inline]
+    unsafe fn downcast_raw(&self, id: TypeId) -> Option<*const ()> {
+        if id == TypeId::of::<Self>() {
+            Some(self as *const _ as *const ())
+        } else {
+            self.as_ref().and_then(|inner| inner.downcast_raw(id))
+        }
+    }
+}
+
+feature! {
+    #![any(feature = "std", feature = "alloc")]
+
+    macro_rules! layer_impl_body {
+        () => {
+            #[inline]
+            fn on_layer(&mut self, subscriber: &mut S) {
+                self.deref_mut().on_layer(subscriber);
+            }
+
+            #[inline]
+            fn on_new_span(&self, attrs: &span::Attributes<'_>, id: &span::Id, ctx: Context<'_, S>) {
+                self.deref().on_new_span(attrs, id, ctx)
+            }
+
+            #[inline]
+            fn register_callsite(&self, metadata: &'static Metadata<'static>) -> Interest {
+                self.deref().register_callsite(metadata)
+            }
+
+            #[inline]
+            fn enabled(&self, metadata: &Metadata<'_>, ctx: Context<'_, S>) -> bool {
+                self.deref().enabled(metadata, ctx)
+            }
+
+            #[inline]
+            fn max_level_hint(&self) -> Option<LevelFilter> {
+                self.deref().max_level_hint()
+            }
+
+            #[inline]
+            fn on_record(&self, span: &span::Id, values: &span::Record<'_>, ctx: Context<'_, S>) {
+                self.deref().on_record(span, values, ctx)
+            }
+
+            #[inline]
+            fn on_follows_from(&self, span: &span::Id, follows: &span::Id, ctx: Context<'_, S>) {
+                self.deref().on_follows_from(span, follows, ctx)
+            }
+
+            #[inline]
+            fn on_event(&self, event: &Event<'_>, ctx: Context<'_, S>) {
+                self.deref().on_event(event, ctx)
+            }
+
+            #[inline]
+            fn on_enter(&self, id: &span::Id, ctx: Context<'_, S>) {
+                self.deref().on_enter(id, ctx)
+            }
+
+            #[inline]
+            fn on_exit(&self, id: &span::Id, ctx: Context<'_, S>) {
+                self.deref().on_exit(id, ctx)
+            }
+
+            #[inline]
+            fn on_close(&self, id: span::Id, ctx: Context<'_, S>) {
+                self.deref().on_close(id, ctx)
+            }
+
+            #[inline]
+            fn on_id_change(&self, old: &span::Id, new: &span::Id, ctx: Context<'_, S>) {
+                self.deref().on_id_change(old, new, ctx)
+            }
+
+            #[doc(hidden)]
+            #[inline]
+            unsafe fn downcast_raw(&self, id: TypeId) -> Option<*const ()> {
+                self.deref().downcast_raw(id)
+            }
+        };
+    }
+
+    impl<L, S> Layer<S> for Box<L>
+    where
+        L: Layer<S>,
+        S: Subscriber,
+    {
+        layer_impl_body! {}
+    }
+
+    impl<S> Layer<S> for Box<dyn Layer<S> + Send + Sync>
+    where
+        S: Subscriber,
+    {
+        layer_impl_body! {}
+    }
+}
+
+// === impl SubscriberExt ===
+
+impl<S: Subscriber> crate::sealed::Sealed for S {}
+impl<S: Subscriber> SubscriberExt for S {}
+
+// === impl Identity ===
+
+impl<S: Subscriber> Layer<S> for Identity {}
+
+impl Identity {
+    /// Returns a new `Identity` layer.
+    pub fn new() -> Self {
+        Self { _p: () }
+    }
+}
diff --git a/vendor/tracing-subscriber-0.3.3/src/layer/tests.rs b/vendor/tracing-subscriber-0.3.3/src/layer/tests.rs
new file mode 100644
index 000000000..d7ad61769
--- /dev/null
+++ b/vendor/tracing-subscriber-0.3.3/src/layer/tests.rs
@@ -0,0 +1,308 @@
+use super::*;
+use tracing_core::subscriber::NoSubscriber;
+
+#[derive(Debug)]
+pub(crate) struct NopLayer;
+impl<S: Subscriber> Layer<S> for NopLayer {}
+
+#[allow(dead_code)]
+struct NopLayer2;
+impl<S: Subscriber> Layer<S> for NopLayer2 {}
+
+/// A layer that holds a string.
+///
+/// Used to test that pointers returned by downcasting are actually valid.
+struct StringLayer(&'static str);
+impl<S: Subscriber> Layer<S> for StringLayer {}
+struct StringLayer2(&'static str);
+impl<S: Subscriber> Layer<S> for StringLayer2 {}
+
+struct StringLayer3(&'static str);
+impl<S: Subscriber> Layer<S> for StringLayer3 {}
+
+pub(crate) struct StringSubscriber(&'static str);
+
+impl Subscriber for StringSubscriber {
+    fn register_callsite(&self, _: &'static Metadata<'static>) -> Interest {
+        Interest::never()
+    }
+
+    fn enabled(&self, _: &Metadata<'_>) -> bool {
+        false
+    }
+
+    fn new_span(&self, _: &span::Attributes<'_>) -> span::Id {
+        span::Id::from_u64(1)
+    }
+
+    fn record(&self, _: &span::Id, _: &span::Record<'_>) {}
+    fn record_follows_from(&self, _: &span::Id, _: &span::Id) {}
+    fn event(&self, _: &Event<'_>) {}
+    fn enter(&self, _: &span::Id) {}
+    fn exit(&self, _: &span::Id) {}
+}
+
+fn assert_subscriber(_s: impl Subscriber) {}
+fn assert_layer<S: Subscriber>(_l: &impl Layer<S>) {}
+
+#[test]
+fn layer_is_subscriber() {
+    let s = NopLayer.with_subscriber(NoSubscriber::default());
+    assert_subscriber(s)
+}
+
+#[test]
+fn two_layers_are_subscriber() {
+    let s = NopLayer
+        .and_then(NopLayer)
+        .with_subscriber(NoSubscriber::default());
+    assert_subscriber(s)
+}
+
+#[test]
+fn three_layers_are_subscriber() {
+    let s = NopLayer
+        .and_then(NopLayer)
+        .and_then(NopLayer)
+        .with_subscriber(NoSubscriber::default());
+    assert_subscriber(s)
+}
+
+#[test]
+fn three_layers_are_layer() {
+    let layers = NopLayer.and_then(NopLayer).and_then(NopLayer);
+    assert_layer(&layers);
+    let _ = layers.with_subscriber(NoSubscriber::default());
+}
+
+#[test]
+#[cfg(feature = "alloc")]
+fn box_layer_is_layer() {
+    use alloc::boxed::Box;
+    let l: Box<dyn Layer<NoSubscriber> + Send + Sync> = Box::new(NopLayer);
+    assert_layer(&l);
+    l.with_subscriber(NoSubscriber::default());
+}
+
+#[test]
+fn downcasts_to_subscriber() {
+    let s = NopLayer
+        .and_then(NopLayer)
+        .and_then(NopLayer)
+        .with_subscriber(StringSubscriber("subscriber"));
+    let subscriber =
+        <dyn Subscriber>::downcast_ref::<StringSubscriber>(&s).expect("subscriber should downcast");
+    assert_eq!(subscriber.0, "subscriber");
+}
+
+#[test]
+fn downcasts_to_layer() {
+    let s = StringLayer("layer_1")
+        .and_then(StringLayer2("layer_2"))
+        .and_then(StringLayer3("layer_3"))
+        .with_subscriber(NoSubscriber::default());
+    let layer = <dyn Subscriber>::downcast_ref::<StringLayer>(&s).expect("layer 1 should downcast");
+    assert_eq!(layer.0, "layer_1");
+    let layer =
+        <dyn Subscriber>::downcast_ref::<StringLayer2>(&s).expect("layer 2 should downcast");
+    assert_eq!(layer.0, "layer_2");
+    let layer =
+        <dyn Subscriber>::downcast_ref::<StringLayer3>(&s).expect("layer 3 should downcast");
+    assert_eq!(layer.0, "layer_3");
+}
+
+#[cfg(all(feature = "registry", feature = "std"))]
+mod registry_tests {
+    use super::*;
+    use crate::registry::LookupSpan;
+
+    #[test]
+    fn context_event_span() {
+        use std::sync::{Arc, Mutex};
+        let last_event_span = Arc::new(Mutex::new(None));
+
+        struct RecordingLayer {
+            last_event_span: Arc<Mutex<Option<&'static str>>>,
+        }
+
+        impl<S> Layer<S> for RecordingLayer
+        where
+            S: Subscriber + for<'lookup> LookupSpan<'lookup>,
+        {
+            fn on_event(&self, event: &Event<'_>, ctx: Context<'_, S>) {
+                let span = ctx.event_span(event);
+                *self.last_event_span.lock().unwrap() = span.map(|s| s.name());
+            }
+        }
+
+        tracing::subscriber::with_default(
+            crate::registry().with(RecordingLayer {
+                last_event_span: last_event_span.clone(),
+            }),
+            || {
+                tracing::info!("no span");
+                assert_eq!(*last_event_span.lock().unwrap(), None);
+
+                let parent = tracing::info_span!("explicit");
+                tracing::info!(parent: &parent, "explicit span");
+                assert_eq!(*last_event_span.lock().unwrap(), Some("explicit"));
+
+                let _guard = tracing::info_span!("contextual").entered();
+                tracing::info!("contextual span");
+                assert_eq!(*last_event_span.lock().unwrap(), Some("contextual"));
+            },
+        );
+    }
+
+    /// Tests for how max-level hints are calculated when combining layers
+    /// with and without per-layer filtering.
+    mod max_level_hints {
+
+        use super::*;
+        use crate::filter::*;
+
+        #[test]
+        fn mixed_with_unfiltered() {
+            let subscriber = crate::registry()
+                .with(NopLayer)
+                .with(NopLayer.with_filter(LevelFilter::INFO));
+            assert_eq!(subscriber.max_level_hint(), None);
+        }
+
+        #[test]
+        fn mixed_with_unfiltered_layered() {
+            let subscriber = crate::registry().with(NopLayer).with(
+                NopLayer
+                    .with_filter(LevelFilter::INFO)
+                    .and_then(NopLayer.with_filter(LevelFilter::TRACE)),
+            );
+            assert_eq!(dbg!(subscriber).max_level_hint(), None);
+        }
+
+        #[test]
+        fn mixed_interleaved() {
+            let subscriber = crate::registry()
+                .with(NopLayer)
+                .with(NopLayer.with_filter(LevelFilter::INFO))
+                .with(NopLayer)
+                .with(NopLayer.with_filter(LevelFilter::INFO));
+            assert_eq!(dbg!(subscriber).max_level_hint(), None);
+        }
+
+        #[test]
+        fn mixed_layered() {
+            let subscriber = crate::registry()
+                .with(NopLayer.with_filter(LevelFilter::INFO).and_then(NopLayer))
+                .with(NopLayer.and_then(NopLayer.with_filter(LevelFilter::INFO)));
+            assert_eq!(dbg!(subscriber).max_level_hint(), None);
+        }
+
+        #[test]
+        fn plf_only_unhinted() {
+            let subscriber = crate::registry()
+                .with(NopLayer.with_filter(LevelFilter::INFO))
+                .with(NopLayer.with_filter(filter_fn(|_| true)));
+            assert_eq!(dbg!(subscriber).max_level_hint(), None);
+        }
+
+        #[test]
+        fn plf_only_unhinted_nested_outer() {
+            // if a nested tree of per-layer filters has an _outer_ filter with
+            // no max level hint, it should return `None`.
+            let subscriber = crate::registry()
+                .with(
+                    NopLayer
+                        .with_filter(LevelFilter::INFO)
+                        .and_then(NopLayer.with_filter(LevelFilter::WARN)),
+                )
+                .with(
+                    NopLayer
+                        .with_filter(filter_fn(|_| true))
+                        .and_then(NopLayer.with_filter(LevelFilter::DEBUG)),
+                );
+            assert_eq!(dbg!(subscriber).max_level_hint(), None);
+        }
+
+        #[test]
+        fn plf_only_unhinted_nested_inner() {
+            // If a nested tree of per-layer filters has an _inner_ filter with
+            // no max-level hint, but the _outer_ filter has a max level hint,
+            // it should pick the outer hint. This is because the outer filter
+            // will disable the spans/events before they make it to the inner
+            // filter.
+            let subscriber = dbg!(crate::registry().with(
+                NopLayer
+                    .with_filter(filter_fn(|_| true))
+                    .and_then(NopLayer.with_filter(filter_fn(|_| true)))
+                    .with_filter(LevelFilter::INFO),
+            ));
+            assert_eq!(dbg!(subscriber).max_level_hint(), Some(LevelFilter::INFO));
+        }
+
+        #[test]
+        fn unhinted_nested_inner() {
+            let subscriber = dbg!(crate::registry()
+                .with(NopLayer.and_then(NopLayer).with_filter(LevelFilter::INFO))
+                .with(
+                    NopLayer
+                        .with_filter(filter_fn(|_| true))
+                        .and_then(NopLayer.with_filter(filter_fn(|_| true)))
+                        .with_filter(LevelFilter::WARN),
+                ));
+            assert_eq!(dbg!(subscriber).max_level_hint(), Some(LevelFilter::INFO));
+        }
+
+        #[test]
+        fn unhinted_nested_inner_mixed() {
+            let subscriber = dbg!(crate::registry()
+                .with(
+                    NopLayer
+                        .and_then(NopLayer.with_filter(filter_fn(|_| true)))
+                        .with_filter(LevelFilter::INFO)
+                )
+                .with(
+                    NopLayer
+                        .with_filter(filter_fn(|_| true))
+                        .and_then(NopLayer.with_filter(filter_fn(|_| true)))
+                        .with_filter(LevelFilter::WARN),
+                ));
+            assert_eq!(dbg!(subscriber).max_level_hint(), Some(LevelFilter::INFO));
+        }
+
+        #[test]
+        fn plf_only_picks_max() {
+            let subscriber = crate::registry()
+                .with(NopLayer.with_filter(LevelFilter::WARN))
+                .with(NopLayer.with_filter(LevelFilter::DEBUG));
+            assert_eq!(dbg!(subscriber).max_level_hint(), Some(LevelFilter::DEBUG));
+        }
+
+        #[test]
+        fn many_plf_only_picks_max() {
+            let subscriber = crate::registry()
+                .with(NopLayer.with_filter(LevelFilter::WARN))
+                .with(NopLayer.with_filter(LevelFilter::DEBUG))
+                .with(NopLayer.with_filter(LevelFilter::INFO))
+                .with(NopLayer.with_filter(LevelFilter::ERROR));
+            assert_eq!(dbg!(subscriber).max_level_hint(), Some(LevelFilter::DEBUG));
+        }
+
+        #[test]
+        fn nested_plf_only_picks_max() {
+            let subscriber = crate::registry()
+                .with(
+                    NopLayer.with_filter(LevelFilter::INFO).and_then(
+                        NopLayer
+                            .with_filter(LevelFilter::WARN)
+                            .and_then(NopLayer.with_filter(LevelFilter::DEBUG)),
+                    ),
+                )
+                .with(
+                    NopLayer
+                        .with_filter(LevelFilter::INFO)
+                        .and_then(NopLayer.with_filter(LevelFilter::ERROR)),
+                );
+            assert_eq!(dbg!(subscriber).max_level_hint(), Some(LevelFilter::DEBUG));
+        }
+    }
+}
diff --git a/vendor/tracing-subscriber-0.3.3/src/lib.rs b/vendor/tracing-subscriber-0.3.3/src/lib.rs
new file mode 100644
index 000000000..563a86dee
--- /dev/null
+++ b/vendor/tracing-subscriber-0.3.3/src/lib.rs
@@ -0,0 +1,218 @@
+//! Utilities for implementing and composing [`tracing`] subscribers.
+//!
+//! [`tracing`] is a framework for instrumenting Rust programs to collect
+//! scoped, structured, and async-aware diagnostics. The [`Subscriber`] trait
+//! represents the functionality necessary to collect this trace data. This
+//! crate contains tools for composing subscribers out of smaller units of
+//! behaviour, and batteries-included implementations of common subscriber
+//! functionality.
+//!
+//! `tracing-subscriber` is intended for use by both `Subscriber` authors and
+//! application authors using `tracing` to instrument their applications.
+//!
+//! *Compiler support: [requires `rustc` 1.42+][msrv]*
+//!
+//! [msrv]: #supported-rust-versions
+//!
+//! ## `Layer`s and `Filter`s
+//!
+//! The most important component of the `tracing-subscriber` API is the
+//! [`Layer`] trait, which provides a composable abstraction for building
+//! [`Subscriber`]s. Like the [`Subscriber`] trait, a [`Layer`] defines a
+//! particular behavior for collecting trace data. Unlike [`Subscriber`]s,
+//! which implement a *complete* strategy for how trace data is collected,
+//! [`Layer`]s provide *modular* implementations of specific behaviors.
+//! Therefore, they can be [composed together] to form a [`Subscriber`] which is
+//! capable of recording traces in a variety of ways. See the [`layer` module's
+//! documentation][layer] for details on using [`Layer`]s.
+//!
+//! In addition, the [`Filter`] trait defines an interface for filtering what
+//! spans and events are recorded by a particular layer. This allows different
+//! [`Layer`]s to handle separate subsets of the trace data emitted by a
+//! program. See the [documentation on per-layer filtering][plf] for more
+//! information on using [`Filter`]s.
+//!
+//! [`Layer`]: crate::layer::Layer
+//! [composed together]: crate::layer#composing-layers
+//! [layer]: crate::layer
+//! [`Filter`]: crate::layer::Filter
+//! [plf]: crate::layer#per-layer-filtering
+//!
+//! ## Included Subscribers
+//!
+//! The following `Subscriber`s are provided for application authors:
+//!
+//! - [`fmt`] - Formats and logs tracing data (requires the `fmt` feature flag)
+//!
+//! ## Feature Flags
+//!
+//! - `std`: Enables APIs that depend on the on the Rust standard library
+//!   (enabled by default).
+//! - `alloc`: Depend on [`liballoc`] (enabled by "std").
+//! - `env-filter`: Enables the [`EnvFilter`] type, which implements filtering
+//!   similar to the [`env_logger` crate]. **Requires "std"**.
+//! - `fmt`: Enables the [`fmt`] module, which provides a subscriber
+//!   implementation for printing formatted representations of trace events.
+//!   Enabled by default. **Requires "std"**.
+//! - `ansi`: Enables `fmt` support for ANSI terminal colors. Enabled by
+//!   default.
+//! - `registry`: enables the [`registry`] module. Enabled by default.
+//!   **Requires "std"**.
+//! - `json`: Enables `fmt` support for JSON output. In JSON output, the ANSI
+//!   feature does nothing. **Requires "fmt" and "std"**.
+//! - [`local-time`]: Enables local time formatting when using the [`time`
+//!   crate]'s timestamp formatters with the `fmt` subscriber.
+//!
+//! ### Optional Dependencies
+//!
+//! - [`tracing-log`]: Enables better formatting for events emitted by `log`
+//!   macros in the `fmt` subscriber. Enabled by default.
+//! - [`time`][`time` crate]: Enables support for using the [`time` crate] for timestamp
+//!   formatting in the `fmt` subscriber.
+//! - [`smallvec`]: Causes the `EnvFilter` type to use the `smallvec` crate (rather
+//!   than `Vec`) as a performance optimization. Enabled by default.
+//! - [`parking_lot`]: Use the `parking_lot` crate's `RwLock` implementation
+//!   rather than the Rust standard library's implementation.
+//!
+//! ### `no_std` Support
+//!
+//! In embedded systems and other bare-metal applications, `tracing` can be
+//! used without requiring the Rust standard library, although some features are
+//! disabled. Although most of the APIs provided by `tracing-subscriber`, such
+//! as [`fmt`] and [`EnvFilter`], require the standard library, some
+//! functionality, such as the [`Subscriber`] trait, can still be used in
+//! `no_std` environments.
+//!
+//! The dependency on the standard library is controlled by two crate feature
+//! flags, "std", which enables the dependency on [`libstd`], and "alloc", which
+//! enables the dependency on [`liballoc`] (and is enabled by the "std"
+//! feature). These features are enabled by default, but `no_std` users can
+//! disable them using:
+//!
+//! ```toml
+//! # Cargo.toml
+//! tracing-subscriber = { version = "0.3", default-features = false }
+//! ```
+//!
+//! Additional APIs are available when [`liballoc`] is available. To enable
+//! `liballoc` but not `std`, use:
+//!
+//! ```toml
+//! # Cargo.toml
+//! tracing-subscriber = { version = "0.3", default-features = false, features = ["alloc"] }
+//! ```
+//!
+//! ## Supported Rust Versions
+//!
+//! Tracing is built against the latest stable release. The minimum supported
+//! version is 1.42. The current Tracing version is not guaranteed to build on
+//! Rust versions earlier than the minimum supported version.
+//!
+//! Tracing follows the same compiler support policies as the rest of the Tokio
+//! project. The current stable Rust compiler and the three most recent minor
+//! versions before it will always be supported. For example, if the current
+//! stable compiler version is 1.45, the minimum supported version will not be
+//! increased past 1.42, three minor versions prior. Increasing the minimum
+//! supported compiler version is not considered a semver breaking change as
+//! long as doing so complies with this policy.
+//!
+//! [`tracing`]: https://docs.rs/tracing/latest/tracing/
+//! [`Subscriber`]: https://docs.rs/tracing-core/latest/tracing_core/subscriber/trait.Subscriber.html
+//! [`EnvFilter`]: filter/struct.EnvFilter.html
+//! [`fmt`]: fmt/index.html
+//! [`tracing-log`]: https://crates.io/crates/tracing-log
+//! [`smallvec`]: https://crates.io/crates/smallvec
+//! [`env_logger` crate]: https://crates.io/crates/env_logger
+//! [`parking_lot`]: https://crates.io/crates/parking_lot
+//! [`time` crate]: https://crates.io/crates/time
+//! [`liballoc`]: https://doc.rust-lang.org/alloc/index.html
+#![doc(html_root_url = "https://docs.rs/tracing-subscriber/0.3.1")]
+#![doc(
+    html_logo_url = "https://raw.githubusercontent.com/tokio-rs/tracing/master/assets/logo-type.png",
+    issue_tracker_base_url = "https://github.com/tokio-rs/tracing/issues/"
+)]
+#![cfg_attr(
+    docsrs,
+    // Allows displaying cfgs/feature flags in the documentation.
+    feature(doc_cfg),
+    // Allows adding traits to RustDoc's list of "notable traits"
+    feature(doc_notable_trait),
+    // Fail the docs build if any intra-docs links are broken
+    deny(rustdoc::broken_intra_doc_links),
+)]
+#![warn(
+    missing_debug_implementations,
+    missing_docs,
+    rust_2018_idioms,
+    unreachable_pub,
+    bad_style,
+    const_err,
+    dead_code,
+    improper_ctypes,
+    non_shorthand_field_patterns,
+    no_mangle_generic_items,
+    overflowing_literals,
+    path_statements,
+    patterns_in_fns_without_body,
+    private_in_public,
+    unconditional_recursion,
+    unused,
+    unused_allocation,
+    unused_comparisons,
+    unused_parens,
+    while_true
+)]
+// Using struct update syntax when a struct has no additional fields avoids
+// a potential source change if additional fields are added to the struct in the
+// future, reducing diff noise. Allow this even though clippy considers it
+// "needless".
+#![allow(clippy::needless_update)]
+#![cfg_attr(not(feature = "std"), no_std)]
+
+#[cfg(feature = "alloc")]
+extern crate alloc;
+
+#[macro_use]
+mod macros;
+
+pub mod field;
+pub mod filter;
+pub mod prelude;
+pub mod registry;
+
+pub mod layer;
+pub mod util;
+
+feature! {
+    #![feature = "std"]
+    pub mod reload;
+    pub(crate) mod sync;
+}
+
+feature! {
+    #![all(feature = "fmt", feature = "std")]
+    pub mod fmt;
+    pub use fmt::fmt;
+    pub use fmt::Subscriber as FmtSubscriber;
+}
+
+feature! {
+    #![all(feature = "env-filter", feature = "std")]
+    pub use filter::EnvFilter;
+}
+
+pub use layer::Layer;
+
+feature! {
+    #![all(feature = "registry", feature = "std")]
+    pub use registry::Registry;
+
+    ///
+    pub fn registry() -> Registry {
+        Registry::default()
+    }
+}
+
+mod sealed {
+    pub trait Sealed<A = ()> {}
+}
diff --git a/vendor/tracing-subscriber-0.3.3/src/macros.rs b/vendor/tracing-subscriber-0.3.3/src/macros.rs
new file mode 100644
index 000000000..81351132f
--- /dev/null
+++ b/vendor/tracing-subscriber-0.3.3/src/macros.rs
@@ -0,0 +1,28 @@
+#[cfg(feature = "std")]
+macro_rules! try_lock {
+    ($lock:expr) => {
+        try_lock!($lock, else return)
+    };
+    ($lock:expr, else $els:expr) => {
+        if let Ok(l) = $lock {
+            l
+        } else if std::thread::panicking() {
+            $els
+        } else {
+            panic!("lock poisoned")
+        }
+    };
+}
+
+macro_rules! feature {
+    (
+        #![$meta:meta]
+        $($item:item)*
+    ) => {
+        $(
+            #[cfg($meta)]
+            #[cfg_attr(docsrs, doc(cfg($meta)))]
+            $item
+        )*
+    }
+}
diff --git a/vendor/tracing-subscriber-0.3.3/src/prelude.rs b/vendor/tracing-subscriber-0.3.3/src/prelude.rs
new file mode 100644
index 000000000..c2230907b
--- /dev/null
+++ b/vendor/tracing-subscriber-0.3.3/src/prelude.rs
@@ -0,0 +1,19 @@
+//! The `tracing-subscriber` prelude.
+//!
+//! This brings into scope a number of extension traits that define methods on
+//! types defined here and in other crates.
+
+pub use crate::field::{
+    MakeExt as __tracing_subscriber_field_MakeExt,
+    RecordFields as __tracing_subscriber_field_RecordFields,
+};
+pub use crate::layer::{
+    Layer as __tracing_subscriber_Layer, SubscriberExt as __tracing_subscriber_SubscriberExt,
+};
+
+pub use crate::util::SubscriberInitExt as _;
+
+feature! {
+    #![all(feature = "fmt", feature = "std")]
+    pub use crate::fmt::writer::MakeWriterExt as _;
+}
diff --git a/vendor/tracing-subscriber-0.3.3/src/registry/extensions.rs b/vendor/tracing-subscriber-0.3.3/src/registry/extensions.rs
new file mode 100644
index 000000000..899e1549f
--- /dev/null
+++ b/vendor/tracing-subscriber-0.3.3/src/registry/extensions.rs
@@ -0,0 +1,274 @@
+// taken from https://github.com/hyperium/http/blob/master/src/extensions.rs.
+
+use crate::sync::{RwLockReadGuard, RwLockWriteGuard};
+use std::{
+    any::{Any, TypeId},
+    collections::HashMap,
+    fmt,
+    hash::{BuildHasherDefault, Hasher},
+};
+
+#[allow(warnings)]
+type AnyMap = HashMap<TypeId, Box<dyn Any + Send + Sync>, BuildHasherDefault<IdHasher>>;
+
+/// With TypeIds as keys, there's no need to hash them. They are already hashes
+/// themselves, coming from the compiler. The IdHasher holds the u64 of
+/// the TypeId, and then returns it, instead of doing any bit fiddling.
+#[derive(Default, Debug)]
+struct IdHasher(u64);
+
+impl Hasher for IdHasher {
+    fn write(&mut self, _: &[u8]) {
+        unreachable!("TypeId calls write_u64");
+    }
+
+    #[inline]
+    fn write_u64(&mut self, id: u64) {
+        self.0 = id;
+    }
+
+    #[inline]
+    fn finish(&self) -> u64 {
+        self.0
+    }
+}
+
+/// An immutable, read-only reference to a Span's extensions.
+#[derive(Debug)]
+#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
+pub struct Extensions<'a> {
+    inner: RwLockReadGuard<'a, ExtensionsInner>,
+}
+
+impl<'a> Extensions<'a> {
+    #[cfg(feature = "registry")]
+    pub(crate) fn new(inner: RwLockReadGuard<'a, ExtensionsInner>) -> Self {
+        Self { inner }
+    }
+
+    /// Immutably borrows a type previously inserted into this `Extensions`.
+    pub fn get<T: 'static>(&self) -> Option<&T> {
+        self.inner.get::<T>()
+    }
+}
+
+/// An mutable reference to a Span's extensions.
+#[derive(Debug)]
+#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
+pub struct ExtensionsMut<'a> {
+    inner: RwLockWriteGuard<'a, ExtensionsInner>,
+}
+
+impl<'a> ExtensionsMut<'a> {
+    #[cfg(feature = "registry")]
+    pub(crate) fn new(inner: RwLockWriteGuard<'a, ExtensionsInner>) -> Self {
+        Self { inner }
+    }
+
+    /// Insert a type into this `Extensions`.
+    ///
+    /// Note that extensions are _not_
+    /// `Layer`-specific—they are _span_-specific. This means that
+    /// other layers can access and mutate extensions that
+    /// a different Layer recorded. For example, an application might
+    /// have a layer that records execution timings, alongside a layer
+    /// that reports spans and events to a distributed
+    /// tracing system that requires timestamps for spans.
+    /// Ideally, if one layer records a timestamp _x_, the other layer
+    /// should be able to reuse timestamp _x_.
+    ///
+    /// Therefore, extensions should generally be newtypes, rather than common
+    /// types like [`String`](https://doc.rust-lang.org/std/string/struct.String.html), to avoid accidental
+    /// cross-`Layer` clobbering.
+    ///
+    /// ## Panics
+    ///
+    /// If `T` is already present in `Extensions`, then this method will panic.
+    pub fn insert<T: Send + Sync + 'static>(&mut self, val: T) {
+        assert!(self.replace(val).is_none())
+    }
+
+    /// Replaces an existing `T` into this extensions.
+    ///
+    /// If `T` is not present, `Option::None` will be returned.
+    pub fn replace<T: Send + Sync + 'static>(&mut self, val: T) -> Option<T> {
+        self.inner.insert(val)
+    }
+
+    /// Get a mutable reference to a type previously inserted on this `ExtensionsMut`.
+    pub fn get_mut<T: 'static>(&mut self) -> Option<&mut T> {
+        self.inner.get_mut::<T>()
+    }
+
+    /// Remove a type from this `Extensions`.
+    ///
+    /// If a extension of this type existed, it will be returned.
+    pub fn remove<T: Send + Sync + 'static>(&mut self) -> Option<T> {
+        self.inner.remove::<T>()
+    }
+}
+
+/// A type map of span extensions.
+///
+/// [ExtensionsInner] is used by `SpanData` to store and
+/// span-specific data. A given `Layer` can read and write
+/// data that it is interested in recording and emitting.
+#[derive(Default)]
+pub(crate) struct ExtensionsInner {
+    map: AnyMap,
+}
+
+impl ExtensionsInner {
+    /// Create an empty `Extensions`.
+    #[cfg(any(test, feature = "registry"))]
+    #[inline]
+    #[cfg(any(test, feature = "registry"))]
+    pub(crate) fn new() -> ExtensionsInner {
+        ExtensionsInner {
+            map: AnyMap::default(),
+        }
+    }
+
+    /// Insert a type into this `Extensions`.
+    ///
+    /// If a extension of this type already existed, it will
+    /// be returned.
+    pub(crate) fn insert<T: Send + Sync + 'static>(&mut self, val: T) -> Option<T> {
+        self.map
+            .insert(TypeId::of::<T>(), Box::new(val))
+            .and_then(|boxed| {
+                #[allow(warnings)]
+                {
+                    (boxed as Box<Any + 'static>)
+                        .downcast()
+                        .ok()
+                        .map(|boxed| *boxed)
+                }
+            })
+    }
+
+    /// Get a reference to a type previously inserted on this `Extensions`.
+    pub(crate) fn get<T: 'static>(&self) -> Option<&T> {
+        self.map
+            .get(&TypeId::of::<T>())
+            .and_then(|boxed| (&**boxed as &(dyn Any + 'static)).downcast_ref())
+    }
+
+    /// Get a mutable reference to a type previously inserted on this `Extensions`.
+    pub(crate) fn get_mut<T: 'static>(&mut self) -> Option<&mut T> {
+        self.map
+            .get_mut(&TypeId::of::<T>())
+            .and_then(|boxed| (&mut **boxed as &mut (dyn Any + 'static)).downcast_mut())
+    }
+
+    /// Remove a type from this `Extensions`.
+    ///
+    /// If a extension of this type existed, it will be returned.
+    pub(crate) fn remove<T: Send + Sync + 'static>(&mut self) -> Option<T> {
+        self.map.remove(&TypeId::of::<T>()).and_then(|boxed| {
+            #[allow(warnings)]
+            {
+                (boxed as Box<Any + 'static>)
+                    .downcast()
+                    .ok()
+                    .map(|boxed| *boxed)
+            }
+        })
+    }
+
+    /// Clear the `ExtensionsInner` in-place, dropping any elements in the map but
+    /// retaining allocated capacity.
+    ///
+    /// This permits the hash map allocation to be pooled by the registry so
+    /// that future spans will not need to allocate new hashmaps.
+    #[cfg(any(test, feature = "registry"))]
+    pub(crate) fn clear(&mut self) {
+        self.map.clear();
+    }
+}
+
+impl fmt::Debug for ExtensionsInner {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Extensions")
+            .field("len", &self.map.len())
+            .field("capacity", &self.map.capacity())
+            .finish()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[derive(Debug, PartialEq)]
+    struct MyType(i32);
+
+    #[test]
+    fn test_extensions() {
+        let mut extensions = ExtensionsInner::new();
+
+        extensions.insert(5i32);
+        extensions.insert(MyType(10));
+
+        assert_eq!(extensions.get(), Some(&5i32));
+        assert_eq!(extensions.get_mut(), Some(&mut 5i32));
+
+        assert_eq!(extensions.remove::<i32>(), Some(5i32));
+        assert!(extensions.get::<i32>().is_none());
+
+        assert_eq!(extensions.get::<bool>(), None);
+        assert_eq!(extensions.get(), Some(&MyType(10)));
+    }
+
+    #[test]
+    fn clear_retains_capacity() {
+        let mut extensions = ExtensionsInner::new();
+        extensions.insert(5i32);
+        extensions.insert(MyType(10));
+        extensions.insert(true);
+
+        assert_eq!(extensions.map.len(), 3);
+        let prev_capacity = extensions.map.capacity();
+        extensions.clear();
+
+        assert_eq!(
+            extensions.map.len(),
+            0,
+            "after clear(), extensions map should have length 0"
+        );
+        assert_eq!(
+            extensions.map.capacity(),
+            prev_capacity,
+            "after clear(), extensions map should retain prior capacity"
+        );
+    }
+
+    #[test]
+    fn clear_drops_elements() {
+        use std::sync::Arc;
+        struct DropMePlease(Arc<()>);
+        struct DropMeTooPlease(Arc<()>);
+
+        let mut extensions = ExtensionsInner::new();
+        let val1 = DropMePlease(Arc::new(()));
+        let val2 = DropMeTooPlease(Arc::new(()));
+
+        let val1_dropped = Arc::downgrade(&val1.0);
+        let val2_dropped = Arc::downgrade(&val2.0);
+        extensions.insert(val1);
+        extensions.insert(val2);
+
+        assert!(val1_dropped.upgrade().is_some());
+        assert!(val2_dropped.upgrade().is_some());
+
+        extensions.clear();
+        assert!(
+            val1_dropped.upgrade().is_none(),
+            "after clear(), val1 should be dropped"
+        );
+        assert!(
+            val2_dropped.upgrade().is_none(),
+            "after clear(), val2 should be dropped"
+        );
+    }
+}
diff --git a/vendor/tracing-subscriber-0.3.3/src/registry/mod.rs b/vendor/tracing-subscriber-0.3.3/src/registry/mod.rs
new file mode 100644
index 000000000..f3b77b6a9
--- /dev/null
+++ b/vendor/tracing-subscriber-0.3.3/src/registry/mod.rs
@@ -0,0 +1,604 @@
+//! Storage for span data shared by multiple [`Layer`]s.
+//!
+//! ## Using the Span Registry
+//!
+//! This module provides the [`Registry`] type, a [`Subscriber`] implementation
+//! which tracks per-span data and exposes it to [`Layer`]s. When a `Registry`
+//! is used as the base `Subscriber` of a `Layer` stack, the
+//! [`layer::Context`][ctx] type will provide methods allowing `Layer`s to
+//! [look up span data][lookup] stored in the registry. While [`Registry`] is a
+//! reasonable default for storing spans and events, other stores that implement
+//! [`LookupSpan`] and [`Subscriber`] themselves (with [`SpanData`] implemented
+//! by the per-span data they store) can be used as a drop-in replacement.
+//!
+//! For example, we might create a `Registry` and add multiple `Layer`s like so:
+//! ```rust
+//! use tracing_subscriber::{registry::Registry, Layer, prelude::*};
+//! # use tracing_core::Subscriber;
+//! # pub struct FooLayer {}
+//! # pub struct BarLayer {}
+//! # impl<S: Subscriber> Layer<S> for FooLayer {}
+//! # impl<S: Subscriber> Layer<S> for BarLayer {}
+//! # impl FooLayer {
+//! # fn new() -> Self { Self {} }
+//! # }
+//! # impl BarLayer {
+//! # fn new() -> Self { Self {} }
+//! # }
+//!
+//! let subscriber = Registry::default()
+//!     .with(FooLayer::new())
+//!     .with(BarLayer::new());
+//! ```
+//!
+//! If a type implementing `Layer` depends on the functionality of a `Registry`
+//! implementation, it should bound its `Subscriber` type parameter with the
+//! [`LookupSpan`] trait, like so:
+//!
+//! ```rust
+//! use tracing_subscriber::{registry, Layer};
+//! use tracing_core::Subscriber;
+//!
+//! pub struct MyLayer {
+//!     // ...
+//! }
+//!
+//! impl<S> Layer<S> for MyLayer
+//! where
+//!     S: Subscriber + for<'a> registry::LookupSpan<'a>,
+//! {
+//!     // ...
+//! }
+//! ```
+//! When this bound is added, the `Layer` implementation will be guaranteed
+//! access to the [`Context`][ctx] methods, such as [`Context::span`][lookup], that
+//! require the root subscriber to be a registry.
+//!
+//! [`Layer`]: crate::layer::Layer
+//! [`Subscriber`]:
+//!     https://docs.rs/tracing-core/latest/tracing_core/subscriber/trait.Subscriber.html
+//! [ctx]: crate::layer::Context
+//! [lookup]: crate::layer::Context::span()
+use tracing_core::{field::FieldSet, span::Id, Metadata};
+
+feature! {
+    #![feature = "std"]
+    /// A module containing a type map of span extensions.
+    mod extensions;
+    pub use extensions::{Extensions, ExtensionsMut};
+
+}
+
+feature! {
+    #![all(feature = "registry", feature = "std")]
+
+    mod sharded;
+    mod stack;
+
+    pub use sharded::Data;
+    pub use sharded::Registry;
+
+    use crate::filter::FilterId;
+}
+
+/// Provides access to stored span data.
+///
+/// Subscribers which store span data and associate it with span IDs should
+/// implement this trait; if they do, any [`Layer`]s wrapping them can look up
+/// metadata via the [`Context`] type's [`span()`] method.
+///
+/// [`Layer`]: ../layer/trait.Layer.html
+/// [`Context`]: ../layer/struct.Context.html
+/// [`span()`]: ../layer/struct.Context.html#method.span
+pub trait LookupSpan<'a> {
+    /// The type of span data stored in this registry.
+    type Data: SpanData<'a>;
+
+    /// Returns the [`SpanData`] for a given `Id`, if it exists.
+    ///
+    /// <pre class="ignore" style="white-space:normal;font:inherit;">
+    /// <strong>Note</strong>: users of the <code>LookupSpan</code> trait should
+    /// typically call the <a href="#method.span"><code>span</code></a> method rather
+    /// than this method. The <code>span</code> method is implemented by
+    /// <em>calling</em> <code>span_data</code>, but returns a reference which is
+    /// capable of performing more sophisiticated queries.
+    /// </pre>
+    ///
+    /// [`SpanData`]: trait.SpanData.html
+    fn span_data(&'a self, id: &Id) -> Option<Self::Data>;
+
+    /// Returns a [`SpanRef`] for the span with the given `Id`, if it exists.
+    ///
+    /// A `SpanRef` is similar to [`SpanData`], but it allows performing
+    /// additional lookups against the registryr that stores the wrapped data.
+    ///
+    /// In general, _users_ of the `LookupSpan` trait should use this method
+    /// rather than the [`span_data`] method; while _implementors_ of this trait
+    /// should only implement `span_data`.
+    ///
+    /// [`SpanRef`]: struct.SpanRef.html
+    /// [`SpanData`]: trait.SpanData.html
+    /// [`span_data`]: #method.span_data
+    fn span(&'a self, id: &Id) -> Option<SpanRef<'_, Self>>
+    where
+        Self: Sized,
+    {
+        let data = self.span_data(id)?;
+        Some(SpanRef {
+            registry: self,
+            data,
+            #[cfg(feature = "registry")]
+            filter: FilterId::none(),
+        })
+    }
+
+    /// Registers a [`Filter`] for [per-layer filtering] with this
+    /// [`Subscriber`].
+    ///
+    /// The [`Filter`] can then use the returned [`FilterId`] to
+    /// [check if it previously enabled a span][check].
+    ///
+    /// # Panics
+    ///
+    /// If this `Subscriber` does not support [per-layer filtering].
+    ///
+    /// [`Filter`]: crate::layer::Filter
+    /// [per-layer filtering]: crate::layer::Layer#per-layer-filtering
+    /// [`Subscriber`]: tracing_core::Subscriber
+    /// [`FilterId`]: crate::filter::FilterId
+    /// [check]: SpanData::is_enabled_for
+    #[cfg(feature = "registry")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "registry")))]
+    fn register_filter(&mut self) -> FilterId {
+        panic!(
+            "{} does not currently support filters",
+            std::any::type_name::<Self>()
+        )
+    }
+}
+
+/// A stored representation of data associated with a span.
+pub trait SpanData<'a> {
+    /// Returns this span's ID.
+    fn id(&self) -> Id;
+
+    /// Returns a reference to the span's `Metadata`.
+    fn metadata(&self) -> &'static Metadata<'static>;
+
+    /// Returns a reference to the ID
+    fn parent(&self) -> Option<&Id>;
+
+    /// Returns a reference to this span's `Extensions`.
+    ///
+    /// The extensions may be used by `Layer`s to store additional data
+    /// describing the span.
+    #[cfg(feature = "std")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
+    fn extensions(&self) -> Extensions<'_>;
+
+    /// Returns a mutable reference to this span's `Extensions`.
+    ///
+    /// The extensions may be used by `Layer`s to store additional data
+    /// describing the span.
+    #[cfg(feature = "std")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
+    fn extensions_mut(&self) -> ExtensionsMut<'_>;
+
+    /// Returns `true` if this span is enabled for the [per-layer filter][plf]
+    /// corresponding to the provided [`FilterId`].
+    ///
+    /// ## Default Implementation
+    ///
+    /// By default, this method assumes that the [`LookupSpan`] implementation
+    /// does not support [per-layer filtering][plf], and always returns `true`.
+    ///
+    /// [plf]: crate::layer::Layer#per-layer-filtering
+    /// [`FilterId`]: crate::filter::FilterId
+    #[cfg(feature = "registry")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "registry")))]
+    fn is_enabled_for(&self, filter: FilterId) -> bool {
+        let _ = filter;
+        true
+    }
+}
+
+/// A reference to [span data] and the associated [registry].
+///
+/// This type implements all the same methods as [`SpanData`][span data], and
+/// provides additional methods for querying the registry based on values from
+/// the span.
+///
+/// [span data]: trait.SpanData.html
+/// [registry]: trait.LookupSpan.html
+#[derive(Debug)]
+pub struct SpanRef<'a, R: LookupSpan<'a>> {
+    registry: &'a R,
+    data: R::Data,
+
+    #[cfg(feature = "registry")]
+    filter: FilterId,
+}
+
+/// An iterator over the parents of a span, ordered from leaf to root.
+///
+/// This is returned by the [`SpanRef::scope`] method.
+#[derive(Debug)]
+pub struct Scope<'a, R> {
+    registry: &'a R,
+    next: Option<Id>,
+
+    #[cfg(all(feature = "registry", feature = "std"))]
+    filter: FilterId,
+}
+
+feature! {
+    #![any(feature = "alloc", feature = "std")]
+
+    #[cfg(not(feature = "smallvec"))]
+    use alloc::vec::{self, Vec};
+
+    use core::{fmt,iter};
+
+    /// An iterator over the parents of a span, ordered from root to leaf.
+    ///
+    /// This is returned by the [`Scope::from_root`] method.
+    pub struct ScopeFromRoot<'a, R>
+    where
+        R: LookupSpan<'a>,
+    {
+        #[cfg(feature = "smallvec")]
+        spans: iter::Rev<smallvec::IntoIter<SpanRefVecArray<'a, R>>>,
+        #[cfg(not(feature = "smallvec"))]
+        spans: iter::Rev<vec::IntoIter<SpanRef<'a, R>>>,
+    }
+
+    #[cfg(feature = "smallvec")]
+    type SpanRefVecArray<'span, L> = [SpanRef<'span, L>; 16];
+
+    impl<'a, R> Scope<'a, R>
+    where
+        R: LookupSpan<'a>,
+    {
+        /// Flips the order of the iterator, so that it is ordered from root to leaf.
+        ///
+        /// The iterator will first return the root span, then that span's immediate child,
+        /// and so on until it finally returns the span that [`SpanRef::scope`] was called on.
+        ///
+        /// If any items were consumed from the [`Scope`] before calling this method then they
+        /// will *not* be returned from the [`ScopeFromRoot`].
+        ///
+        /// **Note**: this will allocate if there are many spans remaining, or if the
+        /// "smallvec" feature flag is not enabled.
+        #[allow(clippy::wrong_self_convention)]
+        pub fn from_root(self) -> ScopeFromRoot<'a, R> {
+            #[cfg(feature = "smallvec")]
+            type Buf<T> = smallvec::SmallVec<T>;
+            #[cfg(not(feature = "smallvec"))]
+            type Buf<T> = Vec<T>;
+            ScopeFromRoot {
+                spans: self.collect::<Buf<_>>().into_iter().rev(),
+            }
+        }
+    }
+
+    impl<'a, R> Iterator for ScopeFromRoot<'a, R>
+    where
+        R: LookupSpan<'a>,
+    {
+        type Item = SpanRef<'a, R>;
+
+        #[inline]
+        fn next(&mut self) -> Option<Self::Item> {
+            self.spans.next()
+        }
+
+        #[inline]
+        fn size_hint(&self) -> (usize, Option<usize>) {
+            self.spans.size_hint()
+        }
+    }
+
+    impl<'a, R> fmt::Debug for ScopeFromRoot<'a, R>
+    where
+        R: LookupSpan<'a>,
+    {
+        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+            f.pad("ScopeFromRoot { .. }")
+        }
+    }
+}
+
+impl<'a, R> Iterator for Scope<'a, R>
+where
+    R: LookupSpan<'a>,
+{
+    type Item = SpanRef<'a, R>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        loop {
+            let curr = self.registry.span(self.next.as_ref()?)?;
+
+            #[cfg(all(feature = "registry", feature = "std"))]
+            let curr = curr.with_filter(self.filter);
+            self.next = curr.data.parent().cloned();
+
+            // If the `Scope` is filtered, check if the current span is enabled
+            // by the selected filter ID.
+
+            #[cfg(all(feature = "registry", feature = "std"))]
+            {
+                if !curr.is_enabled_for(self.filter) {
+                    // The current span in the chain is disabled for this
+                    // filter. Try its parent.
+                    continue;
+                }
+            }
+
+            return Some(curr);
+        }
+    }
+}
+
+impl<'a, R> SpanRef<'a, R>
+where
+    R: LookupSpan<'a>,
+{
+    /// Returns this span's ID.
+    pub fn id(&self) -> Id {
+        self.data.id()
+    }
+
+    /// Returns a static reference to the span's metadata.
+    pub fn metadata(&self) -> &'static Metadata<'static> {
+        self.data.metadata()
+    }
+
+    /// Returns the span's name,
+    pub fn name(&self) -> &'static str {
+        self.data.metadata().name()
+    }
+
+    /// Returns a list of [fields] defined by the span.
+    ///
+    /// [fields]: https://docs.rs/tracing-core/latest/tracing_core/field/index.html
+    pub fn fields(&self) -> &FieldSet {
+        self.data.metadata().fields()
+    }
+
+    /// Returns a `SpanRef` describing this span's parent, or `None` if this
+    /// span is the root of its trace tree.
+    pub fn parent(&self) -> Option<Self> {
+        let id = self.data.parent()?;
+        let data = self.registry.span_data(id)?;
+
+        #[cfg(all(feature = "registry", feature = "std"))]
+        {
+            // move these into mut bindings if the registry feature is enabled,
+            // since they may be mutated in the loop.
+            let mut data = data;
+            loop {
+                // Is this parent enabled by our filter?
+                if data.is_enabled_for(self.filter) {
+                    return Some(Self {
+                        registry: self.registry,
+                        filter: self.filter,
+                        data,
+                    });
+                }
+
+                // It's not enabled. If the disabled span has a parent, try that!
+                let id = data.parent()?;
+                data = self.registry.span_data(id)?;
+            }
+        }
+
+        #[cfg(not(all(feature = "registry", feature = "std")))]
+        Some(Self {
+            registry: self.registry,
+            data,
+        })
+    }
+
+    /// Returns an iterator over all parents of this span, starting with this span,
+    /// ordered from leaf to root.
+    ///
+    /// The iterator will first return the span, then the span's immediate parent,
+    /// followed by that span's parent, and so on, until it reaches a root span.
+    ///
+    /// ```rust
+    /// use tracing::{span, Subscriber};
+    /// use tracing_subscriber::{
+    ///     layer::{Context, Layer},
+    ///     prelude::*,
+    ///     registry::LookupSpan,
+    /// };
+    ///
+    /// struct PrintingLayer;
+    /// impl<S> Layer<S> for PrintingLayer
+    /// where
+    ///     S: Subscriber + for<'lookup> LookupSpan<'lookup>,
+    /// {
+    ///     fn on_enter(&self, id: &span::Id, ctx: Context<S>) {
+    ///         let span = ctx.span(id).unwrap();
+    ///         let scope = span.scope().map(|span| span.name()).collect::<Vec<_>>();
+    ///         println!("Entering span: {:?}", scope);
+    ///     }
+    /// }
+    ///
+    /// tracing::subscriber::with_default(tracing_subscriber::registry().with(PrintingLayer), || {
+    ///     let _root = tracing::info_span!("root").entered();
+    ///     // Prints: Entering span: ["root"]
+    ///     let _child = tracing::info_span!("child").entered();
+    ///     // Prints: Entering span: ["child", "root"]
+    ///     let _leaf = tracing::info_span!("leaf").entered();
+    ///     // Prints: Entering span: ["leaf", "child", "root"]
+    /// });
+    /// ```
+    ///
+    /// If the opposite order (from the root to this span) is desired, calling [`Scope::from_root`] on
+    /// the returned iterator reverses the order.
+    ///
+    /// ```rust
+    /// # use tracing::{span, Subscriber};
+    /// # use tracing_subscriber::{
+    /// #     layer::{Context, Layer},
+    /// #     prelude::*,
+    /// #     registry::LookupSpan,
+    /// # };
+    /// # struct PrintingLayer;
+    /// impl<S> Layer<S> for PrintingLayer
+    /// where
+    ///     S: Subscriber + for<'lookup> LookupSpan<'lookup>,
+    /// {
+    ///     fn on_enter(&self, id: &span::Id, ctx: Context<S>) {
+    ///         let span = ctx.span(id).unwrap();
+    ///         let scope = span.scope().from_root().map(|span| span.name()).collect::<Vec<_>>();
+    ///         println!("Entering span: {:?}", scope);
+    ///     }
+    /// }
+    ///
+    /// tracing::subscriber::with_default(tracing_subscriber::registry().with(PrintingLayer), || {
+    ///     let _root = tracing::info_span!("root").entered();
+    ///     // Prints: Entering span: ["root"]
+    ///     let _child = tracing::info_span!("child").entered();
+    ///     // Prints: Entering span: ["root", "child"]
+    ///     let _leaf = tracing::info_span!("leaf").entered();
+    ///     // Prints: Entering span: ["root", "child", "leaf"]
+    /// });
+    /// ```
+    pub fn scope(&self) -> Scope<'a, R> {
+        Scope {
+            registry: self.registry,
+            next: Some(self.id()),
+
+            #[cfg(feature = "registry")]
+            filter: self.filter,
+        }
+    }
+
+    /// Returns a reference to this span's `Extensions`.
+    ///
+    /// The extensions may be used by `Layer`s to store additional data
+    /// describing the span.
+    #[cfg(feature = "std")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
+    pub fn extensions(&self) -> Extensions<'_> {
+        self.data.extensions()
+    }
+
+    /// Returns a mutable reference to this span's `Extensions`.
+    ///
+    /// The extensions may be used by `Layer`s to store additional data
+    /// describing the span.
+    #[cfg(feature = "std")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
+    pub fn extensions_mut(&self) -> ExtensionsMut<'_> {
+        self.data.extensions_mut()
+    }
+
+    #[cfg(all(feature = "registry", feature = "std"))]
+    pub(crate) fn try_with_filter(self, filter: FilterId) -> Option<Self> {
+        if self.is_enabled_for(filter) {
+            return Some(self.with_filter(filter));
+        }
+
+        None
+    }
+
+    #[inline]
+    #[cfg(all(feature = "registry", feature = "std"))]
+    pub(crate) fn is_enabled_for(&self, filter: FilterId) -> bool {
+        self.data.is_enabled_for(filter)
+    }
+
+    #[inline]
+    #[cfg(all(feature = "registry", feature = "std"))]
+    fn with_filter(self, filter: FilterId) -> Self {
+        Self { filter, ..self }
+    }
+}
+
+#[cfg(all(test, feature = "registry", feature = "std"))]
+mod tests {
+    use crate::{
+        layer::{Context, Layer},
+        prelude::*,
+        registry::LookupSpan,
+    };
+    use std::sync::{Arc, Mutex};
+    use tracing::{span, Subscriber};
+
+    #[test]
+    fn spanref_scope_iteration_order() {
+        let last_entered_scope = Arc::new(Mutex::new(Vec::new()));
+
+        #[derive(Default)]
+        struct PrintingLayer {
+            last_entered_scope: Arc<Mutex<Vec<&'static str>>>,
+        }
+
+        impl<S> Layer<S> for PrintingLayer
+        where
+            S: Subscriber + for<'lookup> LookupSpan<'lookup>,
+        {
+            fn on_enter(&self, id: &span::Id, ctx: Context<'_, S>) {
+                let span = ctx.span(id).unwrap();
+                let scope = span.scope().map(|span| span.name()).collect::<Vec<_>>();
+                *self.last_entered_scope.lock().unwrap() = scope;
+            }
+        }
+
+        let _guard = tracing::subscriber::set_default(crate::registry().with(PrintingLayer {
+            last_entered_scope: last_entered_scope.clone(),
+        }));
+
+        let _root = tracing::info_span!("root").entered();
+        assert_eq!(&*last_entered_scope.lock().unwrap(), &["root"]);
+        let _child = tracing::info_span!("child").entered();
+        assert_eq!(&*last_entered_scope.lock().unwrap(), &["child", "root"]);
+        let _leaf = tracing::info_span!("leaf").entered();
+        assert_eq!(
+            &*last_entered_scope.lock().unwrap(),
+            &["leaf", "child", "root"]
+        );
+    }
+
+    #[test]
+    fn spanref_scope_fromroot_iteration_order() {
+        let last_entered_scope = Arc::new(Mutex::new(Vec::new()));
+
+        #[derive(Default)]
+        struct PrintingLayer {
+            last_entered_scope: Arc<Mutex<Vec<&'static str>>>,
+        }
+
+        impl<S> Layer<S> for PrintingLayer
+        where
+            S: Subscriber + for<'lookup> LookupSpan<'lookup>,
+        {
+            fn on_enter(&self, id: &span::Id, ctx: Context<'_, S>) {
+                let span = ctx.span(id).unwrap();
+                let scope = span
+                    .scope()
+                    .from_root()
+                    .map(|span| span.name())
+                    .collect::<Vec<_>>();
+                *self.last_entered_scope.lock().unwrap() = scope;
+            }
+        }
+
+        let _guard = tracing::subscriber::set_default(crate::registry().with(PrintingLayer {
+            last_entered_scope: last_entered_scope.clone(),
+        }));
+
+        let _root = tracing::info_span!("root").entered();
+        assert_eq!(&*last_entered_scope.lock().unwrap(), &["root"]);
+        let _child = tracing::info_span!("child").entered();
+        assert_eq!(&*last_entered_scope.lock().unwrap(), &["root", "child",]);
+        let _leaf = tracing::info_span!("leaf").entered();
+        assert_eq!(
+            &*last_entered_scope.lock().unwrap(),
+            &["root", "child", "leaf"]
+        );
+    }
+}
diff --git a/vendor/tracing-subscriber-0.3.3/src/registry/sharded.rs b/vendor/tracing-subscriber-0.3.3/src/registry/sharded.rs
new file mode 100644
index 000000000..a6311cb71
--- /dev/null
+++ b/vendor/tracing-subscriber-0.3.3/src/registry/sharded.rs
@@ -0,0 +1,904 @@
+use sharded_slab::{pool::Ref, Clear, Pool};
+use thread_local::ThreadLocal;
+
+use super::stack::SpanStack;
+use crate::{
+    filter::{FilterId, FilterMap, FilterState},
+    registry::{
+        extensions::{Extensions, ExtensionsInner, ExtensionsMut},
+        LookupSpan, SpanData,
+    },
+    sync::RwLock,
+};
+use std::{
+    cell::{self, Cell, RefCell},
+    sync::atomic::{fence, AtomicUsize, Ordering},
+};
+use tracing_core::{
+    dispatcher::{self, Dispatch},
+    span::{self, Current, Id},
+    Event, Interest, Metadata, Subscriber,
+};
+
+/// A shared, reusable store for spans.
+///
+/// A `Registry` is a [`Subscriber`] around which multiple [`Layer`]s
+/// implementing various behaviors may be [added]. Unlike other types
+/// implementing `Subscriber`, `Registry` does not actually record traces itself:
+/// instead, it collects and stores span data that is exposed to any [`Layer`]s
+/// wrapping it through implementations of the [`LookupSpan`] trait.
+/// The `Registry` is responsible for storing span metadata, recording
+/// relationships between spans, and tracking which spans are active and which
+/// are closed. In addition, it provides a mechanism for [`Layer`]s to store
+/// user-defined per-span data, called [extensions], in the registry. This
+/// allows [`Layer`]-specific data to benefit from the `Registry`'s
+/// high-performance concurrent storage.
+///
+/// This registry is implemented using a [lock-free sharded slab][slab], and is
+/// highly optimized for concurrent access.
+///
+/// # Span ID Generation
+///
+/// Span IDs are not globally unique, but the registry ensures that
+/// no two currently active spans have the same ID within a process.
+///
+/// One of the primary responsibilities of the registry is to generate [span
+/// IDs]. Therefore, it's important for other code that interacts with the
+/// registry, such as [`Layer`]s, to understand the guarantees of the
+/// span IDs that are generated.
+///
+/// The registry's span IDs are guaranteed to be unique **at a given point
+/// in time**. This means that an active span will never be assigned the
+/// same ID as another **currently active** span. However, the registry
+/// **will** eventually reuse the IDs of [closed] spans, although an ID
+/// will never be reassigned immediately after a span has closed.
+///
+/// Spans are not [considered closed] by the `Registry` until *every*
+/// [`Span`] reference with that ID has been dropped.
+///
+/// Thus: span IDs generated by the registry should be considered unique
+/// only at a given point in time, and only relative to other spans
+/// generated by the same process. Two spans with the same ID will not exist
+/// in the same process concurrently. However, if historical span data is
+/// being stored, the same ID may occur for multiple spans times in that
+/// data. If spans must be uniquely identified in historical data, the user
+/// code storing this data must assign its own unique identifiers to those
+/// spans. A counter is generally sufficient for this.
+///
+/// Similarly, span IDs generated by the registry are not unique outside of
+/// a given process. Distributed tracing systems may require identifiers
+/// that are unique across multiple processes on multiple machines (for
+/// example, [OpenTelemetry's `SpanId`s and `TraceId`s][ot]). `tracing` span
+/// IDs generated by the registry should **not** be used for this purpose.
+/// Instead, code which integrates with a distributed tracing system should
+/// generate and propagate its own IDs according to the rules specified by
+/// the distributed tracing system. These IDs can be associated with
+/// `tracing` spans using [fields] and/or [stored span data].
+///
+/// [span IDs]: https://docs.rs/tracing-core/latest/tracing_core/span/struct.Id.html
+/// [slab]: https://docs.rs/crate/sharded-slab/
+/// [`Layer`]: crate::Layer
+/// [added]: crate::layer::Layer#composing-layers
+/// [extensions]: super::Extensions
+/// [closed]: https://docs.rs/tracing/latest/tracing/span/index.html#closing-spans
+/// [considered closed]: https://docs.rs/tracing-core/latest/tracing_core/subscriber/trait.Subscriber.html#method.try_close
+/// [`Span`]: https://docs.rs/tracing/latest/tracing/span/struct.Span.html
+/// [ot]: https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/trace/api.md#spancontext
+/// [fields]: https://docs.rs/tracing-core/latest/tracing-core/field/index.html
+/// [stored span data]: crate::registry::SpanData::extensions_mut
+#[cfg(feature = "registry")]
+#[cfg_attr(docsrs, doc(cfg(all(feature = "registry", feature = "std"))))]
+#[derive(Debug)]
+pub struct Registry {
+    spans: Pool<DataInner>,
+    current_spans: ThreadLocal<RefCell<SpanStack>>,
+    next_filter_id: u8,
+}
+
+/// Span data stored in a [`Registry`].
+///
+/// The registry stores well-known data defined by tracing: span relationships,
+/// metadata and reference counts. Additional user-defined data provided by
+/// [`Layer`s], such as formatted fields, metrics, or distributed traces should
+/// be stored in the [extensions] typemap.
+///
+/// [`Registry`]: struct.Registry.html
+/// [`Layer`s]: ../layer/trait.Layer.html
+/// [extensions]: struct.Extensions.html
+#[cfg(feature = "registry")]
+#[cfg_attr(docsrs, doc(cfg(all(feature = "registry", feature = "std"))))]
+#[derive(Debug)]
+pub struct Data<'a> {
+    /// Immutable reference to the pooled `DataInner` entry.
+    inner: Ref<'a, DataInner>,
+}
+
+/// Stored data associated with a span.
+///
+/// This type is pooled using `sharded_slab::Pool`; when a span is dropped, the
+/// `DataInner` entry at that span's slab index is cleared in place and reused
+/// by a future span. Thus, the `Default` and `sharded_slab::Clear`
+/// implementations for this type are load-bearing.
+#[derive(Debug)]
+struct DataInner {
+    filter_map: FilterMap,
+    metadata: &'static Metadata<'static>,
+    parent: Option<Id>,
+    ref_count: AtomicUsize,
+    // The span's `Extensions` typemap. Allocations for the `HashMap` backing
+    // this are pooled and reused in place.
+    pub(crate) extensions: RwLock<ExtensionsInner>,
+}
+
+// === impl Registry ===
+
+impl Default for Registry {
+    fn default() -> Self {
+        Self {
+            spans: Pool::new(),
+            current_spans: ThreadLocal::new(),
+            next_filter_id: 0,
+        }
+    }
+}
+
+#[inline]
+fn idx_to_id(idx: usize) -> Id {
+    Id::from_u64(idx as u64 + 1)
+}
+
+#[inline]
+fn id_to_idx(id: &Id) -> usize {
+    id.into_u64() as usize - 1
+}
+
+/// A guard that tracks how many [`Registry`]-backed `Layer`s have
+/// processed an `on_close` event.
+///
+/// This is needed to enable a [`Registry`]-backed Layer to access span
+/// data after the `Layer` has recieved the `on_close` callback.
+///
+/// Once all `Layer`s have processed this event, the [`Registry`] knows
+/// that is able to safely remove the span tracked by `id`. `CloseGuard`
+/// accomplishes this through a two-step process:
+/// 1. Whenever a [`Registry`]-backed `Layer::on_close` method is
+///    called, `Registry::start_close` is closed.
+///    `Registry::start_close` increments a thread-local `CLOSE_COUNT`
+///    by 1 and returns a `CloseGuard`.
+/// 2. The `CloseGuard` is dropped at the end of `Layer::on_close`. On
+///    drop, `CloseGuard` checks thread-local `CLOSE_COUNT`. If
+///    `CLOSE_COUNT` is 0, the `CloseGuard` removes the span with the
+///    `id` from the registry, as all `Layers` that might have seen the
+///    `on_close` notification have processed it. If `CLOSE_COUNT` is
+///    greater than 0, `CloseGuard` decrements the counter by one and
+///    _does not_ remove the span from the [`Registry`].
+///
+/// [`Registry`]: ./struct.Registry.html
+pub(crate) struct CloseGuard<'a> {
+    id: Id,
+    registry: &'a Registry,
+    is_closing: bool,
+}
+
+impl Registry {
+    fn get(&self, id: &Id) -> Option<Ref<'_, DataInner>> {
+        self.spans.get(id_to_idx(id))
+    }
+
+    /// Returns a guard which tracks how many `Layer`s have
+    /// processed an `on_close` notification via the `CLOSE_COUNT` thread-local.
+    /// For additional details, see [`CloseGuard`].
+    ///
+    /// [`CloseGuard`]: ./struct.CloseGuard.html
+    pub(crate) fn start_close(&self, id: Id) -> CloseGuard<'_> {
+        CLOSE_COUNT.with(|count| {
+            let c = count.get();
+            count.set(c + 1);
+        });
+        CloseGuard {
+            id,
+            registry: self,
+            is_closing: false,
+        }
+    }
+
+    pub(crate) fn has_per_layer_filters(&self) -> bool {
+        self.next_filter_id > 0
+    }
+
+    pub(crate) fn span_stack(&self) -> cell::Ref<'_, SpanStack> {
+        self.current_spans.get_or_default().borrow()
+    }
+}
+
+thread_local! {
+    /// `CLOSE_COUNT` is the thread-local counter used by `CloseGuard` to
+    /// track how many layers have processed the close.
+    /// For additional details, see [`CloseGuard`].
+    ///
+    /// [`CloseGuard`]: ./struct.CloseGuard.html
+    static CLOSE_COUNT: Cell<usize> = Cell::new(0);
+}
+
+impl Subscriber for Registry {
+    fn register_callsite(&self, _: &'static Metadata<'static>) -> Interest {
+        if self.has_per_layer_filters() {
+            return FilterState::take_interest().unwrap_or_else(Interest::always);
+        }
+
+        Interest::always()
+    }
+
+    fn enabled(&self, _: &Metadata<'_>) -> bool {
+        if self.has_per_layer_filters() {
+            return FilterState::event_enabled();
+        }
+        true
+    }
+
+    #[inline]
+    fn new_span(&self, attrs: &span::Attributes<'_>) -> span::Id {
+        let parent = if attrs.is_root() {
+            None
+        } else if attrs.is_contextual() {
+            self.current_span().id().map(|id| self.clone_span(id))
+        } else {
+            attrs.parent().map(|id| self.clone_span(id))
+        };
+
+        let id = self
+            .spans
+            // Check out a `DataInner` entry from the pool for the new span. If
+            // there are free entries already allocated in the pool, this will
+            // preferentially reuse one; otherwise, a new `DataInner` is
+            // allocated and added to the pool.
+            .create_with(|data| {
+                data.metadata = attrs.metadata();
+                data.parent = parent;
+                data.filter_map = crate::filter::FILTERING.with(|filtering| filtering.filter_map());
+                #[cfg(debug_assertions)]
+                {
+                    if data.filter_map != FilterMap::default() {
+                        debug_assert!(self.has_per_layer_filters());
+                    }
+                }
+
+                let refs = data.ref_count.get_mut();
+                debug_assert_eq!(*refs, 0);
+                *refs = 1;
+            })
+            .expect("Unable to allocate another span");
+        idx_to_id(id)
+    }
+
+    /// This is intentionally not implemented, as recording fields
+    /// on a span is the responsibility of layers atop of this registry.
+    #[inline]
+    fn record(&self, _: &span::Id, _: &span::Record<'_>) {}
+
+    fn record_follows_from(&self, _span: &span::Id, _follows: &span::Id) {}
+
+    /// This is intentionally not implemented, as recording events
+    /// is the responsibility of layers atop of this registry.
+    fn event(&self, _: &Event<'_>) {}
+
+    fn enter(&self, id: &span::Id) {
+        if self
+            .current_spans
+            .get_or_default()
+            .borrow_mut()
+            .push(id.clone())
+        {
+            self.clone_span(id);
+        }
+    }
+
+    fn exit(&self, id: &span::Id) {
+        if let Some(spans) = self.current_spans.get() {
+            if spans.borrow_mut().pop(id) {
+                dispatcher::get_default(|dispatch| dispatch.try_close(id.clone()));
+            }
+        }
+    }
+
+    fn clone_span(&self, id: &span::Id) -> span::Id {
+        let span = self
+            .get(id)
+            .unwrap_or_else(|| panic!(
+                "tried to clone {:?}, but no span exists with that ID\n\
+                This may be caused by consuming a parent span (`parent: span`) rather than borrowing it (`parent: &span`).",
+                id,
+            ));
+        // Like `std::sync::Arc`, adds to the ref count (on clone) don't require
+        // a strong ordering; if we call` clone_span`, the reference count must
+        // always at least 1. The only synchronization necessary is between
+        // calls to `try_close`: we have to ensure that all threads have
+        // dropped their refs to the span before the span is closed.
+        let refs = span.ref_count.fetch_add(1, Ordering::Relaxed);
+        assert_ne!(
+            refs, 0,
+            "tried to clone a span ({:?}) that already closed",
+            id
+        );
+        id.clone()
+    }
+
+    fn current_span(&self) -> Current {
+        self.current_spans
+            .get()
+            .and_then(|spans| {
+                let spans = spans.borrow();
+                let id = spans.current()?;
+                let span = self.get(id)?;
+                Some(Current::new(id.clone(), span.metadata))
+            })
+            .unwrap_or_else(Current::none)
+    }
+
+    /// Decrements the reference count of the span with the given `id`, and
+    /// removes the span if it is zero.
+    ///
+    /// The allocated span slot will be reused when a new span is created.
+    fn try_close(&self, id: span::Id) -> bool {
+        let span = match self.get(&id) {
+            Some(span) => span,
+            None if std::thread::panicking() => return false,
+            None => panic!("tried to drop a ref to {:?}, but no such span exists!", id),
+        };
+
+        let refs = span.ref_count.fetch_sub(1, Ordering::Release);
+        if !std::thread::panicking() {
+            assert!(refs < std::usize::MAX, "reference count overflow!");
+        }
+        if refs > 1 {
+            return false;
+        }
+
+        // Synchronize if we are actually removing the span (stolen
+        // from std::Arc); this ensures that all other `try_close` calls on
+        // other threads happen-before we actually remove the span.
+        fence(Ordering::Acquire);
+        true
+    }
+}
+
+impl<'a> LookupSpan<'a> for Registry {
+    type Data = Data<'a>;
+
+    fn span_data(&'a self, id: &Id) -> Option<Self::Data> {
+        let inner = self.get(id)?;
+        Some(Data { inner })
+    }
+
+    fn register_filter(&mut self) -> FilterId {
+        let id = FilterId::new(self.next_filter_id);
+        self.next_filter_id += 1;
+        id
+    }
+}
+
+// === impl CloseGuard ===
+
+impl<'a> CloseGuard<'a> {
+    pub(crate) fn is_closing(&mut self) {
+        self.is_closing = true;
+    }
+}
+
+impl<'a> Drop for CloseGuard<'a> {
+    fn drop(&mut self) {
+        // If this returns with an error, we are already panicking. At
+        // this point, there's nothing we can really do to recover
+        // except by avoiding a double-panic.
+        let _ = CLOSE_COUNT.try_with(|count| {
+            let c = count.get();
+            // Decrement the count to indicate that _this_ guard's
+            // `on_close` callback has completed.
+            //
+            // Note that we *must* do this before we actually remove the span
+            // from the registry, since dropping the `DataInner` may trigger a
+            // new close, if this span is the last reference to a parent span.
+            count.set(c - 1);
+
+            // If the current close count is 1, this stack frame is the last
+            // `on_close` call. If the span is closing, it's okay to remove the
+            // span.
+            if c == 1 && self.is_closing {
+                self.registry.spans.clear(id_to_idx(&self.id));
+            }
+        });
+    }
+}
+
+// === impl Data ===
+
+impl<'a> SpanData<'a> for Data<'a> {
+    fn id(&self) -> Id {
+        idx_to_id(self.inner.key())
+    }
+
+    fn metadata(&self) -> &'static Metadata<'static> {
+        (*self).inner.metadata
+    }
+
+    fn parent(&self) -> Option<&Id> {
+        self.inner.parent.as_ref()
+    }
+
+    fn extensions(&self) -> Extensions<'_> {
+        Extensions::new(self.inner.extensions.read().expect("Mutex poisoned"))
+    }
+
+    fn extensions_mut(&self) -> ExtensionsMut<'_> {
+        ExtensionsMut::new(self.inner.extensions.write().expect("Mutex poisoned"))
+    }
+
+    #[inline]
+    fn is_enabled_for(&self, filter: FilterId) -> bool {
+        self.inner.filter_map.is_enabled(filter)
+    }
+}
+
+// === impl DataInner ===
+
+impl Default for DataInner {
+    fn default() -> Self {
+        // Since `DataInner` owns a `&'static Callsite` pointer, we need
+        // something to use as the initial default value for that callsite.
+        // Since we can't access a `DataInner` until it has had actual span data
+        // inserted into it, the null metadata will never actually be accessed.
+        struct NullCallsite;
+        impl tracing_core::callsite::Callsite for NullCallsite {
+            fn set_interest(&self, _: Interest) {
+                unreachable!(
+                    "/!\\ Tried to register the null callsite /!\\\n \
+                    This should never have happened and is definitely a bug. \
+                    A `tracing` bug report would be appreciated."
+                )
+            }
+
+            fn metadata(&self) -> &Metadata<'_> {
+                unreachable!(
+                    "/!\\ Tried to access the null callsite's metadata /!\\\n \
+                    This should never have happened and is definitely a bug. \
+                    A `tracing` bug report would be appreciated."
+                )
+            }
+        }
+
+        static NULL_CALLSITE: NullCallsite = NullCallsite;
+        static NULL_METADATA: Metadata<'static> = tracing_core::metadata! {
+            name: "",
+            target: "",
+            level: tracing_core::Level::TRACE,
+            fields: &[],
+            callsite: &NULL_CALLSITE,
+            kind: tracing_core::metadata::Kind::SPAN,
+        };
+
+        Self {
+            filter_map: FilterMap::default(),
+            metadata: &NULL_METADATA,
+            parent: None,
+            ref_count: AtomicUsize::new(0),
+            extensions: RwLock::new(ExtensionsInner::new()),
+        }
+    }
+}
+
+impl Clear for DataInner {
+    /// Clears the span's data in place, dropping the parent's reference count.
+    fn clear(&mut self) {
+        // A span is not considered closed until all of its children have closed.
+        // Therefore, each span's `DataInner` holds a "reference" to the parent
+        // span, keeping the parent span open until all its children have closed.
+        // When we close a span, we must then decrement the parent's ref count
+        // (potentially, allowing it to close, if this child is the last reference
+        // to that span).
+        // We have to actually unpack the option inside the `get_default`
+        // closure, since it is a `FnMut`, but testing that there _is_ a value
+        // here lets us avoid the thread-local access if we don't need the
+        // dispatcher at all.
+        if self.parent.is_some() {
+            // Note that --- because `Layered::try_close` works by calling
+            // `try_close` on the inner subscriber and using the return value to
+            // determine whether to call the `Layer`'s `on_close` callback ---
+            // we must call `try_close` on the entire subscriber stack, rather
+            // than just on the registry. If the registry called `try_close` on
+            // itself directly, the layers wouldn't see the close notification.
+            let subscriber = dispatcher::get_default(Dispatch::clone);
+            if let Some(parent) = self.parent.take() {
+                let _ = subscriber.try_close(parent);
+            }
+        }
+
+        // Clear (but do not deallocate!) the pooled `HashMap` for the span's extensions.
+        self.extensions
+            .get_mut()
+            .unwrap_or_else(|l| {
+                // This function can be called in a `Drop` impl, such as while
+                // panicking, so ignore lock poisoning.
+                l.into_inner()
+            })
+            .clear();
+
+        self.filter_map = FilterMap::default();
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{layer::Context, registry::LookupSpan, Layer};
+    use std::{
+        collections::HashMap,
+        sync::{Arc, Mutex, Weak},
+    };
+    use tracing::{self, subscriber::with_default};
+    use tracing_core::{
+        dispatcher,
+        span::{Attributes, Id},
+        Subscriber,
+    };
+
+    #[derive(Debug)]
+    struct DoesNothing;
+    impl<S: Subscriber> Layer<S> for DoesNothing {}
+
+    struct AssertionLayer;
+    impl<S> Layer<S> for AssertionLayer
+    where
+        S: Subscriber + for<'a> LookupSpan<'a>,
+    {
+        fn on_close(&self, id: Id, ctx: Context<'_, S>) {
+            dbg!(format_args!("closing {:?}", id));
+            assert!(&ctx.span(&id).is_some());
+        }
+    }
+
+    #[test]
+    fn single_layer_can_access_closed_span() {
+        let subscriber = AssertionLayer.with_subscriber(Registry::default());
+
+        with_default(subscriber, || {
+            let span = tracing::debug_span!("span");
+            drop(span);
+        });
+    }
+
+    #[test]
+    fn multiple_layers_can_access_closed_span() {
+        let subscriber = AssertionLayer
+            .and_then(AssertionLayer)
+            .with_subscriber(Registry::default());
+
+        with_default(subscriber, || {
+            let span = tracing::debug_span!("span");
+            drop(span);
+        });
+    }
+
+    struct CloseLayer {
+        inner: Arc<Mutex<CloseState>>,
+    }
+
+    struct CloseHandle {
+        state: Arc<Mutex<CloseState>>,
+    }
+
+    #[derive(Default)]
+    struct CloseState {
+        open: HashMap<&'static str, Weak<()>>,
+        closed: Vec<(&'static str, Weak<()>)>,
+    }
+
+    struct SetRemoved(Arc<()>);
+
+    impl<S> Layer<S> for CloseLayer
+    where
+        S: Subscriber + for<'a> LookupSpan<'a>,
+    {
+        fn on_new_span(&self, _: &Attributes<'_>, id: &Id, ctx: Context<'_, S>) {
+            let span = ctx.span(id).expect("Missing span; this is a bug");
+            let mut lock = self.inner.lock().unwrap();
+            let is_removed = Arc::new(());
+            assert!(
+                lock.open
+                    .insert(span.name(), Arc::downgrade(&is_removed))
+                    .is_none(),
+                "test layer saw multiple spans with the same name, the test is probably messed up"
+            );
+            let mut extensions = span.extensions_mut();
+            extensions.insert(SetRemoved(is_removed));
+        }
+
+        fn on_close(&self, id: Id, ctx: Context<'_, S>) {
+            let span = if let Some(span) = ctx.span(&id) {
+                span
+            } else {
+                println!(
+                    "span {:?} did not exist in `on_close`, are we panicking?",
+                    id
+                );
+                return;
+            };
+            let name = span.name();
+            println!("close {} ({:?})", name, id);
+            if let Ok(mut lock) = self.inner.lock() {
+                if let Some(is_removed) = lock.open.remove(name) {
+                    assert!(is_removed.upgrade().is_some());
+                    lock.closed.push((name, is_removed));
+                }
+            }
+        }
+    }
+
+    impl CloseLayer {
+        fn new() -> (Self, CloseHandle) {
+            let state = Arc::new(Mutex::new(CloseState::default()));
+            (
+                Self {
+                    inner: state.clone(),
+                },
+                CloseHandle { state },
+            )
+        }
+    }
+
+    impl CloseState {
+        fn is_open(&self, span: &str) -> bool {
+            self.open.contains_key(span)
+        }
+
+        fn is_closed(&self, span: &str) -> bool {
+            self.closed.iter().any(|(name, _)| name == &span)
+        }
+    }
+
+    impl CloseHandle {
+        fn assert_closed(&self, span: &str) {
+            let lock = self.state.lock().unwrap();
+            assert!(
+                lock.is_closed(span),
+                "expected {} to be closed{}",
+                span,
+                if lock.is_open(span) {
+                    " (it was still open)"
+                } else {
+                    ", but it never existed (is there a problem with the test?)"
+                }
+            )
+        }
+
+        fn assert_open(&self, span: &str) {
+            let lock = self.state.lock().unwrap();
+            assert!(
+                lock.is_open(span),
+                "expected {} to be open{}",
+                span,
+                if lock.is_closed(span) {
+                    " (it was still open)"
+                } else {
+                    ", but it never existed (is there a problem with the test?)"
+                }
+            )
+        }
+
+        fn assert_removed(&self, span: &str) {
+            let lock = self.state.lock().unwrap();
+            let is_removed = match lock.closed.iter().find(|(name, _)| name == &span) {
+                Some((_, is_removed)) => is_removed,
+                None => panic!(
+                    "expected {} to be removed from the registry, but it was not closed {}",
+                    span,
+                    if lock.is_closed(span) {
+                        " (it was still open)"
+                    } else {
+                        ", but it never existed (is there a problem with the test?)"
+                    }
+                ),
+            };
+            assert!(
+                is_removed.upgrade().is_none(),
+                "expected {} to have been removed from the registry",
+                span
+            )
+        }
+
+        fn assert_not_removed(&self, span: &str) {
+            let lock = self.state.lock().unwrap();
+            let is_removed = match lock.closed.iter().find(|(name, _)| name == &span) {
+                Some((_, is_removed)) => is_removed,
+                None if lock.is_open(span) => return,
+                None => unreachable!(),
+            };
+            assert!(
+                is_removed.upgrade().is_some(),
+                "expected {} to have been removed from the registry",
+                span
+            )
+        }
+
+        #[allow(unused)] // may want this for future tests
+        fn assert_last_closed(&self, span: Option<&str>) {
+            let lock = self.state.lock().unwrap();
+            let last = lock.closed.last().map(|(span, _)| span);
+            assert_eq!(
+                last,
+                span.as_ref(),
+                "expected {:?} to have closed last",
+                span
+            );
+        }
+
+        fn assert_closed_in_order(&self, order: impl AsRef<[&'static str]>) {
+            let lock = self.state.lock().unwrap();
+            let order = order.as_ref();
+            for (i, name) in order.iter().enumerate() {
+                assert_eq!(
+                    lock.closed.get(i).map(|(span, _)| span),
+                    Some(name),
+                    "expected close order: {:?}, actual: {:?}",
+                    order,
+                    lock.closed.iter().map(|(name, _)| name).collect::<Vec<_>>()
+                );
+            }
+        }
+    }
+
+    #[test]
+    fn spans_are_removed_from_registry() {
+        let (close_layer, state) = CloseLayer::new();
+        let subscriber = AssertionLayer
+            .and_then(close_layer)
+            .with_subscriber(Registry::default());
+
+        // Create a `Dispatch` (which is internally reference counted) so that
+        // the subscriber lives to the end of the test. Otherwise, if we just
+        // passed the subscriber itself to `with_default`, we could see the span
+        // be dropped when the subscriber itself is dropped, destroying the
+        // registry.
+        let dispatch = dispatcher::Dispatch::new(subscriber);
+
+        dispatcher::with_default(&dispatch, || {
+            let span = tracing::debug_span!("span1");
+            drop(span);
+            let span = tracing::info_span!("span2");
+            drop(span);
+        });
+
+        state.assert_removed("span1");
+        state.assert_removed("span2");
+
+        // Ensure the registry itself outlives the span.
+        drop(dispatch);
+    }
+
+    #[test]
+    fn spans_are_only_closed_when_the_last_ref_drops() {
+        let (close_layer, state) = CloseLayer::new();
+        let subscriber = AssertionLayer
+            .and_then(close_layer)
+            .with_subscriber(Registry::default());
+
+        // Create a `Dispatch` (which is internally reference counted) so that
+        // the subscriber lives to the end of the test. Otherwise, if we just
+        // passed the subscriber itself to `with_default`, we could see the span
+        // be dropped when the subscriber itself is dropped, destroying the
+        // registry.
+        let dispatch = dispatcher::Dispatch::new(subscriber);
+
+        let span2 = dispatcher::with_default(&dispatch, || {
+            let span = tracing::debug_span!("span1");
+            drop(span);
+            let span2 = tracing::info_span!("span2");
+            let span2_clone = span2.clone();
+            drop(span2);
+            span2_clone
+        });
+
+        state.assert_removed("span1");
+        state.assert_not_removed("span2");
+
+        drop(span2);
+        state.assert_removed("span1");
+
+        // Ensure the registry itself outlives the span.
+        drop(dispatch);
+    }
+
+    #[test]
+    fn span_enter_guards_are_dropped_out_of_order() {
+        let (close_layer, state) = CloseLayer::new();
+        let subscriber = AssertionLayer
+            .and_then(close_layer)
+            .with_subscriber(Registry::default());
+
+        // Create a `Dispatch` (which is internally reference counted) so that
+        // the subscriber lives to the end of the test. Otherwise, if we just
+        // passed the subscriber itself to `with_default`, we could see the span
+        // be dropped when the subscriber itself is dropped, destroying the
+        // registry.
+        let dispatch = dispatcher::Dispatch::new(subscriber);
+
+        dispatcher::with_default(&dispatch, || {
+            let span1 = tracing::debug_span!("span1");
+            let span2 = tracing::info_span!("span2");
+
+            let enter1 = span1.enter();
+            let enter2 = span2.enter();
+
+            drop(enter1);
+            drop(span1);
+
+            state.assert_removed("span1");
+            state.assert_not_removed("span2");
+
+            drop(enter2);
+            state.assert_not_removed("span2");
+
+            drop(span2);
+            state.assert_removed("span1");
+            state.assert_removed("span2");
+        });
+    }
+
+    #[test]
+    fn child_closes_parent() {
+        // This test asserts that if a parent span's handle is dropped before
+        // a child span's handle, the parent will remain open until child
+        // closes, and will then be closed.
+
+        let (close_layer, state) = CloseLayer::new();
+        let subscriber = close_layer.with_subscriber(Registry::default());
+
+        let dispatch = dispatcher::Dispatch::new(subscriber);
+
+        dispatcher::with_default(&dispatch, || {
+            let span1 = tracing::info_span!("parent");
+            let span2 = tracing::info_span!(parent: &span1, "child");
+
+            state.assert_open("parent");
+            state.assert_open("child");
+
+            drop(span1);
+            state.assert_open("parent");
+            state.assert_open("child");
+
+            drop(span2);
+            state.assert_closed("parent");
+            state.assert_closed("child");
+        });
+    }
+
+    #[test]
+    fn child_closes_grandparent() {
+        // This test asserts that, when a span is kept open by a child which
+        // is *itself* kept open by a child, closing the grandchild will close
+        // both the parent *and* the grandparent.
+        let (close_layer, state) = CloseLayer::new();
+        let subscriber = close_layer.with_subscriber(Registry::default());
+
+        let dispatch = dispatcher::Dispatch::new(subscriber);
+
+        dispatcher::with_default(&dispatch, || {
+            let span1 = tracing::info_span!("grandparent");
+            let span2 = tracing::info_span!(parent: &span1, "parent");
+            let span3 = tracing::info_span!(parent: &span2, "child");
+
+            state.assert_open("grandparent");
+            state.assert_open("parent");
+            state.assert_open("child");
+
+            drop(span1);
+            drop(span2);
+            state.assert_open("grandparent");
+            state.assert_open("parent");
+            state.assert_open("child");
+
+            drop(span3);
+
+            state.assert_closed_in_order(&["child", "parent", "grandparent"]);
+        });
+    }
+}
diff --git a/vendor/tracing-subscriber-0.3.3/src/registry/stack.rs b/vendor/tracing-subscriber-0.3.3/src/registry/stack.rs
new file mode 100644
index 000000000..4a3f7e59d
--- /dev/null
+++ b/vendor/tracing-subscriber-0.3.3/src/registry/stack.rs
@@ -0,0 +1,77 @@
+pub(crate) use tracing_core::span::Id;
+
+#[derive(Debug)]
+struct ContextId {
+    id: Id,
+    duplicate: bool,
+}
+
+/// `SpanStack` tracks what spans are currently executing on a thread-local basis.
+///
+/// A "separate current span" for each thread is a semantic choice, as each span
+/// can be executing in a different thread.
+#[derive(Debug, Default)]
+pub(crate) struct SpanStack {
+    stack: Vec<ContextId>,
+}
+
+impl SpanStack {
+    #[inline]
+    pub(super) fn push(&mut self, id: Id) -> bool {
+        let duplicate = self.stack.iter().any(|i| i.id == id);
+        self.stack.push(ContextId { id, duplicate });
+        !duplicate
+    }
+
+    #[inline]
+    pub(super) fn pop(&mut self, expected_id: &Id) -> bool {
+        if let Some((idx, _)) = self
+            .stack
+            .iter()
+            .enumerate()
+            .rev()
+            .find(|(_, ctx_id)| ctx_id.id == *expected_id)
+        {
+            let ContextId { id: _, duplicate } = self.stack.remove(idx);
+            return !duplicate;
+        }
+        false
+    }
+
+    #[inline]
+    pub(crate) fn iter(&self) -> impl Iterator<Item = &Id> {
+        self.stack
+            .iter()
+            .rev()
+            .filter_map(|ContextId { id, duplicate }| if !*duplicate { Some(id) } else { None })
+    }
+
+    #[inline]
+    pub(crate) fn current(&self) -> Option<&Id> {
+        self.iter().next()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{Id, SpanStack};
+
+    #[test]
+    fn pop_last_span() {
+        let mut stack = SpanStack::default();
+        let id = Id::from_u64(1);
+        stack.push(id.clone());
+
+        assert!(stack.pop(&id));
+    }
+
+    #[test]
+    fn pop_first_span() {
+        let mut stack = SpanStack::default();
+        stack.push(Id::from_u64(1));
+        stack.push(Id::from_u64(2));
+
+        let id = Id::from_u64(1);
+        assert!(stack.pop(&id));
+    }
+}
diff --git a/vendor/tracing-subscriber-0.3.3/src/reload.rs b/vendor/tracing-subscriber-0.3.3/src/reload.rs
new file mode 100644
index 000000000..b8ec67dfa
--- /dev/null
+++ b/vendor/tracing-subscriber-0.3.3/src/reload.rs
@@ -0,0 +1,237 @@
+//! Wrapper for a `Layer` to allow it to be dynamically reloaded.
+//!
+//! This module provides a [`Layer` type] which wraps another type implementing
+//! the [`Layer` trait], allowing the wrapped type to be replaced with another
+//! instance of that type at runtime.
+//!
+//! This can be used in cases where a subset of `Subscriber` functionality
+//! should be dynamically reconfigured, such as when filtering directives may
+//! change at runtime. Note that this layer introduces a (relatively small)
+//! amount of overhead, and should thus only be used as needed.
+//!
+//! [`Layer` type]: struct.Layer.html
+//! [`Layer` trait]: ../layer/trait.Layer.html
+use crate::layer;
+use crate::sync::RwLock;
+
+use std::{
+    error, fmt,
+    marker::PhantomData,
+    sync::{Arc, Weak},
+};
+use tracing_core::{
+    callsite, span,
+    subscriber::{Interest, Subscriber},
+    Event, Metadata,
+};
+
+/// Wraps a `Layer`, allowing it to be reloaded dynamically at runtime.
+#[derive(Debug)]
+pub struct Layer<L, S> {
+    // TODO(eliza): this once used a `crossbeam_util::ShardedRwLock`. We may
+    // eventually wish to replace it with a sharded lock implementation on top
+    // of our internal `RwLock` wrapper type. If possible, we should profile
+    // this first to determine if it's necessary.
+    inner: Arc<RwLock<L>>,
+    _s: PhantomData<fn(S)>,
+}
+
+/// Allows reloading the state of an associated `Layer`.
+#[derive(Debug)]
+pub struct Handle<L, S> {
+    inner: Weak<RwLock<L>>,
+    _s: PhantomData<fn(S)>,
+}
+
+/// Indicates that an error occurred when reloading a layer.
+#[derive(Debug)]
+pub struct Error {
+    kind: ErrorKind,
+}
+
+#[derive(Debug)]
+enum ErrorKind {
+    SubscriberGone,
+    Poisoned,
+}
+
+// ===== impl Layer =====
+
+impl<L, S> crate::Layer<S> for Layer<L, S>
+where
+    L: crate::Layer<S> + 'static,
+    S: Subscriber,
+{
+    fn on_layer(&mut self, subscriber: &mut S) {
+        try_lock!(self.inner.write(), else return).on_layer(subscriber);
+    }
+
+    #[inline]
+    fn register_callsite(&self, metadata: &'static Metadata<'static>) -> Interest {
+        try_lock!(self.inner.read(), else return Interest::sometimes()).register_callsite(metadata)
+    }
+
+    #[inline]
+    fn enabled(&self, metadata: &Metadata<'_>, ctx: layer::Context<'_, S>) -> bool {
+        try_lock!(self.inner.read(), else return false).enabled(metadata, ctx)
+    }
+
+    #[inline]
+    fn on_new_span(&self, attrs: &span::Attributes<'_>, id: &span::Id, ctx: layer::Context<'_, S>) {
+        try_lock!(self.inner.read()).on_new_span(attrs, id, ctx)
+    }
+
+    #[inline]
+    fn on_record(&self, span: &span::Id, values: &span::Record<'_>, ctx: layer::Context<'_, S>) {
+        try_lock!(self.inner.read()).on_record(span, values, ctx)
+    }
+
+    #[inline]
+    fn on_follows_from(&self, span: &span::Id, follows: &span::Id, ctx: layer::Context<'_, S>) {
+        try_lock!(self.inner.read()).on_follows_from(span, follows, ctx)
+    }
+
+    #[inline]
+    fn on_event(&self, event: &Event<'_>, ctx: layer::Context<'_, S>) {
+        try_lock!(self.inner.read()).on_event(event, ctx)
+    }
+
+    #[inline]
+    fn on_enter(&self, id: &span::Id, ctx: layer::Context<'_, S>) {
+        try_lock!(self.inner.read()).on_enter(id, ctx)
+    }
+
+    #[inline]
+    fn on_exit(&self, id: &span::Id, ctx: layer::Context<'_, S>) {
+        try_lock!(self.inner.read()).on_exit(id, ctx)
+    }
+
+    #[inline]
+    fn on_close(&self, id: span::Id, ctx: layer::Context<'_, S>) {
+        try_lock!(self.inner.read()).on_close(id, ctx)
+    }
+
+    #[inline]
+    fn on_id_change(&self, old: &span::Id, new: &span::Id, ctx: layer::Context<'_, S>) {
+        try_lock!(self.inner.read()).on_id_change(old, new, ctx)
+    }
+}
+
+impl<L, S> Layer<L, S>
+where
+    L: crate::Layer<S> + 'static,
+    S: Subscriber,
+{
+    /// Wraps the given `Layer`, returning a `Layer` and a `Handle` that allows
+    /// the inner type to be modified at runtime.
+    pub fn new(inner: L) -> (Self, Handle<L, S>) {
+        let this = Self {
+            inner: Arc::new(RwLock::new(inner)),
+            _s: PhantomData,
+        };
+        let handle = this.handle();
+        (this, handle)
+    }
+
+    /// Returns a `Handle` that can be used to reload the wrapped `Layer`.
+    pub fn handle(&self) -> Handle<L, S> {
+        Handle {
+            inner: Arc::downgrade(&self.inner),
+            _s: PhantomData,
+        }
+    }
+}
+
+// ===== impl Handle =====
+
+impl<L, S> Handle<L, S>
+where
+    L: crate::Layer<S> + 'static,
+    S: Subscriber,
+{
+    /// Replace the current layer with the provided `new_layer`.
+    pub fn reload(&self, new_layer: impl Into<L>) -> Result<(), Error> {
+        self.modify(|layer| {
+            *layer = new_layer.into();
+        })
+    }
+
+    /// Invokes a closure with a mutable reference to the current layer,
+    /// allowing it to be modified in place.
+    pub fn modify(&self, f: impl FnOnce(&mut L)) -> Result<(), Error> {
+        let inner = self.inner.upgrade().ok_or(Error {
+            kind: ErrorKind::SubscriberGone,
+        })?;
+
+        let mut lock = try_lock!(inner.write(), else return Err(Error::poisoned()));
+        f(&mut *lock);
+        // Release the lock before rebuilding the interest cache, as that
+        // function will lock the new layer.
+        drop(lock);
+
+        callsite::rebuild_interest_cache();
+        Ok(())
+    }
+
+    /// Returns a clone of the layer's current value if it still exists.
+    /// Otherwise, if the subscriber has been dropped, returns `None`.
+    pub fn clone_current(&self) -> Option<L>
+    where
+        L: Clone,
+    {
+        self.with_current(L::clone).ok()
+    }
+
+    /// Invokes a closure with a borrowed reference to the current layer,
+    /// returning the result (or an error if the subscriber no longer exists).
+    pub fn with_current<T>(&self, f: impl FnOnce(&L) -> T) -> Result<T, Error> {
+        let inner = self.inner.upgrade().ok_or(Error {
+            kind: ErrorKind::SubscriberGone,
+        })?;
+        let inner = try_lock!(inner.read(), else return Err(Error::poisoned()));
+        Ok(f(&*inner))
+    }
+}
+
+impl<L, S> Clone for Handle<L, S> {
+    fn clone(&self) -> Self {
+        Handle {
+            inner: self.inner.clone(),
+            _s: PhantomData,
+        }
+    }
+}
+
+// ===== impl Error =====
+
+impl Error {
+    fn poisoned() -> Self {
+        Self {
+            kind: ErrorKind::Poisoned,
+        }
+    }
+
+    /// Returns `true` if this error occurred because the layer was poisoned by
+    /// a panic on another thread.
+    pub fn is_poisoned(&self) -> bool {
+        matches!(self.kind, ErrorKind::Poisoned)
+    }
+
+    /// Returns `true` if this error occurred because the `Subscriber`
+    /// containing the reloadable layer was dropped.
+    pub fn is_dropped(&self) -> bool {
+        matches!(self.kind, ErrorKind::SubscriberGone)
+    }
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let msg = match self.kind {
+            ErrorKind::SubscriberGone => "subscriber no longer exists",
+            ErrorKind::Poisoned => "lock poisoned",
+        };
+        f.pad(msg)
+    }
+}
+
+impl error::Error for Error {}
diff --git a/vendor/tracing-subscriber-0.3.3/src/sync.rs b/vendor/tracing-subscriber-0.3.3/src/sync.rs
new file mode 100644
index 000000000..ec42b834a
--- /dev/null
+++ b/vendor/tracing-subscriber-0.3.3/src/sync.rs
@@ -0,0 +1,57 @@
+//! Abstracts over sync primitive implementations.
+//!
+//! Optionally, we allow the Rust standard library's `RwLock` to be replaced
+//! with the `parking_lot` crate's implementation. This may provide improved
+//! performance in some cases. However, the `parking_lot` dependency is an
+//! opt-in feature flag. Because `parking_lot::RwLock` has a slightly different
+//! API than `std::sync::RwLock` (it does not support poisoning on panics), we
+//! wrap it with a type that provides the same method signatures. This allows us
+//! to transparently swap `parking_lot` in without changing code at the callsite.
+#[allow(unused_imports)] // may be used later;
+pub(crate) use std::sync::{LockResult, PoisonError, TryLockResult};
+
+#[cfg(not(feature = "parking_lot"))]
+pub(crate) use std::sync::{RwLock, RwLockReadGuard, RwLockWriteGuard};
+
+#[cfg(feature = "parking_lot")]
+pub(crate) use self::parking_lot_impl::*;
+
+#[cfg(feature = "parking_lot")]
+mod parking_lot_impl {
+    pub(crate) use parking_lot::{RwLockReadGuard, RwLockWriteGuard};
+    use std::sync::{LockResult, TryLockError, TryLockResult};
+
+    #[derive(Debug)]
+    pub(crate) struct RwLock<T> {
+        inner: parking_lot::RwLock<T>,
+    }
+
+    impl<T> RwLock<T> {
+        pub(crate) fn new(val: T) -> Self {
+            Self {
+                inner: parking_lot::RwLock::new(val),
+            }
+        }
+
+        #[inline]
+        pub(crate) fn get_mut(&mut self) -> LockResult<&mut T> {
+            Ok(self.inner.get_mut())
+        }
+
+        #[inline]
+        pub(crate) fn read(&self) -> LockResult<RwLockReadGuard<'_, T>> {
+            Ok(self.inner.read())
+        }
+
+        #[inline]
+        #[allow(dead_code)] // may be used later;
+        pub(crate) fn try_read(&self) -> TryLockResult<RwLockReadGuard<'_, T>> {
+            self.inner.try_read().ok_or(TryLockError::WouldBlock)
+        }
+
+        #[inline]
+        pub(crate) fn write(&self) -> LockResult<RwLockWriteGuard<'_, T>> {
+            Ok(self.inner.write())
+        }
+    }
+}
diff --git a/vendor/tracing-subscriber-0.3.3/src/util.rs b/vendor/tracing-subscriber-0.3.3/src/util.rs
new file mode 100644
index 000000000..1c98aa4d2
--- /dev/null
+++ b/vendor/tracing-subscriber-0.3.3/src/util.rs
@@ -0,0 +1,153 @@
+//! Extension traits and other utilities to make working with subscribers more
+//! ergonomic.
+use core::fmt;
+#[cfg(feature = "std")]
+use std::error::Error;
+use tracing_core::dispatcher::{self, Dispatch};
+#[cfg(feature = "tracing-log")]
+use tracing_log::AsLog;
+
+/// Extension trait adding utility methods for subscriber initialization.
+///
+/// This trait provides extension methods to make configuring and setting a
+/// [default subscriber] more ergonomic. It is automatically implemented for all
+/// types that can be converted into a [trace dispatcher]. Since `Dispatch`
+/// implements `From<T>` for all `T: Subscriber`, all `Subscriber`
+/// implementations will implement this extension trait as well. Types which
+/// can be converted into `Subscriber`s, such as builders that construct a
+/// `Subscriber`, may implement `Into<Dispatch>`, and will also receive an
+/// implementation of this trait.
+///
+/// [default subscriber]: https://docs.rs/tracing/0.1.21/tracing/dispatcher/index.html#setting-the-default-subscriber
+/// [trace dispatcher]: https://docs.rs/tracing/0.1.21/tracing/dispatcher/index.html
+pub trait SubscriberInitExt
+where
+    Self: Into<Dispatch>,
+{
+    /// Sets `self` as the [default subscriber] in the current scope, returning a
+    /// guard that will unset it when dropped.
+    ///
+    /// If the "tracing-log" feature flag is enabled, this will also initialize
+    /// a [`log`] compatibility layer. This allows the subscriber to consume
+    /// `log::Record`s as though they were `tracing` `Event`s.
+    ///
+    /// [default subscriber]: https://docs.rs/tracing/0.1.21/tracing/dispatcher/index.html#setting-the-default-subscriber
+    /// [`log`]: https://crates.io/log
+    #[cfg(feature = "std")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
+    fn set_default(self) -> dispatcher::DefaultGuard {
+        #[cfg(feature = "tracing-log")]
+        let _ = tracing_log::LogTracer::init();
+
+        dispatcher::set_default(&self.into())
+    }
+
+    /// Attempts to set `self` as the [global default subscriber] in the current
+    /// scope, returning an error if one is already set.
+    ///
+    /// If the "tracing-log" feature flag is enabled, this will also attempt to
+    /// initialize a [`log`] compatibility layer. This allows the subscriber to
+    /// consume `log::Record`s as though they were `tracing` `Event`s.
+    ///
+    /// This method returns an error if a global default subscriber has already
+    /// been set, or if a `log` logger has already been set (when the
+    /// "tracing-log" feature is enabled).
+    ///
+    /// [global default subscriber]: https://docs.rs/tracing/0.1.21/tracing/dispatcher/index.html#setting-the-default-subscriber
+    /// [`log`]: https://crates.io/log
+    fn try_init(self) -> Result<(), TryInitError> {
+        dispatcher::set_global_default(self.into()).map_err(TryInitError::new)?;
+
+        // Since we are setting the global default subscriber, we can
+        // opportunistically go ahead and set its global max level hint as
+        // the max level for the `log` crate as well. This should make
+        // skipping `log` diagnostics much faster.
+        #[cfg(feature = "tracing-log")]
+        tracing_log::LogTracer::builder()
+            // Note that we must call this *after* setting the global default
+            // subscriber, so that we get its max level hint.
+            .with_max_level(tracing_core::LevelFilter::current().as_log())
+            .init()
+            .map_err(TryInitError::new)?;
+
+        Ok(())
+    }
+
+    /// Attempts to set `self` as the [global default subscriber] in the current
+    /// scope, panicking if this fails.
+    ///
+    /// If the "tracing-log" feature flag is enabled, this will also attempt to
+    /// initialize a [`log`] compatibility layer. This allows the subscriber to
+    /// consume `log::Record`s as though they were `tracing` `Event`s.
+    ///
+    /// This method panics if a global default subscriber has already been set,
+    /// or if a `log` logger has already been set (when the "tracing-log"
+    /// feature is enabled).
+    ///
+    /// [global default subscriber]: https://docs.rs/tracing/0.1.21/tracing/dispatcher/index.html#setting-the-default-subscriber
+    /// [`log`]: https://crates.io/log
+    fn init(self) {
+        self.try_init()
+            .expect("failed to set global default subscriber")
+    }
+}
+
+impl<T> SubscriberInitExt for T where T: Into<Dispatch> {}
+
+/// Error returned by [`try_init`](SubscriberInitExt::try_init) if a global default subscriber could not be initialized.
+pub struct TryInitError {
+    #[cfg(feature = "std")]
+    inner: Box<dyn Error + Send + Sync + 'static>,
+
+    #[cfg(not(feature = "std"))]
+    _p: (),
+}
+
+// ==== impl TryInitError ====
+
+impl TryInitError {
+    #[cfg(feature = "std")]
+    fn new(e: impl Into<Box<dyn Error + Send + Sync + 'static>>) -> Self {
+        Self { inner: e.into() }
+    }
+
+    #[cfg(not(feature = "std"))]
+    fn new<T>(_: T) -> Self {
+        Self { _p: () }
+    }
+}
+
+impl fmt::Debug for TryInitError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        #[cfg(feature = "std")]
+        {
+            fmt::Debug::fmt(&self.inner, f)
+        }
+
+        #[cfg(not(feature = "std"))]
+        {
+            f.write_str("TryInitError(())")
+        }
+    }
+}
+
+impl fmt::Display for TryInitError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        #[cfg(feature = "std")]
+        {
+            fmt::Display::fmt(&self.inner, f)
+        }
+
+        #[cfg(not(feature = "std"))]
+        {
+            f.write_str("failed to set global default subscriber")
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl Error for TryInitError {
+    fn source(&self) -> Option<&(dyn Error + 'static)> {
+        self.inner.source()
+    }
+}