timberjack 0.1.0-alpha.4

A CLI tool that fells log files with speed and insight
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

use super::{LogParser, ParsedLogLine};
use lazy_static::lazy_static;
use regex::Regex;

lazy_static! {
    static ref LEVEL_REGEX: Regex = Regex::new(
        r"\[((?i)ERROR|WARN|INFO|DEBUG|TRACE|SEVERE|WARNING|FINE)]|(?i:ERROR|WARN|INFO|DEBUG|TRACE|SEVERE|WARNING|FINE):"
    ).unwrap();

    static ref TIMESTAMP_REGEX: Regex = Regex::new(
        r"(\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2}:\d{2})"
    ).unwrap();
}

/// Generic log parser that works with standard log formats
pub struct GenericLogParser;

impl LogParser for GenericLogParser {
    fn name(&self) -> &'static str {
        "Generic"
    }

    fn can_parse(&self, _sample_lines: &[&str]) -> bool {
        // Generic parser can handle any log format as a fallback
        true
    }

    fn parse_line(&self, line: &str) -> ParsedLogLine {
        let mut parsed = ParsedLogLine {
            message: Some(line.to_string()),
            ..Default::default()
        };

        // Extract log level
        if let Some(caps) = LEVEL_REGEX.captures(line) {
            parsed.level = caps
                .get(1)
                .map_or_else(
                    || caps.get(0).map(|m| m.as_str().to_uppercase()),
                    |m| Some(m.as_str().to_uppercase()),
                )
                .map(|s| s.to_string());
        }

        // Extract timestamp
        if let Some(caps) = TIMESTAMP_REGEX.captures(line) {
            if let Some(m) = caps.get(1) {
                let ts = m.as_str();
                parsed.timestamp = Some(if ts.len() >= 13 {
                    ts[0..13].to_string()
                } else {
                    ts.to_string()
                });
            }
        }

        parsed
    }
}