Struct HealthMonitor 

pub struct HealthMonitor {
    pub state: RwLock<HealthState>,
    pub failure_count: RwLock<u32>,
    pub last_healthy: RwLock<Option<Instant>>,
    pub buffer: RwLock<VecDeque<InboundMessage>>,
    pub max_buffer_size: usize,
}

Health monitor state

Fields

state: RwLock<HealthState>

Current health state

failure_count: RwLock<u32>

Consecutive failure count

last_healthy: RwLock<Option<Instant>>

Last successful health check

buffer: RwLock<VecDeque<InboundMessage>>

Buffered messages during outage

max_buffer_size: usize

Maximum buffer size

Implementations

impl HealthMonitor

pub fn new(max_buffer_size: usize) -> Self

pub async fn get_state(&self) -> HealthState

Get current state

pub async fn record_success(&self) -> Option<HealthState>

Record a successful health check

pub async fn record_failure(&self, alert_threshold: u32) -> Option<HealthState>

Record a failed health check

pub async fn buffer_message(&self, message: InboundMessage) -> bool

Buffer a message during outage

pub async fn drain_buffer(&self) -> Vec<InboundMessage>

Drain buffered messages

pub async fn buffer_size(&self) -> usize

Get buffer size

pub async fn last_healthy_ago(&self) -> Option<Duration>

Get last healthy timestamp