Struct Logger

pub struct Logger { /* private fields */ }

The configuration for logging.

Implementations

impl Logger

pub fn init_logging() -> Result<(), ExitError>

Initialize logging.

Initializes the logging system so it can be used before having read the configuration. The function sets a maximum log level of warn, leading to only printing important information, and directs all log output to stderr.

Examples found in repository

examples/reflect.rs (line 25)

fn _main() -> Result<(), ExitError> {
    Logger::init_logging()?;
    warn!("Logging initialized.");

    let args = Args::parse();
    let log = Logger::from_config(&args.log.to_config())?;
    let mut process = Process::from_config(args.process.into_config());

    log.switch_logging(args.detach)?;
    process.setup_daemon(args.detach)?;

    // This is where you create listener sockets so they can use privileged
    // ports.

    process.drop_privileges()?;

    warn!("Up and running.");

    // This is where we do something useful later.
    loop {
        std::thread::sleep(std::time::Duration::from_secs(60));
    }

    //Ok(())
}

pub fn from_config(config: &Config) -> Result<Self, Failed>

Creates the logger from a config struct.

Examples found in repository

examples/reflect.rs (line 29)

fn _main() -> Result<(), ExitError> {
    Logger::init_logging()?;
    warn!("Logging initialized.");

    let args = Args::parse();
    let log = Logger::from_config(&args.log.to_config())?;
    let mut process = Process::from_config(args.process.into_config());

    log.switch_logging(args.detach)?;
    process.setup_daemon(args.detach)?;

    // This is where you create listener sockets so they can use privileged
    // ports.

    process.drop_privileges()?;

    warn!("Up and running.");

    // This is where we do something useful later.
    loop {
        std::thread::sleep(std::time::Duration::from_secs(60));
    }

    //Ok(())
}

pub fn switch_logging(&self, daemon: bool) -> Result<(), Failed>

Switches logging to the configured target.

Once the configuration has been successfully loaded, logging should be switched to whatever the user asked for via this method.

The daemon argument changes how the default log target is interpreted: If it is true, syslog is used on Unix systems if available via one of the standard Unix sockets. Otherwise, stderr is used.

This method should only be called once. It returns an error if called again.

Examples found in repository

examples/reflect.rs (line 32)

fn _main() -> Result<(), ExitError> {
    Logger::init_logging()?;
    warn!("Logging initialized.");

    let args = Args::parse();
    let log = Logger::from_config(&args.log.to_config())?;
    let mut process = Process::from_config(args.process.into_config());

    log.switch_logging(args.detach)?;
    process.setup_daemon(args.detach)?;

    // This is where you create listener sockets so they can use privileged
    // ports.

    process.drop_privileges()?;

    warn!("Up and running.");

    // This is where we do something useful later.
    loop {
        std::thread::sleep(std::time::Duration::from_secs(60));
    }

    //Ok(())
}

pub fn rotate_log(&self) -> Result<(), Failed>

Rotates the log file if necessary.

Trait Implementations

impl Clone for Logger

fn clone(&self) -> Logger

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Logger

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

Formats the value using the given formatter.