use crate::handle;
use std::io;
use std::sync::atomic::{AtomicU8, Ordering};
use std::sync::Arc;
pub use handle::LogHandle;
struct WriterEntry {
writer: Box<dyn log::Log>,
}
impl WriterEntry {
fn new(w: impl log::Log + 'static) -> (Self, LogHandle) {
let level = Arc::new(AtomicU8::new(handle::level_to_u8(log::LevelFilter::Trace)));
let log_handle = LogHandle { level: level.clone() };
(
Self {
writer: Box::new(Wrapper {
writer: Box::new(w),
level,
}),
},
log_handle,
)
}
fn new_boxed(w: Box<dyn log::Log>) -> (Self, LogHandle) {
let level = Arc::new(AtomicU8::new(handle::level_to_u8(log::LevelFilter::Trace)));
let log_handle = LogHandle { level: level.clone() };
(
Self {
writer: Box::new(Wrapper { writer: w, level }),
},
log_handle,
)
}
}
struct Wrapper {
writer: Box<dyn log::Log>,
level: Arc<AtomicU8>,
}
impl log::Log for Wrapper {
fn enabled(&self, metadata: &log::Metadata<'_>) -> bool {
let current_level =
handle::u8_to_level(self.level.load(Ordering::Relaxed));
metadata.level() <= current_level && self.writer.enabled(metadata)
}
fn log(&self, record: &log::Record<'_>) {
let current_level =
handle::u8_to_level(self.level.load(Ordering::Relaxed));
if record.level() <= current_level {
self.writer.log(record);
}
}
fn flush(&self) {
self.writer.flush();
}
}
pub struct MultiLog {
writers: Vec<Box<dyn log::Log>>,
}
impl MultiLog {
pub fn new() -> MultiLogBuilder {
MultiLogBuilder::new()
}
}
impl log::Log for MultiLog {
fn enabled(&self, metadata: &log::Metadata<'_>) -> bool {
self.writers
.iter()
.any(|w| w.enabled(metadata))
}
fn log(&self, record: &log::Record<'_>) {
for writer in &self.writers {
if writer.enabled(record.metadata()) {
writer.log(record);
}
}
}
fn flush(&self) {
for writer in &self.writers {
writer.flush();
}
}
}
pub struct MultiLogBuilder {
entries: Vec<WriterEntry>,
}
impl MultiLogBuilder {
pub fn new() -> Self {
Self {
entries: Vec::new(),
}
}
pub fn writer(mut self, w: impl log::Log + 'static) -> Self {
let (entry, _) = WriterEntry::new(w);
self.entries.push(entry);
self
}
pub fn writer_boxed(mut self, w: Box<dyn log::Log>) -> Self {
let (entry, _) = WriterEntry::new_boxed(w);
self.entries.push(entry);
self
}
pub fn writer_with_handle(self, w: impl log::Log + 'static) -> MultiLogBuilderWithHandles {
let (entry, log_handle) = WriterEntry::new(w);
let mut builder = MultiLogBuilderWithHandles {
entries: Vec::new(),
handles: Vec::new(),
};
builder.entries.extend(self.entries);
builder.entries.push(entry);
builder.handles.push(log_handle);
builder
}
pub fn build(self) -> io::Result<MultiLog> {
if self.entries.is_empty() {
return Err(io::Error::new(
io::ErrorKind::InvalidInput,
"MultiLog requires at least one writer",
));
}
Ok(MultiLog {
writers: self.entries.into_iter().map(|e| e.writer).collect(),
})
}
pub fn init(self) -> io::Result<MultiHandle> {
let multi = self.build()?;
let max_level = log::LevelFilter::Trace;
let level = Arc::new(AtomicU8::new(handle::level_to_u8(max_level)));
log::set_max_level(max_level);
let boxed = Box::new(multi);
log::set_boxed_logger(boxed).map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
Ok(MultiHandle {
level,
writer_handles: None,
})
}
}
impl Default for MultiLogBuilder {
fn default() -> Self {
Self::new()
}
}
pub struct MultiLogBuilderWithHandles {
entries: Vec<WriterEntry>,
handles: Vec<LogHandle>,
}
impl MultiLogBuilderWithHandles {
pub fn writer_with_handle(mut self, w: impl log::Log + 'static) -> Self {
let (entry, log_handle) = WriterEntry::new(w);
self.entries.push(entry);
self.handles.push(log_handle);
self
}
pub fn build_with_handles(self) -> io::Result<(MultiLog, Vec<LogHandle>)> {
if self.entries.is_empty() {
return Err(io::Error::new(
io::ErrorKind::InvalidInput,
"MultiLog requires at least one writer",
));
}
let multi = MultiLog {
writers: self.entries.into_iter().map(|e| e.writer).collect(),
};
Ok((multi, self.handles))
}
pub fn init_with_handles(self) -> io::Result<MultiHandle> {
let (multi, handles) = self.build_with_handles()?;
let max_level = log::LevelFilter::Trace;
let level = Arc::new(AtomicU8::new(handle::level_to_u8(max_level)));
log::set_max_level(max_level);
let boxed = Box::new(multi);
log::set_boxed_logger(boxed).map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
Ok(MultiHandle {
level,
writer_handles: Some(handles),
})
}
}
#[derive(Clone)]
pub struct MultiHandle {
level: Arc<AtomicU8>,
writer_handles: Option<Vec<LogHandle>>,
}
impl MultiHandle {
pub fn max_level(&self) -> log::LevelFilter {
handle::u8_to_level(self.level.load(Ordering::Relaxed))
}
pub fn writer_handles(&self) -> Option<&[LogHandle]> {
self.writer_handles.as_deref()
}
pub fn writer_handle(&self, index: usize) -> Option<&LogHandle> {
self.writer_handles.as_ref()?.get(index)
}
}
#[cfg(test)]
mod tests {
use super::*;
use log::Log;
use std::sync::{Arc, Mutex};
struct TestWriter {
level: log::LevelFilter,
records: Arc<Mutex<Vec<String>>>,
}
impl TestWriter {
fn new(level: log::LevelFilter) -> (Self, Arc<Mutex<Vec<String>>>) {
let records = Arc::new(Mutex::new(Vec::new()));
(
Self {
level,
records: records.clone(),
},
records,
)
}
}
impl log::Log for TestWriter {
fn enabled(&self, metadata: &log::Metadata<'_>) -> bool {
metadata.level() <= self.level
}
fn log(&self, record: &log::Record<'_>) {
self.records.lock().unwrap().push(format!(
"{} {}",
record.level(),
record.args()
));
}
fn flush(&self) {}
}
#[test]
fn test_multi_dispatches_to_all_writers() {
let (w1, records1) = TestWriter::new(log::LevelFilter::Debug);
let (w2, records2) = TestWriter::new(log::LevelFilter::Info);
let multi = MultiLog::new()
.writer(w1)
.writer(w2)
.build()
.unwrap();
let record = log::Record::builder()
.level(log::Level::Info)
.target("test")
.args(format_args!("hello"))
.build();
multi.log(&record);
assert_eq!(records1.lock().unwrap().len(), 1);
assert_eq!(records2.lock().unwrap().len(), 1);
let record = log::Record::builder()
.level(log::Level::Debug)
.target("test")
.args(format_args!("debug msg"))
.build();
multi.log(&record);
assert_eq!(records1.lock().unwrap().len(), 2);
assert_eq!(records2.lock().unwrap().len(), 1);
}
#[test]
fn test_empty_builder_fails() {
let result = MultiLog::new().build();
assert!(result.is_err());
}
#[test]
fn test_flush_all_writers() {
let (w1, _) = TestWriter::new(log::LevelFilter::Info);
let (w2, _) = TestWriter::new(log::LevelFilter::Info);
let multi = MultiLog::new()
.writer(w1)
.writer(w2)
.build()
.unwrap();
multi.flush(); }
struct DynamicTestWriter {
level: Arc<AtomicU8>,
records: Arc<Mutex<Vec<String>>>,
}
impl DynamicTestWriter {
fn new(level: log::LevelFilter) -> (Self, LogHandle, Arc<Mutex<Vec<String>>>) {
let level = Arc::new(AtomicU8::new(handle::level_to_u8(level)));
let records = Arc::new(Mutex::new(Vec::new()));
let log_handle = LogHandle { level: level.clone() };
(
Self {
level,
records: records.clone(),
},
log_handle,
records,
)
}
}
impl log::Log for DynamicTestWriter {
fn enabled(&self, metadata: &log::Metadata<'_>) -> bool {
metadata.level()
<= handle::u8_to_level(self.level.load(Ordering::Relaxed))
}
fn log(&self, record: &log::Record<'_>) {
self.records.lock().unwrap().push(format!(
"{} {} (level={:?})",
record.level(),
record.args(),
handle::u8_to_level(self.level.load(Ordering::Relaxed)),
));
}
fn flush(&self) {}
}
#[test]
fn test_dynamic_level_adjust_per_writer() {
let (w1, handle1, rec1) = DynamicTestWriter::new(log::LevelFilter::Debug);
let (w2, handle2, rec2) = DynamicTestWriter::new(log::LevelFilter::Info);
let multi = MultiLog::new()
.writer(w1)
.writer(w2)
.build()
.unwrap();
assert_eq!(handle1.get_level(), log::LevelFilter::Debug);
assert_eq!(handle2.get_level(), log::LevelFilter::Info);
let record = log::Record::builder()
.level(log::Level::Debug)
.target("test")
.args(format_args!("debug message"))
.build();
multi.log(&record);
assert_eq!(rec1.lock().unwrap().len(), 1);
assert_eq!(rec2.lock().unwrap().len(), 0);
let record = log::Record::builder()
.level(log::Level::Info)
.target("test")
.args(format_args!("info message"))
.build();
multi.log(&record);
assert_eq!(rec1.lock().unwrap().len(), 2);
assert_eq!(rec2.lock().unwrap().len(), 1);
handle1.set_level(log::LevelFilter::Error);
handle2.set_level(log::LevelFilter::Trace);
assert_eq!(handle1.get_level(), log::LevelFilter::Error);
assert_eq!(handle2.get_level(), log::LevelFilter::Trace);
let record = log::Record::builder()
.level(log::Level::Warn)
.target("test")
.args(format_args!("warn message"))
.build();
multi.log(&record);
assert_eq!(rec1.lock().unwrap().len(), 2); assert_eq!(rec2.lock().unwrap().len(), 2);
let record = log::Record::builder()
.level(log::Level::Trace)
.target("test")
.args(format_args!("trace message"))
.build();
multi.log(&record);
assert_eq!(rec1.lock().unwrap().len(), 2); assert_eq!(rec2.lock().unwrap().len(), 3);
let record = log::Record::builder()
.level(log::Level::Error)
.target("test")
.args(format_args!("error message"))
.build();
multi.log(&record);
assert_eq!(rec1.lock().unwrap().len(), 3); assert_eq!(rec2.lock().unwrap().len(), 4); }
#[test]
fn test_dynamic_level_disable_and_reenable() {
let (w1, handle1, rec1) = DynamicTestWriter::new(log::LevelFilter::Debug);
let (w2, _handle2, rec2) = DynamicTestWriter::new(log::LevelFilter::Info);
let multi = MultiLog::new()
.writer(w1)
.writer(w2)
.build()
.unwrap();
handle1.set_level(log::LevelFilter::Off);
assert_eq!(handle1.get_level(), log::LevelFilter::Off);
let record = log::Record::builder()
.level(log::Level::Error)
.target("test")
.args(format_args!("error after off"))
.build();
multi.log(&record);
assert_eq!(rec1.lock().unwrap().len(), 0); assert_eq!(rec2.lock().unwrap().len(), 1);
handle1.set_level(log::LevelFilter::Info);
let record = log::Record::builder()
.level(log::Level::Info)
.target("test")
.args(format_args!("info after reenable"))
.build();
multi.log(&record);
assert_eq!(rec1.lock().unwrap().len(), 1); assert_eq!(rec2.lock().unwrap().len(), 2); }
#[test]
fn test_dynamic_level_affects_enabled() {
let (w, handle, _) = DynamicTestWriter::new(log::LevelFilter::Info);
let multi = MultiLog::new().writer(w).build().unwrap();
let info_meta = log::MetadataBuilder::new()
.level(log::Level::Info)
.target("test")
.build();
let trace_meta = log::MetadataBuilder::new()
.level(log::Level::Trace)
.target("test")
.build();
assert!(multi.enabled(&info_meta));
assert!(!multi.enabled(&trace_meta));
handle.set_level(log::LevelFilter::Debug);
assert!(multi.enabled(&info_meta));
assert!(multi.enabled(
&log::MetadataBuilder::new()
.level(log::Level::Debug)
.target("test")
.build()
));
assert!(!multi.enabled(&trace_meta));
handle.set_level(log::LevelFilter::Trace);
assert!(multi.enabled(&info_meta));
assert!(multi.enabled(&trace_meta));
}
#[test]
fn test_handle_is_send_sync() {
fn assert_send<T: Send>() {}
fn assert_sync<T: Sync>() {}
assert_send::<LogHandle>();
assert_sync::<LogHandle>();
}
#[test]
fn test_writer_handle_api() {
let (w1, rec1) = TestWriter::new(log::LevelFilter::Debug);
let (w2, rec2) = TestWriter::new(log::LevelFilter::Info);
let (multi, handles) = MultiLog::new()
.writer_with_handle(w1)
.writer_with_handle(w2)
.build_with_handles()
.unwrap();
assert_eq!(handles.len(), 2);
let debug_record = log::Record::builder()
.level(log::Level::Debug)
.target("test")
.args(format_args!("debug"))
.build();
multi.log(&debug_record);
assert_eq!(rec1.lock().unwrap().len(), 1); assert_eq!(rec2.lock().unwrap().len(), 0);
let info_record = log::Record::builder()
.level(log::Level::Info)
.target("test")
.args(format_args!("info"))
.build();
multi.log(&info_record);
assert_eq!(rec1.lock().unwrap().len(), 2);
assert_eq!(rec2.lock().unwrap().len(), 1);
handles[1].set_level(log::LevelFilter::Error);
let warn_record = log::Record::builder()
.level(log::Level::Warn)
.target("test")
.args(format_args!("warn"))
.build();
multi.log(&warn_record);
assert_eq!(rec1.lock().unwrap().len(), 3); assert_eq!(rec2.lock().unwrap().len(), 1);
let error_record = log::Record::builder()
.level(log::Level::Error)
.target("test")
.args(format_args!("error"))
.build();
multi.log(&error_record);
assert_eq!(rec1.lock().unwrap().len(), 4);
assert_eq!(rec2.lock().unwrap().len(), 2);
fn assert_send<T: Send>() {}
fn assert_sync<T: Sync>() {}
assert_send::<LogHandle>();
assert_sync::<LogHandle>();
let h1 = handles[0].clone();
assert_eq!(h1.get_level(), log::LevelFilter::Trace);
h1.set_level(log::LevelFilter::Warn);
assert_eq!(handles[0].get_level(), log::LevelFilter::Warn);
}
#[test]
fn test_concurrent_writes_to_multi() {
let (w1, rec1) = TestWriter::new(log::LevelFilter::Debug);
let (w2, rec2) = TestWriter::new(log::LevelFilter::Info);
let multi = Arc::new(
MultiLog::new()
.writer(w1)
.writer(w2)
.build()
.unwrap(),
);
let mut jhs = Vec::new();
for i in 0..8 {
let m = multi.clone();
jhs.push(std::thread::spawn(move || {
for j in 0..50 {
m.log(
&log::Record::builder()
.level(log::Level::Info)
.target("test")
.args(format_args!("thread-{i}-msg-{j}"))
.build(),
);
}
m.flush();
}));
}
for jh in jhs {
jh.join().unwrap();
}
assert_eq!(rec1.lock().unwrap().len(), 400);
assert_eq!(rec2.lock().unwrap().len(), 400);
}
#[test]
fn test_concurrent_handle_changes_in_multi() {
let (w1, rec1) = TestWriter::new(log::LevelFilter::Debug);
let (w2, rec2) = TestWriter::new(log::LevelFilter::Info);
let (multi, handles) = MultiLog::new()
.writer_with_handle(w1)
.writer_with_handle(w2)
.build_with_handles()
.unwrap();
let multi = Arc::new(multi);
let handles = Arc::new(handles);
let mut wjhs = Vec::new();
for i in 0..4 {
let m = multi.clone();
wjhs.push(std::thread::spawn(move || {
for _ in 0..100 {
m.log(
&log::Record::builder()
.level(log::Level::Debug)
.target("test")
.args(format_args!("debug-{}", i))
.build(),
);
m.log(
&log::Record::builder()
.level(log::Level::Info)
.target("test")
.args(format_args!("info-{}", i))
.build(),
);
std::thread::yield_now();
}
m.flush();
}));
}
let mut chs = Vec::new();
for idx in 0..2 {
let hs = handles.clone();
chs.push(std::thread::spawn(move || {
for _ in 0..50 {
hs[idx].set_level(log::LevelFilter::Trace);
std::thread::yield_now();
hs[idx].set_level(log::LevelFilter::Warn);
std::thread::yield_now();
}
}));
}
for jh in wjhs {
jh.join().unwrap();
}
for jh in chs {
jh.join().unwrap();
}
assert!(!rec1.lock().unwrap().is_empty());
assert!(!rec2.lock().unwrap().is_empty());
}
}