Struct ConsoleHandler

pub struct ConsoleHandler { /* private fields */ }

A handler that writes to the console

Implementations

impl ConsoleHandler

pub fn stdout(level: LogLevel) -> Self

Create a new console handler that writes to stdout

pub fn stderr(level: LogLevel) -> Self

Create a new console handler that writes to stderr

pub fn with_writer( level: LogLevel, writer: Box<dyn Write + Send + Sync>, ) -> Self

Create a new console handler with a custom writer

pub fn with_colors(self, use_colors: bool) -> Self

Sets whether to use colors in the output.

pub fn with_pattern(self, pattern: impl Into<String>) -> Self

Sets a custom format pattern.

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

where F: Fn(&Record) -> String + Send + Sync + 'static,

Sets a custom format function for the handler.

pub fn with_formatter(self, formatter: Formatter) -> Self

pub fn with_filter(self, filter: HandlerFilter) -> Self

Trait Implementations

impl Clone for ConsoleHandler

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ConsoleHandler

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

Formats the value using the given formatter.

impl Default for ConsoleHandler

fn default() -> Self

Returns the “default value” for a type.

impl Handler for ConsoleHandler

fn handle(&self, record: &Record) -> Result<(), HandlerError>

Handle a log record

fn level(&self) -> LogLevel

Get the log level

fn set_level(&mut self, level: LogLevel)

Set the log level

fn is_enabled(&self) -> bool

Check if the handler is enabled

fn set_enabled(&mut self, enabled: bool)

Set whether the handler is enabled

fn formatter(&self) -> &Formatter

Get the formatter

fn set_formatter(&mut self, formatter: Formatter)

Set the formatter

fn set_filter(&mut self, filter: Option<HandlerFilter>)

Set a filter closure for this handler (optional, default: no filter)

fn filter(&self) -> Option<&HandlerFilter>

Get the filter closure for this handler (optional)

fn handle_batch(&self, records: &[Record]) -> Result<(), HandlerError>

Handle a batch of log records (optimized implementation)

fn init(&mut self) -> Result<(), HandlerError>

Lifecycle: initialize the handler

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

Lifecycle: flush the handler

fn shutdown(&mut self) -> Result<(), HandlerError>

Lifecycle: shutdown the handler