Skip to main content

cmtraceopen_parser/esp/
rules.rs

1use std::collections::BTreeSet;
2
3use chrono::{DateTime, Utc};
4
5use super::models::*;
6
7const STALLED_WORKLOAD_SECONDS: i64 = 15 * 60;
8
9/// Derive stable, read-only diagnostic findings from an immutable snapshot.
10///
11/// Rules only emit when their triggering evidence is present. Every returned
12/// finding therefore carries at least one evidence reference or explicit
13/// coverage-gap identifier.
14pub fn derive_findings(snapshot: &EspDiagnosticsSnapshot) -> Vec<EspDiagnosticFinding> {
15    let mut findings = Vec::new();
16
17    push_failed_blocking_app(snapshot, &mut findings);
18    push_stalled_workload(snapshot, &mut findings);
19    push_esp_timeout(snapshot, &mut findings);
20    push_failed_registration(snapshot, &mut findings);
21    push_unprocessed_workloads(snapshot, &mut findings);
22    push_ime_coverage_gap(snapshot, &mut findings);
23    push_non_elevated_coverage_loss(snapshot, &mut findings);
24    push_ambiguous_installer(snapshot, &mut findings);
25    push_local_graph_conflict(snapshot, &mut findings);
26    push_malformed_source(snapshot, &mut findings);
27    push_successful_completion(snapshot, &mut findings);
28
29    findings
30}
31
32/// Return an immutable snapshot projection with the Graph overlay attached and
33/// every finding re-derived from the combined local and remote evidence.
34pub fn attach_graph_overlay(
35    snapshot: &EspDiagnosticsSnapshot,
36    graph: EspGraphOverlay,
37) -> EspDiagnosticsSnapshot {
38    let mut projected = snapshot.clone();
39    projected.graph = Some(graph);
40    projected.findings = derive_findings(&projected);
41    projected
42}
43
44fn push_failed_blocking_app(
45    snapshot: &EspDiagnosticsSnapshot,
46    findings: &mut Vec<EspDiagnosticFinding>,
47) {
48    let failed = current_workloads(snapshot)
49        .filter(|workload| {
50            is_app_kind(&workload.kind)
51                && workload.status.normalized == EspNormalizedStatus::Failed
52                // `blocking` is frequently unknown (None) in the reduced evidence, so
53                // requiring Some(true) hid real ESP-blocking failures. Surface any failed
54                // app UNLESS it is explicitly non-blocking.
55                && workload.blocking != Some(false)
56        })
57        .collect::<Vec<_>>();
58    if failed.is_empty() {
59        return;
60    }
61    let summary = format!(
62        "{} failed during setup: {}.",
63        if failed.len() == 1 {
64            "An application"
65        } else {
66            "Applications"
67        },
68        failed_app_labels(&failed),
69    );
70    let evidence = collect_evidence(failed.iter().flat_map(|workload| workload.evidence.iter()));
71    push_finding(
72        findings,
73        finding(
74            "blocking-app-failed",
75            EspFindingSeverity::Blocker,
76            EspFindingConfidence::High,
77            "An application failed during setup",
78            &summary,
79            "Inspect the named app's cited IME or deployment log around its final failure for the exit/enforcement code.",
80            evidence,
81            vec![],
82        ),
83    );
84}
85
86/// Comma-joined, de-duplicated labels for failed app workloads: the friendly name
87/// when known, otherwise the raw identifier, capped so the summary stays readable.
88fn failed_app_labels(workloads: &[&EspWorkload]) -> String {
89    const MAX_LABELS: usize = 6;
90    let mut labels: Vec<String> = Vec::new();
91    for workload in workloads {
92        let label = workload
93            .display_name
94            .clone()
95            .unwrap_or_else(|| workload.raw_identifier.clone());
96        if !labels.contains(&label) {
97            labels.push(label);
98        }
99    }
100    let extra = labels.len().saturating_sub(MAX_LABELS);
101    labels.truncate(MAX_LABELS);
102    let mut joined = labels.join(", ");
103    if extra > 0 {
104        joined.push_str(&format!(" (+{extra} more)"));
105    }
106    joined
107}
108
109fn push_stalled_workload(
110    snapshot: &EspDiagnosticsSnapshot,
111    findings: &mut Vec<EspDiagnosticFinding>,
112) {
113    let Some(generated_at) = parse_rfc3339(&snapshot.generated_at_utc) else {
114        return;
115    };
116    let workloads = current_workloads(snapshot).filter(|workload| {
117        if !matches!(
118            workload.status.normalized,
119            EspNormalizedStatus::Downloading
120                | EspNormalizedStatus::Installing
121                | EspNormalizedStatus::InProgress
122        ) {
123            return false;
124        }
125        workload
126            .timestamps
127            .last_updated
128            .as_ref()
129            .or(workload.timestamps.started.as_ref())
130            .and_then(normalized_timestamp)
131            .is_some_and(|updated| {
132                generated_at.signed_duration_since(updated).num_seconds()
133                    >= STALLED_WORKLOAD_SECONDS
134            })
135    });
136    let evidence = collect_evidence(workloads.flat_map(|workload| workload.evidence.iter()));
137    push_finding(
138        findings,
139        finding(
140            "workload-stalled",
141            EspFindingSeverity::Error,
142            EspFindingConfidence::High,
143            "A download or installation has stopped updating",
144            "A workload remains active and its cited last-update timestamp is at least 15 minutes old.",
145            "Compare the cited workload's last update with IME and Delivery Optimization activity.",
146            evidence,
147            vec![],
148        ),
149    );
150}
151
152fn push_esp_timeout(snapshot: &EspDiagnosticsSnapshot, findings: &mut Vec<EspDiagnosticFinding>) {
153    if snapshot.phase == EspPhase::Completed {
154        return;
155    }
156    let Some(generated_at) = parse_rfc3339(&snapshot.generated_at_utc) else {
157        return;
158    };
159    let timeout_values = snapshot
160        .enrollments
161        .iter()
162        .filter_map(|enrollment| enrollment.settings.timeout_seconds)
163        .filter(|timeout| *timeout > 0)
164        .collect::<BTreeSet<_>>();
165    if timeout_values.len() != 1 {
166        return;
167    }
168    let Some(timeout_seconds) = timeout_values.iter().next().copied() else {
169        return;
170    };
171    let Ok(timeout_seconds_i64) = i64::try_from(timeout_seconds) else {
172        return;
173    };
174    let timed_out_sessions = snapshot.sessions.iter().filter(|session| {
175        session.is_latest
176            && !matches!(session.phase, EspPhase::Completed)
177            && session
178                .started_at
179                .as_ref()
180                .and_then(normalized_timestamp)
181                .is_some_and(|started| {
182                    generated_at.signed_duration_since(started).num_seconds() >= timeout_seconds_i64
183                })
184    });
185    let mut evidence =
186        collect_evidence(timed_out_sessions.flat_map(|session| session.evidence.iter()));
187    if evidence.is_empty() {
188        return;
189    }
190    evidence.extend(collect_evidence(
191        snapshot
192            .enrollments
193            .iter()
194            .filter(|enrollment| enrollment.settings.timeout_seconds == Some(timeout_seconds))
195            .flat_map(|enrollment| enrollment.evidence.iter()),
196    ));
197    normalize_evidence(&mut evidence);
198    push_finding(
199        findings,
200        finding(
201            "esp-timeout-reached",
202            EspFindingSeverity::Blocker,
203            EspFindingConfidence::High,
204            "The configured ESP timeout has been reached",
205            "The current time is beyond the configured timeout for a cited active ESP session.",
206            "Compare the cited ESP session start time with the configured timeout.",
207            evidence,
208            vec![],
209        ),
210    );
211}
212
213fn push_failed_registration(
214    snapshot: &EspDiagnosticsSnapshot,
215    findings: &mut Vec<EspDiagnosticFinding>,
216) {
217    let events = snapshot.registration_events.iter().filter(|event| {
218        event.status.normalized == EspNormalizedStatus::Failed && event.event_id == 304
219    });
220    let mut evidence = collect_evidence(events.flat_map(|event| event.evidence.iter()));
221    evidence.extend(collect_evidence(
222        snapshot
223            .activity
224            .iter()
225            .filter(|entry| {
226                entry.kind == EspTimelineKind::OfflineDomainJoin
227                    && entry
228                        .status
229                        .as_ref()
230                        .is_some_and(|status| status.normalized == EspNormalizedStatus::Failed)
231            })
232            .flat_map(|entry| entry.evidence.iter()),
233    ));
234    normalize_evidence(&mut evidence);
235    push_finding(
236        findings,
237        finding(
238            "registration-or-join-failed",
239            EspFindingSeverity::Error,
240            EspFindingConfidence::High,
241            "Device registration or join failed",
242            "A cited device-registration or Offline Domain Join event has an explicit failed status.",
243            "Inspect the cited Device Registration or Offline Domain Join event and its named data.",
244            evidence,
245            vec![],
246        ),
247    );
248}
249
250fn push_unprocessed_workloads(
251    snapshot: &EspDiagnosticsSnapshot,
252    findings: &mut Vec<EspDiagnosticFinding>,
253) {
254    push_unprocessed_kind(
255        snapshot,
256        findings,
257        EspTrackedKind::Policy,
258        "policy-not-processed",
259        "A tracked policy has not been processed",
260        "At least one cited policy remains in a pre-processing state.",
261        "Inspect the cited policy tracking state and enrollment scope.",
262    );
263    push_unprocessed_kind(
264        snapshot,
265        findings,
266        EspTrackedKind::ScepCertificate,
267        "certificate-not-processed",
268        "A tracked certificate has not been processed",
269        "At least one cited certificate remains in a pre-processing state.",
270        "Inspect the cited certificate tracking state and enrollment scope.",
271    );
272}
273
274#[allow(clippy::too_many_arguments)]
275fn push_unprocessed_kind(
276    snapshot: &EspDiagnosticsSnapshot,
277    findings: &mut Vec<EspDiagnosticFinding>,
278    kind: EspTrackedKind,
279    id: &str,
280    title: &str,
281    summary: &str,
282    check: &str,
283) {
284    let workloads = current_workloads(snapshot)
285        .filter(|workload| workload.kind == kind && is_not_processed(&workload.status.normalized));
286    let evidence = collect_evidence(workloads.flat_map(|workload| workload.evidence.iter()));
287    push_finding(
288        findings,
289        finding(
290            id,
291            EspFindingSeverity::Warning,
292            EspFindingConfidence::High,
293            title,
294            summary,
295            check,
296            evidence,
297            vec![],
298        ),
299    );
300}
301
302fn push_ime_coverage_gap(
303    snapshot: &EspDiagnosticsSnapshot,
304    findings: &mut Vec<EspDiagnosticFinding>,
305) {
306    let coverage = snapshot.coverage.iter().filter(|coverage| {
307        is_ime_log_coverage(coverage)
308            && matches!(
309                coverage.status,
310                EspArtifactStatus::Missing | EspArtifactStatus::PermissionDenied
311            )
312    });
313    let entries = coverage.collect::<Vec<_>>();
314    let evidence = collect_evidence(entries.iter().flat_map(|coverage| coverage.evidence.iter()));
315    let gaps = collect_gap_ids(entries.iter().map(|coverage| coverage.artifact_id.as_str()));
316    push_finding(
317        findings,
318        finding(
319            "ime-evidence-unavailable",
320            EspFindingSeverity::Warning,
321            EspFindingConfidence::High,
322            "IME evidence is unavailable",
323            "The source inventory explicitly reports missing or unreadable Intune Management Extension logs.",
324            "Open the cited IME coverage entry and verify the protected log path is readable.",
325            evidence,
326            gaps,
327        ),
328    );
329}
330
331fn is_ime_log_coverage(coverage: &EspArtifactCoverage) -> bool {
332    let artifact = normalize_source_identity(&coverage.artifact_id);
333    let family = normalize_source_identity(&coverage.family);
334    matches!(
335        artifact.as_str(),
336        "imelogs"
337            | "intuneimelogs"
338            | "windowsintuneimelogs"
339            | "intunemanagementextensionlog"
340            | "intunemanagementextensionlogs"
341    ) || matches!(
342        family.as_str(),
343        "intuneime" | "intunemanagementextension" | "intunemanagementextensionlogs"
344    )
345}
346
347fn normalize_source_identity(value: &str) -> String {
348    value
349        .chars()
350        .filter(|character| character.is_ascii_alphanumeric())
351        .flat_map(char::to_lowercase)
352        .collect()
353}
354
355fn push_non_elevated_coverage_loss(
356    snapshot: &EspDiagnosticsSnapshot,
357    findings: &mut Vec<EspDiagnosticFinding>,
358) {
359    if snapshot.elevation.is_elevated {
360        return;
361    }
362    let denied = snapshot
363        .coverage
364        .iter()
365        .filter(|coverage| coverage.status == EspArtifactStatus::PermissionDenied)
366        .collect::<Vec<_>>();
367    let evidence = collect_evidence(denied.iter().flat_map(|coverage| coverage.evidence.iter()));
368    let gaps = collect_gap_ids(
369        denied
370            .iter()
371            .map(|coverage| coverage.artifact_id.as_str())
372            .chain(
373                snapshot
374                    .elevation
375                    .restricted_sources
376                    .iter()
377                    .map(String::as_str),
378            ),
379    );
380    push_finding(
381        findings,
382        finding(
383            "non-elevated-coverage-loss",
384            EspFindingSeverity::Warning,
385            EspFindingConfidence::High,
386            "Non-elevated access is hiding diagnostic evidence",
387            "The session is not elevated and one or more protected evidence sources are unavailable.",
388            "Review the cited coverage gaps, then relaunch CMTrace Open as administrator if deeper evidence is required.",
389            evidence,
390            gaps,
391        ),
392    );
393}
394
395fn push_ambiguous_installer(
396    snapshot: &EspDiagnosticsSnapshot,
397    findings: &mut Vec<EspDiagnosticFinding>,
398) {
399    let correlations = snapshot
400        .installer_correlations
401        .iter()
402        .filter(|correlation| {
403            correlation.workload_id.is_none()
404                && correlation.confidence == EspCorrelationConfidence::Uncorrelated
405                && correlation.candidate_workload_ids.len() > 1
406        });
407    let evidence =
408        collect_evidence(correlations.flat_map(|correlation| correlation.evidence.iter()));
409    push_finding(
410        findings,
411        finding(
412            "installer-correlation-ambiguous",
413            EspFindingSeverity::Warning,
414            EspFindingConfidence::Medium,
415            "The active installer cannot be matched to one workload",
416            "Multiple candidate workloads remain after the available installer evidence is compared.",
417            "Compare the cited process start time, log path, app ID, and product code with each candidate workload.",
418            evidence,
419            vec![],
420        ),
421    );
422}
423
424fn push_local_graph_conflict(
425    snapshot: &EspDiagnosticsSnapshot,
426    findings: &mut Vec<EspDiagnosticFinding>,
427) {
428    let Some(graph) = &snapshot.graph else {
429        return;
430    };
431    let mut evidence = Vec::new();
432
433    if graph.apps.status == GraphSectionStatus::Available {
434        if let Some(apps) = &graph.apps.data {
435            for workload in current_workloads(snapshot).filter(|workload| {
436                !workload.raw_identifier.trim().is_empty() && is_app_kind(&workload.kind)
437            }) {
438                for app in apps
439                    .iter()
440                    .filter(|app| app.app_id.eq_ignore_ascii_case(&workload.raw_identifier))
441                {
442                    extend_status_conflict_evidence(
443                        &mut evidence,
444                        workload,
445                        app.status.as_ref(),
446                        &app.evidence,
447                    );
448                }
449            }
450        }
451    }
452    if graph.policies.status == GraphSectionStatus::Available {
453        if let Some(policies) = &graph.policies.data {
454            for workload in current_workloads(snapshot).filter(|workload| {
455                !workload.raw_identifier.trim().is_empty()
456                    && matches!(
457                        workload.kind,
458                        EspTrackedKind::Policy | EspTrackedKind::ScepCertificate
459                    )
460            }) {
461                for policy in policies.iter().filter(|policy| {
462                    policy
463                        .policy_id
464                        .eq_ignore_ascii_case(&workload.raw_identifier)
465                }) {
466                    extend_status_conflict_evidence(
467                        &mut evidence,
468                        workload,
469                        policy.status.as_ref(),
470                        &policy.evidence,
471                    );
472                }
473            }
474        }
475    }
476    if graph.scripts.status == GraphSectionStatus::Available {
477        if let Some(scripts) = &graph.scripts.data {
478            for workload in current_workloads(snapshot).filter(|workload| {
479                !workload.raw_identifier.trim().is_empty()
480                    && workload.kind == EspTrackedKind::PlatformScript
481            }) {
482                for script in scripts.iter().filter(|script| {
483                    script
484                        .script_id
485                        .eq_ignore_ascii_case(&workload.raw_identifier)
486                }) {
487                    extend_status_conflict_evidence(
488                        &mut evidence,
489                        workload,
490                        script.status.as_ref(),
491                        &script.evidence,
492                    );
493                }
494            }
495        }
496    }
497    normalize_evidence(&mut evidence);
498    push_finding(
499        findings,
500        finding(
501            "local-graph-state-conflict",
502            EspFindingSeverity::Warning,
503            EspFindingConfidence::High,
504            "Local and Intune Graph workload states disagree",
505            "The same exact workload identifier has contradictory explicit terminal states in local evidence and Intune Graph.",
506            "Compare the cited local workload state with the current Intune Graph status.",
507            evidence,
508            vec![],
509        ),
510    );
511}
512
513fn extend_status_conflict_evidence(
514    evidence: &mut Vec<EspEvidenceRef>,
515    workload: &EspWorkload,
516    graph_status: Option<&EspStatus>,
517    graph_evidence: &[EspEvidenceRef],
518) {
519    let Some(graph_status) = graph_status else {
520        return;
521    };
522    if workload.evidence.is_empty()
523        || graph_evidence.is_empty()
524        || !statuses_contradict(&workload.status.normalized, &graph_status.normalized)
525    {
526        return;
527    }
528    evidence.extend(workload.evidence.iter().cloned());
529    evidence.extend(graph_evidence.iter().cloned());
530}
531
532fn statuses_contradict(local: &EspNormalizedStatus, remote: &EspNormalizedStatus) -> bool {
533    (is_unsuccessful_terminal_status(local) && is_successful_terminal_status(remote))
534        || (is_unsuccessful_terminal_status(remote) && is_successful_terminal_status(local))
535}
536
537fn push_malformed_source(
538    snapshot: &EspDiagnosticsSnapshot,
539    findings: &mut Vec<EspDiagnosticFinding>,
540) {
541    let malformed_coverage = snapshot
542        .coverage
543        .iter()
544        .filter(|coverage| coverage.status == EspArtifactStatus::ParseFailed)
545        .collect::<Vec<_>>();
546    let mut evidence = collect_evidence(
547        malformed_coverage
548            .iter()
549            .flat_map(|coverage| coverage.evidence.iter())
550            .chain(
551                snapshot
552                    .raw_evidence
553                    .iter()
554                    .filter(|raw| raw.parse_state == EspParseState::Malformed)
555                    .flat_map(|raw| raw.evidence.iter()),
556            ),
557    );
558    normalize_evidence(&mut evidence);
559    let gaps = collect_gap_ids(
560        malformed_coverage
561            .iter()
562            .map(|coverage| coverage.artifact_id.as_str()),
563    );
564    push_finding(
565        findings,
566        finding(
567            "source-evidence-malformed",
568            EspFindingSeverity::Warning,
569            EspFindingConfidence::High,
570            "A diagnostic source is malformed",
571            "At least one cited diagnostic source failed parsing.",
572            "Inspect the cited source coverage and any available raw evidence.",
573            evidence,
574            gaps,
575        ),
576    );
577}
578
579fn push_successful_completion(
580    snapshot: &EspDiagnosticsSnapshot,
581    findings: &mut Vec<EspDiagnosticFinding>,
582) {
583    if snapshot.phase != EspPhase::Completed {
584        return;
585    }
586    let latest_sessions = snapshot
587        .sessions
588        .iter()
589        .filter(|session| session.is_latest)
590        .collect::<Vec<_>>();
591    if latest_sessions.is_empty()
592        || latest_sessions
593            .iter()
594            .any(|session| session.phase != EspPhase::Completed || session.workload_ids.is_empty())
595    {
596        return;
597    }
598
599    let mut evidence = collect_evidence(
600        latest_sessions
601            .iter()
602            .flat_map(|session| session.evidence.iter()),
603    );
604    let mut supporting_source_ids = evidence
605        .iter()
606        .filter(|evidence| !evidence.source_artifact_id.trim().is_empty())
607        .map(|evidence| evidence.source_artifact_id.clone())
608        .collect::<BTreeSet<_>>();
609    for session in &latest_sessions {
610        for workload_id in &session.workload_ids {
611            let Some(workload) = snapshot.workloads.iter().find(|workload| {
612                workload.session_id == session.session_id && &workload.workload_id == workload_id
613            }) else {
614                return;
615            };
616            if !is_successful_terminal_status(&workload.status.normalized) {
617                return;
618            }
619            supporting_source_ids.extend(
620                workload
621                    .evidence
622                    .iter()
623                    .filter(|evidence| !evidence.source_artifact_id.trim().is_empty())
624                    .map(|evidence| evidence.source_artifact_id.clone()),
625            );
626            evidence.extend(workload.evidence.iter().cloned());
627        }
628    }
629    if evidence.is_empty() {
630        return;
631    }
632    if supporting_source_ids.is_empty() {
633        return;
634    }
635    for source_artifact_id in supporting_source_ids {
636        let mut relevant_coverage = snapshot.coverage.iter().filter(|coverage| {
637            coverage.artifact_id == source_artifact_id
638                || coverage
639                    .evidence
640                    .iter()
641                    .any(|evidence| evidence.source_artifact_id == source_artifact_id)
642        });
643        let Some(first_coverage) = relevant_coverage.next() else {
644            return;
645        };
646        if first_coverage.status != EspArtifactStatus::Available
647            || relevant_coverage.any(|coverage| coverage.status != EspArtifactStatus::Available)
648        {
649            return;
650        }
651    }
652    normalize_evidence(&mut evidence);
653    push_finding(
654        findings,
655        finding(
656            "esp-completed",
657            EspFindingSeverity::Info,
658            EspFindingConfidence::High,
659            "ESP completed successfully",
660            "The cited latest session completed and every declared workload was observed in a successful terminal state.",
661            "Review the cited completed session and terminal workload states.",
662            evidence,
663            vec![],
664        ),
665    );
666}
667
668#[allow(clippy::too_many_arguments)]
669fn finding(
670    id: &str,
671    severity: EspFindingSeverity,
672    confidence: EspFindingConfidence,
673    title: &str,
674    summary: &str,
675    check: &str,
676    evidence: Vec<EspEvidenceRef>,
677    coverage_gap_ids: Vec<String>,
678) -> Option<EspDiagnosticFinding> {
679    if evidence.is_empty() && coverage_gap_ids.is_empty() {
680        return None;
681    }
682    Some(EspDiagnosticFinding {
683        finding_id: id.to_string(),
684        severity,
685        confidence,
686        title: title.to_string(),
687        summary: summary.to_string(),
688        recommended_checks: vec![check.to_string()],
689        evidence,
690        coverage_gap_ids,
691    })
692}
693
694fn push_finding(findings: &mut Vec<EspDiagnosticFinding>, finding: Option<EspDiagnosticFinding>) {
695    if let Some(finding) = finding {
696        findings.push(finding);
697    }
698}
699
700fn is_app_kind(kind: &EspTrackedKind) -> bool {
701    matches!(
702        kind,
703        EspTrackedKind::Msi
704            | EspTrackedKind::Office
705            | EspTrackedKind::ModernApp
706            | EspTrackedKind::Win32App
707            | EspTrackedKind::DevicePreparationWorkload
708    )
709}
710
711fn is_not_processed(status: &EspNormalizedStatus) -> bool {
712    matches!(
713        status,
714        EspNormalizedStatus::NotStarted
715            | EspNormalizedStatus::NotInstalled
716            | EspNormalizedStatus::Initialized
717            | EspNormalizedStatus::Pending
718    )
719}
720
721fn is_successful_terminal_status(status: &EspNormalizedStatus) -> bool {
722    matches!(
723        status,
724        EspNormalizedStatus::Succeeded
725            | EspNormalizedStatus::Processed
726            | EspNormalizedStatus::Skipped
727            | EspNormalizedStatus::Uninstalled
728    )
729}
730
731fn is_unsuccessful_terminal_status(status: &EspNormalizedStatus) -> bool {
732    matches!(
733        status,
734        EspNormalizedStatus::Failed | EspNormalizedStatus::Cancelled
735    )
736}
737
738fn current_workloads(snapshot: &EspDiagnosticsSnapshot) -> impl Iterator<Item = &EspWorkload> {
739    let sessionless = snapshot.sessions.is_empty();
740    let latest_workload_keys = snapshot
741        .sessions
742        .iter()
743        .filter(|session| session.is_latest)
744        .flat_map(|session| {
745            session
746                .workload_ids
747                .iter()
748                .map(move |workload_id| (session.session_id.as_str(), workload_id.as_str()))
749        })
750        .collect::<BTreeSet<_>>();
751
752    snapshot.workloads.iter().filter(move |workload| {
753        sessionless
754            || latest_workload_keys
755                .contains(&(workload.session_id.as_str(), workload.workload_id.as_str()))
756    })
757}
758
759fn normalized_timestamp(timestamp: &EspTimestamp) -> Option<DateTime<Utc>> {
760    timestamp.normalized_utc.as_deref().and_then(parse_rfc3339)
761}
762
763fn parse_rfc3339(value: &str) -> Option<DateTime<Utc>> {
764    DateTime::parse_from_rfc3339(value)
765        .ok()
766        .map(|value| value.with_timezone(&Utc))
767}
768
769fn collect_evidence<'a>(
770    evidence: impl IntoIterator<Item = &'a EspEvidenceRef>,
771) -> Vec<EspEvidenceRef> {
772    let mut collected = evidence.into_iter().cloned().collect::<Vec<_>>();
773    normalize_evidence(&mut collected);
774    collected
775}
776
777fn normalize_evidence(evidence: &mut Vec<EspEvidenceRef>) {
778    evidence.sort_by(|left, right| {
779        left.evidence_id
780            .cmp(&right.evidence_id)
781            .then_with(|| left.source_artifact_id.cmp(&right.source_artifact_id))
782    });
783    evidence.dedup_by(|left, right| {
784        left.evidence_id == right.evidence_id && left.source_artifact_id == right.source_artifact_id
785    });
786}
787
788fn collect_gap_ids<'a>(gaps: impl IntoIterator<Item = &'a str>) -> Vec<String> {
789    let mut gaps = gaps
790        .into_iter()
791        .filter(|gap| !gap.trim().is_empty())
792        .map(str::to_string)
793        .collect::<Vec<_>>();
794    gaps.sort();
795    gaps.dedup();
796    gaps
797}