Fix tracing problems

flow-libs/chrome-trace-event.js.flow

@@ -20,6 +20,7 @@ declare module 'chrome-trace-event' {
     begin(fields: Fields): void;
     completeEvent(fields: Fields): void;
     instantEvent(fields: Fields): void;
+    mkEventFunc(ph: string): (fields: Fields) => void;
     flush(): void;
   }
 }

packages/core/core/src/ParcelConfig.js

@@ -38,6 +38,7 @@ import {
   fromProjectPathRelative,
   toProjectPathUnsafe,
 } from './projectPath';
+import {measureAsyncFunction} from '@parcel/profiler';
 
 type GlobMap<T> = {[Glob]: T, ...};
 type SerializedParcelConfig = {|
@@ -157,16 +158,22 @@ export default class ParcelConfig {
     return Promise.all(plugins.map(p => this.loadPlugin<T>(p)));
   }
 
-  async getResolvers(): Promise<Array<LoadedPlugin<Resolver<mixed>>>> {
-    if (this.resolvers.length === 0) {
-      throw await this.missingPluginError(
-        this.resolvers,
-        'No resolver plugins specified in .parcelrc config',
-        '/resolvers',
-      );
-    }
+  getResolvers(): Promise<Array<LoadedPlugin<Resolver<mixed>>>> {
+    return measureAsyncFunction(
+      'ParcelConfig::getResolvers',
+      'resolve',
+      async () => {
+        if (this.resolvers.length === 0) {
+          throw await this.missingPluginError(
+            this.resolvers,
+            'No resolver plugins specified in .parcelrc config',
+            '/resolvers',
+          );
+        }
 
-    return this.loadPlugins<Resolver<mixed>>(this.resolvers);
+        return this.loadPlugins<Resolver<mixed>>(this.resolvers);
+      },
+    );
   }
 
   _getValidatorNodes(filePath: ProjectPath): $ReadOnlyArray<ParcelPluginNode> {

packages/core/core/src/ReporterRunner.js

@@ -99,7 +99,7 @@ export default class ReporterRunner {
         try {
           // To avoid an infinite loop we don't measure trace events, as they'll
           // result in another trace!
-          if (event.type !== 'trace') {
+          if (!event.type.startsWith('trace')) {
             measurement = tracer.createMeasurement(reporter.name, 'reporter');
           }
           await reporter.plugin.report({
@@ -113,12 +113,14 @@ export default class ReporterRunner {
           });
         } catch (reportError) {
           INTERNAL_ORIGINAL_CONSOLE.error(reportError);
+          INTERNAL_ORIGINAL_CONSOLE.error(reportError.stack);
         } finally {
           measurement && measurement.end();
         }
       }
     } catch (err) {
       INTERNAL_ORIGINAL_CONSOLE.error(err);
+      INTERNAL_ORIGINAL_CONSOLE.error(err.stack);
     }
   }
 

packages/core/core/src/Transformation.js

@@ -356,8 +356,17 @@ export default class Transformation {
     let inputAssets = [initialAsset];
     let resultingAssets = [];
     let finalAssets = [];
+    const pipelineTransformers = tracer.createMeasurement(
+      'Transformation::runPipeline - transformers',
+      'transform',
+      pipeline.id,
+    );
     for (let transformer of pipeline.transformers) {
       resultingAssets = [];
+      const transformerMeasurement = tracer.createMeasurement(
+        `${transformer.name} all_assets`,
+        'transform',
+      );
       for (let asset of inputAssets) {
         if (
           asset.value.type !== initialType &&
@@ -373,13 +382,13 @@ export default class Transformation {
           continue;
         }
 
-        try {
-          const measurement = tracer.createMeasurement(
-            transformer.name,
-            'transform',
-            fromProjectPathRelative(initialAsset.value.filePath),
-          );
+        const measurement = tracer.createMeasurement(
+          transformer.name,
+          'transform',
+          fromProjectPathRelative(initialAsset.value.filePath),
+        );
 
+        try {
           let transformerResults = await this.runTransformer(
             pipeline,
             asset,
@@ -390,11 +399,10 @@ export default class Transformation {
             this.parcelConfig,
           );
 
-          measurement && measurement.end();
-
           for (let result of transformerResults) {
             if (result instanceof UncommittedAsset) {
               resultingAssets.push(result);
+              measurement?.end();
               continue;
             }
             resultingAssets.push(
@@ -434,13 +442,20 @@ export default class Transformation {
             }
           }
 
+          measurement?.end();
+          transformerMeasurement?.end();
+          pipelineTransformers?.end();
           throw new ThrowableDiagnostic({
             diagnostic,
           });
         }
+
+        measurement && measurement.end();
       }
+      transformerMeasurement?.end();
       inputAssets = resultingAssets;
     }
+    pipelineTransformers?.end();
 
     // Make assets with ASTs generate unless they are CSS modules. This parallelizes generation
     // and distributes work more evenly across workers than if one worker needed to

packages/core/core/src/requests/ConfigRequest.js

@@ -26,7 +26,7 @@ import PublicConfig from '../public/Config';
 import {optionsProxy} from '../utils';
 import {getInvalidationHash} from '../assetUtils';
 import {hashString, Hash} from '@parcel/rust';
-import {PluginTracer} from '@parcel/profiler';
+import {measureAsyncFunction, PluginTracer} from '@parcel/profiler';
 import {requestTypes} from '../RequestTracker';
 import {fromProjectPath, fromProjectPathRelative} from '../projectPath';
 import {createBuildCache} from '../buildCache';
@@ -74,37 +74,43 @@ export type ConfigRequest = {
   ...
 };
 
-export async function loadPluginConfig<T: PluginWithLoadConfig>(
+export function loadPluginConfig<T: PluginWithLoadConfig>(
   loadedPlugin: LoadedPlugin<T>,
   config: Config,
   options: ParcelOptions,
 ): Promise<void> {
-  let loadConfig = loadedPlugin.plugin.loadConfig;
-  if (!loadConfig) {
-    return;
-  }
+  return measureAsyncFunction(
+    'ConfigRequest::loadPluginConfig',
+    'building',
+    async () => {
+      let loadConfig = loadedPlugin.plugin.loadConfig;
+      if (!loadConfig) {
+        return;
+      }
 
-  try {
-    config.result = await loadConfig({
-      config: new PublicConfig(config, options),
-      options: new PluginOptions(
-        optionsProxy(options, option => {
-          config.invalidateOnOptionChange.add(option);
-        }),
-      ),
-      logger: new PluginLogger({origin: loadedPlugin.name}),
-      tracer: new PluginTracer({
-        origin: loadedPlugin.name,
-        category: 'loadConfig',
-      }),
-    });
-  } catch (e) {
-    throw new ThrowableDiagnostic({
-      diagnostic: errorToDiagnostic(e, {
-        origin: loadedPlugin.name,
-      }),
-    });
-  }
+      try {
+        config.result = await loadConfig({
+          config: new PublicConfig(config, options),
+          options: new PluginOptions(
+            optionsProxy(options, option => {
+              config.invalidateOnOptionChange.add(option);
+            }),
+          ),
+          logger: new PluginLogger({origin: loadedPlugin.name}),
+          tracer: new PluginTracer({
+            origin: loadedPlugin.name,
+            category: 'loadConfig',
+          }),
+        });
+      } catch (e) {
+        throw new ThrowableDiagnostic({
+          diagnostic: errorToDiagnostic(e, {
+            origin: loadedPlugin.name,
+          }),
+        });
+      }
+    },
+  );
 }
 
 const configKeyCache = createBuildCache();

packages/core/core/src/requests/DevDepRequest.js

@@ -1,5 +1,6 @@
 // @flow
 import type {DependencySpecifier, SemverRange} from '@parcel/types';
+import {measureAsyncFunction} from '@parcel/profiler';
 import type ParcelConfig from '../ParcelConfig';
 import type {
   DevDepRequest,
@@ -26,75 +27,77 @@ import {requestTypes} from '../RequestTracker';
 // paths and hashes.
 const devDepRequestCache = new WeakMap();
 
-export async function createDevDependency(
+export function createDevDependency(
   opts: InternalDevDepOptions,
   requestDevDeps: Map<string, string>,
   options: ParcelOptions,
 ): Promise<DevDepRequest> {
-  let {specifier, resolveFrom, additionalInvalidations} = opts;
-  let key = `${specifier}:${fromProjectPathRelative(resolveFrom)}`;
-
-  // If the request sent us a hash, we know the dev dep and all of its dependencies didn't change.
-  // Reuse the same hash in the response. No need to send back invalidations as the request won't
-  // be re-run anyway.
-  let hash = requestDevDeps.get(key);
-  if (hash != null) {
-    return {
-      specifier,
-      resolveFrom,
-      hash,
-    };
-  }
+  return measureAsyncFunction('createDevDependency', 'resolve', async () => {
+    let {specifier, resolveFrom, additionalInvalidations} = opts;
+    let key = `${specifier}:${fromProjectPathRelative(resolveFrom)}`;
 
-  let resolveFromAbsolute = fromProjectPath(options.projectRoot, resolveFrom);
+    // If the request sent us a hash, we know the dev dep and all of its dependencies didn't change.
+    // Reuse the same hash in the response. No need to send back invalidations as the request won't
+    // be re-run anyway.
+    let hash = requestDevDeps.get(key);
+    if (hash != null) {
+      return {
+        specifier,
+        resolveFrom,
+        hash,
+      };
+    }
 
-  // Ensure that the package manager has an entry for this resolution.
-  try {
-    await options.packageManager.resolve(specifier, resolveFromAbsolute);
-  } catch (err) {
-    // ignore
-  }
+    let resolveFromAbsolute = fromProjectPath(options.projectRoot, resolveFrom);
 
-  let invalidations = options.packageManager.getInvalidations(
-    specifier,
-    resolveFromAbsolute,
-  );
+    // Ensure that the package manager has an entry for this resolution.
+    try {
+      await options.packageManager.resolve(specifier, resolveFromAbsolute);
+    } catch (err) {
+      // ignore
+    }
 
-  let cached = devDepRequestCache.get(invalidations);
-  if (cached != null) {
-    return cached;
-  }
+    let invalidations = options.packageManager.getInvalidations(
+      specifier,
+      resolveFromAbsolute,
+    );
 
-  let invalidateOnFileChangeProject = [
-    ...invalidations.invalidateOnFileChange,
-  ].map(f => toProjectPath(options.projectRoot, f));
-
-  // It is possible for a transformer to have multiple different hashes due to
-  // different dependencies (e.g. conditional requires) so we must always
-  // recompute the hash and compare rather than only sending a transformer
-  // dev dependency once.
-  hash = await getInvalidationHash(
-    invalidateOnFileChangeProject.map(f => ({
-      type: 'file',
-      filePath: f,
-    })),
-    options,
-  );
+    let cached = devDepRequestCache.get(invalidations);
+    if (cached != null) {
+      return cached;
+    }
 
-  let devDepRequest: DevDepRequest = {
-    specifier,
-    resolveFrom,
-    hash,
-    invalidateOnFileCreate: invalidations.invalidateOnFileCreate.map(i =>
-      invalidateOnFileCreateToInternal(options.projectRoot, i),
-    ),
-    invalidateOnFileChange: new Set(invalidateOnFileChangeProject),
-    invalidateOnStartup: invalidations.invalidateOnStartup,
-    additionalInvalidations,
-  };
+    let invalidateOnFileChangeProject = [
+      ...invalidations.invalidateOnFileChange,
+    ].map(f => toProjectPath(options.projectRoot, f));
+
+    // It is possible for a transformer to have multiple different hashes due to
+    // different dependencies (e.g. conditional requires) so we must always
+    // recompute the hash and compare rather than only sending a transformer
+    // dev dependency once.
+    hash = await getInvalidationHash(
+      invalidateOnFileChangeProject.map(f => ({
+        type: 'file',
+        filePath: f,
+      })),
+      options,
+    );
+
+    let devDepRequest: DevDepRequest = {
+      specifier,
+      resolveFrom,
+      hash,
+      invalidateOnFileCreate: invalidations.invalidateOnFileCreate.map(i =>
+        invalidateOnFileCreateToInternal(options.projectRoot, i),
+      ),
+      invalidateOnFileChange: new Set(invalidateOnFileChangeProject),
+      invalidateOnStartup: invalidations.invalidateOnStartup,
+      additionalInvalidations,
+    };
 
-  devDepRequestCache.set(invalidations, devDepRequest);
-  return devDepRequest;
+    devDepRequestCache.set(invalidations, devDepRequest);
+    return devDepRequest;
+  });
 }
 
 export type DevDepSpecifier = {|