use std::fs::File;
use std::io::Write;
use std::path::Path;
use std::sync::mpsc::Sender;
use crate::config::LogFormat;
use crate::error_handling::InitializationError;
use crate::initialization::log_filters;
use crate::utils::ensure_parent_dir_secure;
use colored::Colorize;
use log::LevelFilter;
struct ChannelLogWriter {
sender: Sender<Vec<u8>>,
}
impl Write for ChannelLogWriter {
fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
let _ = self.sender.send(buf.to_vec());
Ok(buf.len())
}
fn flush(&mut self) -> std::io::Result<()> {
Ok(())
}
}
fn spawn_log_writer_thread(file: File) -> Sender<Vec<u8>> {
let (tx, rx) = std::sync::mpsc::channel::<Vec<u8>>();
std::thread::Builder::new()
.name("domain-status-log-writer".to_string())
.spawn(move || {
let mut file = file;
while let Ok(buf) = rx.recv() {
if file.write_all(&buf).is_err() {
break;
}
let _ = file.flush();
}
})
.expect("failed to spawn log writer thread");
tx
}
pub fn init_logger_with(level: LevelFilter, format: LogFormat) -> Result<(), InitializationError> {
colored::control::set_override(true);
let mut builder = env_logger::Builder::from_default_env();
builder.filter_level(level);
log_filters::apply_silenced_crates(&mut builder, level);
builder.target(env_logger::Target::Stderr);
match format {
LogFormat::Json => {
builder.format(|buf, record| {
writeln!(
buf,
"{{\"ts\":{},\"level\":\"{}\",\"target\":\"{}\",\"msg\":{}}}",
chrono::Utc::now().timestamp_millis(),
record.level(),
record.target(),
serde_json::to_string(&record.args().to_string())
.unwrap_or_else(|_| "\"\"".into())
)
});
}
LogFormat::Plain => {
builder.format(|buf, record| {
let level = record.level();
let colored_level = match level {
log::Level::Error => level.to_string().red(),
log::Level::Warn => level.to_string().yellow(),
log::Level::Info => level.to_string().green(),
log::Level::Debug => level.to_string().blue(),
log::Level::Trace => level.to_string().purple(),
};
let emoji = match level {
log::Level::Error => "❌",
log::Level::Warn => "⚠️",
log::Level::Info => "✔️",
log::Level::Debug => "🔍",
log::Level::Trace => "🔬",
};
writeln!(
buf,
"{} {} [{}] {}",
emoji,
record.target().cyan(),
colored_level,
record.args()
)
});
}
_ => {
builder.format(|buf, record| {
writeln!(
buf,
"[{}] {} - {}",
record.level(),
record.target(),
record.args()
)
});
}
}
builder.try_init().map_err(InitializationError::from)?;
Ok(())
}
pub fn init_logger_to_file(
level: LevelFilter,
format: LogFormat,
log_file: &Path,
) -> Result<(), InitializationError> {
ensure_parent_dir_secure(log_file).map_err(|e| {
InitializationError::LoggerSetupError(format!("Failed to create log directory: {e}"))
})?;
let file = File::create(log_file).map_err(|e| {
InitializationError::LoggerSetupError(format!("Failed to create log file: {e}"))
})?;
let writer_tx = spawn_log_writer_thread(file);
let mut builder = env_logger::Builder::from_default_env();
builder.filter_level(level);
log_filters::apply_silenced_crates(&mut builder, level);
match format {
LogFormat::Json => {
builder.format(|buf, record| {
writeln!(
buf,
r#"{{"ts":"{}","level":"{}","target":"{}","msg":{}}}"#,
chrono::Local::now().format("%Y-%m-%dT%H:%M:%S%.3f"),
record.level(),
record.target(),
serde_json::to_string(&record.args().to_string())
.unwrap_or_else(|_| { format!("{:?}", record.args().to_string()) })
)
});
}
LogFormat::Plain => {
builder.format(|buf, record| {
writeln!(
buf,
"[{}] {} {} - {}",
chrono::Local::now().format("%Y-%m-%d %H:%M:%S%.3f"),
record.level(),
record.target(),
record.args()
)
});
}
_ => {
builder.format(|buf, record| {
writeln!(
buf,
"[{}] {} {} - {}",
chrono::Local::now().format("%Y-%m-%d %H:%M:%S%.3f"),
record.level(),
record.target(),
record.args()
)
});
}
}
builder.target(env_logger::Target::Pipe(Box::new(ChannelLogWriter {
sender: writer_tx,
})));
builder.try_init().map_err(InitializationError::from)?;
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_channel_log_writer_round_trips_bytes_to_file() {
use std::io::Read;
let temp_file = tempfile::NamedTempFile::new().expect("tempfile");
let path = temp_file.path().to_path_buf();
let file = File::create(&path).expect("create");
let tx = spawn_log_writer_thread(file);
let mut writer = ChannelLogWriter { sender: tx };
writer
.write_all(b"[fixture] WARN domain_status::test - first\n")
.expect("first write_all enqueue");
writer
.write_all(b"[fixture] INFO domain_status::test - second\n")
.expect("second write_all enqueue");
drop(writer);
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(5);
loop {
let mut content = String::new();
File::open(&path)
.and_then(|mut f| f.read_to_string(&mut content))
.expect("read log file");
if content.contains("first") && content.contains("second") {
assert!(
content.contains("[fixture] WARN domain_status::test - first"),
"expected exact first record, got: {content}"
);
assert!(
content.contains("[fixture] INFO domain_status::test - second"),
"expected exact second record, got: {content}"
);
return;
}
assert!(
std::time::Instant::now() < deadline,
"writer thread didn't flush both records within 5s; got: {content}"
);
std::thread::sleep(std::time::Duration::from_millis(10));
}
}
#[test]
fn test_init_logger_to_file_invalid_path() {
let blocker = tempfile::NamedTempFile::new().expect("tempfile");
let invalid_path = blocker.path().join("nested").join("log.txt");
let result = init_logger_to_file(LevelFilter::Info, LogFormat::Plain, &invalid_path);
assert!(
result.is_err(),
"Should fail when parent path is not a directory"
);
let err = result.unwrap_err();
match &err {
InitializationError::LoggerSetupError(_) => {}
InitializationError::LoggerError(_) => {}
_ => {
panic!("Expected LoggerSetupError or LoggerError, got: {:?}", err);
}
}
}
}