
Un parser multipiattaforma per Apple UnifiedLogs!
Una libreria Rust semplice e ad alte prestazioni che può aiutare ad analizzare i file Unified Log di Apple.
Gli Unified Log sono stati introdotti in macOS 10.12 (Sierra, 2016) come parte del sistema di logging unificato di Apple su macOS, iOS, watchOS e tvOS. Questa libreria può analizzare i file binari tracev3 ed emettere voci di log strutturate.
Ogni voce espone: il messaggio formattato (oltre al messaggio grezzo e agli elementi di log grezzi), il timestamp (Intel e ARM), il tipo di evento e di log, i percorsi di processo e libreria con i relativi UUID, sottosistema, categoria, PID, ID thread, EUID, ID attività (e relativo padre), UUID di avvio e fuso orario.
I binari di esempio si trovano in examples/:
unifiedlog_iterator - Analizza un logarchive (o i log su un sistema macOS attivo)
in un file JSONL o CSV, con supporto per bookmark/ripresa. Il file di output sarà
piuttosto grande.cargo run --release --manifest-path examples/Cargo.toml -p unifiedlog_iterator -- --mode log-archive --input system_logs.logarchive
Consulta RUNNING.md per ulteriori informazioni sull'utilizzo, su come creare un logarchive e sulle avvertenze previste.
Il tipo principale è LogEntry<'a, 'b> — una voce di log a copia zero che prende in prestito direttamente dai buffer del file analizzato. I messaggi vengono formattati in modo lazy su richiesta tramite .message(), evitando l'allocazione sull'heap finché non è esplicitamente necessario. I file di stringhe UUIDText e della cache condivisa (DSC) vengono letti in modo lazy man mano che le voci di log vi fanno riferimento, mantenendo la memoria proporzionale a ciò che i log utilizzano effettivamente; vedi cache::StringStorage::preload per la modalità eager. Per i processi di lunga durata, logarchive::VisitOptions::memory_budget limita i dati di stringhe caricati recuperandoli tra i file tracev3 (disattivato per impostazione predefinita). Vedi ARCHITECTURE.md per la pipeline completa.
[dependencies]
macos-unifiedlogs = "0.8"
use macos_unifiedlogs::logarchive::visit_logarchive;
use std::path::Path;
visit_logarchive(Path::new("system_logs.logarchive"), |entry| {
let timestamp = entry.timestamp().to_rfc3339();
let process = entry.process.unwrap_or("");
let message = entry.message();
println!("{timestamp} [{process}] {message}");
}).unwrap();
use macos_unifiedlogs::logarchive::visit_live_system;
visit_live_system(|entry| {
let timestamp = entry.timestamp().to_rfc3339();
let process = entry.process.unwrap_or("");
let message = entry.message();
println!("{timestamp} [{process}] {message}");
}).unwrap();
Per immagini montate o root non standard, utilizzare filesystem::LiveSystemProvider::with_roots
con logarchive::visit_provider.
use macos_unifiedlogs::logarchive::visit_logarchive_tracev3_file;
use std::path::Path;
visit_logarchive_tracev3_file(
Path::new("system_logs.logarchive"),
"Persist/0000000000000004.tracev3",
|entry| {
let message = entry.message();
println!("{:?} {:?} {message}", entry.event_type, entry.log_type);
},
)
.unwrap();
Implementa traits::FileProvider per alimentare il parser da qualsiasi posizione — un'immagine
montata, un contenitore di prove o semplice memoria. filesystem::InMemoryProvider
è un'implementazione in memoria già pronta:
use macos_unifiedlogs::filesystem::InMemoryProvider;
use macos_unifiedlogs::logarchive::visit_provider;
let mut provider = InMemoryProvider::default();
provider.tracev3.push(("mem://persist-1.tracev3".into(), tracev3_bytes));
provider.timesync.push(("mem://boot.timesync".into(), timesync_bytes));
provider.uuidtext.insert(some_uuid, uuidtext_bytes);
provider.dsc.insert(dsc_uuid, dsc_bytes);
visit_provider(&provider, |entry| {
println!("{}", entry.message());
})
.unwrap();
I dati UUIDText/DSC vengono richiesti in modo lazy tramite UUID man mano che le voci vi fanno riferimento. Usa
logarchive::visit_provider_preloaded per caricare tutto in anticipo
(massimo throughput con massimo utilizzo di memoria).
Nessuna ricerca dei codici di errore in stile printf (%m). La libreria restituisce il numero di errore grezzo, non la stringa leggibile che il comando log di macOS fornisce.
Gli oggetti di log personalizzati non supportati vengono codificati in base64 anziché decodificati.