@atlaspack/profiler 2.14.35-dev-compiled-hash-e5f8a1735.0 → 2.15.0

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # @atlaspack/profiler
 
+## 2.15.0
+
+### Minor Changes
+
+- [#892](https://github.com/atlassian-labs/atlaspack/pull/892) [`617a318`](https://github.com/atlassian-labs/atlaspack/commit/617a318ddc9419b38360257353fec50b9051ee13) Thanks [@marcins](https://github.com/marcins)! - Added a new `shouldProfileNative` option that provides a way to pause and connect a native profiler to Atlaspack.
+
+### Patch Changes
+
+- Updated dependencies [[`8eb84ee`](https://github.com/atlassian-labs/atlaspack/commit/8eb84ee61a42bfe87c58079b610802b07a6a13e4), [`73168c2`](https://github.com/atlassian-labs/atlaspack/commit/73168c275a5d9abff9907bcf536b340bca1ed5f0), [`617a318`](https://github.com/atlassian-labs/atlaspack/commit/617a318ddc9419b38360257353fec50b9051ee13)]:
+  - @atlaspack/types-internal@2.21.0
+  - @atlaspack/utils@3.2.0
+  - @atlaspack/logger@2.14.31
+
+## 2.14.35
+
+### Patch Changes
+
+- Updated dependencies []:
+  - @atlaspack/types-internal@2.20.8
+
 ## 2.14.34
 
 ### Patch Changes

package/dist/NativeProfiler.js

@@ -0,0 +1,205 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@atlaspack/utils");
+const logger_1 = __importDefault(require("@atlaspack/logger"));
+const readline_1 = __importDefault(require("readline"));
+const chalk_1 = __importDefault(require("chalk"));
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+class NativeProfiler {
+    startProfiling(profilerType) {
+        const pid = process.pid;
+        const timeId = (0, utils_1.getTimeId)();
+        let filename;
+        let command;
+        logger_1.default.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) => 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) => {
+            const contentLength = stripAnsi(content).length;
+            const padding = Math.max(0, boxWidth - contentLength - 2);
+            return (chalk_1.default.blue('│') +
+                ' ' +
+                content +
+                ' '.repeat(padding) +
+                ' ' +
+                chalk_1.default.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) => {
+            return chalk_1.default.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_1.default.blue('┌' + '─'.repeat(boxWidth) + '┐'),
+            chalk_1.default.blue('│') +
+                ' '.repeat(titlePadding) +
+                chalk_1.default.blue.bold(title) +
+                ' '.repeat(boxWidth - title.length - titlePadding) +
+                chalk_1.default.blue('│'),
+            chalk_1.default.blue('├' + '─'.repeat(boxWidth) + '┤'),
+            padLine(`${chalk_1.default.gray('PID:')} ${chalk_1.default.white.bold(String(pid))}`),
+            padLine(''),
+            padLine(chalk_1.default.gray('Command:')),
+            padLine(makeCommandDisplay(command)),
+            padLine(''),
+            padLine(chalk_1.default.gray('Run the command above to start profiling.')),
+            padLine(chalk_1.default.gray(continueMessage)),
+            chalk_1.default.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((resolve) => {
+            let resolved = false;
+            const doResolve = () => {
+                if (resolved)
+                    return;
+                resolved = true;
+                logger_1.default.info({
+                    origin: '@atlaspack/profiler',
+                    message: 'Native profiling setup complete',
+                });
+                resolve();
+            };
+            const rl = readline_1.default.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);
+        });
+    }
+    waitForProfiler(profilerType, pid) {
+        logger_1.default.info({
+            origin: '@atlaspack/profiler',
+            message: 'Non-interactive mode: waiting for profiler to attach...',
+        });
+        return new Promise((resolve) => {
+            this.pollForProfiler(profilerType, pid, () => {
+                logger_1.default.info({
+                    origin: '@atlaspack/profiler',
+                    message: 'Native profiling setup complete',
+                });
+                resolve();
+            });
+        });
+    }
+    async pollForProfiler(profilerType, pid, onDetected) {
+        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_1.default.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_1.default.warn({
+            origin: '@atlaspack/profiler',
+            message: 'Could not detect profiler after 30 seconds, continuing anyway...',
+        });
+        onDetected();
+    }
+    async checkProfilerRunning(profilerType, pid) {
+        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) {
+            // If the command fails, log and return false
+            logger_1.default.warn({
+                origin: '@atlaspack/profiler',
+                message: `Error checking profiler status: ${error.message}`,
+            });
+            return false;
+        }
+    }
+}
+exports.default = NativeProfiler;

package/dist/index.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PluginTracer = exports.tracer = exports.Trace = exports.SamplingProfiler = void 0;
+exports.NativeProfiler = exports.PluginTracer = exports.tracer = exports.Trace = exports.SamplingProfiler = void 0;
 var SamplingProfiler_1 = require("./SamplingProfiler");
 Object.defineProperty(exports, "SamplingProfiler", { enumerable: true, get: function () { return __importDefault(SamplingProfiler_1).default; } });
 var Trace_1 = require("./Trace");
@@ -11,3 +11,5 @@ Object.defineProperty(exports, "Trace", { enumerable: true, get: function () { r
 var Tracer_1 = require("./Tracer");
 Object.defineProperty(exports, "tracer", { enumerable: true, get: function () { return Tracer_1.tracer; } });
 Object.defineProperty(exports, "PluginTracer", { enumerable: true, get: function () { return Tracer_1.PluginTracer; } });
+var NativeProfiler_1 = require("./NativeProfiler");
+Object.defineProperty(exports, "NativeProfiler", { enumerable: true, get: function () { return __importDefault(NativeProfiler_1).default; } });

package/lib/NativeProfiler.js

@@ -0,0 +1,235 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+function _utils() {
+  const data = require("@atlaspack/utils");
+  _utils = function () {
+    return data;
+  };
+  return data;
+}
+function _logger() {
+  const data = _interopRequireDefault(require("@atlaspack/logger"));
+  _logger = function () {
+    return data;
+  };
+  return data;
+}
+function _readline() {
+  const data = _interopRequireDefault(require("readline"));
+  _readline = function () {
+    return data;
+  };
+  return data;
+}
+function _chalk() {
+  const data = _interopRequireDefault(require("chalk"));
+  _chalk = function () {
+    return data;
+  };
+  return data;
+}
+function _child_process() {
+  const data = require("child_process");
+  _child_process = function () {
+    return data;
+  };
+  return data;
+}
+function _util() {
+  const data = require("util");
+  _util = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const execAsync = (0, _util().promisify)(_child_process().exec);
+class NativeProfiler {
+  startProfiling(profilerType) {
+    const pid = process.pid;
+    const timeId = (0, _utils().getTimeId)();
+    let filename;
+    let command;
+    _logger().default.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 => 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 => {
+      const contentLength = stripAnsi(content).length;
+      const padding = Math.max(0, boxWidth - contentLength - 2);
+      return _chalk().default.blue('│') + ' ' + content + ' '.repeat(padding) + ' ' + _chalk().default.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 => {
+      return _chalk().default.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().default.blue('┌' + '─'.repeat(boxWidth) + '┐'), _chalk().default.blue('│') + ' '.repeat(titlePadding) + _chalk().default.blue.bold(title) + ' '.repeat(boxWidth - title.length - titlePadding) + _chalk().default.blue('│'), _chalk().default.blue('├' + '─'.repeat(boxWidth) + '┤'), padLine(`${_chalk().default.gray('PID:')} ${_chalk().default.white.bold(String(pid))}`), padLine(''), padLine(_chalk().default.gray('Command:')), padLine(makeCommandDisplay(command)), padLine(''), padLine(_chalk().default.gray('Run the command above to start profiling.')), padLine(_chalk().default.gray(continueMessage)), _chalk().default.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(resolve => {
+      let resolved = false;
+      const doResolve = () => {
+        if (resolved) return;
+        resolved = true;
+        _logger().default.info({
+          origin: '@atlaspack/profiler',
+          message: 'Native profiling setup complete'
+        });
+        resolve();
+      };
+      const rl = _readline().default.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);
+    });
+  }
+  waitForProfiler(profilerType, pid) {
+    _logger().default.info({
+      origin: '@atlaspack/profiler',
+      message: 'Non-interactive mode: waiting for profiler to attach...'
+    });
+    return new Promise(resolve => {
+      this.pollForProfiler(profilerType, pid, () => {
+        _logger().default.info({
+          origin: '@atlaspack/profiler',
+          message: 'Native profiling setup complete'
+        });
+        resolve();
+      });
+    });
+  }
+  async pollForProfiler(profilerType, pid, onDetected) {
+    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().default.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().default.warn({
+      origin: '@atlaspack/profiler',
+      message: 'Could not detect profiler after 30 seconds, continuing anyway...'
+    });
+    onDetected();
+  }
+  async checkProfilerRunning(profilerType, pid) {
+    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) {
+      // If the command fails, log and return false
+      _logger().default.warn({
+        origin: '@atlaspack/profiler',
+        message: `Error checking profiler status: ${error.message}`
+      });
+      return false;
+    }
+  }
+}
+exports.default = NativeProfiler;

package/lib/index.js

@@ -3,6 +3,12 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+Object.defineProperty(exports, "NativeProfiler", {
+  enumerable: true,
+  get: function () {
+    return _NativeProfiler.default;
+  }
+});
 Object.defineProperty(exports, "PluginTracer", {
   enumerable: true,
   get: function () {
@@ -30,4 +36,5 @@ Object.defineProperty(exports, "tracer", {
 var _SamplingProfiler = _interopRequireDefault(require("./SamplingProfiler"));
 var _Trace = _interopRequireDefault(require("./Trace"));
 var _Tracer = require("./Tracer");
+var _NativeProfiler = _interopRequireDefault(require("./NativeProfiler"));
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

package/lib/types/NativeProfiler.d.ts

@@ -0,0 +1,7 @@
+export type NativeProfilerType = 'instruments' | 'samply';
+export default class NativeProfiler {
+    startProfiling(profilerType: NativeProfilerType): Promise<void>;
+    private waitForProfiler;
+    private pollForProfiler;
+    private checkProfilerRunning;
+}

package/lib/types/index.d.ts

@@ -2,3 +2,5 @@ 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/profiler",
-  "version": "2.14.35-dev-compiled-hash-e5f8a1735.0",
+  "version": "2.15.0",
   "description": "Blazing fast, zero configuration web application bundler",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
@@ -20,11 +20,13 @@
     "build:lib": "gulp build --gulpfile ../../../gulpfile.js --cwd ."
   },
   "dependencies": {
-    "@atlaspack/diagnostic": "2.14.5-dev-compiled-hash-e5f8a1735.0",
-    "@atlaspack/events": "2.14.5-dev-compiled-hash-e5f8a1735.0",
-    "@atlaspack/types-internal": "2.20.8-dev-compiled-hash-e5f8a1735.0",
+    "@atlaspack/diagnostic": "2.14.4",
+    "@atlaspack/events": "2.14.4",
+    "@atlaspack/types-internal": "2.21.0",
+    "@atlaspack/logger": "2.14.31",
+    "@atlaspack/utils": "3.2.0",
+    "chalk": "^4.1.2",
     "chrome-trace-event": "^1.0.2"
   },
-  "type": "commonjs",
-  "gitHead": "e5f8a173505611c1fafafd6e7dddb2f6b483f67c"
+  "type": "commonjs"
 }