@fluidframework/container-runtime 2.0.0-internal.2.1.1 → 2.0.0-internal.2.2.0

package/dist/garbageCollection.js

@@ -15,7 +15,7 @@ var __rest = (this && this.__rest) || function (s, e) {
     return t;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GarbageCollector = exports.UnreferencedStateTracker = exports.UnreferencedState = exports.GCNodeType = exports.defaultSessionExpiryDurationMs = exports.defaultInactiveTimeoutMs = exports.oneDayMs = exports.testTombstoneKey = exports.disableSweepLogKey = exports.trackGCStateKey = exports.runSessionExpiryKey = exports.gcTestModeKey = exports.runSweepKey = exports.runGCKey = exports.gcTombstoneBlobKey = exports.gcBlobPrefix = exports.gcTreeKey = void 0;
+exports.GarbageCollector = exports.UnreferencedStateTracker = exports.UnreferencedState = exports.GCNodeType = void 0;
 const common_utils_1 = require("@fluidframework/common-utils");
 const container_utils_1 = require("@fluidframework/container-utils");
 const garbage_collector_1 = require("@fluidframework/garbage-collector");
@@ -25,34 +25,11 @@ const runtime_utils_1 = require("@fluidframework/runtime-utils");
 const telemetry_utils_1 = require("@fluidframework/telemetry-utils");
 const containerRuntime_1 = require("./containerRuntime");
 const dataStores_1 = require("./dataStores");
+const garbageCollectionConstants_1 = require("./garbageCollectionConstants");
 const gcSweepReadyUsageDetection_1 = require("./gcSweepReadyUsageDetection");
 const summaryFormat_1 = require("./summaryFormat");
 /** This is the current version of garbage collection. */
 const GCVersion = 1;
-// The key for the GC tree in summary.
-exports.gcTreeKey = "gc";
-// They prefix for GC blobs in the GC tree in summary.
-exports.gcBlobPrefix = "__gc";
-// The key for tombstone blob in the GC tree in summary.
-exports.gcTombstoneBlobKey = "__tombstones";
-// Feature gate key to turn GC on / off.
-exports.runGCKey = "Fluid.GarbageCollection.RunGC";
-// Feature gate key to turn GC sweep on / off.
-exports.runSweepKey = "Fluid.GarbageCollection.RunSweep";
-// Feature gate key to turn GC test mode on / off.
-exports.gcTestModeKey = "Fluid.GarbageCollection.GCTestMode";
-// Feature gate key to expire a session after a set period of time.
-exports.runSessionExpiryKey = "Fluid.GarbageCollection.RunSessionExpiry";
-// Feature gate key to write the gc blob as a handle if the data is the same.
-exports.trackGCStateKey = "Fluid.GarbageCollection.TrackGCState";
-// Feature gate key to turn GC sweep log off.
-exports.disableSweepLogKey = "Fluid.GarbageCollection.DisableSweepLog";
-// Feature gate key to tombstone datastores.
-exports.testTombstoneKey = "Fluid.GarbageCollection.Test.Tombstone";
-// One day in milliseconds.
-exports.oneDayMs = 1 * 24 * 60 * 60 * 1000;
-exports.defaultInactiveTimeoutMs = 7 * exports.oneDayMs; // 7 days
-exports.defaultSessionExpiryDurationMs = 30 * exports.oneDayMs; // 30 days
 /** The types of GC nodes in the GC reference graph. */
 exports.GCNodeType = {
     // Nodes that are for data stores.
@@ -165,7 +142,7 @@ exports.UnreferencedStateTracker = UnreferencedStateTracker;
  */
 class GarbageCollector {
     constructor(createParams) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        var _a, _b, _c, _d, _e, _f, _g, _h;
         /**
          * Tells whether the initial GC state needs to be reset. This can happen under 2 conditions:
          *
@@ -197,6 +174,7 @@ class GarbageCollector {
         this.runtime = createParams.runtime;
         this.isSummarizerClient = createParams.isSummarizerClient;
         this.gcOptions = createParams.gcOptions;
+        this.createContainerMetadata = createParams.createContainerMetadata;
         this.getNodePackagePath = createParams.getNodePackagePath;
         this.getLastSummaryTimestampMs = createParams.getLastSummaryTimestampMs;
         this.activeConnection = createParams.activeConnection;
@@ -215,8 +193,8 @@ class GarbageCollector {
          * We use server timestamps throughout so the skew should be minimal but make it 1 day to be safe.
          */
         function computeSweepTimeout(sessionExpiryTimeoutMs) {
-            const maxSnapshotCacheExpiryMs = 5 * exports.oneDayMs;
-            const bufferMs = exports.oneDayMs;
+            const maxSnapshotCacheExpiryMs = 5 * garbageCollectionConstants_1.oneDayMs;
+            const bufferMs = garbageCollectionConstants_1.oneDayMs;
             return sessionExpiryTimeoutMs &&
                 (sessionExpiryTimeoutMs + maxSnapshotCacheExpiryMs + bufferMs);
         }
@@ -252,8 +230,8 @@ class GarbageCollector {
             // ...unless we're using the TestOverride
             this.sweepEnabled = this.gcOptions.sweepAllowed === true || testOverrideSweepTimeoutMs !== undefined;
             // Set the Session Expiry only if the flag is enabled and GC is enabled.
-            if (this.mc.config.getBoolean(exports.runSessionExpiryKey) && this.gcEnabled) {
-                this.sessionExpiryTimeoutMs = (_c = this.gcOptions.sessionExpiryTimeoutMs) !== null && _c !== void 0 ? _c : exports.defaultSessionExpiryDurationMs;
+            if (this.mc.config.getBoolean(garbageCollectionConstants_1.runSessionExpiryKey) && this.gcEnabled) {
+                this.sessionExpiryTimeoutMs = (_c = this.gcOptions.sessionExpiryTimeoutMs) !== null && _c !== void 0 ? _c : garbageCollectionConstants_1.defaultSessionExpiryDurationMs;
             }
             this.sweepTimeoutMs =
                 testOverrideSweepTimeoutMs !== null && testOverrideSweepTimeoutMs !== void 0 ? testOverrideSweepTimeoutMs : computeSweepTimeout(this.sessionExpiryTimeoutMs);
@@ -278,7 +256,7 @@ class GarbageCollector {
          *
          * These conditions can be overridden via runGCKey feature flag.
          */
-        this.shouldRunGC = (_d = this.mc.config.getBoolean(exports.runGCKey)) !== null && _d !== void 0 ? _d : (
+        this.shouldRunGC = (_d = this.mc.config.getBoolean(garbageCollectionConstants_1.runGCKey)) !== null && _d !== void 0 ? _d : (
         // GC must be enabled for the document.
         this.gcEnabled
             // GC must not be disabled via GC options.
@@ -296,43 +274,34 @@ class GarbageCollector {
         this.shouldRunSweep =
             this.shouldRunGC
                 && this.sweepTimeoutMs !== undefined
-                && ((_e = this.mc.config.getBoolean(exports.runSweepKey)) !== null && _e !== void 0 ? _e : this.sweepEnabled);
-        this.trackGCState = this.mc.config.getBoolean(exports.trackGCStateKey) === true;
+                && ((_e = this.mc.config.getBoolean(garbageCollectionConstants_1.runSweepKey)) !== null && _e !== void 0 ? _e : this.sweepEnabled);
+        this.trackGCState = this.mc.config.getBoolean(garbageCollectionConstants_1.trackGCStateKey) === true;
         // Override inactive timeout if test config or gc options to override it is set.
-        this.inactiveTimeoutMs = (_g = (_f = this.mc.config.getNumber("Fluid.GarbageCollection.TestOverride.InactiveTimeoutMs")) !== null && _f !== void 0 ? _f : this.gcOptions.inactiveTimeoutMs) !== null && _g !== void 0 ? _g : exports.defaultInactiveTimeoutMs;
+        this.inactiveTimeoutMs = (_g = (_f = this.mc.config.getNumber("Fluid.GarbageCollection.TestOverride.InactiveTimeoutMs")) !== null && _f !== void 0 ? _f : this.gcOptions.inactiveTimeoutMs) !== null && _g !== void 0 ? _g : garbageCollectionConstants_1.defaultInactiveTimeoutMs;
         // Inactive timeout must be greater than sweep timeout since a node goes from active -> inactive -> sweep ready.
         if (this.sweepTimeoutMs !== undefined && this.inactiveTimeoutMs > this.sweepTimeoutMs) {
             throw new container_utils_1.UsageError("inactive timeout should not be greater than the sweep timeout");
         }
         // Whether we are running in test mode. In this mode, unreferenced nodes are immediately deleted.
-        this.testMode = (_h = this.mc.config.getBoolean(exports.gcTestModeKey)) !== null && _h !== void 0 ? _h : this.gcOptions.runGCInTestMode === true;
-        this.tombstoneMode = (_j = this.mc.config.getBoolean(exports.testTombstoneKey)) !== null && _j !== void 0 ? _j : false;
+        this.testMode = (_h = this.mc.config.getBoolean(garbageCollectionConstants_1.gcTestModeKey)) !== null && _h !== void 0 ? _h : this.gcOptions.runGCInTestMode === true;
+        // Whether we are running in tombstone mode. This is true by default unless disabled via feature flags.
+        this.tombstoneMode = this.mc.config.getBoolean(garbageCollectionConstants_1.disableTombstoneKey) !== true;
         // The GC state needs to be reset if the base snapshot contains GC tree and GC is disabled or it doesn't
         // contain GC tree and GC is enabled.
-        const gcTreePresent = (baseSnapshot === null || baseSnapshot === void 0 ? void 0 : baseSnapshot.trees[exports.gcTreeKey]) !== undefined;
+        const gcTreePresent = (baseSnapshot === null || baseSnapshot === void 0 ? void 0 : baseSnapshot.trees[garbageCollectionConstants_1.gcTreeKey]) !== undefined;
         this.initialStateNeedsReset = gcTreePresent !== this.shouldRunGC;
-        // Get the GC state from the GC blob in the base snapshot. Use LazyPromise because we only want to do
-        // this once since it involves fetching blobs from storage which is expensive.
-        const baseSummaryStateP = new common_utils_1.LazyPromise(async () => {
+        // Get the GC data from the base snapshot. Use LazyPromise because we only want to do this once since it
+        // it involves fetching blobs from storage which is expensive.
+        this.baseSnapshotDataP = new common_utils_1.LazyPromise(async () => {
             var _a;
             if (baseSnapshot === undefined) {
                 return undefined;
             }
             try {
                 // For newer documents, GC data should be present in the GC tree in the root of the snapshot.
-                const gcSnapshotTree = baseSnapshot.trees[exports.gcTreeKey];
+                const gcSnapshotTree = baseSnapshot.trees[garbageCollectionConstants_1.gcTreeKey];
                 if (gcSnapshotTree !== undefined) {
-                    const baseGCData = await getGCDataFromSnapshot(gcSnapshotTree, readAndParseBlob);
-                    if (baseGCData.tombstones !== undefined && this.tombstoneMode) {
-                        this.tombstones = baseGCData.tombstones;
-                    }
-                    if (this.trackGCState) {
-                        this.latestSummaryData = {
-                            serializedGCState: JSON.stringify(generateSortedGCState(baseGCData.gcState)),
-                            serializedTombstones: JSON.stringify(baseGCData.tombstones),
-                        };
-                    }
-                    return baseGCData.gcState;
+                    return getGCDataFromSnapshot(gcSnapshotTree, readAndParseBlob);
                 }
                 // back-compat - Older documents will have the GC blobs in each data store's summary tree. Get them and
                 // consolidate into IGarbageCollectionState format.
@@ -368,7 +337,7 @@ class GarbageCollector {
                 }
                 // If there is only one node (root node just added above), either GC is disabled or we are loading from
                 // the first summary generated by detached container. In both cases, GC was not run - return undefined.
-                return Object.keys(gcState.gcNodes).length === 1 ? undefined : gcState;
+                return Object.keys(gcState.gcNodes).length === 1 ? undefined : { gcState, tombstones: undefined };
             }
             catch (error) {
                 const dpe = container_utils_1.DataProcessingError.wrapIfUnrecognized(error, "FailedToInitializeGC");
@@ -377,11 +346,11 @@ class GarbageCollector {
             }
         });
         /**
-         * Set up the initializer which initializes the base GC state from the base snapshot. Note that the reference
-         * timestamp maybe from old ops which were not summarized and stored in the file. So, the unreferenced state
-         * may be out of date. This is fine because the state is updated every time GC runs based on the time then.
+         * Set up the initializer which initializes the GC state from the data in base snapshot. This is done when
+         * connected in write mode or when GC runs the first time. It sets up all unreferenced nodes from the base
+         * GC state and updates their inactive or sweep ready state.
          */
-        this.initializeBaseStateP = new common_utils_1.LazyPromise(async () => {
+        this.initializeGCStateFromBaseSnapshotP = new common_utils_1.LazyPromise(async () => {
             const currentReferenceTimestampMs = this.runtime.getCurrentReferenceTimestampMs();
             /**
              * If there is no current reference timestamp, skip initialization. We need the current timestamp to track
@@ -399,34 +368,41 @@ class GarbageCollector {
                 });
                 return;
             }
-            const baseState = await baseSummaryStateP;
+            const baseSnapshotData = await this.baseSnapshotDataP;
             /**
-             * The base state will not be present if the container is loaded from:
+             * The base snapshot data will not be present if the container is loaded from:
              * 1. The first summary created by the detached container.
              * 2. A summary that was generated with GC disabled.
              * 3. A summary that was generated before GC even existed.
              */
-            if (baseState === undefined) {
+            if (baseSnapshotData === undefined) {
                 return;
             }
             const gcNodes = {};
-            for (const [nodeId, nodeData] of Object.entries(baseState.gcNodes)) {
+            for (const [nodeId, nodeData] of Object.entries(baseSnapshotData.gcState.gcNodes)) {
                 if (nodeData.unreferencedTimestampMs !== undefined) {
                     this.unreferencedNodesState.set(nodeId, new UnreferencedStateTracker(nodeData.unreferencedTimestampMs, this.inactiveTimeoutMs, currentReferenceTimestampMs, this.sweepTimeoutMs));
                 }
                 gcNodes[nodeId] = Array.from(nodeData.outboundRoutes);
             }
             this.previousGCDataFromLastRun = { gcNodes };
+            // If tracking state across summaries, update latest summary data from the base snapshot's GC data.
+            if (this.trackGCState) {
+                this.latestSummaryData = {
+                    serializedGCState: JSON.stringify(generateSortedGCState(baseSnapshotData.gcState)),
+                    serializedTombstones: JSON.stringify(baseSnapshotData.tombstones),
+                };
+            }
         });
         // Get the GC details for each node from the GC state in the base summary. This is returned in getBaseGCDetails
         // which the caller uses to initialize each node's GC state.
         this.baseGCDetailsP = new common_utils_1.LazyPromise(async () => {
-            const baseState = await baseSummaryStateP;
-            if (baseState === undefined) {
+            const baseSnapshotData = await this.baseSnapshotDataP;
+            if (baseSnapshotData === undefined) {
                 return new Map();
             }
             const gcNodes = {};
-            for (const [nodeId, nodeData] of Object.entries(baseState.gcNodes)) {
+            for (const [nodeId, nodeData] of Object.entries(baseSnapshotData.gcState.gcNodes)) {
                 gcNodes[nodeId] = Array.from(nodeData.outboundRoutes);
             }
             // Run GC on the nodes in the base summary to get the routes used in each node in the container.
@@ -436,7 +412,7 @@ class GarbageCollector {
             const baseGCDetailsMap = (0, garbage_collector_1.unpackChildNodesGCDetails)({ gcData: { gcNodes }, usedRoutes });
             // Currently, the nodes may write the GC data. So, we need to update its base GC details with the
             // unreferenced timestamp. Once we start writing the GC data here, we won't need to do this anymore.
-            for (const [nodeId, nodeData] of Object.entries(baseState.gcNodes)) {
+            for (const [nodeId, nodeData] of Object.entries(baseSnapshotData.gcState.gcNodes)) {
                 if (nodeData.unreferencedTimestampMs !== undefined) {
                     const dataStoreGCDetails = baseGCDetailsMap.get(nodeId.slice(1));
                     if (dataStoreGCDetails !== undefined) {
@@ -479,6 +455,26 @@ class GarbageCollector {
     get configs() {
         return Object.assign({ gcEnabled: this.gcEnabled, sweepEnabled: this.sweepEnabled, runGC: this.shouldRunGC, runSweep: this.shouldRunSweep, testMode: this.testMode, tombstoneMode: this.tombstoneMode, sessionExpiry: this.sessionExpiryTimeoutMs, sweepTimeout: this.sweepTimeoutMs, inactiveTimeout: this.inactiveTimeoutMs, trackGCState: this.trackGCState }, this.gcOptions);
     }
+    /**
+     * Called during container initialization. Initialize the tombstone state so that object are marked as tombstones
+     * before they are loaded or used. This is important to get accurate information of whether tombstoned object are
+     * in use or not.
+     */
+    async initializeBaseState() {
+        const baseSnapshotData = await this.baseSnapshotDataP;
+        /**
+         * The base snapshot data or tombstone state will not be present if the container is loaded from:
+         * 1. The first summary created by the detached container.
+         * 2. A summary that was generated with GC disabled.
+         * 3. A summary that was generated before GC even existed.
+         * 4. A summary that was generated with tombstone feature disabled.
+         */
+        if (!this.tombstoneMode || (baseSnapshotData === null || baseSnapshotData === void 0 ? void 0 : baseSnapshotData.tombstones) === undefined) {
+            return;
+        }
+        this.tombstones = baseSnapshotData.tombstones;
+        this.runtime.updateUnusedRoutes(this.tombstones, true /* tombstone */);
+    }
     /**
      * Called when the connection state of the runtime changes, i.e., it connects or disconnects. GC subscribes to this
      * to initialize the base state for non-summarizer clients so that they can track inactive / sweep ready nodes.
@@ -500,7 +496,7 @@ class GarbageCollector {
          * sweep in phases and we want to track when inactive and sweep ready objects are used in any client.
          */
         if (this.activeConnection() && this.shouldRunGC) {
-            this.initializeBaseStateP.catch((error) => { });
+            this.initializeGCStateFromBaseSnapshotP.catch((error) => { });
         }
     }
     /**
@@ -542,8 +538,8 @@ class GarbageCollector {
         }, { end: true, cancel: "error" });
     }
     async runPreGCSteps() {
-        // Ensure that base state has been initialized.
-        await this.initializeBaseStateP;
+        // Ensure that state has been initialized from the base snapshot data.
+        await this.initializeGCStateFromBaseSnapshotP;
         // Let the runtime update its pending state before GC runs.
         await this.runtime.updateStateBeforeGC();
     }
@@ -563,23 +559,13 @@ class GarbageCollector {
         // If we are running in GC test mode, delete objects for unused routes. This enables testing scenarios
         // involving access to deleted data.
         if (this.testMode) {
-            this.runtime.deleteUnusedRoutes(gcResult.deletedNodeIds);
+            this.runtime.updateUnusedRoutes(gcResult.deletedNodeIds, false /* tombstone */);
         }
-        else {
+        else if (this.tombstoneMode) {
             // If we are running in GC tombstone mode, tombstone objects for unused routes. This enables testing
             // scenarios involving access to "deleted" data without actually deleting the data from summaries.
             // Note: we will not tombstone in test mode
-            if (this.tombstoneMode) {
-                const tombstoneRoutes = [];
-                // Currently only tombstone datastores
-                for (const [key, value] of this.unreferencedNodesState.entries()) {
-                    if (value.state === exports.UnreferencedState.SweepReady &&
-                        this.runtime.getNodeType(key) === exports.GCNodeType.DataStore) {
-                        tombstoneRoutes.push(key);
-                    }
-                }
-                this.runtime.deleteUnusedRoutes(tombstoneRoutes);
-            }
+            this.runtime.updateUnusedRoutes(this.tombstones, true /* tombstone */);
         }
         // Log pending unreferenced events such as a node being used after inactive. This is done after GC runs and
         // updates its state so that we don't send false positives based on intermediate state. For example, we may get
@@ -605,7 +591,9 @@ class GarbageCollector {
             };
         }
         const serializedGCState = JSON.stringify(generateSortedGCState(gcState));
-        const serializedTombstones = this.tombstones.length > 0 ? JSON.stringify(this.tombstones.sort()) : undefined;
+        const serializedTombstones = this.tombstoneMode
+            ? (this.tombstones.length > 0 ? JSON.stringify(this.tombstones.sort()) : undefined)
+            : undefined;
         /**
          * Incremental summary of GC data - If any of the GC state or tombstone state hasn't changed since the last
          * summary, send summary handles for them. Otherwise, send the data in summary blobs.
@@ -621,7 +609,7 @@ class GarbageCollector {
                     return {
                         summary: {
                             type: protocol_definitions_1.SummaryType.Handle,
-                            handle: `/${exports.gcTreeKey}`,
+                            handle: `/${garbageCollectionConstants_1.gcTreeKey}`,
                             handleType: protocol_definitions_1.SummaryType.Tree,
                         },
                         stats,
@@ -645,11 +633,11 @@ class GarbageCollector {
      */
     buildGCSummaryTree(serializedGCState, serializedTombstones, trackState) {
         var _a, _b;
-        const gcStateBlobKey = `${exports.gcBlobPrefix}_root`;
+        const gcStateBlobKey = `${garbageCollectionConstants_1.gcBlobPrefix}_root`;
         const builder = new runtime_utils_1.SummaryTreeBuilder();
         // If the GC state hasn't changed, write a summary handle, else write a summary blob for it.
         if (((_a = this.latestSummaryData) === null || _a === void 0 ? void 0 : _a.serializedGCState) === serializedGCState && trackState) {
-            builder.addHandle(gcStateBlobKey, protocol_definitions_1.SummaryType.Blob, `/${exports.gcTreeKey}/${gcStateBlobKey}`);
+            builder.addHandle(gcStateBlobKey, protocol_definitions_1.SummaryType.Blob, `/${garbageCollectionConstants_1.gcTreeKey}/${gcStateBlobKey}`);
         }
         else {
             builder.addBlob(gcStateBlobKey, serializedGCState);
@@ -660,10 +648,10 @@ class GarbageCollector {
         }
         // If the tombstone state hasn't changed, write a summary handle, else write a summary blob for it.
         if (((_b = this.latestSummaryData) === null || _b === void 0 ? void 0 : _b.serializedTombstones) === serializedTombstones && trackState) {
-            builder.addHandle(exports.gcTombstoneBlobKey, protocol_definitions_1.SummaryType.Blob, `/${exports.gcTreeKey}/${exports.gcTombstoneBlobKey}`);
+            builder.addHandle(garbageCollectionConstants_1.gcTombstoneBlobKey, protocol_definitions_1.SummaryType.Blob, `/${garbageCollectionConstants_1.gcTreeKey}/${garbageCollectionConstants_1.gcTombstoneBlobKey}`);
         }
         else {
-            builder.addBlob(exports.gcTombstoneBlobKey, serializedTombstones);
+            builder.addBlob(garbageCollectionConstants_1.gcTombstoneBlobKey, serializedTombstones);
         }
         return builder.getSummaryTree();
     }
@@ -713,7 +701,7 @@ class GarbageCollector {
             const metadata = await readAndParseBlob(metadataBlobId);
             this.latestSummaryGCVersion = (0, summaryFormat_1.getGCVersion)(metadata);
         }
-        const gcSnapshotTree = snapshot.trees[exports.gcTreeKey];
+        const gcSnapshotTree = snapshot.trees[garbageCollectionConstants_1.gcTreeKey];
         if (gcSnapshotTree !== undefined && this.trackGCState) {
             const latestGCData = await getGCDataFromSnapshot(gcSnapshotTree, readAndParseBlob);
             this.latestSummaryData = {
@@ -988,7 +976,7 @@ class GarbageCollector {
      * this will give us a view into how much deleted content a container has.
      */
     logSweepEvents(logger, currentReferenceTimestampMs) {
-        if (this.mc.config.getBoolean(exports.disableSweepLogKey) === true || this.sweepTimeoutMs === undefined) {
+        if (this.mc.config.getBoolean(garbageCollectionConstants_1.disableSweepLogKey) === true || this.sweepTimeoutMs === undefined) {
             return;
         }
         this.unreferencedNodesState.forEach((nodeStateTracker, nodeId) => {
@@ -1038,31 +1026,24 @@ class GarbageCollector {
             return;
         }
         this.loggedUnreferencedEvents.add(uniqueEventId);
-        const propsToLog = {
-            id: nodeId,
-            type: nodeType,
-            unrefTime: nodeStateTracker.unreferencedTimestampMs,
-            age: currentReferenceTimestampMs - nodeStateTracker.unreferencedTimestampMs,
-            timeout: nodeStateTracker.state === exports.UnreferencedState.Inactive
+        const propsToLog = Object.assign(Object.assign({ id: nodeId, type: nodeType, unrefTime: nodeStateTracker.unreferencedTimestampMs, age: currentReferenceTimestampMs - nodeStateTracker.unreferencedTimestampMs, timeout: nodeStateTracker.state === exports.UnreferencedState.Inactive
                 ? this.inactiveTimeoutMs
-                : this.sweepTimeoutMs,
-            completedGCRuns: this.completedRuns,
-            lastSummaryTime: this.getLastSummaryTimestampMs(),
-            externalRequest: requestHeaders === null || requestHeaders === void 0 ? void 0 : requestHeaders[containerRuntime_1.RuntimeHeaders.externalRequest],
-            viaHandle: requestHeaders === null || requestHeaders === void 0 ? void 0 : requestHeaders[containerRuntime_1.RuntimeHeaders.viaHandle],
-            fromId: fromNodeId,
-        };
+                : this.sweepTimeoutMs, completedGCRuns: this.completedRuns, lastSummaryTime: this.getLastSummaryTimestampMs() }, this.createContainerMetadata), { externalRequest: requestHeaders === null || requestHeaders === void 0 ? void 0 : requestHeaders[containerRuntime_1.RuntimeHeaders.externalRequest], viaHandle: requestHeaders === null || requestHeaders === void 0 ? void 0 : requestHeaders[containerRuntime_1.RuntimeHeaders.viaHandle], fromId: fromNodeId });
         // For summarizer client, queue the event so it is logged the next time GC runs if the event is still valid.
         // For non-summarizer client, log the event now since GC won't run on it. This may result in false positives
         // but it's a good signal nonetheless and we can consume it with a grain of salt.
+        // Inactive errors are usages of Objects that are unreferenced for at least a period of 7 days.
+        // SweepReady errors are usages of Objects that will be deleted by GC Sweep!
         if (this.isSummarizerClient) {
             this.pendingEventsQueue.push(Object.assign(Object.assign({}, propsToLog), { usageType, state }));
         }
         else {
             // For non-summarizer clients, only log "Loaded" type events since these objects may not be loaded in the
             // summarizer clients if they are based off of user actions (such as scrolling to content for these objects)
+            // Events generated:
+            // InactiveObject_Loaded, SweepReadyObject_Loaded
             if (usageType === "Loaded") {
-                this.mc.logger.sendErrorEvent(Object.assign(Object.assign({}, propsToLog), { eventName: `${state}Object_${usageType}`, pkg: packagePath ? { value: packagePath.join("/"), tag: telemetry_utils_1.TelemetryDataTag.CodeArtifact } : undefined, stack: (0, telemetry_utils_1.generateStack)() }));
+                this.mc.logger.sendErrorEvent(Object.assign(Object.assign({}, propsToLog), { eventName: `${state}Object_${usageType}`, pkg: (0, runtime_utils_1.packagePathToTelemetryProperty)(packagePath), stack: (0, telemetry_utils_1.generateStack)() }));
             }
             // If SweepReady Usage Detection is enabed, the handler may close the interactive container.
             // Once Sweep is fully implemented, this will be removed since the objects will be gone
@@ -1073,6 +1054,11 @@ class GarbageCollector {
         }
     }
     async logUnreferencedEvents(logger) {
+        // Events sent come only from the summarizer client. In between summaries, events are pushed to a queue and at
+        // summary time they are then logged.
+        // Events generated:
+        // InactiveObject_Loaded, InactiveObject_Changed, InactiveObject_Revived
+        // SweepReadyObject_Loaded, SweepReadyObject_Changed, SweepReadyObject_Revived
         for (const eventProps of this.pendingEventsQueue) {
             const { usageType, state } = eventProps, propsToLog = __rest(eventProps, ["usageType", "state"]);
             /**
@@ -1094,19 +1080,19 @@ class GarbageCollector {
 }
 exports.GarbageCollector = GarbageCollector;
 /**
- * Gets the garbage collection data from the given snapshot tree. It contains GC state and tombstone state.
+ * Gets the base garbage collection state from the given snapshot tree. It contains GC state and tombstone state.
  * The GC state may be written into multiple blobs. Merge the GC state from all such blobs into one.
  */
 async function getGCDataFromSnapshot(gcSnapshotTree, readAndParseBlob) {
     let rootGCState = { gcNodes: {} };
     let tombstones;
     for (const key of Object.keys(gcSnapshotTree.blobs)) {
-        if (key === exports.gcTombstoneBlobKey) {
+        if (key === garbageCollectionConstants_1.gcTombstoneBlobKey) {
             tombstones = await readAndParseBlob(gcSnapshotTree.blobs[key]);
             continue;
         }
         // Skip blobs that do not start with the GC prefix.
-        if (!key.startsWith(exports.gcBlobPrefix)) {
+        if (!key.startsWith(garbageCollectionConstants_1.gcBlobPrefix)) {
             continue;
         }
         const blobId = gcSnapshotTree.blobs[key];