1use crate::handle;
43
44use std::io;
45use std::sync::atomic::{AtomicU8, Ordering};
46use std::sync::Arc;
47
48pub use handle::LogHandle;
49
50struct WriterEntry {
52 writer: Box<dyn log::Log>,
53}
54
55impl WriterEntry {
56 fn new(w: impl log::Log + 'static) -> (Self, LogHandle) {
57 let level = Arc::new(AtomicU8::new(handle::level_to_u8(log::LevelFilter::Trace)));
58 let log_handle = LogHandle { level: level.clone() };
59 (
60 Self {
61 writer: Box::new(Wrapper {
62 writer: Box::new(w),
63 level,
64 }),
65 },
66 log_handle,
67 )
68 }
69
70 fn new_boxed(w: Box<dyn log::Log>) -> (Self, LogHandle) {
71 let level = Arc::new(AtomicU8::new(handle::level_to_u8(log::LevelFilter::Trace)));
72 let log_handle = LogHandle { level: level.clone() };
73 (
74 Self {
75 writer: Box::new(Wrapper { writer: w, level }),
76 },
77 log_handle,
78 )
79 }
80}
81
82struct Wrapper {
84 writer: Box<dyn log::Log>,
85 level: Arc<AtomicU8>,
86}
87
88impl log::Log for Wrapper {
89 fn enabled(&self, metadata: &log::Metadata<'_>) -> bool {
90 let current_level =
91 handle::u8_to_level(self.level.load(Ordering::Relaxed));
92 metadata.level() <= current_level && self.writer.enabled(metadata)
93 }
94
95 fn log(&self, record: &log::Record<'_>) {
96 let current_level =
97 handle::u8_to_level(self.level.load(Ordering::Relaxed));
98 if record.level() <= current_level {
99 self.writer.log(record);
100 }
101 }
102
103 fn flush(&self) {
104 self.writer.flush();
105 }
106}
107
108pub struct MultiLog {
119 writers: Vec<Box<dyn log::Log>>,
120}
121
122impl MultiLog {
123 pub fn new() -> MultiLogBuilder {
125 MultiLogBuilder::new()
126 }
127}
128
129impl log::Log for MultiLog {
130 fn enabled(&self, metadata: &log::Metadata<'_>) -> bool {
131 self.writers
132 .iter()
133 .any(|w| w.enabled(metadata))
134 }
135
136 fn log(&self, record: &log::Record<'_>) {
137 for writer in &self.writers {
138 if writer.enabled(record.metadata()) {
139 writer.log(record);
140 }
141 }
142 }
143
144 fn flush(&self) {
145 for writer in &self.writers {
146 writer.flush();
147 }
148 }
149}
150
151pub struct MultiLogBuilder {
153 entries: Vec<WriterEntry>,
154}
155
156impl MultiLogBuilder {
157 pub fn new() -> Self {
159 Self {
160 entries: Vec::new(),
161 }
162 }
163
164 pub fn writer(mut self, w: impl log::Log + 'static) -> Self {
172 let (entry, _) = WriterEntry::new(w);
173 self.entries.push(entry);
174 self
175 }
176
177 pub fn writer_boxed(mut self, w: Box<dyn log::Log>) -> Self {
182 let (entry, _) = WriterEntry::new_boxed(w);
183 self.entries.push(entry);
184 self
185 }
186
187 pub fn writer_with_handle(self, w: impl log::Log + 'static) -> MultiLogBuilderWithHandles {
210 let (entry, log_handle) = WriterEntry::new(w);
211 let mut builder = MultiLogBuilderWithHandles {
212 entries: Vec::new(),
213 handles: Vec::new(),
214 };
215 builder.entries.extend(self.entries);
216 builder.entries.push(entry);
217 builder.handles.push(log_handle);
218 builder
219 }
220
221 pub fn build(self) -> io::Result<MultiLog> {
225 if self.entries.is_empty() {
226 return Err(io::Error::new(
227 io::ErrorKind::InvalidInput,
228 "MultiLog requires at least one writer",
229 ));
230 }
231 Ok(MultiLog {
232 writers: self.entries.into_iter().map(|e| e.writer).collect(),
233 })
234 }
235
236 pub fn init(self) -> io::Result<MultiHandle> {
243 let multi = self.build()?;
244
245 let max_level = log::LevelFilter::Trace;
248
249 let level = Arc::new(AtomicU8::new(handle::level_to_u8(max_level)));
250 log::set_max_level(max_level);
251
252 let boxed = Box::new(multi);
253 log::set_boxed_logger(boxed).map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
254
255 Ok(MultiHandle {
256 level,
257 writer_handles: None,
258 })
259 }
260}
261
262impl Default for MultiLogBuilder {
263 fn default() -> Self {
264 Self::new()
265 }
266}
267
268pub struct MultiLogBuilderWithHandles {
275 entries: Vec<WriterEntry>,
276 handles: Vec<LogHandle>,
277}
278
279impl MultiLogBuilderWithHandles {
280 pub fn writer_with_handle(mut self, w: impl log::Log + 'static) -> Self {
282 let (entry, log_handle) = WriterEntry::new(w);
283 self.entries.push(entry);
284 self.handles.push(log_handle);
285 self
286 }
287
288 pub fn build_with_handles(self) -> io::Result<(MultiLog, Vec<LogHandle>)> {
292 if self.entries.is_empty() {
293 return Err(io::Error::new(
294 io::ErrorKind::InvalidInput,
295 "MultiLog requires at least one writer",
296 ));
297 }
298 let multi = MultiLog {
299 writers: self.entries.into_iter().map(|e| e.writer).collect(),
300 };
301 Ok((multi, self.handles))
302 }
303
304 pub fn init_with_handles(self) -> io::Result<MultiHandle> {
309 let (multi, handles) = self.build_with_handles()?;
310
311 let max_level = log::LevelFilter::Trace;
312 let level = Arc::new(AtomicU8::new(handle::level_to_u8(max_level)));
313 log::set_max_level(max_level);
314
315 let boxed = Box::new(multi);
316 log::set_boxed_logger(boxed).map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
317
318 Ok(MultiHandle {
319 level,
320 writer_handles: Some(handles),
321 })
322 }
323}
324
325#[derive(Clone)]
332pub struct MultiHandle {
333 level: Arc<AtomicU8>,
334 writer_handles: Option<Vec<LogHandle>>,
335}
336
337impl MultiHandle {
338 pub fn max_level(&self) -> log::LevelFilter {
340 handle::u8_to_level(self.level.load(Ordering::Relaxed))
341 }
342
343 pub fn writer_handles(&self) -> Option<&[LogHandle]> {
351 self.writer_handles.as_deref()
352 }
353
354 pub fn writer_handle(&self, index: usize) -> Option<&LogHandle> {
359 self.writer_handles.as_ref()?.get(index)
360 }
361}
362
363#[cfg(test)]
364mod tests {
365 use super::*;
366 use log::Log;
367 use std::sync::{Arc, Mutex};
368
369 struct TestWriter {
371 level: log::LevelFilter,
372 records: Arc<Mutex<Vec<String>>>,
373 }
374
375 impl TestWriter {
376 fn new(level: log::LevelFilter) -> (Self, Arc<Mutex<Vec<String>>>) {
377 let records = Arc::new(Mutex::new(Vec::new()));
378 (
379 Self {
380 level,
381 records: records.clone(),
382 },
383 records,
384 )
385 }
386 }
387
388 impl log::Log for TestWriter {
389 fn enabled(&self, metadata: &log::Metadata<'_>) -> bool {
390 metadata.level() <= self.level
391 }
392
393 fn log(&self, record: &log::Record<'_>) {
394 self.records.lock().unwrap().push(format!(
395 "{} {}",
396 record.level(),
397 record.args()
398 ));
399 }
400
401 fn flush(&self) {}
402 }
403
404 #[test]
405 fn test_multi_dispatches_to_all_writers() {
406 let (w1, records1) = TestWriter::new(log::LevelFilter::Debug);
407 let (w2, records2) = TestWriter::new(log::LevelFilter::Info);
408
409 let multi = MultiLog::new()
410 .writer(w1)
411 .writer(w2)
412 .build()
413 .unwrap();
414
415 let record = log::Record::builder()
417 .level(log::Level::Info)
418 .target("test")
419 .args(format_args!("hello"))
420 .build();
421 multi.log(&record);
422
423 assert_eq!(records1.lock().unwrap().len(), 1);
424 assert_eq!(records2.lock().unwrap().len(), 1);
425
426 let record = log::Record::builder()
428 .level(log::Level::Debug)
429 .target("test")
430 .args(format_args!("debug msg"))
431 .build();
432 multi.log(&record);
433
434 assert_eq!(records1.lock().unwrap().len(), 2);
435 assert_eq!(records2.lock().unwrap().len(), 1);
436 }
437
438 #[test]
439 fn test_empty_builder_fails() {
440 let result = MultiLog::new().build();
441 assert!(result.is_err());
442 }
443
444 #[test]
445 fn test_flush_all_writers() {
446 let (w1, _) = TestWriter::new(log::LevelFilter::Info);
447 let (w2, _) = TestWriter::new(log::LevelFilter::Info);
448
449 let multi = MultiLog::new()
450 .writer(w1)
451 .writer(w2)
452 .build()
453 .unwrap();
454
455 multi.flush(); }
457
458 struct DynamicTestWriter {
462 level: Arc<AtomicU8>,
463 records: Arc<Mutex<Vec<String>>>,
464 }
465
466 impl DynamicTestWriter {
467 fn new(level: log::LevelFilter) -> (Self, LogHandle, Arc<Mutex<Vec<String>>>) {
468 let level = Arc::new(AtomicU8::new(handle::level_to_u8(level)));
469 let records = Arc::new(Mutex::new(Vec::new()));
470 let log_handle = LogHandle { level: level.clone() };
471 (
472 Self {
473 level,
474 records: records.clone(),
475 },
476 log_handle,
477 records,
478 )
479 }
480 }
481
482 impl log::Log for DynamicTestWriter {
483 fn enabled(&self, metadata: &log::Metadata<'_>) -> bool {
484 metadata.level()
485 <= handle::u8_to_level(self.level.load(Ordering::Relaxed))
486 }
487
488 fn log(&self, record: &log::Record<'_>) {
489 self.records.lock().unwrap().push(format!(
490 "{} {} (level={:?})",
491 record.level(),
492 record.args(),
493 handle::u8_to_level(self.level.load(Ordering::Relaxed)),
494 ));
495 }
496
497 fn flush(&self) {}
498 }
499
500 #[test]
501 fn test_dynamic_level_adjust_per_writer() {
502 let (w1, handle1, rec1) = DynamicTestWriter::new(log::LevelFilter::Debug);
503 let (w2, handle2, rec2) = DynamicTestWriter::new(log::LevelFilter::Info);
504
505 let multi = MultiLog::new()
506 .writer(w1)
507 .writer(w2)
508 .build()
509 .unwrap();
510
511 assert_eq!(handle1.get_level(), log::LevelFilter::Debug);
513 assert_eq!(handle2.get_level(), log::LevelFilter::Info);
514
515 let record = log::Record::builder()
517 .level(log::Level::Debug)
518 .target("test")
519 .args(format_args!("debug message"))
520 .build();
521 multi.log(&record);
522
523 assert_eq!(rec1.lock().unwrap().len(), 1);
524 assert_eq!(rec2.lock().unwrap().len(), 0);
525
526 let record = log::Record::builder()
528 .level(log::Level::Info)
529 .target("test")
530 .args(format_args!("info message"))
531 .build();
532 multi.log(&record);
533
534 assert_eq!(rec1.lock().unwrap().len(), 2);
535 assert_eq!(rec2.lock().unwrap().len(), 1);
536
537 handle1.set_level(log::LevelFilter::Error);
539 handle2.set_level(log::LevelFilter::Trace);
540
541 assert_eq!(handle1.get_level(), log::LevelFilter::Error);
542 assert_eq!(handle2.get_level(), log::LevelFilter::Trace);
543
544 let record = log::Record::builder()
546 .level(log::Level::Warn)
547 .target("test")
548 .args(format_args!("warn message"))
549 .build();
550 multi.log(&record);
551
552 assert_eq!(rec1.lock().unwrap().len(), 2); assert_eq!(rec2.lock().unwrap().len(), 2); let record = log::Record::builder()
557 .level(log::Level::Trace)
558 .target("test")
559 .args(format_args!("trace message"))
560 .build();
561 multi.log(&record);
562
563 assert_eq!(rec1.lock().unwrap().len(), 2); assert_eq!(rec2.lock().unwrap().len(), 3); let record = log::Record::builder()
568 .level(log::Level::Error)
569 .target("test")
570 .args(format_args!("error message"))
571 .build();
572 multi.log(&record);
573
574 assert_eq!(rec1.lock().unwrap().len(), 3); assert_eq!(rec2.lock().unwrap().len(), 4); }
577
578 #[test]
579 fn test_dynamic_level_disable_and_reenable() {
580 let (w1, handle1, rec1) = DynamicTestWriter::new(log::LevelFilter::Debug);
581 let (w2, _handle2, rec2) = DynamicTestWriter::new(log::LevelFilter::Info);
582
583 let multi = MultiLog::new()
584 .writer(w1)
585 .writer(w2)
586 .build()
587 .unwrap();
588
589 handle1.set_level(log::LevelFilter::Off);
591 assert_eq!(handle1.get_level(), log::LevelFilter::Off);
592
593 let record = log::Record::builder()
594 .level(log::Level::Error)
595 .target("test")
596 .args(format_args!("error after off"))
597 .build();
598 multi.log(&record);
599
600 assert_eq!(rec1.lock().unwrap().len(), 0); assert_eq!(rec2.lock().unwrap().len(), 1); handle1.set_level(log::LevelFilter::Info);
605
606 let record = log::Record::builder()
607 .level(log::Level::Info)
608 .target("test")
609 .args(format_args!("info after reenable"))
610 .build();
611 multi.log(&record);
612
613 assert_eq!(rec1.lock().unwrap().len(), 1); assert_eq!(rec2.lock().unwrap().len(), 2); }
616
617 #[test]
618 fn test_dynamic_level_affects_enabled() {
619 let (w, handle, _) = DynamicTestWriter::new(log::LevelFilter::Info);
620
621 let multi = MultiLog::new().writer(w).build().unwrap();
622
623 let info_meta = log::MetadataBuilder::new()
624 .level(log::Level::Info)
625 .target("test")
626 .build();
627 let trace_meta = log::MetadataBuilder::new()
628 .level(log::Level::Trace)
629 .target("test")
630 .build();
631
632 assert!(multi.enabled(&info_meta));
634 assert!(!multi.enabled(&trace_meta));
635
636 handle.set_level(log::LevelFilter::Debug);
638
639 assert!(multi.enabled(&info_meta));
641 assert!(multi.enabled(
642 &log::MetadataBuilder::new()
643 .level(log::Level::Debug)
644 .target("test")
645 .build()
646 ));
647 assert!(!multi.enabled(&trace_meta));
648
649 handle.set_level(log::LevelFilter::Trace);
651 assert!(multi.enabled(&info_meta));
652 assert!(multi.enabled(&trace_meta));
653 }
654
655 #[test]
656 fn test_handle_is_send_sync() {
657 fn assert_send<T: Send>() {}
658 fn assert_sync<T: Sync>() {}
659 assert_send::<LogHandle>();
660 assert_sync::<LogHandle>();
661 }
662
663 #[test]
664 fn test_writer_handle_api() {
665 let (w1, rec1) = TestWriter::new(log::LevelFilter::Debug);
667 let (w2, rec2) = TestWriter::new(log::LevelFilter::Info);
668
669 let (multi, handles) = MultiLog::new()
670 .writer_with_handle(w1)
671 .writer_with_handle(w2)
672 .build_with_handles()
673 .unwrap();
674
675 assert_eq!(handles.len(), 2);
677
678 let debug_record = log::Record::builder()
680 .level(log::Level::Debug)
681 .target("test")
682 .args(format_args!("debug"))
683 .build();
684 multi.log(&debug_record);
685 assert_eq!(rec1.lock().unwrap().len(), 1); assert_eq!(rec2.lock().unwrap().len(), 0); let info_record = log::Record::builder()
689 .level(log::Level::Info)
690 .target("test")
691 .args(format_args!("info"))
692 .build();
693 multi.log(&info_record);
694 assert_eq!(rec1.lock().unwrap().len(), 2);
695 assert_eq!(rec2.lock().unwrap().len(), 1);
696
697 handles[1].set_level(log::LevelFilter::Error);
699
700 let warn_record = log::Record::builder()
703 .level(log::Level::Warn)
704 .target("test")
705 .args(format_args!("warn"))
706 .build();
707 multi.log(&warn_record);
708 assert_eq!(rec1.lock().unwrap().len(), 3); assert_eq!(rec2.lock().unwrap().len(), 1); let error_record = log::Record::builder()
713 .level(log::Level::Error)
714 .target("test")
715 .args(format_args!("error"))
716 .build();
717 multi.log(&error_record);
718 assert_eq!(rec1.lock().unwrap().len(), 4);
719 assert_eq!(rec2.lock().unwrap().len(), 2);
720
721 fn assert_send<T: Send>() {}
723 fn assert_sync<T: Sync>() {}
724 assert_send::<LogHandle>();
725 assert_sync::<LogHandle>();
726
727 let h1 = handles[0].clone();
729 assert_eq!(h1.get_level(), log::LevelFilter::Trace);
730 h1.set_level(log::LevelFilter::Warn);
731 assert_eq!(handles[0].get_level(), log::LevelFilter::Warn);
732 }
733
734 #[test]
735 fn test_concurrent_writes_to_multi() {
736 let (w1, rec1) = TestWriter::new(log::LevelFilter::Debug);
737 let (w2, rec2) = TestWriter::new(log::LevelFilter::Info);
738
739 let multi = Arc::new(
740 MultiLog::new()
741 .writer(w1)
742 .writer(w2)
743 .build()
744 .unwrap(),
745 );
746
747 let mut jhs = Vec::new();
748 for i in 0..8 {
749 let m = multi.clone();
750 jhs.push(std::thread::spawn(move || {
751 for j in 0..50 {
752 m.log(
753 &log::Record::builder()
754 .level(log::Level::Info)
755 .target("test")
756 .args(format_args!("thread-{i}-msg-{j}"))
757 .build(),
758 );
759 }
760 m.flush();
761 }));
762 }
763 for jh in jhs {
764 jh.join().unwrap();
765 }
766
767 assert_eq!(rec1.lock().unwrap().len(), 400);
769 assert_eq!(rec2.lock().unwrap().len(), 400);
770 }
771
772 #[test]
773 fn test_concurrent_handle_changes_in_multi() {
774 let (w1, rec1) = TestWriter::new(log::LevelFilter::Debug);
775 let (w2, rec2) = TestWriter::new(log::LevelFilter::Info);
776
777 let (multi, handles) = MultiLog::new()
778 .writer_with_handle(w1)
779 .writer_with_handle(w2)
780 .build_with_handles()
781 .unwrap();
782
783 let multi = Arc::new(multi);
784 let handles = Arc::new(handles);
785
786 let mut wjhs = Vec::new();
788 for i in 0..4 {
789 let m = multi.clone();
790 wjhs.push(std::thread::spawn(move || {
791 for _ in 0..100 {
792 m.log(
793 &log::Record::builder()
794 .level(log::Level::Debug)
795 .target("test")
796 .args(format_args!("debug-{}", i))
797 .build(),
798 );
799 m.log(
800 &log::Record::builder()
801 .level(log::Level::Info)
802 .target("test")
803 .args(format_args!("info-{}", i))
804 .build(),
805 );
806 std::thread::yield_now();
807 }
808 m.flush();
809 }));
810 }
811
812 let mut chs = Vec::new();
814 for idx in 0..2 {
815 let hs = handles.clone();
816 chs.push(std::thread::spawn(move || {
817 for _ in 0..50 {
818 hs[idx].set_level(log::LevelFilter::Trace);
819 std::thread::yield_now();
820 hs[idx].set_level(log::LevelFilter::Warn);
821 std::thread::yield_now();
822 }
823 }));
824 }
825
826 for jh in wjhs {
827 jh.join().unwrap();
828 }
829 for jh in chs {
830 jh.join().unwrap();
831 }
832
833 assert!(!rec1.lock().unwrap().is_empty());
835 assert!(!rec2.lock().unwrap().is_empty());
836 }
837}