cmtraceopen-parser 0.1.1

Parse ConfigMgr/SCCM, Intune, CBS, DISM, Panther, MSI, and PSADT logs with format auto-detection, severity classification, and Windows error-code lookup. Pure Rust, no I/O, native + wasm32.
Documentation
use std::collections::HashSet;

use crate::collector::types::CollectionProfile;

const EMBEDDED_PROFILE_JSON: &str = include_str!("profile_data.json");

impl CollectionProfile {
    /// Load the embedded collection profile compiled into the binary.
    pub fn embedded() -> CollectionProfile {
        let profile: CollectionProfile = serde_json::from_str(EMBEDDED_PROFILE_JSON)
            .expect("embedded collection profile JSON must be valid");
        assert!(
            profile.has_unique_artifact_ids(),
            "embedded collection profile artifact IDs must be unique"
        );
        profile
    }

    /// Total number of individual collection items across all categories.
    pub fn total_items(&self) -> usize {
        self.logs.len()
            + self.registry.len()
            + self.event_logs.len()
            + self.exports.len()
            + self.commands.len()
    }

    /// Filter all collection items to only those whose `family` is in the provided list.
    pub fn filter_by_families(&mut self, families: &[String]) {
        self.logs.retain(|item| families.contains(&item.family));
        self.registry.retain(|item| families.contains(&item.family));
        self.event_logs
            .retain(|item| families.contains(&item.family));
        self.exports.retain(|item| families.contains(&item.family));
        self.commands.retain(|item| families.contains(&item.family));
    }

    /// IDs are a bundle-wide contract, so uniqueness spans every category.
    pub fn artifact_ids(&self) -> impl Iterator<Item = &str> {
        self.logs
            .iter()
            .map(|item| item.id.as_str())
            .chain(self.registry.iter().map(|item| item.id.as_str()))
            .chain(self.event_logs.iter().map(|item| item.id.as_str()))
            .chain(self.exports.iter().map(|item| item.id.as_str()))
            .chain(self.commands.iter().map(|item| item.id.as_str()))
    }

    pub fn has_unique_artifact_ids(&self) -> bool {
        let mut seen = HashSet::new();
        self.artifact_ids().all(|id| seen.insert(id))
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn embedded_profile_deserializes() {
        let profile = CollectionProfile::embedded();
        assert_eq!(profile.profile_name, "cmtrace-full-diagnostics-v1");
        assert!(!profile.logs.is_empty());
        assert!(!profile.registry.is_empty());
        assert!(!profile.event_logs.is_empty());
        assert!(!profile.exports.is_empty());
        assert!(!profile.commands.is_empty());
    }

    #[test]
    fn total_items_sums_all_categories() {
        let profile = CollectionProfile::embedded();
        let expected = profile.logs.len()
            + profile.registry.len()
            + profile.event_logs.len()
            + profile.exports.len()
            + profile.commands.len();
        assert_eq!(profile.total_items(), expected);
        assert!(expected > 100, "full profile should have 100+ items");
    }

    #[test]
    fn filter_by_families_retains_only_matching() {
        let mut profile = CollectionProfile::embedded();
        let original_total = profile.total_items();

        profile.filter_by_families(&["general".to_string(), "networking".to_string()]);

        assert!(
            profile.total_items() > 0,
            "should have some items for general+networking"
        );
        assert!(
            profile.total_items() < original_total,
            "should be fewer items than full profile"
        );

        // Verify every remaining item belongs to an allowed family.
        for item in &profile.logs {
            assert!(
                item.family == "general" || item.family == "networking",
                "unexpected log family: {}",
                item.family
            );
        }
        for item in &profile.registry {
            assert!(
                item.family == "general" || item.family == "networking",
                "unexpected registry family: {}",
                item.family
            );
        }
        for item in &profile.commands {
            assert!(
                item.family == "general" || item.family == "networking",
                "unexpected command family: {}",
                item.family
            );
        }
    }

    #[test]
    fn filter_by_families_empty_list_yields_empty_profile() {
        let mut profile = CollectionProfile::embedded();
        profile.filter_by_families(&[]);
        assert_eq!(profile.total_items(), 0);
    }

    #[test]
    fn embedded_profile_includes_new_teams_msix_logs() {
        // Regression guard for issue #205: the new Teams (MSIX) client writes
        // logs under %LOCALAPPDATA%\Packages\MSTeams_8wekyb3d8bbwe\..., which the
        // classic-Teams manifest rows do not cover.
        let profile = CollectionProfile::embedded();
        let item = profile
            .logs
            .iter()
            .find(|i| i.id == "teams-msix-logs")
            .expect("profile must contain the new Teams MSIX log source");
        assert_eq!(item.family, "teams");
        assert!(
            item.source_pattern.contains("MSTeams_8wekyb3d8bbwe"),
            "unexpected source pattern: {}",
            item.source_pattern
        );
    }
}