zentinel-agent-protocol 0.6.12

Agent protocol and IPC for Zentinel reverse proxy external processors
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
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

//! Health reporting for Protocol v2.

use serde::{Deserialize, Serialize};

/// Health status reported by agent.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct HealthStatus {
    pub agent_id: String,
    pub state: HealthState,
    pub message: Option<String>,
    pub load: Option<LoadMetrics>,
    pub resources: Option<ResourceMetrics>,
    pub valid_until_ms: Option<u64>,
    pub timestamp_ms: u64,
}

impl HealthStatus {
    pub fn healthy(agent_id: impl Into<String>) -> Self {
        Self {
            agent_id: agent_id.into(),
            state: HealthState::Healthy,
            message: None,
            load: None,
            resources: None,
            valid_until_ms: None,
            timestamp_ms: now_ms(),
        }
    }

    pub fn degraded(agent_id: impl Into<String>, disabled: Vec<String>, multiplier: f32) -> Self {
        Self {
            agent_id: agent_id.into(),
            state: HealthState::Degraded {
                disabled_features: disabled,
                timeout_multiplier: multiplier,
            },
            message: None,
            load: None,
            resources: None,
            valid_until_ms: None,
            timestamp_ms: now_ms(),
        }
    }

    pub fn unhealthy(
        agent_id: impl Into<String>,
        reason: impl Into<String>,
        recoverable: bool,
    ) -> Self {
        Self {
            agent_id: agent_id.into(),
            state: HealthState::Unhealthy {
                reason: reason.into(),
                recoverable,
            },
            message: None,
            load: None,
            resources: None,
            valid_until_ms: None,
            timestamp_ms: now_ms(),
        }
    }

    pub fn is_healthy(&self) -> bool {
        matches!(self.state, HealthState::Healthy)
    }
}

/// Health state.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(rename_all = "snake_case", tag = "status")]
pub enum HealthState {
    Healthy,
    Degraded {
        disabled_features: Vec<String>,
        timeout_multiplier: f32,
    },
    Draining {
        eta_ms: Option<u64>,
    },
    Unhealthy {
        reason: String,
        recoverable: bool,
    },
}

/// Load metrics.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct LoadMetrics {
    pub in_flight: u32,
    pub queue_depth: u32,
    pub avg_latency_ms: f32,
    pub p50_latency_ms: f32,
    pub p95_latency_ms: f32,
    pub p99_latency_ms: f32,
    pub requests_processed: u64,
    pub requests_rejected: u64,
    pub requests_timed_out: u64,
}

/// Resource metrics.
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct ResourceMetrics {
    pub cpu_percent: Option<f32>,
    pub memory_bytes: Option<u64>,
    pub memory_limit: Option<u64>,
    pub active_threads: Option<u32>,
    pub open_fds: Option<u32>,
    pub fd_limit: Option<u32>,
    pub connections: Option<u32>,
}

fn now_ms() -> u64 {
    std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .map(|d| d.as_millis() as u64)
        .unwrap_or(0)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_health_status_builders() {
        let healthy = HealthStatus::healthy("test-agent");
        assert!(healthy.is_healthy());

        let unhealthy = HealthStatus::unhealthy("test-agent", "OOM", true);
        assert!(!unhealthy.is_healthy());
    }
}