diff --git a/examples/examples/attrs-args.rs b/examples/examples/attrs-args.rs index 365f740736..08a8953fe8 100644 --- a/examples/examples/attrs-args.rs +++ b/examples/examples/attrs-args.rs @@ -29,7 +29,7 @@ fn fibonacci_seq(to: u64) -> Vec { fn main() { use tracing_subscriber::fmt; let subscriber = fmt::Subscriber::builder() - .with_filter("attrs_args=trace") + .with_env_filter("attrs_args=trace") .finish(); tracing::subscriber::with_default(subscriber, || { diff --git a/examples/examples/attrs-basic.rs b/examples/examples/attrs-basic.rs index efbdaf65e6..bb6dd777d0 100644 --- a/examples/examples/attrs-basic.rs +++ b/examples/examples/attrs-basic.rs @@ -12,7 +12,7 @@ fn suggest_band() -> String { fn main() { let subscriber = tracing_subscriber::fmt::Subscriber::builder() - .with_filter("attrs_basic=trace") + .with_env_filter("attrs_basic=trace") .finish(); tracing::subscriber::with_default(subscriber, || { let num_recs = 1; diff --git a/examples/examples/futures-proxy-server.rs b/examples/examples/futures-proxy-server.rs index 9ed88ea353..763dfdf870 100644 --- a/examples/examples/futures-proxy-server.rs +++ b/examples/examples/futures-proxy-server.rs @@ -17,10 +17,10 @@ use tokio::net::{TcpListener, TcpStream}; use tokio::prelude::*; fn main() -> Result<(), Box> { - use tracing_subscriber::{fmt, Filter}; + use tracing_subscriber::{fmt, EnvFilter}; let subscriber = fmt::Subscriber::builder() - .with_filter(Filter::from_default_env()) + .with_env_filter(EnvFilter::from_default_env()) .finish(); tracing::subscriber::set_global_default(subscriber)?; diff --git a/examples/examples/subscriber-filter.rs b/examples/examples/subscriber-filter.rs index 67fccb884a..459b76b67b 100644 --- a/examples/examples/subscriber-filter.rs +++ b/examples/examples/subscriber-filter.rs @@ -3,10 +3,10 @@ mod yak_shave; fn main() { - use tracing_subscriber::{fmt, Filter}; + use tracing_subscriber::{fmt, EnvFilter}; let subscriber = fmt::Subscriber::builder() - .with_filter(Filter::from_default_env()) + .with_env_filter(EnvFilter::from_default_env()) .finish(); tracing::subscriber::with_default(subscriber, || { diff --git a/examples/examples/tower-h2-client.rs b/examples/examples/tower-h2-client.rs index a2c728f3d2..78e9c5460a 100644 --- a/examples/examples/tower-h2-client.rs +++ b/examples/examples/tower-h2-client.rs @@ -18,14 +18,14 @@ use tracing_tower::InstrumentableService; pub struct Conn(SocketAddr); fn main() { - use tracing_subscriber::filter::Filter; + use tracing_subscriber::filter::EnvFilter; // Set the default subscriber to record all traces emitted by this example // and by the `tracing_tower` library's helpers. - let filter = Filter::from_default_env() + let filter = EnvFilter::from_default_env() .add_directive("tower_h2_client=trace".parse().unwrap()) .add_directive("tracing_tower=trace".parse().unwrap()); let subscriber = tracing_subscriber::FmtSubscriber::builder() - .with_filter(filter) + .with_env_filter(filter) .finish(); let _ = tracing::subscriber::set_global_default(subscriber); diff --git a/examples/examples/tower-h2-server.rs b/examples/examples/tower-h2-server.rs index 8df087ddb7..508dbc9140 100644 --- a/examples/examples/tower-h2-server.rs +++ b/examples/examples/tower-h2-server.rs @@ -95,12 +95,12 @@ impl tower_service::Service<()> for NewSvc { fn main() { // Set the default subscriber to record all traces emitted by this example // and by the `tracing_tower` library's helpers. - use tracing_subscriber::filter::Filter; - let filter = Filter::from_default_env() + use tracing_subscriber::filter::EnvFilter; + let filter = EnvFilter::from_default_env() .add_directive("tower_h2_server=trace".parse().unwrap()) .add_directive("tracing_tower=trace".parse().unwrap()); let subscriber = tracing_subscriber::FmtSubscriber::builder() - .with_filter(filter) + .with_env_filter(filter) .finish(); let _ = tracing::subscriber::set_global_default(subscriber); diff --git a/examples/examples/tower-load.rs b/examples/examples/tower-load.rs index 7273d27d33..212bdcf009 100644 --- a/examples/examples/tower-load.rs +++ b/examples/examples/tower-load.rs @@ -36,7 +36,7 @@ use tracing_subscriber::FmtSubscriber; fn main() { let builder = FmtSubscriber::builder() - .with_filter("info,tower_load=debug") + .with_env_filter("info,tower_load=debug") .with_filter_reloading(); let handle = builder.reload_handle(); @@ -224,7 +224,7 @@ impl Service<()> for MakeSvc { } struct AdminSvc { - handle: tracing_subscriber::reload::Handle, + handle: tracing_subscriber::reload::Handle, } impl Clone for AdminSvc { @@ -296,7 +296,7 @@ where let body = str::from_utf8(&bytes.as_ref()).map_err(|e| format!("{}", e))?; tracing::trace!(request.body = ?body); let new_filter = body - .parse::() + .parse::() .map_err(|e| format!("{}", e))?; self.handle.reload(new_filter).map_err(|e| format!("{}", e)) } diff --git a/nightly-examples/examples/async_fn.rs b/nightly-examples/examples/async_fn.rs index e957680496..7c67f3a3a5 100644 --- a/nightly-examples/examples/async_fn.rs +++ b/nightly-examples/examples/async_fn.rs @@ -44,7 +44,7 @@ pub async fn main() -> Result<(), Box> { let addr = "127.0.0.1:6142".parse()?; let subscriber = tracing_subscriber::fmt::Subscriber::builder() - .with_filter("async_fn=trace") + .with_env_filter("async_fn=trace") .finish(); tracing::subscriber::set_global_default(subscriber).unwrap(); diff --git a/nightly-examples/examples/echo.rs b/nightly-examples/examples/echo.rs index e4d0b00523..f284845168 100644 --- a/nightly-examples/examples/echo.rs +++ b/nightly-examples/examples/echo.rs @@ -37,10 +37,10 @@ use tracing_futures::Instrument; #[tokio::main] async fn main() -> Result<(), Box> { - use tracing_subscriber::{Filter, FmtSubscriber}; + use tracing_subscriber::{EnvFilter, FmtSubscriber}; let subscriber = FmtSubscriber::builder() - .with_filter(Filter::from_default_env().add_directive("echo=trace".parse()?)) + .with_env_filter(EnvFilter::from_default_env().add_directive("echo=trace".parse()?)) .finish(); tracing::subscriber::set_global_default(subscriber)?; diff --git a/nightly-examples/examples/proxy_server.rs b/nightly-examples/examples/proxy_server.rs index baa3289861..952a330c9f 100644 --- a/nightly-examples/examples/proxy_server.rs +++ b/nightly-examples/examples/proxy_server.rs @@ -86,10 +86,10 @@ async fn transfer( #[tokio::main] async fn main() -> Result<(), Box> { - use tracing_subscriber::{Filter, FmtSubscriber}; + use tracing_subscriber::{EnvFilter, FmtSubscriber}; let subscriber = FmtSubscriber::builder() - .with_filter(Filter::from_default_env().add_directive("proxy_server=trace".parse()?)) + .with_env_filter(EnvFilter::from_default_env().add_directive("proxy_server=trace".parse()?)) .finish(); tracing::subscriber::set_global_default(subscriber)?; diff --git a/tracing-subscriber/Cargo.toml b/tracing-subscriber/Cargo.toml index e9542e75ce..f1d343fd54 100644 --- a/tracing-subscriber/Cargo.toml +++ b/tracing-subscriber/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "tracing-subscriber" -version = "0.1.1" +version = "0.1.2" authors = ["Eliza Weisman ", "Tokio Contributors "] edition = "2018" license = "MIT" @@ -20,11 +20,14 @@ keywords = ["logging", "tracing", "metrics", "subscriber"] [features] -default = ["filter", "smallvec", "fmt", "ansi", "chrono", "tracing-log"] -filter = ["matchers", "regex", "lazy_static"] +default = ["env-filter", "smallvec", "fmt", "ansi", "chrono", "tracing-log"] +env-filter = ["matchers", "regex", "lazy_static"] fmt = ["owning_ref", "parking_lot"] ansi = ["fmt", "ansi_term"] +# Alias for `env-filter`; renamed in version 0.1.2, and will be removed in 0.2. +filter = ["env-filter"] + [dependencies] tracing-core = "0.1.2" crossbeam-utils = "0.6" diff --git a/tracing-subscriber/src/filter/env/mod.rs b/tracing-subscriber/src/filter/env/mod.rs index 107926f0fd..d3518cac53 100644 --- a/tracing-subscriber/src/filter/env/mod.rs +++ b/tracing-subscriber/src/filter/env/mod.rs @@ -29,8 +29,15 @@ use tracing_core::{ /// A `Layer` which filters spans and events based on a set of filter /// directives. // TODO(eliza): document filter directive syntax? +#[cfg_attr( + feature = "filter", + deprecated( + since = "0.1.2", + note = "the `filter` feature flag was renamed to `env-filter` and will be removed in 0.2", + ) +)] #[derive(Debug)] -pub struct Filter { +pub struct EnvFilter { // TODO: eventually, this should be exposed by the registry. scope: thread::Local>, @@ -48,7 +55,7 @@ type FilterVec = smallvec::SmallVec<[T; 8]>; #[cfg(not(feature = "smallvec"))] type FilterVec = Vec; -/// Indicates that an error occurred while parsing a `Filter` from an +/// Indicates that an error occurred while parsing a `EnvFilter` from an /// environment variable. #[derive(Debug)] pub struct FromEnvError { @@ -61,27 +68,27 @@ enum ErrorKind { Env(env::VarError), } -impl Filter { - /// The default environment variable used by [`Filter::from_default_env`] - /// and [`Filter::try_from_default_env`]. +impl EnvFilter { + /// The default environment variable used by [`EnvFilter::from_default_env`] + /// and [`EnvFilter::try_from_default_env`]. /// - /// [`Filter::from_default_env`]: #method.from_default_env - /// [`Filter::try_from_default_env`]: #method.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 `Filter` from the value of the `RUST_LOG` environment + /// 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 `Filter` from the value of the given environment + /// Returns a new `EnvFilter` from the value of the given environment /// variable, ignoring any invalid filter directives. pub fn from_env>(env: A) -> Self { env::var(env.as_ref()).map(Self::new).unwrap_or_default() } - /// Returns a new `Filter` from the directives in the given string, + /// Returns a new `EnvFilter` from the directives in the given string, /// ignoring any that are invalid. pub fn new>(dirs: S) -> Self { let directives = dirs.as_ref().split(',').filter_map(|s| match s.parse() { @@ -94,7 +101,7 @@ impl Filter { Self::from_directives(directives) } - /// Returns a new `Filter` from the directives in the given string, + /// Returns a new `EnvFilter` from the directives in the given string, /// or an error if any are invalid. pub fn try_new>(dirs: S) -> Result { let directives = dirs @@ -105,21 +112,21 @@ impl Filter { Ok(Self::from_directives(directives)) } - /// Returns a new `Filter` from the value of the `RUST_LOG` environment + /// 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::try_from_env(Self::DEFAULT_ENV) } - /// Returns a new `Filter` from the value of the given environment + /// 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>(env: A) -> Result { env::var(env.as_ref())?.parse().map_err(Into::into) } - /// Add a filtering directive to this `Filter`. + /// 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 @@ -137,17 +144,17 @@ impl Filter { /// /// # Examples /// ```rust - /// use tracing_subscriber::filter::{Filter, LevelFilter}; + /// use tracing_subscriber::filter::{EnvFilter, LevelFilter}; /// # fn main() { - /// let mut filter = Filter::from_default_env() + /// let mut filter = EnvFilter::from_default_env() /// .add_directive(LevelFilter::INFO.into()); /// # } /// ``` /// ```rust - /// use tracing_subscriber::filter::{Filter, Directive}; + /// use tracing_subscriber::filter::{EnvFilter, Directive}; /// /// # fn try_mk_filter() -> Result<(), Box> { - /// let mut filter = Filter::try_from_default_env()? + /// 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(()) @@ -193,7 +200,7 @@ impl Filter { } } -impl Layer for Filter { +impl Layer for EnvFilter { fn register_callsite(&self, metadata: &'static Metadata<'static>) -> Interest { if metadata.is_span() { // If this metadata describes a span, first, check if there is a @@ -271,7 +278,7 @@ impl Layer for Filter { } } -impl FromStr for Filter { +impl FromStr for EnvFilter { type Err = ParseError; fn from_str(spec: &str) -> Result { @@ -279,7 +286,7 @@ impl FromStr for Filter { } } -impl From for Filter +impl From for EnvFilter where S: AsRef, { @@ -288,13 +295,13 @@ where } } -impl Default for Filter { +impl Default for EnvFilter { fn default() -> Self { Self::from_directives(std::iter::empty()) } } -impl fmt::Display for Filter { +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() { @@ -401,7 +408,7 @@ mod tests { #[test] fn callsite_enabled_no_span_directive() { - let filter = Filter::new("app=debug").with_subscriber(NoSubscriber); + let filter = EnvFilter::new("app=debug").with_subscriber(NoSubscriber); static META: &'static Metadata<'static> = &Metadata::new( "mySpan", "app", @@ -419,7 +426,7 @@ mod tests { #[test] fn callsite_off() { - let filter = Filter::new("app=off").with_subscriber(NoSubscriber); + let filter = EnvFilter::new("app=off").with_subscriber(NoSubscriber); static META: &'static Metadata<'static> = &Metadata::new( "mySpan", "app", @@ -437,7 +444,7 @@ mod tests { #[test] fn callsite_enabled_includes_span_directive() { - let filter = Filter::new("app[mySpan]=debug").with_subscriber(NoSubscriber); + let filter = EnvFilter::new("app[mySpan]=debug").with_subscriber(NoSubscriber); static META: &'static Metadata<'static> = &Metadata::new( "mySpan", "app", @@ -456,7 +463,7 @@ mod tests { #[test] fn callsite_enabled_includes_span_directive_field() { let filter = - Filter::new("app[mySpan{field=\"value\"}]=debug").with_subscriber(NoSubscriber); + EnvFilter::new("app[mySpan{field=\"value\"}]=debug").with_subscriber(NoSubscriber); static META: &'static Metadata<'static> = &Metadata::new( "mySpan", "app", @@ -474,7 +481,7 @@ mod tests { #[test] fn callsite_enabled_includes_span_directive_multiple_fields() { - let filter = Filter::new("app[mySpan{field=\"value\",field2=2}]=debug") + let filter = EnvFilter::new("app[mySpan{field=\"value\",field2=2}]=debug") .with_subscriber(NoSubscriber); static META: &'static Metadata<'static> = &Metadata::new( "mySpan", @@ -493,11 +500,11 @@ mod tests { #[test] fn roundtrip() { - let f1: Filter = + let f1: EnvFilter = "[span1{foo=1}]=error,[span2{bar=2 baz=false}],crate2[{quux=\"quuux\"}]=debug" .parse() .unwrap(); - let f2: Filter = format!("{}", f1).parse().unwrap(); + let f2: EnvFilter = format!("{}", f1).parse().unwrap(); assert_eq!(f1.statics, f2.statics); assert_eq!(f1.dynamics, f2.dynamics); } diff --git a/tracing-subscriber/src/filter/mod.rs b/tracing-subscriber/src/filter/mod.rs index 99cbde1274..a7c73ef250 100644 --- a/tracing-subscriber/src/filter/mod.rs +++ b/tracing-subscriber/src/filter/mod.rs @@ -2,11 +2,19 @@ //! subscriber. //! //! [`Layer`]: ../trait.Layer.html -#[cfg(feature = "filter")] +#[cfg(feature = "env-filter")] mod env; mod level; pub use self::level::{LevelFilter, ParseError as LevelParseError}; -#[cfg(feature = "filter")] +#[cfg(feature = "env-filter")] pub use self::env::*; + +/// A `Layer` which filters spans and events based on a set of filter +/// directives. +/// +/// **Note**: renamed to `EnvFilter` in 0.1.2; use that instead. +#[cfg(feature = "env-filter")] +#[deprecated(since = "0.1.2", note = "renamed to `EnvFilter`")] +pub type Filter = EnvFilter; diff --git a/tracing-subscriber/src/fmt/mod.rs b/tracing-subscriber/src/fmt/mod.rs index 9d218b14a6..54f72e4943 100644 --- a/tracing-subscriber/src/fmt/mod.rs +++ b/tracing-subscriber/src/fmt/mod.rs @@ -383,8 +383,8 @@ where } } -#[cfg(feature = "filter")] -impl Builder +#[cfg(feature = "env-filter")] +impl Builder where Formatter: tracing_core::Subscriber + 'static, { @@ -392,7 +392,7 @@ where /// runtime. pub fn with_filter_reloading( self, - ) -> Builder>, W> { + ) -> Builder>, W> { let (filter, _) = crate::reload::Layer::new(self.filter); Builder { new_visitor: self.new_visitor, @@ -404,14 +404,14 @@ where } } -#[cfg(feature = "filter")] -impl Builder>, W> +#[cfg(feature = "env-filter")] +impl Builder>, W> where Formatter: 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> { + pub fn reload_handle(&self) -> crate::reload::Handle> { self.filter.handle() } } @@ -432,10 +432,10 @@ impl Builder { } } - /// Sets the [`Filter`] that the subscriber will use to determine if + /// Sets the [`EnvFilter`] that the subscriber will use to determine if /// a span or event is enabled. /// - /// Note that this method requires the "filter" feature flag to be 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. @@ -445,10 +445,10 @@ impl Builder { /// Setting a filter based on the value of the `RUST_LOG` environment /// variable: /// ```rust - /// use tracing_subscriber::{FmtSubscriber, Filter}; + /// use tracing_subscriber::{FmtSubscriber, EnvFilter}; /// /// let subscriber = FmtSubscriber::builder() - /// .with_filter(Filter::from_default_env()) + /// .with_env_filter(EnvFilter::from_default_env()) /// .finish(); /// ``` /// @@ -458,7 +458,7 @@ impl Builder { /// /// # fn main() -> Result<(), Box> { /// let subscriber = FmtSubscriber::builder() - /// .with_filter("my_crate=info,my_crate::my_mod=debug,[my_span]=trace") + /// .with_env_filter("my_crate=info,my_crate::my_mod=debug,[my_span]=trace") /// .finish(); /// # Ok(()) } /// ``` @@ -467,11 +467,11 @@ impl Builder { /// ```rust /// use tracing_subscriber::{ /// FmtSubscriber, - /// filter::{Filter, LevelFilter}, + /// filter::{EnvFilter, LevelFilter}, /// }; /// /// # fn filter() -> Result<(), Box> { - /// let filter = Filter::try_from_env("MY_CUSTOM_FILTER_ENV_VAR")? + /// 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 @@ -479,14 +479,17 @@ impl Builder { /// .add_directive("my_crate::my_mod=debug".parse()?); /// /// let subscriber = FmtSubscriber::builder() - /// .with_filter(filter) + /// .with_env_filter(filter) /// .finish(); /// # Ok(())} /// ``` - /// [`Filter`]: ../filter/struct.Filter.html + /// [`EnvFilter`]: ../filter/struct.EnvFilter.html /// [`with_max_level`]: #method.with_max_level - #[cfg(feature = "filter")] - pub fn with_filter(self, filter: impl Into) -> Builder + #[cfg(feature = "env-filter")] + pub fn with_env_filter( + self, + filter: impl Into, + ) -> Builder where Formatter: tracing_core::Subscriber + 'static, { @@ -500,10 +503,31 @@ impl Builder { } } + /// Sets the [`EnvFilter`] that the subscriber will use to determine if + /// a span or event is enabled. + /// + /// **Note**: this method was renamed to [`with_env_filter`] in version + /// 0.1.2. This method just wraps a call to `with_env_filter`, and will be + /// removed in version 0.2. + /// + /// [`EnvFilter`]: ../filter/struct.EnvFilter.html + /// [`with_env_filter`]: #method.with_env_filter + #[cfg(feature = "env-filter")] + #[deprecated(since = "0.1.2", note = "renamed to `with_env_filter`")] + pub fn with_filter( + self, + filter: impl Into, + ) -> Builder + where + Formatter: tracing_core::Subscriber + 'static, + { + self.with_env_filter(filter) + } + /// Sets the maximum [verbosity level] that will be enabled by the /// subscriber. /// - /// If the max level has already been set, or a [`Filter`] was added by + /// 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. /// @@ -530,7 +554,7 @@ impl Builder { /// .finish(); /// ``` /// [verbosity level]: https://docs.rs/tracing-core/0.1.5/tracing_core/struct.Level.html - /// [`Filter`]: ../filter/struct.Filter.html + /// [`EnvFilter`]: ../filter/struct.EnvFilter.html /// [`with_filter`]: #method.with_filter pub fn with_max_level(self, filter: impl Into) -> Builder { let filter = filter.into(); diff --git a/tracing-subscriber/src/lib.rs b/tracing-subscriber/src/lib.rs index 22b423142a..38c7e916d6 100644 --- a/tracing-subscriber/src/lib.rs +++ b/tracing-subscriber/src/lib.rs @@ -12,8 +12,10 @@ //! //! ## Feature Flags //! -//! - `filter`: Enables the [`Filter`] type, which implements filtering similar -//! to the [`env_logger` crate]. Enabled by default. +//! - `env-filter`: Enables the [`EnvFilter`] type, which implements filtering +//! similar to the [`env_logger` crate]. Enabled by default. +//! - `filter`: Alias for `env-filter`. This feature flag was renamed in version +//! 0.1.2, and will be removed in version 0.2. //! - `fmt`: Enables the [`fmt`] module, which provides a subscriber //! implementation for printing formatted representations of trace events. //! Enabled by default. @@ -25,12 +27,12 @@ //! macros in the `fmt` subscriber. On by default. //! - [`chrono`]: Enables human-readable time formatting in the `fmt` subscriber. //! Enabled by default. -//! - [`smallvec`]: Causes the `Filter` type to use the `smallvec` crate (rather +//! - [`smallvec`]: Causes the `EnvFilter` type to use the `smallvec` crate (rather //! than `Vec`) as a performance optimization. Enabled by default. //! //! [`tracing`]: https://docs.rs/tracing/latest/tracing/ //! [`Subscriber`]: https://docs.rs/tracing-core/latest/tracing_core/subscriber/trait.Subscriber.html -//! [`Filter`]: filter/struct.Filter.html +//! [`EnvFilter`]: filter/struct.EnvFilter.html //! [`fmt`]: fmt/index.html //! [`tracing-log`]: https://crates.io/crates/tracing-log //! [`smallvec`]: https://crates.io/crates/smallvec @@ -96,8 +98,10 @@ pub mod prelude; pub mod reload; pub(crate) mod thread; -#[cfg(feature = "filter")] -pub use filter::Filter; +#[cfg(feature = "env-filter")] +#[allow(deprecated)] +pub use filter::{EnvFilter, Filter}; + pub use layer::Layer; #[cfg(feature = "fmt")] @@ -144,6 +148,5 @@ impl Default for CurrentSpan { } mod sealed { - pub trait Sealed {} } diff --git a/tracing-subscriber/src/reload.rs b/tracing-subscriber/src/reload.rs index 7546709440..82d81ee7d7 100644 --- a/tracing-subscriber/src/reload.rs +++ b/tracing-subscriber/src/reload.rs @@ -248,19 +248,19 @@ mod test { static FILTER1_CALLS: AtomicUsize = AtomicUsize::new(0); static FILTER2_CALLS: AtomicUsize = AtomicUsize::new(0); - enum Filter { + enum EnvFilter { One, Two, } - impl crate::Layer for Filter { + impl crate::Layer for EnvFilter { fn register_callsite(&self, _: &Metadata<'_>) -> Interest { Interest::sometimes() } fn enabled(&self, _: &Metadata<'_>, _: layer::Context<'_, S>) -> bool { match self { - Filter::One => FILTER1_CALLS.fetch_add(1, Ordering::Relaxed), - Filter::Two => FILTER2_CALLS.fetch_add(1, Ordering::Relaxed), + EnvFilter::One => FILTER1_CALLS.fetch_add(1, Ordering::Relaxed), + EnvFilter::Two => FILTER2_CALLS.fetch_add(1, Ordering::Relaxed), }; true } @@ -269,7 +269,7 @@ mod test { tracing::trace!("my event"); } - let (layer, handle) = Layer::new(Filter::One); + let (layer, handle) = Layer::new(EnvFilter::One); let subscriber = tracing_core::dispatcher::Dispatch::new(crate::layer::tests::NopSubscriber.with(layer)); @@ -283,7 +283,7 @@ mod test { assert_eq!(FILTER1_CALLS.load(Ordering::Relaxed), 1); assert_eq!(FILTER2_CALLS.load(Ordering::Relaxed), 0); - handle.reload(Filter::Two).expect("should reload"); + handle.reload(EnvFilter::Two).expect("should reload"); event(); diff --git a/tracing-subscriber/tests/field_filter.rs b/tracing-subscriber/tests/field_filter.rs index 94b2af2333..7c39441739 100644 --- a/tracing-subscriber/tests/field_filter.rs +++ b/tracing-subscriber/tests/field_filter.rs @@ -1,11 +1,11 @@ mod support; use self::support::*; use tracing::{self, subscriber::with_default, Level}; -use tracing_subscriber::{filter::Filter, prelude::*}; +use tracing_subscriber::{filter::EnvFilter, prelude::*}; #[test] fn field_filter_events() { - let filter: Filter = "[{thing}]=debug".parse().expect("filter should parse"); + let filter: EnvFilter = "[{thing}]=debug".parse().expect("filter should parse"); let (subscriber, finished) = subscriber::mock() .event( event::mock() @@ -34,7 +34,7 @@ fn field_filter_events() { #[test] fn field_filter_spans() { - let filter: Filter = "[{enabled=true}]=debug" + let filter: EnvFilter = "[{enabled=true}]=debug" .parse() .expect("filter should parse"); let (subscriber, finished) = subscriber::mock() @@ -77,7 +77,7 @@ fn field_filter_spans() { #[test] fn record_after_created() { - let filter: Filter = "[{enabled=true}]=debug" + let filter: EnvFilter = "[{enabled=true}]=debug" .parse() .expect("filter should parse"); let (subscriber, finished) = subscriber::mock() diff --git a/tracing-subscriber/tests/filter.rs b/tracing-subscriber/tests/filter.rs index 385cba22c5..4f52a7fd94 100644 --- a/tracing-subscriber/tests/filter.rs +++ b/tracing-subscriber/tests/filter.rs @@ -1,11 +1,11 @@ mod support; use self::support::*; use tracing::{self, subscriber::with_default, Level}; -use tracing_subscriber::{filter::Filter, prelude::*}; +use tracing_subscriber::{filter::EnvFilter, prelude::*}; #[test] fn level_filter_event() { - let filter: Filter = "info".parse().expect("filter should parse"); + let filter: EnvFilter = "info".parse().expect("filter should parse"); let (subscriber, finished) = subscriber::mock() .event(event::mock().at_level(Level::INFO)) .event(event::mock().at_level(Level::WARN)) @@ -27,7 +27,7 @@ fn level_filter_event() { #[test] fn same_name_spans() { - let filter: Filter = "[foo{bar}]=trace,[foo{baz}]=trace" + let filter: EnvFilter = "[foo{bar}]=trace,[foo{baz}]=trace" .parse() .expect("filter should parse"); let (subscriber, finished) = subscriber::mock() @@ -56,7 +56,7 @@ fn same_name_spans() { #[test] fn level_filter_event_with_target() { - let filter: Filter = "info,stuff=debug".parse().expect("filter should parse"); + let filter: EnvFilter = "info,stuff=debug".parse().expect("filter should parse"); let (subscriber, finished) = subscriber::mock() .event(event::mock().at_level(Level::INFO)) .event(event::mock().at_level(Level::DEBUG).with_target("stuff")) @@ -83,7 +83,7 @@ fn level_filter_event_with_target() { #[test] fn span_name_filter_is_dynamic() { - let filter: Filter = "info,[cool_span]=debug" + let filter: EnvFilter = "info,[cool_span]=debug" .parse() .expect("filter should parse"); let (subscriber, finished) = subscriber::mock() @@ -129,7 +129,7 @@ fn span_name_filter_is_dynamic() { #[test] fn field_filter_events() { - let filter: Filter = "[{thing}]=debug".parse().expect("filter should parse"); + let filter: EnvFilter = "[{thing}]=debug".parse().expect("filter should parse"); let (subscriber, finished) = subscriber::mock() .event( event::mock() diff --git a/tracing-subscriber/tests/same_len_filters.rs b/tracing-subscriber/tests/same_len_filters.rs index bb0de62ff1..5b85ac7717 100644 --- a/tracing-subscriber/tests/same_len_filters.rs +++ b/tracing-subscriber/tests/same_len_filters.rs @@ -4,11 +4,11 @@ mod support; use self::support::*; use tracing::{self, subscriber::with_default, Level}; -use tracing_subscriber::{filter::Filter, prelude::*}; +use tracing_subscriber::{filter::EnvFilter, prelude::*}; #[test] fn same_length_targets() { - let filter: Filter = "foo=trace,bar=trace".parse().expect("filter should parse"); + let filter: EnvFilter = "foo=trace,bar=trace".parse().expect("filter should parse"); let (subscriber, finished) = subscriber::mock() .event(event::mock().at_level(Level::TRACE)) .event(event::mock().at_level(Level::TRACE)) @@ -26,7 +26,7 @@ fn same_length_targets() { #[test] fn same_num_fields_event() { - let filter: Filter = "[{foo}]=trace,[{bar}]=trace" + let filter: EnvFilter = "[{foo}]=trace,[{bar}]=trace" .parse() .expect("filter should parse"); let (subscriber, finished) = subscriber::mock() @@ -53,7 +53,7 @@ fn same_num_fields_event() { #[test] fn same_num_fields_and_name_len() { - let filter: Filter = "[foo{bar=1}]=trace,[baz{boz=1}]=trace" + let filter: EnvFilter = "[foo{bar=1}]=trace,[baz{boz=1}]=trace" .parse() .expect("filter should parse"); let (subscriber, finished) = subscriber::mock()