1use crate::parser::ccm::naive_to_utc_millis;
2use regex::Regex;
3
4use super::severity::detect_severity_from_text;
5use crate::models::log_entry::{LogEntry, LogFormat};
6use std::sync::OnceLock;
7
8#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, serde::Serialize, serde::Deserialize)]
10pub enum DateOrder {
11 #[default]
13 MonthFirst,
14 DayFirst,
16}
17
18fn iso_re() -> &'static Regex {
24 static CELL: OnceLock<Regex> = OnceLock::new();
25 CELL.get_or_init(|| {
26 Regex::new(
27 r"^(\d{4})-(\d{2})-(\d{2})[T ](\d{1,2}):(\d{2}):(\d{2})([.,]\d+)?(Z|[+-]\d{2}:?\d{2})?\s*(.*)"
28 ).unwrap()
29})
30}
31
32fn slash_date_re() -> &'static Regex {
34 static CELL: OnceLock<Regex> = OnceLock::new();
35 CELL.get_or_init(|| {
36 Regex::new(
37 r"^(\d{1,2})/(\d{1,2})/(\d{4})\s+(\d{1,2}):(\d{2}):(\d{2})(\.\d+)?(\s*[AaPp][Mm])?\s+(.*)",
38 )
39 .unwrap()
40 })
41}
42
43fn syslog_re() -> &'static Regex {
45 static CELL: OnceLock<Regex> = OnceLock::new();
46 CELL.get_or_init(|| {
47 Regex::new(
48 r"^(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s+(\d{1,2})\s+(\d{2}):(\d{2}):(\d{2})\s+(.*)"
49 ).unwrap()
50})
51}
52
53fn time_only_re() -> &'static Regex {
55 static CELL: OnceLock<Regex> = OnceLock::new();
56 CELL.get_or_init(|| Regex::new(r"^(\d{2}):(\d{2}):(\d{2})([.,]\d+)?\s+(.*)").unwrap())
57}
58
59#[derive(Clone, Copy, PartialEq, Eq)]
65enum TimestampFormat {
66 Iso,
67 SlashDate,
68 Syslog,
69 TimeOnly,
70}
71
72fn parse_line_with_hint(
74 line: &str,
75 date_order: DateOrder,
76 hint: Option<TimestampFormat>,
77) -> Option<(LogEntry, TimestampFormat)> {
78 if let Some(fmt) = hint {
80 if let Some(entry) = match fmt {
81 TimestampFormat::Iso => try_iso(line),
82 TimestampFormat::SlashDate => try_slash_date(line, date_order),
83 TimestampFormat::Syslog => try_syslog(line),
84 TimestampFormat::TimeOnly => try_time_only(line),
85 } {
86 return Some((entry, fmt));
87 }
88 }
89
90 if let Some(entry) = try_iso(line) {
92 return Some((entry, TimestampFormat::Iso));
93 }
94 if let Some(entry) = try_slash_date(line, date_order) {
95 return Some((entry, TimestampFormat::SlashDate));
96 }
97 if let Some(entry) = try_syslog(line) {
98 return Some((entry, TimestampFormat::Syslog));
99 }
100 if let Some(entry) = try_time_only(line) {
101 return Some((entry, TimestampFormat::TimeOnly));
102 }
103 None
104}
105
106pub fn parse_lines(lines: &[&str], file_path: &str, date_order: DateOrder) -> (Vec<LogEntry>, u32) {
111 let mut entries = Vec::with_capacity(lines.len());
112 let mut parse_errors: u32 = 0;
113 let mut id: u64 = 0;
114 let mut format_hint: Option<TimestampFormat> = None;
115
116 for (i, line) in lines.iter().enumerate() {
117 let trimmed = line.trim();
118 if trimmed.is_empty() {
119 continue;
120 }
121
122 if let Some((mut entry, fmt)) = parse_line_with_hint(trimmed, date_order, format_hint) {
123 entry.id = id;
124 entry.line_number = (i + 1) as u32;
125 entry.file_path = file_path.to_string();
126 entries.push(entry);
127 format_hint = Some(fmt);
128 } else {
129 entries.push(LogEntry {
131 id,
132 line_number: (i + 1) as u32,
133 message: trimmed.to_string(),
134 component: None,
135 timestamp: None,
136 timestamp_display: None,
137 severity: detect_severity_from_text(trimmed),
138 thread: None,
139 thread_display: None,
140 source_file: None,
141 format: LogFormat::Timestamped,
142 file_path: file_path.to_string(),
143 timezone_offset: None,
144 error_code_spans: Vec::new(),
145 ip_address: None,
146 host_name: None,
147 mac_address: None,
148 result_code: None,
149 gle_code: None,
150 setup_phase: None,
151 operation_name: None,
152 http_method: None,
153 uri_stem: None,
154 uri_query: None,
155 status_code: None,
156 sub_status: None,
157 time_taken_ms: None,
158 client_ip: None,
159 server_ip: None,
160 user_agent: None,
161 server_port: None,
162 username: None,
163 win32_status: None,
164 query_name: None,
165 query_type: None,
166 response_code: None,
167 dns_direction: None,
168 dns_protocol: None,
169 source_ip: None,
170 dns_flags: None,
171 dns_event_id: None,
172 zone_name: None,
173 entry_kind: None,
174 whatif: None,
175 section_name: None,
176 section_color: None,
177 iteration: None,
178 tags: None,
179 });
180 parse_errors += 1;
181 }
182 id += 1;
183 }
184
185 (entries, parse_errors)
186}
187
188#[cfg(test)]
193fn parse_line(line: &str, date_order: DateOrder) -> Option<LogEntry> {
194 parse_line_with_hint(line, date_order, None).map(|(entry, _)| entry)
195}
196
197pub fn matches_any_timestamp(line: &str) -> bool {
199 iso_re().is_match(line)
200 || slash_date_re().is_match(line)
201 || syslog_re().is_match(line)
202 || time_only_re().is_match(line)
203}
204
205pub fn slash_date_first_field(line: &str) -> Option<u32> {
207 slash_date_re()
208 .captures(line)
209 .and_then(|caps| caps.get(1).and_then(|m| m.as_str().parse::<u32>().ok()))
210}
211
212fn try_iso(line: &str) -> Option<LogEntry> {
217 let caps = iso_re().captures(line)?;
218
219 let yr: i32 = caps.get(1)?.as_str().parse().ok()?;
220 let mon: u32 = caps.get(2)?.as_str().parse().ok()?;
221 let day: u32 = caps.get(3)?.as_str().parse().ok()?;
222 let h: u32 = caps.get(4)?.as_str().parse().ok()?;
223 let m: u32 = caps.get(5)?.as_str().parse().ok()?;
224 let s: u32 = caps.get(6)?.as_str().parse().ok()?;
225
226 let ms = parse_fractional_millis(caps.get(7).map(|m| m.as_str()));
227 let tz_offset = parse_tz_offset(caps.get(8).map(|m| m.as_str()));
228 let message = caps
229 .get(9)
230 .map(|m| m.as_str().to_string())
231 .unwrap_or_default();
232
233 let timestamp = chrono::NaiveDate::from_ymd_opt(yr, mon, day)
234 .and_then(|d| d.and_hms_milli_opt(h, m, s, ms))
235 .map(|naive| naive_to_utc_millis(naive, tz_offset));
236
237 let timestamp_display = Some(format!(
238 "{:04}-{:02}-{:02} {:02}:{:02}:{:02}.{:03}",
239 yr, mon, day, h, m, s, ms
240 ));
241
242 let severity = detect_severity_from_text(&message);
243
244 Some(LogEntry {
245 id: 0,
246 line_number: 0,
247 message,
248 component: None,
249 timestamp,
250 timestamp_display,
251 severity,
252 thread: None,
253 thread_display: None,
254 source_file: None,
255 format: LogFormat::Timestamped,
256 file_path: String::new(),
257 timezone_offset: tz_offset,
258 error_code_spans: Vec::new(),
259 ip_address: None,
260 host_name: None,
261 mac_address: None,
262 result_code: None,
263 gle_code: None,
264 setup_phase: None,
265 operation_name: None,
266 http_method: None,
267 uri_stem: None,
268 uri_query: None,
269 status_code: None,
270 sub_status: None,
271 time_taken_ms: None,
272 client_ip: None,
273 server_ip: None,
274 user_agent: None,
275 server_port: None,
276 username: None,
277 win32_status: None,
278 query_name: None,
279 query_type: None,
280 response_code: None,
281 dns_direction: None,
282 dns_protocol: None,
283 source_ip: None,
284 dns_flags: None,
285 dns_event_id: None,
286 zone_name: None,
287 entry_kind: None,
288 whatif: None,
289 section_name: None,
290 section_color: None,
291 iteration: None,
292 tags: None,
293 })
294}
295
296fn try_slash_date(line: &str, date_order: DateOrder) -> Option<LogEntry> {
297 let caps = slash_date_re().captures(line)?;
298
299 let field1: u32 = caps.get(1)?.as_str().parse().ok()?;
300 let field2: u32 = caps.get(2)?.as_str().parse().ok()?;
301 let yr: i32 = caps.get(3)?.as_str().parse().ok()?;
302
303 let (mon, day) = match date_order {
304 DateOrder::MonthFirst => (field1, field2),
305 DateOrder::DayFirst => (field2, field1),
306 };
307
308 let mut h: u32 = caps.get(4)?.as_str().parse().ok()?;
309 let m: u32 = caps.get(5)?.as_str().parse().ok()?;
310 let s: u32 = caps.get(6)?.as_str().parse().ok()?;
311
312 let ms = parse_fractional_millis(caps.get(7).map(|m| m.as_str()));
313
314 if let Some(ampm) = caps.get(8) {
316 let ampm_str = ampm.as_str().trim().to_uppercase();
317 if ampm_str == "PM" && h < 12 {
318 h += 12;
319 } else if ampm_str == "AM" && h == 12 {
320 h = 0;
321 }
322 }
323
324 let message = caps
325 .get(9)
326 .map(|m| m.as_str().to_string())
327 .unwrap_or_default();
328
329 let timestamp = chrono::NaiveDate::from_ymd_opt(yr, mon, day)
330 .and_then(|d| d.and_hms_milli_opt(h, m, s, ms))
331 .map(|dt| dt.and_utc().timestamp_millis());
332
333 let timestamp_display = Some(format!(
334 "{:04}-{:02}-{:02} {:02}:{:02}:{:02}.{:03}",
335 yr, mon, day, h, m, s, ms
336 ));
337
338 let severity = detect_severity_from_text(&message);
339
340 Some(LogEntry {
341 id: 0,
342 line_number: 0,
343 message,
344 component: None,
345 timestamp,
346 timestamp_display,
347 severity,
348 thread: None,
349 thread_display: None,
350 source_file: None,
351 format: LogFormat::Timestamped,
352 file_path: String::new(),
353 timezone_offset: None,
354 error_code_spans: Vec::new(),
355 ip_address: None,
356 host_name: None,
357 mac_address: None,
358 result_code: None,
359 gle_code: None,
360 setup_phase: None,
361 operation_name: None,
362 http_method: None,
363 uri_stem: None,
364 uri_query: None,
365 status_code: None,
366 sub_status: None,
367 time_taken_ms: None,
368 client_ip: None,
369 server_ip: None,
370 user_agent: None,
371 server_port: None,
372 username: None,
373 win32_status: None,
374 query_name: None,
375 query_type: None,
376 response_code: None,
377 dns_direction: None,
378 dns_protocol: None,
379 source_ip: None,
380 dns_flags: None,
381 dns_event_id: None,
382 zone_name: None,
383 entry_kind: None,
384 whatif: None,
385 section_name: None,
386 section_color: None,
387 iteration: None,
388 tags: None,
389 })
390}
391
392fn try_syslog(line: &str) -> Option<LogEntry> {
393 let caps = syslog_re().captures(line)?;
394
395 let month_str = caps.get(1)?.as_str();
396 let day: u32 = caps.get(2)?.as_str().parse().ok()?;
397 let h: u32 = caps.get(3)?.as_str().parse().ok()?;
398 let m: u32 = caps.get(4)?.as_str().parse().ok()?;
399 let s: u32 = caps.get(5)?.as_str().parse().ok()?;
400 let message = caps
401 .get(6)
402 .map(|m| m.as_str().to_string())
403 .unwrap_or_default();
404
405 let mon = month_name_to_number(month_str)?;
406 let yr = chrono::Local::now()
407 .format("%Y")
408 .to_string()
409 .parse::<i32>()
410 .unwrap_or(2024);
411
412 let timestamp = chrono::NaiveDate::from_ymd_opt(yr, mon, day)
413 .and_then(|d| d.and_hms_opt(h, m, s))
414 .map(|dt| dt.and_utc().timestamp_millis());
415
416 let timestamp_display = Some(format!(
417 "{:04}-{:02}-{:02} {:02}:{:02}:{:02}.000",
418 yr, mon, day, h, m, s
419 ));
420
421 let severity = detect_severity_from_text(&message);
422
423 Some(LogEntry {
424 id: 0,
425 line_number: 0,
426 message,
427 component: None,
428 timestamp,
429 timestamp_display,
430 severity,
431 thread: None,
432 thread_display: None,
433 source_file: None,
434 format: LogFormat::Timestamped,
435 file_path: String::new(),
436 timezone_offset: None,
437 error_code_spans: Vec::new(),
438 ip_address: None,
439 host_name: None,
440 mac_address: None,
441 result_code: None,
442 gle_code: None,
443 setup_phase: None,
444 operation_name: None,
445 http_method: None,
446 uri_stem: None,
447 uri_query: None,
448 status_code: None,
449 sub_status: None,
450 time_taken_ms: None,
451 client_ip: None,
452 server_ip: None,
453 user_agent: None,
454 server_port: None,
455 username: None,
456 win32_status: None,
457 query_name: None,
458 query_type: None,
459 response_code: None,
460 dns_direction: None,
461 dns_protocol: None,
462 source_ip: None,
463 dns_flags: None,
464 dns_event_id: None,
465 zone_name: None,
466 entry_kind: None,
467 whatif: None,
468 section_name: None,
469 section_color: None,
470 iteration: None,
471 tags: None,
472 })
473}
474
475fn try_time_only(line: &str) -> Option<LogEntry> {
476 let caps = time_only_re().captures(line)?;
477
478 let h: u32 = caps.get(1)?.as_str().parse().ok()?;
479 let m: u32 = caps.get(2)?.as_str().parse().ok()?;
480 let s: u32 = caps.get(3)?.as_str().parse().ok()?;
481 let ms = parse_fractional_millis(caps.get(4).map(|m| m.as_str()));
482 let message = caps
483 .get(5)
484 .map(|m| m.as_str().to_string())
485 .unwrap_or_default();
486
487 if h >= 24 || m >= 60 || s >= 60 {
489 return None;
490 }
491
492 let timestamp_display = Some(format!("{:02}:{:02}:{:02}.{:03}", h, m, s, ms));
493
494 let severity = detect_severity_from_text(&message);
495
496 Some(LogEntry {
497 id: 0,
498 line_number: 0,
499 message,
500 component: None,
501 timestamp: None, timestamp_display,
503 severity,
504 thread: None,
505 thread_display: None,
506 source_file: None,
507 format: LogFormat::Timestamped,
508 file_path: String::new(),
509 timezone_offset: None,
510 error_code_spans: Vec::new(),
511 ip_address: None,
512 host_name: None,
513 mac_address: None,
514 result_code: None,
515 gle_code: None,
516 setup_phase: None,
517 operation_name: None,
518 http_method: None,
519 uri_stem: None,
520 uri_query: None,
521 status_code: None,
522 sub_status: None,
523 time_taken_ms: None,
524 client_ip: None,
525 server_ip: None,
526 user_agent: None,
527 server_port: None,
528 username: None,
529 win32_status: None,
530 query_name: None,
531 query_type: None,
532 response_code: None,
533 dns_direction: None,
534 dns_protocol: None,
535 source_ip: None,
536 dns_flags: None,
537 dns_event_id: None,
538 zone_name: None,
539 entry_kind: None,
540 whatif: None,
541 section_name: None,
542 section_color: None,
543 iteration: None,
544 tags: None,
545 })
546}
547
548fn parse_fractional_millis(frac: Option<&str>) -> u32 {
554 match frac {
555 Some(s) => {
556 let digits = s.trim_start_matches(['.', ',']);
558 let padded = format!("{:0<3}", digits);
560 padded[..3].parse::<u32>().unwrap_or(0)
561 }
562 None => 0,
563 }
564}
565
566fn parse_tz_offset(tz: Option<&str>) -> Option<i32> {
569 match tz {
570 None => None,
571 Some("Z") | Some("z") => Some(0),
572 Some(s) => {
573 let sign: i32 = if s.starts_with('-') { -1 } else { 1 };
574 let digits = s.trim_start_matches(['+', '-']);
575 let clean = digits.replace(':', "");
576 if clean.len() >= 4 {
577 let hours: i32 = clean[..2].parse().ok()?;
578 let mins: i32 = clean[2..4].parse().ok()?;
579 Some(sign * (hours * 60 + mins))
580 } else {
581 None
582 }
583 }
584 }
585}
586
587fn month_name_to_number(name: &str) -> Option<u32> {
588 match name {
589 "Jan" => Some(1),
590 "Feb" => Some(2),
591 "Mar" => Some(3),
592 "Apr" => Some(4),
593 "May" => Some(5),
594 "Jun" => Some(6),
595 "Jul" => Some(7),
596 "Aug" => Some(8),
597 "Sep" => Some(9),
598 "Oct" => Some(10),
599 "Nov" => Some(11),
600 "Dec" => Some(12),
601 _ => None,
602 }
603}
604
605#[cfg(test)]
606mod tests {
607 use super::*;
608 use crate::models::log_entry::Severity;
609 use chrono::FixedOffset;
610 use chrono::TimeZone;
611
612 #[test]
613 fn test_iso_with_z() {
614 let entry = parse_line(
615 "2024-01-15T14:30:00.123Z Error: connection refused",
616 DateOrder::MonthFirst,
617 )
618 .unwrap();
619 assert_eq!(
620 entry.timestamp_display.as_deref(),
621 Some("2024-01-15 14:30:00.123")
622 );
623 assert!(entry.message.contains("connection refused"));
624 assert_eq!(entry.severity, Severity::Error);
625 assert_eq!(entry.timezone_offset, Some(0));
626 }
627
628 #[test]
629 fn test_iso_with_offset() {
630 let entry = parse_line(
631 "2024-01-15T14:30:00.000+05:30 Starting service",
632 DateOrder::MonthFirst,
633 )
634 .unwrap();
635 assert_eq!(entry.timezone_offset, Some(330));
636 assert_eq!(entry.severity, Severity::Info);
637 let expected_ts = FixedOffset::east_opt(330 * 60)
639 .unwrap()
640 .from_local_datetime(
641 &chrono::NaiveDate::from_ymd_opt(2024, 1, 15)
642 .unwrap()
643 .and_hms_milli_opt(14, 30, 0, 0)
644 .unwrap(),
645 )
646 .single()
647 .unwrap()
648 .timestamp_millis();
649 assert_eq!(entry.timestamp, Some(expected_ts));
650 }
651
652 #[test]
653 fn test_iso_space_separator() {
654 let entry = parse_line(
655 "2024-01-15 14:30:00,456 WARNING: disk space low",
656 DateOrder::MonthFirst,
657 )
658 .unwrap();
659 assert_eq!(
660 entry.timestamp_display.as_deref(),
661 Some("2024-01-15 14:30:00.456")
662 );
663 assert_eq!(entry.severity, Severity::Warning);
664 }
665
666 #[test]
667 fn test_iso_no_fractional() {
668 let entry = parse_line("2024-01-15T14:30:00 Ready", DateOrder::MonthFirst).unwrap();
669 assert_eq!(
670 entry.timestamp_display.as_deref(),
671 Some("2024-01-15 14:30:00.000")
672 );
673 }
674
675 #[test]
676 fn test_us_date() {
677 let entry = parse_line(
678 "01/15/2024 14:30:00 Processing request",
679 DateOrder::MonthFirst,
680 )
681 .unwrap();
682 assert_eq!(
683 entry.timestamp_display.as_deref(),
684 Some("2024-01-15 14:30:00.000")
685 );
686 }
687
688 #[test]
689 fn test_us_date_with_ampm() {
690 let entry =
691 parse_line("1/15/2024 2:30:00 PM Task completed", DateOrder::MonthFirst).unwrap();
692 assert_eq!(
693 entry.timestamp_display.as_deref(),
694 Some("2024-01-15 14:30:00.000")
695 );
696 }
697
698 #[test]
699 fn test_eu_date() {
700 let entry = parse_line(
701 "15/01/2024 14:30:00 Processing request",
702 DateOrder::DayFirst,
703 )
704 .unwrap();
705 assert_eq!(
706 entry.timestamp_display.as_deref(),
707 Some("2024-01-15 14:30:00.000")
708 );
709 }
710
711 #[test]
712 fn test_syslog() {
713 let entry = parse_line(
714 "Jan 15 14:30:00 myhost kernel: NIC Link is Up",
715 DateOrder::MonthFirst,
716 )
717 .unwrap();
718 assert!(entry
719 .timestamp_display
720 .as_deref()
721 .unwrap()
722 .contains("14:30:00"));
723 assert!(entry.message.contains("myhost"));
724 assert_eq!(entry.format, LogFormat::Timestamped);
725 }
726
727 #[test]
728 fn test_time_only() {
729 let entry = parse_line("14:30:00.123 Initializing module", DateOrder::MonthFirst).unwrap();
730 assert!(entry.timestamp.is_none());
731 assert_eq!(entry.timestamp_display.as_deref(), Some("14:30:00.123"));
732 }
733
734 #[test]
735 fn test_no_timestamp() {
736 assert!(parse_line("Just some plain text", DateOrder::MonthFirst).is_none());
737 }
738
739 #[test]
740 fn test_am_midnight() {
741 let entry = parse_line(
742 "1/15/2024 12:30:00 AM Midnight event",
743 DateOrder::MonthFirst,
744 )
745 .unwrap();
746 assert_eq!(
748 entry.timestamp_display.as_deref(),
749 Some("2024-01-15 00:30:00.000")
750 );
751 }
752
753 #[test]
754 fn test_parse_fractional_millis_helper() {
755 assert_eq!(parse_fractional_millis(Some(".123")), 123);
756 assert_eq!(parse_fractional_millis(Some(",456789")), 456);
757 assert_eq!(parse_fractional_millis(Some(".1")), 100);
758 assert_eq!(parse_fractional_millis(None), 0);
759 }
760
761 #[test]
762 fn test_parse_tz_offset_helper() {
763 assert_eq!(parse_tz_offset(Some("Z")), Some(0));
764 assert_eq!(parse_tz_offset(Some("+05:30")), Some(330));
765 assert_eq!(parse_tz_offset(Some("-0800")), Some(-480));
766 assert_eq!(parse_tz_offset(None), None);
767 }
768
769 #[test]
770 fn test_matches_any_timestamp() {
771 assert!(matches_any_timestamp("2024-01-15T14:30:00Z Starting"));
772 assert!(matches_any_timestamp("01/15/2024 14:30:00 Test"));
773 assert!(matches_any_timestamp("Jan 15 14:30:00 syslog message"));
774 assert!(matches_any_timestamp("14:30:00 time only"));
775 assert!(!matches_any_timestamp("Just plain text"));
776 }
777
778 #[test]
779 fn test_slash_date_first_field() {
780 assert_eq!(slash_date_first_field("25/01/2024 14:30:00 test"), Some(25));
781 assert_eq!(slash_date_first_field("01/15/2024 14:30:00 test"), Some(1));
782 assert_eq!(slash_date_first_field("plain text"), None);
783 }
784
785 #[test]
786 fn test_invalid_time_only_rejected() {
787 assert!(parse_line("25:00:00 invalid time", DateOrder::MonthFirst).is_none());
789 }
790}