feat: event based non-blocking logger

subcrates/zlog/src/tests.rs

@@ -0,0 +1,90 @@
+use super::*;
+use pretty_assertions::assert_eq;
+use tracing::Level;
+
+#[test]
+fn test_logger_sequential_consistency() {
+    use std::sync::atomic::{AtomicUsize, Ordering};
+    use tracing::{debug, error, info, trace, warn};
+
+    let config = LoggerConfig::default()
+        .log_to_stdout(true)
+        .log_to_file(true);
+    let logger = Logger::new(config);
+
+    static COUNTER: AtomicUsize = AtomicUsize::new(0);
+
+    for i in 0..4096 * 128 {
+        let count = COUNTER.fetch_add(1, Ordering::SeqCst);
+        match i % 5 {
+            0 => error!("Error message {}", count),
+            1 => warn!("Warning message {}", count),
+            2 => info!("Info message {}", count),
+            3 => debug!("Debug message {}", count),
+            _ => trace!("Trace message {}", count),
+        }
+    }
+
+    let logs = logger.get_logs(LogQuery::All);
+    assert_eq!(
+        logs.len(),
+        4096 * 128,
+        "Should have exactly 5000 log entries"
+    );
+
+    for (i, log) in logs.iter().enumerate() {
+        let expected_count = i;
+        let expected_level = match i % 5 {
+            0 => Level::ERROR,
+            1 => Level::WARN,
+            2 => Level::INFO,
+            3 => Level::DEBUG,
+            _ => Level::TRACE,
+        };
+
+        assert_eq!(
+            log.level, expected_level,
+            "Log {} has incorrect level: {:?}",
+            i, log.level
+        );
+
+        let expected_msg = match expected_level {
+            Level::ERROR => format!("Error message {}", expected_count),
+            Level::WARN => format!("Warning message {}", expected_count),
+            Level::INFO => format!("Info message {}", expected_count),
+            Level::DEBUG => format!("Debug message {}", expected_count),
+            Level::TRACE => format!("Trace message {}", expected_count),
+        };
+
+        assert_eq!(
+            log.message, expected_msg,
+            "Log {} has incorrect message. Expected: '{}', Got: '{}'",
+            i, expected_msg, log.message
+        );
+
+        if i > 0 {
+            assert!(
+                log.timestamp >= logs[i - 1].timestamp,
+                "Log {} has timestamp out of order. Current: {:?}, Previous: {:?}",
+                i,
+                log.timestamp,
+                logs[i - 1].timestamp
+            );
+        }
+    }
+
+    let mut counts: Vec<usize> = logs
+        .iter()
+        .map(|log| {
+            log.message
+                .split_whitespace()
+                .last()
+                .unwrap()
+                .parse::<usize>()
+                .unwrap()
+        })
+        .collect();
+    counts.sort();
+    counts.dedup();
+    assert_eq!(counts.len(), 4096 * 128, "Found duplicate log entries");
+}