oluso 0.2.0

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

use regex::Regex;

static NUMBER_RE: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"\d+").unwrap());
static UUID_RE: LazyLock<Regex> = LazyLock::new(|| {
    Regex::new(r"(?i)[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}").unwrap()
});
static PATH_RE: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"[/\\][\w/\\.\-]+").unwrap());
static URL_RE: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"https?://\S+").unwrap());
static WHITESPACE_RE: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"\s+").unwrap());

/// Generates a stable fingerprint for error deduplication, from the error
/// type, its (normalized) message, and the first few lines of its stack
/// trace when one's available.
///
/// Uses a plain FNV-1a hash rather than a cryptographic one -- same choice
/// @oluso/core makes, since deduplication only needs a stable,
/// well-distributed hash, and this keeps the algorithm identical (and the
/// resulting fingerprints comparable) across every Oluso SDK.
pub fn generate_fingerprint(error_type: &str, message: &str, stack_trace: Option<&str>) -> String {
    let mut components = vec![error_type.to_string(), normalize_message(message)];

    if let Some(stack) = stack_trace {
        components.push(stack_signature(stack));
    }

    fnv1a_hash(&components.join("|"))
}

fn normalize_message(message: &str) -> String {
    let normalized = NUMBER_RE.replace_all(message, "N");
    let normalized = UUID_RE.replace_all(&normalized, "UUID");
    let normalized = PATH_RE.replace_all(&normalized, "PATH");
    let normalized = URL_RE.replace_all(&normalized, "URL");
    WHITESPACE_RE
        .replace_all(&normalized, " ")
        .trim()
        .to_string()
}

/// Rust backtraces don't share JS/V8's `at fn (file:line)` shape, so unlike
/// @oluso/core this doesn't try to extract bare function names -- it just
/// takes the first few lines verbatim as a stable-enough signature.
fn stack_signature(stack: &str) -> String {
    stack.lines().take(5).collect::<Vec<_>>().join("->")
}

fn fnv1a_hash(input: &str) -> String {
    let mut hash: u32 = 0x811c9dc5;
    for byte in input.bytes() {
        hash ^= byte as u32;
        hash = hash.wrapping_mul(0x01000193);
    }
    format!("{:08x}", hash)
}

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

    #[test]
    fn same_error_type_and_message_produce_the_same_fingerprint() {
        let a = generate_fingerprint("ValueError", "invalid input", None);
        let b = generate_fingerprint("ValueError", "invalid input", None);
        assert_eq!(a, b);
    }

    #[test]
    fn different_messages_produce_different_fingerprints() {
        let a = generate_fingerprint("ValueError", "invalid input", None);
        let b = generate_fingerprint("ValueError", "missing field", None);
        assert_ne!(a, b);
    }

    #[test]
    fn normalizes_dynamic_values_so_similar_errors_collapse_together() {
        let a = generate_fingerprint("NotFound", "user 12345 not found", None);
        let b = generate_fingerprint("NotFound", "user 67890 not found", None);
        assert_eq!(a, b);
    }

    #[test]
    fn normalizes_uuids_and_paths_and_urls() {
        let a = generate_fingerprint(
            "IoError",
            "failed to read /var/data/file.txt from https://example.test/a",
            None,
        );
        let b = generate_fingerprint(
            "IoError",
            "failed to read /tmp/other.log from https://example.test/b",
            None,
        );
        assert_eq!(a, b);
    }

    #[test]
    fn returns_an_8_character_hex_string() {
        let fp = generate_fingerprint("Error", "boom", None);
        assert_eq!(fp.len(), 8);
        assert!(fp.chars().all(|c| c.is_ascii_hexdigit()));
    }
}