@fluidframework/container-runtime 2.0.0-dev.2.2.0.111723 → 2.0.0-dev.3.1.0.125672

package/lib/garbageCollection.js

@@ -14,44 +14,18 @@ var __rest = (this && this.__rest) || function (s, e) {
     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 { ClientSessionExpiredError, DataProcessingError, UsageError, } from "@fluidframework/container-utils";
+import { cloneGCData, concatGarbageCollectionData, getGCDataFromSnapshot, runGarbageCollection, trimLeadingSlashes, } from "@fluidframework/garbage-collector";
 import { SummaryType } from "@fluidframework/protocol-definitions";
-import { gcBlobKey, } from "@fluidframework/runtime-definitions";
+import { gcTreeKey, gcBlobPrefix, gcTombstoneBlobKey, gcDeletedBlobKey, } 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 { currentGCVersion, defaultInactiveTimeoutMs, defaultSessionExpiryDurationMs, disableSweepLogKey, disableTombstoneKey, gcVersionUpgradeToV2Key, gcTestModeKey, oneDayMs, runGCKey, runSessionExpiryKey, runSweepKey, stableGCVersion, trackGCStateKey, } from "./garbageCollectionConstants";
+import { sendGCUnexpectedUsageEvent } from "./garbageCollectionHelpers";
 import { SweepReadyUsageDetectionHandler } from "./gcSweepReadyUsageDetection";
 import { getGCVersion, metadataBlobName, dataStoreAttributesBlobName, } from "./summaryFormat";
-/** This is the current version of garbage collection. */
-const GCVersion = 1;
-// The key for the GC tree in summary.
-export const gcTreeKey = "gc";
-// They prefix for GC blobs in the GC tree in summary.
-export const gcBlobPrefix = "__gc";
-// The key for tombstone blob in the GC tree in summary.
-export const gcTombstoneBlobKey = "__tombstones";
-// Feature gate key to turn GC on / off.
-export const runGCKey = "Fluid.GarbageCollection.RunGC";
-// Feature gate key to turn GC sweep on / off.
-export const runSweepKey = "Fluid.GarbageCollection.RunSweep";
-// Feature gate key to turn GC test mode on / off.
-export const gcTestModeKey = "Fluid.GarbageCollection.GCTestMode";
-// Feature gate key to expire a session after a set period of time.
-export const runSessionExpiryKey = "Fluid.GarbageCollection.RunSessionExpiry";
-// Feature gate key to write the gc blob as a handle if the data is the same.
-export const trackGCStateKey = "Fluid.GarbageCollection.TrackGCState";
-// Feature gate key to turn GC sweep log off.
-export const disableSweepLogKey = "Fluid.GarbageCollection.DisableSweepLog";
-// Feature gate key to disable the tombstone feature, i.e., tombstone information is not read / written into summary.
-export const disableTombstoneKey = "Fluid.GarbageCollection.DisableTombstone";
-// Feature gate to enable throwing an error when tombstone object is used.
-export const throwOnTombstoneUsageKey = "Fluid.GarbageCollection.ThrowOnTombstoneUsage";
-// One day in milliseconds.
-export const oneDayMs = 1 * 24 * 60 * 60 * 1000;
-export const defaultInactiveTimeoutMs = 7 * oneDayMs; // 7 days
-export const defaultSessionExpiryDurationMs = 30 * oneDayMs; // 30 days
 /** The types of GC nodes in the GC reference graph. */
 export const GCNodeType = {
     // Nodes that are for data stores.
@@ -164,25 +138,13 @@ export class UnreferencedStateTracker {
 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();
+        // A list of nodes that have been tombstoned.
         this.tombstones = [];
+        // A list of nodes that have been deleted during sweep phase.
+        this.deletedNodes = new Set();
         // 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
@@ -202,7 +164,14 @@ export class GarbageCollector {
         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.mc = loggerToMonitoringContext(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(gcVersionUpgradeToV2Key) === true
+                ? currentGCVersion
+                : stableGCVersion;
         this.sweepReadyUsageHandler = new SweepReadyUsageDetectionHandler(createParams.getContainerDiagnosticId(), this.mc, this.runtime.closeFn);
         let prevSummaryGCVersion;
         /**
@@ -216,8 +185,8 @@ export class GarbageCollector {
         function computeSweepTimeout(sessionExpiryTimeoutMs) {
             const maxSnapshotCacheExpiryMs = 5 * oneDayMs;
             const bufferMs = oneDayMs;
-            return sessionExpiryTimeoutMs &&
-                (sessionExpiryTimeoutMs + maxSnapshotCacheExpiryMs + bufferMs);
+            return (sessionExpiryTimeoutMs &&
+                sessionExpiryTimeoutMs + maxSnapshotCacheExpiryMs + bufferMs);
         }
         /**
          * The following GC state is enabled during container creation and cannot be changed throughout its lifetime:
@@ -248,11 +217,11 @@ export class GarbageCollector {
             // 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;
+            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(runSessionExpiryKey) && this.gcEnabled) {
-                this.sessionExpiryTimeoutMs = (_c = this.gcOptions.sessionExpiryTimeoutMs) !== null && _c !== void 0 ? _c : defaultSessionExpiryDurationMs;
+                this.sessionExpiryTimeoutMs =
+                    (_c = this.gcOptions.sessionExpiryTimeoutMs) !== null && _c !== void 0 ? _c : defaultSessionExpiryDurationMs;
             }
             this.sweepTimeoutMs =
                 testOverrideSweepTimeoutMs !== null && testOverrideSweepTimeoutMs !== void 0 ? testOverrideSweepTimeoutMs : computeSweepTimeout(this.sessionExpiryTimeoutMs);
@@ -262,7 +231,9 @@ export class GarbageCollector {
             // If Test Override config is set, override Session Expiry timeout.
             const overrideSessionExpiryTimeoutMs = this.mc.config.getNumber("Fluid.GarbageCollection.TestOverride.SessionExpiryMs");
             const timeoutMs = overrideSessionExpiryTimeoutMs !== null && overrideSessionExpiryTimeoutMs !== void 0 ? overrideSessionExpiryTimeoutMs : this.sessionExpiryTimeoutMs;
-            this.sessionExpiryTimer = new Timer(timeoutMs, () => { this.runtime.closeFn(new ClientSessionExpiredError(`Client session expired.`, timeoutMs)); });
+            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
@@ -277,11 +248,12 @@ export class GarbageCollector {
          *
          * 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);
+        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:
          *
@@ -293,24 +265,26 @@ export class GarbageCollector {
          * feature flag.
          */
         this.shouldRunSweep =
-            this.shouldRunGC
-                && this.sweepTimeoutMs !== undefined
-                && ((_e = this.mc.config.getBoolean(runSweepKey)) !== null && _e !== void 0 ? _e : this.sweepEnabled);
+            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;
+        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;
+        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 enabled by default if sweep won't run. It can be disabled
+        // via feature flags.
+        this.tombstoneMode =
+            !this.shouldRunSweep && this.mc.config.getBoolean(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[gcTreeKey]) !== undefined;
         // 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 () => {
@@ -327,11 +301,13 @@ export class GarbageCollector {
                 // 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 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];
+                    const blobId = dsSnapshotTree.blobs[gcTreeKey];
                     if (blobId === undefined) {
                         continue;
                     }
@@ -351,14 +327,19 @@ export class GarbageCollector {
                         // 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) };
+                        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;
+                    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 };
+                return Object.keys(gcState.gcNodes).length === 1
+                    ? undefined
+                    : { gcState, tombstones: undefined, deletedNodes: undefined };
             }
             catch (error) {
                 const dpe = DataProcessingError.wrapIfUnrecognized(error, "FailedToInitializeGC");
@@ -372,7 +353,6 @@ export class GarbageCollector {
          * 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.
@@ -381,6 +361,7 @@ export class GarbageCollector {
              * 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.
                 this.mc.logger.sendErrorEvent({
@@ -389,38 +370,24 @@ export class GarbageCollector {
                 });
                 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.
              */
+            const baseSnapshotData = await this.baseSnapshotDataP;
             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),
-                };
-            }
+            this.updateStateFromSnapshotData(baseSnapshotData, currentReferenceTimestampMs);
         });
-        // 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.
+        // Get the GC details from the GC state in the base summary. This is returned in getBaseGCDetails which is
+        // used to initialize the GC state of all the nodes in the container.
         this.baseGCDetailsP = new LazyPromise(async () => {
             const baseSnapshotData = await this.baseSnapshotDataP;
             if (baseSnapshotData === undefined) {
-                return new Map();
+                return {};
             }
             const gcNodes = {};
             for (const [nodeId, nodeData] of Object.entries(baseSnapshotData.gcState.gcNodes)) {
@@ -430,18 +397,7 @@ export class GarbageCollector {
             // 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;
+            return { gcData: { gcNodes }, usedRoutes };
         });
         // 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.
@@ -462,39 +418,143 @@ export class GarbageCollector {
      *
      * 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. 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:
      *
-     * 3.1. The summary this client loaded with has data from a different GC version.
+     * 4.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.
+     * 4.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);
+        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);
     }
     /**
-     * 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.
+     * 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.
      */
     async initializeBaseState() {
         const baseSnapshotData = await this.baseSnapshotDataP;
         /**
-         * The base snapshot data or tombstone state will not be present if the container is loaded from:
+         * The base snapshot data will not be present if the container is loaded from:
          * 1. The first summary created by the detached container.
          * 2. A summary that was generated with GC disabled.
          * 3. A summary that was generated before GC even existed.
-         * 4. A summary that was generated with tombstone feature disabled.
          */
-        if (!this.tombstoneMode || (baseSnapshotData === null || baseSnapshotData === void 0 ? void 0 : baseSnapshotData.tombstones) === undefined) {
+        if (baseSnapshotData === undefined) {
             return;
         }
-        this.tombstones = baseSnapshotData.tombstones;
-        this.runtime.updateUnusedRoutes(this.tombstones, true /* tombstone */);
+        // Initialize the deleted nodes from the snapshot. This is done irrespective of whether sweep is enabled or not
+        // to identify deleted nodes' usage.
+        if (baseSnapshotData.deletedNodes !== undefined) {
+            this.deletedNodes = new Set(baseSnapshotData.deletedNodes);
+        }
+        // If running in tombstone mode, initialize the tombstone state from the snapshot. Also, notify the runtime of
+        // tombstone routes.
+        if (this.tombstoneMode && baseSnapshotData.tombstones !== undefined) {
+            this.tombstones = Array.from(baseSnapshotData.tombstones);
+            this.runtime.updateTombstonedRoutes(this.tombstones);
+        }
+    }
+    /**
+     * Update state from the given snapshot data. This is done during load and during refreshing state from a snapshot.
+     * All current tracking is reset and updated from the data in the snapshot.
+     * @param snapshotData - The snapshot data to update state from. If this is undefined, all GC state and tracking
+     * is reset.
+     * @param currentReferenceTimestampMs - The current reference timestamp for marking unreferenced nodes' unreferenced
+     * timestamp.
+     */
+    updateStateFromSnapshotData(snapshotData, currentReferenceTimestampMs) {
+        /**
+         * Note: "newReferencesSinceLastRun" is not reset here. This is done because there may be references since the
+         * snapshot that we are updating state from. For example, this client may have processed ops till seq#1000 and
+         * its refreshing state from a summary that happened at seq#900. In this case, there may be references between
+         * seq#901 and seq#1000 that we don't want to reset.
+         * Unfortunately, there is no way to track the seq# of ops that add references, so we choose to not reset any
+         * references here. This should be fine because, in the worst case, we may end up updating the unreferenced
+         * timestamp of a node which will delay its deletion. Although not ideal, this will only happen in rare
+         * scenarios, so it should be okay.
+         */
+        // Clear all existing unreferenced state tracking.
+        for (const [, nodeStateTracker] of this.unreferencedNodesState) {
+            nodeStateTracker.stopTracking();
+        }
+        this.unreferencedNodesState.clear();
+        // If running sweep, the tombstone state represents the list of nodes that have been deleted during sweep.
+        // If running in tombstone mode, the tombstone state represents the list of nodes that have been marked as
+        // tombstones.
+        // If this call is because we are refreshing from a snapshot due to an ack, it is likely that the GC state
+        // in the snapshot is newer than this client's. And so, the deleted / tombstone nodes need to be updated.
+        if (this.shouldRunSweep) {
+            const snapshotDeletedNodes = (snapshotData === null || snapshotData === void 0 ? void 0 : snapshotData.tombstones)
+                ? new Set(snapshotData.tombstones)
+                : undefined;
+            // If the snapshot contains deleted nodes that are not yet deleted by this client, ask the runtime to
+            // delete them.
+            if (snapshotDeletedNodes !== undefined) {
+                const newDeletedNodes = [];
+                for (const nodeId of snapshotDeletedNodes) {
+                    if (!this.deletedNodes.has(nodeId)) {
+                        newDeletedNodes.push(nodeId);
+                    }
+                }
+                if (newDeletedNodes.length > 0) {
+                    // Call container runtime to delete these nodes and add deleted nodes to this.deletedNodes.
+                }
+            }
+        }
+        else if (this.tombstoneMode) {
+            // The snapshot may contain more or fewer tombstone nodes than this client. Update tombstone state and
+            // notify the runtime to update its state as well.
+            this.tombstones = (snapshotData === null || snapshotData === void 0 ? void 0 : snapshotData.tombstones) ? Array.from(snapshotData.tombstones) : [];
+            this.runtime.updateTombstonedRoutes(this.tombstones);
+        }
+        // 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
+        // to the GC data from the snapshot data.
+        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));
+            }
+            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
@@ -528,7 +588,9 @@ export class GarbageCollector {
         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 } })
+            ? 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
@@ -580,13 +642,13 @@ export class GarbageCollector {
         // If we are running in GC test mode, delete objects for unused routes. This enables testing scenarios
         // involving access to deleted data.
         if (this.testMode) {
-            this.runtime.updateUnusedRoutes(gcResult.deletedNodeIds, false /* tombstone */);
+            this.runtime.updateUnusedRoutes(gcResult.deletedNodeIds);
         }
         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 */);
+            // If we are running in GC tombstone mode, update tombstoned 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.updateTombstonedRoutes(this.tombstones);
         }
         // 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
@@ -601,30 +663,44 @@ export class GarbageCollector {
      */
     summarize(fullTree, trackState, telemetryContext) {
         var _a;
-        if (!this.shouldRunGC || this.previousGCDataFromLastRun === undefined) {
+        if (!this.shouldRunGC || this.gcDataFromLastRun === undefined) {
             return;
         }
         const gcState = { gcNodes: {} };
-        for (const [nodeId, outboundRoutes] of Object.entries(this.previousGCDataFromLastRun.gcNodes)) {
+        for (const [nodeId, outboundRoutes] of Object.entries(this.gcDataFromLastRun.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));
+        // 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)
+            ? 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.
+         * 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 };
+            this.pendingSummaryData = {
+                serializedGCState,
+                serializedTombstones,
+                serializedDeletedNodes,
+            };
             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) {
+                // 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 = mergeStats();
                     stats.handleNodeCount++;
                     return {
@@ -636,24 +712,25 @@ export class GarbageCollector {
                         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 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, false /* trackState */);
+        return this.buildGCSummaryTree(serializedGCState, serializedTombstones, serializedDeletedNodes, 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.
+     * 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 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, trackState) {
-        var _a, _b;
+    buildGCSummaryTree(serializedGCState, serializedTombstones, serializedDeletedNodes, trackState) {
+        var _a, _b, _c;
         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.
@@ -663,16 +740,28 @@ export class GarbageCollector {
         else {
             builder.addBlob(gcStateBlobKey, serializedGCState);
         }
-        // If there is no tombstone data, return only the GC state.
-        if (serializedTombstones === undefined) {
+        // 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(gcTombstoneBlobKey, SummaryType.Blob, `/${gcTreeKey}/${gcTombstoneBlobKey}`);
+            }
+            else {
+                builder.addBlob(gcTombstoneBlobKey, serializedTombstones);
+            }
+        }
+        // If there are no deleted nodes, return the summary tree.
+        if (serializedDeletedNodes === 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}`);
+        // 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(gcDeletedBlobKey, SummaryType.Blob, `/${gcTreeKey}/${gcDeletedBlobKey}`);
         }
         else {
-            builder.addBlob(gcTombstoneBlobKey, serializedTombstones);
+            builder.addBlob(gcDeletedBlobKey, serializedDeletedNodes);
         }
         return builder.getSummaryTree();
     }
@@ -689,50 +778,58 @@ export class GarbageCollector {
         };
     }
     /**
-     * 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.
+     * Returns a the GC details generated from the base summary. This is used to initialize the GC state of the nodes
+     * in the container.
      */
     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.
+     * Called to refresh the latest summary state. This happens when either a pending summary is acked or a snapshot
+     * is downloaded and should be used to update the state.
      */
-    async latestSummaryStateRefreshed(result, readAndParseBlob) {
-        if (!this.shouldRunGC || !result.latestSummaryUpdated) {
+    async refreshLatestSummary(result, proposalHandle, summaryRefSeq, 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.
-        // Basically, it was written in the current GC version.
+        // Update latest state from pending.
         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.
+        // If the summary was not tracked by this client, the state should be updated from the downloaded snapshot.
         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),
-            };
+        // 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 DataProcessingError.create("No reference timestamp when updating GC state from snapshot", "refreshLatestSummary", undefined, { proposalHandle, summaryRefSeq, details: JSON.stringify(this.configs) });
         }
-        else {
-            this.latestSummaryData = undefined;
+        const gcSnapshotTree = snapshot.trees[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 getGCDataFromSnapshot(gcSnapshotTree, readAndParseBlob);
         }
+        this.updateStateFromSnapshotData(latestGCData, currentReferenceTimestampMs);
         this.pendingSummaryData = undefined;
     }
     /**
@@ -771,6 +868,30 @@ export class GarbageCollector {
         if (nodeStateTracker && nodeStateTracker.state !== 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 === GCNodeType.DataStore) {
+                eventName = "GC_Tombstone_Datastore_Revived";
+            }
+            else if (nodeType === GCNodeType.Blob) {
+                eventName = "GC_Tombstone_Blob_Revived";
+            }
+            sendGCUnexpectedUsageEvent(this.mc, {
+                eventName,
+                category: "generic",
+                isSummarizerClient: this.isSummarizerClient,
+                url: trimLeadingSlashes(toNodePath),
+                nodeType,
+            }, undefined /* packagePath */);
+        }
+    }
+    /**
+     * Returns whether a node with the given path has been deleted or not. This can be used by the runtime to identify
+     * cases where objects are used after they are deleted and throw / log errors accordingly.
+     */
+    isNodeDeleted(nodePath) {
+        return this.deletedNodes.has(nodePath);
     }
     dispose() {
         var _a;
@@ -787,7 +908,7 @@ export class GarbageCollector {
      * @param currentReferenceTimestampMs - The timestamp to be used for unreferenced nodes' timestamp.
      */
     updateCurrentState(gcData, gcResult, currentReferenceTimestampMs) {
-        this.previousGCDataFromLastRun = cloneGCData(gcData);
+        this.gcDataFromLastRun = cloneGCData(gcData);
         this.tombstones = [];
         this.newReferencesSinceLastRun.clear();
         // Iterate through the referenced nodes and stop tracking if they were unreferenced before.
@@ -823,27 +944,31 @@ export class GarbageCollector {
     }
     /**
      * Since GC runs periodically, the GC data that is generated only tells us the state of the world at that point in
-     * time. It's possible that nodes transition from `unreferenced -> referenced -> unreferenced` between two runs. The
-     * unreferenced timestamp of such nodes needs to be reset as they may have been accessed when they were referenced.
+     * 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) {
+        if (this.gcDataFromLastRun === undefined) {
             return;
         }
         // Find any references that haven't been identified correctly.
-        const missingExplicitReferences = this.findMissingExplicitReferences(currentGCData, this.previousGCDataFromLastRun, this.newReferencesSinceLastRun);
+        const missingExplicitReferences = this.findMissingExplicitReferences(currentGCData, this.gcDataFromLastRun, this.newReferencesSinceLastRun);
         if (missingExplicitReferences.length > 0) {
             missingExplicitReferences.forEach((missingExplicitReference) => {
-                const event = {
+                logger.sendErrorEvent({
                     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
@@ -857,21 +982,18 @@ export class GarbageCollector {
          * run, and then add the references since last run.
          *
          * Note on why we need to combine the data from previous run, current run and all references in between -
-         *
          * 1. We need data from last run because some of its references may have been deleted since then. If those
-         * references added new outbound references before getting deleted, we need to detect them.
+         * references added new outbound references before 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 getting deleted, we need to detect them.
+         * 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. For this, we need GC at DDS level
-         * which is tracked by https://github.com/microsoft/FluidFramework/issues/8470.
-         *
+         * - 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 gcDataSuperSet = concatGarbageCollectionData(this.gcDataFromLastRun, currentGCData);
+        const newOutboundRoutesSinceLastRun = [];
         this.newReferencesSinceLastRun.forEach((outboundRoutes, sourceNodeId) => {
             if (gcDataSuperSet.gcNodes[sourceNodeId] === undefined) {
                 gcDataSuperSet.gcNodes[sourceNodeId] = outboundRoutes;
@@ -879,19 +1001,25 @@ export class GarbageCollector {
             else {
                 gcDataSuperSet.gcNodes[sourceNodeId].push(...outboundRoutes);
             }
+            newOutboundRoutesSinceLastRun.push(...outboundRoutes);
         });
         /**
-         * Run GC on the above reference graph to find all nodes that are referenced. For each one, if they are
+         * 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.
-         * Some of these nodes may be unreferenced now and if so, the current run will add unreferenced state for them.
+         * 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, ["/"]);
+        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 node as we don't need to track it any more.
+                // Delete the unreferenced state as we don't need to track it any more.
                 this.unreferencedNodesState.delete(nodeId);
             }
         }
@@ -910,7 +1038,7 @@ export class GarbageCollector {
      * @returns - a list of missing explicit references
      */
     findMissingExplicitReferences(currentGCData, previousGCData, explicitReferences) {
-        assert(previousGCData !== undefined, 0x2b7);
+        assert(previousGCData !== undefined, 0x2b7 /* "Can't validate correctness without GC data from last run" */);
         const currentGraph = Object.entries(currentGCData.gcNodes);
         const missingExplicitReferences = [];
         currentGraph.forEach(([nodeId, currentOutboundRoutes]) => {
@@ -918,14 +1046,20 @@ export class GarbageCollector {
             const previousRoutes = (_a = previousGCData.gcNodes[nodeId]) !== null && _a !== void 0 ? _a : [];
             const explicitRoutes = (_b = explicitReferences.get(nodeId)) !== null && _b !== void 0 ? _b : [];
             const missingExplicitRoutes = [];
+            /**
+             * 1. For routes in the current GC data, routes that were not present in previous GC data and did not have
+             * explicit references should be added to missing explicit routes list.
+             * 2. Only include data store and blob routes since GC only works for these two.
+             * Note: Due to a bug with de-duped blobs, only adding data store routes for now.
+             * 3. Ignore DDS routes to their parent datastores since those were added implicitly. So, there won't be
+             * explicit routes to them.
+             */
             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))) {
+                const nodeType = this.runtime.getNodeType(route);
+                if ((nodeType === GCNodeType.DataStore || nodeType === GCNodeType.Blob) &&
+                    !nodeId.startsWith(route) &&
+                    !previousRoutes.includes(route) &&
+                    !explicitRoutes.includes(route)) {
                     missingExplicitRoutes.push(route);
                 }
             });
@@ -957,7 +1091,7 @@ export class GarbageCollector {
             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 ||
+            const stateUpdated = this.gcDataFromLastRun === undefined ||
                 this.unreferencedNodesState.has(nodeId) === referenced;
             if (stateUpdated) {
                 gcStats.updatedNodeCount++;
@@ -997,7 +1131,8 @@ export class GarbageCollector {
      * this will give us a view into how much deleted content a container has.
      */
     logSweepEvents(logger, currentReferenceTimestampMs) {
-        if (this.mc.config.getBoolean(disableSweepLogKey) === true || this.sweepTimeoutMs === undefined) {
+        if (this.mc.config.getBoolean(disableSweepLogKey) === true ||
+            this.sweepTimeoutMs === undefined) {
             return;
         }
         this.unreferencedNodesState.forEach((nodeStateTracker, nodeId) => {
@@ -1032,7 +1167,8 @@ export class GarbageCollector {
         // If there is no reference timestamp to work with, no ops have been processed after creation. If so, skip
         // logging as nothing interesting would have happened worth logging.
         // If the node is active, skip logging.
-        if (currentReferenceTimestampMs === undefined || nodeStateTracker.state === UnreferencedState.Active) {
+        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
@@ -1064,9 +1200,17 @@ export class GarbageCollector {
             // 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() }));
+                const event = Object.assign(Object.assign({}, propsToLog), { eventName: `${state}Object_${usageType}`, pkg: packagePathToTelemetryProperty(packagePath), stack: 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 === UnreferencedState.Inactive) {
+                    this.mc.logger.sendTelemetryEvent(event);
+                }
+                else {
+                    this.mc.logger.sendErrorEvent(event);
+                }
             }
-            // If SweepReady Usage Detection is enabed, the handler may close the interactive container.
+            // 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 === UnreferencedState.SweepReady) {
@@ -1089,43 +1233,29 @@ export class GarbageCollector {
              * revived and a Revived event will be logged for it.
              */
             const nodeStateTracker = this.unreferencedNodesState.get(eventProps.id);
-            const active = nodeStateTracker === undefined || nodeStateTracker.state === UnreferencedState.Active;
+            const active = nodeStateTracker === undefined ||
+                nodeStateTracker.state === 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 }));
+                const fromPkg = eventProps.fromId
+                    ? await this.getNodePackagePath(eventProps.fromId)
+                    : undefined;
+                const event = 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 });
+                if (state === UnreferencedState.Inactive) {
+                    logger.sendTelemetryEvent(event);
+                }
+                else {
+                    logger.sendErrorEvent(event);
+                }
             }
         }
         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));
@@ -1140,7 +1270,9 @@ function generateSortedGCState(gcState) {
 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"); });
+        super(0, () => {
+            throw new Error("DefaultHandler should not be used");
+        });
         this.callback = callback;
     }
     start(timeoutMs) {