grow-graylog 0.2.0

Rust SDK for Graylog Open by Grow Codes
Documentation
// Generated by sdk-kit 0.3.0 — do not edit; change sdk-kit and run "sdk-kit sync"
//! Redaction of log records before they leave the process (SPEC §4 `RedactionProcessor`).

use regex::Regex;

use super::{AttrValue, Attributes, LogRecord};

/// Attribute-name fragments redacted by default (case-insensitive substring match).
pub const DEFAULT_REDACT_KEYS: &[&str] = &[
    "password",
    "passwd",
    "token",
    "authorization",
    "secret",
    "cookie",
    "api_key",
    "apikey",
    "access_key",
    "private_key",
];

/// Returns redacted copies of records: sensitive attribute names (recursively) get the
/// replacement, and every pattern is replaced in the body and in string attribute values.
#[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 {
    /// Processor with the given keys and patterns and the `[REDACTED]` replacement.
    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(),
        }
    }

    /// Adds more key fragments to the defaults.
    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
    }

    /// Adds a pattern applied to the body and string values.
    pub fn with_pattern(mut self, pattern: Regex) -> Self {
        self.patterns.push(pattern);
        self
    }

    /// Changes the replacement text.
    pub fn with_replacement(mut self, replacement: impl Into<String>) -> Self {
        self.replacement = replacement.into();
        self
    }

    /// Key fragments in use (lower-case).
    pub fn keys(&self) -> &[String] {
        &self.keys
    }

    /// Whether an attribute name is sensitive.
    pub fn is_sensitive_key(&self, name: &str) -> bool {
        let lower = name.to_lowercase();
        self.keys.iter().any(|k| lower.contains(k.as_str()))
    }

    /// Returns a redacted copy of `record`.
    pub fn process(&self, record: &LogRecord) -> LogRecord {
        let mut out = record.clone();
        self.apply(&mut out);
        out
    }

    /// Redacts `record` in place.
    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);
                    }
                }
            }
            _ => {}
        }
    }
}