Skip to main content

esh_audit/
lib.rs

1//! Audit sinks (FR-010). Events never include secret values.
2
3use async_trait::async_trait;
4use esh_core::{AuditEvent, Auditor};
5use parking_lot::Mutex;
6use std::sync::Arc;
7use tracing::{info, warn};
8
9/// Logs audit events as JSON via `tracing`.
10#[derive(Debug, Default, Clone, Copy)]
11pub struct TracingAuditor;
12
13#[async_trait]
14impl Auditor for TracingAuditor {
15    async fn record(&self, event: AuditEvent) {
16        match serde_json::to_string(&event) {
17            Ok(json) => info!(target: "esh_audit", %json, "audit"),
18            Err(e) => warn!(error = %e, "failed to serialize audit event"),
19        }
20    }
21}
22
23/// Writes each event as a JSON line to stdout.
24#[derive(Debug, Default, Clone, Copy)]
25pub struct StdoutAuditor;
26
27#[async_trait]
28impl Auditor for StdoutAuditor {
29    async fn record(&self, event: AuditEvent) {
30        if let Ok(json) = serde_json::to_string(&event) {
31            println!("{json}");
32        }
33    }
34}
35
36/// Collects events in memory (tests).
37#[derive(Clone, Default)]
38pub struct MemoryAuditor {
39    events: Arc<Mutex<Vec<AuditEvent>>>,
40}
41
42impl MemoryAuditor {
43    /// Create empty auditor.
44    #[must_use]
45    pub fn new() -> Self {
46        Self::default()
47    }
48
49    /// Snapshot recorded events.
50    #[must_use]
51    pub fn events(&self) -> Vec<AuditEvent> {
52        self.events.lock().clone()
53    }
54}
55
56#[async_trait]
57impl Auditor for MemoryAuditor {
58    async fn record(&self, event: AuditEvent) {
59        self.events.lock().push(event);
60    }
61}
62
63#[cfg(test)]
64mod tests {
65    use super::*;
66    use esh_core::EventKind;
67    use esh_test_support::{assert_no_leak_in, SAMPLE_SECRET};
68
69    #[tokio::test]
70    async fn memory_auditor_records_without_values() {
71        let a = MemoryAuditor::new();
72        a.record(AuditEvent::new(EventKind::SecretLoaded, "db_url").with_provider("env"))
73            .await;
74        let ev = &a.events()[0];
75        let json = serde_json::to_string(ev).unwrap();
76        assert!(json.contains("db_url"));
77        assert!(json.contains("secret_loaded"));
78        assert!(!json.contains("postgres://"));
79    }
80
81    #[tokio::test]
82    async fn all_event_kinds_serialize_without_secret_values() {
83        let a = MemoryAuditor::new();
84        for kind in [
85            EventKind::SecretLoaded,
86            EventKind::SecretRefreshed,
87            EventKind::SecretExpired,
88            EventKind::SecretAccessFailure,
89        ] {
90            a.record(
91                AuditEvent::new(kind, "database_url")
92                    .with_provider("aws")
93                    .with_message("safe"),
94            )
95            .await;
96        }
97        let blob = serde_json::to_string(&a.events()).unwrap();
98        assert_no_leak_in(&blob, SAMPLE_SECRET);
99        assert!(blob.contains("secret_loaded"));
100        assert!(blob.contains("secret_refreshed"));
101        assert!(blob.contains("secret_expired"));
102        assert!(blob.contains("secret_access_failure"));
103    }
104
105    #[tokio::test]
106    async fn tracing_and_stdout_accept_events() {
107        TracingAuditor
108            .record(AuditEvent::new(EventKind::SecretLoaded, "k"))
109            .await;
110        StdoutAuditor
111            .record(AuditEvent::new(EventKind::SecretRefreshed, "k"))
112            .await;
113    }
114}