use core::cell::RefCell;
use core::fmt;
use critical_section::Mutex;
use heapless::Vec;
use portable_atomic::{AtomicBool, Ordering};
use crate::erased::MetricGroup;
fn same_group(a: &dyn MetricGroup, b: &dyn MetricGroup) -> bool {
core::ptr::addr_eq(a, b)
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct RegistryFull;
impl fmt::Display for RegistryFull {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str("the metrics registry is full")
}
}
impl core::error::Error for RegistryFull {}
pub type GroupSnapshot<const N: usize = { crate::config::MAX_GROUPS }> =
Vec<&'static dyn MetricGroup, N>;
pub struct Registry<const N: usize = { crate::config::MAX_GROUPS }> {
groups: Mutex<RefCell<Vec<&'static dyn MetricGroup, N>>>,
}
impl<const N: usize> Registry<N> {
pub const fn new() -> Self {
Self {
groups: Mutex::new(RefCell::new(Vec::new())),
}
}
pub fn register(&self, group: &'static dyn MetricGroup) -> Result<(), RegistryFull> {
critical_section::with(|cs| {
let mut groups = self.groups.borrow_ref_mut(cs);
if groups.iter().any(|g| same_group(*g, group)) {
return Ok(());
}
groups.push(group).map_err(|_| RegistryFull)
})
}
pub fn snapshot(&self) -> Vec<&'static dyn MetricGroup, N> {
critical_section::with(|cs| self.groups.borrow_ref(cs).clone())
}
}
impl<const N: usize> Default for Registry<N> {
fn default() -> Self {
Self::new()
}
}
static GLOBAL: Registry = Registry::new();
pub fn register(group: &'static dyn MetricGroup) -> Result<(), RegistryFull> {
GLOBAL.register(group)
}
pub fn snapshot() -> GroupSnapshot {
GLOBAL.snapshot()
}
pub struct OnceRegister {
registered: AtomicBool,
}
impl OnceRegister {
pub const fn new() -> Self {
Self {
registered: AtomicBool::new(false),
}
}
pub fn ensure(&self, group: &'static dyn MetricGroup) {
self.ensure_with(group, || register(group));
}
pub fn ensure_in<const N: usize>(
&self,
registry: &Registry<N>,
group: &'static dyn MetricGroup,
) {
self.ensure_with(group, || registry.register(group));
}
fn ensure_with(
&self,
group: &'static dyn MetricGroup,
register: impl FnOnce() -> Result<(), RegistryFull>,
) {
if self.registered.load(Ordering::Acquire) {
return;
}
let result = register();
if !self.registered.swap(true, Ordering::AcqRel) {
#[cfg(feature = "log")]
if result.is_err() {
log::error!(
"embeprom: metric group \"{}\" did not self-register: registry is full \
(increase its capacity); its metrics will be absent from scrapes",
group.group_name()
);
}
}
#[cfg(not(feature = "log"))]
let _ = (group, result);
}
}
impl Default for OnceRegister {
fn default() -> Self {
Self::new()
}
}
#[cfg(test)]
mod tests {
use super::*;
mod a_metrics {
crate::metrics! {
registration = manual;
namespace = "a";
value: Counter,
}
}
mod b_metrics {
crate::metrics! {
registration = manual;
namespace = "b";
value: Counter,
}
}
mod c_metrics {
crate::metrics! {
registration = manual;
namespace = "c";
value: Counter,
}
}
mod d_metrics {
crate::metrics! {
registration = manual;
namespace = "d";
value: Counter,
}
}
#[test]
fn registers_and_snapshots() {
let r: Registry<2> = Registry::new();
assert!(r.snapshot().is_empty());
r.register(a_metrics::get()).unwrap();
r.register(b_metrics::get()).unwrap();
let snap = r.snapshot();
assert_eq!(snap.len(), 2);
assert_eq!(snap[0].group_name(), "a");
assert_eq!(snap[1].group_name(), "b");
}
#[test]
fn register_reports_full() {
let r: Registry<1> = Registry::new();
assert_eq!(r.register(a_metrics::get()), Ok(()));
assert_eq!(r.register(b_metrics::get()), Err(RegistryFull));
assert_eq!(r.snapshot().len(), 1);
let mut message = heapless::String::<64>::new();
core::fmt::Write::write_fmt(&mut message, format_args!("{RegistryFull}")).unwrap();
assert_eq!(message, "the metrics registry is full");
}
#[test]
fn registering_the_same_group_twice_is_a_no_op() {
let r: Registry<1> = Registry::new();
assert_eq!(r.register(a_metrics::get()), Ok(()));
assert_eq!(r.register(a_metrics::get()), Ok(()));
assert_eq!(r.snapshot().len(), 1);
}
#[test]
fn global_registry_accepts_registration() {
register(c_metrics::get()).unwrap();
assert_eq!(
snapshot()
.iter()
.filter(|g| core::ptr::addr_eq(**g, c_metrics::get()))
.count(),
1
);
}
#[test]
fn once_register_registers_exactly_once() {
let once = OnceRegister::new();
once.ensure(d_metrics::get());
once.ensure(d_metrics::get());
once.ensure(d_metrics::get());
assert_eq!(
snapshot()
.iter()
.filter(|g| core::ptr::addr_eq(**g, d_metrics::get()))
.count(),
1
);
}
#[test]
fn once_register_can_target_a_caller_owned_registry() {
let registry: Registry<1> = Registry::new();
let once = OnceRegister::new();
once.ensure_in(®istry, a_metrics::get());
once.ensure_in(®istry, a_metrics::get());
assert_eq!(registry.snapshot().len(), 1);
}
#[test]
fn completed_registration_skips_later_attempts() {
let once = OnceRegister::new();
let attempts = core::cell::Cell::new(0);
once.ensure_with(a_metrics::get(), || {
attempts.set(attempts.get() + 1);
Ok(())
});
once.ensure_with(a_metrics::get(), || {
attempts.set(attempts.get() + 1);
Ok(())
});
assert_eq!(attempts.get(), 1);
}
}