use async_trait::async_trait;
use parking_lot::Mutex;
use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::Arc;
use std::time::Duration;
use tokio::sync::mpsc;
use tokio::task::JoinHandle;
use tokio::time::MissedTickBehavior;
use wordval_core::{Error, Result};
#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize)]
#[serde(rename_all = "snake_case")]
pub enum AuditResult {
Success,
Denied,
Error,
}
impl AuditResult {
pub fn from_status(status: u16) -> Self {
match status {
401 | 403 | 429 => Self::Denied,
s if s >= 400 => Self::Error,
_ => Self::Success,
}
}
}
#[derive(Debug, Clone, serde::Serialize)]
#[non_exhaustive]
pub struct AuditRecord {
pub ts_ms: i64,
pub user_id: String,
pub tenant: Option<String>,
pub action: String,
pub method: Option<String>,
pub resource: String,
pub result: AuditResult,
pub detail: Option<String>,
pub request_id: Option<String>,
pub elapsed_ms: Option<u64>,
pub user_agent: Option<String>,
pub ip: Option<String>,
pub extra: Option<serde_json::Value>,
pub status: Option<u16>,
}
impl AuditRecord {
pub fn new(action: impl Into<String>, resource: impl Into<String>, result: AuditResult) -> Self {
Self {
ts_ms: unix_ms(),
user_id: String::new(),
tenant: None,
action: action.into(),
method: None,
resource: resource.into(),
result,
detail: None,
request_id: None,
elapsed_ms: None,
user_agent: None,
ip: None,
extra: None,
status: None,
}
}
pub fn from_ctx(
ctx: &crate::extract::ClientContext,
action: impl Into<String>,
resource: impl Into<String>,
result: AuditResult,
) -> Self {
Self::new(action, resource, result)
.with_user_agent(ctx.user_agent.clone())
.with_ip(Some(ctx.ip.clone()))
.with_request_id(ctx.request_id.clone())
.with_elapsed_ms(ctx.elapsed_ms())
}
pub fn with_user(mut self, user_id: impl Into<String>) -> Self {
self.user_id = user_id.into();
self
}
pub fn with_tenant(mut self, tenant: Option<String>) -> Self {
self.tenant = tenant;
self
}
pub fn with_method(mut self, method: impl Into<String>) -> Self {
self.method = Some(method.into());
self
}
pub fn with_detail(mut self, detail: impl Into<String>) -> Self {
self.detail = Some(detail.into());
self
}
pub fn with_request_id(mut self, request_id: Option<String>) -> Self {
self.request_id = request_id;
self
}
pub fn with_elapsed_ms(mut self, elapsed_ms: u64) -> Self {
self.elapsed_ms = Some(elapsed_ms);
self
}
pub fn with_user_agent(mut self, user_agent: Option<String>) -> Self {
self.user_agent = user_agent;
self
}
pub fn with_ip(mut self, ip: Option<String>) -> Self {
self.ip = ip;
self
}
pub fn with_extra(mut self, extra: serde_json::Value) -> Self {
self.extra = Some(extra);
self
}
pub fn with_status(mut self, status: u16) -> Self {
self.status = Some(status);
self
}
}
fn unix_ms() -> i64 {
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_millis() as i64)
.unwrap_or(0)
}
#[async_trait]
pub trait AuditSink: Send + Sync + 'static {
async fn write_batch(&self, batch: Vec<AuditRecord>) -> Result<()>;
}
#[cfg(feature = "db")]
const AUDIT_COLUMNS: &[&str] = &[
"ts_ms",
"user_id",
"tenant",
"action",
"method",
"resource",
"result",
"detail",
"request_id",
"elapsed_ms",
"user_agent",
"ip",
"extra",
"status",
];
#[cfg(feature = "db")]
fn result_name(result: AuditResult) -> &'static str {
match result {
AuditResult::Success => "success",
AuditResult::Denied => "denied",
AuditResult::Error => "error",
}
}
pub struct JsonlAuditSink {
path: std::path::PathBuf,
max_bytes: u64,
dir_ready: std::sync::atomic::AtomicBool,
}
impl JsonlAuditSink {
pub fn new(path: impl Into<std::path::PathBuf>, max_bytes: u64) -> Self {
Self {
path: path.into(),
max_bytes,
dir_ready: std::sync::atomic::AtomicBool::new(false),
}
}
pub fn path(&self) -> &std::path::Path {
&self.path
}
}
#[async_trait]
impl AuditSink for JsonlAuditSink {
async fn write_batch(&self, batch: Vec<AuditRecord>) -> Result<()> {
use std::sync::atomic::Ordering::Relaxed;
use tokio::io::AsyncWriteExt;
if batch.is_empty() {
return Ok(());
}
if !self.dir_ready.load(Relaxed) {
if let Some(parent) = self.path.parent() {
if !parent.as_os_str().is_empty() {
tokio::fs::create_dir_all(parent).await.map_err(|e| {
Error::Server(format!("审计目录创建失败 {}: {e}", parent.display()))
})?;
}
}
self.dir_ready.store(true, Relaxed);
}
if self.max_bytes > 0 {
let size = tokio::fs::metadata(&self.path)
.await
.map(|m| m.len())
.unwrap_or(0);
if size >= self.max_bytes {
let rotated = format!("{}.{}", self.path.display(), unix_ms());
match tokio::fs::rename(&self.path, &rotated).await {
Ok(()) => tracing::info!("审计文件已滚动归档: {rotated}"),
Err(e) if e.kind() == std::io::ErrorKind::NotFound => {}
Err(e) => {
return Err(Error::Server(format!(
"审计文件滚动失败 {}: {e}",
self.path.display()
)))
}
}
}
}
let mut payload = String::with_capacity(128 * batch.len());
for record in &batch {
payload.push_str(&serde_json::to_string(record).map_err(|e| {
Error::Server(format!("审计记录序列化失败: {e}"))
})?);
payload.push('\n');
}
let mut file = tokio::fs::OpenOptions::new()
.create(true)
.append(true)
.open(&self.path)
.await
.map_err(|e| {
Error::Server(format!("审计文件打开失败 {}: {e}", self.path.display()))
})?;
file.write_all(payload.as_bytes())
.await
.map_err(|e| {
Error::Server(format!("审计文件写入失败 {}: {e}", self.path.display()))
})?;
file.flush().await.map_err(|e| {
Error::Server(format!("审计文件刷盘失败 {}: {e}", self.path.display()))
})
}
}
#[cfg(feature = "db")]
fn validate_audit_table(table: &str) -> Result<()> {
let ok = !table.is_empty()
&& table.len() <= 64
&& table.starts_with(|c: char| c.is_ascii_alphabetic() || c == '_')
&& table.chars().all(|c| c.is_ascii_alphanumeric() || c == '_');
if ok {
Ok(())
} else {
Err(Error::Config(format!(
"audit table 名称非法: '{table}'(仅允许字母/数字/下划线,且不能以数字开头)"
)))
}
}
#[cfg(feature = "db")]
pub struct DbAuditSink {
db: wordval_db::Db,
table: String,
}
#[cfg(feature = "db")]
impl DbAuditSink {
pub fn new(db: wordval_db::Db, table: impl Into<String>) -> Result<Self> {
let table = table.into();
validate_audit_table(&table)?;
Ok(Self { db, table })
}
pub fn table(&self) -> &str {
&self.table
}
pub async fn ensure_table(&self) -> Result<()> {
let sql = match self.db.dialect() {
wordval_db::Dialect::Postgres => format!(
"CREATE TABLE IF NOT EXISTS {} (ts_ms BIGINT NOT NULL, user_id TEXT NOT NULL, \
tenant TEXT, action TEXT NOT NULL, method TEXT, resource TEXT NOT NULL, \
result TEXT NOT NULL, detail TEXT, request_id TEXT, elapsed_ms BIGINT, \
user_agent TEXT, ip TEXT, extra jsonb, status INT)",
self.table
),
wordval_db::Dialect::Mysql => format!(
"CREATE TABLE IF NOT EXISTS {} (ts_ms BIGINT NOT NULL, user_id VARCHAR(255) NOT NULL, \
tenant VARCHAR(255), action VARCHAR(255) NOT NULL, method VARCHAR(16), \
resource VARCHAR(512) NOT NULL, result VARCHAR(16) NOT NULL, detail TEXT, \
request_id VARCHAR(128), elapsed_ms BIGINT, user_agent VARCHAR(1024), \
ip VARCHAR(64), extra JSON, status INT)",
self.table
),
wordval_db::Dialect::Sqlite => format!(
"CREATE TABLE IF NOT EXISTS {} (ts_ms INTEGER NOT NULL, user_id TEXT NOT NULL, \
tenant TEXT, action TEXT NOT NULL, method TEXT, resource TEXT NOT NULL, \
result TEXT NOT NULL, detail TEXT, request_id TEXT, elapsed_ms INTEGER, \
user_agent TEXT, ip TEXT, extra TEXT, status INTEGER)",
self.table
),
};
self.db
.execute(&sql, &[])
.await
.map(|_| ())
.map_err(|e| Error::Server(format!("审计表 {} 创建失败: {e}", self.table)))
}
fn row_params(record: &AuditRecord) -> Vec<wordval_db::Param> {
use wordval_db::Param;
vec![
Param::I64(record.ts_ms),
Param::Str(record.user_id.clone()),
record
.tenant
.as_ref()
.map(|t| Param::Str(t.clone()))
.unwrap_or(Param::Null),
Param::Str(record.action.clone()),
record
.method
.as_ref()
.map(|m| Param::Str(m.clone()))
.unwrap_or(Param::Null),
Param::Str(record.resource.clone()),
Param::Str(result_name(record.result).to_string()),
record
.detail
.as_ref()
.map(|d| Param::Str(d.clone()))
.unwrap_or(Param::Null),
record
.request_id
.as_ref()
.map(|r| Param::Str(r.clone()))
.unwrap_or(Param::Null),
record
.elapsed_ms
.map(|e| Param::I64(e as i64))
.unwrap_or(Param::Null),
record
.user_agent
.as_ref()
.map(|u| Param::Str(u.clone()))
.unwrap_or(Param::Null),
record
.ip
.as_ref()
.map(|i| Param::Str(i.clone()))
.unwrap_or(Param::Null),
record
.extra
.clone()
.map(Param::Json)
.unwrap_or(Param::Null),
record.status.map(|s| Param::I64(s as i64)).unwrap_or(Param::Null),
]
}
}
#[cfg(feature = "db")]
#[async_trait]
impl AuditSink for DbAuditSink {
async fn write_batch(&self, batch: Vec<AuditRecord>) -> Result<()> {
if batch.is_empty() {
return Ok(());
}
let dialect = self.db.dialect();
let per_row = AUDIT_COLUMNS.len();
let rows_per_chunk = (dialect.max_bind_params() / per_row).max(1);
for chunk in batch.chunks(rows_per_chunk) {
let mut sql = format!(
"INSERT INTO {} ({}) VALUES ",
self.table,
AUDIT_COLUMNS.join(", ")
);
let mut params = Vec::with_capacity(chunk.len() * per_row);
let mut n = 1usize;
for (i, record) in chunk.iter().enumerate() {
if i > 0 {
sql.push_str(", ");
}
sql.push('(');
let row = Self::row_params(record);
for (j, p) in row.iter().enumerate() {
if j > 0 {
sql.push_str(", ");
}
sql.push_str(&dialect.placeholder_param(n, p));
n += 1;
}
sql.push(')');
params.extend(row);
}
self.db
.execute(&sql, params)
.await
.map_err(|e| Error::Server(format!("审计落库失败 {}: {e}", self.table)))?;
}
Ok(())
}
}
pub struct OverflowFile {
path: std::path::PathBuf,
max_bytes: u64,
file: Mutex<Option<std::fs::File>>,
bytes: AtomicU64,
capped: std::sync::atomic::AtomicBool,
}
impl OverflowFile {
pub fn new(path: impl Into<std::path::PathBuf>, max_bytes: u64) -> Self {
Self {
path: path.into(),
max_bytes,
file: Mutex::new(None),
bytes: AtomicU64::new(0),
capped: std::sync::atomic::AtomicBool::new(false),
}
}
pub fn path(&self) -> &std::path::Path {
&self.path
}
pub fn write(&self, record: &AuditRecord) -> bool {
use std::io::Write;
use std::sync::atomic::Ordering::Relaxed;
if self.capped.load(Relaxed) {
return false;
}
let mut payload = match serde_json::to_string(record) {
Ok(s) => s,
Err(e) => {
tracing::warn!("审计溢出记录序列化失败: {e}");
return false;
}
};
payload.push('\n');
let mut guard = self.file.lock();
if guard.is_none() {
if let Some(parent) = self.path.parent() {
if !parent.as_os_str().is_empty() {
if let Err(e) = std::fs::create_dir_all(parent) {
tracing::warn!("审计溢出目录创建失败 {}: {e}", parent.display());
return false;
}
}
}
match std::fs::OpenOptions::new().create(true).append(true).open(&self.path) {
Ok(f) => {
let existing = f.metadata().map(|m| m.len()).unwrap_or(0);
self.bytes.store(existing, Relaxed);
*guard = Some(f);
}
Err(e) => {
tracing::warn!("审计溢出文件打开失败 {}: {e}", self.path.display());
return false;
}
}
}
let file = guard.as_mut().expect("上一步刚建立的句柄");
if self.max_bytes > 0
&& self.bytes.fetch_add(payload.len() as u64, Relaxed) + payload.len() as u64
> self.max_bytes
{
self.capped.store(true, Relaxed);
tracing::warn!(
"审计溢出文件已达上限 {} 字节,后续溢出记录只计数不再落盘: {}",
self.max_bytes,
self.path.display()
);
return false;
}
match file.write_all(payload.as_bytes()) {
Ok(()) => true,
Err(e) => {
tracing::warn!("审计溢出文件写入失败 {}: {e}", self.path.display());
*guard = None; false
}
}
}
}
pub const DEFAULT_SHUTDOWN_TIMEOUT: Duration = Duration::from_secs(3);
#[derive(Debug, Clone)]
pub struct AuditConfig {
pub capacity: usize,
pub max_batch: usize,
pub flush_interval: Duration,
}
impl Default for AuditConfig {
fn default() -> Self {
Self {
capacity: 4096,
max_batch: 128,
flush_interval: Duration::from_secs(1),
}
}
}
pub struct AuditWriter {
tx: Mutex<Option<mpsc::Sender<AuditRecord>>>,
task: Mutex<Option<JoinHandle<()>>>,
written: Arc<AtomicU64>,
dropped: AtomicU64,
flush_errors: Arc<AtomicU64>,
overflowed: AtomicU64,
overflow: Option<Arc<OverflowFile>>,
}
impl AuditWriter {
pub fn new(sink: Arc<dyn AuditSink>, config: AuditConfig) -> Result<Self> {
Self::build(sink, config, None)
}
pub fn with_overflow(
sink: Arc<dyn AuditSink>,
config: AuditConfig,
overflow: Arc<OverflowFile>,
) -> Result<Self> {
Self::build(sink, config, Some(overflow))
}
fn build(
sink: Arc<dyn AuditSink>,
config: AuditConfig,
overflow: Option<Arc<OverflowFile>>,
) -> Result<Self> {
if config.capacity == 0 {
return Err(Error::Config("audit capacity 必须大于 0".into()));
}
if config.max_batch == 0 {
return Err(Error::Config("audit max_batch 必须大于 0".into()));
}
if config.flush_interval.is_zero() {
return Err(Error::Config("audit flush_interval 不能为 0".into()));
}
let (tx, rx) = mpsc::channel(config.capacity);
let written = Arc::new(AtomicU64::new(0));
let flush_errors = Arc::new(AtomicU64::new(0));
let task = tokio::spawn(flush_loop(
sink,
rx,
config,
Arc::clone(&written),
Arc::clone(&flush_errors),
));
Ok(Self {
tx: Mutex::new(Some(tx)),
task: Mutex::new(Some(task)),
dropped: AtomicU64::new(0),
overflowed: AtomicU64::new(0),
overflow,
written,
flush_errors,
})
}
pub fn write(&self, record: AuditRecord) {
let guard = self.tx.lock();
let Some(tx) = guard.as_ref() else {
self.handle_overflow(record, "写入器已关闭");
return;
};
match tx.try_send(record) {
Ok(()) => {}
Err(e) => {
let (reason, record) = match e {
mpsc::error::TrySendError::Full(r) => ("队列已满", r),
mpsc::error::TrySendError::Closed(r) => ("写入器已关闭", r),
};
self.handle_overflow(record, reason);
}
}
}
fn handle_overflow(&self, record: AuditRecord, reason: &str) {
if let Some(ovf) = &self.overflow {
if ovf.write(&record) {
let n = self.overflowed.fetch_add(1, Ordering::Relaxed) + 1;
if n == 1 || n % 1024 == 0 {
tracing::warn!("审计写入器: {reason},转入溢出文件(累计 {n} 条)");
}
return;
}
}
self.count_dropped(reason);
}
pub fn write_all(&self, records: impl IntoIterator<Item = AuditRecord>) {
for record in records {
self.write(record);
}
}
fn count_dropped(&self, reason: &str) {
let n = self.dropped.fetch_add(1, Ordering::Relaxed) + 1;
if n == 1 || n % 1024 == 0 {
tracing::warn!("审计写入器: {reason},丢弃审计记录(累计 {n} 条)");
}
}
pub fn written(&self) -> u64 {
self.written.load(Ordering::Relaxed)
}
pub fn dropped(&self) -> u64 {
self.dropped.load(Ordering::Relaxed)
}
pub fn overflowed(&self) -> u64 {
self.overflowed.load(Ordering::Relaxed)
}
pub fn flush_errors(&self) -> u64 {
self.flush_errors.load(Ordering::Relaxed)
}
pub async fn shutdown(&self, timeout: Option<Duration>) -> Result<()> {
let handle = {
*self.tx.lock() = None;
self.task.lock().take()
};
let Some(mut handle) = handle else {
return Ok(()); };
match timeout {
None => {
handle.await.map_err(|e| Error::Server(format!("审计 flush 任务异常退出: {e}")))
}
Some(d) => {
let deadline = tokio::time::Instant::now() + d;
match tokio::time::timeout_at(deadline, &mut handle).await {
Ok(Ok(())) => Ok(()),
Ok(Err(e)) => Err(Error::Server(format!("审计 flush 任务异常退出: {e}"))),
Err(_) => {
*self.task.lock() = Some(handle);
Err(Error::Server(
"审计写入器关闭超时,存量记录可能未完全落盘;flush 任务仍在后台运行,可重试".into(),
))
}
}
}
}
}
}
pub async fn writer_from_config(
cfg: &wordval_config::AuditMiddlewareConfig,
) -> Result<Arc<AuditWriter>> {
let config = AuditConfig {
capacity: cfg.capacity,
max_batch: cfg.max_batch,
flush_interval: Duration::from_secs(cfg.flush_interval_secs),
};
let sink: Arc<dyn AuditSink> = match cfg.sink.as_str() {
"jsonl" => Arc::new(JsonlAuditSink::new(&cfg.path, cfg.max_bytes)),
"db" => {
#[cfg(feature = "db")]
{
let db = crate::resources::try_using(crate::resources::DEFAULT_DB_NAME).ok_or_else(
|| Error::Config("audit.sink = \"db\" 需要先初始化数据库".into()),
)?;
let sink = DbAuditSink::new(db, &cfg.table)?;
sink.ensure_table().await?;
Arc::new(sink)
}
#[cfg(not(feature = "db"))]
{
return Err(Error::Config(
"audit.sink = \"db\" 需要启用 wordval-web 的 db 特性".into(),
));
}
}
other => {
return Err(Error::Config(format!(
"audit.sink 无效: {other}(应为 jsonl 或 db)"
)))
}
};
let writer = match cfg.on_overflow.as_str() {
"drop" => AuditWriter::new(sink, config)?,
"file" => AuditWriter::with_overflow(
sink,
config,
Arc::new(OverflowFile::new(&cfg.overflow_path, cfg.max_bytes)),
)?,
other => {
return Err(Error::Config(format!(
"audit.on_overflow 无效: {other}(应为 drop 或 file)"
)))
}
};
tracing::info!(
"审计写入器已启动: sink={} 队列={} 批量={}/{}s 溢出={}",
cfg.sink,
cfg.capacity,
cfg.max_batch,
cfg.flush_interval_secs,
cfg.on_overflow
);
Ok(Arc::new(writer))
}
async fn flush_loop(
sink: Arc<dyn AuditSink>,
mut rx: mpsc::Receiver<AuditRecord>,
config: AuditConfig,
written: Arc<AtomicU64>,
flush_errors: Arc<AtomicU64>,
) {
let AuditConfig { max_batch, flush_interval, .. } = config;
let mut buf: Vec<AuditRecord> = Vec::with_capacity(max_batch);
let mut interval = tokio::time::interval(flush_interval);
interval.set_missed_tick_behavior(MissedTickBehavior::Delay);
let mut err_batches: u64 = 0;
loop {
if buf.len() >= max_batch {
flush_batch(&sink, &mut buf, &written, &flush_errors, &mut err_batches).await;
}
tokio::select! {
_ = interval.tick() => {
if !buf.is_empty() {
flush_batch(&sink, &mut buf, &written, &flush_errors, &mut err_batches).await;
}
}
rec = rx.recv() => match rec {
Some(rec) => buf.push(rec),
None => break,
},
}
}
if !buf.is_empty() {
flush_batch(&sink, &mut buf, &written, &flush_errors, &mut err_batches).await;
}
}
async fn flush_batch(
sink: &Arc<dyn AuditSink>,
buf: &mut Vec<AuditRecord>,
written: &AtomicU64,
flush_errors: &AtomicU64,
err_batches: &mut u64,
) {
let n = buf.len();
match sink.write_batch(std::mem::take(buf)).await {
Ok(()) => {
written.fetch_add(n as u64, Ordering::Relaxed);
}
Err(e) => {
flush_errors.fetch_add(n as u64, Ordering::Relaxed);
*err_batches += 1;
if *err_batches == 1 || *err_batches % 1024 == 0 {
tracing::warn!("审计写入器: sink 落盘失败,丢弃 {n} 条(累计失败批数 {}): {e}", err_batches);
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
struct SharedSink {
batches: Mutex<Vec<Vec<AuditRecord>>>,
delay: Duration,
}
impl SharedSink {
fn new(delay: Duration) -> Arc<Self> {
Arc::new(Self { batches: Mutex::new(Vec::new()), delay })
}
fn all_records(&self) -> Vec<AuditRecord> {
self.batches.lock().iter().flatten().cloned().collect()
}
}
#[async_trait]
impl AuditSink for SharedSink {
async fn write_batch(&self, batch: Vec<AuditRecord>) -> Result<()> {
if !self.delay.is_zero() {
tokio::time::sleep(self.delay).await;
}
self.batches.lock().push(batch);
Ok(())
}
}
fn record(n: usize) -> AuditRecord {
AuditRecord::new(format!("action.{n}"), "/api/test", AuditResult::Success)
}
fn default_config() -> AuditConfig {
AuditConfig { flush_interval: Duration::from_millis(30), ..AuditConfig::default() }
}
#[tokio::test]
async fn test_close_drains_all_pending() {
let sink = SharedSink::new(Duration::ZERO);
let writer = AuditWriter::new(sink.clone(), default_config()).unwrap();
for n in 0..50 {
writer.write(record(n));
}
writer.shutdown(None).await.unwrap();
assert_eq!(sink.all_records().len(), 50, "关闭后排空应零丢失");
assert_eq!(writer.written(), 50);
assert_eq!(writer.dropped(), 0);
}
#[tokio::test]
async fn test_batch_respects_max_batch() {
let sink = SharedSink::new(Duration::ZERO);
let cfg = AuditConfig {
capacity: 256,
max_batch: 16,
flush_interval: Duration::from_millis(30),
};
let writer = AuditWriter::new(sink.clone(), cfg).unwrap();
for n in 0..64 {
writer.write(record(n));
}
writer.shutdown(None).await.unwrap();
let batches = sink.batches.lock().clone();
assert!(batches.iter().all(|b| b.len() <= 16), "每批不得超过 max_batch");
assert_eq!(batches.iter().map(|b| b.len()).sum::<usize>(), 64);
}
#[tokio::test]
async fn test_interval_flush_without_full_batch() {
let sink = SharedSink::new(Duration::ZERO);
let writer = AuditWriter::new(sink.clone(), default_config()).unwrap();
writer.write(record(1));
writer.write(record(2));
let mut flushed = 0usize;
for _ in 0..40 {
tokio::time::sleep(Duration::from_millis(50)).await;
flushed = sink.all_records().len();
if flushed == 2 {
break;
}
}
assert_eq!(flushed, 2, "interval 到期应刷出不足一批的记录");
writer.shutdown(None).await.unwrap();
assert_eq!(writer.written(), 2);
}
#[tokio::test]
async fn test_overflow_drops_and_counts() {
let sink = SharedSink::new(Duration::from_millis(300));
let cfg = AuditConfig {
capacity: 4,
max_batch: 8,
flush_interval: Duration::from_millis(30),
};
let writer = AuditWriter::new(sink.clone(), cfg).unwrap();
for n in 0..100 {
writer.write(record(n));
}
writer.shutdown(None).await.unwrap();
let written = writer.written();
let dropped = writer.dropped();
assert!((1..=8).contains(&written), "应至少写入一批,实际 {written}");
assert!(dropped >= 90, "溢出应大量丢弃,实际 {dropped}");
assert_eq!(written + dropped, 100, "写入+丢弃应与提交总数守恒");
assert_eq!(sink.all_records().len() as u64, written, "落盘数应等于 written 计数");
}
#[tokio::test]
async fn test_write_after_shutdown_counts_dropped() {
let sink = SharedSink::new(Duration::ZERO);
let writer = AuditWriter::new(sink.clone(), default_config()).unwrap();
writer.write(record(1));
writer.shutdown(None).await.unwrap();
writer.write(record(2));
writer.write(record(3));
assert_eq!(writer.dropped(), 2, "关闭后的写入应被丢弃并计数");
assert_eq!(sink.all_records().len(), 1);
writer.shutdown(None).await.unwrap();
writer.shutdown(Some(Duration::from_secs(1))).await.unwrap();
}
#[tokio::test]
async fn test_sink_failure_counts_flush_errors() {
struct FailingSink;
#[async_trait]
impl AuditSink for FailingSink {
async fn write_batch(&self, _batch: Vec<AuditRecord>) -> Result<()> {
Err(Error::Server("db down".into()))
}
}
let writer = AuditWriter::new(Arc::new(FailingSink), default_config()).unwrap();
for n in 0..5 {
writer.write(record(n));
}
writer.shutdown(None).await.unwrap();
assert_eq!(writer.flush_errors(), 5, "sink 失败应计入 flush_errors");
assert_eq!(writer.written(), 0);
}
#[tokio::test]
async fn test_config_validation() {
let sink = SharedSink::new(Duration::ZERO);
assert!(AuditWriter::new(sink.clone(), AuditConfig { capacity: 0, ..default_config() }).is_err());
assert!(AuditWriter::new(
sink,
AuditConfig { max_batch: 0, flush_interval: Duration::from_secs(1), ..AuditConfig::default() }
)
.is_err());
}
#[tokio::test]
async fn test_overflow_file_captures_dropped() {
let dir = std::env::temp_dir().join(format!("wv_audit_ovf_{}", std::process::id()));
let path = dir.join("ovf.log");
let _ = std::fs::remove_file(&path);
let sink = SharedSink::new(Duration::from_millis(300));
let cfg = AuditConfig {
capacity: 2,
max_batch: 8,
flush_interval: Duration::from_millis(30),
};
let writer =
AuditWriter::with_overflow(sink.clone(), cfg, Arc::new(OverflowFile::new(&path, 0)))
.unwrap();
for n in 0..20 {
writer.write(record(n));
}
writer.shutdown(None).await.unwrap();
assert_eq!(writer.overflowed(), 18, "溢出应等于 20 - capacity");
assert_eq!(writer.dropped(), 0, "配置溢出通道后不该丢记录");
let lines = std::fs::read_to_string(&path).expect("溢出文件应已写入");
assert_eq!(lines.lines().count(), 18, "溢出文件行数应与 overflowed 一致");
let first: serde_json::Value = serde_json::from_str(lines.lines().next().unwrap()).unwrap();
assert_eq!(first["action"], "action.2", "前 2 条走主通道,溢出从第 3 条开始");
assert_eq!(sink.all_records().len() + 18, 20);
}
#[tokio::test]
async fn test_overflow_file_capacity_cap() {
let dir = std::env::temp_dir().join(format!("wv_audit_ovfcap_{}", std::process::id()));
let path = dir.join("ovf-cap.log");
let _ = std::fs::remove_file(&path);
let sink = SharedSink::new(Duration::from_millis(300));
let cfg = AuditConfig {
capacity: 2,
max_batch: 8,
flush_interval: Duration::from_millis(30),
};
let writer = AuditWriter::with_overflow(
sink.clone(),
cfg,
Arc::new(OverflowFile::new(&path, 8)),
)
.unwrap();
for n in 0..20 {
writer.write(record(n));
}
writer.shutdown(None).await.unwrap();
assert_eq!(writer.overflowed(), 0, "超限后不应有记录落入溢出文件");
assert_eq!(writer.dropped(), 18, "溢出失败回退为丢弃计数");
assert!(!path.exists() || std::fs::metadata(&path).unwrap().len() == 0);
}
#[test]
fn test_result_from_status() {
assert_eq!(AuditResult::from_status(200), AuditResult::Success);
assert_eq!(AuditResult::from_status(302), AuditResult::Success);
assert_eq!(AuditResult::from_status(401), AuditResult::Denied);
assert_eq!(AuditResult::from_status(403), AuditResult::Denied);
assert_eq!(AuditResult::from_status(429), AuditResult::Denied);
assert_eq!(AuditResult::from_status(400), AuditResult::Error);
assert_eq!(AuditResult::from_status(500), AuditResult::Error);
}
#[test]
fn test_record_serializes() {
let rec = AuditRecord::new("user.login", "/api/login", AuditResult::Denied)
.with_user("u-1")
.with_tenant(Some("acme".into()))
.with_detail("权限不足")
.with_elapsed_ms(42)
.with_user_agent(Some("Mozilla/5.0 Test".into()))
.with_extra(serde_json::json!({ "order_id": "o-9", "retry": false }));
let json = serde_json::to_value(&rec).unwrap();
assert_eq!(json["action"], "user.login");
assert_eq!(json["result"], "denied");
assert_eq!(json["tenant"], "acme");
assert!(json["ts_ms"].is_i64());
assert_eq!(json["elapsed_ms"], 42);
assert_eq!(json["user_agent"], "Mozilla/5.0 Test");
assert_eq!(json["extra"]["order_id"], "o-9");
let plain = serde_json::to_value(AuditRecord::new("a", "r", AuditResult::Success)).unwrap();
assert!(plain["request_id"].is_null());
assert!(plain["elapsed_ms"].is_null());
assert!(plain["user_agent"].is_null());
assert!(plain["ip"].is_null());
assert!(plain["method"].is_null());
assert!(plain["extra"].is_null());
assert!(plain["status"].is_null(), "业务侧手写记录不带状态码");
let with_st =
serde_json::to_value(AuditRecord::new("a", "r", AuditResult::Error).with_status(500))
.unwrap();
assert_eq!(with_st["status"], 500);
}
#[test]
fn test_record_from_ctx_fills_ua_and_elapsed() {
use std::time::{Duration, Instant};
let ctx = crate::extract::ClientContext {
ip: "1.2.3.4".into(),
user_agent: Some("UA/1.0".into()),
started: Instant::now() - Duration::from_millis(3),
request_id: Some("req-abc-1".into()),
};
let rec = AuditRecord::from_ctx(&ctx, "order.delete", "/api/orders/1", AuditResult::Success);
assert_eq!(rec.user_agent.as_deref(), Some("UA/1.0"));
assert_eq!(rec.request_id.as_deref(), Some("req-abc-1"));
assert_eq!(rec.ip.as_deref(), Some("1.2.3.4"), "from_ctx 应带客户端 IP");
let elapsed = rec.elapsed_ms.expect("from_ctx 应填充耗时");
assert!((3..1000).contains(&elapsed), "elapsed_ms 异常: {elapsed}");
assert_eq!(rec.action, "order.delete");
assert_eq!(rec.result, AuditResult::Success);
assert!(rec.extra.is_none());
}
#[cfg(feature = "db")]
#[test]
fn test_audit_table_name_whitelist() {
assert!(validate_audit_table("audit_log").is_ok());
assert!(validate_audit_table("AuditLog2").is_ok());
let long = "a".repeat(65);
for bad in [
"audit; DROP TABLE users",
"1audit",
"audit-log",
"audit log",
"\"audit\"",
"",
long.as_str(),
] {
assert!(validate_audit_table(bad).is_err(), "应拒绝非法表名: {bad:?}");
}
}
#[tokio::test]
async fn test_writer_from_config_rejects_unknown_values() {
let dir = std::env::temp_dir().join(format!("wv_audit_cfg_{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
let overflow_path = dir.join("overflow.log");
let mut cfg = wordval_config::AuditMiddlewareConfig {
enabled: true,
path: dir.join("audit.log").to_str().unwrap().to_string(),
overflow_path: overflow_path.to_str().unwrap().to_string(),
sink: "parquet".into(),
..wordval_config::AuditMiddlewareConfig::default()
};
assert!(writer_from_config(&cfg).await.is_err(), "未知 sink 应装配失败");
cfg.sink = "jsonl".into();
cfg.on_overflow = "socket".into();
assert!(writer_from_config(&cfg).await.is_err(), "未知溢出策略应装配失败");
assert!(
!overflow_path.exists(),
"装配失败不应留下半初始化的文件: {:?}",
cfg.on_overflow
);
cfg.on_overflow = "file".into();
let writer = writer_from_config(&cfg).await.expect("jsonl + 溢出文件通道应可装配");
writer.write(record(7));
writer.shutdown(None).await.unwrap();
let lines = std::fs::read_to_string(&cfg.path).unwrap();
assert_eq!(lines.lines().count(), 1);
assert!(lines.contains("action.7"));
let _ = std::fs::remove_dir_all(&dir);
}
}