Struct HealthCheck 

pub struct HealthCheck {

    pub state: EngineState,
    pub ready: bool,
    pub memory_pressure: f64,
    pub backpressure_level: BackpressureLevel,
    pub accepting_writes: bool,
    pub l1_items: usize,
    pub l1_bytes: usize,
    pub filter_items: usize,
    pub filter_trust: FilterTrust,
    pub redis_connected: Option<bool>,
    pub redis_latency_ms: Option<u64>,
    pub sql_connected: Option<bool>,
    pub sql_latency_ms: Option<u64>,
    pub wal_pending_items: Option<u64>,
    pub healthy: bool,
}

Comprehensive health status of the sync engine.

This struct provides all the information needed for:

• /ready endpoint: Just check healthy field
• /health endpoint: Full diagnostics with data sources documented
• Metrics dashboards: Memory pressure, cache stats, backend latencies

Data Sources

Each field documents where its value comes from:

• Live probe: Fresh check performed during health_check() call
• Cached: From internal state, no I/O required
• Derived: Computed from other fields

Example

let health = engine.health_check().await;
if health.healthy {
    // Ready for traffic
} else {
    // Log diagnostics
    eprintln!("Engine unhealthy: state={:?}, redis={}, sql={}",
        health.state, health.redis_connected, health.sql_connected);
}

Fields

state: EngineState

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

ready: bool

Whether the engine is in Running state and ready for traffic. Source: Derived from state == Running.

memory_pressure: f64

Current memory pressure ratio (0.0 to 1.0). Source: Cached from l1_size_bytes / config.l1_max_bytes.

backpressure_level: BackpressureLevel

Current backpressure level based on thresholds. Source: Derived from memory_pressure vs config thresholds.

accepting_writes: bool

Whether the engine is accepting write operations. Source: Derived from backpressure_level != Critical.

l1_items: usize

Number of items in L1 cache. Source: Cached from l1_cache.len().

l1_bytes: usize

Total bytes in L1 cache. Source: Cached from l1_size_bytes atomic.

filter_items: usize

Number of items tracked in L3 cuckoo filter. Source: Cached from l3_filter.len().

filter_trust: FilterTrust

Cuckoo filter trust status. Source: Cached from l3_filter.trust().

redis_connected: Option<bool>

Whether Redis (L2) responded to PING. Source: Live probe - redis::cmd("PING"). None if Redis is not configured.

redis_latency_ms: Option<u64>

Redis PING latency in milliseconds. Source: Live probe - timed PING command. None if Redis is not configured or PING failed.

sql_connected: Option<bool>

Whether SQL (L3) responded to SELECT 1. Source: Live probe - sqlx::query("SELECT 1"). None if SQL is not configured.

sql_latency_ms: Option<u64>

SQL SELECT 1 latency in milliseconds. Source: Live probe - timed query. None if SQL is not configured or query failed.

wal_pending_items: Option<u64>

Number of items pending in WAL (awaiting drain to SQL). Source: Cached from l3_wal.stats().pending_items. None if WAL is not configured.

healthy: bool

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

• state == Running
• redis_connected != Some(false) (connected or not configured)
• sql_connected != Some(false) (connected or not configured)
• backpressure_level != Critical

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.