use super::{AuditBackend, AuditEvent, ErrorSink, IgnoreErrors, WriteError};
use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::mpsc::{Receiver, SyncSender, TrySendError};
use std::sync::{Arc, Mutex};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum OverflowPolicy {
#[default]
Block,
DropAndReport,
}
enum Message {
Audit(Box<AuditEvent>),
Security(Box<serde_json::Value>),
Flush(SyncSender<()>),
}
pub struct AsyncBackend {
sender: Mutex<Option<SyncSender<Message>>>,
worker: Mutex<Option<std::thread::JoinHandle<()>>>,
policy: OverflowPolicy,
dropped: Arc<AtomicU64>,
errors: Arc<dyn ErrorSink>,
}
impl AsyncBackend {
#[must_use]
pub fn builder(inner: Arc<dyn AuditBackend>) -> AsyncBackendBuilder {
AsyncBackendBuilder {
inner,
capacity: 1024,
policy: OverflowPolicy::Block,
errors: Arc::new(IgnoreErrors),
}
}
#[must_use]
pub fn new(inner: Arc<dyn AuditBackend>) -> Self {
Self::builder(inner).build()
}
#[must_use]
pub fn dropped(&self) -> u64 {
self.dropped.load(Ordering::Relaxed)
}
fn send(&self, message: Message) {
let guard = self
.sender
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
let Some(sender) = guard.as_ref() else {
return; };
match self.policy {
OverflowPolicy::Block => {
let _ = sender.send(message);
}
#[allow(clippy::match_same_arms)]
OverflowPolicy::DropAndReport => match sender.try_send(message) {
Ok(()) => {}
Err(TrySendError::Full(_)) => {
self.dropped.fetch_add(1, Ordering::Relaxed);
self.errors.on_error(&WriteError {
backend: "AsyncBackend",
source: std::io::Error::new(
std::io::ErrorKind::WouldBlock,
"audit queue full",
),
events_lost: 1,
});
}
Err(TrySendError::Disconnected(_)) => {}
},
}
}
fn drain(&self) {
let (ack, done) = std::sync::mpsc::sync_channel(1);
{
let guard = self
.sender
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
let Some(sender) = guard.as_ref() else {
return; };
if sender.send(Message::Flush(ack)).is_err() {
return; }
}
let _ = done.recv();
}
fn shutdown(&self) {
self.drain();
{
let mut guard = self
.sender
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
*guard = None;
}
let handle = self
.worker
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.take();
if let Some(handle) = handle {
drop(handle.join());
}
}
}
impl AuditBackend for AsyncBackend {
fn log_audit(&self, event: &AuditEvent) {
self.send(Message::Audit(Box::new(event.clone())));
}
fn security_log(&self, event: &serde_json::Value) {
self.send(Message::Security(Box::new(event.clone())));
}
fn flush(&self) {
self.drain();
}
}
impl Drop for AsyncBackend {
fn drop(&mut self) {
self.shutdown();
}
}
impl std::fmt::Debug for AsyncBackend {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("AsyncBackend")
.field("policy", &self.policy)
.field("dropped", &self.dropped())
.finish_non_exhaustive()
}
}
fn run_writer(inner: &Arc<dyn AuditBackend>, receiver: &Receiver<Message>) {
for message in receiver {
match message {
Message::Audit(event) => inner.log_audit(&event),
Message::Security(event) => inner.security_log(&event),
Message::Flush(ack) => {
inner.flush();
let _ = ack.send(());
}
}
}
inner.flush();
}
pub struct AsyncBackendBuilder {
inner: Arc<dyn AuditBackend>,
capacity: usize,
policy: OverflowPolicy,
errors: Arc<dyn ErrorSink>,
}
impl AsyncBackendBuilder {
#[must_use]
pub const fn capacity(mut self, capacity: usize) -> Self {
self.capacity = capacity;
self
}
#[must_use]
pub const fn overflow(mut self, policy: OverflowPolicy) -> Self {
self.policy = policy;
self
}
#[must_use]
pub fn errors(mut self, errors: Arc<dyn ErrorSink>) -> Self {
self.errors = errors;
self
}
#[must_use]
pub fn build(self) -> AsyncBackend {
let (sender, receiver) = std::sync::mpsc::sync_channel(self.capacity.max(1));
let inner = self.inner;
let worker = std::thread::Builder::new()
.name("ash-log-writer".to_string())
.spawn(move || run_writer(&inner, &receiver))
.expect("spawn the audit writer thread");
AsyncBackend {
sender: Mutex::new(Some(sender)),
worker: Mutex::new(Some(worker)),
policy: self.policy,
dropped: Arc::new(AtomicU64::new(0)),
errors: self.errors,
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::{AuditEventType, AuditResult, CountingErrorSink};
use std::sync::PoisonError;
use std::time::Duration;
#[derive(Default)]
struct Collector(Mutex<Vec<AuditEvent>>);
impl Collector {
fn count(&self) -> usize {
self.0.lock().unwrap_or_else(PoisonError::into_inner).len()
}
}
impl AuditBackend for Collector {
fn log_audit(&self, event: &AuditEvent) {
self.0
.lock()
.unwrap_or_else(PoisonError::into_inner)
.push(event.clone());
}
}
struct SlowBackend {
inner: Arc<Collector>,
delay: Duration,
}
impl AuditBackend for SlowBackend {
fn log_audit(&self, event: &AuditEvent) {
std::thread::sleep(self.delay);
self.inner.log_audit(event);
}
}
fn event() -> AuditEvent {
AuditEvent::builder()
.event_type(AuditEventType::MethodInvocation)
.result(AuditResult::Success)
.build()
}
#[test]
fn test_events_reach_the_inner_backend() {
let collector = Arc::new(Collector::default());
let backend = AsyncBackend::new(collector.clone());
for _ in 0..50 {
backend.log_audit(&event());
}
backend.flush();
assert_eq!(collector.count(), 50);
}
#[test]
fn test_flush_waits_for_the_queue_to_drain() {
let collector = Arc::new(Collector::default());
let slow = Arc::new(SlowBackend {
inner: collector.clone(),
delay: Duration::from_millis(2),
});
let backend = AsyncBackend::new(slow);
for _ in 0..10 {
backend.log_audit(&event());
}
backend.flush();
assert_eq!(
collector.count(),
10,
"flush returns only once every queued event is written"
);
}
#[test]
fn test_dropping_the_backend_drains_the_queue() {
let collector = Arc::new(Collector::default());
{
let backend = AsyncBackend::new(collector.clone());
for _ in 0..20 {
backend.log_audit(&event());
}
}
assert_eq!(
collector.count(),
20,
"shutdown flushes rather than discards"
);
}
#[test]
fn test_blocking_policy_loses_nothing_under_overload() {
let collector = Arc::new(Collector::default());
let slow = Arc::new(SlowBackend {
inner: collector.clone(),
delay: Duration::from_micros(200),
});
let backend = AsyncBackend::builder(slow)
.capacity(4)
.overflow(OverflowPolicy::Block)
.build();
for _ in 0..100 {
backend.log_audit(&event());
}
backend.flush();
assert_eq!(collector.count(), 100);
assert_eq!(backend.dropped(), 0, "Block never drops");
}
#[test]
fn test_drop_policy_reports_what_it_discards() {
let collector = Arc::new(Collector::default());
let slow = Arc::new(SlowBackend {
inner: collector.clone(),
delay: Duration::from_millis(5),
});
let sink = Arc::new(CountingErrorSink::new());
let backend = AsyncBackend::builder(slow)
.capacity(2)
.overflow(OverflowPolicy::DropAndReport)
.errors(sink.clone())
.build();
for _ in 0..200 {
backend.log_audit(&event());
}
backend.flush();
assert!(
backend.dropped() > 0,
"a tiny queue under a burst overflows"
);
assert_eq!(
sink.events_lost(),
backend.dropped(),
"every dropped event is reported, so the gap is knowable"
);
assert_eq!(
collector.count() as u64 + backend.dropped(),
200,
"written plus dropped accounts for everything submitted"
);
}
#[test]
fn test_producers_are_not_blocked_by_a_slow_writer() {
let collector = Arc::new(Collector::default());
let slow = Arc::new(SlowBackend {
inner: collector.clone(),
delay: Duration::from_millis(10),
});
let backend = AsyncBackend::builder(slow).capacity(64).build();
let start = std::time::Instant::now();
for _ in 0..20 {
backend.log_audit(&event());
}
let enqueue = start.elapsed();
assert!(
enqueue < Duration::from_millis(100),
"20 enqueues took {enqueue:?}, but 20 synchronous writes would take 200ms"
);
backend.flush();
assert_eq!(collector.count(), 20);
}
#[test]
fn test_concurrent_producers_all_arrive() {
let collector = Arc::new(Collector::default());
let backend = Arc::new(AsyncBackend::new(collector.clone()));
let mut handles = Vec::new();
for _ in 0..8 {
let backend = backend.clone();
handles.push(std::thread::spawn(move || {
for _ in 0..50 {
backend.log_audit(&event());
}
}));
}
for handle in handles {
handle.join().expect("worker panicked");
}
backend.flush();
assert_eq!(collector.count(), 400);
}
}