cmtraceopen_parser/parser/
simple.rs1use 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
17fn 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
31fn parse_line(line: &str) -> Option<SimpleParsed> {
33 let dollar_pos = line.find("$$<")?;
35 let message = line[..dollar_pos].trim_end().to_string();
36 let metadata = &line[dollar_pos + 3..]; let comp_end = metadata.find('>')?;
40 let component = metadata[..comp_end].to_string();
41 let rest = &metadata[comp_end + 1..];
42
43 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 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 let thread_display = thread.map(format_thread_display);
66
67 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
93pub 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 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 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}