Skip to main content

cmtraceopen_parser/parser/
burn.rs

1//! WiX/Burn bootstrapper log parser.
2//!
3//! Parses log lines in the format:
4//!   [PID:TID][YYYY-MM-DDTHH:MM:SS]sNNN: message
5//!
6//! Where s = severity letter (i=info, w=warning, e=error), NNN = message code.
7//!
8//! Examples:
9//!   [07A4:0CBC][2025-11-25T01:55:42]i001: Burn v3.14.1.8722, Windows v10.0
10//!   [07A4:0CBC][2025-11-25T01:55:42]e000: Error 0x80070005: Failed to ...
11
12use regex::Regex;
13
14use crate::models::log_entry::{LogEntry, LogFormat, Severity};
15use std::sync::OnceLock;
16
17/// Regex matching the WiX/Burn bootstrapper log format.
18/// Groups: pid(hex), tid(hex), timestamp(ISO), severity(letter), code(3digits), message
19fn burn_re() -> &'static Regex {
20    static CELL: OnceLock<Regex> = OnceLock::new();
21    CELL.get_or_init(|| {
22        Regex::new(concat!(
23            r"^\[([0-9A-Fa-f]+):([0-9A-Fa-f]+)\]",        // [PID:TID]
24            r"\[(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2})\]", // [ISO timestamp]
25            r"([iew])(\d{3}):\s*(.*)",                    // severity + code + message
26        ))
27        .expect("Burn regex must compile")
28    })
29}
30
31/// Check if a line matches the WiX/Burn format (used by detect.rs).
32pub fn matches_burn_record(line: &str) -> bool {
33    burn_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 WiX/Burn bootstrapper 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) = burn_re().captures(trimmed) {
57            let pid_hex = caps.get(1).unwrap().as_str();
58            let tid_hex = caps.get(2).unwrap().as_str();
59            let ts_str = caps.get(3).unwrap().as_str();
60            let sev_letter = caps.get(4).unwrap().as_str();
61            let msg_code = caps.get(5).unwrap().as_str();
62            let message = caps
63                .get(6)
64                .map(|m| m.as_str().to_string())
65                .unwrap_or_default();
66
67            let pid = u32::from_str_radix(pid_hex, 16).unwrap_or(0);
68            let tid = u32::from_str_radix(tid_hex, 16).unwrap_or(0);
69            let severity = severity_from_letter(sev_letter);
70
71            // Parse ISO timestamp: YYYY-MM-DDTHH:MM:SS
72            let timestamp = chrono::NaiveDateTime::parse_from_str(ts_str, "%Y-%m-%dT%H:%M:%S")
73                .ok()
74                .map(|dt| dt.and_utc().timestamp_millis());
75
76            let timestamp_display = ts_str
77                .replace('T', " ")
78                .parse::<String>()
79                .ok()
80                .map(|s| format!("{}.000", s));
81
82            let thread_display = Some(format!("{:04X}:{:04X}", pid, tid));
83            let component = Some(format!("{}{}", sev_letter, msg_code));
84
85            entries.push(LogEntry {
86                id,
87                line_number: (i + 1) as u32,
88                message,
89                component,
90                timestamp,
91                timestamp_display,
92                severity,
93                thread: Some(pid),
94                thread_display,
95                source_file: None,
96                format: LogFormat::Timestamped,
97                file_path: file_path.to_string(),
98                timezone_offset: None,
99                error_code_spans: Vec::new(),
100                ip_address: None,
101                host_name: None,
102                mac_address: None,
103                result_code: None,
104                gle_code: None,
105                setup_phase: None,
106                operation_name: None,
107                http_method: None,
108                uri_stem: None,
109                uri_query: None,
110                status_code: None,
111                sub_status: None,
112                time_taken_ms: None,
113                client_ip: None,
114                server_ip: None,
115                user_agent: None,
116                server_port: None,
117                username: None,
118                win32_status: None,
119                query_name: None,
120                query_type: None,
121                response_code: None,
122                dns_direction: None,
123                dns_protocol: None,
124                source_ip: None,
125                dns_flags: None,
126                dns_event_id: None,
127                zone_name: None,
128                entry_kind: None,
129                whatif: None,
130                section_name: None,
131                section_color: None,
132                iteration: None,
133                tags: None,
134            });
135        } else {
136            // Non-matching line — plain text fallback
137            entries.push(LogEntry {
138                id,
139                line_number: (i + 1) as u32,
140                message: trimmed.to_string(),
141                component: None,
142                timestamp: None,
143                timestamp_display: None,
144                severity: super::severity::detect_severity_from_text(trimmed),
145                thread: None,
146                thread_display: None,
147                source_file: None,
148                format: LogFormat::Plain,
149                file_path: file_path.to_string(),
150                timezone_offset: None,
151                error_code_spans: Vec::new(),
152                ip_address: None,
153                host_name: None,
154                mac_address: None,
155                result_code: None,
156                gle_code: None,
157                setup_phase: None,
158                operation_name: None,
159                http_method: None,
160                uri_stem: None,
161                uri_query: None,
162                status_code: None,
163                sub_status: None,
164                time_taken_ms: None,
165                client_ip: None,
166                server_ip: None,
167                user_agent: None,
168                server_port: None,
169                username: None,
170                win32_status: None,
171                query_name: None,
172                query_type: None,
173                response_code: None,
174                dns_direction: None,
175                dns_protocol: None,
176                source_ip: None,
177                dns_flags: None,
178                dns_event_id: None,
179                zone_name: None,
180                entry_kind: None,
181                whatif: None,
182                section_name: None,
183                section_color: None,
184                iteration: None,
185                tags: None,
186            });
187            parse_errors += 1;
188        }
189        id += 1;
190    }
191
192    (entries, parse_errors)
193}
194
195#[cfg(test)]
196mod tests {
197    use super::*;
198
199    #[test]
200    fn test_parse_info_line() {
201        let lines = vec![
202            "[07A4:0CBC][2025-11-25T01:55:42]i001: Burn v3.14.1.8722, Windows v10.0 (Build 26100: Service Pack 0)",
203        ];
204        let (entries, errors) = parse_lines(&lines, "test.log");
205        assert_eq!(errors, 0);
206        assert_eq!(entries.len(), 1);
207        assert_eq!(entries[0].severity, Severity::Info);
208        assert_eq!(entries[0].component.as_deref(), Some("i001"));
209        assert_eq!(entries[0].thread_display.as_deref(), Some("07A4:0CBC"));
210        assert!(entries[0].message.contains("Burn v3.14.1.8722"));
211    }
212
213    #[test]
214    fn test_parse_error_line() {
215        let lines = vec!["[1234:5678][2025-11-25T01:55:42]e000: Error 0x80070005: Access denied"];
216        let (entries, _) = parse_lines(&lines, "test.log");
217        assert_eq!(entries[0].severity, Severity::Error);
218        assert_eq!(entries[0].component.as_deref(), Some("e000"));
219        assert!(entries[0].message.contains("Access denied"));
220    }
221
222    #[test]
223    fn test_parse_warning_line() {
224        let lines = vec!["[ABCD:EF01][2025-11-25T02:00:00]w000: Ignoring failure to set variable"];
225        let (entries, _) = parse_lines(&lines, "test.log");
226        assert_eq!(entries[0].severity, Severity::Warning);
227        assert_eq!(entries[0].component.as_deref(), Some("w000"));
228    }
229
230    #[test]
231    fn test_matches_burn_record() {
232        assert!(matches_burn_record(
233            "[07A4:0CBC][2025-11-25T01:55:42]i001: Burn started"
234        ));
235        assert!(!matches_burn_record("Just plain text"));
236        assert!(!matches_burn_record(
237            "2024-01-15T14:30:00Z Error: connection refused"
238        ));
239    }
240
241    #[test]
242    fn test_pid_tid_parsing() {
243        let lines = vec!["[07A4:0CBC][2025-11-25T01:55:42]i000: test"];
244        let (entries, _) = parse_lines(&lines, "test.log");
245        assert_eq!(entries[0].thread, Some(0x07A4));
246        assert_eq!(entries[0].thread_display.as_deref(), Some("07A4:0CBC"));
247    }
248}