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

package/lib/Tracer.d.ts

@@ -1,10 +1,9 @@
-import type { TraceEvent, IDisposable, PluginTracer as IPluginTracer } from "@parcel/types";
+import type { TraceEvent, IDisposable, MeasurementOptions, PluginTracer as IPluginTracer } from "@parcel/types";
 import type { TraceMeasurement as ITraceMeasurement } from "./types";
 export default class Tracer {
 
     onTrace(cb: (event: TraceEvent) => unknown): IDisposable;
-    wrap(name: string, fn: () => unknown): Promise<void>;
-    createMeasurement(name: string, category?: string, argumentName?: string, otherArgs?: Record<string, unknown>): ITraceMeasurement | null;
+    measure<T>({ args, categories, name }: MeasurementOptions, fn: () => T): T;
     get enabled(): boolean;
     enable(): void;
     disable(): void;
@@ -24,5 +23,6 @@ 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,38 +62,37 @@ class Tracer {
   onTrace(cb) {
     return this.#traceEmitter.addListener(cb);
   }
-  async wrap(name, fn) {
-    let measurement = this.createMeasurement(name);
-    try {
-      await fn();
-    } finally {
-      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
-      };
+  measure({
+    args = {},
+    categories,
+    name
+  }, fn) {
+    if (!this.enabled) {
+      return fn();
     }
-    if (typeof otherArgs === 'object') {
-      if (typeof args == 'undefined') {
-        args = {};
+    let measurement = new TraceMeasurement(this, name, pid, tid, {
+      categories,
+      args
+    });
+    let result;
+    let hasFinally = false;
+    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();
+        });
       }
-      for (const [k, v] of Object.entries(otherArgs)) {
-        args[k] = v;
+    } finally {
+      if (!hasFinally) {
+        measurement === null || measurement === void 0 || measurement.end();
       }
     }
-    const data = {
-      categories: [category],
-      args
-    };
-    return new TraceMeasurement(this, name, pid, tid, data);
+    return result;
   }
   get enabled() {
     return this.#enabled;
@@ -125,7 +124,44 @@ class PluginTracer {
     return tracer.enabled;
   }
   createMeasurement(name, category, argumentName, otherArgs) {
-    return tracer.createMeasurement(name, `${this.category}:${this.origin}${typeof category === 'string' ? `:${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);
   }
 }
 exports.PluginTracer = PluginTracer;

package/lib/types.d.ts

@@ -1,6 +1,4 @@
-export interface TraceMeasurement {
-    end(): void;
-}
+export type { TraceMeasurement } from "@parcel/types-internal";
 export type TraceMeasurementData = {
     readonly categories: string[];
     readonly args?: Record<string, unknown>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@parcel/profiler",
-  "version": "2.12.1-dev.3171+79b158883",
+  "version": "2.12.1-dev.3185+298c035e0",
   "description": "Blazing fast, zero configuration web application bundler",
   "license": "MIT",
   "publishConfig": {
@@ -20,13 +20,14 @@
     "node": ">= 12.0.0"
   },
   "scripts": {
-    "build-ts": "flow-to-ts src/*.js --write && 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",
+    "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.1548+79b158883",
-    "@parcel/events": "2.0.0-dev.1548+79b158883",
+    "@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",
     "chrome-trace-event": "^1.0.2"
   },
-  "gitHead": "79b158883170daac9cd17bdecfebff163bc99e52"
+  "gitHead": "298c035e0ffb82d7c5579ce233cc35dce2fe1061"
 }

package/src/Tracer.js

@@ -3,6 +3,7 @@
 import type {
   TraceEvent,
   IDisposable,
+  MeasurementOptions,
   PluginTracer as IPluginTracer,
 } from '@parcel/types';
 import type {
@@ -64,44 +65,44 @@ export default class Tracer {
     return this.#traceEmitter.addListener(cb);
   }
 
-  async wrap(name: string, fn: () => mixed): Promise<void> {
-    let measurement = this.createMeasurement(name);
-    try {
-      await fn();
-    } finally {
-      measurement && measurement.end();
+  measure<T>(
+    {args = {}, categories, name}: MeasurementOptions,
+    fn: () => T,
+  ): T {
+    if (!this.enabled) {
+      return fn();
     }
-  }
 
-  createMeasurement(
-    name: string,
-    category: string = 'Core',
-    argumentName?: string,
-    otherArgs?: {[key: string]: mixed},
-  ): ITraceMeasurement | null {
-    if (!this.enabled) return null;
+    let measurement = new TraceMeasurement(this, name, pid, tid, {
+      categories,
+      args,
+    });
 
-    // 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 = {};
+    let result: T;
+    let hasFinally = false;
+
+    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();
+        });
       }
-      for (const [k, v] of Object.entries(otherArgs)) {
-        args[k] = v;
+    } finally {
+      if (!hasFinally) {
+        measurement?.end();
       }
     }
 
-    const data: TraceMeasurementData = {
-      categories: [category],
-      args,
-    };
-
-    return new TraceMeasurement(this, name, pid, tid, data);
+    return result;
   }
 
   get enabled(): boolean {
@@ -128,6 +129,7 @@ type TracerOpts = {|
   origin: string,
   category: string,
 |};
+
 export class PluginTracer implements IPluginTracer {
   /** @private */
   origin: string;
@@ -151,13 +153,51 @@ export class PluginTracer implements IPluginTracer {
     argumentName?: string,
     otherArgs?: {[key: string]: mixed},
   ): ITraceMeasurement | null {
-    return tracer.createMeasurement(
-      name,
-      `${this.category}:${this.origin}${
-        typeof category === 'string' ? `:${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: {[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,
     );
   }
 }

package/src/types.js

@@ -1,8 +1,6 @@
 // @flow
 
-export interface TraceMeasurement {
-  end(): void;
-}
+export type {TraceMeasurement} from '@parcel/types-internal';
 
 export type TraceMeasurementData = {|
   +categories: string[],

package/test/Tracer.test.js

@@ -5,74 +5,123 @@ 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();
   });
 
-  it('returns no measurement when disabled', () => {
-    tracer.disable();
-    const measurement = tracer.createMeasurement('test');
-    assert(measurement == null);
-    assert(onTrace.notCalled);
-  });
-  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('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,
+            }),
+          );
+        });
+      });
+    }
   });
 
   describe('PluginTracer', () => {
-    it('emits events with proper origin/category', () => {
-      const pluginTracer = new PluginTracer({
-        origin: 'origin',
-        category: 'cat',
+    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,
+          }),
+        );
+      });
+    });
+
+    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,
+          }),
+        );
       });
-      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,
-        }),
-      );
     });
   });
 });