@fluidframework/container-runtime 1.2.7 → 2.0.0-dev.1.3.0.96595

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.GCNodeType = exports.defaultSessionExpiryDurationMs = exports.oneDayMs = exports.trackGCStateKey = exports.disableSessionExpiryKey = exports.runSessionExpiryKey = 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;
@@ -33,24 +34,24 @@ exports.gcTreeKey = "gc";
 // They prefix for GC blobs in the GC tree in summary.
 exports.gcBlobPrefix = "__gc";
 // Feature gate key to turn GC on / off.
-const runGCKey = "Fluid.GarbageCollection.RunGC";
+exports.runGCKey = "Fluid.GarbageCollection.RunGC";
 // Feature gate key to turn GC sweep on / off.
-const runSweepKey = "Fluid.GarbageCollection.RunSweep";
+exports.runSweepKey = "Fluid.GarbageCollection.RunSweep";
 // Feature gate key to turn GC test mode on / off.
-const gcTestModeKey = "Fluid.GarbageCollection.GCTestMode";
+exports.gcTestModeKey = "Fluid.GarbageCollection.GCTestMode";
 // Feature gate key to write GC data at the root of the summary tree.
 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;
-const defaultInactiveTimeoutMs = 7 * exports.oneDayMs; // 7 days
+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 = {
@@ -64,7 +65,7 @@ exports.GCNodeType = {
     Other: "Other",
 };
 /** The state of node that is unreferenced. */
-const UnreferencedState = {
+exports.UnreferencedState = {
     /** The node is active, i.e., it can become referenced again. */
     Active: "Active",
     /** The node is inactive, i.e., it should not become referenced. */
@@ -80,19 +81,29 @@ 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;
-        this._state = UnreferencedState.Active;
-        // If there is no current reference timestamp, don't track the node's unreferenced state. This will happen
-        // later when updateTracking is called with a reference timestamp.
-        if (currentReferenceTimestampMs !== undefined) {
-            this.updateTracking(currentReferenceTimestampMs);
+        this._state = exports.UnreferencedState.Active;
+        if (this.sweepTimeoutMs !== undefined) {
+            (0, common_utils_1.assert)(this.inactiveTimeoutMs <= this.sweepTimeoutMs, 0x3b0 /* inactive timeout must not be greater than the sweep timeout */);
         }
+        this.sweepTimer = new TimerWithNoDefaultTimeout(() => {
+            this._state = exports.UnreferencedState.SweepReady;
+            (0, common_utils_1.assert)(!this.inactiveTimer.hasTimer, 0x3b1 /* inactiveTimer still running after sweepTimer fired! */);
+        });
+        this.inactiveTimer = new TimerWithNoDefaultTimeout(() => {
+            this._state = exports.UnreferencedState.Inactive;
+            // After the node becomes inactive, start the sweep timer after which the node will be ready for sweep.
+            if (this.sweepTimeoutMs !== undefined) {
+                this.sweepTimer.restart(this.sweepTimeoutMs - this.inactiveTimeoutMs);
+            }
+        });
+        this.updateTracking(currentReferenceTimestampMs);
     }
     get state() {
         return this._state;
@@ -102,54 +113,45 @@ class UnreferencedStateTracker {
         const unreferencedDurationMs = currentReferenceTimestampMs - this.unreferencedTimestampMs;
         // If the node has been unreferenced for sweep timeout amount of time, update the state to SweepReady.
         if (this.sweepTimeoutMs !== undefined && unreferencedDurationMs >= this.sweepTimeoutMs) {
-            this._state = UnreferencedState.SweepReady;
+            this._state = exports.UnreferencedState.SweepReady;
             this.clearTimers();
             return;
         }
         // If the node has been unreferenced for inactive timeoutMs amount of time, update the state to inactive.
         // Also, start a timer for the sweep timeout.
         if (unreferencedDurationMs >= this.inactiveTimeoutMs) {
-            this._state = UnreferencedState.Inactive;
-            this.clearTimers();
+            this._state = exports.UnreferencedState.Inactive;
+            this.inactiveTimer.clear();
             if (this.sweepTimeoutMs !== undefined) {
-                setLongTimeout(this.sweepTimeoutMs - unreferencedDurationMs, () => { this._state = UnreferencedState.SweepReady; }, (timer) => { this.sweepTimer = timer; });
+                this.sweepTimer.restart(this.sweepTimeoutMs - unreferencedDurationMs);
             }
             return;
         }
-        // The node is still active. Start the inactive timer for the remaining duration.
-        const remainingDurationMs = this.inactiveTimeoutMs - unreferencedDurationMs;
-        if (this.inactiveTimer === undefined) {
-            const inactiveTimeoutHandler = () => {
-                this._state = UnreferencedState.Inactive;
-                // After the node becomes inactive, start the sweep timer after which the node will be ready for sweep.
-                if (this.sweepTimeoutMs !== undefined) {
-                    setLongTimeout(this.sweepTimeoutMs - this.inactiveTimeoutMs, () => { this._state = UnreferencedState.SweepReady; }, (timer) => { this.sweepTimer = timer; });
-                }
-            };
-            this.inactiveTimer = new common_utils_1.Timer(remainingDurationMs, () => inactiveTimeoutHandler());
-        }
-        this.inactiveTimer.restart(remainingDurationMs);
+        // The node is still active. Ensure the inactive timer is running with the proper remaining duration.
+        this.inactiveTimer.restart(this.inactiveTimeoutMs - unreferencedDurationMs);
     }
     clearTimers() {
-        var _a;
-        (_a = this.inactiveTimer) === null || _a === void 0 ? void 0 : _a.clear();
-        if (this.sweepTimer !== undefined) {
-            clearTimeout(this.sweepTimer);
-        }
+        this.inactiveTimer.clear();
+        this.sweepTimer.clear();
     }
     /** Stop tracking this node. Reset the unreferenced timers and state, if any. */
     stopTracking() {
         this.clearTimers();
-        this._state = UnreferencedState.Active;
+        this._state = exports.UnreferencedState.Active;
     }
 }
+exports.UnreferencedStateTracker = UnreferencedStateTracker;
 /**
  * The garbage collector for the container runtime. It consolidates the garbage collection functionality and maintains
  * 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
@@ -159,20 +161,23 @@ class UnreferencedStateTracker {
  *         /                 \\
  *       Node               Node
  *  NodeId = "dds1"     NodeId = "dds2"
+ * ```
  */
 class GarbageCollector {
     constructor(createParams) {
-        var _a, _b, _c, _d, _e, _f, _g;
+        var _a, _b, _c, _d, _e, _f, _g, _h;
         /**
          * Tells whether the GC data should be written to the root of the summary tree.
          */
         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.
@@ -197,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:
@@ -228,9 +235,9 @@ class GarbageCollector {
             this.gcEnabled = this.gcOptions.gcAllowed !== false;
             // The sweep phase has to be explicitly enabled by setting the sweepAllowed flag in GC options to true.
             this.sweepEnabled = this.gcOptions.sweepAllowed === true;
-            // Set the Session Expiry only if the flag is enabled or the test option is set.
+            // 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 = exports.defaultSessionExpiryDurationMs;
+                this.sessionExpiryTimeoutMs = (_b = this.gcOptions.sessionExpiryTimeoutMs) !== null && _b !== void 0 ? _b : exports.defaultSessionExpiryDurationMs;
             }
         }
         // If session expiry is enabled, we need to close the container when the session expiry timeout expires.
@@ -238,15 +245,20 @@ class GarbageCollector {
             // If Test Override config is set, override Session Expiry timeout.
             const overrideSessionExpiryTimeoutMs = this.mc.config.getNumber("Fluid.GarbageCollection.TestOverride.SessionExpiryMs");
             const timeoutMs = overrideSessionExpiryTimeoutMs !== null && overrideSessionExpiryTimeoutMs !== void 0 ? overrideSessionExpiryTimeoutMs : this.sessionExpiryTimeoutMs;
-            setLongTimeout(timeoutMs, () => { this.runtime.closeFn(new container_utils_1.ClientSessionExpiredError(`Client session expired.`, timeoutMs)); }, (timer) => { this.sessionExpiryTimer = timer; });
+            this.sessionExpiryTimer = new common_utils_1.Timer(timeoutMs, () => { this.runtime.closeFn(new container_utils_1.ClientSessionExpiredError(`Client session expired.`, timeoutMs)); });
+            this.sessionExpiryTimer.start();
+            // TEMPORARY: Hardcode a default of 2 days which is the value used in the ODSP driver.
+            // This unblocks the Sweep Log (see logSweepEvents function).
+            // This will be removed before sweep is fully implemented.
+            const snapshotCacheExpiryMs = (_c = createParams.snapshotCacheExpiryMs) !== null && _c !== void 0 ? _c : 2 * 24 * 60 * 60 * 1000;
             /**
              * Sweep timeout is the time after which unreferenced content can be swept.
              * Sweep timeout = session expiry timeout + snapshot cache expiry timeout + one day buffer. The buffer is
              * added to account for any clock skew. We use server timestamps throughout so the skew should be minimal
              * but make it one day to be safe.
              */
-            if (createParams.snapshotCacheExpiryMs !== undefined) {
-                this.sweepTimeoutMs = this.sessionExpiryTimeoutMs + createParams.snapshotCacheExpiryMs + exports.oneDayMs;
+            if (snapshotCacheExpiryMs !== undefined) {
+                this.sweepTimeoutMs = this.sessionExpiryTimeoutMs + snapshotCacheExpiryMs + exports.oneDayMs;
             }
         }
         // For existing document, the latest summary is the one that we loaded from. So, use its GC version as the
@@ -254,36 +266,43 @@ 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 = (_b = this.mc.config.getBoolean(runGCKey)) !== null && _b !== void 0 ? _b : (
+        this.shouldRunGC = (_d = this.mc.config.getBoolean(exports.runGCKey)) !== null && _d !== void 0 ? _d : (
         // GC must be enabled for the document.
         this.gcEnabled
             // GC must not be disabled via GC options.
             && !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 = this.shouldRunGC
-            && this.sweepTimeoutMs !== undefined
-            && ((_c = this.mc.config.getBoolean(runSweepKey)) !== null && _c !== void 0 ? _c : this.sweepEnabled);
+        this.shouldRunSweep = false; // disable while TEMPORARY measure hardcoding snapshotCacheExpiryMs is here
+        // this.shouldRunGC
+        // && this.sweepTimeoutMs !== undefined
+        // && (this.mc.config.getBoolean(runSweepKey) ?? this.sweepEnabled);
         this.trackGCState = this.mc.config.getBoolean(exports.trackGCStateKey) === true;
         // Override inactive timeout if test config or gc options to override it is set.
-        this.inactiveTimeoutMs = (_e = (_d = this.mc.config.getNumber("Fluid.GarbageCollection.TestOverride.InactiveTimeoutMs")) !== null && _d !== void 0 ? _d : this.gcOptions.inactiveTimeoutMs) !== null && _e !== void 0 ? _e : defaultInactiveTimeoutMs;
+        this.inactiveTimeoutMs = (_f = (_e = this.mc.config.getNumber("Fluid.GarbageCollection.TestOverride.InactiveTimeoutMs")) !== null && _e !== void 0 ? _e : this.gcOptions.inactiveTimeoutMs) !== null && _f !== void 0 ? _f : exports.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 greated than the sweep timeout");
+            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 = (_f = this.mc.config.getBoolean(gcTestModeKey)) !== null && _f !== void 0 ? _f : this.gcOptions.runGCInTestMode === true;
+        this.testMode = (_g = this.mc.config.getBoolean(exports.gcTestModeKey)) !== null && _g !== void 0 ? _g : this.gcOptions.runGCInTestMode === true;
         // GC state is written into root of the summary tree by default. Can be overridden via feature flag for now.
-        this._writeDataAtRoot = (_g = this.mc.config.getBoolean(writeAtRootKey)) !== null && _g !== void 0 ? _g : true;
+        this._writeDataAtRoot = (_h = this.mc.config.getBoolean(writeAtRootKey)) !== null && _h !== void 0 ? _h : true;
         if (this._writeDataAtRoot) {
             // 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.
@@ -297,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
@@ -351,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);
             }
@@ -380,7 +428,7 @@ class GarbageCollector {
             // each node in the summary.
             const usedRoutes = (0, garbage_collector_1.runGarbageCollection)(gcNodes, ["/"]).referencedNodeIds;
             const baseGCDetailsMap = (0, garbage_collector_1.unpackChildNodesGCDetails)({ gcData: { gcNodes }, usedRoutes });
-            // Currently, the nodes may write the GC data. So, we need to update it's base GC details with the
+            // 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)) {
                 if (nodeData.unreferencedTimestampMs !== undefined) {
@@ -394,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),
             });
         }
     }
@@ -415,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 ||
@@ -428,22 +472,64 @@ 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);
-            event.end(Object.assign({}, gcStats));
+            const gcStats = await this.runPostGCSteps(gcData, gcResult, logger, currentReferenceTimestampMs);
+            event.end(Object.assign(Object.assign({}, gcStats), { timestamp: currentReferenceTimestampMs }));
             this.completedRuns++;
             return gcStats;
         }, { end: true, cancel: "error" });
@@ -454,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);
@@ -462,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
@@ -591,7 +676,7 @@ class GarbageCollector {
             return;
         }
         const nodeStateTracker = this.unreferencedNodesState.get(nodePath);
-        if (nodeStateTracker && nodeStateTracker.state !== UnreferencedState.Active) {
+        if (nodeStateTracker && nodeStateTracker.state !== exports.UnreferencedState.Active) {
             this.inactiveNodeUsed(reason, nodePath, nodeStateTracker, undefined /* fromNodeId */, packagePath, timestampMs, requestHeaders);
         }
     }
@@ -611,15 +696,14 @@ class GarbageCollector {
         outboundRoutes.push(toNodePath);
         this.newReferencesSinceLastRun.set(fromNodePath, outboundRoutes);
         const nodeStateTracker = this.unreferencedNodesState.get(toNodePath);
-        if (nodeStateTracker && nodeStateTracker.state !== UnreferencedState.Active) {
+        if (nodeStateTracker && nodeStateTracker.state !== exports.UnreferencedState.Active) {
             this.inactiveNodeUsed("Revived", toNodePath, nodeStateTracker, fromNodePath);
         }
     }
     dispose() {
-        if (this.sessionExpiryTimer !== undefined) {
-            clearTimeout(this.sessionExpiryTimer);
-            this.sessionExpiryTimer = undefined;
-        }
+        var _a;
+        (_a = this.sessionExpiryTimer) === null || _a === void 0 ? void 0 : _a.clear();
+        this.sessionExpiryTimer = undefined;
     }
     /**
      * Updates the state of the system as per the current GC run. It does the following:
@@ -643,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
@@ -659,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);
@@ -702,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) => {
@@ -837,13 +918,11 @@ 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) => {
-            if (nodeStateTracker.state !== UnreferencedState.SweepReady) {
+            if (nodeStateTracker.state !== exports.UnreferencedState.SweepReady) {
                 return;
             }
             const nodeType = this.runtime.getNodeType(nodeId);
@@ -874,12 +953,7 @@ class GarbageCollector {
         // If there is no reference timestamp to work with, no ops have been processed after creation. If so, skip
         // logging as nothing interesting would have happened worth logging.
         // If the node is active, skip logging.
-        if (currentReferenceTimestampMs === undefined || nodeStateTracker.state === 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") {
+        if (currentReferenceTimestampMs === undefined || nodeStateTracker.state === exports.UnreferencedState.Active) {
             return;
         }
         // We only care about data stores and attachment blobs for this telemetry since GC only marks these objects
@@ -899,7 +973,7 @@ class GarbageCollector {
             type: nodeType,
             unrefTime: nodeStateTracker.unreferencedTimestampMs,
             age: currentReferenceTimestampMs - nodeStateTracker.unreferencedTimestampMs,
-            timeout: nodeStateTracker.state === UnreferencedState.Inactive
+            timeout: nodeStateTracker.state === exports.UnreferencedState.Inactive
                 ? this.inactiveTimeoutMs
                 : this.sweepTimeoutMs,
             completedGCRuns: this.completedRuns,
@@ -915,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) {
@@ -928,7 +1012,7 @@ class GarbageCollector {
              * revived and a Revived event will be logged for it.
              */
             const nodeStateTracker = this.unreferencedNodesState.get(eventProps.id);
-            const active = nodeStateTracker === undefined || nodeStateTracker.state === UnreferencedState.Active;
+            const active = nodeStateTracker === undefined || nodeStateTracker.state === exports.UnreferencedState.Active;
             if ((usageType === "Revived") === active) {
                 const pkg = await this.getNodePackagePath(eventProps.id);
                 const fromPkg = eventProps.fromId ? await this.getNodePackagePath(eventProps.fromId) : undefined;
@@ -971,23 +1055,18 @@ function generateSortedGCState(gcState) {
     }
     return sortedGCState;
 }
-/**
- * setLongTimeout is used for timeouts longer than setTimeout's ~24.8 day max
- * @param timeoutMs - the total time the timeout needs to last in ms
- * @param timeoutFn - the function to execute when the timer ends
- * @param setTimerFn - the function used to update your timer variable
- */
-function setLongTimeout(timeoutMs, timeoutFn, setTimerFn) {
-    // The setTimeout max is 24.8 days before looping occurs.
-    const maxTimeout = 2147483647;
-    let timer;
-    if (timeoutMs > maxTimeout) {
-        const newTimeoutMs = timeoutMs - maxTimeout;
-        timer = setTimeout(() => setLongTimeout(newTimeoutMs, timeoutFn, setTimerFn), maxTimeout);
-    }
-    else {
-        timer = setTimeout(() => timeoutFn(), timeoutMs);
-    }
-    setTimerFn(timer);
+/** A wrapper around common-utils Timer that requires the timeout when calling start/restart */
+class TimerWithNoDefaultTimeout extends common_utils_1.Timer {
+    constructor(callback) {
+        // The default timeout/handlers will never be used since start/restart pass overrides below
+        super(0, () => { throw new Error("DefaultHandler should not be used"); });
+        this.callback = callback;
+    }
+    start(timeoutMs) {
+        super.start(timeoutMs, this.callback);
+    }
+    restart(timeoutMs) {
+        super.restart(timeoutMs, this.callback);
+    }
 }
 //# sourceMappingURL=garbageCollection.js.map