Struct slog_async::Async

pub struct Async { /* fields omitted */ }

Async drain

Async will send all the logging records to a wrapped drain running in another thread.

Async never returns AsyncError::Full.

Records are passed to the worker thread through a channel with a bounded size (see AsyncBuilder::chan_size). On channel overflow Async will start dropping Records and log a message informing about it after sending more Records is possible again. The exact details of handling overflow is implementation defined, might change and should not be relied on, other than message won't be dropped as long as channel does not overflow.

Any messages reported by Async will contain slog-async logging Record tag to allow easy custom handling.

Note: On drop Async waits for it's worker-thread to finish (after handling all previous Records sent to it). If you can't tolerate the delay, make sure you drop it eg. in another thread.

Methods

impl Async

fn default<D: Drain<Err = Never, Ok = ()> + Send + 'static>(drain: D) -> Self

New AsyncCore with default parameters

fn new<D: Drain<Err = Never, Ok = ()> + Send + 'static>(
    drain: D
) -> AsyncBuilder<D>

Build Async drain with custom parameters

The wrapped drain must handle all results (Drain<Ok=(),Error=Never>) since there's no way to return it back. See slog::DrainExt::fuse() and slog::DrainExt::ignore_res() for typical error handling strategies.

Trait Implementations

impl Drain for Async

type Ok = ()

Type returned by this drain

type Err = AsyncError

Type of potential errors that can be returned by this Drain

fn log(&self, record: &Record, logger_values: &OwnedKVList) -> AsyncResult<()>

Handle one logging statement (Record)

fn map<F, R>(self, f: F) -> R where
    F: FnOnce(Self) -> R, 

Pass Drain through a closure, eg. to wrap into another Drain.

fn filter<F>(self, f: F) -> Filter<Self, F> where
    F: FilterFn, 

Filter logging records passed to Drain

fn filter_level(self, level: Level) -> LevelFilter<Self>

Filter logging records passed to Drain (by level)

fn map_err<F, E>(self, f: F) -> MapError<Self, E> where
    F: MapErrFn<Self::Err, E>, 

Map logging errors returned by this drain

fn ignore_res(self) -> IgnoreResult<Self>

Ignore results returned by this drain

fn fuse(self) -> Fuse<Self> where
    Self::Err: Debug, 

Make Self panic when returning any errors

impl Drop for Async

fn drop(&mut self)

A method called when the value goes out of scope.