Skip to main content

cmtraceopen_parser/parser/
simple.rs

1//! Simple/legacy format parser.
2//!
3//! Parses log lines in the format:
4//!   message text$$<ComponentName><MM-dd-yyyy HH:mm:ss.fff+TTTTT><thread=N (0xNNNN)>
5//!
6//! This format has no type/severity field — severity is detected by
7//! searching for "error", "fail" (excluding "failover"), and "warn"
8//! in the message text, matching CMTrace's binary behavior.
9
10use regex::Regex;
11
12use super::ccm::{build_timestamp, format_thread_display};
13use super::severity::detect_severity_from_text;
14use crate::models::log_entry::{LogEntry, LogFormat, Severity};
15use std::sync::OnceLock;
16
17/// Combined regex for timestamp and thread portions in a single pass.
18/// Matches: <MM-dd-yyyy HH:mm:ss.fff±TTTTT><thread=N (0xNNNN)>
19/// The thread group is optional to handle lines without thread info.
20fn meta_re() -> &'static Regex {
21    static CELL: OnceLock<Regex> = OnceLock::new();
22    CELL.get_or_init(|| {
23        Regex::new(concat!(
24            r#"<(\d{1,2})-(\d{1,2})-(\d{4})\s+(\d{1,2}):(\d{1,2}):(\d{1,2})\.(\d+)([+-]?\d+)>"#,
25            r#"(?:<thread=(\d+)(?:\s*\(0x[0-9a-fA-F]+\))?>)?"#,
26        ))
27        .expect("Simple metadata regex must compile")
28    })
29}
30
31/// Parse a single simple-format log line.
32fn parse_line(line: &str) -> Option<SimpleParsed> {
33    // Split on "$$<" — everything before is the message
34    let dollar_pos = line.find("$$<")?;
35    let message = line[..dollar_pos].trim_end().to_string();
36    let metadata = &line[dollar_pos + 3..]; // skip "$$<"
37
38    // Extract component: first <...> block
39    let comp_end = metadata.find('>')?;
40    let component = metadata[..comp_end].to_string();
41    let rest = &metadata[comp_end + 1..];
42
43    // Single regex pass extracts both timestamp and thread
44    let caps = meta_re().captures(rest)?;
45    let mon: u32 = caps.get(1)?.as_str().parse().ok()?;
46    let day: u32 = caps.get(2)?.as_str().parse().ok()?;
47    let yr: i32 = caps.get(3)?.as_str().parse().ok()?;
48    let h: u32 = caps.get(4)?.as_str().parse().ok()?;
49    let m: u32 = caps.get(5)?.as_str().parse().ok()?;
50    let s: u32 = caps.get(6)?.as_str().parse().ok()?;
51    let ms_str = caps.get(7)?.as_str();
52    let ms: u32 = if ms_str.len() > 3 {
53        ms_str[..3].parse().ok()?
54    } else {
55        ms_str.parse().ok()?
56    };
57    let tz: i32 = caps.get(8)?.as_str().parse().ok()?;
58
59    // Thread is optional (captured by the combined regex)
60    let thread = caps.get(9).and_then(|m| m.as_str().parse::<u32>().ok());
61
62    let (timestamp, timestamp_display) = build_timestamp(mon, day, yr, h, m, s, ms, Some(tz));
63
64    // Reuse cached thread display from ccm module
65    let thread_display = thread.map(format_thread_display);
66
67    // Text-based severity detection (no type field in simple format)
68    let severity = detect_severity_from_text(&message);
69
70    Some(SimpleParsed {
71        message,
72        component,
73        timestamp,
74        timestamp_display,
75        severity,
76        thread,
77        thread_display,
78        timezone_offset: tz,
79    })
80}
81
82struct SimpleParsed {
83    message: String,
84    component: String,
85    timestamp: Option<i64>,
86    timestamp_display: Option<String>,
87    severity: Severity,
88    thread: Option<u32>,
89    thread_display: Option<String>,
90    timezone_offset: i32,
91}
92
93/// Parse all lines as simple format.
94pub fn parse_lines(lines: &[&str], file_path: &str) -> (Vec<LogEntry>, u32) {
95    let mut entries = Vec::with_capacity(lines.len());
96    let mut errors = 0u32;
97    let mut id_counter = 0u64;
98
99    for (i, line) in lines.iter().enumerate() {
100        if line.trim().is_empty() {
101            continue;
102        }
103
104        match parse_line(line) {
105            Some(parsed) => {
106                entries.push(LogEntry {
107                    id: id_counter,
108                    line_number: (i + 1) as u32,
109                    message: parsed.message,
110                    component: Some(parsed.component),
111                    timestamp: parsed.timestamp,
112                    timestamp_display: parsed.timestamp_display,
113                    severity: parsed.severity,
114                    thread: parsed.thread,
115                    thread_display: parsed.thread_display,
116                    source_file: None,
117                    format: LogFormat::Simple,
118                    file_path: file_path.to_string(),
119                    timezone_offset: Some(parsed.timezone_offset),
120                    error_code_spans: Vec::new(),
121                    ip_address: None,
122                    host_name: None,
123                    mac_address: None,
124                    result_code: None,
125                    gle_code: None,
126                    setup_phase: None,
127                    operation_name: None,
128                    http_method: None,
129                    uri_stem: None,
130                    uri_query: None,
131                    status_code: None,
132                    sub_status: None,
133                    time_taken_ms: None,
134                    client_ip: None,
135                    server_ip: None,
136                    user_agent: None,
137                    server_port: None,
138                    username: None,
139                    win32_status: None,
140                    query_name: None,
141                    query_type: None,
142                    response_code: None,
143                    dns_direction: None,
144                    dns_protocol: None,
145                    source_ip: None,
146                    dns_flags: None,
147                    dns_event_id: None,
148                    zone_name: None,
149                    entry_kind: None,
150                    whatif: None,
151                    section_name: None,
152                    section_color: None,
153                    iteration: None,
154                    tags: None,
155                });
156                id_counter += 1;
157            }
158            None => {
159                // Doesn't match simple format — treat as plain text
160                entries.push(LogEntry {
161                    id: id_counter,
162                    line_number: (i + 1) as u32,
163                    message: line.to_string(),
164                    component: None,
165                    timestamp: None,
166                    timestamp_display: None,
167                    severity: detect_severity_from_text(line),
168                    thread: None,
169                    thread_display: None,
170                    source_file: None,
171                    format: LogFormat::Plain,
172                    file_path: file_path.to_string(),
173                    timezone_offset: None,
174                    error_code_spans: Vec::new(),
175                    ip_address: None,
176                    host_name: None,
177                    mac_address: None,
178                    result_code: None,
179                    gle_code: None,
180                    setup_phase: None,
181                    operation_name: None,
182                    http_method: None,
183                    uri_stem: None,
184                    uri_query: None,
185                    status_code: None,
186                    sub_status: None,
187                    time_taken_ms: None,
188                    client_ip: None,
189                    server_ip: None,
190                    user_agent: None,
191                    server_port: None,
192                    username: None,
193                    win32_status: None,
194                    query_name: None,
195                    query_type: None,
196                    response_code: None,
197                    dns_direction: None,
198                    dns_protocol: None,
199                    source_ip: None,
200                    dns_flags: None,
201                    dns_event_id: None,
202                    zone_name: None,
203                    entry_kind: None,
204                    whatif: None,
205                    section_name: None,
206                    section_color: None,
207                    iteration: None,
208                    tags: None,
209                });
210                id_counter += 1;
211                errors += 1;
212            }
213        }
214    }
215
216    (entries, errors)
217}
218
219#[cfg(test)]
220mod tests {
221    use super::*;
222
223    #[test]
224    fn test_parse_simple_line() {
225        let line = r#"Sending status message (MessageID = 500). $$<SMS_HIERARCHY_MANAGER><07-15-2023 09:12:45.332+240><thread=4116 (0x1014)>"#;
226        let parsed = parse_line(line).expect("should parse");
227        assert_eq!(parsed.message, "Sending status message (MessageID = 500).");
228        assert_eq!(parsed.component, "SMS_HIERARCHY_MANAGER");
229        assert_eq!(parsed.thread, Some(4116));
230        assert_eq!(parsed.severity, Severity::Info);
231        assert_eq!(parsed.timezone_offset, 240);
232        // Verify epoch millis: 09:12:45.332 at UTC+4 = 05:12:45.332 UTC
233        let expected_ts = chrono::NaiveDate::from_ymd_opt(2023, 7, 15)
234            .unwrap()
235            .and_hms_milli_opt(5, 12, 45, 332)
236            .unwrap()
237            .and_utc()
238            .timestamp_millis();
239        assert_eq!(parsed.timestamp, Some(expected_ts));
240    }
241
242    #[test]
243    fn test_parse_simple_error() {
244        let line = r#"An error occurred during processing $$<TestComp><01-01-2024 10:00:00.000+000><thread=100>"#;
245        let parsed = parse_line(line).expect("should parse");
246        assert_eq!(parsed.severity, Severity::Error);
247    }
248}