@atlaspack/profiler 2.14.1-canary.43 → 2.14.1-canary.430

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/profiler",
-  "version": "2.14.1-canary.43+47cfa92f1",
+  "version": "2.14.1-canary.430+8acee7f43",
   "description": "Blazing fast, zero configuration web application bundler",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
@@ -10,21 +10,24 @@
     "type": "git",
     "url": "https://github.com/atlassian-labs/atlaspack.git"
   },
-  "main": "lib/index.js",
-  "source": "src/index.js",
+  "main": "./lib/index.js",
+  "source": "./src/index.ts",
+  "types": "./lib/types/index.d.ts",
   "engines": {
     "node": ">= 16.0.0"
   },
   "scripts": {
-    "build-ts": "flow-to-ts src/*.js --write && rm -f ./src/*.d.ts && tsc --emitDeclarationOnly --declaration --esModuleInterop --target es2015 --moduleResolution node16 --module node16 src/*.ts && mkdir -p lib && mv src/*.d.ts lib/. && rm src/*.ts && node build-ts.js",
-    "check-ts": "tsc --noEmit lib/index.d.ts"
+    "build:lib": "gulp build --gulpfile ../../../gulpfile.js --cwd ."
   },
   "dependencies": {
-    "@atlaspack/diagnostic": "2.14.1-canary.43+47cfa92f1",
-    "@atlaspack/events": "2.14.1-canary.43+47cfa92f1",
-    "@atlaspack/types-internal": "2.14.1-canary.43+47cfa92f1",
+    "@atlaspack/diagnostic": "2.14.1-canary.430+8acee7f43",
+    "@atlaspack/events": "2.14.1-canary.430+8acee7f43",
+    "@atlaspack/logger": "2.14.5-canary.362+8acee7f43",
+    "@atlaspack/types-internal": "2.14.1-canary.430+8acee7f43",
+    "@atlaspack/utils": "2.14.5-canary.362+8acee7f43",
+    "chalk": "^4.1.2",
     "chrome-trace-event": "^1.0.2"
   },
   "type": "commonjs",
-  "gitHead": "47cfa92f1e2dfae9abcc2db48269f3ce64f98fe3"
-}
+  "gitHead": "8acee7f433511c6e33b02ce793e01ed347ecd6d8"
+}

package/src/NativeProfiler.ts

@@ -0,0 +1,245 @@
+import {getTimeId} from '@atlaspack/utils';
+import logger from '@atlaspack/logger';
+import readline from 'readline';
+import chalk from 'chalk';
+import {exec} from 'child_process';
+import {promisify} from 'util';
+
+const execAsync = promisify(exec);
+
+export type NativeProfilerType = 'instruments' | 'samply';
+
+export default class NativeProfiler {
+  startProfiling(profilerType: NativeProfilerType): Promise<void> {
+    const pid = process.pid;
+    const timeId = getTimeId();
+
+    let filename: string;
+    let command: string;
+
+    logger.info({
+      origin: '@atlaspack/profiler',
+      message: 'Starting native profiling...',
+    });
+
+    if (profilerType === 'instruments') {
+      filename = `native-profile-${timeId}.trace`;
+      command = `xcrun xctrace record --template "CPU Profiler" --output ${filename} --attach ${pid}`;
+    } else {
+      filename = `native-profile-${timeId}.json`;
+      command = `samply record --save-only --output ${filename} --pid ${pid}`;
+    }
+
+    // Display banner with PID and command
+    // Strip ANSI codes for length calculation
+    // eslint-disable-next-line no-control-regex
+    const stripAnsi = (str: string) => str.replace(/\u001b\[[0-9;]*m/g, '');
+    const boxWidth = Math.max(60, stripAnsi(command).length + 6);
+    const title = 'Native Profiling';
+    const titlePadding = Math.floor((boxWidth - title.length - 2) / 2);
+    const isTTY = process.stdin.isTTY;
+    const maxWaitTime = 30; // seconds
+
+    const padLine = (content: string) => {
+      const contentLength = stripAnsi(content).length;
+      const padding = Math.max(0, boxWidth - contentLength - 2);
+      return (
+        chalk.blue('│') +
+        ' ' +
+        content +
+        ' '.repeat(padding) +
+        ' ' +
+        chalk.blue('│')
+      );
+    };
+
+    // Make the command visually distinct and easy to copy
+    // Note: Hyperlinks can cause issues with commands (words become separate links)
+    // So we just make it visually prominent with colors
+    const makeCommandDisplay = (cmd: string) => {
+      return chalk.cyan.bold(cmd);
+    };
+
+    // Contextual message based on TTY
+    const continueMessage = isTTY
+      ? 'Press Enter or start the profiler to continue'
+      : `Build will continue when profiler has started, or after ${maxWaitTime}s`;
+
+    const banner = [
+      '',
+      chalk.blue('┌' + '─'.repeat(boxWidth) + '┐'),
+      chalk.blue('│') +
+        ' '.repeat(titlePadding) +
+        chalk.blue.bold(title) +
+        ' '.repeat(boxWidth - title.length - titlePadding) +
+        chalk.blue('│'),
+      chalk.blue('├' + '─'.repeat(boxWidth) + '┤'),
+      padLine(`${chalk.gray('PID:')} ${chalk.white.bold(String(pid))}`),
+      padLine(''),
+      padLine(chalk.gray('Command:')),
+      padLine(makeCommandDisplay(command)),
+      padLine(''),
+      padLine(chalk.gray('Run the command above to start profiling.')),
+      padLine(chalk.gray(continueMessage)),
+      chalk.blue('└' + '─'.repeat(boxWidth) + '┘'),
+      '',
+    ].join('\n');
+
+    // eslint-disable-next-line no-console
+    console.log(banner);
+
+    // In both interactive and non-interactive mode, detect when profiler is running
+    // In interactive mode, also allow user to press Enter to continue
+    if (!process.stdin.isTTY) {
+      return this.waitForProfiler(profilerType, pid);
+    }
+
+    // Interactive mode: wait for either user to press Enter OR profiler to be detected
+    return new Promise<void>((resolve) => {
+      let resolved = false;
+      const doResolve = () => {
+        if (resolved) return;
+        resolved = true;
+        logger.info({
+          origin: '@atlaspack/profiler',
+          message: 'Native profiling setup complete',
+        });
+        resolve();
+      };
+
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+      });
+
+      // User presses Enter
+      rl.on('line', () => {
+        rl.close();
+        doResolve();
+      });
+
+      // Also poll for profiler in the background
+      this.pollForProfiler(profilerType, pid, doResolve);
+    });
+  }
+
+  private waitForProfiler(
+    profilerType: NativeProfilerType,
+    pid: number,
+  ): Promise<void> {
+    logger.info({
+      origin: '@atlaspack/profiler',
+      message: 'Non-interactive mode: waiting for profiler to attach...',
+    });
+
+    return new Promise<void>((resolve) => {
+      this.pollForProfiler(profilerType, pid, () => {
+        logger.info({
+          origin: '@atlaspack/profiler',
+          message: 'Native profiling setup complete',
+        });
+        resolve();
+      });
+    });
+  }
+
+  private async pollForProfiler(
+    profilerType: NativeProfilerType,
+    pid: number,
+    onDetected: () => void,
+  ): Promise<void> {
+    const maxAttempts = 60; // 60 attempts * 500ms = 30 seconds max
+    const pollInterval = 500; // 500ms between checks
+
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      const isRunning = await this.checkProfilerRunning(profilerType, pid);
+
+      if (isRunning) {
+        // Instruments takes longer to start up (~5s), samply needs ~1s
+        const waitTime = profilerType === 'instruments' ? 5000 : 1000;
+        logger.info({
+          origin: '@atlaspack/profiler',
+          message: `Profiler detected, waiting ${waitTime}ms before continuing...`,
+        });
+        await new Promise((resolve) => setTimeout(resolve, waitTime));
+        onDetected();
+        return;
+      }
+
+      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    }
+
+    // If we couldn't detect the profiler after 30 seconds, log a warning and continue anyway
+    logger.warn({
+      origin: '@atlaspack/profiler',
+      message:
+        'Could not detect profiler after 30 seconds, continuing anyway...',
+    });
+    onDetected();
+  }
+
+  private async checkProfilerRunning(
+    profilerType: NativeProfilerType,
+    pid: number,
+  ): Promise<boolean> {
+    try {
+      // Get all processes and filter in JavaScript
+      const {stdout} = await execAsync('ps aux');
+      const lines = stdout.split('\n').filter((line) => line.trim().length > 0);
+
+      // Use word boundaries to match the PID as a complete number
+      const pidRegex = new RegExp(`\\b${pid}\\b`);
+
+      // Determine the profiler process name to look for
+      const profilerName =
+        profilerType === 'instruments' ? 'xctrace' : 'samply';
+
+      for (const line of lines) {
+        const lowerLine = line.toLowerCase();
+
+        // Skip lines that are part of our own process checking (avoid false positives)
+        // Skip lines containing "ps aux" or "grep" to avoid matching our own commands
+        if (lowerLine.includes('ps aux') || lowerLine.includes(' grep ')) {
+          continue;
+        }
+
+        // Skip our own process (the Atlaspack process itself)
+        // The PID column is the second field in ps aux output
+        const fields = line.trim().split(/\s+/);
+        if (fields.length >= 2 && fields[1] === String(pid)) {
+          continue;
+        }
+
+        // Check if this line contains the profiler name as a command
+        const profilerRegex = new RegExp(`\\b${profilerName}\\b`);
+        if (!profilerRegex.test(lowerLine)) {
+          continue;
+        }
+
+        // Now check if our PID appears in the command arguments (not in the PID column)
+        // The PID should appear after the profiler command, typically as --pid <pid> or --attach <pid>
+        // We need to check the command portion, which starts around column 11 in ps aux
+        // For safety, check if PID appears after the profiler name in the line
+        const profilerIndex = lowerLine.indexOf(profilerName);
+        if (profilerIndex === -1) {
+          continue;
+        }
+
+        // Check if PID appears in the command portion (after the profiler name)
+        const commandPortion = line.substring(profilerIndex);
+        if (pidRegex.test(commandPortion)) {
+          return true;
+        }
+      }
+
+      return false;
+    } catch (error: any) {
+      // If the command fails, log and return false
+      logger.warn({
+        origin: '@atlaspack/profiler',
+        message: `Error checking profiler status: ${error.message}`,
+      });
+      return false;
+    }
+  }
+}

package/src/{SamplingProfiler.js → SamplingProfiler.ts}

@@ -1,50 +1,50 @@
-// @flow
 import type {Session} from 'inspector';
 import invariant from 'assert';
 import ThrowableDiagnostic from '@atlaspack/diagnostic';
 
 // https://chromedevtools.github.io/devtools-protocol/tot/Profiler#type-Profile
-export type Profile = {|
-  nodes: Array<ProfileNode>,
-  startTime: number,
-  endTime: number,
-  samples?: Array<number>,
-  timeDeltas?: Array<number>,
-|};
+export type Profile = {
+  nodes: Array<ProfileNode>;
+  startTime: number;
+  endTime: number;
+  samples?: Array<number>;
+  timeDeltas?: Array<number>;
+};
 
 // https://chromedevtools.github.io/devtools-protocol/tot/Profiler#type-ProfileNode
-type ProfileNode = {|
-  id: number,
-  callFrame: CallFrame,
-  hitCount?: number,
-  children?: Array<number>,
-  deoptReason?: string,
-  positionTicks?: PositionTickInfo,
-|};
+type ProfileNode = {
+  id: number;
+  callFrame: CallFrame;
+  hitCount?: number;
+  children?: Array<number>;
+  deoptReason?: string;
+  positionTicks?: PositionTickInfo;
+};
 
 // https://chromedevtools.github.io/devtools-protocol/tot/Runtime#type-CallFrame
-type CallFrame = {|
-  functionName: string,
-  scriptId: string,
-  url: string,
-  lineNumber: string,
-  columnNumber: string,
-|};
+type CallFrame = {
+  functionName: string;
+  scriptId: string;
+  url: string;
+  lineNumber: string;
+  columnNumber: string;
+};
 
 // https://chromedevtools.github.io/devtools-protocol/tot/Profiler#type-PositionTickInfo
-type PositionTickInfo = {|
-  line: number,
-  ticks: number,
-|};
+type PositionTickInfo = {
+  line: number;
+  ticks: number;
+};
 
 export default class SamplingProfiler {
+  // @ts-expect-error not initialized
   session: Session;
 
-  startProfiling(): Promise<mixed> {
+  startProfiling(): Promise<unknown> {
     let inspector;
     try {
       inspector = require('inspector');
-    } catch (err) {
+    } catch (err: any) {
       throw new ThrowableDiagnostic({
         diagnostic: {
           message: `The inspector module isn't available`,
@@ -68,18 +68,37 @@ export default class SamplingProfiler {
 
   sendCommand(
     method: string,
-    params?: mixed,
-  ): Promise<{profile: Profile, ...}> {
+    params?: any,
+  ): Promise<{
+    profile: Profile;
+  }> {
     invariant(this.session != null);
-    return new Promise((resolve, reject) => {
-      this.session.post(method, params, (err, p) => {
-        if (err == null) {
-          resolve((p: {profile: Profile, ...}));
-        } else {
-          reject(err);
-        }
-      });
-    });
+    return new Promise(
+      (
+        resolve: (
+          result:
+            | Promise<{
+                profile: Profile;
+              }>
+            | {
+                profile: Profile;
+              },
+        ) => void,
+        reject: (error?: any) => void,
+      ) => {
+        this.session.post(method, params, (err, p) => {
+          if (err == null) {
+            resolve(
+              p as {
+                profile: Profile;
+              },
+            );
+          } else {
+            reject(err);
+          }
+        });
+      },
+    );
   }
 
   destroy() {

package/src/{Trace.js → Trace.ts}

@@ -1,4 +1,3 @@
-// @flow
 import type {Profile} from './SamplingProfiler';
 import type {Writable} from 'stream';
 import {Tracer} from 'chrome-trace-event';

package/src/{Tracer.js → Tracer.ts}

@@ -1,19 +1,17 @@
-// @flow strict-local
-
 import type {
   TraceEvent,
   IDisposable,
   PluginTracer as IPluginTracer,
-} from '@atlaspack/types';
+} from '@atlaspack/types-internal';
 import type {
   TraceMeasurement as ITraceMeasurement,
   TraceMeasurementData,
 } from './types';
-// @ts-ignore
 import {ValueEmitter} from '@atlaspack/events';
 
 import {performance} from 'perf_hooks';
 
+// @ts-expect-error TS7034
 let tid;
 try {
   tid = require('worker_threads').threadId;
@@ -29,9 +27,14 @@ class TraceMeasurement implements ITraceMeasurement {
   #pid: number;
   #tid: number;
   #start: number;
-  // $FlowFixMe
   #data: any;
-  constructor(tracer: Tracer, name, pid, tid, data) {
+  constructor(
+    tracer: Tracer,
+    name: string,
+    pid: number,
+    tid: number,
+    data: TraceMeasurementData,
+  ) {
     this.#name = name;
     this.#pid = pid;
     this.#tid = tid;
@@ -60,11 +63,11 @@ export default class Tracer {
 
   #enabled: boolean = false;
 
-  onTrace(cb: (event: TraceEvent) => mixed): IDisposable {
+  onTrace(cb: (event: TraceEvent) => unknown): IDisposable {
     return this.#traceEmitter.addListener(cb);
   }
 
-  async wrap(name: string, fn: () => mixed): Promise<void> {
+  async wrap(name: string, fn: () => unknown): Promise<void> {
     let measurement = this.createMeasurement(name);
     try {
       await fn();
@@ -77,17 +80,22 @@ export default class Tracer {
     name: string,
     category: string = 'Core',
     argumentName?: string,
-    otherArgs?: {[key: string]: mixed},
+    otherArgs?: {
+      [key: string]: unknown;
+    },
   ): ITraceMeasurement | null {
     if (!this.enabled) return null;
 
     // We create `args` in a fairly verbose way to avoid object
     // allocation where not required.
-    let args: {[key: string]: mixed};
+    let args: {
+      [key: string]: unknown;
+    };
     if (typeof argumentName === 'string') {
       args = {name: argumentName};
     }
     if (typeof otherArgs === 'object') {
+      // @ts-expect-error TS2454
       if (typeof args == 'undefined') {
         args = {};
       }
@@ -98,9 +106,11 @@ export default class Tracer {
 
     const data: TraceMeasurementData = {
       categories: [category],
+      // @ts-expect-error TS2454
       args,
     };
 
+    // @ts-expect-error TS7005
     return new TraceMeasurement(this, name, pid, tid, data);
   }
 
@@ -124,10 +134,10 @@ export default class Tracer {
 
 export const tracer: Tracer = new Tracer();
 
-type TracerOpts = {|
-  origin: string,
-  category: string,
-|};
+type TracerOpts = {
+  origin: string;
+  category: string;
+};
 export class PluginTracer implements IPluginTracer {
   /** @private */
   origin: string;
@@ -149,7 +159,9 @@ export class PluginTracer implements IPluginTracer {
     name: string,
     category?: string,
     argumentName?: string,
-    otherArgs?: {[key: string]: mixed},
+    otherArgs?: {
+      [key: string]: unknown;
+    },
   ): ITraceMeasurement | null {
     return tracer.createMeasurement(
       name,

package/src/{index.js → index.ts}

@@ -1,5 +1,6 @@
-// @flow
 export {default as SamplingProfiler} from './SamplingProfiler';
 export {default as Trace} from './Trace';
 export {tracer, PluginTracer} from './Tracer';
 export type {TraceMeasurement, TraceMeasurementData} from './types';
+export {default as NativeProfiler} from './NativeProfiler';
+export type {NativeProfilerType} from './NativeProfiler';

package/src/types.ts

@@ -0,0 +1,8 @@
+export type {TraceMeasurement} from '@atlaspack/types-internal';
+
+export type TraceMeasurementData = {
+  readonly categories: string[];
+  readonly args?: {
+    [key: string]: unknown;
+  };
+};

package/test/{Tracer.test.js → Tracer.test.ts}

@@ -1,11 +1,10 @@
-// @flow
 import {tracer, PluginTracer} from '../src/Tracer';
 import sinon from 'sinon';
 import assert from 'assert';
 
 describe('Tracer', () => {
-  let onTrace;
-  let traceDisposable;
+  let onTrace: any;
+  let traceDisposable: any;
   beforeEach(() => {
     onTrace = sinon.spy();
     traceDisposable = tracer.onTrace(onTrace);

package/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "extends": "../../../tsconfig.base.json",
+  "include": ["src"],
+  "compilerOptions": {
+    "composite": true
+  },
+  "references": [
+    {
+      "path": "../../utils/events/tsconfig.json"
+    },
+    {
+      "path": "../diagnostic/tsconfig.json"
+    },
+    {
+      "path": "../types-internal/tsconfig.json"
+    },
+    {
+      "path": "../logger/tsconfig.json"
+    },
+    {
+      "path": "../utils/tsconfig.json"
+    }
+  ]
+}