Struct HealthCheck 

pub struct HealthCheck {
    pub state: EngineState,
    pub ready: bool,
    pub sync_engine_accepting_writes: bool,
    pub peers_total: usize,
    pub peers_connected: usize,
    pub peers_circuit_open: usize,
    pub peers_catching_up: usize,
    pub peers: Vec<PeerHealth>,
    pub healthy: bool,
}

Comprehensive health status of the replication engine.

This struct provides all the information needed for:

• /ready endpoint: Just check ready field
• /health endpoint: Full diagnostics with per-peer status
• Metrics dashboards: Peer connectivity, lag, circuit states

Data Sources

All data is cached from internal state - no network I/O during health check:

• Engine state: From internal watch channel
• Peer status: From PeerConnection atomics and mutexes
• Sync-engine health: From SyncEngineRef::should_accept_writes()

Example

let health = engine.health_check().await;
if health.ready {
    // Ready for traffic
} else {
    // Log diagnostics
    eprintln!("Engine not ready: state={}, peers_connected={}/{}",
        health.state, health.peers_connected, health.peers_total);
}

Fields

state: EngineState

Current engine lifecycle state. Source: Cached from state_tx watch channel.

ready: bool

Whether the engine is ready for traffic. Source: Derived from state == Running && peers_connected > 0.

sync_engine_accepting_writes: bool

Whether the local sync-engine is accepting writes. Source: From sync_engine.should_accept_writes(). false when sync-engine is under critical memory pressure.

peers_total: usize

Total number of configured peers.

peers_connected: usize

Number of peers currently connected.

peers_circuit_open: usize

Number of peers with open circuit breakers (temporarily excluded).

peers_catching_up: usize

Number of peers we’re currently catching up with (lagging behind).

peers: Vec<PeerHealth>

Per-peer health details.

healthy: bool

Overall health verdict for load balancer decisions. Source: Derived from:

• state == Running
• peers_connected > 0
• sync_engine_accepting_writes == true

Implementations

impl HealthCheck

pub fn has_healthy_peer(&self) -> bool

Check if at least one peer is healthy and connected.

pub fn max_lag_ms(&self) -> Option<u64>

Get the maximum lag across all peers (in milliseconds). Returns None if no peers have reported lag.

pub fn unhealthy_peers(&self) -> Vec<&str>

Get peer IDs that have open circuit breakers.

Trait Implementations

impl Clone for HealthCheck

fn clone(&self) -> HealthCheck

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for HealthCheck

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.