acmed/acme_common/src/logs.rs

use crate::error::Error;
use env_logger::Builder;
use log::LevelFilter;
use syslog::Facility;

pub const DEFAULT_LOG_SYSTEM: LogSystem = LogSystem::SysLog;
pub const DEFAULT_LOG_LEVEL: LevelFilter = LevelFilter::Warn;

#[derive(Debug, PartialEq, Eq)]
pub enum LogSystem {
    SysLog,
    StdErr,
}

fn get_loglevel(log_level: Option<&str>) -> Result<LevelFilter, Error> {
    let level = match log_level {
        Some(v) => match v {
            "error" => LevelFilter::Error,
            "warn" => LevelFilter::Warn,
            "info" => LevelFilter::Info,
            "debug" => LevelFilter::Debug,
            "trace" => LevelFilter::Trace,
            _ => {
                return Err(format!("{}: invalid log level", v).into());
            }
        },
        None => DEFAULT_LOG_LEVEL,
    };
    Ok(level)
}

fn set_log_syslog(log_level: LevelFilter) -> Result<(), Error> {
    syslog::init(
        Facility::LOG_DAEMON,
        log_level,
        Some(env!("CARGO_PKG_NAME")),
    )?;
    Ok(())
}

fn set_log_stderr(log_level: LevelFilter) -> Result<(), Error> {
    let mut builder = Builder::from_env("ACMED_LOG_LEVEL");
    builder.filter_level(log_level);
    builder.init();
    Ok(())
}

pub fn set_log_system(
    log_level: Option<&str>,
    has_syslog: bool,
    has_stderr: bool,
) -> Result<(LogSystem, LevelFilter), Error> {
    let log_level = get_loglevel(log_level)?;
    let logtype = if has_syslog {
        LogSystem::SysLog
    } else if has_stderr {
        LogSystem::StdErr
    } else {
        DEFAULT_LOG_SYSTEM
    };
    match logtype {
        LogSystem::SysLog => set_log_syslog(log_level)?,
        LogSystem::StdErr => set_log_stderr(log_level)?,
    };
    Ok((logtype, log_level))
}

#[cfg(test)]
mod tests {
    use super::{set_log_system, DEFAULT_LOG_LEVEL, DEFAULT_LOG_SYSTEM};

    #[test]
    fn test_invalid_level() {
        let ret = set_log_system(Some("invalid"), false, false);
        assert!(ret.is_err());
    }

    #[test]
    fn test_default_values() {
        let ret = set_log_system(None, false, false);
        assert!(ret.is_ok());
        let (logtype, log_level) = ret.unwrap();
        assert_eq!(logtype, DEFAULT_LOG_SYSTEM);
        assert_eq!(log_level, DEFAULT_LOG_LEVEL);
    }
}