use regex::Regex;
use super::{AttrValue, Attributes, LogRecord};
pub const DEFAULT_REDACT_KEYS: &[&str] = &[
"password",
"passwd",
"token",
"authorization",
"secret",
"cookie",
"api_key",
"apikey",
"access_key",
"private_key",
];
#[derive(Debug, Clone)]
pub struct RedactionProcessor {
keys: Vec<String>,
patterns: Vec<Regex>,
replacement: String,
}
impl Default for RedactionProcessor {
fn default() -> Self {
RedactionProcessor::new(DEFAULT_REDACT_KEYS.iter().copied(), Vec::new())
}
}
impl RedactionProcessor {
pub fn new<K, S>(keys: K, patterns: Vec<Regex>) -> Self
where
K: IntoIterator<Item = S>,
S: AsRef<str>,
{
RedactionProcessor {
keys: keys
.into_iter()
.map(|k| k.as_ref().to_lowercase())
.collect(),
patterns,
replacement: crate::core::REDACTED.to_string(),
}
}
pub fn with_extra_keys<S: AsRef<str>>(mut self, keys: impl IntoIterator<Item = S>) -> Self {
self.keys
.extend(keys.into_iter().map(|k| k.as_ref().to_lowercase()));
self
}
pub fn with_pattern(mut self, pattern: Regex) -> Self {
self.patterns.push(pattern);
self
}
pub fn with_replacement(mut self, replacement: impl Into<String>) -> Self {
self.replacement = replacement.into();
self
}
pub fn keys(&self) -> &[String] {
&self.keys
}
pub fn is_sensitive_key(&self, name: &str) -> bool {
let lower = name.to_lowercase();
self.keys.iter().any(|k| lower.contains(k.as_str()))
}
pub fn process(&self, record: &LogRecord) -> LogRecord {
let mut out = record.clone();
self.apply(&mut out);
out
}
pub fn apply(&self, record: &mut LogRecord) {
if !self.patterns.is_empty() {
record.body = self.redact_text(&record.body);
}
self.redact_map(&mut record.attributes);
}
fn redact_text(&self, text: &str) -> String {
self.patterns.iter().fold(text.to_string(), |acc, p| {
p.replace_all(&acc, self.replacement.as_str()).into_owned()
})
}
fn redact_map(&self, map: &mut Attributes) {
for (k, v) in map.iter_mut() {
if self.is_sensitive_key(k) {
*v = AttrValue::String(self.replacement.clone());
} else {
self.redact_value(v);
}
}
}
fn redact_value(&self, value: &mut AttrValue) {
match value {
AttrValue::String(s) if !self.patterns.is_empty() => *s = self.redact_text(s),
AttrValue::Array(items) => items.iter_mut().for_each(|v| self.redact_value(v)),
AttrValue::Object(m) => {
for (k, v) in m.iter_mut() {
if self.is_sensitive_key(k) {
*v = AttrValue::String(self.replacement.clone());
} else {
self.redact_value(v);
}
}
}
_ => {}
}
}
}