Trait slog::Drain [−][src]
pub trait Drain { type Ok; type Err; fn log(
&self,
record: &Record,
values: &OwnedKVList
) -> Result<Self::Ok, Self::Err>; fn is_enabled(&self, level: Level) -> bool { ... } fn is_critical_enabled(&self) -> bool { ... } fn is_error_enabled(&self) -> bool { ... } fn is_warning_enabled(&self) -> bool { ... } fn is_info_enabled(&self) -> bool { ... } fn is_debug_enabled(&self) -> bool { ... } fn is_trace_enabled(&self) -> bool { ... } fn map<F, R>(self, f: F) -> R
where
Self: Sized,
F: FnOnce(Self) -> R, { ... } fn filter<F>(self, f: F) -> Filter<Self, F>
where
Self: Sized,
F: FilterFn, { ... } fn filter_level(self, level: Level) -> LevelFilter<Self>
where
Self: Sized, { ... } fn map_err<F, E>(self, f: F) -> MapError<Self, E>
where
Self: Sized,
F: MapErrFn<Self::Err, E>, { ... } fn ignore_res(self) -> IgnoreResult<Self>
where
Self: Sized, { ... } fn fuse(self) -> Fuse<Self>
where
Self::Err: Debug,
Self: Sized, { ... } }
Logging drain
Drain
s typically mean destination for logs, but slog
generalizes the
term.
Drain
s are responsible for handling logging statements (Record
s) from
Logger
s associated with them: filtering, modifying, formatting
and writing the log records into given destination(s).
It's a typical pattern to parametrize Drain
s over Drain
traits to allow
composing Drain
s.
Implementing this trait allows writing custom Drain
s. Slog users should
not be afraid of implementing their own Drain
s. Any custom log handling
logic should be implemented as a Drain
.
Associated Types
type Ok
Type returned by this drain
It can be useful in some circumstances, but rarely. It will probably
default to ()
once https://github.com/rust-lang/rust/issues/29661 is
stable.
type Err
Type of potential errors that can be returned by this Drain
Required Methods
fn log(
&self,
record: &Record,
values: &OwnedKVList
) -> Result<Self::Ok, Self::Err>
&self,
record: &Record,
values: &OwnedKVList
) -> Result<Self::Ok, Self::Err>
Handle one logging statement (Record
)
Every logging Record
built from a logging statement (eg.
info!(...)
), and key-value lists of a Logger
it was executed on
will be passed to the root drain registered during Logger::root
.
Typically Drain
s:
- pass this information (or not) to the sub-logger(s) (filters)
- format and write the information the a destination (writers)
- deal with the errors returned from the sub-logger(s)
Provided Methods
fn is_enabled(&self, level: Level) -> bool
Avoid: Check if messages at the specified log level are maybe enabled for this logger.
The purpose of it so to allow imprecise detection if a given logging level has any chance of actually being logged. This might be used to explicitly skip needless computation.
It is best effort, can return false positives, but not false negatives.
The logger is still free to ignore records even if the level is enabled, so an enabled level doesn't necessarily guarantee that the record will actually be logged.
This function is somewhat needless, and is better expressed by using
lazy values (see FnValue
). A FnValue
is more precise and does not
require additional (potentially recursive) calls to do something that
log
will already do anyways (making decision if something should be
logged or not).
let logger = Logger::root(Discard, o!()); if logger.is_enabled(Level::Debug) { let num = 5.0f64; let sqrt = num.sqrt(); debug!(logger, "Sqrt"; "num" => num, "sqrt" => sqrt); }
fn is_critical_enabled(&self) -> bool
Avoid: See is_enabled
fn is_error_enabled(&self) -> bool
Avoid: See is_enabled
fn is_warning_enabled(&self) -> bool
Avoid: See is_enabled
fn is_info_enabled(&self) -> bool
Avoid: See is_enabled
fn is_debug_enabled(&self) -> bool
Avoid: See is_enabled
fn is_trace_enabled(&self) -> bool
Avoid: See is_enabled
fn map<F, R>(self, f: F) -> R where
Self: Sized,
F: FnOnce(Self) -> R,
Self: Sized,
F: FnOnce(Self) -> R,
Pass Drain
through a closure, eg. to wrap
into another Drain
.
#[macro_use] extern crate slog; use slog::*; fn main() { let _drain = Discard.map(Fuse); }
fn filter<F>(self, f: F) -> Filter<Self, F> where
Self: Sized,
F: FilterFn,
Self: Sized,
F: FilterFn,
Filter logging records passed to Drain
Wrap Self
in Filter
This will convert self
to a Drain that ignores
Records for which
f` returns false.
fn filter_level(self, level: Level) -> LevelFilter<Self> where
Self: Sized,
Self: Sized,
Filter logging records passed to Drain
(by level)
Wrap Self
in LevelFilter
This will convert self
to a Drain that ignores
Records of logging lever smaller than
level`.
fn map_err<F, E>(self, f: F) -> MapError<Self, E> where
Self: Sized,
F: MapErrFn<Self::Err, E>,
Self: Sized,
F: MapErrFn<Self::Err, E>,
Map logging errors returned by this drain
f
is a closure that takes Drain::Err
returned by a given
drain, and returns new error of potentially different type
fn ignore_res(self) -> IgnoreResult<Self> where
Self: Sized,
Self: Sized,
Ignore results returned by this drain
Wrap Self
in IgnoreResult
fn fuse(self) -> Fuse<Self> where
Self::Err: Debug,
Self: Sized,
Self::Err: Debug,
Self: Sized,
Make Self
panic when returning any errors
Wrap Self
in Map
Implementations on Foreign Types
impl<'a, D: Drain + 'a> Drain for &'a D
[src]
impl<'a, D: Drain + 'a> Drain for &'a D
type Ok = D::Ok
type Err = D::Err
fn log(
&self,
record: &Record,
values: &OwnedKVList
) -> Result<Self::Ok, Self::Err>
[src]
fn log(
&self,
record: &Record,
values: &OwnedKVList
) -> Result<Self::Ok, Self::Err>
fn is_enabled(&self, level: Level) -> bool
[src]
fn is_enabled(&self, level: Level) -> bool
fn is_critical_enabled(&self) -> bool
[src]
fn is_critical_enabled(&self) -> bool
fn is_error_enabled(&self) -> bool
[src]
fn is_error_enabled(&self) -> bool
fn is_warning_enabled(&self) -> bool
[src]
fn is_warning_enabled(&self) -> bool
fn is_info_enabled(&self) -> bool
[src]
fn is_info_enabled(&self) -> bool
fn is_debug_enabled(&self) -> bool
[src]
fn is_debug_enabled(&self) -> bool
fn is_trace_enabled(&self) -> bool
[src]
fn is_trace_enabled(&self) -> bool
fn map<F, R>(self, f: F) -> R where
Self: Sized,
F: FnOnce(Self) -> R,
[src]
fn map<F, R>(self, f: F) -> R where
Self: Sized,
F: FnOnce(Self) -> R,
fn filter<F>(self, f: F) -> Filter<Self, F> where
Self: Sized,
F: FilterFn,
[src]
fn filter<F>(self, f: F) -> Filter<Self, F> where
Self: Sized,
F: FilterFn,
fn filter_level(self, level: Level) -> LevelFilter<Self> where
Self: Sized,
[src]
fn filter_level(self, level: Level) -> LevelFilter<Self> where
Self: Sized,
fn map_err<F, E>(self, f: F) -> MapError<Self, E> where
Self: Sized,
F: MapErrFn<Self::Err, E>,
[src]
fn map_err<F, E>(self, f: F) -> MapError<Self, E> where
Self: Sized,
F: MapErrFn<Self::Err, E>,
fn ignore_res(self) -> IgnoreResult<Self> where
Self: Sized,
[src]
fn ignore_res(self) -> IgnoreResult<Self> where
Self: Sized,
fn fuse(self) -> Fuse<Self> where
Self::Err: Debug,
Self: Sized,
[src]
fn fuse(self) -> Fuse<Self> where
Self::Err: Debug,
Self: Sized,
impl<'a, D: Drain + 'a> Drain for &'a mut D
[src]
impl<'a, D: Drain + 'a> Drain for &'a mut D
type Ok = D::Ok
type Err = D::Err
fn log(
&self,
record: &Record,
values: &OwnedKVList
) -> Result<Self::Ok, Self::Err>
[src]
fn log(
&self,
record: &Record,
values: &OwnedKVList
) -> Result<Self::Ok, Self::Err>
fn is_enabled(&self, level: Level) -> bool
[src]
fn is_enabled(&self, level: Level) -> bool
fn is_critical_enabled(&self) -> bool
[src]
fn is_critical_enabled(&self) -> bool
fn is_error_enabled(&self) -> bool
[src]
fn is_error_enabled(&self) -> bool
fn is_warning_enabled(&self) -> bool
[src]
fn is_warning_enabled(&self) -> bool
fn is_info_enabled(&self) -> bool
[src]
fn is_info_enabled(&self) -> bool
fn is_debug_enabled(&self) -> bool
[src]
fn is_debug_enabled(&self) -> bool
fn is_trace_enabled(&self) -> bool
[src]
fn is_trace_enabled(&self) -> bool
fn map<F, R>(self, f: F) -> R where
Self: Sized,
F: FnOnce(Self) -> R,
[src]
fn map<F, R>(self, f: F) -> R where
Self: Sized,
F: FnOnce(Self) -> R,
fn filter<F>(self, f: F) -> Filter<Self, F> where
Self: Sized,
F: FilterFn,
[src]
fn filter<F>(self, f: F) -> Filter<Self, F> where
Self: Sized,
F: FilterFn,
fn filter_level(self, level: Level) -> LevelFilter<Self> where
Self: Sized,
[src]
fn filter_level(self, level: Level) -> LevelFilter<Self> where
Self: Sized,
fn map_err<F, E>(self, f: F) -> MapError<Self, E> where
Self: Sized,
F: MapErrFn<Self::Err, E>,
[src]
fn map_err<F, E>(self, f: F) -> MapError<Self, E> where
Self: Sized,
F: MapErrFn<Self::Err, E>,
fn ignore_res(self) -> IgnoreResult<Self> where
Self: Sized,
[src]
fn ignore_res(self) -> IgnoreResult<Self> where
Self: Sized,
fn fuse(self) -> Fuse<Self> where
Self::Err: Debug,
Self: Sized,
[src]
fn fuse(self) -> Fuse<Self> where
Self::Err: Debug,
Self: Sized,
impl<D: Drain + ?Sized> Drain for Box<D>
[src]
impl<D: Drain + ?Sized> Drain for Box<D>
type Ok = D::Ok
type Err = D::Err
fn log(&self, record: &Record, o: &OwnedKVList) -> Result<Self::Ok, D::Err>
[src]
fn log(&self, record: &Record, o: &OwnedKVList) -> Result<Self::Ok, D::Err>
fn is_enabled(&self, level: Level) -> bool
[src]
fn is_enabled(&self, level: Level) -> bool
fn is_critical_enabled(&self) -> bool
[src]
fn is_critical_enabled(&self) -> bool
fn is_error_enabled(&self) -> bool
[src]
fn is_error_enabled(&self) -> bool
fn is_warning_enabled(&self) -> bool
[src]
fn is_warning_enabled(&self) -> bool
fn is_info_enabled(&self) -> bool
[src]
fn is_info_enabled(&self) -> bool
fn is_debug_enabled(&self) -> bool
[src]
fn is_debug_enabled(&self) -> bool
fn is_trace_enabled(&self) -> bool
[src]
fn is_trace_enabled(&self) -> bool
fn map<F, R>(self, f: F) -> R where
Self: Sized,
F: FnOnce(Self) -> R,
[src]
fn map<F, R>(self, f: F) -> R where
Self: Sized,
F: FnOnce(Self) -> R,
fn filter<F>(self, f: F) -> Filter<Self, F> where
Self: Sized,
F: FilterFn,
[src]
fn filter<F>(self, f: F) -> Filter<Self, F> where
Self: Sized,
F: FilterFn,
fn filter_level(self, level: Level) -> LevelFilter<Self> where
Self: Sized,
[src]
fn filter_level(self, level: Level) -> LevelFilter<Self> where
Self: Sized,
fn map_err<F, E>(self, f: F) -> MapError<Self, E> where
Self: Sized,
F: MapErrFn<Self::Err, E>,
[src]
fn map_err<F, E>(self, f: F) -> MapError<Self, E> where
Self: Sized,
F: MapErrFn<Self::Err, E>,
fn ignore_res(self) -> IgnoreResult<Self> where
Self: Sized,
[src]
fn ignore_res(self) -> IgnoreResult<Self> where
Self: Sized,
fn fuse(self) -> Fuse<Self> where
Self::Err: Debug,
Self: Sized,
[src]
fn fuse(self) -> Fuse<Self> where
Self::Err: Debug,
Self: Sized,
impl<D: Drain + ?Sized> Drain for Arc<D>
[src]
impl<D: Drain + ?Sized> Drain for Arc<D>
type Ok = D::Ok
type Err = D::Err
fn log(&self, record: &Record, o: &OwnedKVList) -> Result<Self::Ok, D::Err>
[src]
fn log(&self, record: &Record, o: &OwnedKVList) -> Result<Self::Ok, D::Err>
fn is_enabled(&self, level: Level) -> bool
[src]
fn is_enabled(&self, level: Level) -> bool
fn is_critical_enabled(&self) -> bool
[src]
fn is_critical_enabled(&self) -> bool
fn is_error_enabled(&self) -> bool
[src]
fn is_error_enabled(&self) -> bool
fn is_warning_enabled(&self) -> bool
[src]
fn is_warning_enabled(&self) -> bool
fn is_info_enabled(&self) -> bool
[src]
fn is_info_enabled(&self) -> bool
fn is_debug_enabled(&self) -> bool
[src]
fn is_debug_enabled(&self) -> bool
fn is_trace_enabled(&self) -> bool
[src]
fn is_trace_enabled(&self) -> bool
fn map<F, R>(self, f: F) -> R where
Self: Sized,
F: FnOnce(Self) -> R,
[src]
fn map<F, R>(self, f: F) -> R where
Self: Sized,
F: FnOnce(Self) -> R,
fn filter<F>(self, f: F) -> Filter<Self, F> where
Self: Sized,
F: FilterFn,
[src]
fn filter<F>(self, f: F) -> Filter<Self, F> where
Self: Sized,
F: FilterFn,
fn filter_level(self, level: Level) -> LevelFilter<Self> where
Self: Sized,
[src]
fn filter_level(self, level: Level) -> LevelFilter<Self> where
Self: Sized,
fn map_err<F, E>(self, f: F) -> MapError<Self, E> where
Self: Sized,
F: MapErrFn<Self::Err, E>,
[src]
fn map_err<F, E>(self, f: F) -> MapError<Self, E> where
Self: Sized,
F: MapErrFn<Self::Err, E>,
fn ignore_res(self) -> IgnoreResult<Self> where
Self: Sized,
[src]
fn ignore_res(self) -> IgnoreResult<Self> where
Self: Sized,
fn fuse(self) -> Fuse<Self> where
Self::Err: Debug,
Self: Sized,
[src]
fn fuse(self) -> Fuse<Self> where
Self::Err: Debug,
Self: Sized,
impl<D: Drain> Drain for Mutex<D>
[src]
impl<D: Drain> Drain for Mutex<D>
type Ok = D::Ok
type Err = MutexDrainError<D>
fn log(
&self,
record: &Record,
logger_values: &OwnedKVList
) -> Result<Self::Ok, Self::Err>
[src]
fn log(
&self,
record: &Record,
logger_values: &OwnedKVList
) -> Result<Self::Ok, Self::Err>
fn is_enabled(&self, level: Level) -> bool
[src]
fn is_enabled(&self, level: Level) -> bool
fn is_critical_enabled(&self) -> bool
[src]
fn is_critical_enabled(&self) -> bool
fn is_error_enabled(&self) -> bool
[src]
fn is_error_enabled(&self) -> bool
fn is_warning_enabled(&self) -> bool
[src]
fn is_warning_enabled(&self) -> bool
fn is_info_enabled(&self) -> bool
[src]
fn is_info_enabled(&self) -> bool
fn is_debug_enabled(&self) -> bool
[src]
fn is_debug_enabled(&self) -> bool
fn is_trace_enabled(&self) -> bool
[src]
fn is_trace_enabled(&self) -> bool
fn map<F, R>(self, f: F) -> R where
Self: Sized,
F: FnOnce(Self) -> R,
[src]
fn map<F, R>(self, f: F) -> R where
Self: Sized,
F: FnOnce(Self) -> R,
fn filter<F>(self, f: F) -> Filter<Self, F> where
Self: Sized,
F: FilterFn,
[src]
fn filter<F>(self, f: F) -> Filter<Self, F> where
Self: Sized,
F: FilterFn,
fn filter_level(self, level: Level) -> LevelFilter<Self> where
Self: Sized,
[src]
fn filter_level(self, level: Level) -> LevelFilter<Self> where
Self: Sized,
fn map_err<F, E>(self, f: F) -> MapError<Self, E> where
Self: Sized,
F: MapErrFn<Self::Err, E>,
[src]
fn map_err<F, E>(self, f: F) -> MapError<Self, E> where
Self: Sized,
F: MapErrFn<Self::Err, E>,
fn ignore_res(self) -> IgnoreResult<Self> where
Self: Sized,
[src]
fn ignore_res(self) -> IgnoreResult<Self> where
Self: Sized,
fn fuse(self) -> Fuse<Self> where
Self::Err: Debug,
Self: Sized,
[src]
fn fuse(self) -> Fuse<Self> where
Self::Err: Debug,
Self: Sized,
Implementors
impl<D> Drain for Logger<D> where
D: SendSyncUnwindSafeDrain<Ok = (), Err = Never>, type Ok = (); type Err = Never;impl Drain for Discard type Ok = (); type Err = Never;
impl<D: Drain, F> Drain for Filter<D, F> where
F: FilterFn, type Ok = Option<D::Ok>; type Err = D::Err;impl<D: Drain> Drain for LevelFilter<D> type Ok = Option<D::Ok>; type Err = D::Err;
impl<D: Drain, E> Drain for MapError<D, E> type Ok = D::Ok; type Err = E;
impl<D1: Drain, D2: Drain> Drain for Duplicate<D1, D2> type Ok = (D1::Ok, D2::Ok); type Err = (Result<D1::Ok, D1::Err>, Result<D2::Ok, D2::Err>);
impl<D: Drain> Drain for Fuse<D> where
D::Err: Debug, type Ok = (); type Err = Never;impl<D: Drain> Drain for IgnoreResult<D> type Ok = (); type Err = Never;