import Foundation
|
|
public enum PerformanceDiagnosticArchiveWriter {
|
public static func write(
|
to destinationURL: URL,
|
summaryJSON: Data,
|
eventLogURLs: [URL],
|
fileManager: FileManager = .default
|
) throws -> URL {
|
guard !fileManager.fileExists(atPath: destinationURL.path) else {
|
throw ArchiveError.destinationAlreadyExists
|
}
|
let workingDirectory = fileManager.temporaryDirectory
|
.appendingPathComponent("Aligner-Diagnostics-\(UUID().uuidString)", isDirectory: true)
|
let contentsDirectory = workingDirectory
|
.appendingPathComponent("Aligner-Diagnostics", isDirectory: true)
|
|
try fileManager.createDirectory(at: contentsDirectory, withIntermediateDirectories: true)
|
defer { try? fileManager.removeItem(at: workingDirectory) }
|
|
try summaryJSON.write(
|
to: contentsDirectory.appendingPathComponent("summary.json"),
|
options: [.atomic]
|
)
|
try readmeText.write(
|
to: contentsDirectory.appendingPathComponent("README.txt"),
|
atomically: true,
|
encoding: .utf8
|
)
|
|
var copiedLogCount = 0
|
for (index, sourceURL) in eventLogURLs.enumerated() where fileManager.fileExists(atPath: sourceURL.path) {
|
let name = index == 0 ? "performance-events.log" : "performance-events-previous.log"
|
try sanitizedEventLogData(from: sourceURL).write(
|
to: contentsDirectory.appendingPathComponent(name),
|
options: [.atomic]
|
)
|
copiedLogCount += 1
|
}
|
|
if copiedLogCount == 0 {
|
try "No performance events have been recorded yet. Reproduce the issue, then export again.\n".write(
|
to: contentsDirectory.appendingPathComponent("performance-events.log"),
|
atomically: true,
|
encoding: .utf8
|
)
|
}
|
|
let temporaryArchiveURL = destinationURL
|
.deletingLastPathComponent()
|
.appendingPathComponent(".Aligner-Diagnostics-\(UUID().uuidString).zip")
|
defer { try? fileManager.removeItem(at: temporaryArchiveURL) }
|
try createArchive(
|
sourceDirectory: contentsDirectory,
|
destinationURL: temporaryArchiveURL
|
)
|
try fileManager.moveItem(at: temporaryArchiveURL, to: destinationURL)
|
return destinationURL
|
}
|
|
private static func createArchive(sourceDirectory: URL, destinationURL: URL) throws {
|
let process = Process()
|
process.executableURL = URL(fileURLWithPath: "/usr/bin/ditto")
|
process.arguments = [
|
"-c",
|
"-k",
|
"--sequesterRsrc",
|
"--keepParent",
|
sourceDirectory.path,
|
destinationURL.path
|
]
|
try process.run()
|
process.waitUntilExit()
|
guard process.terminationStatus == 0 else {
|
throw ArchiveError.dittoFailed(status: process.terminationStatus)
|
}
|
}
|
|
private static func sanitizedEventLogData(from sourceURL: URL) throws -> Data {
|
let source = try String(contentsOf: sourceURL, encoding: .utf8)
|
let sanitized = source
|
.split(whereSeparator: \.isNewline)
|
.compactMap(sanitizedEventLine)
|
.joined(separator: "\n")
|
return Data((sanitized.isEmpty ? "No exportable performance events were recorded.\n" : sanitized + "\n").utf8)
|
}
|
|
private static func sanitizedEventLine(_ line: Substring) -> String? {
|
let source = String(line)
|
guard let event = tokenValue(named: "event", in: source) else { return nil }
|
|
let allowedKeys = [
|
"ts",
|
"event",
|
"pid",
|
"runID",
|
"generation",
|
"durationMilliseconds",
|
"overlayOpenElapsedMilliseconds",
|
"startElapsedMilliseconds",
|
"snapshotStartElapsedMilliseconds",
|
"lastActivationDurationMilliseconds",
|
"appCount",
|
"windowCount",
|
"displayCount",
|
"spaceCount",
|
"screenshotEligibleCount",
|
"screenshotResolvedCount",
|
"screenshotPendingCount",
|
"screenshotNotRequestedCount",
|
"ranOnMainThread",
|
"result",
|
"reason"
|
]
|
let values = allowedKeys.compactMap { key -> String? in
|
let value = key == "event" ? event : tokenValue(named: key, in: source)
|
return value.map { "\(key)=\($0)" }
|
}
|
return values.isEmpty ? nil : values.joined(separator: " ")
|
}
|
|
private static func tokenValue(named key: String, in line: String) -> String? {
|
let prefix = "\(key)="
|
guard let range = line.range(of: prefix) else { return nil }
|
let suffix = line[range.upperBound...]
|
guard let first = suffix.first, first != "\"" else { return nil }
|
let value = suffix.prefix { !$0.isWhitespace }
|
return value.isEmpty ? nil : String(value)
|
}
|
|
private static let readmeText = """
|
Aligner performance diagnostics
|
|
This archive contains local performance information for troubleshooting:
|
- summary.json: app version, system, display, permissions, preferences, recent Quick Switch timings, application names, and window counts.
|
- performance-events.log: recent performance events with a fixed allowlist of timing and count fields.
|
|
It does not include window titles, screenshots, or typed text.
|
"""
|
|
private enum ArchiveError: LocalizedError {
|
case destinationAlreadyExists
|
case dittoFailed(status: Int32)
|
|
var errorDescription: String? {
|
switch self {
|
case .destinationAlreadyExists:
|
return "A diagnostic archive already exists at the selected location."
|
case .dittoFailed(let status):
|
return "Failed to create the diagnostic archive (ditto exit status \(status))."
|
}
|
}
|
}
|
}
|
