phoxia-auditlog 0.1.0

Tower middleware for automatic audit logging in Axum apps. Append-only, batch-written, zero external services.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

use sqlx::PgPool;
use std::collections::HashSet;

/// Configuration for the audit middleware.
///
/// # Example
///
/// ```rust,no_run
/// # use phoxia_auditlog::AuditConfig;
/// # use sqlx::PgPool;
/// # fn example() -> Result<(), sqlx::Error> {
/// let pool = PgPool::connect_lazy("postgres://localhost")?;
/// let config = AuditConfig::new(pool, "phoxia-id")
///     .skip_path("/internal/health")
///     .batch_size(100);
/// # Ok(())
/// # }
/// ```
#[derive(Clone)]
pub struct AuditConfig {
    /// sqlx connection pool. Required.
    pub pool: PgPool,

    /// Identifies this service in audit entries.
    /// e.g. `"phoxia-id"`, `"phoxia-watch"`, `"idle-fair"`.
    pub service_name: String,

    /// Name of the audit log table. Default: `"audit_log"`.
    pub table_name: String,

    /// Paths excluded from automatic audit. Case-sensitive exact match.
    /// Default: `{"/health", "/metrics"}`.
    pub skip_paths: HashSet<String>,

    /// Max events in buffer before forced flush. Default: `50`.
    pub batch_size: usize,

    /// Max milliseconds between flushes. Default: `100`.
    pub flush_interval_ms: u64,
}

impl AuditConfig {
    /// Create a config with sensible defaults.
    /// Only `pool` and `service_name` are required.
    pub fn new(pool: PgPool, service_name: impl Into<String>) -> Self {
        let mut skip_paths = HashSet::new();
        skip_paths.insert("/health".into());
        skip_paths.insert("/metrics".into());

        Self {
            pool,
            service_name: service_name.into(),
            table_name: "audit_log".into(),
            skip_paths,
            batch_size: 50,
            flush_interval_ms: 100,
        }
    }

    /// Override the table name.
    pub fn table_name(mut self, name: impl Into<String>) -> Self {
        self.table_name = name.into();
        self
    }

    /// Add a single path to the skip list.
    pub fn skip_path(mut self, path: impl Into<String>) -> Self {
        self.skip_paths.insert(path.into());
        self
    }

    /// Override the full skip list.
    pub fn skip_paths(mut self, paths: HashSet<String>) -> Self {
        self.skip_paths = paths;
        self
    }

    /// Override batch size (max events before forced flush).
    pub fn batch_size(mut self, size: usize) -> Self {
        self.batch_size = size;
        self
    }

    /// Override flush interval in milliseconds.
    pub fn flush_interval_ms(mut self, ms: u64) -> Self {
        self.flush_interval_ms = ms;
        self
    }
}