1use async_trait::async_trait;
4use esh_core::{AuditEvent, Auditor};
5use parking_lot::Mutex;
6use std::sync::Arc;
7use tracing::{info, warn};
8
9#[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#[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#[derive(Clone, Default)]
38pub struct MemoryAuditor {
39 events: Arc<Mutex<Vec<AuditEvent>>>,
40}
41
42impl MemoryAuditor {
43 #[must_use]
45 pub fn new() -> Self {
46 Self::default()
47 }
48
49 #[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}