@fluidframework/container-runtime 2.0.0-dev.2.3.0.115467 → 2.0.0-dev.4.1.0.148229

package/lib/garbageCollection.js

@@ -1,1133 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-import { assert, LazyPromise, Timer } from "@fluidframework/common-utils";
-import { ClientSessionExpiredError, DataProcessingError, UsageError } from "@fluidframework/container-utils";
-import { cloneGCData, concatGarbageCollectionStates, concatGarbageCollectionData, runGarbageCollection, unpackChildNodesGCDetails, } from "@fluidframework/garbage-collector";
-import { SummaryType } from "@fluidframework/protocol-definitions";
-import { gcBlobKey, } from "@fluidframework/runtime-definitions";
-import { mergeStats, packagePathToTelemetryProperty, SummaryTreeBuilder, } from "@fluidframework/runtime-utils";
-import { ChildLogger, generateStack, loggerToMonitoringContext, PerformanceEvent, TelemetryDataTag, } from "@fluidframework/telemetry-utils";
-import { RuntimeHeaders } from "./containerRuntime";
-import { getSummaryForDatastores } from "./dataStores";
-import { defaultInactiveTimeoutMs, defaultSessionExpiryDurationMs, disableSweepLogKey, disableTombstoneKey, gcBlobPrefix, gcTestModeKey, gcTombstoneBlobKey, gcTreeKey, oneDayMs, runGCKey, runSessionExpiryKey, runSweepKey, trackGCStateKey } from "./garbageCollectionConstants";
-import { SweepReadyUsageDetectionHandler } from "./gcSweepReadyUsageDetection";
-import { getGCVersion, metadataBlobName, dataStoreAttributesBlobName, } from "./summaryFormat";
-/** This is the current version of garbage collection. */
-const GCVersion = 1;
-/** The types of GC nodes in the GC reference graph. */
-export const 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. */
-export const 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.
- */
-export 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 = UnreferencedState.Active;
-        if (this.sweepTimeoutMs !== undefined) {
-            assert(this.inactiveTimeoutMs <= this.sweepTimeoutMs, 0x3b0 /* inactive timeout must not be greater than the sweep timeout */);
-        }
-        this.sweepTimer = new TimerWithNoDefaultTimeout(() => {
-            this._state = UnreferencedState.SweepReady;
-            assert(!this.inactiveTimer.hasTimer, 0x3b1 /* inactiveTimer still running after sweepTimer fired! */);
-        });
-        this.inactiveTimer = new TimerWithNoDefaultTimeout(() => {
-            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) {
-                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 = 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.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 = UnreferencedState.Active;
-    }
-}
-/**
- * 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
- *        NodeId = "datastore1"
- *           /             \\
- *    OutboundRoute   OutboundRoute
- *         /                 \\
- *       Node               Node
- *  NodeId = "dds1"     NodeId = "dds2"
- * ```
- */
-export class GarbageCollector {
-    constructor(createParams) {
-        var _a, _b, _c, _d, _e, _f, _g, _h;
-        /**
-         * Tells whether the initial GC state needs to be reset. This can happen under 2 conditions:
-         *
-         * 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.
-         *
-         * 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.
-        */
-        this.initialStateNeedsReset = false;
-        // The current GC version that this container is running.
-        this.currentGCVersion = GCVersion;
-        // Keeps a list of references (edges in the GC graph) between GC runs. Each entry has a node id and a list of
-        // outbound routes from that node.
-        this.newReferencesSinceLastRun = new Map();
-        this.tombstones = [];
-        // Map of node ids to their unreferenced state tracker.
-        this.unreferencedNodesState = new Map();
-        // Keeps track of unreferenced events that are logged for a node. This is used to limit the log generation to one
-        // per event per node.
-        this.loggedUnreferencedEvents = new Set();
-        // Queue for unreferenced events that should be logged the next time GC runs.
-        this.pendingEventsQueue = [];
-        // The number of times GC has successfully completed on this instance of GarbageCollector.
-        this.completedRuns = 0;
-        this.runtime = createParams.runtime;
-        this.isSummarizerClient = createParams.isSummarizerClient;
-        this.gcOptions = createParams.gcOptions;
-        this.createContainerMetadata = createParams.createContainerMetadata;
-        this.getNodePackagePath = createParams.getNodePackagePath;
-        this.getLastSummaryTimestampMs = createParams.getLastSummaryTimestampMs;
-        this.activeConnection = createParams.activeConnection;
-        const baseSnapshot = createParams.baseSnapshot;
-        const metadata = createParams.metadata;
-        const readAndParseBlob = createParams.readAndParseBlob;
-        this.mc = loggerToMonitoringContext(ChildLogger.create(createParams.baseLogger, "GarbageCollector", { all: { completedGCRuns: () => this.completedRuns } }));
-        this.sweepReadyUsageHandler = new SweepReadyUsageDetectionHandler(createParams.getContainerDiagnosticId(), this.mc, this.runtime.closeFn);
-        let prevSummaryGCVersion;
-        /**
-         * 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 snapshot cache expiry timeout cannot be known precisely but the upper bound is 5 days.
-         * The buffer is added to account for any clock skew or other edge cases.
-         * 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 * oneDayMs;
-            const bufferMs = oneDayMs;
-            return sessionExpiryTimeoutMs &&
-                (sessionExpiryTimeoutMs + maxSnapshotCacheExpiryMs + bufferMs);
-        }
-        /**
-         * The following GC state is enabled during container creation and cannot be changed throughout its lifetime:
-         * 1. Whether running GC mark phase is allowed or not.
-         * 2. Whether running GC sweep phase is allowed or not.
-         * 3. Whether GC session expiry is enabled or not.
-         * For existing containers, we get this information from the metadata blob of its summary.
-         */
-        if (createParams.existing) {
-            prevSummaryGCVersion = 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.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 =
-                (_b = metadata === null || metadata === void 0 ? void 0 : metadata.sweepTimeoutMs) !== null && _b !== void 0 ? _b : computeSweepTimeout(this.sessionExpiryTimeoutMs); // Backfill old documents that didn't persist this
-        }
-        else {
-            // Sweep should not be enabled without enabling GC mark phase. We could silently disable sweep in this
-            // scenario but explicitly failing makes it clearer and promotes correct usage.
-            if (this.gcOptions.sweepAllowed && this.gcOptions.gcAllowed === false) {
-                throw new UsageError("GC sweep phase cannot be enabled without enabling GC mark phase");
-            }
-            // This Test Override only applies for new containers
-            const testOverrideSweepTimeoutMs = this.mc.config.getNumber("Fluid.GarbageCollection.TestOverride.SweepTimeoutMs");
-            // For new documents, GC is enabled by default. It can be explicitly disabled by setting the gcAllowed
-            // flag in GC options to false.
-            this.gcEnabled = this.gcOptions.gcAllowed !== false;
-            // The sweep phase has to be explicitly enabled by setting the sweepAllowed flag in GC options to true.
-            // ...unless we're using the TestOverride
-            this.sweepEnabled = this.gcOptions.sweepAllowed === true || testOverrideSweepTimeoutMs !== undefined;
-            // Set the Session Expiry only if the flag is enabled and GC is enabled.
-            if (this.mc.config.getBoolean(runSessionExpiryKey) && this.gcEnabled) {
-                this.sessionExpiryTimeoutMs = (_c = this.gcOptions.sessionExpiryTimeoutMs) !== null && _c !== void 0 ? _c : defaultSessionExpiryDurationMs;
-            }
-            this.sweepTimeoutMs =
-                testOverrideSweepTimeoutMs !== null && testOverrideSweepTimeoutMs !== void 0 ? testOverrideSweepTimeoutMs : computeSweepTimeout(this.sessionExpiryTimeoutMs);
-        }
-        // If session expiry is enabled, we need to close the container when the session expiry timeout expires.
-        if (this.sessionExpiryTimeoutMs !== undefined) {
-            // 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;
-            this.sessionExpiryTimer = new Timer(timeoutMs, () => { this.runtime.closeFn(new ClientSessionExpiredError(`Client session expired.`, timeoutMs)); });
-            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:
-         *
-         * 1. GC should be enabled for this container.
-         *
-         * 2. GC should not be disabled via disableGC GC option.
-         *
-         * These conditions can be overridden via runGCKey feature flag.
-         */
-        this.shouldRunGC = (_d = this.mc.config.getBoolean(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. The driver must implement the policy limiting the age of snapshots used for loading. Otherwise
-         * the Sweep Timeout calculation is not valid. We use the persisted value to ensure consistency over time.
-         * 4. Sweep should be enabled for this container (this.sweepEnabled). This can be overridden via runSweep
-         * feature flag.
-         */
-        this.shouldRunSweep =
-            this.shouldRunGC
-                && this.sweepTimeoutMs !== undefined
-                && ((_e = this.mc.config.getBoolean(runSweepKey)) !== null && _e !== void 0 ? _e : this.sweepEnabled);
-        this.trackGCState = this.mc.config.getBoolean(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 : 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 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(gcTestModeKey)) !== null && _h !== void 0 ? _h : this.gcOptions.runGCInTestMode === true;
-        // Whether we are running in tombstone mode. This is true by default unless disabled via feature flags.
-        this.tombstoneMode = this.mc.config.getBoolean(disableTombstoneKey) !== true;
-        // The GC state needs to be reset if the base snapshot contains GC tree and GC is disabled or it doesn't
-        // contain GC tree and GC is enabled.
-        const gcTreePresent = (baseSnapshot === null || baseSnapshot === void 0 ? void 0 : baseSnapshot.trees[gcTreeKey]) !== undefined;
-        this.initialStateNeedsReset = gcTreePresent !== this.shouldRunGC;
-        // 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 LazyPromise(async () => {
-            var _a;
-            if (baseSnapshot === undefined) {
-                return undefined;
-            }
-            try {
-                // For newer documents, GC data should be present in the GC tree in the root of the snapshot.
-                const gcSnapshotTree = baseSnapshot.trees[gcTreeKey];
-                if (gcSnapshotTree !== undefined) {
-                    return getGCDataFromSnapshot(gcSnapshotTree, readAndParseBlob);
-                }
-                // back-compat - Older documents will have the GC blobs in each data store's summary tree. Get them and
-                // consolidate into IGarbageCollectionState format.
-                // Add a node for the root node that is not present in older snapshot format.
-                const gcState = { gcNodes: { "/": { outboundRoutes: [] } } };
-                const dataStoreSnapshotTree = getSummaryForDatastores(baseSnapshot, metadata);
-                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[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[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) };
-                    }
-                    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, tombstones: undefined };
-            }
-            catch (error) {
-                const dpe = DataProcessingError.wrapIfUnrecognized(error, "FailedToInitializeGC");
-                dpe.addTelemetryProperties({ gcConfigs: JSON.stringify(this.configs) });
-                throw dpe;
-            }
-        });
-        /**
-         * Set up the initializer which initializes the GC state from the data in base snapshot. This is done when
-         * connected in write mode or when GC runs the first time. It sets up all unreferenced nodes from the base
-         * GC state and updates their inactive or sweep ready state.
-         */
-        this.initializeGCStateFromBaseSnapshotP = new 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 baseSnapshotData = await this.baseSnapshotDataP;
-            /**
-             * The base snapshot data will not be present if the container is loaded from:
-             * 1. The first summary created by the detached container.
-             * 2. A summary that was generated with GC disabled.
-             * 3. A summary that was generated before GC even existed.
-             */
-            if (baseSnapshotData === undefined) {
-                return;
-            }
-            const gcNodes = {};
-            for (const [nodeId, nodeData] of Object.entries(baseSnapshotData.gcState.gcNodes)) {
-                if (nodeData.unreferencedTimestampMs !== undefined) {
-                    this.unreferencedNodesState.set(nodeId, new UnreferencedStateTracker(nodeData.unreferencedTimestampMs, this.inactiveTimeoutMs, currentReferenceTimestampMs, this.sweepTimeoutMs));
-                }
-                gcNodes[nodeId] = Array.from(nodeData.outboundRoutes);
-            }
-            this.previousGCDataFromLastRun = { gcNodes };
-            // If tracking state across summaries, update latest summary data from the base snapshot's GC data.
-            if (this.trackGCState) {
-                this.latestSummaryData = {
-                    serializedGCState: JSON.stringify(generateSortedGCState(baseSnapshotData.gcState)),
-                    serializedTombstones: JSON.stringify(baseSnapshotData.tombstones),
-                };
-            }
-        });
-        // Get the GC details for each node from the GC state in the base summary. This is returned in getBaseGCDetails
-        // which the caller uses to initialize each node's GC state.
-        this.baseGCDetailsP = new LazyPromise(async () => {
-            const baseSnapshotData = await this.baseSnapshotDataP;
-            if (baseSnapshotData === undefined) {
-                return new Map();
-            }
-            const gcNodes = {};
-            for (const [nodeId, nodeData] of Object.entries(baseSnapshotData.gcState.gcNodes)) {
-                gcNodes[nodeId] = Array.from(nodeData.outboundRoutes);
-            }
-            // Run GC on the nodes in the base summary to get the routes used in each node in the container.
-            // This is an optimization for space (vs performance) wherein we don't need to store the used routes of
-            // each node in the summary.
-            const usedRoutes = runGarbageCollection(gcNodes, ["/"]).referencedNodeIds;
-            const baseGCDetailsMap = unpackChildNodesGCDetails({ gcData: { gcNodes }, usedRoutes });
-            // Currently, the nodes may write the GC data. So, we need to update its base GC details with the
-            // unreferenced timestamp. Once we start writing the GC data here, we won't need to do this anymore.
-            for (const [nodeId, nodeData] of Object.entries(baseSnapshotData.gcState.gcNodes)) {
-                if (nodeData.unreferencedTimestampMs !== undefined) {
-                    const dataStoreGCDetails = baseGCDetailsMap.get(nodeId.slice(1));
-                    if (dataStoreGCDetails !== undefined) {
-                        dataStoreGCDetails.unrefTimestamp = nodeData.unreferencedTimestampMs;
-                    }
-                }
-            }
-            return baseGCDetailsMap;
-        });
-        // 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.
-        if (this.isSummarizerClient) {
-            this.mc.logger.sendTelemetryEvent({
-                eventName: "GarbageCollectorLoaded",
-                gcConfigs: JSON.stringify(this.configs),
-            });
-        }
-    }
-    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. 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.
-     */
-    get summaryStateNeedsReset() {
-        return this.initialStateNeedsReset ||
-            (this.shouldRunGC && this.latestSummaryGCVersion !== this.currentGCVersion);
-    }
-    /** 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);
-    }
-    /**
-     * Called during container initialization. Initialize the tombstone state so that object are marked as tombstones
-     * before they are loaded or used. This is important to get accurate information of whether tombstoned object are
-     * in use or not.
-     */
-    async initializeBaseState() {
-        const baseSnapshotData = await this.baseSnapshotDataP;
-        /**
-         * The base snapshot data or tombstone state will not be present if the container is loaded from:
-         * 1. The first summary created by the detached container.
-         * 2. A summary that was generated with GC disabled.
-         * 3. A summary that was generated before GC even existed.
-         * 4. A summary that was generated with tombstone feature disabled.
-         */
-        if (!this.tombstoneMode || (baseSnapshotData === null || baseSnapshotData === void 0 ? void 0 : baseSnapshotData.tombstones) === undefined) {
-            return;
-        }
-        this.tombstones = baseSnapshotData.tombstones;
-        this.runtime.updateUnusedRoutes(this.tombstones, true /* tombstone */);
-    }
-    /**
-     * Called when the connection state of the runtime changes, i.e., it connects or disconnects. GC subscribes to this
-     * to initialize the base state for non-summarizer clients so that they can track inactive / sweep ready nodes.
-     * @param connected - Whether the runtime connected / disconnected.
-     * @param clientId - The clientId of this runtime.
-     */
-    setConnectionState(connected, clientId) {
-        /**
-         * For all 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.
-         *
-         * If GC is up-to-date for the client and the summarizing client, there will be an doubling of both
-         * InactiveObject_Loaded and SweepReady_Loaded errors, as there will be one from the sending client and one from
-         * the receiving summarizer client.
-         *
-         * 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.shouldRunGC) {
-            this.initializeGCStateFromBaseSnapshotP.catch((error) => { });
-        }
-    }
-    /**
-     * 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) {
-        var _a;
-        const fullGC = (_a = options.fullGC) !== null && _a !== void 0 ? _a : (this.gcOptions.runFullGC === true || this.summaryStateNeedsReset);
-        const logger = options.logger
-            ? 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 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 = runGarbageCollection(gcData.gcNodes, ["/"]);
-            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" });
-    }
-    async runPreGCSteps() {
-        // Ensure that state has been initialized from the base snapshot data.
-        await this.initializeGCStateFromBaseSnapshotP;
-        // Let the runtime update its pending state before GC runs.
-        await this.runtime.updateStateBeforeGC();
-    }
-    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);
-        // Update the state since the last GC run. There can be nodes that were referenced between the last and
-        // 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.
-        this.updateCurrentState(gcData, gcResult, currentReferenceTimestampMs);
-        this.runtime.updateUsedRoutes(gcResult.referencedNodeIds);
-        // Log events for objects that are ready to be deleted by sweep. When we have sweep enabled, we will
-        // delete these objects here instead.
-        this.logSweepEvents(logger, currentReferenceTimestampMs);
-        // If we are running in GC test mode, delete objects for unused routes. This enables testing scenarios
-        // involving access to deleted data.
-        if (this.testMode) {
-            this.runtime.updateUnusedRoutes(gcResult.deletedNodeIds, false /* tombstone */);
-        }
-        else if (this.tombstoneMode) {
-            // If we are running in GC tombstone mode, tombstone objects for unused routes. This enables testing
-            // scenarios involving access to "deleted" data without actually deleting the data from summaries.
-            // Note: we will not tombstone in test mode
-            this.runtime.updateUnusedRoutes(this.tombstones, true /* tombstone */);
-        }
-        // Log pending unreferenced events such as a node being used after inactive. This is done after GC runs and
-        // updates its state so that we don't send false positives based on intermediate state. For example, we may get
-        // reference to an unreferenced node from another unreferenced node which means the node wasn't revived.
-        await this.logUnreferencedEvents(logger);
-        return gcStats;
-    }
-    /**
-     * Summarizes the GC data and returns it as a summary tree.
-     * We current write the entire GC state in a single blob. This can be modified later to write multiple
-     * blobs. All the blob keys should start with `gcBlobPrefix`.
-     */
-    summarize(fullTree, trackState, telemetryContext) {
-        var _a;
-        if (!this.shouldRunGC || this.previousGCDataFromLastRun === undefined) {
-            return;
-        }
-        const gcState = { gcNodes: {} };
-        for (const [nodeId, outboundRoutes] of Object.entries(this.previousGCDataFromLastRun.gcNodes)) {
-            gcState.gcNodes[nodeId] = {
-                outboundRoutes,
-                unreferencedTimestampMs: (_a = this.unreferencedNodesState.get(nodeId)) === null || _a === void 0 ? void 0 : _a.unreferencedTimestampMs,
-            };
-        }
-        const serializedGCState = JSON.stringify(generateSortedGCState(gcState));
-        const serializedTombstones = this.tombstoneMode
-            ? (this.tombstones.length > 0 ? JSON.stringify(this.tombstones.sort()) : undefined)
-            : undefined;
-        /**
-         * Incremental summary of GC data - If any of the GC state or tombstone state hasn't changed since the last
-         * summary, send summary handles for them. Otherwise, send the data in summary blobs.
-         */
-        if (this.trackGCState) {
-            this.pendingSummaryData = { serializedGCState, serializedTombstones };
-            if (trackState && !fullTree && this.latestSummaryData !== undefined) {
-                // If neither GC state or tombstone state changed, send a summary handle for the entire GC data.
-                if (this.latestSummaryData.serializedGCState === serializedGCState
-                    && this.latestSummaryData.serializedTombstones === serializedTombstones) {
-                    const stats = mergeStats();
-                    stats.handleNodeCount++;
-                    return {
-                        summary: {
-                            type: SummaryType.Handle,
-                            handle: `/${gcTreeKey}`,
-                            handleType: SummaryType.Tree,
-                        },
-                        stats,
-                    };
-                }
-                // If either or both of GC state or tombstone state changed, build a GC summary tree.
-                return this.buildGCSummaryTree(serializedGCState, serializedTombstones, true /* trackState */);
-            }
-        }
-        // If not tracking GC state, build a GC summary tree without any summary handles.
-        return this.buildGCSummaryTree(serializedGCState, serializedTombstones, false /* trackState */);
-    }
-    /**
-     * Builds the GC summary tree which contains GC state and tombstone state.
-     * If trackState is false, both GC state and tombstone state are written as summary blobs.
-     * If trackState is true, summary blob is written for GC state or tombstone state if they changed.
-     * @param serializedGCState - The GC state serialized as string.
-     * @param serializedTombstones - THe tombstone state serialized as string.
-     * @param trackState - Whether we are tracking GC state across summaries.
-     * @returns the GC summary tree.
-     */
-    buildGCSummaryTree(serializedGCState, serializedTombstones, trackState) {
-        var _a, _b;
-        const gcStateBlobKey = `${gcBlobPrefix}_root`;
-        const builder = new 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, SummaryType.Blob, `/${gcTreeKey}/${gcStateBlobKey}`);
-        }
-        else {
-            builder.addBlob(gcStateBlobKey, serializedGCState);
-        }
-        // If there is no tombstone data, return only the GC state.
-        if (serializedTombstones === undefined) {
-            return builder.getSummaryTree();
-        }
-        // If the tombstone state hasn't changed, write a summary handle, else write a summary blob for it.
-        if (((_b = this.latestSummaryData) === null || _b === void 0 ? void 0 : _b.serializedTombstones) === serializedTombstones && trackState) {
-            builder.addHandle(gcTombstoneBlobKey, SummaryType.Blob, `/${gcTreeKey}/${gcTombstoneBlobKey}`);
-        }
-        else {
-            builder.addBlob(gcTombstoneBlobKey, serializedTombstones);
-        }
-        return builder.getSummaryTree();
-    }
-    getMetadata() {
-        return {
-            /**
-             * 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,
-            sessionExpiryTimeoutMs: this.sessionExpiryTimeoutMs,
-            sweepEnabled: this.sweepEnabled,
-            sweepTimeoutMs: this.sweepTimeoutMs,
-        };
-    }
-    /**
-     * Returns a map of node ids to their base GC details generated from the base summary. This is used by the caller
-     * to initialize the GC state of the nodes.
-     */
-    async getBaseGCDetails() {
-        return this.baseGCDetailsP;
-    }
-    /**
-     * Called when the latest summary of the system has been refreshed. This will be used to update the state of the
-     * latest summary tracked.
-     */
-    async latestSummaryStateRefreshed(result, readAndParseBlob) {
-        if (!this.shouldRunGC || !result.latestSummaryUpdated) {
-            return;
-        }
-        // If the summary was tracked by this client, it was the one that generated the summary in the first place.
-        // Basically, it was written in the current GC version.
-        if (result.wasSummaryTracked) {
-            this.latestSummaryGCVersion = this.currentGCVersion;
-            this.initialStateNeedsReset = false;
-            if (this.trackGCState) {
-                this.latestSummaryData = this.pendingSummaryData;
-                this.pendingSummaryData = undefined;
-            }
-            return;
-        }
-        // If the summary was not tracked by this client, update latest GC version and blob from the snapshot in the
-        // result as that is now the latest summary.
-        const snapshot = result.snapshot;
-        const metadataBlobId = snapshot.blobs[metadataBlobName];
-        if (metadataBlobId) {
-            const metadata = await readAndParseBlob(metadataBlobId);
-            this.latestSummaryGCVersion = getGCVersion(metadata);
-        }
-        const gcSnapshotTree = snapshot.trees[gcTreeKey];
-        if (gcSnapshotTree !== undefined && this.trackGCState) {
-            const latestGCData = await getGCDataFromSnapshot(gcSnapshotTree, readAndParseBlob);
-            this.latestSummaryData = {
-                serializedGCState: JSON.stringify(generateSortedGCState(latestGCData.gcState)),
-                serializedTombstones: JSON.stringify(latestGCData.tombstones),
-            };
-        }
-        else {
-            this.latestSummaryData = undefined;
-        }
-        this.pendingSummaryData = undefined;
-    }
-    /**
-     * Called when a node with the given id is updated. If the node is inactive, log an error.
-     * @param nodePath - The id of the node that changed.
-     * @param reason - Whether the node was loaded or changed.
-     * @param timestampMs - The timestamp when the node changed.
-     * @param packagePath - The package path of the node. This may not be available if the node hasn't been loaded yet.
-     * @param requestHeaders - If the node was loaded via request path, the headers in the request.
-     */
-    nodeUpdated(nodePath, reason, timestampMs, packagePath, requestHeaders) {
-        if (!this.shouldRunGC) {
-            return;
-        }
-        const nodeStateTracker = this.unreferencedNodesState.get(nodePath);
-        if (nodeStateTracker && nodeStateTracker.state !== UnreferencedState.Active) {
-            this.inactiveNodeUsed(reason, nodePath, nodeStateTracker, undefined /* fromNodeId */, packagePath, timestampMs, requestHeaders);
-        }
-    }
-    /**
-     * Called when an outbound reference is added to a node. This is used to identify all nodes that have been
-     * referenced between summaries so that their unreferenced timestamp can be reset.
-     *
-     * @param fromNodePath - The node from which the reference is added.
-     * @param toNodePath - The node to which the reference is added.
-     */
-    addedOutboundReference(fromNodePath, toNodePath) {
-        var _a;
-        if (!this.shouldRunGC) {
-            return;
-        }
-        const outboundRoutes = (_a = this.newReferencesSinceLastRun.get(fromNodePath)) !== null && _a !== void 0 ? _a : [];
-        outboundRoutes.push(toNodePath);
-        this.newReferencesSinceLastRun.set(fromNodePath, outboundRoutes);
-        const nodeStateTracker = this.unreferencedNodesState.get(toNodePath);
-        if (nodeStateTracker && nodeStateTracker.state !== UnreferencedState.Active) {
-            this.inactiveNodeUsed("Revived", toNodePath, nodeStateTracker, fromNodePath);
-        }
-    }
-    dispose() {
-        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:
-     * 1. Sets up the current GC state as per the gcData.
-     * 2. Starts tracking for nodes that have become unreferenced in this run.
-     * 3. Clears tracking for nodes that were unreferenced but became referenced in this run.
-     * @param gcData - The data representing the reference graph on which GC is run.
-     * @param gcResult - The result of the GC run on the gcData.
-     * @param currentReferenceTimestampMs - The timestamp to be used for unreferenced nodes' timestamp.
-     */
-    updateCurrentState(gcData, gcResult, currentReferenceTimestampMs) {
-        this.previousGCDataFromLastRun = cloneGCData(gcData);
-        this.tombstones = [];
-        this.newReferencesSinceLastRun.clear();
-        // Iterate through the referenced nodes and stop tracking if they were unreferenced before.
-        for (const nodeId of gcResult.referencedNodeIds) {
-            const nodeStateTracker = this.unreferencedNodesState.get(nodeId);
-            if (nodeStateTracker !== undefined) {
-                // Stop tracking so as to clear out any running timers.
-                nodeStateTracker.stopTracking();
-                // Delete the node as we don't need to track it any more.
-                this.unreferencedNodesState.delete(nodeId);
-            }
-        }
-        /**
-         * 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
-         * from the ops seen, this will ensure that we keep updating the unreferenced state as time moves forward.
-         */
-        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));
-            }
-            else {
-                nodeStateTracker.updateTracking(currentReferenceTimestampMs);
-                if (this.tombstoneMode && nodeStateTracker.state === UnreferencedState.SweepReady) {
-                    const nodeType = this.runtime.getNodeType(nodeId);
-                    if (nodeType === GCNodeType.DataStore || nodeType === GCNodeType.Blob) {
-                        this.tombstones.push(nodeId);
-                    }
-                }
-            }
-        }
-    }
-    /**
-     * Since GC runs periodically, the GC data that is generated only tells us the state of the world at that point in
-     * time. There can be nodes that were referenced in between two runs and their unreferenced state needs to be
-     * updated. For example, in the following scenarios not updating the unreferenced timestamp can lead to deletion of
-     * these objects while there can be in-memory referenced to it:
-     * 1. A node transitions from `unreferenced -> referenced -> unreferenced` between two runs. When the reference is
-     * added, the object may have been accessed and in-memory reference to it added.
-     * 2. A reference is added from one unreferenced node to one or more unreferenced nodes. Even though the node[s] were
-     * unreferenced, they could have been accessed and in-memory reference to them added.
-     *
-     * This function identifies nodes that were referenced since last run and removes their unreferenced state, if any.
-     * If these nodes are currently unreferenced, they will be assigned new unreferenced state by the current run.
-     */
-    updateStateSinceLastRun(currentGCData, logger) {
-        // If we haven't run GC before there is nothing to do.
-        if (this.previousGCDataFromLastRun === undefined) {
-            return;
-        }
-        // Find any references that haven't been identified correctly.
-        const missingExplicitReferences = this.findMissingExplicitReferences(currentGCData, this.previousGCDataFromLastRun, this.newReferencesSinceLastRun);
-        if (missingExplicitReferences.length > 0) {
-            missingExplicitReferences.forEach((missingExplicitReference) => {
-                const event = {
-                    eventName: "gcUnknownOutboundReferences",
-                    gcNodeId: missingExplicitReference[0],
-                    gcRoutes: JSON.stringify(missingExplicitReference[1]),
-                };
-                logger.sendPerformanceEvent(event);
-            });
-        }
-        // No references were added since the last run so we don't have to update reference states of any unreferenced
-        // nodes
-        if (this.newReferencesSinceLastRun.size === 0) {
-            return;
-        }
-        /**
-         * Generate a super set of the GC data that contains the nodes and edges from last run, plus any new node and
-         * edges that have been added since then. To do this, combine the GC data from the last run and the current
-         * 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 they were 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 they were 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.
-         * - A new data store may have "root" DDSes already created and we don't detect them today.
-         */
-        const gcDataSuperSet = concatGarbageCollectionData(this.previousGCDataFromLastRun, currentGCData);
-        const newOutboundRoutesSinceLastRun = [];
-        this.newReferencesSinceLastRun.forEach((outboundRoutes, sourceNodeId) => {
-            if (gcDataSuperSet.gcNodes[sourceNodeId] === undefined) {
-                gcDataSuperSet.gcNodes[sourceNodeId] = outboundRoutes;
-            }
-            else {
-                gcDataSuperSet.gcNodes[sourceNodeId].push(...outboundRoutes);
-            }
-            newOutboundRoutesSinceLastRun.push(...outboundRoutes);
-        });
-        /**
-         * Run GC on the above reference graph starting with root and all new outbound routes. This will generate a
-         * list of all nodes that could have been referenced since the last run. If any of these nodes are unreferenced,
-         * unreferenced, stop tracking them and remove from unreferenced list.
-         * Note that some of these nodes may be unreferenced now and if so, the current run will mark them as
-         * unreferenced and add unreferenced state.
-         */
-        const gcResult = runGarbageCollection(gcDataSuperSet.gcNodes, ["/", ...newOutboundRoutesSinceLastRun]);
-        for (const nodeId of gcResult.referencedNodeIds) {
-            const nodeStateTracker = this.unreferencedNodesState.get(nodeId);
-            if (nodeStateTracker !== undefined) {
-                // Stop tracking so as to clear out any running timers.
-                nodeStateTracker.stopTracking();
-                // Delete the unreferenced state as we don't need to track it any more.
-                this.unreferencedNodesState.delete(nodeId);
-            }
-        }
-    }
-    /**
-     * Finds all new references or outbound routes in the current graph that haven't been explicitly notified to GC.
-     * The principle is that every new reference or outbound route must be notified to GC via the
-     * addedOutboundReference method. It it hasn't, its a bug and we want to identify these scenarios.
-     *
-     * In more simple terms:
-     * Missing Explicit References = Current References - Previous References - Explicitly Added References;
-     *
-     * @param currentGCData - The GC data (reference graph) from the current GC run.
-     * @param previousGCData - The GC data (reference graph) from the previous GC run.
-     * @param explicitReferences - New references added explicity between the previous and the current run.
-     * @returns - a list of missing explicit references
-     */
-    findMissingExplicitReferences(currentGCData, previousGCData, explicitReferences) {
-        assert(previousGCData !== undefined, 0x2b7);
-        const currentGraph = Object.entries(currentGCData.gcNodes);
-        const missingExplicitReferences = [];
-        currentGraph.forEach(([nodeId, currentOutboundRoutes]) => {
-            var _a, _b;
-            const previousRoutes = (_a = previousGCData.gcNodes[nodeId]) !== null && _a !== void 0 ? _a : [];
-            const explicitRoutes = (_b = explicitReferences.get(nodeId)) !== null && _b !== void 0 ? _b : [];
-            const missingExplicitRoutes = [];
-            currentOutboundRoutes.forEach((route) => {
-                const isBlobOrDataStoreRoute = this.runtime.getNodeType(route) === GCNodeType.Blob ||
-                    this.runtime.getNodeType(route) === GCNodeType.DataStore;
-                // Ignore implicitly added DDS routes to their parent datastores
-                const notRouteFromDDSToParentDataStore = !nodeId.startsWith(route);
-                if (isBlobOrDataStoreRoute &&
-                    notRouteFromDDSToParentDataStore &&
-                    (!previousRoutes.includes(route) && !explicitRoutes.includes(route))) {
-                    missingExplicitRoutes.push(route);
-                }
-            });
-            if (missingExplicitRoutes.length > 0) {
-                missingExplicitReferences.push([nodeId, missingExplicitRoutes]);
-            }
-        });
-        // Ideally missingExplicitReferences should always have a size 0
-        return missingExplicitReferences;
-    }
-    /**
-     * Generates the stats of a garbage collection run from the given results of the run.
-     * @param gcResult - The result of a GC run.
-     * @returns the GC stats of the GC run.
-     */
-    generateStats(gcResult) {
-        const gcStats = {
-            nodeCount: 0,
-            dataStoreCount: 0,
-            attachmentBlobCount: 0,
-            unrefNodeCount: 0,
-            unrefDataStoreCount: 0,
-            unrefAttachmentBlobCount: 0,
-            updatedNodeCount: 0,
-            updatedDataStoreCount: 0,
-            updatedAttachmentBlobCount: 0,
-        };
-        const updateNodeStats = (nodeId, referenced) => {
-            gcStats.nodeCount++;
-            // If there is no previous GC data, every node's state is generated and is considered as updated.
-            // Otherwise, find out if any node went from referenced to unreferenced or vice-versa.
-            const stateUpdated = this.previousGCDataFromLastRun === undefined ||
-                this.unreferencedNodesState.has(nodeId) === referenced;
-            if (stateUpdated) {
-                gcStats.updatedNodeCount++;
-            }
-            if (!referenced) {
-                gcStats.unrefNodeCount++;
-            }
-            if (this.runtime.getNodeType(nodeId) === GCNodeType.DataStore) {
-                gcStats.dataStoreCount++;
-                if (stateUpdated) {
-                    gcStats.updatedDataStoreCount++;
-                }
-                if (!referenced) {
-                    gcStats.unrefDataStoreCount++;
-                }
-            }
-            if (this.runtime.getNodeType(nodeId) === GCNodeType.Blob) {
-                gcStats.attachmentBlobCount++;
-                if (stateUpdated) {
-                    gcStats.updatedAttachmentBlobCount++;
-                }
-                if (!referenced) {
-                    gcStats.unrefAttachmentBlobCount++;
-                }
-            }
-        };
-        for (const nodeId of gcResult.referencedNodeIds) {
-            updateNodeStats(nodeId, true /* referenced */);
-        }
-        for (const nodeId of gcResult.deletedNodeIds) {
-            updateNodeStats(nodeId, false /* referenced */);
-        }
-        return gcStats;
-    }
-    /**
-     * For nodes that are ready to sweep, log an event for now. Until we start running sweep which deletes objects,
-     * this will give us a view into how much deleted content a container has.
-     */
-    logSweepEvents(logger, currentReferenceTimestampMs) {
-        if (this.mc.config.getBoolean(disableSweepLogKey) === true || this.sweepTimeoutMs === undefined) {
-            return;
-        }
-        this.unreferencedNodesState.forEach((nodeStateTracker, nodeId) => {
-            if (nodeStateTracker.state !== UnreferencedState.SweepReady) {
-                return;
-            }
-            const nodeType = this.runtime.getNodeType(nodeId);
-            if (nodeType !== GCNodeType.DataStore && nodeType !== GCNodeType.Blob) {
-                return;
-            }
-            // Log deleted event for each node only once to reduce noise in telemetry.
-            const uniqueEventId = `Deleted-${nodeId}`;
-            if (this.loggedUnreferencedEvents.has(uniqueEventId)) {
-                return;
-            }
-            this.loggedUnreferencedEvents.add(uniqueEventId);
-            logger.sendTelemetryEvent({
-                eventName: "GCObjectDeleted",
-                id: nodeId,
-                type: nodeType,
-                age: currentReferenceTimestampMs - nodeStateTracker.unreferencedTimestampMs,
-                timeout: this.sweepTimeoutMs,
-                completedGCRuns: this.completedRuns,
-                lastSummaryTime: this.getLastSummaryTimestampMs(),
-            });
-        });
-    }
-    /**
-     * Called when an inactive node is used after. Queue up an event that will be logged next time GC runs.
-     */
-    inactiveNodeUsed(usageType, nodeId, nodeStateTracker, fromNodeId, packagePath, currentReferenceTimestampMs = this.runtime.getCurrentReferenceTimestampMs(), requestHeaders) {
-        // 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;
-        }
-        // 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 !== GCNodeType.DataStore && nodeType !== GCNodeType.Blob) {
-            return;
-        }
-        const state = nodeStateTracker.state;
-        const uniqueEventId = `${state}-${nodeId}-${usageType}`;
-        if (this.loggedUnreferencedEvents.has(uniqueEventId)) {
-            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 === UnreferencedState.Inactive
-                ? this.inactiveTimeoutMs
-                : this.sweepTimeoutMs, completedGCRuns: this.completedRuns, lastSummaryTime: this.getLastSummaryTimestampMs() }, this.createContainerMetadata), { externalRequest: requestHeaders === null || requestHeaders === void 0 ? void 0 : requestHeaders[RuntimeHeaders.externalRequest], viaHandle: requestHeaders === null || requestHeaders === void 0 ? void 0 : requestHeaders[RuntimeHeaders.viaHandle], fromId: fromNodeId });
-        // For summarizer client, queue the event so it is logged the next time GC runs if the event is still valid.
-        // For non-summarizer client, log the event now since GC won't run on it. This may result in false positives
-        // but it's a good signal nonetheless and we can consume it with a grain of salt.
-        // Inactive errors are usages of Objects that are unreferenced for at least a period of 7 days.
-        // SweepReady errors are usages of Objects that will be deleted by GC Sweep!
-        if (this.isSummarizerClient) {
-            this.pendingEventsQueue.push(Object.assign(Object.assign({}, propsToLog), { usageType, state }));
-        }
-        else {
-            // For non-summarizer clients, only log "Loaded" type events since these objects may not be loaded in the
-            // summarizer clients if they are based off of user actions (such as scrolling to content for these objects)
-            // Events generated:
-            // InactiveObject_Loaded, SweepReadyObject_Loaded
-            if (usageType === "Loaded") {
-                this.mc.logger.sendErrorEvent(Object.assign(Object.assign({}, propsToLog), { eventName: `${state}Object_${usageType}`, pkg: packagePathToTelemetryProperty(packagePath), stack: generateStack() }));
-            }
-            // If SweepReady Usage Detection is enabed, the handler may close the interactive container.
-            // Once Sweep is fully implemented, this will be removed since the objects will be gone
-            // and errors will arise elsewhere in the runtime
-            if (state === UnreferencedState.SweepReady) {
-                this.sweepReadyUsageHandler.usageDetectedInInteractiveClient(Object.assign(Object.assign({}, propsToLog), { usageType }));
-            }
-        }
-    }
-    async logUnreferencedEvents(logger) {
-        // Events sent come only from the summarizer client. In between summaries, events are pushed to a queue and at
-        // summary time they are then logged.
-        // Events generated:
-        // InactiveObject_Loaded, InactiveObject_Changed, InactiveObject_Revived
-        // SweepReadyObject_Loaded, SweepReadyObject_Changed, SweepReadyObject_Revived
-        for (const eventProps of this.pendingEventsQueue) {
-            const { usageType, state } = eventProps, propsToLog = __rest(eventProps, ["usageType", "state"]);
-            /**
-             * Revived event is logged only if the node is active. If the node is not active, the reference to it was
-             * from another unreferenced node and this scenario is not interesting to log.
-             * Loaded and Changed events are logged only if the node is not active. If the node is active, it was
-             * 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;
-            if ((usageType === "Revived") === active) {
-                const pkg = await this.getNodePackagePath(eventProps.id);
-                const fromPkg = eventProps.fromId ? await this.getNodePackagePath(eventProps.fromId) : undefined;
-                logger.sendErrorEvent(Object.assign(Object.assign({}, propsToLog), { eventName: `${state}Object_${usageType}`, pkg: pkg ? { value: pkg.join("/"), tag: TelemetryDataTag.CodeArtifact } : undefined, fromPkg: fromPkg ? { value: fromPkg.join("/"), tag: TelemetryDataTag.CodeArtifact } : undefined }));
-            }
-        }
-        this.pendingEventsQueue = [];
-    }
-}
-/**
- * Gets the base garbage collection state from the given snapshot tree. It contains GC state and tombstone state.
- * The GC state may be written into multiple blobs. Merge the GC state from all such blobs into one.
- */
-async function getGCDataFromSnapshot(gcSnapshotTree, readAndParseBlob) {
-    let rootGCState = { gcNodes: {} };
-    let tombstones;
-    for (const key of Object.keys(gcSnapshotTree.blobs)) {
-        if (key === gcTombstoneBlobKey) {
-            tombstones = await readAndParseBlob(gcSnapshotTree.blobs[key]);
-            continue;
-        }
-        // Skip blobs that do not start with the GC prefix.
-        if (!key.startsWith(gcBlobPrefix)) {
-            continue;
-        }
-        const blobId = gcSnapshotTree.blobs[key];
-        if (blobId === undefined) {
-            continue;
-        }
-        const gcState = await readAndParseBlob(blobId);
-        assert(gcState !== undefined, 0x2ad /* "GC blob missing from snapshot" */);
-        // Merge the GC state of this blob into the root GC state.
-        rootGCState = concatGarbageCollectionStates(rootGCState, gcState);
-    }
-    return { gcState: rootGCState, tombstones };
-}
-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 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