use crate::{PipelineResult, Trace, TraceOutcome};
use std::collections::BTreeMap;
use std::sync::Mutex;
pub trait Metrics: Send + Sync {
fn record_allow(&self, guard: &'static str);
fn record_block(&self, guard: &'static str);
fn record_modify(&self, guard: &'static str);
fn record_error(&self, guard: &'static str, kind: &'static str);
fn record_panic(&self, guard: &'static str);
}
#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
pub struct GuardCounters {
pub allow: u64,
pub block: u64,
pub modify: u64,
pub error: u64,
pub panic: u64,
}
#[derive(Debug, Default)]
pub struct InMemoryMetrics {
inner: Mutex<BTreeMap<&'static str, GuardCounters>>,
}
impl InMemoryMetrics {
pub fn new() -> Self {
InMemoryMetrics::default()
}
pub fn snapshot(&self) -> BTreeMap<&'static str, GuardCounters> {
self.inner.lock().map(|map| map.clone()).unwrap_or_default()
}
pub fn counters(&self, guard: &'static str) -> GuardCounters {
self.snapshot().get(guard).copied().unwrap_or_default()
}
}
impl InMemoryMetrics {
fn bump(&self, guard: &'static str, update: impl FnOnce(&mut GuardCounters)) {
if let Ok(mut map) = self.inner.lock() {
update(map.entry(guard).or_default());
}
}
}
impl Metrics for InMemoryMetrics {
fn record_allow(&self, guard: &'static str) {
self.bump(guard, |c| c.allow += 1);
}
fn record_block(&self, guard: &'static str) {
self.bump(guard, |c| c.block += 1);
}
fn record_modify(&self, guard: &'static str) {
self.bump(guard, |c| c.modify += 1);
}
fn record_error(&self, guard: &'static str, _kind: &'static str) {
self.bump(guard, |c| c.error += 1);
}
fn record_panic(&self, guard: &'static str) {
self.bump(guard, |c| c.panic += 1);
}
}
impl Trace {
pub fn emit_metrics(&self, metrics: &dyn Metrics) {
for entry in self.iter() {
match entry.outcome() {
TraceOutcome::Allowed => metrics.record_allow(entry.name()),
TraceOutcome::Blocked { .. } => metrics.record_block(entry.name()),
TraceOutcome::Modified => metrics.record_modify(entry.name()),
TraceOutcome::Failed { error, .. } if error.is_panic() => {
metrics.record_panic(entry.name());
}
TraceOutcome::Failed { error, .. } => {
metrics.record_error(entry.name(), error.kind());
}
}
}
}
}
impl<Out> PipelineResult<Out> {
pub fn emit_metrics(&self, metrics: &dyn Metrics) {
self.trace().emit_metrics(metrics);
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::{FailPolicy, GuardError, TraceEntry};
use std::time::Duration;
fn entry(name: &'static str, outcome: TraceOutcome) -> TraceEntry {
TraceEntry::new(name, outcome, Duration::ZERO)
}
#[test]
fn a_trace_increments_the_matching_counter_for_each_outcome() {
let mut trace = Trace::new();
trace.record(entry("a", TraceOutcome::Allowed));
trace.record(entry(
"b",
TraceOutcome::Blocked {
reason: "no".to_owned(),
},
));
trace.record(entry("c", TraceOutcome::Modified));
trace.record(entry(
"d",
TraceOutcome::Failed {
error: GuardError::Timeout,
policy: FailPolicy::FailClosed,
halted: true,
},
));
trace.record(entry(
"e",
TraceOutcome::Failed {
error: GuardError::Panicked("boom".to_owned()),
policy: FailPolicy::FailOpen,
halted: false,
},
));
let metrics = InMemoryMetrics::new();
trace.emit_metrics(&metrics);
assert_eq!(metrics.counters("a").allow, 1);
assert_eq!(metrics.counters("b").block, 1);
assert_eq!(metrics.counters("c").modify, 1);
assert_eq!(metrics.counters("d").error, 1);
assert_eq!(metrics.counters("e").panic, 1);
assert_eq!(metrics.counters("e").error, 0, "a panic is not an error");
}
}