use crate::shutdown::CancellationToken;
use serde::Serialize;
use std::sync::{
Arc, Mutex, OnceLock,
atomic::{AtomicBool, AtomicU8, AtomicUsize, Ordering},
};
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum SubscriptionStatus {
Pending,
Running,
Stopping,
Stopped,
Failed,
}
impl SubscriptionStatus {
const ALL: [Self; 5] = [
Self::Pending,
Self::Running,
Self::Stopping,
Self::Stopped,
Self::Failed,
];
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
pub struct SubscriptionReport {
pub name: String,
pub status: SubscriptionStatus,
pub receive_failures: usize,
pub receive_backoff: bool,
pub publish_retries: usize,
pub ready: bool,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
pub struct HealthReport {
pub live: bool,
pub ready: bool,
pub shutting_down: bool,
pub subscriptions: Vec<SubscriptionReport>,
}
#[derive(Clone, Default)]
pub struct Health(Arc<Registry>);
#[derive(Default)]
struct Registry {
subscriptions: Mutex<Vec<Arc<Tracker>>>,
shutdown: OnceLock<CancellationToken>,
}
impl Health {
pub fn report(&self) -> HealthReport {
let subscriptions: Vec<_> = self
.0
.subscriptions
.lock()
.unwrap()
.iter()
.map(|tracker| tracker.report())
.collect();
let started = self.0.shutdown.get();
let shutting_down = started.is_some_and(CancellationToken::is_cancelled);
HealthReport {
live: subscriptions
.iter()
.all(|subscription| subscription.status != SubscriptionStatus::Failed),
ready: started.is_some()
&& !shutting_down
&& subscriptions.iter().all(|subscription| subscription.ready),
shutting_down,
subscriptions,
}
}
pub fn is_live(&self) -> bool {
self.report().live
}
pub fn is_ready(&self) -> bool {
self.report().ready
}
pub(crate) fn register(&self, name: &str) -> Arc<Tracker> {
let tracker = Arc::new(Tracker::new(name));
self.0.subscriptions.lock().unwrap().push(tracker.clone());
tracker
}
pub(crate) fn start(&self, shutdown: &CancellationToken) {
let _ = self.0.shutdown.set(shutdown.clone());
}
}
pub(crate) struct Tracker {
name: String,
status: AtomicU8,
receive_failures: AtomicUsize,
receive_backoff: AtomicBool,
publish_retries: AtomicUsize,
}
impl Tracker {
fn new(name: &str) -> Self {
Self {
name: name.to_owned(),
status: AtomicU8::new(SubscriptionStatus::Pending as u8),
receive_failures: AtomicUsize::new(0),
receive_backoff: AtomicBool::new(false),
publish_retries: AtomicUsize::new(0),
}
}
pub(crate) fn set_status(&self, status: SubscriptionStatus) {
self.status.store(status as u8, Ordering::Relaxed);
}
pub(crate) fn receive_failed(&self, failures: usize) {
self.receive_failures.store(failures, Ordering::Relaxed);
self.receive_backoff.store(true, Ordering::Relaxed);
}
pub(crate) fn receive_resumed(&self) {
self.receive_backoff.store(false, Ordering::Relaxed);
}
pub(crate) fn receive_succeeded(&self) {
self.receive_failures.store(0, Ordering::Relaxed);
}
pub(crate) fn publish_retry(&self) -> PublishRetry<'_> {
self.publish_retries.fetch_add(1, Ordering::Relaxed);
PublishRetry(self)
}
fn report(&self) -> SubscriptionReport {
let status = SubscriptionStatus::ALL[self.status.load(Ordering::Relaxed) as usize];
let receive_failures = self.receive_failures.load(Ordering::Relaxed);
let receive_backoff = self.receive_backoff.load(Ordering::Relaxed);
let publish_retries = self.publish_retries.load(Ordering::Relaxed);
let ready = match status {
SubscriptionStatus::Running => !receive_backoff && publish_retries == 0,
SubscriptionStatus::Stopped => true,
SubscriptionStatus::Pending
| SubscriptionStatus::Stopping
| SubscriptionStatus::Failed => false,
};
SubscriptionReport {
name: self.name.clone(),
status,
receive_failures,
receive_backoff,
publish_retries,
ready,
}
}
}
pub(crate) struct PublishRetry<'a>(&'a Tracker);
impl Drop for PublishRetry<'_> {
fn drop(&mut self) {
self.0.publish_retries.fetch_sub(1, Ordering::Relaxed);
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn readiness_follows_lifecycle_and_failures() {
let health = Health::default();
let orders = health.register("orders");
let seed = health.register("seed");
assert!(!health.is_ready(), "not ready before the application runs");
assert!(health.is_live());
let shutdown = CancellationToken::new();
health.start(&shutdown);
orders.set_status(SubscriptionStatus::Running);
seed.set_status(SubscriptionStatus::Running);
assert!(health.is_ready());
orders.receive_failed(2);
assert!(!health.is_ready());
orders.receive_resumed();
assert!(health.is_ready(), "a retried receive that waits is ready");
assert_eq!(health.report().subscriptions[0].receive_failures, 2);
orders.receive_succeeded();
{
let _retry = orders.publish_retry();
assert_eq!(health.report().subscriptions[0].publish_retries, 1);
assert!(!health.is_ready());
}
assert!(health.is_ready());
seed.set_status(SubscriptionStatus::Stopped);
assert!(health.is_ready(), "a source that ended keeps the app ready");
shutdown.cancel();
let report = health.report();
assert!(report.shutting_down && !report.ready && report.live);
orders.set_status(SubscriptionStatus::Failed);
assert!(!health.is_live());
}
}