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.

On AsyncError::Full returned by AsyncCore used internally, Async will drop overflowing Records and report number of dropped messages.

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.