Function alert_eval_loop

nodedb/src/event/alert/executor.rs:43–90

(
    state: Arc<SharedState>,
    registry: Arc<AlertRegistry>,
    mut shutdown: watch::Receiver<bool>,
)

}

async fn alert_eval_loop(
    state: Arc<SharedState>,
    registry: Arc<AlertRegistry>,
    mut shutdown: watch::Receiver<bool>,
) {
    // Initial delay to let the system warm up.
    tokio::time::sleep(Duration::from_secs(5)).await;

    // Use the shared hysteresis manager from SharedState so DROP/ALTER handlers
    // and the eval loop operate on the same state.
    let hysteresis = &state.alert_hysteresis;

    loop {
        // Sleep for the shortest alert window (minimum 1 second).
        let sleep_ms = next_eval_interval_ms(&registry);

        tokio::select! {
            _ = tokio::time::sleep(Duration::from_millis(sleep_ms)) => {}
            _ = shutdown.changed() => {
                if *shutdown.borrow() {
                    info!("alert eval loop shutting down");
                    return;
                }
            }
        }

        let alerts = registry.list_all_enabled();
        if alerts.is_empty() {
            continue;
        }

        let now_ms = std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap_or_default()
            .as_millis() as u64;

        for alert in &alerts {
            if let Err(e) = evaluate_alert(&state, alert, hysteresis, now_ms).await {
                warn!(
                    alert = alert.name,
                    collection = alert.collection,
                    error = %e,
                    "alert evaluation failed"
                );
            }
        }
    }
}

/// Evaluate a single alert rule: execute aggregate query, check condition per group,
/// feed through hysteresis, dispatch notifications.