Respect latency thresholds in node switching

Add configurable latency thresholds to monitoring and use them to avoid insignificant latency-based node switches. Changes include:

- config.yml: add latency_threshold and latency_threshold_percent.
- config/mod.rs: add optional latency fields and is_latency_improvement_significant() helper.
- monitoring/sync.rs: refactor selection logic (find_best_candidate, evaluate_switch), make select_best_node accept monitoring config and chain, and honor latency thresholds and in_sync rules when deciding switches; add many tests covering threshold behavior.
- monitoring/request_health.rs: expose test helpers via testkit::sync::url import.
- monitoring/mod.rs: make request_health module crate-visible.
- monitoring/service.rs & monitoring/worker.rs: expose/adopt RequestAdaptiveMonitor (add adaptive_monitor accessor in NodeService, wire adaptive_monitor through NodeMonitor, mark adaptive monitor on successful switches via try_switch).
- monitoring/telemetry.rs: normalize in_sync field serialization to "false" string and minor formatting.
- monitoring/switch_reason.rs: derive PartialEq for test assertions.
- testkit: add sync helpers (url, healthy_observation, not_in_sync_observation) and include them in mod; update test monitoring config defaults.

Overall goal: reduce noisy or insignificant latency-driven switches and integrate adaptive monitoring updates when switches occur. Tests added/updated to validate behavior.

Author: gemcoder21

apps/dynode/config.yml

@@ -13,6 +13,8 @@ monitoring:
   poll_interval: 10m
   max_sync_delay: 24s
   max_sync_blocks: 20
+  latency_threshold: 250ms
+  latency_threshold_percent: 20
   adaptive:
     enabled: true
     window: 30s

apps/dynode/src/config/mod.rs

@@ -28,6 +28,10 @@ pub struct NodeMonitoringConfig {
     #[serde(deserialize_with = "duration::deserialize")]
     pub max_sync_delay: Duration,
     pub max_sync_blocks: u64,
+    #[serde(default, deserialize_with = "duration::deserialize_option")]
+    pub latency_threshold: Option<Duration>,
+    #[serde(default)]
+    pub latency_threshold_percent: Option<f64>,
     pub adaptive: AdaptiveMonitoringConfig,
 }
 
@@ -44,6 +48,24 @@ impl NodeMonitoringConfig {
         let computed = self.max_sync_delay.as_millis() as u64 / block_time_ms;
         computed.clamp(1, self.max_sync_blocks)
     }
+
+    pub fn is_latency_improvement_significant(&self, old: Duration, new: Duration) -> bool {
+        if new >= old {
+            return false;
+        }
+        let diff = old - new;
+        if let Some(threshold) = self.latency_threshold
+            && diff < threshold
+        {
+            return false;
+        }
+        if let Some(percent) = self.latency_threshold_percent
+            && (diff.as_millis() as f64 / old.as_millis() as f64) * 100.0 < percent
+        {
+            return false;
+        }
+        true
+    }
 }
 
 #[derive(Debug, Deserialize, Clone)]

apps/dynode/src/main.rs

@@ -154,6 +154,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
             Arc::clone(&node_service.nodes),
             Arc::clone(&node_service.metrics),
             node_service.monitoring_config.clone(),
+            node_service.adaptive_monitor(),
         );
 
         rocket::tokio::spawn(async move {

apps/dynode/src/monitoring/mod.rs

@@ -1,5 +1,5 @@
 mod chain_client;
-mod request_health;
+pub(crate) mod request_health;
 mod service;
 mod switch_reason;
 mod sync;

apps/dynode/src/monitoring/request_health.rs

@@ -263,6 +263,7 @@ impl RequestWindow {
 mod tests {
     use super::*;
     use crate::testkit::config as testkit;
+    use crate::testkit::sync::url;
     use std::time::Duration;
 
     fn config() -> AdaptiveMonitoringConfig {
@@ -274,13 +275,6 @@ mod tests {
         }
     }
 
-    fn url(value: &str) -> Url {
-        Url {
-            url: value.to_string(),
-            headers: None,
-        }
-    }
-
     #[tokio::test]
     async fn opens_host_when_error_threshold_is_reached() {
         let monitor = RequestAdaptiveMonitor::new(config());

apps/dynode/src/monitoring/service.rs

@@ -63,6 +63,10 @@ impl NodeService {
         }
     }
 
+    pub fn adaptive_monitor(&self) -> Arc<RequestAdaptiveMonitor> {
+        Arc::clone(&self.request_adaptive_monitor)
+    }
+
     pub async fn get_node_domain(nodes: &Arc<RwLock<HashMap<Chain, NodeDomain>>>, chain: Chain) -> Option<NodeDomain> {
         nodes.read().await.get(&chain).cloned()
     }

apps/dynode/src/monitoring/switch_reason.rs

@@ -1,6 +1,6 @@
 use std::fmt;
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq)]
 pub enum NodeSwitchReason {
     BlockHeight { old_block: u64, new_block: u64 },
     Latency { old_latency_ms: u64, new_latency_ms: u64 },
@@ -17,7 +17,6 @@ impl NodeSwitchReason {
             Self::AdaptiveError { .. } => "adaptive_error",
         }
     }
-
 }
 
 impl fmt::Display for NodeSwitchReason {