use super::AuditSeverity;
use std::sync::{Arc, RwLock};
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Directive {
pub target: String,
pub level: AuditSeverity,
}
#[derive(Debug, Clone, Default)]
pub struct FilterDirectives {
default: Option<AuditSeverity>,
directives: Vec<Directive>,
}
impl FilterDirectives {
#[must_use]
pub fn parse(directives: &str) -> Self {
let mut default = None;
let mut parsed = Vec::new();
for entry in directives.split(',') {
let entry = entry.trim();
if entry.is_empty() {
continue;
}
match entry.split_once('=') {
None => {
if let Ok(level) = entry.parse::<AuditSeverity>() {
default = Some(level);
}
}
Some((target, level)) => {
if let Ok(level) = level.trim().parse::<AuditSeverity>() {
parsed.push(Directive {
target: target.trim().to_string(),
level,
});
}
}
}
}
parsed.sort_by_key(|d| std::cmp::Reverse(d.target.len()));
Self {
default,
directives: parsed,
}
}
#[must_use]
pub fn from_env(var: &str) -> Self {
std::env::var(var).map_or_else(|_| Self::default(), |value| Self::parse(&value))
}
#[must_use]
pub fn level_for(&self, module: &str) -> AuditSeverity {
self.directives
.iter()
.find(|d| module == d.target || module.starts_with(&format!("{}::", d.target)))
.map_or_else(|| self.default.unwrap_or(AuditSeverity::Trace), |d| d.level)
}
#[must_use]
pub fn has_default(&self) -> bool {
self.default.is_some()
}
#[must_use]
pub fn directives(&self) -> &[Directive] {
&self.directives
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.default.is_none() && self.directives.is_empty()
}
}
#[derive(Debug, Clone, Default)]
pub struct LiveFilter {
inner: Arc<RwLock<FilterDirectives>>,
}
impl LiveFilter {
#[must_use]
pub fn new(directives: FilterDirectives) -> Self {
Self {
inner: Arc::new(RwLock::new(directives)),
}
}
#[must_use]
pub fn parse(directives: &str) -> Self {
Self::new(FilterDirectives::parse(directives))
}
#[must_use]
pub fn from_env(var: &str) -> Self {
Self::new(FilterDirectives::from_env(var))
}
pub fn set(&self, directives: FilterDirectives) {
*self
.inner
.write()
.unwrap_or_else(std::sync::PoisonError::into_inner) = directives;
}
pub fn reload(&self, directives: &str) {
self.set(FilterDirectives::parse(directives));
}
#[must_use]
pub fn level_for(&self, module: &str) -> AuditSeverity {
self.read().level_for(module)
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.read().is_empty()
}
#[must_use]
pub fn snapshot(&self) -> FilterDirectives {
self.read().clone()
}
fn read(&self) -> std::sync::RwLockReadGuard<'_, FilterDirectives> {
self.inner
.read()
.unwrap_or_else(std::sync::PoisonError::into_inner)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_a_bare_level_sets_the_default() {
let filter = FilterDirectives::parse("warn");
assert_eq!(filter.level_for("anything"), AuditSeverity::Warning);
assert!(filter.has_default());
}
#[test]
fn test_per_module_directives_override_the_default() {
let filter = FilterDirectives::parse("info,my_app::db=trace,hyper=warn");
assert_eq!(filter.level_for("my_app::db"), AuditSeverity::Trace);
assert_eq!(filter.level_for("my_app::db::pool"), AuditSeverity::Trace);
assert_eq!(filter.level_for("hyper::client"), AuditSeverity::Warning);
assert_eq!(filter.level_for("my_app::api"), AuditSeverity::Info);
}
#[test]
fn test_the_most_specific_directive_wins_regardless_of_order() {
let filter = FilterDirectives::parse("my_app=warn,my_app::db=trace");
assert_eq!(filter.level_for("my_app::db::pool"), AuditSeverity::Trace);
assert_eq!(filter.level_for("my_app::api"), AuditSeverity::Warning);
}
#[test]
fn test_prefix_matching_respects_module_boundaries() {
let filter = FilterDirectives::parse("error,my_app=trace");
assert_eq!(filter.level_for("my_app::db"), AuditSeverity::Trace);
assert_eq!(
filter.level_for("my_application::db"),
AuditSeverity::Error,
"a longer name that merely starts with the target does not match"
);
}
#[test]
fn test_a_malformed_directive_is_skipped_not_fatal() {
let filter = FilterDirectives::parse("info,my_app::db=nonsense,hyper=warn");
assert_eq!(filter.level_for("hyper"), AuditSeverity::Warning);
assert_eq!(
filter.level_for("my_app::db"),
AuditSeverity::Info,
"the unparseable directive falls back to the default"
);
}
#[test]
fn test_an_empty_filter_constrains_nothing() {
let filter = FilterDirectives::parse("");
assert!(filter.is_empty());
assert_eq!(
filter.level_for("anything"),
AuditSeverity::Trace,
"with nothing specified the logger's own threshold decides"
);
}
#[test]
fn test_levels_accept_the_usual_aliases() {
let filter = FilterDirectives::parse("a=warn,b=warning,c=crit");
assert_eq!(filter.level_for("a"), AuditSeverity::Warning);
assert_eq!(filter.level_for("b"), AuditSeverity::Warning);
assert_eq!(filter.level_for("c"), AuditSeverity::Critical);
}
#[test]
fn test_live_filter_updates_are_visible_immediately() {
let filter = LiveFilter::parse("info");
assert_eq!(filter.level_for("app"), AuditSeverity::Info);
filter.reload("app=trace,warn");
assert_eq!(filter.level_for("app"), AuditSeverity::Trace);
assert_eq!(filter.level_for("other"), AuditSeverity::Warning);
}
#[test]
fn test_clones_share_one_filter() {
let filter = LiveFilter::parse("info");
let handle = filter.clone();
handle.reload("trace");
assert_eq!(
filter.level_for("app"),
AuditSeverity::Trace,
"the update is visible through the original handle"
);
}
#[test]
fn test_whitespace_is_tolerated() {
let filter = FilterDirectives::parse(" info , my_app::db = debug ");
assert_eq!(filter.level_for("my_app::db"), AuditSeverity::Debug);
assert_eq!(filter.level_for("other"), AuditSeverity::Info);
}
}