@fluidframework/container-runtime 2.0.0-internal.1.1.3 → 2.0.0-internal.1.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.trackGCStateKey = exports.disableSessionExpiryKey = exports.runSessionExpiryKey = exports.gcTestModeKey = exports.runSweepKey = exports.runGCKey = exports.gcBlobPrefix = exports.gcTreeKey = void 0;
+exports.GarbageCollector = exports.UnreferencedStateTracker = exports.UnreferencedState = exports.GCNodeType = exports.defaultSessionExpiryDurationMs = exports.defaultInactiveTimeoutMs = exports.oneDayMs = exports.disableSweepLogKey = exports.trackGCStateKey = exports.disableSessionExpiryKey = exports.runSessionExpiryKey = exports.gcTestModeKey = exports.runSweepKey = exports.runGCKey = exports.gcBlobPrefix = exports.gcTreeKey = 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,6 +25,7 @@ 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 gcSweepReadyUsageDetection_1 = require("./gcSweepReadyUsageDetection");
 const summaryFormat_1 = require("./summaryFormat");
 /** This is the current version of garbage collection. */
 const GCVersion = 1;
@@ -42,12 +43,12 @@ exports.gcTestModeKey = "Fluid.GarbageCollection.GCTestMode";
 const writeAtRootKey = "Fluid.GarbageCollection.WriteDataAtRoot";
 // Feature gate key to expire a session after a set period of time.
 exports.runSessionExpiryKey = "Fluid.GarbageCollection.RunSessionExpiry";
-// Feature gate key to disable expiring session after a set period of time, even if expiry value is present
+// Feature gate key to disable expiring session after a set period of time, even if expiry value is present.
 exports.disableSessionExpiryKey = "Fluid.GarbageCollection.DisableSessionExpiry";
 // 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.
-const disableSweepLogKey = "Fluid.GarbageCollection.DisableSweepLog";
+exports.disableSweepLogKey = "Fluid.GarbageCollection.DisableSweepLog";
 // One day in milliseconds.
 exports.oneDayMs = 1 * 24 * 60 * 60 * 1000;
 exports.defaultInactiveTimeoutMs = 7 * exports.oneDayMs; // 7 days
@@ -80,10 +81,10 @@ class UnreferencedStateTracker {
     constructor(unreferencedTimestampMs, 
     /** The time after which node transitions to Inactive state. */
     inactiveTimeoutMs, 
+    /** The current reference timestamp used to track how long this node has been unreferenced for. */
+    currentReferenceTimestampMs, 
     /** The time after which node transitions to SweepReady state; undefined if session expiry is disabled. */
-    sweepTimeoutMs, 
-    /** The current reference timestamp; undefined if no ops have ever been processed which can happen in tests. */
-    currentReferenceTimestampMs) {
+    sweepTimeoutMs) {
         this.unreferencedTimestampMs = unreferencedTimestampMs;
         this.inactiveTimeoutMs = inactiveTimeoutMs;
         this.sweepTimeoutMs = sweepTimeoutMs;
@@ -102,11 +103,7 @@ class UnreferencedStateTracker {
                 this.sweepTimer.restart(this.sweepTimeoutMs - this.inactiveTimeoutMs);
             }
         });
-        // If there is no current reference timestamp, can't track the node's unreferenced state at this time.
-        // This will happen later when updateTracking is called with a reference timestamp.
-        if (currentReferenceTimestampMs !== undefined) {
-            this.updateTracking(currentReferenceTimestampMs);
-        }
+        this.updateTracking(currentReferenceTimestampMs);
     }
     get state() {
         return this._state;
@@ -149,8 +146,12 @@ exports.UnreferencedStateTracker = UnreferencedStateTracker;
  * its state across summaries.
  *
  * Node - represented as nodeId, it's a node on the GC graph
+ *
  * Outbound Route - a path from one node to another node, think `nodeA` -\> `nodeB`
+ *
  * Graph - all nodes with their respective routes
+ *
+ * ```
  *             GC Graph
  *
  *               Node
@@ -160,6 +161,7 @@ exports.UnreferencedStateTracker = UnreferencedStateTracker;
  *         /                 \\
  *       Node               Node
  *  NodeId = "dds1"     NodeId = "dds2"
+ * ```
  */
 class GarbageCollector {
     constructor(createParams) {
@@ -170,10 +172,12 @@ class GarbageCollector {
         this._writeDataAtRoot = true;
         /**
          * Tells whether the initial GC state needs to be reset. This can happen under 2 conditions:
+         *
          * 1. The base snapshot contains GC state but GC is disabled. This will happen the first time GC is disabled after
-         *    it was enabled before. GC state needs to be removed from summary and all nodes should be marked referenced.
+         * it was enabled before. GC state needs to be removed from summary and all nodes should be marked referenced.
+         *
          * 2. The base snapshot does not have GC state but GC is enabled. This will happen the very first time GC runs on
-         *    a document and the first time GC is enabled after is was disabled before.
+         * a document and the first time GC is enabled after is was disabled before.
          *
          * Note that the state needs reset only for the very first time summary is generated by this client. After that, the
          * state will be up-to-date and this flag will be reset.
@@ -198,10 +202,12 @@ class GarbageCollector {
         this.gcOptions = createParams.gcOptions;
         this.getNodePackagePath = createParams.getNodePackagePath;
         this.getLastSummaryTimestampMs = createParams.getLastSummaryTimestampMs;
+        this.activeConnection = createParams.activeConnection;
         const baseSnapshot = createParams.baseSnapshot;
         const metadata = createParams.metadata;
         const readAndParseBlob = createParams.readAndParseBlob;
         this.mc = (0, telemetry_utils_1.loggerToMonitoringContext)(telemetry_utils_1.ChildLogger.create(createParams.baseLogger, "GarbageCollector", { all: { completedGCRuns: () => this.completedRuns } }));
+        this.sweepReadyUsageHandler = new gcSweepReadyUsageDetection_1.SweepReadyUsageDetectionHandler(createParams.getContainerDiagnosticId(), this.mc, this.runtime.closeFn);
         let prevSummaryGCVersion;
         /**
          * The following GC state is enabled during container creation and cannot be changed throughout its lifetime:
@@ -260,8 +266,11 @@ class GarbageCollector {
         this.latestSummaryGCVersion = prevSummaryGCVersion !== null && prevSummaryGCVersion !== void 0 ? prevSummaryGCVersion : this.currentGCVersion;
         /**
          * Whether GC should run or not. The following conditions have to be met to run sweep:
+         *
          * 1. GC should be enabled for this container.
+         *
          * 2. GC should not be disabled via disableGC GC option.
+         *
          * These conditions can be overridden via runGCKey feature flag.
          */
         this.shouldRunGC = (_d = this.mc.config.getBoolean(exports.runGCKey)) !== null && _d !== void 0 ? _d : (
@@ -271,10 +280,13 @@ class GarbageCollector {
             && !this.gcOptions.disableGC);
         /**
          * Whether sweep should run or not. The following conditions have to be met to run sweep:
+         *
          * 1. Overall GC or mark phase must be enabled (this.shouldRunGC).
+         *
          * 2. Sweep timeout should be available. Without this, we wouldn't know when an object should be deleted.
+         *
          * 3. Sweep should be enabled for this container (this.sweepEnabled). This can be overridden via runSweep
-         *    feature flag.
+         * feature flag.
          */
         this.shouldRunSweep = false; // disable while TEMPORARY measure hardcoding snapshotCacheExpiryMs is here
         // this.shouldRunGC
@@ -304,52 +316,59 @@ class GarbageCollector {
             if (baseSnapshot === undefined) {
                 return undefined;
             }
-            // For newer documents, GC data should be present in the GC tree in the root of the snapshot.
-            const gcSnapshotTree = baseSnapshot.trees[exports.gcTreeKey];
-            if (gcSnapshotTree !== undefined) {
-                // If the GC tree is written at root, we should also do the same.
-                this._writeDataAtRoot = true;
-                const baseGCState = await getGCStateFromSnapshot(gcSnapshotTree, readAndParseBlob);
-                if (this.trackGCState) {
-                    this.latestSerializedSummaryState = JSON.stringify(generateSortedGCState(baseGCState));
-                }
-                return baseGCState;
-            }
-            // back-compat - Older documents will have the GC blobs in each data store's summary tree. Get them and
-            // consolidate into IGarbageCollectionState format.
-            // Add a node for the root node that is not present in older snapshot format.
-            const gcState = { gcNodes: { "/": { outboundRoutes: [] } } };
-            const dataStoreSnapshotTree = (0, dataStores_1.getSummaryForDatastores)(baseSnapshot, metadata);
-            (0, common_utils_1.assert)(dataStoreSnapshotTree !== undefined, 0x2a8 /* "Expected data store snapshot tree in base snapshot" */);
-            for (const [dsId, dsSnapshotTree] of Object.entries(dataStoreSnapshotTree.trees)) {
-                const blobId = dsSnapshotTree.blobs[runtime_definitions_1.gcBlobKey];
-                if (blobId === undefined) {
-                    continue;
-                }
-                const gcSummaryDetails = await readAndParseBlob(blobId);
-                // If there are no nodes for this data store, skip it.
-                if (((_a = gcSummaryDetails.gcData) === null || _a === void 0 ? void 0 : _a.gcNodes) === undefined) {
-                    continue;
-                }
-                const dsRootId = `/${dsId}`;
-                // Since we used to write GC data at data store level, we won't have an entry for the root ("/").
-                // Construct that entry by adding root data store ids to its outbound routes.
-                const initialSnapshotDetails = await readAndParseBlob(dsSnapshotTree.blobs[summaryFormat_1.dataStoreAttributesBlobName]);
-                if (initialSnapshotDetails.isRootDataStore) {
-                    gcState.gcNodes["/"].outboundRoutes.push(dsRootId);
+            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];
+                if (gcSnapshotTree !== undefined) {
+                    // If the GC tree is written at root, we should also do the same.
+                    this._writeDataAtRoot = true;
+                    const baseGCState = await getGCStateFromSnapshot(gcSnapshotTree, readAndParseBlob);
+                    if (this.trackGCState) {
+                        this.latestSerializedSummaryState = JSON.stringify(generateSortedGCState(baseGCState));
+                    }
+                    return baseGCState;
                 }
-                for (const [id, outboundRoutes] of Object.entries(gcSummaryDetails.gcData.gcNodes)) {
-                    // Prefix the data store id to the GC node ids to make them relative to the root from being
-                    // relative to the data store. Similar to how its done in DataStore::getGCData.
-                    const rootId = id === "/" ? dsRootId : `${dsRootId}${id}`;
-                    gcState.gcNodes[rootId] = { outboundRoutes: Array.from(outboundRoutes) };
+                // back-compat - Older documents will have the GC blobs in each data store's summary tree. Get them and
+                // consolidate into IGarbageCollectionState format.
+                // Add a node for the root node that is not present in older snapshot format.
+                const gcState = { gcNodes: { "/": { outboundRoutes: [] } } };
+                const dataStoreSnapshotTree = (0, dataStores_1.getSummaryForDatastores)(baseSnapshot, metadata);
+                (0, common_utils_1.assert)(dataStoreSnapshotTree !== undefined, 0x2a8 /* "Expected data store snapshot tree in base snapshot" */);
+                for (const [dsId, dsSnapshotTree] of Object.entries(dataStoreSnapshotTree.trees)) {
+                    const blobId = dsSnapshotTree.blobs[runtime_definitions_1.gcBlobKey];
+                    if (blobId === undefined) {
+                        continue;
+                    }
+                    const gcSummaryDetails = await readAndParseBlob(blobId);
+                    // If there are no nodes for this data store, skip it.
+                    if (((_a = gcSummaryDetails.gcData) === null || _a === void 0 ? void 0 : _a.gcNodes) === undefined) {
+                        continue;
+                    }
+                    const dsRootId = `/${dsId}`;
+                    // Since we used to write GC data at data store level, we won't have an entry for the root ("/").
+                    // Construct that entry by adding root data store ids to its outbound routes.
+                    const initialSnapshotDetails = await readAndParseBlob(dsSnapshotTree.blobs[summaryFormat_1.dataStoreAttributesBlobName]);
+                    if (initialSnapshotDetails.isRootDataStore) {
+                        gcState.gcNodes["/"].outboundRoutes.push(dsRootId);
+                    }
+                    for (const [id, outboundRoutes] of Object.entries(gcSummaryDetails.gcData.gcNodes)) {
+                        // Prefix the data store id to the GC node ids to make them relative to the root from being
+                        // relative to the data store. Similar to how its done in DataStore::getGCData.
+                        const rootId = id === "/" ? dsRootId : `${dsRootId}${id}`;
+                        gcState.gcNodes[rootId] = { outboundRoutes: Array.from(outboundRoutes) };
+                    }
+                    (0, common_utils_1.assert)(gcState.gcNodes[dsRootId] !== undefined, 0x2a9 /* GC nodes for data store not in GC blob */);
+                    gcState.gcNodes[dsRootId].unreferencedTimestampMs = gcSummaryDetails.unrefTimestamp;
                 }
-                (0, common_utils_1.assert)(gcState.gcNodes[dsRootId] !== undefined, 0x2a9 /* GC nodes for data store not in GC blob */);
-                gcState.gcNodes[dsRootId].unreferencedTimestampMs = gcSummaryDetails.unrefTimestamp;
+                // 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;
+            }
+            catch (error) {
+                const dpe = container_utils_1.DataProcessingError.wrapIfUnrecognized(error, "FailedToInitializeGC");
+                dpe.addTelemetryProperties({ gcConfigs: JSON.stringify(this.configs) });
+                throw dpe;
             }
-            // If there is only one node (root node just added above), either GC is disabled or we are loading from the
-            // very first summary generated by detached container. In both cases, GC was not run - return undefined.
-            return Object.keys(gcState.gcNodes).length === 1 ? undefined : gcState;
         });
         /**
          * Set up the initializer which initializes the base GC state from the base snapshot. Note that the reference
@@ -358,14 +377,36 @@ class GarbageCollector {
          */
         this.initializeBaseStateP = 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
+             * how long objects have been unreferenced and if they can be deleted.
+             *
+             * Note that the only scenario where there is no reference timestamp is when no ops have ever been processed
+             * for this container and it is in read mode. In this scenario, there is no point in running GC anyway
+             * because references in the container do not change without any ops, i.e., there is nothing to collect.
+             */
+            if (currentReferenceTimestampMs === undefined) {
+                // Log an event so we can evaluate how often we run into this scenario.
+                this.mc.logger.sendErrorEvent({
+                    eventName: "GarbageCollectorInitializedWithoutTimestamp",
+                    gcConfigs: JSON.stringify(this.configs),
+                });
+                return;
+            }
             const baseState = await baseSummaryStateP;
+            /**
+             * The base 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.
+             */
             if (baseState === undefined) {
                 return;
             }
             const gcNodes = {};
             for (const [nodeId, nodeData] of Object.entries(baseState.gcNodes)) {
                 if (nodeData.unreferencedTimestampMs !== undefined) {
-                    this.unreferencedNodesState.set(nodeId, new UnreferencedStateTracker(nodeData.unreferencedTimestampMs, this.inactiveTimeoutMs, this.sweepTimeoutMs, currentReferenceTimestampMs));
+                    this.unreferencedNodesState.set(nodeId, new UnreferencedStateTracker(nodeData.unreferencedTimestampMs, this.inactiveTimeoutMs, currentReferenceTimestampMs, this.sweepTimeoutMs));
                 }
                 gcNodes[nodeId] = Array.from(nodeData.outboundRoutes);
             }
@@ -401,19 +442,10 @@ class GarbageCollector {
         });
         // Log all the GC options and the state determined by the garbage collector. This is interesting only for the
         // summarizer client since it is the only one that runs GC. It also helps keep the telemetry less noisy.
-        const gcConfigProps = JSON.stringify(Object.assign({ gcEnabled: this.gcEnabled, sweepEnabled: this.sweepEnabled, runGC: this.shouldRunGC, runSweep: this.shouldRunSweep, writeAtRoot: this._writeDataAtRoot, testMode: this.testMode, sessionExpiry: this.sessionExpiryTimeoutMs, inactiveTimeout: this.inactiveTimeoutMs, existing: createParams.existing, trackGCState: this.trackGCState }, this.gcOptions));
         if (this.isSummarizerClient) {
             this.mc.logger.sendTelemetryEvent({
                 eventName: "GarbageCollectorLoaded",
-                gcConfigs: gcConfigProps,
-            });
-        }
-        // Initialize the base state that is used to detect when inactive objects are used.
-        if (this.shouldRunGC) {
-            this.initializeBaseStateP.catch((error) => {
-                const dpe = container_utils_1.DataProcessingError.wrapIfUnrecognized(error, "FailedToInitializeGC");
-                dpe.addTelemetryProperties({ gcConfigs: gcConfigProps });
-                throw dpe;
+                gcConfigs: JSON.stringify(this.configs),
             });
         }
     }
@@ -422,11 +454,16 @@ class GarbageCollector {
     }
     /**
      * Tells whether the GC state needs to be reset in the next summary. We need to do this if:
+     *
      * 1. GC was enabled and is now disabled. The GC state needs to be removed and everything becomes referenced.
+     *
      * 2. GC was disabled and is now enabled. The GC state needs to be regenerated and added to summary.
+     *
      * 3. The GC version in the latest summary is different from the current GC version. This can happen if:
-     *    3.1. The summary this client loaded with has data from a different GC version.
-     *    3.2. This client's latest summary was updated from a snapshot that has a different GC version.
+     *
+     * 3.1. The summary this client loaded with has data from a different GC version.
+     *
+     * 3.2. This client's latest summary was updated from a snapshot that has a different GC version.
      */
     get summaryStateNeedsReset() {
         return this.initialStateNeedsReset ||
@@ -435,21 +472,63 @@ class GarbageCollector {
     get writeDataAtRoot() {
         return this._writeDataAtRoot;
     }
+    /** Returns a list of all the configurations for garbage collection. */
+    get configs() {
+        return Object.assign({ gcEnabled: this.gcEnabled, sweepEnabled: this.sweepEnabled, runGC: this.shouldRunGC, runSweep: this.shouldRunSweep, writeAtRoot: this._writeDataAtRoot, testMode: this.testMode, sessionExpiry: this.sessionExpiryTimeoutMs, inactiveTimeout: this.inactiveTimeoutMs, trackGCState: this.trackGCState }, this.gcOptions);
+    }
+    /**
+     * 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.
+     * @param connected - Whether the runtime connected / disconnected.
+     * @param clientId - The clientId of this runtime.
+     */
+    setConnectionState(connected, clientId) {
+        /**
+         * For non-summarizer clients, initialize the base state when the container becomes active, i.e., it transitions
+         * to "write" mode. This will ensure that the container's own join op is processed and there is a recent
+         * reference timestamp that will be used to update the state of unreferenced nodes. Also, all trailing ops which
+         * could affect the GC state will have been processed.
+         *
+         * Ideally, this initialization should only be done for summarizer client. However, we are currently rolling out
+         * sweep in phases and we want to track when inactive and sweep ready objects are used in any client.
+         */
+        if (this.activeConnection() && !this.isSummarizerClient && this.shouldRunGC) {
+            this.initializeBaseStateP.catch((error) => { });
+        }
+    }
     /**
      * Runs garbage collection and updates the reference / used state of the nodes in the container.
-     * @returns the number of data stores that have been marked as unreferenced.
+     * @returns stats of the GC run or undefined if GC did not run.
      */
     async collectGarbage(options) {
-        const { fullGC = this.gcOptions.runFullGC === true || this.summaryStateNeedsReset, } = options;
+        var _a;
+        const fullGC = (_a = options.fullGC) !== null && _a !== void 0 ? _a : (this.gcOptions.runFullGC === true || this.summaryStateNeedsReset);
         const logger = options.logger
             ? telemetry_utils_1.ChildLogger.create(options.logger, undefined, { all: { completedGCRuns: () => this.completedRuns } })
             : this.mc.logger;
+        /**
+         * If there is no current reference timestamp, skip running GC. We need the current timestamp to track
+         * how long objects have been unreferenced and if they should be deleted.
+         *
+         * Note that the only scenario where GC is called and there is no reference timestamp is when no ops have ever
+         * been processed for this container and it is in read mode. In this scenario, there is no point in running GC
+         * anyway because references in the container do not change without any ops, i.e., there is nothing to collect.
+         */
+        const currentReferenceTimestampMs = this.runtime.getCurrentReferenceTimestampMs();
+        if (currentReferenceTimestampMs === undefined) {
+            // Log an event so we can evaluate how often we run into this scenario.
+            logger.sendErrorEvent({
+                eventName: "CollectGarbageCalledWithoutTimestamp",
+                gcConfigs: JSON.stringify(this.configs),
+            });
+            return undefined;
+        }
         return telemetry_utils_1.PerformanceEvent.timedExecAsync(logger, { eventName: "GarbageCollection" }, async (event) => {
             await this.runPreGCSteps();
             // Get the runtime's GC data and run GC on the reference graph in it.
             const gcData = await this.runtime.getGCData(fullGC);
             const gcResult = (0, garbage_collector_1.runGarbageCollection)(gcData.gcNodes, ["/"]);
-            const gcStats = await this.runPostGCSteps(gcData, gcResult, logger);
+            const gcStats = await this.runPostGCSteps(gcData, gcResult, logger, currentReferenceTimestampMs);
             event.end(Object.assign({}, gcStats));
             this.completedRuns++;
             return gcStats;
@@ -461,7 +540,7 @@ class GarbageCollector {
         // Let the runtime update its pending state before GC runs.
         await this.runtime.updateStateBeforeGC();
     }
-    async runPostGCSteps(gcData, gcResult, logger) {
+    async runPostGCSteps(gcData, gcResult, logger, currentReferenceTimestampMs) {
         // Generate statistics from the current run. This is done before updating the current state because it
         // generates some of its data based on previous state of the system.
         const gcStats = this.generateStats(gcResult);
@@ -469,7 +548,6 @@ class GarbageCollector {
         // the current run. We need to identify than and update their unreferenced state if needed.
         this.updateStateSinceLastRun(gcData, logger);
         // Update the current state and update the runtime of all routes or ids that used as per the GC run.
-        const currentReferenceTimestampMs = this.runtime.getCurrentReferenceTimestampMs();
         this.updateCurrentState(gcData, gcResult, currentReferenceTimestampMs);
         this.runtime.updateUsedRoutes(gcResult.referencedNodeIds, currentReferenceTimestampMs);
         // Log events for objects that are ready to be deleted by sweep. When we have sweep enabled, we will
@@ -649,14 +727,6 @@ class GarbageCollector {
                 this.unreferencedNodesState.delete(nodeId);
             }
         }
-        /**
-         * If there is no current reference time, skip tracking when a node becomes unreferenced. This would happen
-         * if no ops have been processed ever and we still try to run GC. If so, there is nothing interesting to track
-         * anyway.
-         */
-        if (currentReferenceTimestampMs === undefined) {
-            return;
-        }
         /**
          * If a node became unreferenced in this run, start tracking it.
          * If a node was already unreferenced, update its tracking information. Since the current reference time is
@@ -665,7 +735,7 @@ class GarbageCollector {
         for (const nodeId of gcResult.deletedNodeIds) {
             const nodeStateTracker = this.unreferencedNodesState.get(nodeId);
             if (nodeStateTracker === undefined) {
-                this.unreferencedNodesState.set(nodeId, new UnreferencedStateTracker(currentReferenceTimestampMs, this.inactiveTimeoutMs, this.sweepTimeoutMs, currentReferenceTimestampMs));
+                this.unreferencedNodesState.set(nodeId, new UnreferencedStateTracker(currentReferenceTimestampMs, this.inactiveTimeoutMs, currentReferenceTimestampMs, this.sweepTimeoutMs));
             }
             else {
                 nodeStateTracker.updateTracking(currentReferenceTimestampMs);
@@ -708,14 +778,19 @@ class GarbageCollector {
          * run, and then add the references since last run.
          *
          * Note on why we need to combine the data from previous run, current run and all references in between -
+         *
          * 1. We need data from last run because some of its references may have been deleted since then. If those
-         *    references added new outbound references before getting deleted, we need to detect them.
+         * references added new outbound references before getting deleted, we need to detect them.
+         *
          * 2. We need new outbound references since last run because some of them may have been deleted later. If those
-         *    references added new outbound references before getting deleted, we need to detect them.
+         * references added new outbound references before getting deleted, we need to detect them.
+         *
          * 3. We need data from the current run because currently we may not detect when DDSes are referenced:
-         *    - We don't require DDSes handles to be stored in a referenced DDS. For this, we need GC at DDS level
-         *      which is tracked by https://github.com/microsoft/FluidFramework/issues/8470.
-         *    - A new data store may have "root" DDSes already created and we don't detect them today.
+         *
+         * - We don't require DDSes handles to be stored in a referenced DDS. For this, we need GC at DDS level
+         * which is tracked by https://github.com/microsoft/FluidFramework/issues/8470.
+         *
+         * - A new data store may have "root" DDSes already created and we don't detect them today.
          */
         const gcDataSuperSet = (0, garbage_collector_1.concatGarbageCollectionData)(this.previousGCDataFromLastRun, currentGCData);
         this.newReferencesSinceLastRun.forEach((outboundRoutes, sourceNodeId) => {
@@ -843,9 +918,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(disableSweepLogKey) === true
-            || currentReferenceTimestampMs === undefined
-            || this.sweepTimeoutMs === undefined) {
+        if (this.mc.config.getBoolean(exports.disableSweepLogKey) === true || this.sweepTimeoutMs === undefined) {
             return;
         }
         this.unreferencedNodesState.forEach((nodeStateTracker, nodeId) => {
@@ -883,11 +956,6 @@ class GarbageCollector {
         if (currentReferenceTimestampMs === undefined || nodeStateTracker.state === exports.UnreferencedState.Active) {
             return;
         }
-        // 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).
-        if (!this.isSummarizerClient && usageType !== "Loaded") {
-            return;
-        }
         // We only care about data stores and attachment blobs for this telemetry since GC only marks these objects
         // as unreferenced. Also, if an inactive DDS is used, the corresponding data store store will also be used.
         const nodeType = this.runtime.getNodeType(nodeId);
@@ -921,7 +989,17 @@ class GarbageCollector {
             this.pendingEventsQueue.push(Object.assign(Object.assign({}, propsToLog), { usageType, state }));
         }
         else {
-            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 }));
+            // 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)
+            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 }));
+            }
+            // 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
+            // and errors will arise elsewhere in the runtime
+            if (state === exports.UnreferencedState.SweepReady) {
+                this.sweepReadyUsageHandler.usageDetectedInInteractiveClient(Object.assign(Object.assign({}, propsToLog), { usageType }));
+            }
         }
     }
     async logUnreferencedEvents(logger) {