second_brain_api/
logging.rs1use 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
13pub 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
36pub 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}