spawn-access-control 0.1.12

A Rust library for access control management with WebAssembly support, including role-based access control (RBAC), permissions, and audit logging.
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

use reqwest::Client;
use serde_json::json;
use crate::alert_system::{
    NotificationHandler, 
    NotificationError, 
    AlertNotification,
    AlertSeverity,
    EscalationLevel
};
use async_trait::async_trait;

#[derive(Clone)]
pub struct SlackNotificationHandler {
    client: reqwest::Client,
    config: SlackConfig,
}

#[derive(Clone)]
pub struct SlackConfig {
    pub webhook_url: String,
    pub default_channel: String,
    pub emergency_channel: String,
    pub username: String,
    pub icon_emoji: String,
}

impl SlackNotificationHandler {
    pub fn new(config: SlackConfig) -> Self {
        Self {
            client: Client::new(),
            config,
        }
    }

    fn create_slack_message(&self, notification: &AlertNotification) -> serde_json::Value {
        let severity = AlertSeverity::from(&notification.alert.severity);
        let color = match severity {
            AlertSeverity::Critical => "#ff0000",
            AlertSeverity::Warning => "#ffa500",
            AlertSeverity::Info => "#0000ff",
        };

        json!({
            "username": self.config.username,
            "icon_emoji": self.config.icon_emoji,
            "channel": if notification.escalation_level == EscalationLevel::Critical {
                self.config.emergency_channel.clone()
            } else {
                self.config.default_channel.clone()
            },
            "attachments": [{
                "color": color,
                "title": format!("Alert: {}", notification.alert.message),
                "fields": [
                    {
                        "title": "Severity",
                        "value": format!("{:?}", notification.alert.severity),
                        "short": true
                    },
                    {
                        "title": "Metric",
                        "value": notification.alert.metric_name,
                        "short": true
                    },
                    {
                        "title": "Current Value",
                        "value": notification.alert.current_value.to_string(),
                        "short": true
                    },
                    {
                        "title": "Threshold",
                        "value": notification.alert.threshold.to_string(),
                        "short": true
                    },
                    {
                        "title": "Incident ID",
                        "value": notification.context.incident_id,
                        "short": true
                    }
                ],
                "footer": format!("Alert generated at {}", notification.context.created_at.to_rfc3339())
            }]
        })
    }
}

#[async_trait]
impl NotificationHandler for SlackNotificationHandler {
    async fn send_notification(&self, notification: &AlertNotification) -> Result<(), NotificationError> {
        let payload = self.create_slack_message(notification);

        let response = self.client
            .post(&self.config.webhook_url)
            .json(&payload)
            .send()
            .await
            .map_err(|e| NotificationError::SendError(e.to_string()))?;

        if !response.status().is_success() {
            return Err(NotificationError::SendError(
                format!("Slack API error: {}", response.status())
            ));
        }

        Ok(())
    }
}