Struct flexi_logger::ReconfigurationHandle

pub struct ReconfigurationHandle { /* fields omitted */ }

Allows reconfiguring the logger programmatically.

Example

Obtain the ReconfigurationHandle (using .start()):

let mut log_handle = 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:

// ...
log_handle.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:

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

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

Implementations

impl ReconfigurationHandle

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 shutdown(&self)

Shutdown all participating writers.

This method is supposed to be called at the very end of your program, in case you use your own writers, or if you want to securely shutdown the cleanup-thread of the FileLogWriter. If you use a Cleanup strategy with zipping, and your process terminates without correctly shutting down the cleanup-thread, then you might stop the cleanup-thread while it is zipping a log file, which can leave unexpected files in the filesystem.

See also LogWriter::shutdown.

Trait Implementations

impl Clone for ReconfigurationHandle

fn clone(&self) -> ReconfigurationHandle

Returns a copy of the value.

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

Performs copy-assignment from source.