Skip to main content

cmtraceopen_parser/parser/
timestamped.rs

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/// Controls whether slash-date fields are interpreted as MM/DD or DD/MM.
9#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, serde::Serialize, serde::Deserialize)]
10pub enum DateOrder {
11    /// US style: first field is month (MM/DD/YYYY)
12    #[default]
13    MonthFirst,
14    /// European style: first field is day (DD/MM/YYYY)
15    DayFirst,
16}
17
18// ---------------------------------------------------------------------------
19// Lazy-compiled regex patterns
20// ---------------------------------------------------------------------------
21
22/// ISO 8601: 2024-01-15T14:30:00.123Z or 2024-01-15 14:30:00,456+05:30
23fn 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
32/// Slash-date: 01/15/2024 14:30:00.123 or 1/15/2024 2:30:00 PM
33fn 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
43/// Syslog: Jan 15 14:30:00 hostname ...
44fn 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
53/// Time-only: 14:30:00.123 message...
54fn 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// ---------------------------------------------------------------------------
60// Public API — matches same pattern as ccm/simple/plain parsers
61// ---------------------------------------------------------------------------
62
63/// Which timestamp pattern matched — used to try the same pattern first on subsequent lines.
64#[derive(Clone, Copy, PartialEq, Eq)]
65enum TimestampFormat {
66    Iso,
67    SlashDate,
68    Syslog,
69    TimeOnly,
70}
71
72/// Try a specific pattern first, then fall back to the full search.
73fn parse_line_with_hint(
74    line: &str,
75    date_order: DateOrder,
76    hint: Option<TimestampFormat>,
77) -> Option<(LogEntry, TimestampFormat)> {
78    // Try the hinted format first (common case: same format as previous line)
79    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    // Full search in priority order
91    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
106/// Parse all lines, extracting timestamps where possible.
107/// Lines that don't match any timestamp pattern are included as plain-text entries.
108/// Caches the detected format from the first match and tries it first on subsequent
109/// lines, avoiding up to 3 wasted regex attempts per line.
110pub 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            // Fallback: treat as plain text with severity detection
130            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// ---------------------------------------------------------------------------
189// Internal — try each pattern in priority order
190// ---------------------------------------------------------------------------
191
192#[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
197/// Check whether a line matches any supported timestamp pattern (used by detect.rs).
198pub 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
205/// Check whether a slash-date line has first field > 12, indicating day-first order.
206pub 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
212// ---------------------------------------------------------------------------
213// Pattern matchers
214// ---------------------------------------------------------------------------
215
216fn 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    // Handle AM/PM
315    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    // Validate time values
488    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, // No date → no unix timestamp
502        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
548// ---------------------------------------------------------------------------
549// Helpers
550// ---------------------------------------------------------------------------
551
552/// Parse fractional seconds like ".123", ",456789" → milliseconds (truncated to 3 digits).
553fn parse_fractional_millis(frac: Option<&str>) -> u32 {
554    match frac {
555        Some(s) => {
556            // Strip leading '.' or ','
557            let digits = s.trim_start_matches(['.', ',']);
558            // Pad or truncate to 3 digits
559            let padded = format!("{:0<3}", digits);
560            padded[..3].parse::<u32>().unwrap_or(0)
561        }
562        None => 0,
563    }
564}
565
566/// Parse timezone offset string → minutes.
567/// Examples: "Z" → Some(0), "+05:30" → Some(330), "-08:00" → Some(-480), "+0530" → Some(330)
568fn 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        // Verify the epoch millis are correct: 14:30 at UTC+5:30 = 09:00 UTC
638        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        // 12 AM = 0 hours
747        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        // 25:00:00 is not a valid time
788        assert!(parse_line("25:00:00 invalid time", DateOrder::MonthFirst).is_none());
789    }
790}