Enum flexi_logger::WriteMode

pub enum WriteMode {
    Direct,
    BufferAndFlush,
    BufferAndFlushWith(usize, Duration),
    Async,
    AsyncWith {
        bufsize: usize,
        pool_capa: usize,
        message_capa: usize,
        flush_interval: Duration,
    },
    BufferDontFlush,
}

Describes if the log output should be written synchronously or asynchronously, and if and how file I/O should be buffered and flushed.

Is used in Logger::write_mode.

Using buffering reduces the program’s I/O overhead, and thus increases overall performance, which can become relevant if logging is used heavily. On the other hand, if logging is used with low frequency, buffering can defer the appearance of log lines significantly, so regular flushing is usually advisable with buffering.

Note that for all options except Direct you should keep the LoggerHandle alive up to the very end of your program to ensure that all buffered log lines are flushed out (which happens automatically when the LoggerHandle is dropped) before the program terminates. See here for an example.

Note further that flushing uses an extra thread (with minimal stack).

Variants

Direct

Do not buffer (default).

Every log line is directly written to the output, without buffering. This allows seeing new log lines in real time, and does not need additional threads.

BufferAndFlush

Buffer with default capacity (DEFAULT_BUFFER_CAPACITY) and flush with default interval (DEFAULT_FLUSH_INTERVAL).

BufferAndFlushWith(usize, Duration)

Buffer and flush with given buffer capacity and flush interval.

Async

Lets the FileLogWriter send logs through an unbounded channel to an output thread, which does the file output, the rotation, and the cleanup.

Uses buffered output to reduce overhead, and a bounded message pool to reduce allocations. The log output is flushed regularly with the given interval.

See here for an example.

Only available with feature async.

AsyncWith

Like Async, but allows using non-default parameter values.

Only available with feature async.

Fields of AsyncWith

bufsize: usize

Size of the output buffer for the file.

pool_capa: usize

Capacity of the pool for the message buffers.

message_capa: usize

Capacity of an individual message buffer.

flush_interval: Duration

The interval for flushing the output.

BufferDontFlush

Buffer, but don’t flush.

This might be handy if you want to minimize I/O but don’t want to create the extra thread for flushing and don’t care if log lines appear with delay.

Trait Implementations

impl Clone for WriteMode

fn clone(&self) -> WriteMode

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for WriteMode