fix: eliminate 5s exit delay and restore post-TUI tracing

Xevion · Xevion · commit a81a8ab9224f · 2026-04-08T15:26:28.000-05:00
- Replace Condvar with sync_channel for worker completion signaling
  (recv_timeout is race-free; condvar notify was lost if fired before wait)
- Add TuiTraceGuard RAII type that reroutes tracing to stderr and drains
  buffered log events when the TUI exits
diff --git a/src/tui/mod.rs b/src/tui/mod.rs
@@ -200,18 +200,68 @@ impl fmt::Debug for Segment {
     }
 }
 
-/// A [`MakeWriter`] that sends `tracing_subscriber::fmt`-formatted lines through
-/// a channel while the TUI is active. When the channel disconnects (TUI exited),
-/// output falls back to stderr so post-TUI tracing isn't lost.
+/// Shared routing state between [`TuiMakeWriter`] and [`TuiTraceGuard`].
+///
+/// While `active` is true, formatted trace output is sent to the TUI channel.
+/// Once flipped to false (by dropping the guard), output routes to stderr.
+pub struct TuiTraceState {
+    active: AtomicBool,
+}
+
+impl TuiTraceState {
+    fn new() -> Self {
+        Self {
+            active: AtomicBool::new(true),
+        }
+    }
+
+    fn is_active(&self) -> bool {
+        self.active.load(Ordering::Acquire)
+    }
+}
+
+/// RAII guard that reroutes tracing from the TUI channel to stderr on drop.
+///
+/// When dropped:
+/// 1. Flips the routing flag so future traces write to stderr.
+/// 2. Drains any buffered `TuiEvent::Log` events from the channel to stderr.
+pub struct TuiTraceGuard {
+    state: Arc<TuiTraceState>,
+    rx: mpsc::Receiver<TuiEvent>,
+}
+
+impl TuiTraceGuard {
+    #[must_use]
+    pub fn new(state: Arc<TuiTraceState>, rx: mpsc::Receiver<TuiEvent>) -> Self {
+        Self { state, rx }
+    }
+}
+
+impl Drop for TuiTraceGuard {
+    fn drop(&mut self) {
+        self.state.active.store(false, Ordering::Release);
+
+        while let Ok(event) = self.rx.try_recv() {
+            if let TuiEvent::Log(msg) = event {
+                let _ = io::stderr().write_all(msg.as_bytes());
+                let _ = io::stderr().write_all(b"\n");
+            }
+        }
+    }
+}
+
+/// A [`MakeWriter`] that routes formatted trace lines to the TUI channel
+/// while the TUI is active, then to stderr after the [`TuiTraceGuard`] drops.
 #[derive(Clone)]
 pub struct TuiMakeWriter {
     tx: mpsc::SyncSender<TuiEvent>,
+    state: Arc<TuiTraceState>,
 }
 
 impl TuiMakeWriter {
     #[must_use]
-    pub fn new(tx: mpsc::SyncSender<TuiEvent>) -> Self {
-        Self { tx }
+    pub fn new(tx: mpsc::SyncSender<TuiEvent>, state: Arc<TuiTraceState>) -> Self {
+        Self { tx, state }
     }
 }
 
@@ -221,15 +271,17 @@ impl<'a> MakeWriter<'a> for TuiMakeWriter {
     fn make_writer(&'a self) -> Self::Writer {
         TuiWriter {
             tx: self.tx.clone(),
+            state: Arc::clone(&self.state),
             buf: Vec::with_capacity(256),
         }
     }
 }
 
 /// Per-event writer that buffers a single formatted log line.
-/// On drop, sends the line through the channel or falls back to stderr.
+/// On drop, routes to the TUI channel or stderr based on [`TuiTraceState`].
 pub struct TuiWriter {
     tx: mpsc::SyncSender<TuiEvent>,
+    state: Arc<TuiTraceState>,
     buf: Vec<u8>,
 }
 
@@ -254,9 +306,12 @@ impl Drop for TuiWriter {
         if trimmed.is_empty() {
             return;
         }
-        // Send to TUI for inline display (best-effort).
-        // A separate tracing layer handles stderr output independently.
-        let _ = self.tx.try_send(TuiEvent::Log(trimmed));
+        if self.state.is_active() {
+            let _ = self.tx.try_send(TuiEvent::Log(trimmed));
+        } else {
+            let _ = io::stderr().write_all(trimmed.as_bytes());
+            let _ = io::stderr().write_all(b"\n");
+        }
     }
 }
 
@@ -586,11 +641,17 @@ mod tests {
         assert!(debug.contains('3'));
     }
 
+    fn make_active_state() -> Arc<TuiTraceState> {
+        Arc::new(TuiTraceState::new())
+    }
+
     #[test]
     fn tui_writer_sends_through_channel() {
         let (tx, rx) = mpsc::sync_channel::<TuiEvent>(16);
+        let state = make_active_state();
         let mut writer = TuiWriter {
             tx,
+            state,
             buf: Vec::new(),
         };
         writer.write_all(b" INFO ferrite: hello world\n").unwrap();
@@ -607,8 +668,10 @@ mod tests {
     #[test]
     fn tui_writer_empty_buffer_sends_nothing() {
         let (tx, rx) = mpsc::sync_channel::<TuiEvent>(16);
+        let state = make_active_state();
         let writer = TuiWriter {
             tx,
+            state,
             buf: Vec::new(),
         };
         drop(writer);
@@ -618,6 +681,37 @@ mod tests {
         );
     }
 
+    #[test]
+    fn tui_writer_routes_to_stderr_when_inactive() {
+        let (tx, rx) = mpsc::sync_channel::<TuiEvent>(16);
+        let state = make_active_state();
+        state.active.store(false, Ordering::Release);
+        let mut writer = TuiWriter {
+            tx,
+            state,
+            buf: Vec::new(),
+        };
+        writer.write_all(b"routed to stderr\n").unwrap();
+        drop(writer);
+        // Nothing sent to the TUI channel
+        assert!(rx.try_recv().is_err());
+    }
+
+    #[test]
+    fn tui_trace_guard_drains_and_deactivates() {
+        let state = make_active_state();
+        let (tx, rx) = mpsc::sync_channel::<TuiEvent>(16);
+        let _ = tx.try_send(TuiEvent::Log("buffered msg".into()));
+        let _ = tx.try_send(TuiEvent::Tick); // non-Log events are discarded
+        let _ = tx.try_send(TuiEvent::Log("second msg".into()));
+
+        let guard = TuiTraceGuard::new(Arc::clone(&state), rx);
+        assert!(state.is_active());
+        drop(guard);
+        assert!(!state.is_active());
+        // rx is consumed by the guard — channel fully disconnected
+    }
+
     mod event_loop {
         use std::sync::Arc;
         use std::sync::atomic::Ordering;
diff --git a/src/tui/run.rs b/src/tui/run.rs
@@ -1,7 +1,7 @@
 #![cfg_attr(coverage_nightly, coverage(off))]
 
 use std::sync::atomic::Ordering;
-use std::sync::{Arc, Condvar, Mutex, mpsc};
+use std::sync::{Arc, mpsc};
 use std::thread;
 use std::time::Duration;
 
@@ -18,7 +18,7 @@ use crate::shutdown;
 use crate::units::{Size, UnitSystem};
 
 use super::bridge::EventBridge;
-use super::{Segment, TuiConfig, TuiEvent, TuiMakeWriter};
+use super::{Segment, TuiConfig, TuiEvent, TuiMakeWriter, TuiTraceGuard, TuiTraceState};
 
 /// Set up the global tracing subscriber with a layered registry.
 ///
@@ -104,8 +104,10 @@ pub fn run_tui_mode(
 ) -> Result<()> {
     let (tui_tx, tui_rx) = mpsc::sync_channel::<TuiEvent>(256);
 
-    // Set up tracing: human ANSI layer -> TUI channel, stderr layer based on mode
-    let writer = TuiMakeWriter::new(tui_tx.clone());
+    // Set up tracing: human ANSI layer -> TUI channel, stderr layer based on mode.
+    // The TuiTraceState lets us reroute to stderr after the TUI exits.
+    let trace_state = Arc::new(TuiTraceState::new());
+    let writer = TuiMakeWriter::new(tui_tx.clone(), Arc::clone(&trace_state));
     setup_tracing(json_mode, Some(writer));
 
     // Compute region count
@@ -169,8 +171,7 @@ pub fn run_tui_mode(
     let worker_regions: Vec<Arc<Segment>> = regions.iter().map(Arc::clone).collect();
     let parallel = !sequential;
 
-    let worker_done = Arc::new((Mutex::new(false), Condvar::new()));
-    let worker_done2 = Arc::clone(&worker_done);
+    let (done_tx, done_rx) = std::sync::mpsc::sync_channel::<()>(1);
     let worker = thread::Builder::new()
         .name("test-driver".into())
         .spawn(move || {
@@ -189,8 +190,6 @@ pub fn run_tui_mode(
                     thread::Builder::new()
                         .name(format!("region-{i}"))
                         .spawn_scoped(s, move || {
-                            // Wait while paused before each pattern (checked inside run via on_activity isn't ideal,
-                            // but the pause loop was per-pattern-start, so we handle it here at region level)
                             let on_activity = |pos: f64| {
                                 tui_region.activity.touch(pos);
                             };
@@ -216,10 +215,7 @@ pub fn run_tui_mode(
 
             // All region threads have finished -- signal completion
             let _ = event_tx.send(RunEvent::RunComplete);
-
-            let (lock, cvar) = &*worker_done2;
-            *lock.lock().unwrap() = true;
-            cvar.notify_one();
+            let _ = done_tx.send(());
         })
         .expect("failed to spawn test-driver thread");
 
@@ -237,15 +233,14 @@ pub fn run_tui_mode(
     let config = TuiConfig::default();
     crate::tui::run_tui(&config, &regions, &tui_tx, &tui_rx).context("TUI failed")?;
 
-    // Wait for the worker with a bounded timeout.
-    {
-        let (lock, cvar) = &*worker_done;
-        let guard = lock.lock().unwrap();
-        let (done, _) = cvar.wait_timeout(guard, Duration::from_secs(5)).unwrap();
-        if !*done {
-            eprintln!("Worker did not exit within 5s, forcing exit");
-            shutdown::force_exit(2);
-        }
+    // TUI exited. Reroute tracing to stderr and drain buffered log events.
+    drop(TuiTraceGuard::new(trace_state, tui_rx));
+
+    // Wait for the worker with a bounded timeout (recv_timeout is race-free
+    // unlike Condvar::wait_timeout — the message sits in the buffer).
+    if done_rx.recv_timeout(Duration::from_secs(5)).is_err() {
+        eprintln!("Worker did not exit within 5s, forcing exit");
+        shutdown::force_exit(2);
     }
     let _ = worker.join();
     if bridge_handle.join().is_err() {
