feat(profiler): add 'hack' functions for instruments profiler

Author: GuillaumeEgret

packages/core/types/index.ts

@@ -85,4 +85,6 @@ export interface Profiler {
   cleanup: () => void;
   getScreenRecorder: (videoPath: string) => ScreenRecorder | undefined;
   stopApp: (bundleId: string) => Promise<void>;
+  waitUntilReady: (bundleId: string) => Promise<void>;
+  getMeasures: () => Promise<void>;
 }

packages/platforms/android/src/index.ts

@@ -12,6 +12,12 @@ export { waitFor } from "./utils/waitFor";
 export { executeAsync, executeCommand } from "./commands/shell";
 
 export class AndroidProfiler implements Profiler {
+  waitUntilReady = (bundleId: string) => {
+    return new Promise<void>((resolve) => resolve());
+  };
+  getMeasures = () => {
+    return new Promise<void>((resolve) => resolve());
+  };
   pollPerformanceMeasures = pollPerformanceMeasures;
   detectCurrentBundleId = profiler.detectCurrentBundleId;
   installProfilerOnDevice = ensureCppProfilerIsInstalled;

packages/platforms/ios-instruments/src/index.ts

@@ -1,6 +1,64 @@
 import { Measure, Profiler, ProfilerPollingOptions, ScreenRecorder } from "@perf-profiler/types";
+import { ChildProcess } from "child_process";
+// TODO: refactor so that these functions are not in android
+// eslint-disable-next-line import/no-extraneous-dependencies
+import { executeAsync, executeCommand } from "@perf-profiler/android";
+import { IdbDevice, getConnectedDevice, killApp, launchApp } from "./utils/DeviceManager";
+import { computeMeasures } from "./XcodePerfParser";
+import { getTmpFilePath, removeTmpFiles } from "./utils/tmpFileManager";
 export { killApp } from "./utils/DeviceManager";
 
+const startRecord = async (
+  deviceUdid: string,
+  appPid: number,
+  traceFile: string
+): Promise<ChildProcess> => {
+  const templateFilePath = `${__dirname}/../Flashlight.tracetemplate`;
+  const recordingProcess = executeAsync(
+    `xcrun xctrace record --device ${deviceUdid} --template ${templateFilePath} --attach ${appPid} --output ${traceFile}`
+  );
+  await new Promise<void>((resolve) => {
+    recordingProcess.stdout?.on("data", (data) => {
+      if (data.toString().includes("Ctrl-C to stop")) {
+        resolve();
+      }
+    });
+  });
+  return recordingProcess;
+};
+
+const saveTraceFile = (traceFile: string): string => {
+  const xmlOutputFile = getTmpFilePath("report.xml");
+  executeCommand(
+    `xctrace export --input ${traceFile} --xpath '/trace-toc/run[@number="1"]/data/table[@schema="time-profile"]' --output ${xmlOutputFile}`
+  );
+  return xmlOutputFile;
+};
+
+const stopPerfRecord = async (
+  recordingProcess: ChildProcess,
+  traceFile: string,
+  onMeasure: (measure: Measure) => void
+) => {
+  try {
+    await new Promise<void>((resolve) => {
+      recordingProcess.stdout?.on("data", (data) => {
+        if (data.toString().includes("Output file saved as")) {
+          resolve();
+        }
+      });
+    });
+  } catch (e) {
+    console.log("Error while recording: ", e);
+  }
+  const xmlFile = saveTraceFile(traceFile);
+  const measures = computeMeasures(xmlFile);
+  measures.forEach((measure) => {
+    onMeasure(measure);
+  });
+  removeTmpFiles();
+};
+
 export class IOSInstrumentsProfiler implements Profiler {
   connectedDevice: IdbDevice | undefined;
   recordingProcess: ChildProcess | undefined;
@@ -33,6 +91,28 @@ export class IOSInstrumentsProfiler implements Profiler {
   cleanup: () => void = () => {
     // Do we need anything here?
   };
+
+  async waitUntilReady(bundleId: string): Promise<void> {
+    this.connectedDevice = getConnectedDevice();
+    if (!this.connectedDevice) {
+      throw new Error("No device connected");
+    }
+    this.bundleId = bundleId;
+    this.pid = launchApp(bundleId);
+    const traceFile = `report_${new Date().getTime()}.trace`;
+    this.traceFile = traceFile;
+    this.recordingProcess = await startRecord(this.connectedDevice.udid, this.pid, traceFile);
+  }
+
+  async getMeasures(): Promise<void> {
+    if (!this.recordingProcess || !this.traceFile || !this.pid || !this.onMeasure || !this.bundleId)
+      throw new Error("Profiler is not ready to get measures");
+    const recordingProcess = this.recordingProcess;
+    const traceFile = this.traceFile;
+    killApp(this.bundleId);
+    await stopPerfRecord(recordingProcess, traceFile, this.onMeasure);
+  }
+
   async stopApp(bundleId: string): Promise<void> {
     killApp(bundleId);
     return new Promise<void>((resolve) => resolve());

packages/platforms/ios/src/index.ts

@@ -104,4 +104,12 @@ export class IOSProfiler implements Profiler {
     killApp(bundleId);
     return new Promise<void>((resolve) => resolve());
   }
+
+  async waitUntilReady(bundleId: string): Promise<void> {
+    return new Promise<void>((resolve) => resolve());
+  }
+
+  async getMeasures(): Promise<void> {
+    return new Promise<void>((resolve) => resolve());
+  }
 }