feat: color device Err cell by session-baseline (#6)

Each device's io_errors value is snapshotted at app startup. The cell
renders bold red when the count has grown during this session
(actively failing) and dim when non-zero but unchanged (historic).
Lets the user tell at a glance whether a device's error count is dead
history or still climbing — without bcachefs needing to add a
timestamp or clear-errors knob upstream.

Same logic applies to the TOTAL row.

Author: fenio

README.md

@@ -20,6 +20,7 @@ Built for [NASty](https://github.com/nasty-project/nasty) but works on any syste
 - **Multi-filesystem support** — press `f` to cycle between mounted bcachefs filesystems
 - **Process IO view** showing which processes are doing IO
 - **Journal fill %**, load average, reconcile progress
+- **Session-aware error counts**: the device Err column dims pre-existing counts and turns bold red only when errors grow during the current run — so you can tell at a glance whether a number is dead history or actively climbing
 - **Consistent color scheme**: yellow = read, blue = write, red = errors/stalls
 
 ## Install

src/app.rs

@@ -75,13 +75,20 @@ pub struct App {
     pub show_help: bool,
     /// Scroll offset for counter/time stats/process views.
     pub view_scroll: usize,
+    /// Per-device io_errors value when first observed in this session.
+    /// Used to color the Err cell: matching baseline = historic (dim),
+    /// growing = active (red).
+    pub initial_errors: std::collections::HashMap<String, u64>,
 }
 
 impl App {
     pub fn new(all_fs: Vec<BcachefsFs>, fs_index: usize) -> Self {
         let fs = all_fs[fs_index].clone();
         let snap = sysfs::snapshot(&fs);
         let tuning = TuningState::new(&snap.options);
+        let initial_errors = snap.devices.iter()
+            .map(|d| (d.name.clone(), d.io_errors))
+            .collect();
         Self {
             fs,
             current: snap,
@@ -112,6 +119,7 @@ impl App {
             view_scroll: 0,
             dismissed_temp: Vec::new(),
             dismissed_permanent: std::collections::HashSet::new(),
+            initial_errors,
         }
     }
 
@@ -123,6 +131,12 @@ impl App {
 
         let new_snap = sysfs::snapshot(&self.fs);
 
+        // Baseline error counts for any newly-appearing devices so we
+        // don't flag pre-existing errors on a device added mid-session.
+        for d in &new_snap.devices {
+            self.initial_errors.entry(d.name.clone()).or_insert(d.io_errors);
+        }
+
         // Compute rates from previous snapshot
         let rates = metrics::compute_rates(&self.current, &new_snap, dt);
 
@@ -344,6 +358,9 @@ impl App {
         self.fs = self.all_fs[self.fs_index].clone();
         let snap = sysfs::snapshot(&self.fs);
         self.tuning = TuningState::new(&snap.options);
+        self.initial_errors = snap.devices.iter()
+            .map(|d| (d.name.clone(), d.io_errors))
+            .collect();
         self.current = snap;
         self.previous = None;
         self.rates = None;

src/ui.rs

@@ -447,6 +447,7 @@ fn draw_device_table(
     let mut sr = [0.0_f64; 5];
     let mut sw = [0.0_f64; 5];
     let mut sum_errs = 0u64;
+    let mut sum_new_errs = 0u64;
 
     struct DevData {
         name: String,
@@ -460,6 +461,7 @@ fn draw_device_table(
         read_active: bool,
         write_active: bool,
         errors: u64,
+        new_errors: u64,
         util_pct: f64,
     }
     let mut devs: Vec<DevData> = Vec::new();
@@ -474,12 +476,15 @@ fn draw_device_table(
             sr[4] += d.read_bytes_sec;
             sw[4] += d.write_bytes_sec;
             sum_errs += d.io_errors;
+            let baseline = app.initial_errors.get(&d.name).copied().unwrap_or(d.io_errors);
+            let new_errors = d.io_errors.saturating_sub(baseline);
+            sum_new_errs += new_errors;
             devs.push(DevData {
                 name: d.name.clone(), label: d.label.clone(), rv, wv,
                 read_total: d.read_bytes_sec, write_total: d.write_bytes_sec,
                 read_lat: d.read_latency_ns, write_lat: d.write_latency_ns,
                 read_active: d.read_active, write_active: d.write_active,
-                errors: d.io_errors, util_pct: d.util_pct,
+                errors: d.io_errors, new_errors, util_pct: d.util_pct,
             });
         }
     }
@@ -498,7 +503,16 @@ fn draw_device_table(
         }.style(theme::bold(theme::FG));
 
         let mut rows: Vec<Row> = devs.iter().enumerate().map(|(i, d)| {
-            let es = if d.errors > 0 { Style::default().fg(theme::RED) } else { Style::default().fg(theme::FG) };
+            // Err cell color: red+bold if errors grew this session (active
+            // failure), dim if non-zero but unchanged (historic), default fg
+            // if zero.
+            let es = if d.new_errors > 0 {
+                Style::default().fg(theme::RED).add_modifier(Modifier::BOLD)
+            } else if d.errors > 0 {
+                theme::dim()
+            } else {
+                Style::default().fg(theme::FG)
+            };
             let uc = if d.util_pct > 80.0 { theme::RED } else if d.util_pct > 50.0 { theme::YELLOW } else { theme::GREEN };
             let util_s = if d.util_pct > 0.0 { format!("{:.0}%", d.util_pct) } else { "\u{2014}".into() };
             let util_cell = Cell::new(util_s).style(Style::default().fg(uc));
@@ -519,17 +533,24 @@ fn draw_device_table(
             }
         }).collect();
         let total_style = theme::bold(theme::CYAN);
+        let total_err_style = if sum_new_errs > 0 {
+            Style::default().fg(theme::RED).add_modifier(Modifier::BOLD)
+        } else if sum_errs > 0 {
+            theme::dim()
+        } else {
+            total_style
+        };
         if has_labels {
             rows.push(Row::new(vec![
                 Cell::new("TOTAL").style(total_style),
                 Cell::new(""),
-                Cell::new(format!("{}", sum_errs)).style(total_style),
+                Cell::new(format!("{}", sum_errs)).style(total_err_style),
                 Cell::new(""),
             ]));
         } else {
             rows.push(Row::new(vec![
                 Cell::new("TOTAL").style(total_style),
-                Cell::new(format!("{}", sum_errs)).style(total_style),
+                Cell::new(format!("{}", sum_errs)).style(total_err_style),
                 Cell::new(""),
             ]));
         }