Struct MonitorCore 

pub struct MonitorCore { /* private fields */ }

The monitor’s shareable core: ingest on one side, events + snapshots on the other. Session wiring lives in Monitor; the core is pure and deterministically testable.

Implementations

impl MonitorCore

pub fn new(capacity: usize) -> Arc<MonitorCore>

pub fn bounded(capacity: usize, max_keys: usize) -> Arc<MonitorCore>

A core whose statistics table is bounded at max_keys distinct keys.

pub fn ingest(&self, view: SampleView, sn: Option<u32>)

Ingest one sample: stats update + retention + broadcast. Hot path — two short locks, no tree work (that happens on the tick).

pub fn ingest_at( &self, view: Arc<SampleView>, sn: Option<u32>, now: Instant, wall: SystemTime, )

MonitorCore::ingest with both clocks injected (#217).

Replay rebuilds feed this with the capture clock — the row’s t offset from the load epoch, on both axes: now for the monotonic fold, wall for the skewed-latency subtraction — rather than the live clocks, which is what makes a rebuild deterministic down to the EWMA rates and the latency window: the same rows at the same instants fold to bit-identical statistics, however fast the rebuild loop runs. (Before wall was threaded, the latency read the live wall clock even under an injected now, so a rebuild folded arrival-time garbage — deep-review D2.)

pub fn node_event(&self, key: String, up: bool)

pub fn tick(&self)

Rebuild the snapshot from the stats and announce it.

Two phases, and the split is the whole point (#330). The stats mutex is the one ingest takes on zenoh’s network callback thread, so whatever this holds it for, the network layer waits for. It therefore holds it for the O(keys) row copy (StatsTable::rows) and folds the tree — O(keys × chunks) of BTreeMap descents, a String per new node, ~300 000 map operations at the 50 000-key bound — after releasing it. Four times a second the old shape held the lock for the whole rebuild, which made Monitor::watch’s promise that a slow UI cannot exert backpressure into the network layer false four times a second.

The fold still runs on the calling thread here. The periodic tick takes tick_off_runtime instead, which puts it on the blocking pool where that much CPU belongs.

pub async fn tick_off_runtime(&self)

tick with the fold on the blocking pool (#330): the copy is taken here, the CPU is spent on a blocking thread, and the runtime’s workers stay free for the drains they exist for. Used by the stats-tick task; tick remains the synchronous form for the paths that publish a snapshot as part of another operation (a seed boundary, an unwatch).

pub fn tree(&self) -> Arc<KeyTreeSnapshot>

The latest immutable snapshot (lock-free pull).

pub fn with_stats<R>(&self, f: impl FnOnce(&StatsTable) -> R) -> R

Read access to the raw stats (hz/bw commands).

pub fn with_stats_mut<R>(&self, f: impl FnOnce(&mut StatsTable) -> R) -> R

Mutable access — watch retirement and tests.

pub fn keys_unwatched(&self) -> u64

Keys retired from the table because their watch was released (RFC 09 §5.1 O6 — see crate::model::stats::StatsTable::unwatched).

pub fn dropped(&self) -> u64

Total events dropped across all lagging receivers so far.

pub fn keys_evicted(&self) -> u64

Distinct keys dropped from the statistics table to stay within its bound. Non-zero means the key set on display is partial — report it rather than letting a shrinking tree read as a quieting bus (RFC 09 §5.1).

pub fn retained(&self) -> Arc<[Arc<SampleView>]>

The retained window, oldest first (#217): Arc clones of every sample still inside both retention budgets. This is what the GUI’s retained scrub rebuilds panes from, and what “save window as .zrec” writes — the same rows either way.

Covers only watched keys by construction: the ring sits on the ingest path, and nothing unwatched is ever ingested. A consumer that presents this window MUST say so (RFC 09 §5.1 O5 — a retained window over three watches is not a retained window over the bus).

What this read costs the network thread (#331): the retain mutex is ingest’s, taken on zenoh’s callback thread, so a read that walked the window blocked the network layer for as long as the window was long — 64 MiB of 256-byte samples is ~260 000 refcount atomics, and zengui calls this from update(). The ring is chunked instead (crate::model::retain): under the lock this clones the sealed chunks’ pointers and the open tail — bounded by window / 1024 + 1024, independent of payload — and the flatten into the returned slice happens after the guard is dropped. The result is an Arc<[_]> so passing the window on costs nothing again.

pub fn retention(&self) -> RetentionStats

The retained window’s account of itself: budget in force, what it holds, and what each bound cost — evicted (byte budget) apart from expired (age), both apart from MonitorCore::dropped, MonitorCore::keys_evicted and MonitorCore::keys_unwatched (RFC 09 §5.1 O6; v1.18 R1 forbids folding the kinds).

pub fn set_retention_budget(&self, budget: RetentionBudget)

Change the retention budget in force; applied from the next push or read. The default (RetentionBudget::default) is 64 MiB / 2 min.

pub fn events(self: &Arc<Self>) -> EventStream

Subscribe to the event stream.