Skip to main content

ltrace/
multi_writer.rs

1//! Multi-target log dispatcher that writes to multiple [`log::Log`] writers.
2//!
3//! This module provides [`MultiLog`] which implements `log::Log` and dispatches
4//! log records to all registered writers. It allows combining different log
5//! backends (e.g. console + file, multiple files with different levels).
6//!
7//! # Example: Console + File
8//!
9//! ```ignore
10//! use ltrace::{MultiLog, ConsoleWriter, LogWriter, Rotation, Compression};
11//!
12//! let multi = MultiLog::new()
13//!     .writer(ConsoleWriter::builder()
14//!         .level(log::LevelFilter::Info)
15//!         .build()?)
16//!     .writer(LogWriter::builder("/var/log/myapp/app.log")
17//!         .rotation(Rotation::Daily)
18//!         .compression(Compression::Gzip)
19//!         .level(log::LevelFilter::Debug)
20//!         .build()?)
21//!     .init()?;
22//! ```
23//!
24//! # Example: Dynamic level control per writer
25//!
26//! ```ignore
27//! use ltrace::{MultiLog, ConsoleWriter, LogWriter};
28//!
29//! let (multi, handles) = MultiLog::new()
30//!     .writer_with_handle(ConsoleWriter::builder()
31//!         .level(log::LevelFilter::Info)
32//!         .build()?)
33//!     .writer_with_handle(LogWriter::builder("/var/log/myapp/app.log")
34//!         .level(log::LevelFilter::Debug)
35//!         .build()?)
36//!     .build_with_handles()?;
37//!
38//! // Dynamically change the first writer's level
39//! handles[0].set_level(log::LevelFilter::Error);
40//! ```
41
42use crate::handle;
43
44use std::io;
45use std::sync::atomic::{AtomicU8, Ordering};
46use std::sync::Arc;
47
48pub use handle::LogHandle;
49
50/// Internal wrapper that wraps a boxed writer with an external level filter.
51struct 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
82/// A wrapper that applies dynamic level filtering via an `Arc<AtomicU8>`.
83struct 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
108/// A logger that dispatches records to multiple [`log::Log`] writers.
109///
110/// Each writer receives every log record independently, so each can apply
111/// its own level filtering. This enables scenarios like:
112///
113/// - Logging to both console and file simultaneously
114/// - Writing errors to a separate file from debug logs
115/// - Combining any `log::Log` implementation
116///
117/// Use [`MultiLogBuilder`] to construct it.
118pub struct MultiLog {
119    writers: Vec<Box<dyn log::Log>>,
120}
121
122impl MultiLog {
123    /// Create a new empty multi-log builder.
124    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
151/// Builder for creating a [`MultiLog`] with multiple writers.
152pub struct MultiLogBuilder {
153    entries: Vec<WriterEntry>,
154}
155
156impl MultiLogBuilder {
157    /// Create a new empty builder.
158    pub fn new() -> Self {
159        Self {
160            entries: Vec::new(),
161        }
162    }
163
164    /// Add a log writer to the multi-log.
165    ///
166    /// The writer will receive all log records. Each writer applies its own
167    /// level filtering via its `enabled()` method.
168    ///
169    /// If you need to dynamically adjust the level of this writer after building,
170    /// use [`writer_with_handle`](Self::writer_with_handle) instead.
171    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    /// Add a boxed log writer.
178    ///
179    /// This is useful when you need to add writers whose concrete type is
180    /// not known at compile time.
181    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    /// Add a log writer and return a [`LogHandle`] for dynamic level control.
188    ///
189    /// This wraps the writer with an external level filter controlled by the
190    /// returned handle. The handle's default level is `Trace` (all messages pass).
191    /// The writer's own internal filtering still applies — both the handle's
192    /// level AND the writer's level must accept a record for it to be logged.
193    ///
194    /// # Example
195    ///
196    /// ```ignore
197    /// let (multi, handles) = MultiLog::new()
198    ///     .writer_with_handle(ConsoleWriter::builder().build()?)
199    ///     .writer_with_handle(LogWriter::builder("app.log").build()?)
200    ///     .build_with_handles()?;
201    ///
202    /// // Later, dynamically change levels
203    /// handles[0].set_level(log::LevelFilter::Error);
204    /// handles[1].set_level(log::LevelFilter::Trace);
205    /// ```
206    ///
207    /// Note: `LogHandle` is `Clone + Send + Sync`, so you can send it to
208    /// other threads for remote level control.
209    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    /// Build the [`MultiLog`].
222    ///
223    /// Returns an error if no writers have been added.
224    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    /// Build and register as the global logger.
237    ///
238    /// Sets the global max level to the highest (most verbose) level among
239    /// all writers.
240    ///
241    /// Returns an [`MultiHandle`] for dynamically changing the effective level.
242    pub fn init(self) -> io::Result<MultiHandle> {
243        let multi = self.build()?;
244
245        // Set global max to the most permissive (Trace) so all writers
246        // can receive the records they need; each writer applies its own filtering.
247        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
268/// Builder for creating a [`MultiLog`] with per-writer dynamic level handles.
269///
270/// This builder is returned by [`MultiLogBuilder::writer_with_handle`] and
271/// provides [`build_with_handles`](Self::build_with_handles) and
272/// [`init_with_handles`](Self::init_with_handles) methods that return
273/// [`LogHandle`] for each writer.
274pub struct MultiLogBuilderWithHandles {
275    entries: Vec<WriterEntry>,
276    handles: Vec<LogHandle>,
277}
278
279impl MultiLogBuilderWithHandles {
280    /// Add another log writer and return a [`LogHandle`] for dynamic level control.
281    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    /// Build the [`MultiLog`] and return all writer handles.
289    ///
290    /// Returns an error if no writers have been added.
291    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    /// Build and register as the global logger, returning a handle with per-writer access.
305    ///
306    /// Sets the global max level to `Trace` so all writers can receive records.
307    /// Returns an [`MultiHandle`] containing all writer handles.
308    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/// A handle returned by [`MultiLogBuilder::init`] or [`MultiLogBuilderWithHandles::init_with_handles`]
326/// for managing the multi-log.
327///
328/// When created via `init_with_handles`, you can access per-writer [`LogHandle`]s
329/// to dynamically adjust their log levels via [`writer_handles`](Self::writer_handles)
330/// or [`writer_handle`](Self::writer_handle).
331#[derive(Clone)]
332pub struct MultiHandle {
333    level: Arc<AtomicU8>,
334    writer_handles: Option<Vec<LogHandle>>,
335}
336
337impl MultiHandle {
338    /// Get the effective max level of the multi-log.
339    pub fn max_level(&self) -> log::LevelFilter {
340        handle::u8_to_level(self.level.load(Ordering::Relaxed))
341    }
342
343    /// Get all per-writer handles.
344    ///
345    /// Returns `Some` if the multi-log was created via `init_with_handles`
346    /// or `build_with_handles`. Each [`LogHandle`] can be used to
347    /// dynamically adjust the level of its corresponding writer.
348    ///
349    /// Returns `None` if created via `init()` or `build()` (which don't track handles).
350    pub fn writer_handles(&self) -> Option<&[LogHandle]> {
351        self.writer_handles.as_deref()
352    }
353
354    /// Get a specific writer handle by index.
355    ///
356    /// Returns `None` if out of bounds or if the multi-log was not created
357    /// with handle tracking.
358    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    /// A test writer that captures log records.
370    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        // Log an info record - should go to both
416        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        // Log a debug record - should only go to w1
427        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(); // Should not panic
456    }
457
458    // --- Tests for dynamic per-writer level adjustment ---
459
460    /// A test writer that supports dynamic level adjustment via a handle.
461    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        // Initial state: w1=Debug, w2=Info
512        assert_eq!(handle1.get_level(), log::LevelFilter::Debug);
513        assert_eq!(handle2.get_level(), log::LevelFilter::Info);
514
515        // Log a debug message — only w1 should capture
516        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        // Log an info message — both should capture
527        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        // Dynamically change w1 to Error, w2 to Trace
538        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        // Log a warn message — w1 rejects (Error > Warn), w2 accepts
545        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); // unchanged
553        assert_eq!(rec2.lock().unwrap().len(), 2); // captured
554
555        // Log a trace message — only w2 accepts (Trace)
556        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); // unchanged
564        assert_eq!(rec2.lock().unwrap().len(), 3); // captured info, warn, trace
565
566        // Log an error message — both accept
567        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); // captured
575        assert_eq!(rec2.lock().unwrap().len(), 4); // captured
576    }
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        // Set w1 to Off — it should capture nothing
590        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); // w1 disabled, nothing captured
601        assert_eq!(rec2.lock().unwrap().len(), 1); // w2 still captures Error
602
603        // Re-enable w1 at Info level
604        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); // w1 now captures
614        assert_eq!(rec2.lock().unwrap().len(), 2); // w2 still captures
615    }
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        // Initially Info: Info enabled, Trace disabled
633        assert!(multi.enabled(&info_meta));
634        assert!(!multi.enabled(&trace_meta));
635
636        // Dynamically change to Debug
637        handle.set_level(log::LevelFilter::Debug);
638
639        // Now both Info and Debug are enabled, Trace still disabled
640        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        // Change to Trace — everything enabled
650        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        // Test the writer_with_handle + build_with_handles + LogHandle API
666        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        // Should have 2 handles
676        assert_eq!(handles.len(), 2);
677
678        // Initially both wrappers are at Trace (all pass), inner filters still apply
679        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); // w1 inner=Debug, accepts
686        assert_eq!(rec2.lock().unwrap().len(), 0); // w2 inner=Info, rejects
687
688        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        // Dynamically change w2's wrapper to Error
698        handles[1].set_level(log::LevelFilter::Error);
699
700        // w2 wrapper now only allows Error+, but w2 inner=Info
701        // A warn message: w2 wrapper (Error) rejects, w2 inner (Info) would accept
702        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); // w1 wrapper=Trace, w1 inner=Debug, accepts
709        assert_eq!(rec2.lock().unwrap().len(), 1); // w2 wrapper=Error, rejects warn
710
711        // An error message: w2 wrapper (Error) accepts, w2 inner (Info) accepts
712        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        // Test LogHandle is Send + Sync
722        fn assert_send<T: Send>() {}
723        fn assert_sync<T: Sync>() {}
724        assert_send::<LogHandle>();
725        assert_sync::<LogHandle>();
726
727        // Test clone shares state
728        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        // 8 threads * 50 messages = 400, both writers accept Info
768        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        // Writer threads: log messages at different levels
787        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        // Level changer threads: toggle handles between Debug and Info
813        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        // Just verify no panics and some records were captured
834        assert!(!rec1.lock().unwrap().is_empty());
835        assert!(!rec2.lock().unwrap().is_empty());
836    }
837}