@parcel/workers 2.8.3 → 2.9.0

package/lib/threads/ThreadsChild.js

@@ -4,66 +4,46 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-
 function _worker_threads() {
   const data = require("worker_threads");
-
   _worker_threads = function () {
     return data;
   };
-
   return data;
 }
-
 function _nullthrows() {
   const data = _interopRequireDefault(require("nullthrows"));
-
   _nullthrows = function () {
     return data;
   };
-
   return data;
 }
-
 var _childState = require("../childState");
-
 var _child = require("../child");
-
 function _core() {
   const data = require("@parcel/core");
-
   _core = function () {
     return data;
   };
-
   return data;
 }
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 class ThreadsChild {
   constructor(onMessage, onExit) {
     if (_worker_threads().isMainThread || !_worker_threads().parentPort) {
       throw new Error('Only create ThreadsChild instances in a worker!');
     }
-
     this.onMessage = onMessage;
     this.onExit = onExit;
-
     _worker_threads().parentPort.on('message', data => this.handleMessage(data));
-
     _worker_threads().parentPort.on('close', this.onExit);
   }
-
   handleMessage(data) {
     this.onMessage((0, _core().restoreDeserializedObject)(data));
   }
-
   send(data) {
     (0, _nullthrows().default)(_worker_threads().parentPort).postMessage((0, _core().prepareForSerialization)(data));
   }
-
 }
-
 exports.default = ThreadsChild;
 (0, _childState.setChild)(new _child.Child(ThreadsChild));

package/lib/threads/ThreadsWorker.js

@@ -4,41 +4,29 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-
 function _worker_threads() {
   const data = require("worker_threads");
-
   _worker_threads = function () {
     return data;
   };
-
   return data;
 }
-
 function _path() {
   const data = _interopRequireDefault(require("path"));
-
   _path = function () {
     return data;
   };
-
   return data;
 }
-
 function _core() {
   const data = require("@parcel/core");
-
   _core = function () {
     return data;
   };
-
   return data;
 }
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 const WORKER_PATH = _path().default.join(__dirname, 'ThreadsChild.js');
-
 class ThreadsWorker {
   constructor(execArgv, onMessage, onError, onExit) {
     this.execArgv = execArgv;
@@ -46,7 +34,6 @@ class ThreadsWorker {
     this.onError = onError;
     this.onExit = onExit;
   }
-
   start() {
     this.worker = new (_worker_threads().Worker)(WORKER_PATH, {
       execArgv: this.execArgv,
@@ -59,21 +46,16 @@ class ThreadsWorker {
       this.worker.on('online', resolve);
     });
   }
-
   stop() {
     // In node 12, this returns a promise, but previously it accepted a callback
     // TODO: Pass a callback in earlier versions of Node
     return Promise.resolve(this.worker.terminate());
   }
-
   handleMessage(data) {
     this.onMessage((0, _core().restoreDeserializedObject)(data));
   }
-
   send(data) {
     this.worker.postMessage((0, _core().prepareForSerialization)(data));
   }
-
 }
-
 exports.default = ThreadsWorker;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@parcel/workers",
-  "version": "2.8.3",
+  "version": "2.9.0",
   "description": "Blazing fast, zero configuration web application bundler",
   "license": "MIT",
   "publishConfig": {
@@ -21,20 +21,20 @@
     "node": ">= 12.0.0"
   },
   "dependencies": {
-    "@parcel/diagnostic": "2.8.3",
-    "@parcel/logger": "2.8.3",
-    "@parcel/types": "2.8.3",
-    "@parcel/utils": "2.8.3",
-    "chrome-trace-event": "^1.0.2",
+    "@parcel/diagnostic": "2.9.0",
+    "@parcel/logger": "2.9.0",
+    "@parcel/profiler": "2.9.0",
+    "@parcel/types": "2.9.0",
+    "@parcel/utils": "2.9.0",
     "nullthrows": "^1.1.1"
   },
   "peerDependencies": {
-    "@parcel/core": "^2.8.3"
+    "@parcel/core": "^2.9.0"
   },
   "browser": {
     "./src/cpuCount.js": false,
     "./src/process/ProcessWorker.js": false,
     "./src/threads/ThreadsWorker.js": false
   },
-  "gitHead": "349a6caf40ec8abb6a49fcae0765f8f8deb2073d"
+  "gitHead": "dd9435be8afed35c5ffc161cf4b586fd6c78fc1f"
 }

package/src/Worker.js

@@ -23,6 +23,7 @@ type WorkerOpts = {|
   forcedKillTime: number,
   backend: BackendType,
   shouldPatchConsole?: boolean,
+  shouldTrace?: boolean,
   sharedReferences: $ReadOnlyMap<SharedReference, mixed>,
 |};
 
@@ -108,6 +109,7 @@ export default class Worker extends EventEmitter {
           forkModule,
           {
             shouldPatchConsole: !!this.options.shouldPatchConsole,
+            shouldTrace: !!this.options.shouldTrace,
           },
         ],
         retries: 0,

package/src/WorkerFarm.js

@@ -26,8 +26,7 @@ import cpuCount from './cpuCount';
 import Handle from './Handle';
 import {child} from './childState';
 import {detectBackend} from './backend';
-import Profiler from './Profiler';
-import Trace from './Trace';
+import {SamplingProfiler, Trace} from '@parcel/profiler';
 import fs from 'fs';
 import logger from '@parcel/logger';
 
@@ -44,6 +43,7 @@ export type FarmOptions = {|
   workerPath?: FilePath,
   backend: BackendType,
   shouldPatchConsole?: boolean,
+  shouldTrace?: boolean,
 |};
 
 type WorkerModule = {|
@@ -60,6 +60,8 @@ export type WorkerApi = {|
 
 export {Handle};
 
+const DEFAULT_MAX_CONCURRENT_CALLS: number = 30;
+
 /**
  * workerPath should always be defined inside farmOptions
  */
@@ -77,13 +79,15 @@ export default class WorkerFarm extends EventEmitter {
   sharedReferences: Map<SharedReference, mixed> = new Map();
   sharedReferencesByValue: Map<mixed, SharedReference> = new Map();
   serializedSharedReferences: Map<SharedReference, ?ArrayBuffer> = new Map();
-  profiler: ?Profiler;
+  profiler: ?SamplingProfiler;
 
   constructor(farmOptions: $Shape<FarmOptions> = {}) {
     super();
     this.options = {
       maxConcurrentWorkers: WorkerFarm.getNumWorkers(),
-      maxConcurrentCallsPerWorker: WorkerFarm.getConcurrentCallsPerWorker(),
+      maxConcurrentCallsPerWorker: WorkerFarm.getConcurrentCallsPerWorker(
+        farmOptions.shouldTrace ? 1 : DEFAULT_MAX_CONCURRENT_CALLS,
+      ),
       forcedKillTime: 500,
       warmWorkers: false,
       useLocalWorker: true, // TODO: setting this to false makes some tests fail, figure out why
@@ -192,6 +196,10 @@ export default class WorkerFarm extends EventEmitter {
   }
 
   createHandle(method: string, useMainThread: boolean = false): HandleFunction {
+    if (!this.options.useLocalWorker) {
+      useMainThread = false;
+    }
+
     return async (...args) => {
       // Child process workers are slow to start (~600ms).
       // While we're waiting, just run on the main thread.
@@ -235,6 +243,7 @@ export default class WorkerFarm extends EventEmitter {
       forcedKillTime: this.options.forcedKillTime,
       backend: this.options.backend,
       shouldPatchConsole: this.options.shouldPatchConsole,
+      shouldTrace: this.options.shouldTrace,
       sharedReferences: this.sharedReferences,
     });
 
@@ -512,7 +521,7 @@ export default class WorkerFarm extends EventEmitter {
       );
     }
 
-    this.profiler = new Profiler();
+    this.profiler = new SamplingProfiler();
 
     promises.push(this.profiler.startProfiling());
     await Promise.all(promises);
@@ -643,8 +652,12 @@ export default class WorkerFarm extends EventEmitter {
     return child.workerApi;
   }
 
-  static getConcurrentCallsPerWorker(): number {
-    return parseInt(process.env.PARCEL_MAX_CONCURRENT_CALLS, 10) || 30;
+  static getConcurrentCallsPerWorker(
+    defaultValue?: number = DEFAULT_MAX_CONCURRENT_CALLS,
+  ): number {
+    return (
+      parseInt(process.env.PARCEL_MAX_CONCURRENT_CALLS, 10) || defaultValue
+    );
   }
 }
 

package/src/child.js

@@ -18,7 +18,7 @@ import Logger, {patchConsole, unpatchConsole} from '@parcel/logger';
 import ThrowableDiagnostic, {anyToDiagnostic} from '@parcel/diagnostic';
 import {deserialize} from '@parcel/core';
 import bus from './bus';
-import Profiler from './Profiler';
+import {SamplingProfiler, tracer} from '@parcel/profiler';
 import _Handle from './Handle';
 
 // The import of './Handle' should really be imported eagerly (with @babel/plugin-transform-modules-commonjs's lazy mode).
@@ -37,8 +37,9 @@ export class Child {
   responseId: number = 0;
   responseQueue: Map<number, ChildCall> = new Map();
   loggerDisposable: IDisposable;
+  tracerDisposable: IDisposable;
   child: ChildImpl;
-  profiler: ?Profiler;
+  profiler: ?SamplingProfiler;
   handles: Map<number, Handle> = new Map();
   sharedReferences: Map<SharedReference, mixed> = new Map();
   sharedReferencesByValue: Map<mixed, SharedReference> = new Map();
@@ -56,6 +57,10 @@ export class Child {
     this.loggerDisposable = Logger.onLog(event => {
       bus.emit('logEvent', event);
     });
+    // .. and do the same for trace events
+    this.tracerDisposable = tracer.onTrace(event => {
+      bus.emit('traceEvent', event);
+    });
   }
 
   workerApi: {|
@@ -141,12 +146,16 @@ export class Child {
           unpatchConsole();
         }
 
+        if (childOptions.shouldTrace) {
+          tracer.enable();
+        }
+
         result = responseFromContent(await this.childInit(moduleName, child));
       } catch (e) {
         result = errorResponseFromError(e);
       }
     } else if (method === 'startProfile') {
-      this.profiler = new Profiler();
+      this.profiler = new SamplingProfiler();
       try {
         result = responseFromContent(await this.profiler.startProfiling());
       } catch (e) {
@@ -289,6 +298,7 @@ export class Child {
 
   handleEnd(): void {
     this.loggerDisposable.dispose();
+    this.tracerDisposable.dispose();
   }
 
   createReverseHandle(fn: (...args: Array<any>) => mixed): Handle {

package/src/index.js

@@ -1,9 +1,10 @@
 // @flow
-import type {LogEvent} from '@parcel/types';
+import type {TraceEvent, LogEvent} from '@parcel/types';
 import invariant from 'assert';
 import WorkerFarm from './WorkerFarm';
 import Logger from '@parcel/logger';
 import bus from './bus';
+import {tracer} from '@parcel/profiler';
 
 if (!WorkerFarm.isWorker()) {
   // Forward all logger events originating from workers into the main process
@@ -29,6 +30,11 @@ if (!WorkerFarm.isWorker()) {
         throw new Error('Unknown log level');
     }
   });
+
+  // Forward all trace events originating from workers into the main process
+  bus.on('traceEvent', (e: TraceEvent) => {
+    tracer.trace(e);
+  });
 }
 
 export default WorkerFarm;

package/lib/Profiler.js

@@ -1,80 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-function _assert() {
-  const data = _interopRequireDefault(require("assert"));
-
-  _assert = function () {
-    return data;
-  };
-
-  return data;
-}
-
-function _diagnostic() {
-  const data = _interopRequireDefault(require("@parcel/diagnostic"));
-
-  _diagnostic = function () {
-    return data;
-  };
-
-  return data;
-}
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-class Profiler {
-  startProfiling() {
-    let inspector;
-
-    try {
-      inspector = require('inspector');
-    } catch (err) {
-      throw new (_diagnostic().default)({
-        diagnostic: {
-          message: `The inspector module isn't available`,
-          origin: '@parcel/workers',
-          hints: ['Disable build profiling']
-        }
-      });
-    }
-
-    this.session = new inspector.Session();
-    this.session.connect();
-    return Promise.all([this.sendCommand('Profiler.setSamplingInterval', {
-      interval: 100
-    }), this.sendCommand('Profiler.enable'), this.sendCommand('Profiler.start')]);
-  }
-
-  sendCommand(method, params) {
-    (0, _assert().default)(this.session != null);
-    return new Promise((resolve, reject) => {
-      this.session.post(method, params, (err, params) => {
-        if (err == null) {
-          resolve(params);
-        } else {
-          reject(err);
-        }
-      });
-    });
-  }
-
-  destroy() {
-    if (this.session != null) {
-      this.session.disconnect();
-    }
-  }
-
-  async stopProfiling() {
-    let res = await this.sendCommand('Profiler.stop');
-    this.destroy();
-    return res.profile;
-  }
-
-}
-
-exports.default = Profiler;

package/lib/Trace.js

@@ -1,131 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-function _chromeTraceEvent() {
-  const data = require("chrome-trace-event");
-
-  _chromeTraceEvent = function () {
-    return data;
-  };
-
-  return data;
-}
-
-class Trace {
-  constructor() {
-    this.tracer = new (_chromeTraceEvent().Tracer)();
-    this.tid = 0;
-    this.eventId = 0;
-  }
-
-  getEventId() {
-    return this.eventId++;
-  }
-
-  init(ts) {
-    this.tracer.instantEvent({
-      name: 'TracingStartedInPage',
-      id: this.getEventId(),
-      ts,
-      cat: ['disabled-by-default-devtools.timeline'],
-      args: {
-        data: {
-          sessionId: '-1',
-          page: '0xfff',
-          frames: [{
-            frame: '0xfff',
-            url: 'parcel',
-            name: ''
-          }]
-        }
-      }
-    });
-    this.tracer.instantEvent({
-      name: 'TracingStartedInBrowser',
-      id: this.getEventId(),
-      ts,
-      cat: ['disabled-by-default-devtools.timeline'],
-      args: {
-        data: {
-          sessionId: '-1'
-        }
-      }
-    });
-  }
-
-  addCPUProfile(name, profile) {
-    if (this.eventId === 0) {
-      this.init(profile.startTime);
-    }
-
-    const trace = this.tracer;
-    const tid = this.tid;
-    this.tid++;
-    const cpuStartTime = profile.startTime;
-    const cpuEndTime = profile.endTime;
-    trace.instantEvent({
-      tid,
-      id: this.getEventId(),
-      cat: ['toplevel'],
-      name: 'TaskQueueManager::ProcessTaskFromWorkQueue',
-      args: {
-        src_file: '../../ipc/ipc_moji_bootstrap.cc',
-        src_func: 'Accept'
-      },
-      ts: cpuStartTime
-    });
-    trace.completeEvent({
-      tid,
-      name: 'EvaluateScript',
-      id: this.getEventId(),
-      cat: ['devtools.timeline'],
-      ts: cpuStartTime,
-      dur: cpuEndTime - cpuStartTime,
-      args: {
-        data: {
-          url: 'parcel',
-          lineNumber: 1,
-          columnNumber: 1,
-          frame: '0xFFF'
-        }
-      }
-    });
-    trace.instantEvent({
-      tid,
-      ts: 0,
-      ph: 'M',
-      cat: ['__metadata'],
-      name: 'thread_name',
-      args: {
-        name
-      }
-    });
-    trace.instantEvent({
-      tid,
-      name: 'CpuProfile',
-      id: this.getEventId(),
-      cat: ['disabled-by-default-devtools.timeline'],
-      ts: cpuEndTime,
-      args: {
-        data: {
-          cpuProfile: profile
-        }
-      }
-    });
-  }
-
-  pipe(writable) {
-    return this.tracer.pipe(writable);
-  }
-
-  flush() {
-    this.tracer.push(null);
-  }
-
-}
-
-exports.default = Trace;

package/src/Profiler.js

@@ -1,93 +0,0 @@
-// @flow
-import type {Session} from 'inspector';
-import invariant from 'assert';
-import ThrowableDiagnostic from '@parcel/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>,
-|};
-
-// 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,
-|};
-
-// https://chromedevtools.github.io/devtools-protocol/tot/Runtime#type-CallFrame
-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,
-|};
-
-export default class Profiler {
-  session: Session;
-
-  startProfiling(): Promise<mixed> {
-    let inspector;
-    try {
-      inspector = require('inspector');
-    } catch (err) {
-      throw new ThrowableDiagnostic({
-        diagnostic: {
-          message: `The inspector module isn't available`,
-          origin: '@parcel/workers',
-          hints: ['Disable build profiling'],
-        },
-      });
-    }
-
-    this.session = new inspector.Session();
-    this.session.connect();
-
-    return Promise.all([
-      this.sendCommand('Profiler.setSamplingInterval', {
-        interval: 100,
-      }),
-      this.sendCommand('Profiler.enable'),
-      this.sendCommand('Profiler.start'),
-    ]);
-  }
-
-  sendCommand(method: string, params: mixed): Promise<{profile: Profile, ...}> {
-    invariant(this.session != null);
-    return new Promise((resolve, reject) => {
-      this.session.post(method, params, (err, params) => {
-        if (err == null) {
-          resolve(params);
-        } else {
-          reject(err);
-        }
-      });
-    });
-  }
-
-  destroy() {
-    if (this.session != null) {
-      this.session.disconnect();
-    }
-  }
-
-  async stopProfiling(): Promise<Profile> {
-    let res = await this.sendCommand('Profiler.stop');
-    this.destroy();
-    return res.profile;
-  }
-}