Bump version to v0.15.1

lance0 · lance0 · commit 93ccdf67b883 · 2026-01-27T20:36:09.000-05:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -5,6 +5,12 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.15.1] - 2026-01-28
+
+### Fixed
+- **TUI lock contention**: Snapshot session data before rendering so no locks are held during draw, fixing UI freezes during rapid target switching (#19)
+- **Stat column desync**: Sent counter now updates atomically with Avg/Min/Max/Loss instead of racing ahead (#17)
+
 ## [0.15.0] - 2026-01-27
 
 ### Added
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "ttl"
-version = "0.15.0"
+version = "0.15.1"
 edition = "2024"
 rust-version = "1.88"
 description = "Modern traceroute/mtr-style TUI with hop stats and optional ASN/geo enrichment"
diff --git a/src/state/session.rs b/src/state/session.rs
@@ -1229,7 +1229,7 @@ pub struct Session {
     pub config: Config,
     pub complete: bool,       // destination reached?
     pub dest_ttl: Option<u8>, // TTL at which destination was reached (actual hop count)
-    pub total_sent: u64,      // total probes sent across all hops
+    pub total_sent: u64,      // total completed probes (response or timeout) across all hops
     #[serde(skip)]
     pub paused: bool, // pause probing (TUI only)
     /// PMTUD state (only present when --pmtud is enabled)
@@ -1352,6 +1352,26 @@ impl Session {
         self.hops.iter().find(|h| h.has_nat()).map(|h| h.ttl)
     }
 
+    /// Clone session data for TUI rendering, excluding events (which can be large).
+    /// The events vec is only used for replay export, never during TUI rendering.
+    pub fn snapshot_for_render(&self) -> Self {
+        Self {
+            target: self.target.clone(),
+            started_at: self.started_at,
+            started_instant: self.started_instant,
+            hops: self.hops.clone(),
+            config: self.config.clone(),
+            complete: self.complete,
+            dest_ttl: self.dest_ttl,
+            total_sent: self.total_sent,
+            paused: self.paused,
+            pmtud: self.pmtud.clone(),
+            source_ip: self.source_ip,
+            gateway: self.gateway,
+            events: Vec::new(),
+        }
+    }
+
     /// Record a probe event for animated replay
     pub fn record_event(&mut self, event: ProbeEvent) {
         self.events.push(event);
diff --git a/src/trace/engine.rs b/src/trace/engine.rs
@@ -269,16 +269,6 @@ impl ProbeEngine {
                             continue;
                         }
 
-                        // Record that we sent a probe
-                        {
-                            let mut state = self.state.write();
-                            if let Some(hop) = state.hop_mut(ttl) {
-                                hop.record_sent();
-                                hop.record_flow_sent(0); // ICMP uses single flow (checksum trick not yet implemented)
-                            }
-                            state.total_sent += 1;
-                        }
-
                         // Apply rate limiting if configured
                         self.apply_rate_limit().await;
                     }
@@ -425,16 +415,6 @@ impl ProbeEngine {
                                 continue;
                             }
 
-                            // Record that we sent a probe
-                            {
-                                let mut state = self.state.write();
-                                if let Some(hop) = state.hop_mut(ttl) {
-                                    hop.record_sent();
-                                    hop.record_flow_sent(flow_id);
-                                }
-                                state.total_sent += 1;
-                            }
-
                             // Apply rate limiting if configured
                             self.apply_rate_limit().await;
                         }
@@ -563,16 +543,6 @@ impl ProbeEngine {
                                 continue;
                             }
 
-                            // Record that we sent a probe
-                            {
-                                let mut state = self.state.write();
-                                if let Some(hop) = state.hop_mut(ttl) {
-                                    hop.record_sent();
-                                    hop.record_flow_sent(flow_id);
-                                }
-                                state.total_sent += 1;
-                            }
-
                             // Apply rate limiting if configured
                             self.apply_rate_limit().await;
                         }
@@ -701,10 +671,7 @@ impl ProbeEngine {
         // Send the probe
         match send_icmp(socket, &packet, self.target) {
             Ok(_) => {
-                // Don't increment hop.sent for PMTUD probes - they're for MTU discovery,
-                // not traceroute measurements. Only increment total_sent for diagnostics.
-                let mut state = self.state.write();
-                state.total_sent += 1;
+                // Sent counting deferred to receiver for atomic stat updates
                 true
             }
             Err(e) => {
@@ -797,9 +764,12 @@ impl ProbeEngine {
 
                         // Update state with parity to receiver behavior
                         let mut state = self.state.write();
+                        state.total_sent += 1;
 
                         // Only record hop stats for normal probes, not PMTUD probes
                         if !is_pmtud_probe && let Some(hop) = state.hop_mut(parsed.probe_id.ttl) {
+                            hop.record_sent();
+                            hop.record_flow_sent(flow_id);
                             // Use flap-detecting record for single-flow mode (ICMP is always single-flow)
                             hop.record_response_detecting_flaps(parsed.responder, rtt, None);
                             hop.record_flow_response(flow_id, parsed.responder, rtt);
diff --git a/src/trace/receiver.rs b/src/trace/receiver.rs
@@ -295,10 +295,15 @@ impl Receiver {
                         let mut state = session.write();
                         let is_pmtud_probe = resp.packet_size.is_some();
 
+                        // Increment sent count here (not in engine) so all stats update atomically
+                        state.total_sent += 1;
+
                         // Only record hop stats for normal probes, not PMTUD probes
                         // PMTUD probes are for MTU discovery, not traceroute measurements
                         if !is_pmtud_probe {
                             if let Some(hop) = state.hop_mut(resp.probe_id.ttl) {
+                                hop.record_sent();
+                                hop.record_flow_sent(resp.flow_id);
                                 // Record aggregate stats with optional flap detection
                                 // Only detect flaps in single-flow mode (multi-flow expects path changes)
                                 if self.config.num_flows == 1 {
@@ -410,9 +415,14 @@ impl Receiver {
                         if let Some(session) = sessions.get(target) {
                             let mut state = session.write();
 
+                            // Increment sent count here (not in engine) so all stats update atomically
+                            state.total_sent += 1;
+
                             // Only record hop timeouts for normal probes, not PMTUD probes
                             if !is_pmtud_probe {
                                 if let Some(hop) = state.hop_mut(probe_id.ttl) {
+                                    hop.record_sent();
+                                    hop.record_flow_sent(probe.flow_id);
                                     hop.record_timeout();
                                     hop.record_flow_timeout(probe.flow_id);
                                 }
diff --git a/src/tui/app.rs b/src/tui/app.rs
@@ -24,7 +24,8 @@ use crate::state::{ProbeEvent, ProbeOutcome, Session};
 use crate::trace::receiver::SessionMap;
 use crate::tui::theme::Theme;
 use crate::tui::views::{
-    HelpView, HopDetailView, MainView, SettingsState, SettingsView, TargetListView,
+    HelpView, HopDetailView, MainView, SettingsState, SettingsView, TargetInfo, TargetListView,
+    extract_target_infos,
 };
 
 /// State for animated replay playback
@@ -99,6 +100,10 @@ pub struct UiState {
     pub update_available: Option<String>,
     /// Replay animation state (None = live mode or static replay)
     pub replay_state: Option<ReplayState>,
+    /// Cached target list info (populated when overlay is open, refreshed every 30 ticks)
+    pub target_list_cache: Option<Vec<TargetInfo>>,
+    /// Tick counter for target list cache refresh
+    pub target_list_tick: u32,
 }
 
 impl UiState {
@@ -310,22 +315,23 @@ where
             // Capture target before acquiring locks to prevent race condition
             let target_ip = targets[ui_state.selected_target];
 
-            // Apply all events up to current adjusted time
-            while replay.current_index < replay.events.len() {
-                let event = &replay.events[replay.current_index];
-                if event.offset_ms <= adjusted_elapsed {
-                    let sessions_read = sessions.read();
-                    if let Some(session_lock) = sessions_read.get(&target_ip) {
-                        let mut session = session_lock.write();
-                        apply_replay_event(
-                            &mut session,
-                            &replay.events[replay.current_index].clone(),
-                        );
+            // Find all events up to current adjusted time
+            let start = replay.current_index;
+            let mut end = start;
+            while end < replay.events.len() && replay.events[end].offset_ms <= adjusted_elapsed {
+                end += 1;
+            }
+
+            // Apply all events in a single lock acquisition (no per-event lock churn)
+            if end > start {
+                let sessions_read = sessions.read();
+                if let Some(session_lock) = sessions_read.get(&target_ip) {
+                    let mut session = session_lock.write();
+                    for event in &replay.events[start..end] {
+                        apply_replay_event(&mut session, event);
                     }
-                    replay.current_index += 1;
-                } else {
-                    break; // Wait for this event's time
                 }
+                replay.current_index = end;
             }
 
             // Check if replay is complete
@@ -344,24 +350,41 @@ where
         // Get cache status for settings modal
         let cache_status = ix_lookup.as_ref().map(|ix| ix.get_cache_status());
 
-        // Draw
-        terminal.draw(|f| {
+        // Snapshot session data BEFORE draw so no locks are held during rendering.
+        // Uses snapshot_for_render() to skip cloning the events vec (unbounded, not used in render).
+        let session_snapshot = {
             let sessions_read = sessions.read();
-            if let Some(state) = sessions_read.get(&current_target) {
-                let session = state.read();
+            sessions_read
+                .get(&current_target)
+                .map(|state| state.read().snapshot_for_render())
+        };
+
+        // Refresh target list cache (~every 500ms while overlay is open)
+        if ui_state.show_target_list {
+            ui_state.target_list_tick += 1;
+            if ui_state.target_list_cache.is_none() || ui_state.target_list_tick.is_multiple_of(30)
+            {
+                ui_state.target_list_cache = Some(extract_target_infos(&sessions, &targets));
+            }
+        } else {
+            ui_state.target_list_cache = None;
+            ui_state.target_list_tick = 0;
+        }
+
+        // Draw (no locks held — all data is pre-extracted snapshots)
+        if let Some(ref session) = session_snapshot {
+            terminal.draw(|f| {
                 draw_ui(
                     f,
-                    &session,
+                    session,
                     ui_state,
                     &theme,
                     num_targets,
-                    &sessions,
-                    &targets,
                     cache_status.clone(),
                     ix_enabled,
                 );
-            }
-        })?;
+            })?;
+        }
 
         // Handle input with timeout
         if event::poll(tick_rate)?
@@ -685,6 +708,9 @@ where
                     if num_targets > 1 {
                         ui_state.target_list_index = ui_state.selected_target;
                         ui_state.show_target_list = true;
+                        ui_state.target_list_cache =
+                            Some(extract_target_infos(&sessions, &targets));
+                        ui_state.target_list_tick = 0;
                     }
                 }
                 KeyCode::Char('u') => {
@@ -782,8 +808,6 @@ fn draw_ui(
     ui_state: &UiState,
     theme: &Theme,
     num_targets: usize,
-    sessions: &SessionMap,
-    targets: &[IpAddr],
     cache_status: Option<crate::lookup::ix::CacheStatus>,
     ix_enabled: bool,
 ) {
@@ -897,9 +921,11 @@ fn draw_ui(
         }
     }
 
-    if ui_state.show_target_list {
+    if ui_state.show_target_list
+        && let Some(ref infos) = ui_state.target_list_cache
+    {
         f.render_widget(
-            TargetListView::new(theme, sessions, targets, ui_state.target_list_index),
+            TargetListView::new(theme, infos, ui_state.target_list_index),
             area,
         );
     }
diff --git a/src/tui/views/targets.rs b/src/tui/views/targets.rs
