use std::sync::Arc;
use ash_log::{AuditEvent, AuditEventType, AuditResult, AuditSeverity, Logger};
use crate::context::Context;
use crate::hook::{Event, Hook, Outcome};
pub struct Audit {
logger: Arc<Logger>,
}
impl Audit {
pub fn new(logger: Arc<Logger>) -> Self {
Self { logger }
}
}
impl Hook for Audit {
fn after(&self, event: &Event<'_>, outcome: &Outcome, ctx: &Context) {
let method = match event.id {
Some(id) => format!("{} {}/{}", event.operation.as_str(), event.resource, id),
None => format!("{} {}", event.operation.as_str(), event.resource),
};
let mut builder = AuditEvent::builder()
.event_type(event_type(outcome))
.result(result(outcome))
.severity(severity(event, outcome))
.correlation_id(ctx.correlation_id())
.method(method);
if let Some(principal) = ctx.principal() {
builder = builder.principal(principal);
}
self.logger.log(builder.build());
}
}
fn event_type(outcome: &Outcome) -> AuditEventType {
match outcome {
Outcome::Succeeded { .. } => AuditEventType::MethodInvocation,
Outcome::Failed { status: 401 | 403 } => AuditEventType::AuthorizationCheck,
Outcome::Failed { .. } => AuditEventType::ErrorOccurred,
}
}
fn result(outcome: &Outcome) -> AuditResult {
match outcome {
Outcome::Succeeded { .. } => AuditResult::Success,
Outcome::Failed { status: 401 | 403 } => AuditResult::Denied,
Outcome::Failed { .. } => AuditResult::Failure,
}
}
fn severity(event: &Event<'_>, outcome: &Outcome) -> AuditSeverity {
match outcome {
Outcome::Succeeded { .. } => AuditSeverity::Info,
Outcome::Failed { status: 401 | 403 } if event.operation.is_write() => {
AuditSeverity::Warning
}
Outcome::Failed { status } if *status >= 500 => AuditSeverity::Warning,
Outcome::Failed { .. } => AuditSeverity::Info,
}
}