@fluidframework/container-runtime 2.0.0-internal.2.2.1 → 2.0.0-internal.2.3.0

package/lib/garbageCollection.js

@@ -15,18 +15,16 @@ var __rest = (this && this.__rest) || function (s, e) {
 };
 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 { 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, } 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 { currentGCVersion, defaultInactiveTimeoutMs, defaultSessionExpiryDurationMs, disableSweepLogKey, disableTombstoneKey, gcVersionUpgradeToV2Key, gcTestModeKey, oneDayMs, runGCKey, runSessionExpiryKey, runSweepKey, stableGCVersion, throwOnTombstoneUsageKey, 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.
@@ -139,21 +137,6 @@ 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();
@@ -178,6 +161,9 @@ export class GarbageCollector {
         const metadata = createParams.metadata;
         const readAndParseBlob = createParams.readAndParseBlob;
         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;
         /**
@@ -282,10 +268,8 @@ export class GarbageCollector {
         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;
+        // 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 () => {
@@ -306,7 +290,7 @@ export class GarbageCollector {
                 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;
                     }
@@ -347,7 +331,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.
@@ -356,6 +339,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({
@@ -364,38 +348,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)) {
@@ -405,18 +375,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.
@@ -437,16 +396,35 @@ 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.
      *
-     * 3.1. The summary this client loaded with has data from a different GC version.
+     * 4. The GC version in the latest summary is different from the current GC version. This can happen if:
      *
-     * 3.2. This client's latest summary was updated from a snapshot that has a different GC version.
+     * 4.1. The summary this client loaded with has data from a different GC version.
+     *
+     * 4.2. This client's latest summary was updated from a snapshot that has a different GC version.
      */
     get summaryStateNeedsReset() {
-        return this.initialStateNeedsReset ||
+        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);
@@ -468,8 +446,63 @@ export class GarbageCollector {
         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 */);
+        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 tombstone mode is enabled, update tombstone information and also update all tombstoned nodes in the
+        // container as per the state in the snapshot data.
+        if (this.tombstoneMode) {
+            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),
+            };
+        }
     }
     /**
      * Called when the connection state of the runtime changes, i.e., it connects or disconnects. GC subscribes to this
@@ -555,13 +588,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
@@ -576,11 +609,11 @@ 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,
@@ -664,50 +697,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;
     }
     /**
@@ -735,7 +776,7 @@ export class GarbageCollector {
      * @param toNodePath - The node to which the reference is added.
      */
     addedOutboundReference(fromNodePath, toNodePath) {
-        var _a;
+        var _a, _b;
         if (!this.shouldRunGC) {
             return;
         }
@@ -746,6 +787,23 @@ 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";
+            }
+            this.mc.logger.sendTelemetryEvent({
+                eventName,
+                isSummarizerClient: this.isSummarizerClient,
+                url: trimLeadingSlashes(toNodePath),
+                nodeType,
+                throwOnTombstoneUsage: (_b = this.mc.config.getBoolean(throwOnTombstoneUsageKey)) !== null && _b !== void 0 ? _b : false,
+            });
+        }
     }
     dispose() {
         var _a;
@@ -762,7 +820,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.
@@ -798,27 +856,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
@@ -832,21 +894,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;
@@ -854,19 +913,22 @@ 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);
             }
         }
@@ -893,14 +955,19 @@ 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);
                 }
             });
@@ -932,7 +999,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++;
@@ -1039,7 +1106,15 @@ 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.
             // Once Sweep is fully implemented, this will be removed since the objects will be gone
@@ -1068,39 +1143,18 @@ export class GarbageCollector {
             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 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));