Add measure and measureAsync tracing API

parcel-bundler · Apr 12, 2024 · 9f8c706 · 9f8c706
1 parent 4cd9467
commit 9f8c706
Show file tree

Hide file tree

Showing 13 changed files with 601 additions and 429 deletions.
diff --git a/packages/core/core/src/PackagerRunner.js b/packages/core/core/src/PackagerRunner.js
@@ -396,47 +396,52 @@ export default class PackagerRunner {
 
     let packager = await this.config.getPackager(bundle.name);
     let {name, resolveFrom, plugin} = packager;
-    let measurement;
     try {
-      measurement = tracer.createMeasurement(name, 'packaging', bundle.name, {
-        type: bundle.type,
-      });
-      return await plugin.package({
-        config: configs.get(name)?.result,
-        bundleConfig: bundleConfigs.get(name)?.result,
-        bundle,
-        bundleGraph: new BundleGraph<NamedBundleType>(
-          bundleGraph,
-          NamedBundle.get.bind(NamedBundle),
-          this.options,
-        ),
-        getSourceMapReference: map => {
-          return this.getSourceMapReference(bundle, map);
-        },
-        options: this.pluginOptions,
-        logger: new PluginLogger({origin: name}),
-        tracer: new PluginTracer({origin: name, category: 'package'}),
-        getInlineBundleContents: async (
-          bundle: BundleType,
-          bundleGraph: BundleGraphType<NamedBundleType>,
-        ) => {
-          if (bundle.bundleBehavior !== 'inline') {
-            throw new Error(
-              'Bundle is not inline and unable to retrieve contents',
-            );
-          }
-
-          let res = await this.getBundleResult(
-            bundleToInternalBundle(bundle),
-            // $FlowFixMe
-            bundleGraphToInternalBundleGraph(bundleGraph),
-            configs,
-            bundleConfigs,
-          );
-
-          return {contents: res.contents};
+      return await tracer.measureAsync(
+        {
+          name,
+          args: {bundle: bundle.name},
+          categories: ['packaging'],
         },
-      });
+        // eslint-disable-next-line require-await
+        async () =>
+          plugin.package({
+            config: configs.get(name)?.result,
+            bundleConfig: bundleConfigs.get(name)?.result,
+            bundle,
+            bundleGraph: new BundleGraph<NamedBundleType>(
+              bundleGraph,
+              NamedBundle.get.bind(NamedBundle),
+              this.options,
+            ),
+            getSourceMapReference: map => {
+              return this.getSourceMapReference(bundle, map);
+            },
+            options: this.pluginOptions,
+            logger: new PluginLogger({origin: name}),
+            tracer: new PluginTracer({origin: name, category: 'package'}),
+            getInlineBundleContents: async (
+              bundle: BundleType,
+              bundleGraph: BundleGraphType<NamedBundleType>,
+            ) => {
+              if (bundle.bundleBehavior !== 'inline') {
+                throw new Error(
+                  'Bundle is not inline and unable to retrieve contents',
+                );
+              }
+
+              let res = await this.getBundleResult(
+                bundleToInternalBundle(bundle),
+                // $FlowFixMe
+                bundleGraphToInternalBundleGraph(bundleGraph),
+                configs,
+                bundleConfigs,
+              );
+
+              return {contents: res.contents};
+            },
+          }),
+      );
     } catch (e) {
       throw new ThrowableDiagnostic({
         diagnostic: errorToDiagnostic(e, {
@@ -445,7 +450,6 @@ export default class PackagerRunner {
         }),
       });
     } finally {
-      measurement && measurement.end();
       // Add dev dependency for the packager. This must be done AFTER running it due to
       // the potential for lazy require() that aren't executed until the request runs.
       let devDepRequest = await createDevDependency(
@@ -503,34 +507,37 @@ export default class PackagerRunner {
     };
 
     for (let optimizer of optimizers) {
-      let measurement;
       try {
-        measurement = tracer.createMeasurement(
-          optimizer.name,
-          'optimize',
-          bundle.name,
-        );
-        let next = await optimizer.plugin.optimize({
-          config: configs.get(optimizer.name)?.result,
-          bundleConfig: bundleConfigs.get(optimizer.name)?.result,
-          bundle,
-          bundleGraph,
-          contents: optimized.contents,
-          map: optimized.map,
-          getSourceMapReference: map => {
-            return this.getSourceMapReference(bundle, map);
+        await tracer.measureAsync(
+          {
+            name: optimizer.name,
+            args: {name: bundle.name},
+            categories: ['optimize'],
           },
-          options: this.pluginOptions,
-          logger: new PluginLogger({origin: optimizer.name}),
-          tracer: new PluginTracer({
-            origin: optimizer.name,
-            category: 'optimize',
-          }),
-        });
-
-        optimized.type = next.type ?? optimized.type;
-        optimized.contents = next.contents;
-        optimized.map = next.map;
+          async () => {
+            let next = await optimizer.plugin.optimize({
+              config: configs.get(optimizer.name)?.result,
+              bundleConfig: bundleConfigs.get(optimizer.name)?.result,
+              bundle,
+              bundleGraph,
+              contents: optimized.contents,
+              map: optimized.map,
+              getSourceMapReference: map => {
+                return this.getSourceMapReference(bundle, map);
+              },
+              options: this.pluginOptions,
+              logger: new PluginLogger({origin: optimizer.name}),
+              tracer: new PluginTracer({
+                origin: optimizer.name,
+                category: 'optimize',
+              }),
+            });
+
+            optimized.type = next.type ?? optimized.type;
+            optimized.contents = next.contents;
+            optimized.map = next.map;
+          },
+        );
       } catch (e) {
         throw new ThrowableDiagnostic({
           diagnostic: errorToDiagnostic(e, {
@@ -539,7 +546,6 @@ export default class PackagerRunner {
           }),
         });
       } finally {
-        measurement && measurement.end();
         // Add dev dependency for the optimizer. This must be done AFTER running it due to
         // the potential for lazy require() that aren't executed until the request runs.
         let devDepRequest = await createDevDependency(

diff --git a/packages/core/core/src/ReporterRunner.js b/packages/core/core/src/ReporterRunner.js
@@ -95,26 +95,32 @@ export default class ReporterRunner {
       }
 
       for (let reporter of this.reporters) {
-        let measurement;
         try {
+          // eslint-disable-next-line require-await
+          let fn = async () =>
+            reporter.plugin.report({
+              event,
+              options: this.pluginOptions,
+              logger: new PluginLogger({origin: reporter.name}),
+              tracer: new PluginTracer({
+                origin: reporter.name,
+                category: 'reporter',
+              }),
+            });
+
           // To avoid an infinite loop we don't measure trace events, as they'll
           // result in another trace!
-          if (event.type !== 'trace') {
-            measurement = tracer.createMeasurement(reporter.name, 'reporter');
-          }
-          await reporter.plugin.report({
-            event,
-            options: this.pluginOptions,
-            logger: new PluginLogger({origin: reporter.name}),
-            tracer: new PluginTracer({
-              origin: reporter.name,
-              category: 'reporter',
-            }),
-          });
+          await (event.type === 'trace'
+            ? fn()
+            : tracer.measureAsync(
+                {
+                  name: reporter.name,
+                  categories: ['reporter'],
+                },
+                fn,
+              ));
         } catch (reportError) {
           INTERNAL_ORIGINAL_CONSOLE.error(reportError);
-        } finally {
-          measurement && measurement.end();
         }
       }
     } catch (err) {

diff --git a/packages/core/core/src/Transformation.js b/packages/core/core/src/Transformation.js
@@ -374,24 +374,27 @@ export default class Transformation {
         }
 
         try {
-          const measurement = tracer.createMeasurement(
-            transformer.name,
-            'transform',
-            fromProjectPathRelative(initialAsset.value.filePath),
-          );
-
-          let transformerResults = await this.runTransformer(
-            pipeline,
-            asset,
-            transformer.plugin,
-            transformer.name,
-            transformer.config,
-            transformer.configKeyPath,
-            this.parcelConfig,
+          let transformerResults = await tracer.measureAsync(
+            {
+              name: transformer.name,
+              args: {
+                filename: fromProjectPathRelative(initialAsset.value.filePath),
+              },
+              categories: ['transform'],
+            },
+            // eslint-disable-next-line require-await
+            async () =>
+              this.runTransformer(
+                pipeline,
+                asset,
+                transformer.plugin,
+                transformer.name,
+                transformer.config,
+                transformer.configKeyPath,
+                this.parcelConfig,
+              ),
           );
 
-          measurement && measurement.end();
-
           for (let result of transformerResults) {
             if (result instanceof UncommittedAsset) {
               resultingAssets.push(result);