pmat 3.15.0

PMAT - Zero-config AI context generation and code quality toolkit (CLI, MCP, HTTP)
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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

#![allow(unused)]
#![cfg_attr(coverage_nightly, coverage(off))]
//! Sprint 31 Week 2 - Alert System with Configurable Thresholds
//!
//! Provides real-time alerting capabilities with configurable thresholds,
//! notification channels, and alert management features.
use anyhow::Result;
use serde::{Deserialize, Serialize};
use std::collections::{HashMap, VecDeque};
use std::sync::Arc;
use std::time::{Duration, SystemTime};
use tokio::sync::{mpsc, RwLock};

/// Alert definition with threshold and conditions
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AlertRule {
    pub id: String,
    pub name: String,
    pub description: String,
    pub metric: String,
    pub condition: AlertCondition,
    pub threshold: f64,
    pub duration: Duration,
    pub severity: AlertSeverity,
    pub enabled: bool,
    pub notification_channels: Vec<NotificationChannel>,
    pub cooldown_period: Duration,
    pub metadata: HashMap<String, String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
/// Alert condition.
pub enum AlertCondition {
    GreaterThan,
    LessThan,
    Equal,
    NotEqual,
    GreaterThanOrEqual,
    LessThanOrEqual,
    RateOfChange,
    Anomaly,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
/// Severity level classification for alert.
pub enum AlertSeverity {
    Info,
    Warning,
    Error,
    Critical,
}

impl AlertSeverity {
    #[must_use]
    #[provable_contracts_macros::contract("pmat-core.yaml", equation = "check_compliance")]
    /// Priority.
    pub fn priority(&self) -> u8 {
        match self {
            AlertSeverity::Info => 1,
            AlertSeverity::Warning => 2,
            AlertSeverity::Error => 3,
            AlertSeverity::Critical => 4,
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
/// Notification channel.
pub enum NotificationChannel {
    Dashboard,
    Email {
        recipients: Vec<String>,
    },
    Webhook {
        url: String,
        method: String,
    },
    Slack {
        webhook_url: String,
        channel: String,
    },
    PagerDuty {
        integration_key: String,
    },
    Log {
        level: String,
    },
}

/// Active alert instance
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Alert {
    pub id: String,
    pub rule_id: String,
    pub rule_name: String,
    pub severity: AlertSeverity,
    pub state: AlertState,
    pub triggered_at: SystemTime,
    pub resolved_at: Option<SystemTime>,
    pub metric_value: f64,
    pub threshold_value: f64,
    pub message: String,
    pub context: HashMap<String, String>,
    pub notification_sent: bool,
    pub acknowledgement: Option<Acknowledgement>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
/// State of alert lifecycle.
pub enum AlertState {
    Triggered,
    Active,
    Acknowledged,
    Resolved,
    Silenced,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
/// Acknowledgement.
pub struct Acknowledgement {
    pub acknowledged_by: String,
    pub acknowledged_at: SystemTime,
    pub comment: Option<String>,
}

/// Alert manager for the TDG system
pub struct AlertManager {
    rules: Arc<RwLock<HashMap<String, AlertRule>>>,
    active_alerts: Arc<RwLock<HashMap<String, Alert>>>,
    alert_history: Arc<RwLock<VecDeque<Alert>>>,
    metric_values: Arc<RwLock<HashMap<String, MetricValue>>>,
    notification_tx: mpsc::UnboundedSender<Alert>,

    notification_rx: Arc<RwLock<mpsc::UnboundedReceiver<Alert>>>,
    statistics: Arc<RwLock<AlertStatistics>>,
    config: AlertManagerConfig,
}

// Configuration, supporting types (AlertManagerConfig, MetricValue, AlertStatistics, etc.)
include!("alerts_types.rs");

// AlertManager implementation (rule evaluation, triggering, resolution)
include!("alerts_manager.rs");

// Default TDG alert rules
include!("alerts_defaults.rs");

#[cfg(test)]
#[path = "alerts_tests.rs"]
mod tests;