Rolling window errors and stale error message clearing

Health endpoint now shows errors from the last hour (rolling window)
instead of since startup. Error message clears from the dashboard
after 10 minutes of healthy operation. Admin endpoint exposes both
errors_last_hour and total_errors for full visibility.

Author: kenbak wan

src/api/admin.rs

@@ -848,6 +848,7 @@ pub async fn scanner_metrics(req: actix_web::HttpRequest) -> actix_web::HttpResp
     let m = crate::scanner::metrics::global();
     let snap = m.snapshot();
     let uptime = m.uptime_secs().await;
+    let recent_errors = m.recent_errors().await;
     let last_error = m.last_error().await;
 
     let mut body = serde_json::json!({
@@ -859,7 +860,8 @@ pub async fn scanner_metrics(req: actix_web::HttpRequest) -> actix_web::HttpResp
         "blocks_behind": snap.blocks_behind(),
         "payments_detected": snap.payments_detected,
         "mempool_txs_checked": snap.mempool_txs_checked,
-        "scan_errors": snap.scan_errors,
+        "errors_last_hour": recent_errors,
+        "total_errors": snap.total_errors,
         "last_block_scan_ms": snap.last_block_scan_ms,
         "last_mempool_scan_ms": snap.last_mempool_scan_ms,
     });

src/api/system.rs

@@ -44,19 +44,19 @@ pub async fn health(
     let m = crate::scanner::metrics::global();
     let snap = m.snapshot();
     let scanner_status = snap.status();
-    let scan_errors = snap.scan_errors;
+    let recent_errors = m.recent_errors().await;
     let blocks_behind = snap.blocks_behind();
     let last_error = m.last_error().await;
 
-    if scanner_status == "behind" || (scan_errors > 0 && snap.last_block_height == 0) {
+    if scanner_status == "behind" || (recent_errors > 0 && snap.last_block_height == 0) {
         unhealthy = true;
     } else if scanner_status == "catching_up" || blocks_behind > 5 {
         degraded = true;
     }
     let mut scanner_json = serde_json::json!({
         "status": scanner_status,
         "blocks_behind": blocks_behind,
-        "scan_errors": scan_errors,
+        "scan_errors": recent_errors,
         "last_block_height": snap.last_block_height,
     });
     if let Some((msg, ago_secs)) = last_error {
@@ -116,6 +116,11 @@ pub async fn well_known_payment(config: web::Data<crate::config::Config>) -> Htt
     } else {
         "zcash:mainnet"
     };
+    let base_url = if config.is_testnet() {
+        "https://testnet.api.cipherpay.app"
+    } else {
+        "https://api.cipherpay.app"
+    };
     HttpResponse::Ok()
         .insert_header(("Access-Control-Allow-Origin", "*"))
         .insert_header(("Cache-Control", "public, max-age=3600"))
@@ -125,13 +130,25 @@ pub async fn well_known_payment(config: web::Data<crate::config::Config>) -> Htt
             "methods": ["zcash"],
             "currencies": ["ZEC"],
             "network": network,
+            "asset": "ZEC",
+            "scheme": "exact",
             "protocols": ["x402", "mpp"],
             "capabilities": {
                 "sessions": true,
                 "streaming": true,
                 "replay_protection": true,
+                "idempotency": true,
+                "auto_session": true,
+            },
+            "facilitator": base_url,
+            "facilitatorUrl": format!("{}/api/x402", base_url),
+            "endpoints": {
+                "verify": format!("{}/api/x402/v2/verify", base_url),
+                "settle": format!("{}/api/x402/v2/settle", base_url),
+                "supported": format!("{}/api/x402/supported", base_url),
+                "session_prepare": format!("{}/api/sessions/prepare", base_url),
+                "session_validate": format!("{}/api/sessions/validate", base_url),
             },
-            "facilitator": "https://api.cipherpay.app",
             "documentation": "https://cipherpay.app/docs",
         }))
 }

src/scanner/metrics.rs

@@ -5,17 +5,21 @@ use tokio::sync::RwLock;
 
 static INSTANCE: OnceLock<ScannerMetrics> = OnceLock::new();
 
+const ERROR_WINDOW_SECS: u64 = 3600;
+const STALE_ERROR_MSG_SECS: u64 = 600;
+
 pub struct ScannerMetrics {
     pub blocks_scanned: AtomicU64,
     pub last_block_height: AtomicU64,
     pub chain_tip_height: AtomicU64,
     pub payments_detected: AtomicU64,
     pub mempool_txs_checked: AtomicU64,
-    pub scan_errors: AtomicU64,
+    total_errors: AtomicU64,
     pub last_block_scan_ms: AtomicU64,
     pub last_mempool_scan_ms: AtomicU64,
     started_at: RwLock<Option<Instant>>,
     last_error: RwLock<Option<(String, Instant)>>,
+    error_timestamps: RwLock<Vec<Instant>>,
 }
 
 impl ScannerMetrics {
@@ -26,11 +30,12 @@ impl ScannerMetrics {
             chain_tip_height: AtomicU64::new(0),
             payments_detected: AtomicU64::new(0),
             mempool_txs_checked: AtomicU64::new(0),
-            scan_errors: AtomicU64::new(0),
+            total_errors: AtomicU64::new(0),
             last_block_scan_ms: AtomicU64::new(0),
             last_mempool_scan_ms: AtomicU64::new(0),
             started_at: RwLock::new(None),
             last_error: RwLock::new(None),
+            error_timestamps: RwLock::new(Vec::new()),
         }
     }
 
@@ -67,30 +72,42 @@ impl ScannerMetrics {
     }
 
     pub fn record_scan_error(&self, msg: &str) {
-        self.scan_errors.fetch_add(1, Ordering::Relaxed);
+        self.total_errors.fetch_add(1, Ordering::Relaxed);
         if let Ok(mut guard) = self.last_error.try_write() {
             *guard = Some((msg.to_string(), Instant::now()));
         }
+        if let Ok(mut ts) = self.error_timestamps.try_write() {
+            ts.push(Instant::now());
+        }
     }
 
-    /// Clear error state after sustained healthy operation (10 min without errors).
-    pub async fn clear_stale_errors(&self) {
-        const STALE_THRESHOLD_SECS: u64 = 600;
-        let should_clear = self
-            .last_error
-            .read()
-            .await
-            .as_ref()
-            .map_or(false, |(_, when)| when.elapsed().as_secs() > STALE_THRESHOLD_SECS);
-        if should_clear {
-            self.scan_errors.store(0, Ordering::Relaxed);
-            *self.last_error.write().await = None;
-        }
+    /// Errors in the last hour (rolling window).
+    pub async fn recent_errors(&self) -> u64 {
+        let cutoff = Instant::now() - std::time::Duration::from_secs(ERROR_WINDOW_SECS);
+        let ts = self.error_timestamps.read().await;
+        ts.iter().filter(|t| **t > cutoff).count() as u64
+    }
+
+    pub fn total_errors(&self) -> u64 {
+        self.total_errors.load(Ordering::Relaxed)
+    }
+
+    /// Evict old timestamps from the rolling window to avoid unbounded growth.
+    pub async fn evict_old_errors(&self) {
+        let cutoff = Instant::now() - std::time::Duration::from_secs(ERROR_WINDOW_SECS);
+        let mut ts = self.error_timestamps.write().await;
+        ts.retain(|t| *t > cutoff);
     }
 
+    /// Returns last error message and age — only if the error is recent (< 10 min).
     pub async fn last_error(&self) -> Option<(String, u64)> {
-        self.last_error.read().await.as_ref().map(|(msg, when)| {
-            (msg.clone(), when.elapsed().as_secs())
+        self.last_error.read().await.as_ref().and_then(|(msg, when)| {
+            let ago = when.elapsed().as_secs();
+            if ago < STALE_ERROR_MSG_SECS {
+                Some((msg.clone(), ago))
+            } else {
+                None
+            }
         })
     }
 
@@ -109,7 +126,7 @@ impl ScannerMetrics {
             chain_tip_height: self.chain_tip_height.load(Ordering::Relaxed),
             payments_detected: self.payments_detected.load(Ordering::Relaxed),
             mempool_txs_checked: self.mempool_txs_checked.load(Ordering::Relaxed),
-            scan_errors: self.scan_errors.load(Ordering::Relaxed),
+            total_errors: self.total_errors.load(Ordering::Relaxed),
             last_block_scan_ms: self.last_block_scan_ms.load(Ordering::Relaxed),
             last_mempool_scan_ms: self.last_mempool_scan_ms.load(Ordering::Relaxed),
         }
@@ -123,7 +140,7 @@ pub struct MetricsSnapshot {
     pub chain_tip_height: u64,
     pub payments_detected: u64,
     pub mempool_txs_checked: u64,
-    pub scan_errors: u64,
+    pub total_errors: u64,
     pub last_block_scan_ms: u64,
     pub last_mempool_scan_ms: u64,
 }

src/scanner/mod.rs

@@ -188,7 +188,6 @@ pub async fn run(config: Config, pool: SqlitePool, scanner_http: reqwest::Client
                 Ok(_) => {
                     block_cb.record_success();
                     metrics::global().set_last_block_scan_ms(block_start.elapsed().as_millis() as u64);
-                    metrics::global().clear_stale_errors().await;
                 }
                 Err(e) => {
                     block_cb.record_failure();
@@ -213,6 +212,7 @@ pub async fn run(config: Config, pool: SqlitePool, scanner_http: reqwest::Client
             if evicted > 0 {
                 tracing::debug!(evicted, remaining = set.len(), "Evicted stale seen_txids");
             }
+            metrics::global().evict_old_errors().await;
         }
     });