///|
/// Per-rule operational counters. A failure run counts consecutive observed
/// false verdicts, not continuous elapsed-time violation duration.
pub(all) struct RuleSummary {
name : String
accepted : Int32
rejected : Int32
failure_runs : Int32
current_failure_run : Int32
longest_failure_run : Int32
first_failure : Witness?
last_failure : Witness?
last_transition : Witness?
latest : Bool?
}
///|
pub struct Audit {
priv monitor : Monitor
priv summaries : Array[RuleSummary]
}
///|
pub fn Audit::new(plan : Plan) -> Audit {
let summaries = plan.names.map(name => RuleSummary::{
name,
accepted: 0,
rejected: 0,
failure_runs: 0,
current_failure_run: 0,
longest_failure_run: 0,
first_failure: None,
last_failure: None,
last_transition: None,
latest: None,
})
{ monitor: Monitor::new(plan), summaries, }
}
///|
/// Update counters only after the monitor atomically accepts an observation.
/// The audit retains O(number of rules) counters and no observation history.
pub fn Audit::push(
self : Audit,
observation : Observation,
) -> Result[Decision, MonitorError] {
let decision = match self.monitor.push(observation) {
Err(e) => return Err(e)
Ok(value) => value
}
let witness = Witness::{ position: decision.position, time: decision.time, }
for i in 0.. old.longest_failure_run {
run
} else {
old.longest_failure_run
},
first_failure: if !value && old.first_failure is None {
Some(witness)
} else {
old.first_failure
},
last_failure: if !value {
Some(witness)
} else {
old.last_failure
},
last_transition: if old.latest is Some(previous) && previous != value {
Some(witness)
} else {
old.last_transition
},
latest: Some(value),
}
}
Ok(decision)
}
///|
pub fn Audit::summaries(self : Audit) -> Array[RuleSummary] {
self.summaries.copy()
}
///|
pub fn Audit::summary(self : Audit, name : String) -> RuleSummary? {
self.monitor.plan.rule_index(name).map(index => self.summaries[index])
}
///|
pub fn Audit::stats(self : Audit) -> MonitorStats {
self.monitor.stats()
}
///|
pub fn Audit::explain(
self : Audit,
name : String,
) -> Result[Array[Evidence], MonitorError] {
self.monitor.explain(name)
}
///|
pub fn Audit::last_decision(self : Audit) -> Decision? {
self.monitor.last_decision()
}