ZFS tab: Writes — the RAM write buffer, each pool's write rate, and a landing tier with its mover

Live from arcstats (dirty), dmu_tx (throttled writes), each pool's txgs (bytes synced to disk)
and objset kstats (bytes from programs). A landing tier — a mergerfs pool whose first branch is
fast storage and whose last is a ZFS dataset — is detected from mergerfs's branch xattr; a mover
status file in /run/landing-mover/ adds its queue, the file in flight and totals. Sensors
zfs.write.*, zfs.<pool>.write_bps|logical_bps and zfs.<pool>.landing.* carry the history.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

internal/metrics/fold.go

@@ -122,9 +122,54 @@ func fold(b []Sample) Sample {
 			out.Disks[i].ReadBps, out.Disks[i].WriteBps, out.Disks[i].UtilPct = v[0], v[1], v[2]
 		}
 	}
+	out.ZFSWrite = foldZFSWrites(b, out.ZFSWrite)
 	return out
 }
 
+// foldZFSWrites averages the write path's rates and the buffer's fill over a bucket, per pool;
+// everything else (limits, the mover's state, the last walk) is the newest sample's.
+func foldZFSWrites(b []Sample, last *ZFSWrites) *ZFSWrites {
+	if last == nil {
+		return nil
+	}
+	w := *last
+	w.Pools = append([]PoolWrites(nil), last.Pools...)
+	var dirty, delayed, over, n float64
+	for _, s := range b {
+		if s.ZFSWrite != nil {
+			dirty, delayed, over, n = dirty+float64(s.ZFSWrite.Dirty), delayed+s.ZFSWrite.DelayedPerSec, over+s.ZFSWrite.OverMaxPerSec, n+1
+		}
+	}
+	if n > 0 {
+		w.Dirty, w.DelayedPerSec, w.OverMaxPerSec = uint64(dirty/n), round1(delayed/n), round1(over/n)
+	}
+	per := avgBy(b, func(s Sample) map[string][]float64 {
+		m := map[string][]float64{}
+		if s.ZFSWrite == nil {
+			return m
+		}
+		for _, p := range s.ZFSWrite.Pools {
+			v := []float64{p.WriteBps, p.LogicalBps, 0, 0}
+			if p.Landing != nil {
+				v[2], v[3] = p.Landing.InBps, p.Landing.DrainBps
+			}
+			m[p.Pool] = v
+		}
+		return m
+	})
+	for i, p := range w.Pools {
+		if v, ok := per[p.Pool]; ok {
+			w.Pools[i].WriteBps, w.Pools[i].LogicalBps = round1(v[0]), round1(v[1])
+			if p.Landing != nil {
+				l := *p.Landing
+				l.InBps, l.DrainBps = round1(v[2]), round1(v[3])
+				w.Pools[i].Landing = &l
+			}
+		}
+	}
+	return &w
+}
+
 // avgBy averages each sample's named numbers across the bucket, per name.
 func avgBy(b []Sample, of func(Sample) map[string][]float64) map[string][]float64 {
 	sums := map[string][]float64{}