Skip to main content

second_brain_api/
logging.rs

1use std::ffi::OsString;
2use std::path::{Path, PathBuf};
3
4use tracing_appender::rolling::{RollingFileAppender, Rotation};
5use tracing_subscriber::EnvFilter;
6use tracing_subscriber::fmt::writer::BoxMakeWriter;
7
8pub const LOG_DIR_ENV: &str = "SECOND_BRAIN_LOG_DIR";
9pub const FILE_PREFIX: &str = "second-brain";
10pub const KEPT_FILES: usize = 7;
11const DEFAULT_DIRECTIVES: &str = "error,second_brain=info,tower_http=debug";
12
13/// A non-blank `RUST_LOG` replaces the defaults instead of extending them,
14/// because a bare level in it would only replace the `error` catch-all and
15/// leave `tower_http=debug` in force.
16pub fn filter(rust_log: Option<&str>) -> EnvFilter {
17    let directives = rust_log
18        .filter(|v| !v.trim().is_empty())
19        .unwrap_or(DEFAULT_DIRECTIVES);
20    EnvFilter::builder().parse_lossy(directives)
21}
22
23pub fn log_dir(value: Option<OsString>) -> Option<PathBuf> {
24    value.filter(|v| !v.is_empty()).map(PathBuf::from)
25}
26
27pub fn file_writer(dir: &Path) -> anyhow::Result<RollingFileAppender> {
28    Ok(RollingFileAppender::builder()
29        .rotation(Rotation::DAILY)
30        .filename_prefix(FILE_PREFIX)
31        .filename_suffix("log")
32        .max_log_files(KEPT_FILES)
33        .build(dir)?)
34}
35
36/// Logs to a daily file under `SECOND_BRAIN_LOG_DIR` when it is set, because
37/// launchd never rotates the stdout and stderr files it was given; otherwise
38/// to stderr.
39pub fn init() {
40    let filter = filter(std::env::var("RUST_LOG").ok().as_deref());
41    let file = log_dir(std::env::var_os(LOG_DIR_ENV)).and_then(|dir| {
42        file_writer(&dir)
43            .inspect_err(|e| eprintln!("cannot log to {}: {e:#}; logging to stderr", dir.display()))
44            .ok()
45    });
46    let builder = tracing_subscriber::fmt().with_env_filter(filter);
47    match file {
48        Some(appender) => builder
49            .with_ansi(false)
50            .with_writer(BoxMakeWriter::new(appender))
51            .init(),
52        None => builder.with_writer(std::io::stderr).init(),
53    }
54}
55
56#[cfg(test)]
57mod tests {
58    use std::io::Write;
59    use std::sync::{Arc, Mutex};
60
61    use tracing_subscriber::fmt::MakeWriter;
62
63    use super::*;
64
65    #[derive(Clone, Default)]
66    struct Captured(Arc<Mutex<Vec<u8>>>);
67
68    impl Write for Captured {
69        fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
70            self.0.lock().unwrap().extend_from_slice(buf);
71            Ok(buf.len())
72        }
73        fn flush(&mut self) -> std::io::Result<()> {
74            Ok(())
75        }
76    }
77
78    impl<'a> MakeWriter<'a> for Captured {
79        type Writer = Captured;
80        fn make_writer(&'a self) -> Self::Writer {
81            self.clone()
82        }
83    }
84
85    fn emit_all() {
86        tracing::debug!(target: "tower_http::trace::on_request", "tower-debug");
87        tracing::warn!(target: "tower_http::trace::on_failure", "tower-warn");
88        tracing::info!(target: "second_brain_api::ingest", "brain-info");
89        tracing::debug!(target: "second_brain_api::ingest", "brain-debug");
90        tracing::info!(target: "hyper::proto", "hyper-info");
91        tracing::error!(target: "hyper::proto", "hyper-error");
92    }
93
94    fn logged(rust_log: Option<&str>) -> String {
95        let out = Captured::default();
96        let subscriber = tracing_subscriber::fmt()
97            .with_env_filter(filter(rust_log))
98            .without_time()
99            .with_writer(out.clone())
100            .finish();
101        tracing::subscriber::with_default(subscriber, emit_all);
102        String::from_utf8(out.0.lock().unwrap().clone()).unwrap()
103    }
104
105    #[test]
106    fn defaults_log_requests_at_debug_and_other_crates_only_on_error() {
107        let out = logged(None);
108        for line in ["tower-debug", "tower-warn", "brain-info", "hyper-error"] {
109            assert!(out.contains(line), "{line} missing from:\n{out}");
110        }
111        for line in ["brain-debug", "hyper-info"] {
112            assert!(!out.contains(line), "{line} leaked into:\n{out}");
113        }
114    }
115
116    #[test]
117    fn rust_log_overrides_the_tower_http_default() {
118        let out = logged(Some("info,tower_http=warn"));
119        for line in ["tower-warn", "brain-info", "hyper-info", "hyper-error"] {
120            assert!(out.contains(line), "{line} missing from:\n{out}");
121        }
122        for line in ["tower-debug", "brain-debug"] {
123            assert!(!out.contains(line), "{line} leaked into:\n{out}");
124        }
125    }
126
127    #[test]
128    fn bare_rust_log_level_replaces_every_default() {
129        let out = logged(Some("warn"));
130        for line in ["tower-warn", "hyper-error"] {
131            assert!(out.contains(line), "{line} missing from:\n{out}");
132        }
133        for line in ["tower-debug", "brain-info", "hyper-info"] {
134            assert!(!out.contains(line), "{line} leaked into:\n{out}");
135        }
136    }
137
138    #[test]
139    fn blank_rust_log_keeps_the_defaults() {
140        assert_eq!(logged(Some("  ")), logged(None));
141    }
142
143    fn log_files(dir: &Path) -> Vec<String> {
144        let mut names: Vec<String> = std::fs::read_dir(dir)
145            .unwrap()
146            .map(|e| e.unwrap().file_name().into_string().unwrap())
147            .filter(|n| n.starts_with(FILE_PREFIX))
148            .collect();
149        names.sort();
150        names
151    }
152
153    #[test]
154    fn log_dir_gets_a_daily_file_and_keeps_seven() {
155        let dir = tempfile::tempdir().unwrap();
156        for day in 1..=10 {
157            std::fs::write(
158                dir.path()
159                    .join(format!("{FILE_PREFIX}.2020-01-{day:02}.log")),
160                "old\n",
161            )
162            .unwrap();
163        }
164        std::fs::write(dir.path().join("launchd.log"), "panic\n").unwrap();
165
166        let subscriber = tracing_subscriber::fmt()
167            .with_env_filter(filter(None))
168            .with_ansi(false)
169            .with_writer(file_writer(dir.path()).unwrap())
170            .finish();
171        tracing::subscriber::with_default(subscriber, emit_all);
172
173        let files = log_files(dir.path());
174        assert_eq!(files.len(), KEPT_FILES, "{files:?}");
175        let today = chrono::Utc::now().format("%Y-%m-%d");
176        let current =
177            std::fs::read_to_string(dir.path().join(format!("{FILE_PREFIX}.{today}.log"))).unwrap();
178        assert!(current.contains("brain-info"), "{current}");
179        assert!(dir.path().join("launchd.log").exists());
180    }
181
182    #[test]
183    fn log_dir_is_unset_when_the_variable_is_missing_or_empty() {
184        assert_eq!(log_dir(None), None);
185        assert_eq!(log_dir(Some(OsString::new())), None);
186        assert_eq!(
187            log_dir(Some(OsString::from("/var/log/sb"))),
188            Some(PathBuf::from("/var/log/sb"))
189        );
190    }
191}