Struct flexi_logger::LoggerHandle

pub struct LoggerHandle { /* fields omitted */ }

Allows reconfiguring the logger programmatically.

Example

Obtain the LoggerHandle (using .start()):

let mut logger = Logger::with_str("info")
    // ... your logger configuration goes here, as usual
    .start()
    .unwrap_or_else(|e| panic!("Logger initialization failed with {}", e));

// ...

You can permanently exchange the log specification programmatically, anywhere in your code:

// ...
logger.parse_new_spec("warn");
// ...

However, when debugging, you often want to modify the log spec only temporarily, for
one or few method calls only; this is easier done with the following method, because it allows switching back to the previous spec:

logger.parse_and_push_temp_spec("trace");
// ...
// critical calls
// ...

logger.pop_temp_spec();
// Continue with the log spec you had before.
// ...

Implementations

impl LoggerHandle

pub fn set_new_spec(&mut self, new_spec: LogSpecification)

Replaces the active LogSpecification.

pub fn parse_new_spec(&mut self, spec: &str)

Tries to replace the active LogSpecification with the result from parsing the given String.

pub fn push_temp_spec(&mut self, new_spec: LogSpecification)

Replaces the active LogSpecification and pushes the previous one to a Stack.

pub fn parse_and_push_temp_spec(&mut self, new_spec: &str)

Tries to replace the active LogSpecification with the result from parsing the given String and pushes the previous one to a Stack.

pub fn pop_temp_spec(&mut self)

Reverts to the previous LogSpecification, if any.

pub fn flush(&self)

Flush all writers.

pub fn shutdown(&self)

Shutdown all participating writers.

This method is supposed to be called at the very end of your program, if

• you use buffering (to ensure that all buffered log lines are flushed before the program terminates)
• you use your own writer(s) (in case they need to cleanup resources)
• or if you want to securely shutdown the cleanup-thread of the FileLogWriter (if you use a Cleanup strategy with compressing, and your process terminates without correctly shutting down the cleanup-thread, then you might stop the cleanup-thread while it is compressing a log file, which can leave unexpected files in the filesystem)

See also LogWriter::shutdown.

Trait Implementations

impl Clone for LoggerHandle

fn clone(&self) -> LoggerHandle

Returns a copy of the value.

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

Performs copy-assignment from source.