Module writers 

Describes how to extend flexi_logger with additional log writers.

The module also contains two ready-to-use log writers, one for writing to files (FileLogWriter), one for writing to the syslog ([SyslogWriter]).

Log writers can be used in two ways:

• Default output channel:
  You can influence to which output stream normal log messages will be written, i.e. those from log macro calls without explicit target specification (like in log::error!("File not found")).

  With one of the methods

  • Logger::log_to_stderr (default)
  • Logger::log_to_stdout
  • Logger::log_to_file
  • Logger::log_to_writer
  • Logger::log_to_file_and_writer
  • Logger::do_not_log

  you can change the default output channel. The fourth and the fifth of these methods take log writers as input. See their documentation for more details.

  Messages will only be written to the default output channel if they match the current log specification.

  
  

• Additional output channels:
  You can register additional log writers under a target name with Logger::add_writer(), and address these log writers by specifying the target name in calls to the log macros.

  The message of a log call with a target value that has the form {Name1,Name2,...}, i.e., a comma-separated list of target names, within braces, is not sent to the default output channel, but to the loggers specified explicitly in the list. In such a list you can also specify the default output channel with the built-in target name _Default.

  Log calls that are directed to an additional output channel will not be affected by the value of flexi_logger’s log specification; they will always be handed over to the respective LogWriter, as you might want it for alerts or auditing.

  In the following example we define an alert writer, and a macro to facilitate using it (and avoid using the explicit target specification in the macro call), and show some example calls.

  use log::*;
  
  use flexi_logger::{FileSpec,Logger};
  use flexi_logger::writers::FileLogWriter;
  
  // Configure a FileLogWriter for alert messages
  pub fn alert_logger() -> Box<FileLogWriter> {
      Box::new(FileLogWriter::builder(
          FileSpec::default()
              .discriminant("Alert")
              .suffix("alerts")
          )
          .print_message()
          .try_build()
          .unwrap())
  }
  
  // Define a macro for writing messages to the alert log and to the normal log
  #[macro_use]
  mod macros {
      #[macro_export]
      macro_rules! alert_error {
          ($($arg:tt)*) => (
              error!(target: "{Alert,_Default}", $($arg)*);
          )
      }
  }
  
  fn main() {
      Logger::try_with_env_or_str("info")
          .expect("LogSpecification String has errors")
          .print_message()
          .log_to_file(FileSpec::default())
          .add_writer("Alert", alert_logger())
          .start()
          .unwrap_or_else(|e| panic!("Logger initialization failed with {}", e));
  
  
      // Explicitly send logs to different loggers
      error!(target : "{Alert}", "This is only an alert");
      error!(target : "{Alert,_Default}", "This is an alert and log message");
  
      // Nicer: use the explicit macro
      alert_error!("This is another alert and log message");
  
      // Standard log macros write only to the normal log
      error!("This is a normal error message");
      warn!("This is a warning");
      info!("This is an info message");
      debug!("This is a debug message - you will not see it");
      trace!("This is a trace message - you will not see it");
  }
  

Structs

ArcFileLogWriter

A shareable FileLogWriter with a handle.

FileLogWriter

A configurable LogWriter implementation that writes to a file or a sequence of files.

FileLogWriterBuilder

Builder for FileLogWriter.

FileLogWriterConfig

Configuration of a FileLogWriter.

FileLogWriterHandle

Handle to the FileLogWriter in an ArcFileLogWriter that shuts down the FileLogWriter in its Drop implementation.

Traits

LogWriter

Writes to a single log output stream.