Struct RuleSet 

pub struct RuleSet<'a> { /* private fields */ }

Available on crate feature decode only.

A set of rules judged tick by tick over one event stream — the watchdog’s per-tick body, lifted out of watchdog so a second driver can run it (#218).

The driver owns the stream, the drain loop and the sweep; this owns everything the rules know: per-rule counters, the last sample and drop instants, the per-tick decode budget, and the transition detectors. Feed it every sample (observe_sample) and every drop (observe_drop) the stream yields, then evaluate once per tick and get back only what changed.

Why the seam exists. A trigger capture (zenctl record --on) must judge the same event stream it records: one subscription, one drop ledger. Had the capture run a watchdog of its own beside its recorder, the drops the judge saw and the drops in the file would have been two different facts about two different observers — and a {"dropped": n} in the file would say nothing about whether the rule that fired was judged over a clean window. With the body a value, the recorder drains one stream and hands every item to both the ring and the rules.

Sample attribution is by key-expression intersection against each rule’s selector; a sample whose key does not parse as one counts for no rule. Time is tokio::time::Instant, so a driver under paused time judges exact windows.

Implementations

impl<'a> RuleSet<'a>

pub fn new( rules: &[Condition], base: &'a str, slices: Option<&'a SliceSet>, ) -> Result<Self>

Compile the rules. Fails on a selector that is not a key expression — before anything is declared, so the ? has nothing to tear down (#336). The watch clock starts here: CondWindow::observed_s is measured from construction, so build the set right before the subscriptions are declared.

pub fn watched(&self) -> &[String]

The distinct selectors the rules observe — what the driver must subscribe to before the first window opens (O4).

pub fn wants_doctor(&self) -> bool

Some rule judges a doctor run, so the driver owes one per tick.

pub fn wants_roster(&self) -> bool

Some rule judges the liveliness roster, so the driver owes one ask per tick.

pub fn wants_decode(&self) -> bool

Some rule judges payload validity, so the driver owes a warmed, sealed schema store (#337) and a decode per wants_verdict.

pub fn wants_verdict(&mut self, s: &SampleView) -> bool

Whether this sample should be decoded before it is observed: an invalid-payload rule matches its key and the key’s per-tick decode budget has room. Spends the budget — ask once per sample, then hand the verdict to observe_sample. The decode stays the driver’s, because it is async and this is not.

pub fn observe_sample( &mut self, s: &SampleView, facts_cache: &mut FactsCache, verdict: Option<&Verdict>, )

Count one observed sample against every rule its key matches. verdict is the decode the driver ran when wants_verdict said so; None means the sample was not checked, which is counted as exactly that.

pub fn observe_drop(&mut self, n: u64)

The stream dropped n samples here (RFC 09 §5.1 O6): unattributable to any one selector, so it taints every completeness claim this tick.

pub fn evaluate( &mut self, now: Instant, at: &str, sweep: SweepOutcome<'_>, ) -> Vec<Transition>

Close the tick: judge every rule over the window measured since the last evaluation, reset the per-tick counts, and hand back only the genuine changes — none for an unchanged rule. at is the wall-clock stamp the transitions carry.

pub fn ticks(&self) -> u64

Ticks evaluated so far.

pub fn last_eval(&self) -> Instant

When the last tick closed (construction, before the first): the driver’s next deadline is measured from here, so a slow consumer of the transitions widens the next window rather than skipping one.

pub fn transitions(&self) -> u64

Transitions emitted so far.