@fluidframework/container-runtime 2.0.0-internal.3.1.0 → 2.0.0-internal.3.2.1

package/dist/{garbageCollection.js → gc/garbageCollection.js}

@@ -15,108 +15,21 @@ var __rest = (this && this.__rest) || function (s, e) {
     return t;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GarbageCollector = exports.UnreferencedStateTracker = exports.UnreferencedState = exports.GCNodeType = void 0;
+exports.GarbageCollector = 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");
-const protocol_definitions_1 = require("@fluidframework/protocol-definitions");
 const runtime_definitions_1 = require("@fluidframework/runtime-definitions");
 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 garbageCollectionHelpers_1 = require("./garbageCollectionHelpers");
+const containerRuntime_1 = require("../containerRuntime");
+const dataStores_1 = require("../dataStores");
+const summary_1 = require("../summary");
+const gcDefinitions_1 = require("./gcDefinitions");
+const gcHelpers_1 = require("./gcHelpers");
+const gcSummaryStateTracker_1 = require("./gcSummaryStateTracker");
 const gcSweepReadyUsageDetection_1 = require("./gcSweepReadyUsageDetection");
-const summaryFormat_1 = require("./summaryFormat");
-/** The types of GC nodes in the GC reference graph. */
-exports.GCNodeType = {
-    // Nodes that are for data stores.
-    DataStore: "DataStore",
-    // Nodes that are within a data store. For example, DDS nodes.
-    SubDataStore: "SubDataStore",
-    // Nodes that are for attachment blobs, i.e., blobs uploaded via BlobManager.
-    Blob: "Blob",
-    // Nodes that are neither of the above. For example, root node.
-    Other: "Other",
-};
-/** The state of node that is unreferenced. */
-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. */
-    Inactive: "Inactive",
-    /** The node is ready to be deleted by the sweep phase. */
-    SweepReady: "SweepReady",
-};
-/**
- * Helper class that tracks the state of an unreferenced node such as the time it was unreferenced and if it can
- * be deleted by the sweep phase.
- */
-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) {
-        this.unreferencedTimestampMs = unreferencedTimestampMs;
-        this.inactiveTimeoutMs = inactiveTimeoutMs;
-        this.sweepTimeoutMs = sweepTimeoutMs;
-        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;
-    }
-    /* Updates the unreferenced state based on the provided timestamp. */
-    updateTracking(currentReferenceTimestampMs) {
-        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 = 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 = exports.UnreferencedState.Inactive;
-            this.inactiveTimer.clear();
-            if (this.sweepTimeoutMs !== undefined) {
-                this.sweepTimer.restart(this.sweepTimeoutMs - unreferencedDurationMs);
-            }
-            return;
-        }
-        // The node is still active. Ensure the inactive timer is running with the proper remaining duration.
-        this.inactiveTimer.restart(this.inactiveTimeoutMs - unreferencedDurationMs);
-    }
-    clearTimers() {
-        this.inactiveTimer.clear();
-        this.sweepTimer.clear();
-    }
-    /** Stop tracking this node. Reset the unreferenced timers and state, if any. */
-    stopTracking() {
-        this.clearTimers();
-        this._state = exports.UnreferencedState.Active;
-    }
-}
-exports.UnreferencedStateTracker = UnreferencedStateTracker;
+const gcUnreferencedStateTracker_1 = require("./gcUnreferencedStateTracker");
 /**
  * The garbage collector for the container runtime. It consolidates the garbage collection functionality and maintains
  * its state across summaries.
@@ -171,13 +84,8 @@ class GarbageCollector {
         this.mc = (0, telemetry_utils_1.loggerToMonitoringContext)(telemetry_utils_1.ChildLogger.create(createParams.baseLogger, "GarbageCollector", {
             all: { completedGCRuns: () => this.completedRuns },
         }));
-        // If version upgrade is not enabled, fall back to the stable GC version.
-        this.currentGCVersion =
-            this.mc.config.getBoolean(garbageCollectionConstants_1.gcVersionUpgradeToV2Key) === true
-                ? garbageCollectionConstants_1.currentGCVersion
-                : garbageCollectionConstants_1.stableGCVersion;
         this.sweepReadyUsageHandler = new gcSweepReadyUsageDetection_1.SweepReadyUsageDetectionHandler(createParams.getContainerDiagnosticId(), this.mc, this.runtime.closeFn);
-        let prevSummaryGCVersion;
+        let gcVersionInBaseSnapshot;
         /**
          * Sweep timeout is the time after which unreferenced content can be swept.
          * Sweep timeout = session expiry timeout + snapshot cache expiry timeout + one day buffer.
@@ -187,8 +95,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 * garbageCollectionConstants_1.oneDayMs;
-            const bufferMs = garbageCollectionConstants_1.oneDayMs;
+            const maxSnapshotCacheExpiryMs = 5 * gcDefinitions_1.oneDayMs;
+            const bufferMs = gcDefinitions_1.oneDayMs;
             return (sessionExpiryTimeoutMs &&
                 sessionExpiryTimeoutMs + maxSnapshotCacheExpiryMs + bufferMs);
         }
@@ -200,10 +108,10 @@ class GarbageCollector {
          * For existing containers, we get this information from the metadata blob of its summary.
          */
         if (createParams.existing) {
-            prevSummaryGCVersion = (0, summaryFormat_1.getGCVersion)(metadata);
+            gcVersionInBaseSnapshot = (0, gcHelpers_1.getGCVersion)(metadata);
             // Existing documents which did not have metadata blob or had GC disabled have version as 0. For all
             // other existing documents, GC is enabled.
-            this.gcEnabled = prevSummaryGCVersion > 0;
+            this.gcEnabled = gcVersionInBaseSnapshot > 0;
             this.sweepEnabled = (_a = metadata === null || metadata === void 0 ? void 0 : metadata.sweepEnabled) !== null && _a !== void 0 ? _a : false;
             this.sessionExpiryTimeoutMs = metadata === null || metadata === void 0 ? void 0 : metadata.sessionExpiryTimeoutMs;
             this.sweepTimeoutMs =
@@ -224,15 +132,15 @@ class GarbageCollector {
             // 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 and GC is enabled.
-            if (this.mc.config.getBoolean(garbageCollectionConstants_1.runSessionExpiryKey) && this.gcEnabled) {
+            if (this.mc.config.getBoolean(gcDefinitions_1.runSessionExpiryKey) && this.gcEnabled) {
                 this.sessionExpiryTimeoutMs =
-                    (_c = this.gcOptions.sessionExpiryTimeoutMs) !== null && _c !== void 0 ? _c : garbageCollectionConstants_1.defaultSessionExpiryDurationMs;
+                    (_c = this.gcOptions.sessionExpiryTimeoutMs) !== null && _c !== void 0 ? _c : gcDefinitions_1.defaultSessionExpiryDurationMs;
             }
             this.sweepTimeoutMs =
                 testOverrideSweepTimeoutMs !== null && testOverrideSweepTimeoutMs !== void 0 ? testOverrideSweepTimeoutMs : computeSweepTimeout(this.sessionExpiryTimeoutMs);
-            if (this.gcOptions[garbageCollectionConstants_1.gcTombstoneGenerationOptionName] !== undefined) {
+            if (this.gcOptions[gcDefinitions_1.gcTombstoneGenerationOptionName] !== undefined) {
                 this.persistedGcFeatureMatrix = {
-                    tombstoneGeneration: this.gcOptions[garbageCollectionConstants_1.gcTombstoneGenerationOptionName],
+                    tombstoneGeneration: this.gcOptions[gcDefinitions_1.gcTombstoneGenerationOptionName],
                 };
             }
         }
@@ -246,9 +154,6 @@ class GarbageCollector {
             });
             this.sessionExpiryTimer.start();
         }
-        // For existing document, the latest summary is the one that we loaded from. So, use its GC version as the
-        // latest tracked GC version. For new documents, we will be writing the first summary with the current version.
-        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:
          *
@@ -259,7 +164,7 @@ class GarbageCollector {
          * These conditions can be overridden via runGCKey feature flag.
          */
         this.shouldRunGC =
-            (_d = this.mc.config.getBoolean(garbageCollectionConstants_1.runGCKey)) !== null && _d !== void 0 ? _d : 
+            (_d = this.mc.config.getBoolean(gcDefinitions_1.runGCKey)) !== null && _d !== void 0 ? _d : 
             // GC must be enabled for the document.
             (this.gcEnabled &&
                 // GC must not be disabled via GC options.
@@ -277,24 +182,23 @@ class GarbageCollector {
         this.shouldRunSweep =
             this.shouldRunGC &&
                 this.sweepTimeoutMs !== undefined &&
-                ((_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;
+                ((_e = this.mc.config.getBoolean(gcDefinitions_1.runSweepKey)) !== null && _e !== void 0 ? _e : this.sweepEnabled);
+        this.trackGCState = this.mc.config.getBoolean(gcDefinitions_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 : garbageCollectionConstants_1.defaultInactiveTimeoutMs;
+            (_g = (_f = this.mc.config.getNumber("Fluid.GarbageCollection.TestOverride.InactiveTimeoutMs")) !== null && _f !== void 0 ? _f : this.gcOptions.inactiveTimeoutMs) !== null && _g !== void 0 ? _g : gcDefinitions_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(garbageCollectionConstants_1.gcTestModeKey)) !== null && _h !== void 0 ? _h : this.gcOptions.runGCInTestMode === true;
+            (_h = this.mc.config.getBoolean(gcDefinitions_1.gcTestModeKey)) !== null && _h !== void 0 ? _h : this.gcOptions.runGCInTestMode === true;
         // Whether we are running in tombstone mode. This is enabled by default if sweep won't run. It can be disabled
         // via feature flags.
         this.tombstoneMode =
-            !this.shouldRunSweep && this.mc.config.getBoolean(garbageCollectionConstants_1.disableTombstoneKey) !== true;
-        // If GC ran in the container that generated the base snapshot, it will have a GC tree.
-        this.wasGCRunInLatestSummary = (baseSnapshot === null || baseSnapshot === void 0 ? void 0 : baseSnapshot.trees[runtime_definitions_1.gcTreeKey]) !== undefined;
+            !this.shouldRunSweep && this.mc.config.getBoolean(gcDefinitions_1.disableTombstoneKey) !== true;
+        this.summaryStateTracker = new gcSummaryStateTracker_1.GCSummaryStateTracker(this.shouldRunGC, this.trackGCState, this.tombstoneMode, this.mc, (baseSnapshot === null || baseSnapshot === void 0 ? void 0 : baseSnapshot.trees[runtime_definitions_1.gcTreeKey]) !== undefined /* wasGCRunInBaseSnapshot */, gcVersionInBaseSnapshot);
         // 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 () => {
@@ -329,7 +233,7 @@ class GarbageCollector {
                     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]);
+                    const initialSnapshotDetails = await readAndParseBlob(dsSnapshotTree.blobs[summary_1.dataStoreAttributesBlobName]);
                     if (initialSnapshotDetails.isRootDataStore) {
                         gcState.gcNodes["/"].outboundRoutes.push(dsRootId);
                     }
@@ -421,46 +325,13 @@ class GarbageCollector {
     static create(createParams) {
         return new GarbageCollector(createParams);
     }
-    /**
-     * 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. GC is enabled and the latest summary state is refreshed from a snapshot that had GC disabled and vice-versa.
-     *
-     * 4. The GC version in the latest summary is different from the current GC version. This can happen if:
-     *
-     * 4.1. The summary this client loaded with has data from a different GC version.
-     *
-     * 4.2. This client's latest summary was updated from a snapshot that has a different GC version.
-     */
-    get summaryStateNeedsReset() {
-        return (this.gcStateNeedsReset ||
-            (this.shouldRunGC && this.latestSummaryGCVersion !== this.currentGCVersion));
-    }
-    /**
-     * Tells whether the GC state needs to be reset. This can happen under 3 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.
-     *
-     * 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.
-     *
-     * 3. GC is enabled and the latest summary state is refreshed from a snapshot that had GC disabled and vice-versa.
-     *
-     * Note that the state will be reset only once for the first summary generated after this returns true. After that,
-     * this will return false.
-     */
-    get gcStateNeedsReset() {
-        return this.wasGCRunInLatestSummary !== this.shouldRunGC;
-    }
     /** 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, testMode: this.testMode, tombstoneMode: this.tombstoneMode, sessionExpiry: this.sessionExpiryTimeoutMs, sweepTimeout: this.sweepTimeoutMs, inactiveTimeout: this.inactiveTimeoutMs, trackGCState: this.trackGCState }, this.gcOptions);
     }
+    get summaryStateNeedsReset() {
+        return this.summaryStateTracker.doesSummaryStateNeedReset();
+    }
     /**
      * Called during container initialization. Initialize from the tombstone state in the base snapshot. This is done
      * during initialization so that deleted or tombstoned objects are marked as such before they are loaded or used.
@@ -542,10 +413,11 @@ class GarbageCollector {
             this.tombstones = (snapshotData === null || snapshotData === void 0 ? void 0 : snapshotData.tombstones) ? Array.from(snapshotData.tombstones) : [];
             this.runtime.updateTombstonedRoutes(this.tombstones);
         }
+        // Update the summary state tracker's state from this snapshot.
+        this.summaryStateTracker.updateStateFromSnapshotData(snapshotData);
         // If there is no snapshot data, it means this snapshot was generated with GC disabled. Unset all GC state.
         if (snapshotData === undefined) {
             this.gcDataFromLastRun = undefined;
-            this.latestSummaryData = undefined;
             return;
         }
         // Update unreferenced state tracking as per the GC state in the snapshot data and update gcDataFromLastRun
@@ -553,19 +425,11 @@ class GarbageCollector {
         const gcNodes = {};
         for (const [nodeId, nodeData] of Object.entries(snapshotData.gcState.gcNodes)) {
             if (nodeData.unreferencedTimestampMs !== undefined) {
-                this.unreferencedNodesState.set(nodeId, new UnreferencedStateTracker(nodeData.unreferencedTimestampMs, this.inactiveTimeoutMs, currentReferenceTimestampMs, this.sweepTimeoutMs));
+                this.unreferencedNodesState.set(nodeId, new gcUnreferencedStateTracker_1.UnreferencedStateTracker(nodeData.unreferencedTimestampMs, this.inactiveTimeoutMs, currentReferenceTimestampMs, this.sweepTimeoutMs));
             }
             gcNodes[nodeId] = Array.from(nodeData.outboundRoutes);
         }
         this.gcDataFromLastRun = { gcNodes };
-        // If tracking state across summaries, update latest summary data from the snapshot's GC data.
-        if (this.trackGCState) {
-            this.latestSummaryData = {
-                serializedGCState: JSON.stringify(generateSortedGCState(snapshotData.gcState)),
-                serializedTombstones: JSON.stringify(snapshotData.tombstones),
-                serializedDeletedNodes: JSON.stringify(snapshotData.deletedNodes),
-            };
-        }
     }
     /**
      * Called when the connection state of the runtime changes, i.e., it connects or disconnects. GC subscribes to this
@@ -595,9 +459,10 @@ class GarbageCollector {
      * Runs garbage collection and updates the reference / used state of the nodes in the container.
      * @returns stats of the GC run or undefined if GC did not run.
      */
-    async collectGarbage(options) {
+    async collectGarbage(options, telemetryContext) {
         var _a;
-        const fullGC = (_a = options.fullGC) !== null && _a !== void 0 ? _a : (this.gcOptions.runFullGC === true || this.summaryStateNeedsReset);
+        const fullGC = (_a = options.fullGC) !== null && _a !== void 0 ? _a : (this.gcOptions.runFullGC === true ||
+            this.summaryStateTracker.doesSummaryStateNeedReset());
         const logger = options.logger
             ? telemetry_utils_1.ChildLogger.create(options.logger, undefined, {
                 all: { completedGCRuns: () => this.completedRuns },
@@ -620,6 +485,11 @@ class GarbageCollector {
             });
             return undefined;
         }
+        // Add the options that are used to run GC to the telemetry context.
+        telemetryContext === null || telemetryContext === void 0 ? void 0 : telemetryContext.setMultiple("fluid_GC", "Options", {
+            fullGC,
+            runSweep: options.runSweep,
+        });
         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.
@@ -687,97 +557,7 @@ class GarbageCollector {
                 unreferencedTimestampMs: (_a = this.unreferencedNodesState.get(nodeId)) === null || _a === void 0 ? void 0 : _a.unreferencedTimestampMs,
             };
         }
-        const serializedGCState = JSON.stringify(generateSortedGCState(gcState));
-        // Serialize and write deleted nodes, if any. This is done irrespective of whether sweep is enabled or not so
-        // to identify deleted nodes' usage.
-        const serializedDeletedNodes = this.deletedNodes.size > 0
-            ? JSON.stringify(Array.from(this.deletedNodes).sort())
-            : undefined;
-        // If running in tombstone mode, serialize and write tombstones, if any.
-        const serializedTombstones = this.tombstoneMode
-            ? this.tombstones.length > 0
-                ? JSON.stringify(this.tombstones.sort())
-                : undefined
-            : undefined;
-        /**
-         * Incremental summary of GC data - If none of GC state, deleted nodes or tombstones changed since last summary,
-         * write summary handle instead of summary tree for GC.
-         * Otherwise, write the GC summary tree. In the tree, for each of these that changed, write a summary blob and
-         * for each of these that did not change, write a summary handle.
-         */
-        if (this.trackGCState) {
-            this.pendingSummaryData = {
-                serializedGCState,
-                serializedTombstones,
-                serializedDeletedNodes,
-            };
-            if (trackState && !fullTree && this.latestSummaryData !== undefined) {
-                // If nothing changed since last summary, send a summary handle for the entire GC data.
-                if (this.latestSummaryData.serializedGCState === serializedGCState &&
-                    this.latestSummaryData.serializedTombstones === serializedTombstones) {
-                    const stats = (0, runtime_utils_1.mergeStats)();
-                    stats.handleNodeCount++;
-                    return {
-                        summary: {
-                            type: protocol_definitions_1.SummaryType.Handle,
-                            handle: `/${runtime_definitions_1.gcTreeKey}`,
-                            handleType: protocol_definitions_1.SummaryType.Tree,
-                        },
-                        stats,
-                    };
-                }
-                // If some state changed, build a GC summary tree.
-                return this.buildGCSummaryTree(serializedGCState, serializedTombstones, serializedDeletedNodes, true /* trackState */);
-            }
-        }
-        // If not tracking GC state, build a GC summary tree without any summary handles.
-        return this.buildGCSummaryTree(serializedGCState, serializedTombstones, serializedDeletedNodes, false /* trackState */);
-    }
-    /**
-     * Builds the GC summary tree which contains GC state, deleted nodes and tombstones.
-     * If trackState is false, all of GC state, deleted nodes and tombstones are written as summary blobs.
-     * If trackState is true, only states that changed are written. Rest are written as handles.
-     * @param serializedGCState - The GC state serialized as string.
-     * @param serializedTombstones - The tombstone state serialized as string.
-     * @param serializedDeletedNodes - Deleted nodes serialized as string.
-     * @param trackState - Whether we are tracking GC state across summaries.
-     * @returns the GC summary tree.
-     */
-    buildGCSummaryTree(serializedGCState, serializedTombstones, serializedDeletedNodes, trackState) {
-        var _a, _b, _c;
-        const gcStateBlobKey = `${runtime_definitions_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, `/${runtime_definitions_1.gcTreeKey}/${gcStateBlobKey}`);
-        }
-        else {
-            builder.addBlob(gcStateBlobKey, serializedGCState);
-        }
-        // If tombstones exist, write a summary handle if it hasn't changed. If it has changed, write a
-        // summary blob.
-        if (serializedTombstones !== undefined) {
-            if (((_b = this.latestSummaryData) === null || _b === void 0 ? void 0 : _b.serializedTombstones) === serializedTombstones &&
-                trackState) {
-                builder.addHandle(runtime_definitions_1.gcTombstoneBlobKey, protocol_definitions_1.SummaryType.Blob, `/${runtime_definitions_1.gcTreeKey}/${runtime_definitions_1.gcTombstoneBlobKey}`);
-            }
-            else {
-                builder.addBlob(runtime_definitions_1.gcTombstoneBlobKey, serializedTombstones);
-            }
-        }
-        // If there are no deleted nodes, return the summary tree.
-        if (serializedDeletedNodes === undefined) {
-            return builder.getSummaryTree();
-        }
-        // If the deleted nodes hasn't changed, write a summary handle, else write a summary blob for it.
-        if (((_c = this.latestSummaryData) === null || _c === void 0 ? void 0 : _c.serializedDeletedNodes) === serializedDeletedNodes &&
-            trackState) {
-            builder.addHandle(runtime_definitions_1.gcDeletedBlobKey, protocol_definitions_1.SummaryType.Blob, `/${runtime_definitions_1.gcTreeKey}/${runtime_definitions_1.gcDeletedBlobKey}`);
-        }
-        else {
-            builder.addBlob(runtime_definitions_1.gcDeletedBlobKey, serializedDeletedNodes);
-        }
-        return builder.getSummaryTree();
+        return this.summaryStateTracker.summarize(fullTree, trackState, gcState, this.deletedNodes, this.tombstones);
     }
     getMetadata() {
         return {
@@ -785,7 +565,7 @@ class GarbageCollector {
              * If GC is enabled, the GC data is written using the current GC version and that is the gcFeature that goes
              * into the metadata blob. If GC is disabled, the gcFeature is 0.
              */
-            gcFeature: this.gcEnabled ? this.currentGCVersion : 0,
+            gcFeature: this.gcEnabled ? this.summaryStateTracker.currentGCVersion : 0,
             gcFeatureMatrix: this.persistedGcFeatureMatrix,
             sessionExpiryTimeoutMs: this.sessionExpiryTimeoutMs,
             sweepEnabled: this.sweepEnabled,
@@ -804,52 +584,22 @@ class GarbageCollector {
      * is downloaded and should be used to update the state.
      */
     async refreshLatestSummary(proposalHandle, result, readAndParseBlob) {
-        // If the latest summary was updated and the summary was tracked, this client is the one that generated this
-        // summary. So, update wasGCRunInLatestSummary.
-        // Note that this has to be updated if GC did not run too. Otherwise, `gcStateNeedsReset` will always return
-        // true in scenarios where GC is disabled but enabled in the snapshot we loaded from.
-        if (result.latestSummaryUpdated && result.wasSummaryTracked) {
-            this.wasGCRunInLatestSummary = this.shouldRunGC;
-        }
-        if (!result.latestSummaryUpdated || !this.shouldRunGC) {
-            return;
-        }
-        // If the summary was tracked by this client, it was the one that generated the summary in the first place.
-        // Update latest state from pending.
-        if (result.wasSummaryTracked) {
-            this.latestSummaryGCVersion = this.currentGCVersion;
-            if (this.trackGCState) {
-                this.latestSummaryData = this.pendingSummaryData;
-                this.pendingSummaryData = undefined;
+        const latestSnapshotData = await this.summaryStateTracker.refreshLatestSummary(proposalHandle, result, readAndParseBlob);
+        // If the latest summary was updated but it was not tracked by this client, our state needs to be updated from
+        // this snapshot data.
+        if (this.shouldRunGC && result.latestSummaryUpdated && !result.wasSummaryTracked) {
+            // The current reference timestamp should be available if we are refreshing state from a snapshot. There has
+            // to be at least one op (summary op / ack, if nothing else) if a snapshot was taken.
+            const currentReferenceTimestampMs = this.runtime.getCurrentReferenceTimestampMs();
+            if (currentReferenceTimestampMs === undefined) {
+                throw container_utils_1.DataProcessingError.create("No reference timestamp when updating GC state from snapshot", "refreshLatestSummary", undefined, {
+                    proposalHandle,
+                    summaryRefSeq: result.summaryRefSeq,
+                    details: JSON.stringify(this.configs),
+                });
             }
-            return;
-        }
-        // If the summary was not tracked by this client, the state should be updated from the downloaded snapshot.
-        const snapshotTree = result.snapshotTree;
-        const metadataBlobId = snapshotTree.blobs[summaryFormat_1.metadataBlobName];
-        if (metadataBlobId) {
-            const metadata = await readAndParseBlob(metadataBlobId);
-            this.latestSummaryGCVersion = (0, summaryFormat_1.getGCVersion)(metadata);
-        }
-        // The current reference timestamp should be available if we are refreshing state from a snapshot. There has
-        // to be at least one op (summary op / ack, if nothing else) if a snapshot was taken.
-        const currentReferenceTimestampMs = this.runtime.getCurrentReferenceTimestampMs();
-        if (currentReferenceTimestampMs === undefined) {
-            throw container_utils_1.DataProcessingError.create("No reference timestamp when updating GC state from snapshot", "refreshLatestSummary", undefined, {
-                proposalHandle,
-                summaryRefSeq: result.summaryRefSeq,
-                details: JSON.stringify(this.configs),
-            });
-        }
-        const gcSnapshotTree = snapshotTree.trees[runtime_definitions_1.gcTreeKey];
-        // If GC ran in the container that generated this snapshot, it will have a GC tree.
-        this.wasGCRunInLatestSummary = gcSnapshotTree !== undefined;
-        let latestGCData;
-        if (gcSnapshotTree !== undefined) {
-            latestGCData = await (0, garbage_collector_1.getGCDataFromSnapshot)(gcSnapshotTree, readAndParseBlob);
+            this.updateStateFromSnapshotData(latestSnapshotData, currentReferenceTimestampMs);
         }
-        this.updateStateFromSnapshotData(latestGCData, currentReferenceTimestampMs);
-        this.pendingSummaryData = undefined;
     }
     /**
      * Called when a node with the given id is updated. If the node is inactive, log an error.
@@ -864,7 +614,7 @@ class GarbageCollector {
             return;
         }
         const nodeStateTracker = this.unreferencedNodesState.get(nodePath);
-        if (nodeStateTracker && nodeStateTracker.state !== exports.UnreferencedState.Active) {
+        if (nodeStateTracker && nodeStateTracker.state !== gcDefinitions_1.UnreferencedState.Active) {
             this.inactiveNodeUsed(reason, nodePath, nodeStateTracker, undefined /* fromNodeId */, packagePath, timestampMs, requestHeaders);
         }
     }
@@ -884,19 +634,19 @@ class GarbageCollector {
         outboundRoutes.push(toNodePath);
         this.newReferencesSinceLastRun.set(fromNodePath, outboundRoutes);
         const nodeStateTracker = this.unreferencedNodesState.get(toNodePath);
-        if (nodeStateTracker && nodeStateTracker.state !== exports.UnreferencedState.Active) {
+        if (nodeStateTracker && nodeStateTracker.state !== gcDefinitions_1.UnreferencedState.Active) {
             this.inactiveNodeUsed("Revived", toNodePath, nodeStateTracker, fromNodePath);
         }
         if (this.tombstones.includes(toNodePath)) {
             const nodeType = this.runtime.getNodeType(toNodePath);
             let eventName = "GC_Tombstone_SubDatastore_Revived";
-            if (nodeType === exports.GCNodeType.DataStore) {
+            if (nodeType === gcDefinitions_1.GCNodeType.DataStore) {
                 eventName = "GC_Tombstone_Datastore_Revived";
             }
-            else if (nodeType === exports.GCNodeType.Blob) {
+            else if (nodeType === gcDefinitions_1.GCNodeType.Blob) {
                 eventName = "GC_Tombstone_Blob_Revived";
             }
-            (0, garbageCollectionHelpers_1.sendGCUnexpectedUsageEvent)(this.mc, {
+            (0, gcHelpers_1.sendGCUnexpectedUsageEvent)(this.mc, {
                 eventName,
                 category: "generic",
                 url: (0, garbage_collector_1.trimLeadingSlashes)(toNodePath),
@@ -954,11 +704,11 @@ 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, currentReferenceTimestampMs, this.sweepTimeoutMs));
+                this.unreferencedNodesState.set(nodeId, new gcUnreferencedStateTracker_1.UnreferencedStateTracker(currentReferenceTimestampMs, this.inactiveTimeoutMs, currentReferenceTimestampMs, this.sweepTimeoutMs));
             }
             else {
                 nodeStateTracker.updateTracking(currentReferenceTimestampMs);
-                if (nodeStateTracker.state === exports.UnreferencedState.SweepReady) {
+                if (nodeStateTracker.state === gcDefinitions_1.UnreferencedState.SweepReady) {
                     sweepReadyNodes.push(nodeId);
                 }
             }
@@ -972,7 +722,7 @@ class GarbageCollector {
     runSweepPhase(sweepReadyNodes, gcData) {
         // TODO: GC:Validation - validate that removed routes are not double deleted
         // TODO: GC:Validation - validate that the child routes of removed routes are deleted as well
-        const sweptRoutes = this.runtime.deleteUnusedNodes(sweepReadyNodes);
+        const sweptRoutes = this.runtime.deleteSweepReadyNodes(sweepReadyNodes);
         const updatedGCData = this.deleteSweptRoutes(sweptRoutes, gcData);
         for (const nodeId of sweptRoutes) {
             const nodeStateTracker = this.unreferencedNodesState.get(nodeId);
@@ -1113,7 +863,7 @@ class GarbageCollector {
              */
             currentOutboundRoutes.forEach((route) => {
                 const nodeType = this.runtime.getNodeType(route);
-                if ((nodeType === exports.GCNodeType.DataStore || nodeType === exports.GCNodeType.Blob) &&
+                if ((nodeType === gcDefinitions_1.GCNodeType.DataStore || nodeType === gcDefinitions_1.GCNodeType.Blob) &&
                     !nodeId.startsWith(route) &&
                     !previousRoutes.includes(route) &&
                     !explicitRoutes.includes(route)) {
@@ -1156,7 +906,7 @@ class GarbageCollector {
             if (!referenced) {
                 gcStats.unrefNodeCount++;
             }
-            if (this.runtime.getNodeType(nodeId) === exports.GCNodeType.DataStore) {
+            if (this.runtime.getNodeType(nodeId) === gcDefinitions_1.GCNodeType.DataStore) {
                 gcStats.dataStoreCount++;
                 if (stateUpdated) {
                     gcStats.updatedDataStoreCount++;
@@ -1165,7 +915,7 @@ class GarbageCollector {
                     gcStats.unrefDataStoreCount++;
                 }
             }
-            if (this.runtime.getNodeType(nodeId) === exports.GCNodeType.Blob) {
+            if (this.runtime.getNodeType(nodeId) === gcDefinitions_1.GCNodeType.Blob) {
                 gcStats.attachmentBlobCount++;
                 if (stateUpdated) {
                     gcStats.updatedAttachmentBlobCount++;
@@ -1188,16 +938,16 @@ class GarbageCollector {
      * this will give us a view into how much deleted content a container has.
      */
     logSweepEvents(logger, currentReferenceTimestampMs) {
-        if (this.mc.config.getBoolean(garbageCollectionConstants_1.disableSweepLogKey) === true ||
+        if (this.mc.config.getBoolean(gcDefinitions_1.disableSweepLogKey) === true ||
             this.sweepTimeoutMs === undefined) {
             return;
         }
         this.unreferencedNodesState.forEach((nodeStateTracker, nodeId) => {
-            if (nodeStateTracker.state !== exports.UnreferencedState.SweepReady) {
+            if (nodeStateTracker.state !== gcDefinitions_1.UnreferencedState.SweepReady) {
                 return;
             }
             const nodeType = this.runtime.getNodeType(nodeId);
-            if (nodeType !== exports.GCNodeType.DataStore && nodeType !== exports.GCNodeType.Blob) {
+            if (nodeType !== gcDefinitions_1.GCNodeType.DataStore && nodeType !== gcDefinitions_1.GCNodeType.Blob) {
                 return;
             }
             // Log deleted event for each node only once to reduce noise in telemetry.
@@ -1225,13 +975,13 @@ class GarbageCollector {
         // logging as nothing interesting would have happened worth logging.
         // If the node is active, skip logging.
         if (currentReferenceTimestampMs === undefined ||
-            nodeStateTracker.state === exports.UnreferencedState.Active) {
+            nodeStateTracker.state === gcDefinitions_1.UnreferencedState.Active) {
             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);
-        if (nodeType !== exports.GCNodeType.DataStore && nodeType !== exports.GCNodeType.Blob) {
+        if (nodeType !== gcDefinitions_1.GCNodeType.DataStore && nodeType !== gcDefinitions_1.GCNodeType.Blob) {
             return;
         }
         const state = nodeStateTracker.state;
@@ -1240,9 +990,9 @@ class GarbageCollector {
             return;
         }
         this.loggedUnreferencedEvents.add(uniqueEventId);
-        const propsToLog = Object.assign(Object.assign({ 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 === gcDefinitions_1.UnreferencedState.Inactive
                 ? this.inactiveTimeoutMs
-                : 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 });
+                : this.sweepTimeoutMs, completedGCRuns: this.completedRuns, lastSummaryTime: this.getLastSummaryTimestampMs() }, this.createContainerMetadata), { 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.
@@ -1260,7 +1010,7 @@ class GarbageCollector {
                 const event = Object.assign(Object.assign({}, propsToLog), { eventName: `${state}Object_${usageType}`, pkg: (0, runtime_utils_1.packagePathToTelemetryProperty)(packagePath), stack: (0, telemetry_utils_1.generateStack)() });
                 // Do not log the inactive object x events as error events as they are not the best signal for
                 // detecting something wrong with GC either from the partner or from the runtime itself.
-                if (state === exports.UnreferencedState.Inactive) {
+                if (state === gcDefinitions_1.UnreferencedState.Inactive) {
                     this.mc.logger.sendTelemetryEvent(event);
                 }
                 else {
@@ -1270,7 +1020,7 @@ class GarbageCollector {
             // If SweepReady Usage Detection is enabled, 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) {
+            if (state === gcDefinitions_1.UnreferencedState.SweepReady) {
                 this.sweepReadyUsageHandler.usageDetectedInInteractiveClient(Object.assign(Object.assign({}, propsToLog), { usageType }));
             }
         }
@@ -1291,7 +1041,7 @@ class GarbageCollector {
              */
             const nodeStateTracker = this.unreferencedNodesState.get(eventProps.id);
             const active = nodeStateTracker === undefined ||
-                nodeStateTracker.state === exports.UnreferencedState.Active;
+                nodeStateTracker.state === gcDefinitions_1.UnreferencedState.Active;
             if ((usageType === "Revived") === active) {
                 const pkg = await this.getNodePackagePath(eventProps.id);
                 const fromPkg = eventProps.fromId
@@ -1302,7 +1052,7 @@ class GarbageCollector {
                         : undefined, fromPkg: fromPkg
                         ? { value: fromPkg.join("/"), tag: telemetry_utils_1.TelemetryDataTag.CodeArtifact }
                         : undefined });
-                if (state === exports.UnreferencedState.Inactive) {
+                if (state === gcDefinitions_1.UnreferencedState.Inactive) {
                     logger.sendTelemetryEvent(event);
                 }
                 else {
@@ -1314,30 +1064,4 @@ class GarbageCollector {
     }
 }
 exports.GarbageCollector = GarbageCollector;
-function generateSortedGCState(gcState) {
-    const sortableArray = Object.entries(gcState.gcNodes);
-    sortableArray.sort(([a], [b]) => a.localeCompare(b));
-    const sortedGCState = { gcNodes: {} };
-    for (const [nodeId, nodeData] of sortableArray) {
-        nodeData.outboundRoutes.sort();
-        sortedGCState.gcNodes[nodeId] = nodeData;
-    }
-    return sortedGCState;
-}
-/** 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