use std::sync::Arc;
use std::sync::atomic::{AtomicU64, Ordering};
#[derive(Debug)]
pub struct WriteError {
pub backend: &'static str,
pub source: std::io::Error,
pub events_lost: u64,
}
impl std::fmt::Display for WriteError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(
f,
"{}: audit write failed, {} event(s) lost: {}",
self.backend, self.events_lost, self.source
)
}
}
impl std::error::Error for WriteError {
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
Some(&self.source)
}
}
pub trait ErrorSink: Send + Sync {
fn on_error(&self, error: &WriteError);
}
#[derive(Debug, Clone, Copy, Default)]
pub struct IgnoreErrors;
impl ErrorSink for IgnoreErrors {
fn on_error(&self, _error: &WriteError) {}
}
#[derive(Debug, Clone, Copy, Default)]
pub struct StderrErrorSink;
impl ErrorSink for StderrErrorSink {
fn on_error(&self, error: &WriteError) {
eprintln!("ash-log: {error}");
}
}
#[derive(Debug, Default)]
pub struct CountingErrorSink {
failures: AtomicU64,
events_lost: AtomicU64,
}
impl CountingErrorSink {
#[must_use]
pub fn new() -> Self {
Self::default()
}
#[must_use]
pub fn failures(&self) -> u64 {
self.failures.load(Ordering::Relaxed)
}
#[must_use]
pub fn events_lost(&self) -> u64 {
self.events_lost.load(Ordering::Relaxed)
}
#[must_use]
pub fn had_failures(&self) -> bool {
self.failures() > 0
}
}
impl ErrorSink for CountingErrorSink {
fn on_error(&self, error: &WriteError) {
self.failures.fetch_add(1, Ordering::Relaxed);
self.events_lost
.fetch_add(error.events_lost, Ordering::Relaxed);
}
}
pub struct FnErrorSink<F: Fn(&WriteError) + Send + Sync>(F);
impl<F: Fn(&WriteError) + Send + Sync> FnErrorSink<F> {
pub const fn new(f: F) -> Self {
Self(f)
}
}
impl<F: Fn(&WriteError) + Send + Sync> ErrorSink for FnErrorSink<F> {
fn on_error(&self, error: &WriteError) {
(self.0)(error);
}
}
impl<T: ErrorSink + ?Sized> ErrorSink for Arc<T> {
fn on_error(&self, error: &WriteError) {
(**self).on_error(error);
}
}
#[cfg(test)]
mod tests {
use super::*;
fn error(events_lost: u64) -> WriteError {
WriteError {
backend: "TestBackend",
source: std::io::Error::other("disk full"),
events_lost,
}
}
#[test]
fn test_counting_sink_accumulates_losses() {
let sink = CountingErrorSink::new();
assert!(!sink.had_failures());
sink.on_error(&error(1));
sink.on_error(&error(64));
assert_eq!(sink.failures(), 2);
assert_eq!(sink.events_lost(), 65, "a batch loss counts every event");
assert!(sink.had_failures());
}
#[test]
fn test_error_displays_backend_and_loss() {
let rendered = error(3).to_string();
assert!(
rendered.contains("TestBackend"),
"names the failing backend"
);
assert!(rendered.contains('3'), "states how many events were lost");
assert!(rendered.contains("disk full"), "includes the cause");
}
#[test]
fn test_fn_sink_receives_errors() {
let count = Arc::new(AtomicU64::new(0));
let seen = count.clone();
let sink = FnErrorSink::new(move |_| {
seen.fetch_add(1, Ordering::Relaxed);
});
sink.on_error(&error(1));
assert_eq!(count.load(Ordering::Relaxed), 1);
}
}