Struct AsyncPoolSink 

pub struct AsyncPoolSink { /* private fields */ }

A combined sink, logging and flushing asynchronously (thread-pool-based).

Expensive operations (such as log and flush) on asynchronous sinks will be performed asynchronously on other threads.

Since there is no waiting, errors that occur while performing asynchronous operations will not be returned to the upper level, and instead the error handler of the sink will be called.

Users should only use asynchronous combined sinks to wrap actual sinks that require a long time for operations (e.g., file sinks that are frequently flushed, sinks involving networks), otherwise they will not get a performance boost or even worse.

Since the thread pool has a capacity limit, the queue may be full in some cases. When users encounter this situation, they have the following options:

• Adjust to a larger capacity via ThreadPoolBuilder::capacity.

• Adjust the overflow policy via AsyncPoolSinkBuilder::overflow_policy.

• Set up an error handler on asynchronous combined sinks via AsyncPoolSinkBuilder::error_handler. The handler will be called when a record is dropped or an operation has failed.

Note

Errors that occur in log and flush will not be returned directly, instead the error handler will be called.

Examples

See ./examples directory.

Implementations

impl AsyncPoolSink

pub fn builder() -> AsyncPoolSinkBuilder

Available on crate feature multi-thread only.

Constructs a builder of AsyncPoolSink with default parameters:

Parameter	Default Value
level_filter	LevelFilter::All
error_handler	ErrorHandler::default()
overflow_policy	OverflowPolicy::Block
thread_pool	internal shared default thread pool

Examples found in repository

examples/07-async.rs (line 13)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let path = env::current_exe()?.with_file_name("async.log");
    let file_sink = FileSink::builder().path(path).build_arc()?;

    // AsyncPoolSink is a combined sink which wraps other sinks
    let async_pool_sink = AsyncPoolSink::builder().sink(file_sink).build_arc()?;

    let async_logger = Logger::builder()
        .sink(async_pool_sink)
        .flush_level_filter(LevelFilter::All)
        .build_arc()?;

    info!(logger: async_logger, "Hello, async!");

    Ok(())
}

pub fn sinks(&self) -> &[Arc<dyn Sink>]

Available on crate feature multi-thread only.

Gets a reference to internal sinks in the combined sink.

Trait Implementations

impl Sink for AsyncPoolSink

Available on crate feature multi-thread only.

fn log(&self, record: &Record<'_>) -> Result<()>

Logs a record.

fn flush(&self) -> Result<()>

Flushes any buffered records.

fn flush_on_exit(&self) -> Result<()>

Flushes any buffered records at program exit.

fn should_log(&self, level: Level) -> bool

Determines if a log message with the specified level would be logged.

impl SinkPropAccess for AsyncPoolSink

Available on crate feature multi-thread only.

fn set_formatter(&self, formatter: Box<dyn Formatter>)

For AsyncPoolSink, the function performs the same call to all internal sinks.

fn level_filter(&self) -> LevelFilter

Gets the log level filter.

fn set_level_filter(&self, level_filter: LevelFilter)

Sets the log level filter.

fn set_error_handler(&self, handler: ErrorHandler)

Sets a error handler.