use crate::Redactor;
use tracing::field::{Field, Visit};
use tracing_subscriber::field::RecordFields;
use tracing_subscriber::fmt::FormatFields;
use tracing_subscriber::fmt::format::Writer;
#[derive(Debug)]
pub struct RedactFields {
redactor: Redactor,
}
pub fn redact_fields() -> RedactFields {
RedactFields {
redactor: crate::default_redactor(),
}
}
impl RedactFields {
pub fn field(mut self, name: impl Into<String>) -> Self {
self.redactor.fields.push(name.into());
self
}
pub fn fields<I, S>(mut self, names: I) -> Self
where
I: IntoIterator<Item = S>,
S: Into<String>,
{
self.redactor
.fields
.extend(names.into_iter().map(Into::into));
self
}
pub fn mask(mut self, mask: impl Into<String>) -> Self {
self.redactor.mask = mask.into();
self
}
#[cfg(feature = "regex")]
pub fn field_pattern(mut self, pattern: &str) -> Result<Self, crate::Error> {
self.redactor.field_patterns.push(compile(pattern)?);
Ok(self)
}
#[cfg(feature = "regex")]
pub fn value_pattern(mut self, pattern: &str, replacement: &str) -> Result<Self, crate::Error> {
let re = compile(pattern)?;
self.redactor
.value_patterns
.push((re, replacement.to_string()));
Ok(self)
}
}
#[cfg(feature = "regex")]
fn compile(pattern: &str) -> Result<regex::Regex, crate::Error> {
regex::Regex::new(pattern).map_err(|source| crate::Error::InvalidRegex {
pattern: pattern.to_string(),
source,
})
}
struct FieldVisitor {
fields: Vec<(String, String, bool)>,
}
impl Visit for FieldVisitor {
fn record_debug(&mut self, field: &Field, value: &dyn std::fmt::Debug) {
if field.name() == "message" {
return;
}
self.fields
.push((field.name().to_string(), format!("{value:?}"), false));
}
fn record_str(&mut self, field: &Field, value: &str) {
if field.name() == "message" {
return;
}
self.fields
.push((field.name().to_string(), value.to_string(), true));
}
}
impl<'writer> FormatFields<'writer> for RedactFields {
fn format_fields<R: RecordFields>(
&self,
mut writer: Writer<'writer>,
fields: R,
) -> std::fmt::Result {
let mut visitor = FieldVisitor { fields: Vec::new() };
fields.record(&mut visitor);
for (name, raw, is_str) in &visitor.fields {
let effective = self.redactor.redact_field(name, raw);
let display = if *is_str {
format!("{effective:?}")
} else {
effective
};
write!(writer, " {name}={display}")?;
}
Ok(())
}
}