use metrics::{Counter, Gauge, Histogram, HistogramFn, Key, KeyName, Metadata, SharedString, Unit};
use std::collections::HashMap;
use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::{Arc, Mutex};
#[derive(Clone, Default)]
pub(crate) struct CapturingRecorder {
counters: Arc<Mutex<HashMap<Key, Arc<AtomicU64>>>>,
histograms: Arc<Mutex<HashMap<Key, Arc<VecHistogram>>>>,
}
#[derive(Default)]
struct VecHistogram(Mutex<Vec<f64>>);
impl HistogramFn for VecHistogram {
fn record(&self, value: f64) {
self.0.lock().expect("histogram samples should be lockable").push(value);
}
}
impl metrics::Recorder for CapturingRecorder {
fn describe_counter(&self, _: KeyName, _: Option<Unit>, _: SharedString) {}
fn describe_gauge(&self, _: KeyName, _: Option<Unit>, _: SharedString) {}
fn describe_histogram(&self, _: KeyName, _: Option<Unit>, _: SharedString) {}
fn register_counter(&self, key: &Key, _: &Metadata<'_>) -> Counter {
let cell = self
.counters
.lock()
.expect("counter map should be lockable")
.entry(key.clone())
.or_default()
.clone();
Counter::from_arc(cell)
}
fn register_gauge(&self, _: &Key, _: &Metadata<'_>) -> Gauge {
Gauge::noop()
}
fn register_histogram(&self, key: &Key, _: &Metadata<'_>) -> Histogram {
let cell = self
.histograms
.lock()
.expect("histogram map should be lockable")
.entry(key.clone())
.or_default()
.clone();
Histogram::from_arc(cell)
}
}
impl CapturingRecorder {
pub(crate) fn counter_value(&self, name: &str, labels: &[(&str, &str)]) -> u64 {
self.counters
.lock()
.expect("counter map should be lockable")
.iter()
.filter(|(key, _)| {
key.name() == name
&& labels
.iter()
.all(|(lk, lv)| key.labels().any(|label| label.key() == *lk && label.value() == *lv))
})
.map(|(_, value)| value.load(Ordering::Relaxed))
.sum()
}
pub(crate) fn histogram_sample_count(&self, name: &str) -> usize {
self.histograms
.lock()
.expect("histogram map should be lockable")
.iter()
.filter(|(key, _)| key.name() == name)
.map(|(_, samples)| samples.0.lock().expect("samples should be lockable").len())
.sum()
}
pub(crate) fn histogram_values(&self, name: &str, labels: &[(&str, &str)]) -> Vec<f64> {
self.histograms
.lock()
.expect("histogram map should be lockable")
.iter()
.filter(|(key, _)| {
key.name() == name
&& labels
.iter()
.all(|(lk, lv)| key.labels().any(|label| label.key() == *lk && label.value() == *lv))
})
.flat_map(|(_, samples)| samples.0.lock().expect("samples should be lockable").clone())
.collect()
}
}