Struct Monitor 

pub struct Monitor { /* private fields */ }

The wired monitor: a runtime-mutable watch set + liveliness + tick task feeding a core.

Lazy by construction (issue #84): start with empty spec.selectors declares no data-plane subscribers at all — only the zero-payload liveliness watches and the tick. Data flows only for what Monitor::watch was asked to observe, and Monitor::unwatch provably undeclares (an explicit, awaited undeclaration — not a dropped handle racing the network).

Implementations

impl Monitor

pub async fn start(session: &Session, spec: MonitorSpec) -> Result<Monitor>

Declare the spec’s subscribers on session and start watching. spec.selectors are simply the initial watches — [] is the lazy start.

pub async fn watch(&self, selector: &str) -> Result<WatchId>

Observe a selector: declares a callback subscriber feeding the core.

The callback runs on zenoh’s network thread and does exactly what the old per-selector task did — one stats lock, one bounded broadcast send — so a slow UI still cannot exert backpressure into the network layer beyond the channel’s bound.

pub async fn watch_seeded( &self, selector: &str, policy: SeedPolicy, ) -> Result<WatchId>

Observe a selector with a correct seed phase (issue #92; the RFC 04 §3.2 discipline of crate::seed_subscribe, run through this monitor’s bounded broadcast):

• the subscriber is declared first, then both seed paths run as bounded GETs (@adv caches for live publishers, the selector itself for router storages — the crashed-producer case);
• one per-key LWW merge spans seed and live samples until the boundary, so a transition in the seed window lands exactly once and a stale seed cannot regress a key. Suppressions are counted in the coverage, never silently absorbed (O6) — and they are not part of Dropped(n), which counts only broadcast lag;
• FleetEvent::WatchSeeded fires once both paths resolve, carrying this id and the crate::SeedCoverage. After it, the merge is dropped and live samples flow untouched (the merge map is a seed-phase structure, not a per-watch leak).

pub async fn unwatch(&self, id: WatchId) -> Result<()>

Stop observing: undeclares the subscriber (awaited to completion — the teardown is acknowledged, not racing a drop), then retires statistics for keys no remaining watch covers. Retired keys are counted (crate::stats::StatsTable::unwatched): a shrinking key set must never read as a quieting bus (RFC 09 §5.1 O6).

pub async fn watched(&self) -> Vec<(WatchId, String)>

The active watch set.

pub fn core(&self) -> &Arc<MonitorCore>

pub fn events(&self) -> EventStream

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

pub fn stop(self)

Stop watching. Equivalent to dropping the monitor — kept as an explicit verb for call sites that want to say so.

Trait Implementations

impl Debug for Monitor

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Drop for Monitor

Dropping a monitor stops it: the ingest tasks are aborted and the subscribers undeclare.

This is not a nicety. A JoinHandle merely detaches on drop, so without this impl every monitor that goes out of scope leaks a live subscriber and its ingest task for the lifetime of the session. zenctl never noticed — it calls Monitor::stop once and exits — but a GUI re-scopes its subscription whenever the user changes what they are watching, dropping and rebuilding the monitor each time.

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.