oxirs-cluster 0.2.4

Raft-backed distributed dataset for high availability and horizontal scaling
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

//! # RegionManager - monitor_latencies_group Methods
//!
//! This module contains method implementations for `RegionManager`.
//!
//! 🤖 Generated with [SplitRS](https://github.com/cool-japan/splitrs)

use anyhow::Result;
use std::time::SystemTime;

use super::types::LatencyStats;

use super::regionmanager_type::RegionManager;

impl RegionManager {
    /// Monitor and update inter-region latencies
    pub async fn monitor_latencies(&self) -> Result<()> {
        let topology = self.topology.read().await;
        let mut metrics = self.performance_metrics.write().await;
        for (region_a, region_b) in topology.latency_matrix.keys() {
            if region_a != region_b {
                let latency = self
                    .measure_inter_region_latency(region_a, region_b)
                    .await?;
                let stats = metrics
                    .inter_region_latencies
                    .entry((region_a.clone(), region_b.clone()))
                    .or_default();
                self.update_latency_stats(stats, latency);
            }
        }
        metrics.last_updated = SystemTime::now();
        Ok(())
    }
    /// Update latency statistics
    fn update_latency_stats(&self, stats: &mut LatencyStats, new_latency: f64) {
        if stats.sample_count == 0 {
            stats.min_ms = new_latency;
            stats.max_ms = new_latency;
            stats.avg_ms = new_latency;
            stats.p95_ms = new_latency;
            stats.p99_ms = new_latency;
        } else {
            stats.min_ms = stats.min_ms.min(new_latency);
            stats.max_ms = stats.max_ms.max(new_latency);
            stats.avg_ms = (stats.avg_ms * stats.sample_count as f64 + new_latency)
                / (stats.sample_count as f64 + 1.0);
            if new_latency > stats.p95_ms {
                stats.p95_ms = (stats.p95_ms * 19.0 + new_latency) / 20.0;
            }
            if new_latency > stats.p99_ms {
                stats.p99_ms = (stats.p99_ms * 99.0 + new_latency) / 100.0;
            }
        }
        stats.sample_count += 1;
    }
}