@parcel/profiler 2.12.1-dev.3185 → 2.12.1-dev.3195

package/lib/Tracer.d.ts

@@ -1,9 +1,10 @@
-import type { TraceEvent, IDisposable, MeasurementOptions, PluginTracer as IPluginTracer } from "@parcel/types";
+import type { TraceEvent, IDisposable, PluginTracer as IPluginTracer } from "@parcel/types";
 import type { TraceMeasurement as ITraceMeasurement } from "./types";
 export default class Tracer {
 
     onTrace(cb: (event: TraceEvent) => unknown): IDisposable;
-    measure<T>({ args, categories, name }: MeasurementOptions, fn: () => T): T;
+    wrap(name: string, fn: () => unknown): Promise<void>;
+    createMeasurement(name: string, category?: string, argumentName?: string, otherArgs?: Record<string, unknown>): ITraceMeasurement | null;
     get enabled(): boolean;
     enable(): void;
     disable(): void;
@@ -23,6 +24,5 @@ export declare class PluginTracer implements IPluginTracer {
     constructor(opts: TracerOpts);
     get enabled(): boolean;
     createMeasurement(name: string, category?: string, argumentName?: string, otherArgs?: Record<string, unknown>): ITraceMeasurement | null;
-    measure<T>(options: MeasurementOptions, fn: () => T): T;
 }
 export {};

package/lib/Tracer.js

@@ -62,37 +62,38 @@ class Tracer {
   onTrace(cb) {
     return this.#traceEmitter.addListener(cb);
   }
-  measure({
-    args = {},
-    categories,
-    name
-  }, fn) {
-    if (!this.enabled) {
-      return fn();
-    }
-    let measurement = new TraceMeasurement(this, name, pid, tid, {
-      categories,
-      args
-    });
-    let result;
-    let hasFinally = false;
+  async wrap(name, fn) {
+    let measurement = this.createMeasurement(name);
     try {
-      result = fn();
-      // @ts-expect-error TypeScript types cannot infer that finally can exist
-      if (result != null && typeof result === 'object' && typeof result.finally === 'function') {
-        hasFinally = true;
-        // @ts-expect-error
-        // $FlowFixMe[incompatible-use] This will run for a promise type, but it cannot be easily typed in Flow
-        result = result.finally(() => {
-          measurement === null || measurement === void 0 || measurement.end();
-        });
-      }
+      await fn();
     } finally {
-      if (!hasFinally) {
-        measurement === null || measurement === void 0 || measurement.end();
+      measurement && measurement.end();
+    }
+  }
+  createMeasurement(name, category = 'Core', argumentName, otherArgs) {
+    if (!this.enabled) return null;
+
+    // We create `args` in a fairly verbose way to avoid object
+    // allocation where not required.
+    let args;
+    if (typeof argumentName === 'string') {
+      args = {
+        name: argumentName
+      };
+    }
+    if (typeof otherArgs === 'object') {
+      if (typeof args == 'undefined') {
+        args = {};
+      }
+      for (const [k, v] of Object.entries(otherArgs)) {
+        args[k] = v;
       }
     }
-    return result;
+    const data = {
+      categories: [category],
+      args
+    };
+    return new TraceMeasurement(this, name, pid, tid, data);
   }
   get enabled() {
     return this.#enabled;
@@ -124,44 +125,7 @@ class PluginTracer {
     return tracer.enabled;
   }
   createMeasurement(name, category, argumentName, otherArgs) {
-    if (!this.enabled) return null;
-
-    // We create `args` in a fairly verbose way to avoid object
-    // allocation where not required.
-    let args;
-    if (typeof argumentName === 'string') {
-      args = {
-        name: argumentName
-      };
-    }
-    if (typeof otherArgs === 'object') {
-      if (typeof args == 'undefined') {
-        args = {};
-      }
-      for (const [k, v] of Object.entries(otherArgs)) {
-        args[k] = v;
-      }
-    }
-    const data = {
-      categories: [`${this.category}:${this.origin}${typeof category === 'string' ? `:${category}` : ''}`],
-      args
-    };
-    return new TraceMeasurement(tracer, name, pid, tid, data);
-  }
-  measure(options, fn) {
-    var _options$args;
-    if (!this.enabled) {
-      return fn();
-    }
-    return tracer.measure({
-      ...options,
-      // $FlowFixMe[cannot-spread-inexact]
-      args: {
-        origin: this.origin,
-        ...((_options$args = options.args) !== null && _options$args !== void 0 ? _options$args : {})
-      },
-      categories: [this.category, ...options.categories]
-    }, fn);
+    return tracer.createMeasurement(name, `${this.category}:${this.origin}${typeof category === 'string' ? `:${category}` : ''}`, argumentName, otherArgs);
   }
 }
 exports.PluginTracer = PluginTracer;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@parcel/profiler",
-  "version": "2.12.1-dev.3185+298c035e0",
+  "version": "2.12.1-dev.3195+7afdafedd",
   "description": "Blazing fast, zero configuration web application bundler",
   "license": "MIT",
   "publishConfig": {
@@ -17,17 +17,17 @@
   "main": "lib/index.js",
   "source": "src/index.js",
   "engines": {
-    "node": ">= 12.0.0"
+    "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"
   },
   "dependencies": {
-    "@parcel/diagnostic": "2.0.0-dev.1562+298c035e0",
-    "@parcel/events": "2.0.0-dev.1562+298c035e0",
-    "@parcel/types-internal": "2.12.1-dev.3185+298c035e0",
+    "@parcel/diagnostic": "2.0.0-dev.1572+7afdafedd",
+    "@parcel/events": "2.0.0-dev.1572+7afdafedd",
+    "@parcel/types-internal": "2.12.1-dev.3195+7afdafedd",
     "chrome-trace-event": "^1.0.2"
   },
-  "gitHead": "298c035e0ffb82d7c5579ce233cc35dce2fe1061"
+  "gitHead": "7afdafedd7f01d82b9868ec004b3966a88006300"
 }

package/src/Tracer.js

@@ -3,7 +3,6 @@
 import type {
   TraceEvent,
   IDisposable,
-  MeasurementOptions,
   PluginTracer as IPluginTracer,
 } from '@parcel/types';
 import type {
@@ -65,44 +64,44 @@ export default class Tracer {
     return this.#traceEmitter.addListener(cb);
   }
 
-  measure<T>(
-    {args = {}, categories, name}: MeasurementOptions,
-    fn: () => T,
-  ): T {
-    if (!this.enabled) {
-      return fn();
+  async wrap(name: string, fn: () => mixed): Promise<void> {
+    let measurement = this.createMeasurement(name);
+    try {
+      await fn();
+    } finally {
+      measurement && measurement.end();
     }
+  }
 
-    let measurement = new TraceMeasurement(this, name, pid, tid, {
-      categories,
-      args,
-    });
-
-    let result: T;
-    let hasFinally = false;
+  createMeasurement(
+    name: string,
+    category: string = 'Core',
+    argumentName?: string,
+    otherArgs?: {[key: string]: mixed},
+  ): ITraceMeasurement | null {
+    if (!this.enabled) return null;
 
-    try {
-      result = fn();
-      // @ts-expect-error TypeScript types cannot infer that finally can exist
-      if (
-        result != null &&
-        typeof result === 'object' &&
-        typeof result.finally === 'function'
-      ) {
-        hasFinally = true;
-        // @ts-expect-error
-        // $FlowFixMe[incompatible-use] This will run for a promise type, but it cannot be easily typed in Flow
-        result = result.finally(() => {
-          measurement?.end();
-        });
+    // We create `args` in a fairly verbose way to avoid object
+    // allocation where not required.
+    let args: {[key: string]: mixed};
+    if (typeof argumentName === 'string') {
+      args = {name: argumentName};
+    }
+    if (typeof otherArgs === 'object') {
+      if (typeof args == 'undefined') {
+        args = {};
       }
-    } finally {
-      if (!hasFinally) {
-        measurement?.end();
+      for (const [k, v] of Object.entries(otherArgs)) {
+        args[k] = v;
       }
     }
 
-    return result;
+    const data: TraceMeasurementData = {
+      categories: [category],
+      args,
+    };
+
+    return new TraceMeasurement(this, name, pid, tid, data);
   }
 
   get enabled(): boolean {
@@ -129,7 +128,6 @@ type TracerOpts = {|
   origin: string,
   category: string,
 |};
-
 export class PluginTracer implements IPluginTracer {
   /** @private */
   origin: string;
@@ -153,51 +151,13 @@ export class PluginTracer implements IPluginTracer {
     argumentName?: string,
     otherArgs?: {[key: string]: mixed},
   ): 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};
-    if (typeof argumentName === 'string') {
-      args = {name: argumentName};
-    }
-    if (typeof otherArgs === 'object') {
-      if (typeof args == 'undefined') {
-        args = {};
-      }
-      for (const [k, v] of Object.entries(otherArgs)) {
-        args[k] = v;
-      }
-    }
-
-    const data: TraceMeasurementData = {
-      categories: [
-        `${this.category}:${this.origin}${
-          typeof category === 'string' ? `:${category}` : ''
-        }`,
-      ],
-      args,
-    };
-
-    return new TraceMeasurement(tracer, name, pid, tid, data);
-  }
-
-  measure<T>(options: MeasurementOptions, fn: () => T): T {
-    if (!this.enabled) {
-      return fn();
-    }
-
-    return tracer.measure(
-      {
-        ...options,
-        // $FlowFixMe[cannot-spread-inexact]
-        args: {
-          origin: this.origin,
-          ...(options.args ?? {}),
-        },
-        categories: [this.category, ...options.categories],
-      },
-      fn,
+    return tracer.createMeasurement(
+      name,
+      `${this.category}:${this.origin}${
+        typeof category === 'string' ? `:${category}` : ''
+      }`,
+      argumentName,
+      otherArgs,
     );
   }
 }

package/test/Tracer.test.js

@@ -5,123 +5,74 @@ import assert from 'assert';
 describe('Tracer', () => {
   let onTrace;
   let traceDisposable;
-  let opts = {name: 'test', categories: ['tracer']};
-
   beforeEach(() => {
     onTrace = sinon.spy();
     traceDisposable = tracer.onTrace(onTrace);
     tracer.enable();
   });
-
   afterEach(() => {
     traceDisposable.dispose();
   });
 
-  describe('measure()', () => {
-    let cases = [
-      ['synchronous', () => () => {}],
-      ['asynchronous', () => async () => {}],
-    ];
-
-    for (let [type, createFn] of cases) {
-      describe(`given a ${type} function`, () => {
-        it('does not trace when disabled', async () => {
-          tracer.disable();
-
-          let result = tracer.measure(opts, sinon.spy());
-          if (type === 'asynchronous') {
-            sinon.assert.notCalled(onTrace);
-            await result;
-          }
-
-          assert(onTrace.notCalled);
-        });
-
-        it('emits a basic trace event', async () => {
-          let result = tracer.measure(opts, createFn());
-          if (type === 'asynchronous') {
-            sinon.assert.notCalled(onTrace);
-            await result;
-          }
-
-          sinon.assert.calledOnce(onTrace);
-          sinon.assert.calledWith(
-            onTrace,
-            sinon.match({
-              type: 'trace',
-              name: 'test',
-              args: {},
-              categories: ['tracer'],
-              duration: sinon.match.number,
-            }),
-          );
-        });
-
-        it('emits a complex trace event', async () => {
-          let result = tracer.measure(
-            {...opts, args: {hello: 'world'}},
-            createFn(),
-          );
-          if (type === 'asynchronous') {
-            sinon.assert.notCalled(onTrace);
-            await result;
-          }
-
-          sinon.assert.calledOnce(onTrace);
-          sinon.assert.calledWith(
-            onTrace,
-            sinon.match({
-              type: 'trace',
-              name: 'test',
-              args: {hello: 'world'},
-              categories: ['tracer'],
-              duration: sinon.match.number,
-            }),
-          );
-        });
-      });
-    }
+  it('returns no measurement when disabled', () => {
+    tracer.disable();
+    const measurement = tracer.createMeasurement('test');
+    assert(measurement == null);
+    assert(onTrace.notCalled);
   });
-
-  describe('PluginTracer', () => {
-    const pluginTracer = new PluginTracer({
-      origin: 'origin',
-      category: 'cat',
-    });
-
-    describe(`measure()`, () => {
-      it('emits events with origin and category', () => {
-        pluginTracer.measure(opts, sinon.spy());
-
-        sinon.assert.calledOnce(onTrace);
-        sinon.assert.calledWith(
-          onTrace,
-          sinon.match({
-            type: 'trace',
-            name: 'test',
-            args: {origin: 'origin'},
-            categories: ['cat', 'tracer'],
-            duration: sinon.match.number,
-          }),
-        );
-      });
+  it('emits a basic trace event', () => {
+    const measurement = tracer.createMeasurement('test');
+    measurement.end();
+    sinon.assert.calledWith(
+      onTrace,
+      sinon.match({
+        type: 'trace',
+        name: 'test',
+        args: undefined,
+        duration: sinon.match.number,
+      }),
+    );
+  });
+  it('emits a complex trace event', () => {
+    const measurement = tracer.createMeasurement('test', 'myPlugin', 'aaargh', {
+      extra: 'data',
     });
+    measurement.end();
+    sinon.assert.calledWith(
+      onTrace,
+      sinon.match({
+        type: 'trace',
+        name: 'test',
+        categories: ['myPlugin'],
+        args: {extra: 'data', name: 'aaargh'},
+        duration: sinon.match.number,
+      }),
+    );
+  });
+  it('calling end twice on measurment should be a no-op', () => {
+    const measurement = tracer.createMeasurement('test');
+    measurement.end();
+    measurement.end();
+    sinon.assert.calledOnce(onTrace);
+  });
 
-    describe('createMeasurement()', () => {
-      it('emits events with origin and category', () => {
-        pluginTracer.createMeasurement('test', 'customCat').end();
-
-        sinon.assert.calledOnce(onTrace);
-        sinon.assert.calledWith(
-          onTrace,
-          sinon.match({
-            type: 'trace',
-            name: 'test',
-            categories: ['cat:origin:customCat'],
-            duration: sinon.match.number,
-          }),
-        );
+  describe('PluginTracer', () => {
+    it('emits events with proper origin/category', () => {
+      const pluginTracer = new PluginTracer({
+        origin: 'origin',
+        category: 'cat',
       });
+      const measurement = pluginTracer.createMeasurement('test', 'customCat');
+      measurement.end();
+      sinon.assert.calledWith(
+        onTrace,
+        sinon.match({
+          type: 'trace',
+          name: 'test',
+          categories: ['cat:origin:customCat'],
+          duration: sinon.match.number,
+        }),
+      );
     });
   });
 });