Skip to main content

cmtraceopen_parser/parser/
intune_macos.rs

1//! macOS Intune MDM Daemon log parser.
2//!
3//! Parses pipe-delimited log lines in the format:
4//!   YYYY-MM-DD HH:MM:SS:mmm | Process | Severity | ThreadID | SubComponent | Message
5//!
6//! Example:
7//!   2026-03-23 12:51:11:888 | IntuneMDM-Daemon | I | 11054604 | SyncActivityTracer | Reporting results Context: network observer
8
9use regex::Regex;
10
11use crate::models::log_entry::{LogEntry, LogFormat, Severity};
12use std::sync::OnceLock;
13
14/// Regex matching the pipe-delimited macOS Intune log format.
15/// Groups: year, month, day, hour, minute, second, millis, process, severity, thread, subcomponent, message
16fn intune_macos_re() -> &'static Regex {
17    static CELL: OnceLock<Regex> = OnceLock::new();
18    CELL.get_or_init(|| {
19        Regex::new(concat!(
20            r"^(\d{4})-(\d{2})-(\d{2})\s+(\d{2}):(\d{2}):(\d{2}):(\d{3})",
21            r"\s*\|\s*([^|]+?)\s*", // process
22            r"\|\s*([A-Z])\s*",     // severity letter
23            r"\|\s*(\d+)\s*",       // thread ID
24            r"\|\s*([^|]+?)\s*",    // sub-component
25            r"\|\s*(.*)",           // message (rest of line)
26        ))
27        .expect("Intune macOS regex must compile")
28    })
29}
30
31/// Check if a line matches the macOS Intune pipe-delimited format (used by detect.rs).
32pub fn matches_intune_macos(line: &str) -> bool {
33    intune_macos_re().is_match(line)
34}
35
36fn severity_from_letter(letter: &str) -> Severity {
37    match letter {
38        "E" => Severity::Error,
39        "W" => Severity::Warning,
40        _ => Severity::Info,
41    }
42}
43
44/// Parse all lines as macOS Intune pipe-delimited format.
45pub fn parse_lines(lines: &[&str], file_path: &str) -> (Vec<LogEntry>, u32) {
46    let mut entries = Vec::with_capacity(lines.len());
47    let mut parse_errors: u32 = 0;
48    let mut id: u64 = 0;
49
50    for (i, line) in lines.iter().enumerate() {
51        let trimmed = line.trim();
52        if trimmed.is_empty() {
53            continue;
54        }
55
56        if let Some(caps) = intune_macos_re().captures(trimmed) {
57            let yr: i32 = caps.get(1).unwrap().as_str().parse().unwrap_or(2024);
58            let mon: u32 = caps.get(2).unwrap().as_str().parse().unwrap_or(1);
59            let day: u32 = caps.get(3).unwrap().as_str().parse().unwrap_or(1);
60            let h: u32 = caps.get(4).unwrap().as_str().parse().unwrap_or(0);
61            let m: u32 = caps.get(5).unwrap().as_str().parse().unwrap_or(0);
62            let s: u32 = caps.get(6).unwrap().as_str().parse().unwrap_or(0);
63            let ms: u32 = caps.get(7).unwrap().as_str().parse().unwrap_or(0);
64
65            let component = caps.get(8).map(|m| m.as_str().trim().to_string());
66            let severity_str = caps.get(9).map(|m| m.as_str()).unwrap_or("I");
67            let thread: Option<u32> = caps.get(10).and_then(|m| m.as_str().parse().ok());
68            let source_file = caps.get(11).map(|m| m.as_str().trim().to_string());
69            let message = caps
70                .get(12)
71                .map(|m| m.as_str().trim().to_string())
72                .unwrap_or_default();
73
74            let severity = severity_from_letter(severity_str);
75
76            let timestamp = chrono::NaiveDate::from_ymd_opt(yr, mon, day)
77                .and_then(|d| d.and_hms_milli_opt(h, m, s, ms))
78                .map(|dt| dt.and_utc().timestamp_millis());
79
80            let timestamp_display = Some(format!(
81                "{:04}-{:02}-{:02} {:02}:{:02}:{:02}.{:03}",
82                yr, mon, day, h, m, s, ms
83            ));
84
85            let thread_display = thread.map(super::ccm::format_thread_display);
86
87            entries.push(LogEntry {
88                id,
89                line_number: (i + 1) as u32,
90                message,
91                component,
92                timestamp,
93                timestamp_display,
94                severity,
95                thread,
96                thread_display,
97                source_file,
98                format: LogFormat::Timestamped,
99                file_path: file_path.to_string(),
100                timezone_offset: None,
101                error_code_spans: Vec::new(),
102                ip_address: None,
103                host_name: None,
104                mac_address: None,
105                result_code: None,
106                gle_code: None,
107                setup_phase: None,
108                operation_name: None,
109                http_method: None,
110                uri_stem: None,
111                uri_query: None,
112                status_code: None,
113                sub_status: None,
114                time_taken_ms: None,
115                client_ip: None,
116                server_ip: None,
117                user_agent: None,
118                server_port: None,
119                username: None,
120                win32_status: None,
121                query_name: None,
122                query_type: None,
123                response_code: None,
124                dns_direction: None,
125                dns_protocol: None,
126                source_ip: None,
127                dns_flags: None,
128                dns_event_id: None,
129                zone_name: None,
130                entry_kind: None,
131                whatif: None,
132                section_name: None,
133                section_color: None,
134                iteration: None,
135                tags: None,
136            });
137        } else {
138            // Non-matching line (e.g., continuation/JSON dump) — plain text
139            entries.push(LogEntry {
140                id,
141                line_number: (i + 1) as u32,
142                message: trimmed.to_string(),
143                component: None,
144                timestamp: None,
145                timestamp_display: None,
146                severity: super::severity::detect_severity_from_text(trimmed),
147                thread: None,
148                thread_display: None,
149                source_file: None,
150                format: LogFormat::Plain,
151                file_path: file_path.to_string(),
152                timezone_offset: None,
153                error_code_spans: Vec::new(),
154                ip_address: None,
155                host_name: None,
156                mac_address: None,
157                result_code: None,
158                gle_code: None,
159                setup_phase: None,
160                operation_name: None,
161                http_method: None,
162                uri_stem: None,
163                uri_query: None,
164                status_code: None,
165                sub_status: None,
166                time_taken_ms: None,
167                client_ip: None,
168                server_ip: None,
169                user_agent: None,
170                server_port: None,
171                username: None,
172                win32_status: None,
173                query_name: None,
174                query_type: None,
175                response_code: None,
176                dns_direction: None,
177                dns_protocol: None,
178                source_ip: None,
179                dns_flags: None,
180                dns_event_id: None,
181                zone_name: None,
182                entry_kind: None,
183                whatif: None,
184                section_name: None,
185                section_color: None,
186                iteration: None,
187                tags: None,
188            });
189            parse_errors += 1;
190        }
191        id += 1;
192    }
193
194    (entries, parse_errors)
195}
196
197#[cfg(test)]
198mod tests {
199    use super::*;
200
201    #[test]
202    fn test_parse_intune_macos_line() {
203        let lines = vec![
204            "2026-03-23 12:51:11:888 | IntuneMDM-Daemon | I | 11054604 | SyncActivityTracer | Reporting results Context: network observer",
205        ];
206        let (entries, errors) = parse_lines(&lines, "test.log");
207        assert_eq!(errors, 0);
208        assert_eq!(entries.len(), 1);
209        assert_eq!(entries[0].component.as_deref(), Some("IntuneMDM-Daemon"));
210        assert_eq!(entries[0].severity, Severity::Info);
211        assert_eq!(entries[0].thread, Some(11054604));
212        assert_eq!(
213            entries[0].message,
214            "Reporting results Context: network observer"
215        );
216        assert!(entries[0].source_file.as_deref() == Some("SyncActivityTracer"));
217    }
218
219    #[test]
220    fn test_parse_error_severity() {
221        let lines = vec![
222            "2026-03-23 12:51:11:888 | IntuneMDM-Daemon | E | 100 | AppInstaller | Installation failed",
223        ];
224        let (entries, _) = parse_lines(&lines, "test.log");
225        assert_eq!(entries[0].severity, Severity::Error);
226    }
227
228    #[test]
229    fn test_parse_warning_severity() {
230        let lines = vec![
231            "2026-03-23 12:51:11:888 | IntuneMDM-Daemon | W | 100 | AppInstaller | Retry needed",
232        ];
233        let (entries, _) = parse_lines(&lines, "test.log");
234        assert_eq!(entries[0].severity, Severity::Warning);
235    }
236
237    #[test]
238    fn test_matches_intune_macos() {
239        assert!(matches_intune_macos(
240            "2026-03-23 12:51:11:888 | IntuneMDM-Daemon | I | 11054604 | SyncActivityTracer | test"
241        ));
242        assert!(!matches_intune_macos("Just plain text"));
243        assert!(!matches_intune_macos(
244            "2024-01-15T14:30:00Z Error: connection refused"
245        ));
246    }
247}