Skip to main content

auth_framework/analytics/
reports.rs

1//! RBAC Analytics Reports
2//!
3//! This module provides comprehensive reporting capabilities
4//! for RBAC analytics data.
5//!
6//! > **Status:** Report generation is available today using the analytics
7//! > events and snapshots currently persisted by the framework.
8
9use super::{AnalyticsError, ReportType, TimeRange};
10use crate::storage::AuthStorage;
11use serde::{Deserialize, Serialize};
12use std::sync::Arc;
13
14/// Report generator configuration
15#[derive(Debug, Clone, Serialize, Deserialize)]
16pub struct ReportConfig {
17    /// Output format
18    pub format: ReportFormat,
19
20    /// Include charts in reports
21    pub include_charts: bool,
22
23    /// Report template
24    pub template: Option<String>,
25}
26
27/// Report output formats
28#[derive(Debug, Clone, Serialize, Deserialize)]
29pub enum ReportFormat {
30    Json,
31    Html,
32    Pdf,
33    Csv,
34}
35
36impl Default for ReportConfig {
37    fn default() -> Self {
38        Self {
39            format: ReportFormat::Json,
40            include_charts: true,
41            template: None,
42        }
43    }
44}
45
46/// Report generator
47pub struct ReportGenerator {
48    _config: ReportConfig,
49    storage: Arc<dyn AuthStorage>,
50}
51
52impl ReportGenerator {
53    /// Create new report generator
54    pub fn new(config: ReportConfig, storage: Arc<dyn AuthStorage>) -> Self {
55        Self {
56            _config: config,
57            storage,
58        }
59    }
60
61    /// Generate report
62    pub async fn generate_report(
63        &self,
64        report_type: ReportType,
65        time_range: TimeRange,
66    ) -> Result<String, AnalyticsError> {
67        let keys = self
68            .storage
69            .list_kv_keys("analytics_event_")
70            .await
71            .unwrap_or_default();
72
73        let mut total_events: u64 = 0;
74        let mut success_count: u64 = 0;
75        let mut failure_count: u64 = 0;
76        let mut event_types: std::collections::HashMap<String, u64> =
77            std::collections::HashMap::new();
78        let mut total_duration_ms: f64 = 0.0;
79        let mut duration_count: u64 = 0;
80
81        for key in keys {
82            if let Ok(Some(data)) = self.storage.get_kv(&key).await
83                && let Ok(event) = serde_json::from_slice::<crate::analytics::AnalyticsEvent>(&data)
84            {
85                // Filter by time range
86                if event.timestamp < time_range.start || event.timestamp > time_range.end {
87                    continue;
88                }
89                total_events += 1;
90                match event.result {
91                    crate::analytics::EventResult::Success => success_count += 1,
92                    _ => failure_count += 1,
93                }
94                *event_types
95                    .entry(format!("{:?}", event.event_type))
96                    .or_insert(0) += 1;
97                if let Some(d) = event.duration_ms {
98                    total_duration_ms += d as f64;
99                    duration_count += 1;
100                }
101            }
102        }
103
104        let avg_duration_ms = if duration_count > 0 {
105            total_duration_ms / duration_count as f64
106        } else {
107            0.0
108        };
109        let success_rate = if total_events > 0 {
110            (success_count as f64 / total_events as f64) * 100.0
111        } else {
112            0.0
113        };
114
115        let report = serde_json::json!({
116            "report_type": format!("{:?}", report_type),
117            "time_range": {
118                "start": time_range.start.to_rfc3339(),
119                "end": time_range.end.to_rfc3339(),
120            },
121            "generated_at": chrono::Utc::now().to_rfc3339(),
122            "summary": {
123                "total_events": total_events,
124                "success_count": success_count,
125                "failure_count": failure_count,
126                "success_rate_percent": (success_rate * 100.0).round() / 100.0,
127                "avg_duration_ms": (avg_duration_ms * 100.0).round() / 100.0,
128            },
129            "event_type_breakdown": event_types,
130        });
131
132        serde_json::to_string_pretty(&report).map_err(AnalyticsError::SerializationError)
133    }
134}
135
136#[cfg(test)]
137mod tests {
138    use super::*;
139
140    #[test]
141    fn test_report_config_default() {
142        let config = ReportConfig::default();
143        assert!(config.include_charts);
144        assert!(config.template.is_none());
145        assert!(matches!(config.format, ReportFormat::Json));
146    }
147
148    #[test]
149    fn test_report_generator_creation() {
150        let config = ReportConfig::default();
151        let _gen = ReportGenerator::new(
152            config,
153            std::sync::Arc::new(crate::storage::MemoryStorage::new()),
154        );
155    }
156
157    #[tokio::test]
158    async fn test_generate_report_returns_content() {
159        let generator = ReportGenerator::new(
160            ReportConfig::default(),
161            std::sync::Arc::new(crate::storage::MemoryStorage::new()),
162        );
163        let range = TimeRange::last_days(7);
164        let report = generator
165            .generate_report(ReportType::Daily, range)
166            .await
167            .unwrap();
168        assert!(!report.is_empty());
169    }
170}