Struct LoggerOptions 

pub struct LoggerOptions {
    pub levels: Option<LoggerLevels>,
    pub format: Option<Arc<dyn Format<Input = LogInfo> + Send + Sync>>,
    pub level: Option<String>,
    pub transports: Option<Vec<(TransportHandle, LoggerTransport<LogInfo>)>>,
    pub channel_capacity: Option<usize>,
    pub backpressure_strategy: Option<BackpressureStrategy>,
}

Fields

levels: Option<LoggerLevels>

format: Option<Arc<dyn Format<Input = LogInfo> + Send + Sync>>

level: Option<String>

transports: Option<Vec<(TransportHandle, LoggerTransport<LogInfo>)>>

channel_capacity: Option<usize>

backpressure_strategy: Option<BackpressureStrategy>

Implementations

impl LoggerOptions

pub fn new() -> Self

Creates a new LoggerOptions instance with default settings.

pub fn level<T: Into<String>>(self, level: T) -> Self

Sets the logging level for the logger.

Arguments

• level - A string slice that represents the logging level.

pub fn format<F>(self, format: F) -> Self

where F: Format<Input = LogInfo> + Send + Sync + 'static,

Sets the log format for the logger.

Arguments

• format - The log format to be used.

pub fn transport(self, transport: impl IntoLoggerTransport) -> Self

Adds a single transport to the existing list of transports.

This method is additive — it appends the provided transport to any previously added transports. Each transport is automatically wrapped in an Arc and assigned a unique [TransportHandle].

This method accepts either a raw transport or a pre-configured LoggerTransport.

Example

use winston_rs::LoggerOptions;

// Raw transport
let options = LoggerOptions::new()
    .transport(stdout())
    .transport(FileTransport::new("app.log"));

// Pre-configured transport
let options = LoggerOptions::new()
    .transport(
        LoggerTransport::new(FileTransport::new("app.log"))
            .with_level("debug")
            .with_format(json())
    );

Each call to transport appends a new transport, allowing multiple outputs (e.g. console + file + network) to be used simultaneously.

pub fn transports<I>(self, transports: I) -> Self

where I: IntoIterator, I::Item: IntoLoggerTransport,

Replaces all transports with the provided collection.

This method is not additive — it replaces any previously configured transports. Each transport must already be wrapped in an Arc and will be assigned a unique [TransportHandle].

Example

use winston_rs::LoggerOptions;
use std::sync::Arc;

let transports = vec![
    Arc::new(stdout()),
    Arc::new(FileTransport::new("app.log")),
];
let options = LoggerOptions::new().transports(transports);

Use this method when you want to replace all existing transports instead of appending new ones. Multiple calls to .transports() will override the previous collection.

pub fn levels(self, levels: HashMap<String, u8>) -> Self

Sets custom logging levels for the logger.

Arguments

• levels - A HashMap where the key is the level name and the value is its severity.

pub fn channel_capacity(self, capacity: usize) -> Self

Sets the channel capacity for the logger.

Arguments

• capacity - An usize that defines the capacity of the channel.

pub fn backpressure_strategy(self, strategy: BackpressureStrategy) -> Self

Sets the backpressure strategy for the logger.

Arguments

• strategy - The backpressure strategy to apply when the channel is full.

Trait Implementations

impl Clone for LoggerOptions

fn clone(&self) -> LoggerOptions

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LoggerOptions

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for LoggerOptions

fn default() -> Self

Provides the default configuration for LoggerOptions.

The default configuration includes:

• A default set of logging levels.
• The logging level set to “info”.
• No default transports.
• The JSON format for log entries.
• A channel capacity of 1024.
• A backpressure strategy set to BackpressureStrategy::Block, meaning the logger will block on overflow until space is available.