1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

use std::ffi::CStr;
use tracing::{info, Level};
use tracing_subscriber::{
    layer::SubscriberExt, util::SubscriberInitExt, EnvFilter, Layer,
};

#[derive(thiserror::Error, Debug)]
pub(crate) enum LoggingError {
    #[error("Failed to setup basic tracing: {source:?}")]
    SetupFailure { source: Box<dyn std::error::Error> },

    #[error(transparent)]
    IOError(#[from] std::io::Error),

    #[error(transparent)]
    TryInitError(#[from] tracing_subscriber::util::TryInitError),

    #[error("Failed to setup syslog logging")]
    SyslogError,
}

pub(crate) fn init(verbose: bool, container: bool) -> Result<(), LoggingError> {
    // The logger will log to stdout.
    //
    // We hold the opinion that the program is either "verbose"
    // or it's not.
    //
    // Normal mode: Info, Warn, Error
    // Verbose mode: Debug, Trace, Info, Warn, Error
    let tracing_level = if verbose { Level::TRACE } else { Level::INFO };

    if container {
        init_container_logging(tracing_level)
    } else {
        match std::process::id() {
            1 => init_pid1_logging(tracing_level),
            _ => init_daemon_logging(tracing_level),
        }
    }
}

fn init_container_logging(tracing_level: Level) -> Result<(), LoggingError> {
    info!("initializing container logging");

    // Stdout
    let stdout_layer = Layer::with_filter(
        tracing_subscriber::fmt::layer().compact(),
        EnvFilter::new(format!("auraed={tracing_level}")),
    );

    tracing_subscriber::registry()
        .with(stdout_layer)
        .try_init()
        .map_err(|e| e.into())
}

/// when we run as a daemon we want to log to stdout and syslog.
fn init_daemon_logging(tracing_level: Level) -> Result<(), LoggingError> {
    info!("initializing syslog logging");

    // Syslog
    let syslog_identity =
        CStr::from_bytes_with_nul(b"auraed\0").expect("valid CStr");
    let syslog_facility = Default::default();
    let syslog_options = syslog_tracing::Options::LOG_PID;
    let Some(syslog) = syslog_tracing::Syslog::new(
        syslog_identity,
        syslog_options,
        syslog_facility,
    ) else {
        return Err(LoggingError::SyslogError);
    };

    let syslog_layer = tracing_subscriber::fmt::layer().with_writer(syslog);

    // Stdout
    let stdout_layer = Layer::with_filter(
        tracing_subscriber::fmt::layer().compact(),
        EnvFilter::new(format!("auraed={tracing_level}")),
    );

    tracing_subscriber::registry()
        .with(syslog_layer)
        .with(stdout_layer)
        .try_init()
        .map_err(|e| e.into())
}

#[allow(unused)]
fn init_stdout_logging(tracing_level: Level) -> Result<(), LoggingError> {
    info!("initializing stdout logging");
    tracing_subscriber::fmt()
        .compact()
        .with_env_filter(format!("auraed={tracing_level}"))
        .finish()
        .try_init()
        .map_err(|e| e.into())
}

fn init_pid1_logging(tracing_level: Level) -> Result<(), LoggingError> {
    info!("initializing pid1 logging");
    tracing_subscriber::fmt()
        .compact()
        .with_env_filter(format!("auraed={tracing_level}"))
        .try_init()
        .map_err(|e| LoggingError::SetupFailure { source: e })
}