Address review: use mlaunch crash snapshot diff for iOS device

Replace devicectl-based copy-everything-then-filter approach with
XHarness's CrashSnapshotReporter pattern, ported to Python:

* Before the iteration loop, run 'mlaunch --list-crash-reports' to
  capture the device's existing crash report set.
* In the kill-failure handler, re-list and download only the diff
  via 'mlaunch --download-crash-report --download-crash-report-to'.
* Poll the final snapshot for up to 60s so iOS has time to finish
  writing the crash report after the process dies (matches
  CrashSnapshotReporter.EndCaptureAsync).

The previous bundle/mtime filter still uploaded the historical
backlog of unrelated crashes that accumulate on shared
Mac.iPhone.17.Perf devices (8-20 stale .ips per work item seen in
build 2986965). The snapshot diff scopes uploads to only the
crashes generated during this test run.

It's a list+copy, not a move — device state is unchanged, matching
XHarness behaviour.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: matouskozak

src/scenarios/shared/runner.py

@@ -6,6 +6,7 @@
 import os
 import glob
 import re
+import tempfile
 import time
 import json
 
@@ -767,6 +768,43 @@ def run(self):
             RunCommand(installCmd, verbose=True).run()
             getLogger().info("Completed install.")
 
+            # The Mac.iPhone.17.Perf devices in the Helix pool are shared across many test
+            # runs over days, and iOS retains crash reports in /var/mobile/Library/Logs/
+            # CrashReporter/ until rotated out. To avoid re-uploading that historical
+            # backlog on a kill failure, snapshot the device's current crash report set
+            # now and below upload only reports that appeared since this snapshot.
+            # This mirrors XHarness's CrashSnapshotReporter pattern (it's a copy, not a
+            # move — device state is unchanged).
+            def listDeviceCrashReports():
+                """Return the set of crash report identifiers currently on the device,
+                or None if listing failed."""
+                listFilePath = None
+                try:
+                    with tempfile.NamedTemporaryFile(mode='w', suffix='.list', delete=False) as listFile:
+                        listFilePath = listFile.name
+                    listCmd = xharnesscommand() + [
+                        'apple', 'mlaunch', '--',
+                        f'--list-crash-reports={listFilePath}',
+                        '--devname', deviceUDID,
+                    ]
+                    RunCommand(listCmd, verbose=True).run()
+                    with open(listFilePath) as f:
+                        return {line.strip() for line in f if line.strip()}
+                except Exception as listEx:
+                    getLogger().warning(f"Failed to list device crash reports: {listEx}")
+                    return None
+                finally:
+                    if listFilePath and os.path.exists(listFilePath):
+                        try:
+                            os.remove(listFilePath)
+                        except OSError:
+                            pass
+
+            getLogger().info("Snapshotting existing crash reports on device.")
+            initial_device_crashes = listDeviceCrashReports()
+            if initial_device_crashes is not None:
+                getLogger().info(f"Found {len(initial_device_crashes)} pre-existing crash report(s).")
+
             allResults = []
             timeToFirstDrawEventEndDateTime = datetime.now() + timedelta(minutes=-10) # This is used to keep track of the latest time to draw end event, we use this to calculate time to draw and also as a reference point for the next iteration log time.
             for i in range(self.startupiterations + 1): # adding one iteration to account for the warmup iteration
@@ -861,41 +899,43 @@ def run(self):
                                 make_archive(archive_base, 'zip', root_dir=logarchive_filename)
                             except Exception as upload_ex:
                                 getLogger().warning(f"Failed to save logarchive for diagnosis: {upload_ex}")
-                        # Pull iOS crash reports (.ips) from the device into the upload root, then prune
-                        # to entries relevant to this iteration (matching bundle name OR generated since
-                        # the iteration started). The systemCrashLogs domain exposes /var/mobile/Library/
-                        # Logs/CrashReporter/, which on shared devices accumulates unrelated reports.
-                        try:
-                            crash_dest = os.path.join(upload_root, f'iteration{i}_crashlogs')
-                            os.makedirs(crash_dest, exist_ok=True)
-                            crashCopyCmd = [
-                                'xcrun', 'devicectl', 'device', 'copy', 'from',
-                                '--device', deviceUDID,
-                                '--domain-type', 'systemCrashLogs',
-                                '--source', '/',
-                                '--destination', crash_dest,
-                            ]
-                            getLogger().info(f"Copying device crash logs to {crash_dest} for diagnosis.")
-                            RunCommand(crashCopyCmd, verbose=True).run()
-                            bundle_name = os.path.splitext(os.path.basename(os.path.normpath(self.packagepath)))[0]
-                            iteration_start_ts = runCmdTimestamp.timestamp()
-                            kept = removed = 0
-                            for root, _, files in os.walk(crash_dest):
-                                for fname in files:
-                                    fpath = os.path.join(root, fname)
+                        # Take a final snapshot and download only crash reports that appeared
+                        # since the initial snapshot taken before the iteration loop. This
+                        # matches XHarness's CrashSnapshotReporter pattern and avoids uploading
+                        # the historical backlog of unrelated crashes the shared device retains.
+                        # iOS may take a few seconds to finish writing a crash report after the
+                        # process dies, so poll the snapshot for up to 60s waiting for new
+                        # entries to appear (matches CrashSnapshotReporter.EndCaptureAsync).
+                        if initial_device_crashes is None:
+                            getLogger().info("Skipping device crash log download (initial snapshot unavailable).")
+                        else:
+                            crash_wait_deadline = time.time() + 60
+                            final_device_crashes = listDeviceCrashReports()
+                            new_crashes = sorted(final_device_crashes - initial_device_crashes) if final_device_crashes is not None else []
+                            while final_device_crashes is not None and not new_crashes and time.time() < crash_wait_deadline:
+                                time.sleep(1)
+                                final_device_crashes = listDeviceCrashReports()
+                                new_crashes = sorted(final_device_crashes - initial_device_crashes) if final_device_crashes is not None else []
+                            if final_device_crashes is None:
+                                getLogger().warning("Skipping device crash log download (final snapshot failed).")
+                            elif not new_crashes:
+                                getLogger().info("No new crash reports on device for this test run.")
+                            else:
+                                crash_dest = os.path.join(upload_root, f'iteration{i}_crashlogs')
+                                os.makedirs(crash_dest, exist_ok=True)
+                                getLogger().info(f"Downloading {len(new_crashes)} new crash report(s) to {crash_dest}.")
+                                for crash_id in new_crashes:
+                                    dst = os.path.join(crash_dest, os.path.basename(crash_id))
+                                    dlCmd = xharnesscommand() + [
+                                        'apple', 'mlaunch', '--',
+                                        f'--download-crash-report={crash_id}',
+                                        f'--download-crash-report-to={dst}',
+                                        '--devname', deviceUDID,
+                                    ]
                                     try:
-                                        is_bundle_match = bool(bundle_name) and bundle_name in fname
-                                        is_recent = os.path.getmtime(fpath) >= iteration_start_ts
-                                        if is_bundle_match or is_recent:
-                                            kept += 1
-                                        else:
-                                            os.remove(fpath)
-                                            removed += 1
-                                    except OSError:
-                                        pass
-                            getLogger().info(f"Kept {kept} crash log(s) relevant to {bundle_name!r} or this iteration; pruned {removed}.")
-                        except Exception as crash_ex:
-                            getLogger().warning(f"Failed to copy device crash logs for diagnosis: {crash_ex}")
+                                        RunCommand(dlCmd, verbose=True).run()
+                                    except Exception as dlEx:
+                                        getLogger().warning(f"Failed to download crash report {crash_id}: {dlEx}")
                     raise
 
                 # Process Data