@atlaspack/core 2.16.2-canary.2 → 2.16.2-canary.20

package/CHANGELOG.md

@@ -1,5 +1,67 @@
 # @atlaspack/core
 
+## 2.17.2
+
+### Patch Changes
+
+- Updated dependencies [[`a1773d2`](https://github.com/atlassian-labs/atlaspack/commit/a1773d2a62d0ef7805ac7524621dcabcc1afe929), [`556d6ab`](https://github.com/atlassian-labs/atlaspack/commit/556d6ab8ede759fa7f37fcd3f4da336ef1c55e8f)]:
+  - @atlaspack/feature-flags@2.15.0
+  - @atlaspack/logger@2.14.7
+  - @atlaspack/rust@3.3.2
+  - @atlaspack/cache@3.2.2
+  - @atlaspack/fs@2.15.2
+  - @atlaspack/graph@3.4.5
+  - @atlaspack/utils@2.14.7
+  - @atlaspack/package-manager@2.14.7
+  - @atlaspack/workers@2.14.7
+  - @atlaspack/profiler@2.14.5
+  - @atlaspack/types@2.14.7
+  - @atlaspack/plugin@2.14.7
+
+## 2.17.1
+
+### Patch Changes
+
+- Updated dependencies [[`e0f5337`](https://github.com/atlassian-labs/atlaspack/commit/e0f533757bd1019dbd108a04952c87da15286e09)]:
+  - @atlaspack/feature-flags@2.14.4
+  - @atlaspack/rust@3.3.1
+  - @atlaspack/cache@3.2.1
+  - @atlaspack/fs@2.15.1
+  - @atlaspack/graph@3.4.4
+  - @atlaspack/utils@2.14.6
+  - @atlaspack/logger@2.14.6
+  - @atlaspack/package-manager@2.14.6
+  - @atlaspack/profiler@2.14.4
+  - @atlaspack/types@2.14.6
+  - @atlaspack/workers@2.14.6
+  - @atlaspack/plugin@2.14.6
+
+## 2.17.0
+
+### Minor Changes
+
+- [#541](https://github.com/atlassian-labs/atlaspack/pull/541) [`e2ba0f6`](https://github.com/atlassian-labs/atlaspack/commit/e2ba0f69702656f3d1ce95ab1454e35062b13b39) Thanks [@yamadapc](https://github.com/yamadapc)! - Add database compaction debug command
+
+### Patch Changes
+
+- [#530](https://github.com/atlassian-labs/atlaspack/pull/530) [`2e90c9b`](https://github.com/atlassian-labs/atlaspack/commit/2e90c9bd07d7eb52645f9d84ccbb7f82685cbc8c) Thanks [@yamadapc](https://github.com/yamadapc)! - Write metadata about the cache in a new entry
+
+- [#511](https://github.com/atlassian-labs/atlaspack/pull/511) [`11d6f16`](https://github.com/atlassian-labs/atlaspack/commit/11d6f16b6397dee2f217167e5c98b39edb63f7a7) Thanks [@yamadapc](https://github.com/yamadapc)! - Clean-up dylib worker threads segmentation fault bug fix feature-flag
+
+- Updated dependencies [[`11d6f16`](https://github.com/atlassian-labs/atlaspack/commit/11d6f16b6397dee2f217167e5c98b39edb63f7a7), [`e2ba0f6`](https://github.com/atlassian-labs/atlaspack/commit/e2ba0f69702656f3d1ce95ab1454e35062b13b39), [`d2c50c2`](https://github.com/atlassian-labs/atlaspack/commit/d2c50c2c020888b33bb25b8690d9320c2b69e2a6), [`46a90dc`](https://github.com/atlassian-labs/atlaspack/commit/46a90dccd019a26b222c878a92d23acc75dc67c5), [`4c17141`](https://github.com/atlassian-labs/atlaspack/commit/4c1714103dab2aa9039c488f381551d2b65d1d01)]:
+  - @atlaspack/feature-flags@2.14.3
+  - @atlaspack/rust@3.3.0
+  - @atlaspack/cache@3.2.0
+  - @atlaspack/fs@2.15.0
+  - @atlaspack/graph@3.4.3
+  - @atlaspack/utils@2.14.5
+  - @atlaspack/logger@2.14.5
+  - @atlaspack/package-manager@2.14.5
+  - @atlaspack/profiler@2.14.3
+  - @atlaspack/types@2.14.5
+  - @atlaspack/workers@2.14.5
+  - @atlaspack/plugin@2.14.5
+
 ## 2.16.1
 
 ### Patch Changes

package/lib/Atlaspack.js

@@ -166,9 +166,7 @@ class Atlaspack {
       ...this.#initialOptions.featureFlags
     };
     (0, _featureFlags().setFeatureFlags)(featureFlags);
-    if ((0, _featureFlags().getFeatureFlag)('enableRustWorkerThreadDylibHack')) {
-      (0, _rustWorkerThreadDylibHack.loadRustWorkerThreadDylibHack)();
-    }
+    (0, _rustWorkerThreadDylibHack.loadRustWorkerThreadDylibHack)();
     await _sourceMap().init;
     await (_rust().init === null || _rust().init === void 0 ? void 0 : (0, _rust().init)());
     this.#disposable = new (_events().Disposable)();
@@ -603,6 +601,19 @@ class Atlaspack {
     }
     return result;
   }
+
+  /**
+   * Copy the cache to a new directory and compact it.
+   */
+  async unstable_compactCache() {
+    await this._init();
+    const cache = (0, _nullthrows().default)(this.#resolvedOptions).cache;
+    if (cache instanceof _cache().LMDBLiteCache) {
+      await cache.compact('parcel-cache-compacted');
+    } else {
+      throw new Error('Cache is not an LMDBLiteCache');
+    }
+  }
   async unstable_transform(options) {
     var _options$env;
     if (!this.#initialized) {

package/lib/RequestTracker.js

@@ -279,6 +279,12 @@ class RequestGraph extends _graph().ContentGraph {
     // If the node is invalidated, the cached request chunk on disk needs to be re-written
     this.removeCachedRequestChunkForNode(nodeId);
   }
+
+  /**
+   * Nodes that are invalidated on start-up, such as JavaScript babel configuration files which are
+   * imported when the build kicks-off and might doing arbitrary work such as reading from the file
+   * system.
+   */
   invalidateUnpredictableNodes() {
     for (let nodeId of this.unpredicatableNodeIds) {
       let node = (0, _nullthrows().default)(this.getNode(nodeId));
@@ -286,6 +292,10 @@ class RequestGraph extends _graph().ContentGraph {
       this.invalidateNode(nodeId, _constants.STARTUP);
     }
   }
+
+  /**
+   * Effectively uncacheable nodes.
+   */
   invalidateOnBuildNodes() {
     for (let nodeId of this.invalidateOnBuildNodeIds) {
       let node = (0, _nullthrows().default)(this.getNode(nodeId));
@@ -293,29 +303,45 @@ class RequestGraph extends _graph().ContentGraph {
       this.invalidateNode(nodeId, _constants.STARTUP);
     }
   }
+
+  /**
+   * Nodes invalidated by environment changes, corresponds to `env: ...` inputs.
+   */
   invalidateEnvNodes(env) {
+    const invalidatedKeys = [];
     for (let nodeId of this.envNodeIds) {
       let node = (0, _nullthrows().default)(this.getNode(nodeId));
       (0, _assert().default)(node.type === ENV);
-      if (env[keyFromEnvContentKey(node.id)] !== node.value) {
+      const key = keyFromEnvContentKey(node.id);
+      if (env[key] !== node.value) {
+        invalidatedKeys.push(key);
         let parentNodes = this.getNodeIdsConnectedTo(nodeId, requestGraphEdgeTypes.invalidated_by_update);
         for (let parentNode of parentNodes) {
           this.invalidateNode(parentNode, _constants.ENV_CHANGE);
         }
       }
     }
+    return invalidatedKeys;
   }
+
+  /**
+   * Nodes invalidated by option changes.
+   */
   invalidateOptionNodes(options) {
+    const invalidatedKeys = [];
     for (let nodeId of this.optionNodeIds) {
       let node = (0, _nullthrows().default)(this.getNode(nodeId));
       (0, _assert().default)(node.type === OPTION);
-      if ((0, _utils2.hashFromOption)(options[keyFromOptionContentKey(node.id)]) !== node.hash) {
+      const key = keyFromOptionContentKey(node.id);
+      if ((0, _utils2.hashFromOption)(options[key]) !== node.hash) {
+        invalidatedKeys.push(key);
         let parentNodes = this.getNodeIdsConnectedTo(nodeId, requestGraphEdgeTypes.invalidated_by_update);
         for (let parentNode of parentNodes) {
           this.invalidateNode(parentNode, _constants.OPTION_CHANGE);
         }
       }
     }
+    return invalidatedKeys;
   }
   invalidateOnConfigKeyChange(requestNodeId, filePath, configKey, contentHash) {
     let configKeyNodeId = this.addNode(nodeFromConfigKey(filePath, configKey, contentHash));
@@ -1030,6 +1056,13 @@ class RequestTracker {
         nodeCountsPerBlob,
         nodes: undefined
       });
+      await runCacheImprovements(() => serialiseAndSet(`request_tracker:cache_metadata:${cacheKey}`, {
+        version: _constants.ATLASPACK_VERSION,
+        entries: this.options.entries,
+        mode: this.options.mode,
+        shouldBuildLazily: this.options.shouldBuildLazily,
+        watchBackend: this.options.watchBackend
+      }), () => Promise.resolve());
       let opts = getWatcherOptions(this.options);
       let snapshotPath = _path2().default.join(this.options.cacheDir, `snapshot-${cacheKey}` + '.txt');
       await this.options.outputFS.writeSnapshot(this.options.watchDir, snapshotPath, opts);
@@ -1112,12 +1145,22 @@ async function loadRequestGraph(options) {
   let timeout;
   const snapshotKey = `snapshot-${cacheKey}`;
   const snapshotPath = _path2().default.join(options.cacheDir, snapshotKey + '.txt');
+  const commonMeta = {
+    cacheKey,
+    snapshotKey,
+    cacheKeyOptions: {
+      version: _constants.ATLASPACK_VERSION,
+      entries: options.entries,
+      mode: options.mode,
+      shouldBuildLazily: options.shouldBuildLazily,
+      watchBackend: options.watchBackend
+    }
+  };
   _logger().default.verbose({
     origin: '@atlaspack/core',
     message: 'Loading request graph',
     meta: {
-      cacheKey,
-      snapshotKey
+      ...commonMeta
     }
   });
   if (await options.cache.hasLargeBlob(requestGraphKey)) {
@@ -1139,16 +1182,29 @@ async function loadRequestGraph(options) {
         origin: '@atlaspack/core',
         message: `File system event count: ${events.length}`,
         meta: {
+          ...commonMeta,
           trackableEvent: 'watcher_events_count',
           watcherEventCount: events.length,
           duration: Date.now() - startTime
         }
       });
-      requestGraph.invalidateUnpredictableNodes();
-      requestGraph.invalidateOnBuildNodes();
-      requestGraph.invalidateEnvNodes(options.env);
-      requestGraph.invalidateOptionNodes(options);
-      await requestGraph.respondToFSEvents(options.unstableFileInvalidations || events, options, 10000, true);
+      if ((0, _featureFlags().getFeatureFlag)('verboseRequestInvalidationStats')) {
+        const invalidationStats = await invalidateRequestGraph(requestGraph, options, events);
+        _logger().default.verbose({
+          origin: '@atlaspack/core',
+          message: 'Request track loaded from cache',
+          meta: {
+            ...commonMeta,
+            trackableEvent: 'request_tracker_cache_key_hit',
+            invalidationStats
+          }
+        });
+      } else {
+        requestGraph.invalidateUnpredictableNodes();
+        requestGraph.invalidateOnBuildNodes();
+        requestGraph.invalidateEnvNodes(options.env);
+        requestGraph.invalidateOptionNodes(options);
+      }
       return requestGraph;
     } catch (e) {
       // Prevent logging fs events took too long warning
@@ -1163,12 +1219,76 @@ async function loadRequestGraph(options) {
     origin: '@atlaspack/core',
     message: 'Cache entry for request tracker was not found, initializing a clean cache.',
     meta: {
-      cacheKey,
-      snapshotKey
+      ...commonMeta,
+      trackableEvent: 'request_tracker_cache_key_miss'
     }
   });
   return new RequestGraph();
 }
+
+/**
+ * A wrapper around an invalidation type / method
+ */
+
+/**
+ * Information about a certain cache invalidation type.
+ */
+
+/**
+ * Respond to unpredictable, build, environment changes, option changes and file-system events
+ * invalidating RequestGraph nodes.
+ *
+ * Returns the count of nodes invalidated by each invalidation type.
+ */
+async function invalidateRequestGraph(requestGraph, options, events) {
+  const invalidationFns = [{
+    key: 'unpredictable',
+    fn: () => requestGraph.invalidateUnpredictableNodes()
+  }, {
+    key: 'onBuild',
+    fn: () => requestGraph.invalidateOnBuildNodes()
+  }, {
+    key: 'env',
+    fn: () => requestGraph.invalidateEnvNodes(options.env)
+  }, {
+    key: 'option',
+    fn: () => requestGraph.invalidateOptionNodes(options)
+  }, {
+    key: 'fsEvents',
+    fn: async () => {
+      await requestGraph.respondToFSEvents(options.unstableFileInvalidations || events, options, 10000, true);
+    }
+  }];
+  const invalidations = [];
+  for (const invalidation of invalidationFns) {
+    invalidations.push(await runInvalidation(requestGraph, invalidation));
+  }
+  const invalidatedCount = invalidations.reduce((acc, invalidation) => acc + invalidation.count, 0);
+  const requestCount = requestGraph.nodes.reduce((acc, node) => acc + ((node === null || node === void 0 ? void 0 : node.type) === REQUEST ? 1 : 0), 0);
+  const nodeCount = requestGraph.nodes.length;
+  return {
+    invalidations,
+    nodeCount,
+    requestCount,
+    invalidatedCount,
+    nodeInvalidationRatio: invalidatedCount / nodeCount,
+    requestInvalidationRatio: invalidatedCount / requestCount
+  };
+}
+
+/**
+ * Runs an invalidation function and reports metrics.
+ */
+async function runInvalidation(requestGraph, invalidationFn) {
+  const startInvalidationCount = requestGraph.invalidNodeIds.size;
+  const result = await invalidationFn.fn();
+  const count = requestGraph.invalidNodeIds.size - startInvalidationCount;
+  return {
+    key: invalidationFn.key,
+    count,
+    changes: typeof result === 'object' && Array.isArray(result) ? result : null
+  };
+}
 function logErrorOnBailout(options, snapshotPath, e) {
   if (e.message && e.message.includes('invalid clockspec')) {
     const snapshotContents = options.inputFS.readFileSync(snapshotPath, 'utf-8');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/core",
-  "version": "2.16.2-canary.2+88fcaf47c",
+  "version": "2.16.2-canary.20+30f60175b",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -20,21 +20,21 @@
     "check-ts": "tsc --noEmit index.d.ts"
   },
   "dependencies": {
-    "@atlaspack/build-cache": "2.13.3-canary.70+88fcaf47c",
-    "@atlaspack/cache": "3.1.1-canary.2+88fcaf47c",
-    "@atlaspack/diagnostic": "2.14.1-canary.70+88fcaf47c",
-    "@atlaspack/events": "2.14.1-canary.70+88fcaf47c",
-    "@atlaspack/feature-flags": "2.14.1-canary.70+88fcaf47c",
-    "@atlaspack/fs": "2.14.5-canary.2+88fcaf47c",
-    "@atlaspack/graph": "3.4.1-canary.70+88fcaf47c",
-    "@atlaspack/logger": "2.14.5-canary.2+88fcaf47c",
-    "@atlaspack/package-manager": "2.14.5-canary.2+88fcaf47c",
-    "@atlaspack/plugin": "2.14.5-canary.2+88fcaf47c",
-    "@atlaspack/profiler": "2.14.1-canary.70+88fcaf47c",
-    "@atlaspack/rust": "3.2.1-canary.2+88fcaf47c",
-    "@atlaspack/types": "2.14.5-canary.2+88fcaf47c",
-    "@atlaspack/utils": "2.14.5-canary.2+88fcaf47c",
-    "@atlaspack/workers": "2.14.5-canary.2+88fcaf47c",
+    "@atlaspack/build-cache": "2.13.3-canary.88+30f60175b",
+    "@atlaspack/cache": "3.1.1-canary.20+30f60175b",
+    "@atlaspack/diagnostic": "2.14.1-canary.88+30f60175b",
+    "@atlaspack/events": "2.14.1-canary.88+30f60175b",
+    "@atlaspack/feature-flags": "2.14.1-canary.88+30f60175b",
+    "@atlaspack/fs": "2.14.5-canary.20+30f60175b",
+    "@atlaspack/graph": "3.4.1-canary.88+30f60175b",
+    "@atlaspack/logger": "2.14.5-canary.20+30f60175b",
+    "@atlaspack/package-manager": "2.14.5-canary.20+30f60175b",
+    "@atlaspack/plugin": "2.14.5-canary.20+30f60175b",
+    "@atlaspack/profiler": "2.14.1-canary.88+30f60175b",
+    "@atlaspack/rust": "3.2.1-canary.20+30f60175b",
+    "@atlaspack/types": "2.14.5-canary.20+30f60175b",
+    "@atlaspack/utils": "2.14.5-canary.20+30f60175b",
+    "@atlaspack/workers": "2.14.5-canary.20+30f60175b",
     "@mischnic/json-sourcemap": "^0.1.0",
     "@parcel/source-map": "^2.1.1",
     "base-x": "^3.0.8",
@@ -67,5 +67,5 @@
     "./src/serializerCore.js": "./src/serializerCore.browser.js"
   },
   "type": "commonjs",
-  "gitHead": "88fcaf47c77a6b7a16003028dd65a4b7a1f19dd7"
+  "gitHead": "30f60175ba4d272c5fc193973c63bc298584775b"
 }

package/src/Atlaspack.js

@@ -58,11 +58,7 @@ import {
   fromProjectPathRelative,
 } from './projectPath';
 import {tracer} from '@atlaspack/profiler';
-import {
-  getFeatureFlag,
-  setFeatureFlags,
-  DEFAULT_FEATURE_FLAGS,
-} from '@atlaspack/feature-flags';
+import {setFeatureFlags, DEFAULT_FEATURE_FLAGS} from '@atlaspack/feature-flags';
 import {AtlaspackV3, FileSystemV3} from './atlaspack-v3';
 import createAssetGraphRequestJS from './requests/AssetGraphRequest';
 import {createAssetGraphRequestRust} from './requests/AssetGraphRequestRust';
@@ -122,9 +118,7 @@ export default class Atlaspack {
     };
     setFeatureFlags(featureFlags);
 
-    if (getFeatureFlag('enableRustWorkerThreadDylibHack')) {
-      loadRustWorkerThreadDylibHack();
-    }
+    loadRustWorkerThreadDylibHack();
 
     await initSourcemaps;
     await initRust?.();
@@ -645,6 +639,20 @@ export default class Atlaspack {
     return result;
   }
 
+  /**
+   * Copy the cache to a new directory and compact it.
+   */
+  async unstable_compactCache(): Promise<void> {
+    await this._init();
+
+    const cache = nullthrows(this.#resolvedOptions).cache;
+    if (cache instanceof LMDBLiteCache) {
+      await cache.compact('parcel-cache-compacted');
+    } else {
+      throw new Error('Cache is not an LMDBLiteCache');
+    }
+  }
+
   async unstable_transform(
     options: AtlaspackTransformOptions,
   ): Promise<Array<Asset>> {

package/src/RequestTracker.js

@@ -446,6 +446,11 @@ export class RequestGraph extends ContentGraph<
     this.removeCachedRequestChunkForNode(nodeId);
   }
 
+  /**
+   * Nodes that are invalidated on start-up, such as JavaScript babel configuration files which are
+   * imported when the build kicks-off and might doing arbitrary work such as reading from the file
+   * system.
+   */
   invalidateUnpredictableNodes() {
     for (let nodeId of this.unpredicatableNodeIds) {
       let node = nullthrows(this.getNode(nodeId));
@@ -454,6 +459,9 @@ export class RequestGraph extends ContentGraph<
     }
   }
 
+  /**
+   * Effectively uncacheable nodes.
+   */
   invalidateOnBuildNodes() {
     for (let nodeId of this.invalidateOnBuildNodeIds) {
       let node = nullthrows(this.getNode(nodeId));
@@ -462,11 +470,20 @@ export class RequestGraph extends ContentGraph<
     }
   }
 
-  invalidateEnvNodes(env: EnvMap) {
+  /**
+   * Nodes invalidated by environment changes, corresponds to `env: ...` inputs.
+   */
+  invalidateEnvNodes(env: EnvMap): string[] {
+    const invalidatedKeys = [];
+
     for (let nodeId of this.envNodeIds) {
       let node = nullthrows(this.getNode(nodeId));
       invariant(node.type === ENV);
-      if (env[keyFromEnvContentKey(node.id)] !== node.value) {
+
+      const key = keyFromEnvContentKey(node.id);
+      if (env[key] !== node.value) {
+        invalidatedKeys.push(key);
+
         let parentNodes = this.getNodeIdsConnectedTo(
           nodeId,
           requestGraphEdgeTypes.invalidated_by_update,
@@ -476,15 +493,23 @@ export class RequestGraph extends ContentGraph<
         }
       }
     }
+
+    return invalidatedKeys;
   }
 
-  invalidateOptionNodes(options: AtlaspackOptions) {
+  /**
+   * Nodes invalidated by option changes.
+   */
+  invalidateOptionNodes(options: AtlaspackOptions): string[] {
+    const invalidatedKeys = [];
+
     for (let nodeId of this.optionNodeIds) {
       let node = nullthrows(this.getNode(nodeId));
       invariant(node.type === OPTION);
-      if (
-        hashFromOption(options[keyFromOptionContentKey(node.id)]) !== node.hash
-      ) {
+      const key = keyFromOptionContentKey(node.id);
+
+      if (hashFromOption(options[key]) !== node.hash) {
+        invalidatedKeys.push(key);
         let parentNodes = this.getNodeIdsConnectedTo(
           nodeId,
           requestGraphEdgeTypes.invalidated_by_update,
@@ -494,6 +519,8 @@ export class RequestGraph extends ContentGraph<
         }
       }
     }
+
+    return invalidatedKeys;
   }
 
   invalidateOnConfigKeyChange(
@@ -1605,6 +1632,18 @@ export default class RequestTracker {
         nodes: undefined,
       });
 
+      await runCacheImprovements(
+        () =>
+          serialiseAndSet(`request_tracker:cache_metadata:${cacheKey}`, {
+            version: ATLASPACK_VERSION,
+            entries: this.options.entries,
+            mode: this.options.mode,
+            shouldBuildLazily: this.options.shouldBuildLazily,
+            watchBackend: this.options.watchBackend,
+          }),
+        () => Promise.resolve(),
+      );
+
       let opts = getWatcherOptions(this.options);
       let snapshotPath = path.join(this.options.cacheDir, snapshotKey + '.txt');
 
@@ -1715,12 +1754,23 @@ async function loadRequestGraph(options): Async<RequestGraph> {
   const snapshotKey = `snapshot-${cacheKey}`;
   const snapshotPath = path.join(options.cacheDir, snapshotKey + '.txt');
 
+  const commonMeta = {
+    cacheKey,
+    snapshotKey,
+    cacheKeyOptions: {
+      version: ATLASPACK_VERSION,
+      entries: options.entries,
+      mode: options.mode,
+      shouldBuildLazily: options.shouldBuildLazily,
+      watchBackend: options.watchBackend,
+    },
+  };
+
   logger.verbose({
     origin: '@atlaspack/core',
     message: 'Loading request graph',
     meta: {
-      cacheKey,
-      snapshotKey,
+      ...commonMeta,
     },
   });
 
@@ -1755,23 +1805,36 @@ async function loadRequestGraph(options): Async<RequestGraph> {
         origin: '@atlaspack/core',
         message: `File system event count: ${events.length}`,
         meta: {
+          ...commonMeta,
           trackableEvent: 'watcher_events_count',
           watcherEventCount: events.length,
           duration: Date.now() - startTime,
         },
       });
 
-      requestGraph.invalidateUnpredictableNodes();
-      requestGraph.invalidateOnBuildNodes();
-      requestGraph.invalidateEnvNodes(options.env);
-      requestGraph.invalidateOptionNodes(options);
+      if (getFeatureFlag('verboseRequestInvalidationStats')) {
+        const invalidationStats = await invalidateRequestGraph(
+          requestGraph,
+          options,
+          events,
+        );
+
+        logger.verbose({
+          origin: '@atlaspack/core',
+          message: 'Request track loaded from cache',
+          meta: {
+            ...commonMeta,
+            trackableEvent: 'request_tracker_cache_key_hit',
+            invalidationStats,
+          },
+        });
+      } else {
+        requestGraph.invalidateUnpredictableNodes();
+        requestGraph.invalidateOnBuildNodes();
+        requestGraph.invalidateEnvNodes(options.env);
+        requestGraph.invalidateOptionNodes(options);
+      }
 
-      await requestGraph.respondToFSEvents(
-        options.unstableFileInvalidations || events,
-        options,
-        10000,
-        true,
-      );
       return requestGraph;
     } catch (e) {
       // Prevent logging fs events took too long warning
@@ -1788,13 +1851,158 @@ async function loadRequestGraph(options): Async<RequestGraph> {
     message:
       'Cache entry for request tracker was not found, initializing a clean cache.',
     meta: {
-      cacheKey,
-      snapshotKey,
+      ...commonMeta,
+      trackableEvent: 'request_tracker_cache_key_miss',
     },
   });
   return new RequestGraph();
 }
 
+/**
+ * A wrapper around an invalidation type / method
+ */
+type InvalidationFn = {|
+  key: string,
+  fn: () => string[] | void | Promise<void>,
+|};
+
+type InvalidationStats = {|
+  /**
+   * Total number of request graph nodes
+   */
+  nodeCount: number,
+  /**
+   * Number of requests in RequestGraph
+   */
+  requestCount: number,
+  /**
+   * Number of nodes that have been invalidated.
+   */
+  invalidatedCount: number,
+  /**
+   * Percentage of requests that have been invalidated
+   */
+  requestInvalidationRatio: number,
+  /**
+   * Percentage of nodes that have been invalidated
+   */
+  nodeInvalidationRatio: number,
+  /**
+   * Details for each invalidation type
+   */
+  invalidations: InvalidationFnStats[],
+|};
+
+/**
+ * Information about a certain cache invalidation type.
+ */
+type InvalidationFnStats = {|
+  /**
+   * Invalidation type, one of:
+   *
+   * - unpredictable
+   * - onBuild
+   * - env
+   * - option
+   * - fsEvents
+   */
+  key: string,
+  /**
+   * Number of invalidated nodes coming from this invalidation type.
+   */
+  count: number,
+  /**
+   * If this is a env or option invalidation, this key will contain the list of changed values.
+   */
+  changes: null | string[],
+|};
+
+/**
+ * Respond to unpredictable, build, environment changes, option changes and file-system events
+ * invalidating RequestGraph nodes.
+ *
+ * Returns the count of nodes invalidated by each invalidation type.
+ */
+async function invalidateRequestGraph(
+  requestGraph: RequestGraph,
+  options: AtlaspackOptions,
+  events: Event[],
+): Promise<InvalidationStats> {
+  const invalidationFns: InvalidationFn[] = [
+    {
+      key: 'unpredictable',
+      fn: () => requestGraph.invalidateUnpredictableNodes(),
+    },
+    {
+      key: 'onBuild',
+      fn: () => requestGraph.invalidateOnBuildNodes(),
+    },
+    {
+      key: 'env',
+      fn: () => requestGraph.invalidateEnvNodes(options.env),
+    },
+    {
+      key: 'option',
+      fn: () => requestGraph.invalidateOptionNodes(options),
+    },
+    {
+      key: 'fsEvents',
+      fn: async () => {
+        await requestGraph.respondToFSEvents(
+          options.unstableFileInvalidations || events,
+          options,
+          10000,
+          true,
+        );
+      },
+    },
+  ];
+
+  const invalidations = [];
+  for (const invalidation of invalidationFns) {
+    invalidations.push(await runInvalidation(requestGraph, invalidation));
+  }
+  const invalidatedCount = invalidations.reduce(
+    (acc, invalidation) => acc + invalidation.count,
+    0,
+  );
+  const requestCount = requestGraph.nodes.reduce(
+    (acc, node) => acc + (node?.type === REQUEST ? 1 : 0),
+    0,
+  );
+  const nodeCount = requestGraph.nodes.length;
+  const nodeInvalidationRatio = invalidatedCount / nodeCount;
+  const requestInvalidationRatio = invalidatedCount / requestCount;
+
+  return {
+    invalidations,
+    nodeCount,
+    requestCount,
+    invalidatedCount,
+    nodeInvalidationRatio,
+    requestInvalidationRatio,
+  };
+}
+
+/**
+ * Runs an invalidation function and reports metrics.
+ */
+async function runInvalidation(
+  requestGraph: RequestGraph,
+  invalidationFn: InvalidationFn,
+): Promise<InvalidationFnStats> {
+  const startInvalidationCount = requestGraph.invalidNodeIds.size;
+  const result = await invalidationFn.fn();
+  const count = requestGraph.invalidNodeIds.size - startInvalidationCount;
+
+  return {
+    key: invalidationFn.key,
+    count,
+    changes:
+      typeof result === 'object' && Array.isArray(result) ? result : null,
+  };
+}
+
 function logErrorOnBailout(
   options: AtlaspackOptions,
   snapshotPath: string,