oluso 0.2.0

AI-powered error monitoring for Rust applications: automatic panic reporting, breadcrumb tracking, and intelligent error grouping.
Documentation
use std::collections::HashMap;

use serde_json::Value;

const REDACTED: &str = "[REDACTED]";
const MAX_DEPTH: usize = 10;

const DEFAULT_SENSITIVE_KEYS: &[&str] = &[
    "password",
    "passwd",
    "pwd",
    "secret",
    "token",
    "api_key",
    "apikey",
    "access_token",
    "auth",
    "credentials",
    "mysql_pwd",
    "private_key",
    "privatekey",
    "session",
    "cookie",
    "csrf",
    "xsrf",
    "authorization",
    "bearer",
    "jwt",
    "ssn",
    "social_security",
    "credit_card",
    "card_number",
    "cvv",
    "pin",
];

/// Redacts values behind sensitive-looking keys (passwords, tokens,
/// auth headers, ...) before a report leaves the process. A key is treated
/// as sensitive if it *contains* one of the patterns, case-insensitively --
/// same substring match the other Oluso SDKs use, so `"user_password"` and
/// `"PASSWORD_HASH"` are both caught, not just an exact `"password"` key.
pub struct Sanitizer {
    patterns: Vec<String>,
}

impl Sanitizer {
    pub fn new(custom_sensitive_keys: &[String]) -> Self {
        let mut patterns: Vec<String> = DEFAULT_SENSITIVE_KEYS
            .iter()
            .map(|s| s.to_lowercase())
            .collect();
        patterns.extend(custom_sensitive_keys.iter().map(|s| s.to_lowercase()));
        Self { patterns }
    }

    fn is_sensitive_key(&self, key: &str) -> bool {
        let lower = key.to_lowercase();
        self.patterns.iter().any(|p| lower.contains(p.as_str()))
    }

    /// Sanitize an arbitrary JSON value (a parsed request body, typically).
    pub fn sanitize_value(&self, value: &Value) -> Value {
        self.sanitize_value_at_depth(value, MAX_DEPTH)
    }

    fn sanitize_value_at_depth(&self, value: &Value, depth: usize) -> Value {
        if depth == 0 {
            return Value::String("[Max Depth Reached]".to_string());
        }

        match value {
            Value::Object(map) => {
                let mut sanitized = serde_json::Map::with_capacity(map.len());
                for (key, val) in map {
                    if self.is_sensitive_key(key) {
                        sanitized.insert(key.clone(), Value::String(REDACTED.to_string()));
                    } else {
                        sanitized.insert(key.clone(), self.sanitize_value_at_depth(val, depth - 1));
                    }
                }
                Value::Object(sanitized)
            }
            Value::Array(items) => Value::Array(
                items
                    .iter()
                    .map(|item| self.sanitize_value_at_depth(item, depth - 1))
                    .collect(),
            ),
            other => other.clone(),
        }
    }

    /// Sanitize a flat string map (HTTP headers or a query string), always
    /// redacting `authorization`/`cookie` outright regardless of the
    /// sensitive-key pattern list, matching the other SDKs' hardcoded rule.
    pub fn sanitize_string_map(&self, map: &HashMap<String, String>) -> HashMap<String, String> {
        map.iter()
            .map(|(key, value)| {
                let lower = key.to_lowercase();
                let sanitized = if lower == "authorization"
                    || lower == "cookie"
                    || self.is_sensitive_key(key)
                {
                    REDACTED.to_string()
                } else {
                    value.clone()
                };
                (key.clone(), sanitized)
            })
            .collect()
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use serde_json::json;

    #[test]
    fn redacts_default_sensitive_keys() {
        let sanitizer = Sanitizer::new(&[]);
        let value = json!({ "username": "dave", "password": "hunter2" });
        let sanitized = sanitizer.sanitize_value(&value);
        assert_eq!(sanitized["username"], "dave");
        assert_eq!(sanitized["password"], "[REDACTED]");
    }

    #[test]
    fn matches_keys_containing_a_sensitive_pattern() {
        let sanitizer = Sanitizer::new(&[]);
        let value = json!({ "user_password_hash": "abc" });
        let sanitized = sanitizer.sanitize_value(&value);
        assert_eq!(sanitized["user_password_hash"], "[REDACTED]");
    }

    #[test]
    fn redacts_custom_sensitive_keys() {
        let sanitizer = Sanitizer::new(&["internal_id".to_string()]);
        let value = json!({ "internal_id": "123", "public_id": "456" });
        let sanitized = sanitizer.sanitize_value(&value);
        assert_eq!(sanitized["internal_id"], "[REDACTED]");
        assert_eq!(sanitized["public_id"], "456");
    }

    #[test]
    fn redacts_nested_objects_and_arrays() {
        let sanitizer = Sanitizer::new(&[]);
        let value = json!({ "items": [{ "token": "abc" }] });
        let sanitized = sanitizer.sanitize_value(&value);
        assert_eq!(sanitized["items"][0]["token"], "[REDACTED]");
    }

    #[test]
    fn always_redacts_authorization_and_cookie_headers() {
        let sanitizer = Sanitizer::new(&[]);
        let mut headers = HashMap::new();
        headers.insert("Authorization".to_string(), "Bearer abc".to_string());
        headers.insert("Cookie".to_string(), "session=abc".to_string());
        headers.insert("Accept".to_string(), "application/json".to_string());

        let sanitized = sanitizer.sanitize_string_map(&headers);
        assert_eq!(sanitized["Authorization"], "[REDACTED]");
        assert_eq!(sanitized["Cookie"], "[REDACTED]");
        assert_eq!(sanitized["Accept"], "application/json");
    }
}