temp

Author: Asuzhan

examples/examples/non-blocking-timeout.rs

@@ -0,0 +1,104 @@
+//! This example demonstrates the configurable shutdown timeout feature of the non-blocking writer.
+//! 
+//! The example uses a custom blocking writer that can simulate slow I/O operations,
+//! allowing us to see how the timeout behaves when the worker thread is blocked
+//! during shutdown.
+
+use std::{io::{self, Write}, thread, time::{Duration, Instant}};
+use tracing::info;
+use tracing_appender::non_blocking::NonBlockingBuilder;
+
+static BLOCK_IN_WORKER: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false);
+static BLOCK_DURATION_SECS: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(3);
+
+struct BlockingMemoryWriter{
+    buffer: Vec<u8>,
+}
+
+impl BlockingMemoryWriter {
+    fn new() -> Self {
+        Self {
+            buffer: Vec::new()
+        }
+    }
+
+    fn contents(&self) -> String {
+        String::from_utf8_lossy(&self.buffer).to_string()
+    }
+}
+
+impl Write for BlockingMemoryWriter {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        if BLOCK_IN_WORKER.load(std::sync::atomic::Ordering::Relaxed) {
+            let block_secs = BLOCK_DURATION_SECS.load(std::sync::atomic::Ordering::Relaxed);
+            println!("Blocking in write() for {} seconds...", block_secs);
+            thread::sleep(Duration::from_secs(block_secs));
+            println!("Done blocking in write()");
+        }
+        self.buffer.extend_from_slice(buf);
+        Ok(buf.len())
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        self.buffer.flush()
+    }
+}
+
+impl Drop for BlockingMemoryWriter {
+    fn drop(&mut self) {
+        println!("BlockingMemoryWriter dropped. Final contents:");
+        println!("{}", self.contents());
+    }
+}
+
+fn main() {
+    let block_secs = 2;
+    let shutdown_timeout = Duration::from_millis(300);
+
+    BLOCK_DURATION_SECS.store(block_secs, std::sync::atomic::Ordering::Relaxed);
+    println!("Blocking for {} seconds in main thread", block_secs);
+    println!("Shutdown timeout set to {:?}", shutdown_timeout);
+
+    let blocking_writer = BlockingMemoryWriter::new();
+
+    let (non_blocking, guard) = NonBlockingBuilder::default()
+        .shutdown_timeout(shutdown_timeout)
+        .finish(blocking_writer);
+
+    tracing_subscriber::fmt()
+        .with_writer(non_blocking)
+        .init();
+
+    for i in 0..5 {
+        info!("Log message {}", i);
+    }
+
+    thread::sleep(Duration::from_millis(100));
+
+    println!("\n=== BLOCKING IN WORKER THREAD ===");
+    BLOCK_IN_WORKER.store(true, std::sync::atomic::Ordering::Relaxed);
+    info!("This message will cause blocking in the worker thread");
+    thread::sleep(Duration::from_millis(100));
+
+    println!("\n=== STARTING SHUTDOWN (should take ~1 second due to timeout) ===");
+    let shutdown_start = Instant::now();
+
+    drop(guard);
+
+    let shutdown_duration = shutdown_start.elapsed();
+    println!("=== SHUTDOWN COMPLETED in {:?} ===", shutdown_duration);
+
+    let expected_min = shutdown_timeout.as_millis() * 9 / 10;
+    let expected_max = shutdown_timeout.as_millis() * 11 / 10;
+
+    if shutdown_duration.as_millis() > expected_min && shutdown_duration.as_millis() < expected_max {
+        println!("Shutdown took ~{:?} second as expected", shutdown_timeout);
+    } else {
+        println!("Shutdown took {:?} instead of ~{:?} second", shutdown_duration, shutdown_timeout);
+    }
+
+    println!("\n=== WAITING TO SEE BACKGROUND THREAD FINISH ===");
+    thread::sleep(Duration::from_secs(block_secs + 1));
+    println!("=== MAIN THREAD EXITING ===");
+
+}