Struct `LevelFilter`

#[repr(transparent)]
pub struct LevelFilter(/* private field */);

A filter comparable to a verbosity Level.

If a Level is considered less than or equal to a LevelFilter, it should be considered enabled; if greater than the LevelFilter, that level is disabled. See LevelFilter::current for more details.

Note that this is essentially identical to the Level type, but with the addition of an OFF level that completely disables all trace instrumentation.

See the documentation for the Level type to see how Levels and LevelFilters interact.

Implementations

`impl LevelFilter`

const OFF: LevelFilter = _;

The "off" level.

Designates that trace instrumentation should be completely disabled.

const ERROR: LevelFilter = _;

The "error" level.

Designates very serious errors.

const WARN: LevelFilter = _;

The "warn" level.

Designates hazardous situations.

const INFO: LevelFilter = _;

The "info" level.

Designates useful information.

const DEBUG: LevelFilter = _;

The "debug" level.

Designates lower priority information.

const TRACE: LevelFilter = _;

The "trace" level.

Designates very low priority, often extremely verbose, information.

const fn from_level(level: Level) -> Self

Returns a LevelFilter that enables spans and events with verbosity up to and including level.

const fn into_level(self) -> Option<Level>

Returns the most verbose Level that this filter accepts, or None if it is OFF.

fn current() -> Self

Returns a LevelFilter that matches the most verbose Level that any currently active Subscriber will enable.

User code should treat this as a hint. If a given span or event has a level higher than the returned LevelFilter, it will not be enabled. However, if the level is less than or equal to this value, the span or event is not guaranteed to be enabled; the subscriber will still filter each callsite individually.

Therefore, comparing a given span or event's level to the returned LevelFilter can be used for determining if something is disabled, but should not be used for determining if something is enabled.

Trait Implementations

`impl Clone for LevelFilter`

fn clone(&self) -> LevelFilter

`impl Copy for LevelFilter`

`impl Debug for LevelFilter`

fn fmt(&self, f: &mut Formatter<'_>) -> Result

`impl Display for LevelFilter`

fn fmt(&self, f: &mut Formatter<'_>) -> Result

`impl Eq for LevelFilter`

`impl From<Level> for LevelFilter`

fn from(level: Level) -> Self

`impl From<Option<Level>> for LevelFilter`

fn from(level: Option<Level>) -> Self

`impl FromStr for LevelFilter`

type Err = ParseLevelFilterError;
fn from_str(from: &str) -> Result<Self, Self::Err>

`impl Hash for LevelFilter`

fn hash<__H: Hasher>(&self, state: &mut __H)

`impl Ord for LevelFilter`

fn cmp(&self, other: &Self) -> Ordering

`impl PartialEq for LevelFilter`

fn eq(&self, other: &LevelFilter) -> bool

`impl PartialEq<Level> for LevelFilter`

fn eq(&self, other: &Level) -> bool

`impl PartialOrd for LevelFilter`

fn partial_cmp(&self, other: &LevelFilter) -> Option<Ordering>
fn lt(&self, other: &LevelFilter) -> bool
fn le(&self, other: &LevelFilter) -> bool
fn gt(&self, other: &LevelFilter) -> bool
fn ge(&self, other: &LevelFilter) -> bool

`impl PartialOrd<Level> for LevelFilter`

fn partial_cmp(&self, other: &Level) -> Option<Ordering>
fn lt(&self, other: &Level) -> bool
fn le(&self, other: &Level) -> bool
fn gt(&self, other: &Level) -> bool
fn ge(&self, other: &Level) -> bool

`impl StructuralPartialEq for LevelFilter`

Auto Trait Implementations

`impl Freeze for LevelFilter`

`impl RefUnwindSafe for LevelFilter`

`impl Send for LevelFilter`

`impl Sync for LevelFilter`

`impl Unpin for LevelFilter`

`impl UnsafeUnpin for LevelFilter`

`impl UnwindSafe for LevelFilter`

Blanket Implementations

`impl<T> Any for LevelFilter where T: 'static + ?Sized,`

fn type_id(&self) -> TypeId

`impl<T> Borrow<T> for LevelFilter where T: ?Sized,`

fn borrow(&self) -> &T

`impl<T> BorrowMut<T> for LevelFilter where T: ?Sized,`

fn borrow_mut(&mut self) -> &mut T

`impl<T> CloneToUninit for LevelFilter where T: Clone,`

unsafe fn clone_to_uninit(&self, dest: *mut u8)

`impl<T> From<T> for LevelFilter`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T> ToOwned for LevelFilter where T: Clone,`

type Owned = T;
fn to_owned(&self) -> T
fn clone_into(&self, target: &mut T)

`impl<T> ToString for LevelFilter where T: Display + ?Sized,`

fn to_string(&self) -> String

`impl<T, U> Into<U> for LevelFilter where U: From<T>,`

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

`impl<T, U> TryFrom<U> for LevelFilter where U: Into<T>,`

type Error = Infallible;
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

`impl<T, U> TryInto<U> for LevelFilter where U: TryFrom<T>,`

type Error = <U as TryFrom<T>>::Error;
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>