@fluidframework/container-runtime 0.53.0 → 0.54.0-47413

package/src/dataStoreContext.ts

@@ -30,7 +30,7 @@ import { BlobTreeEntry } from "@fluidframework/protocol-base";
 import {
     IClientDetails,
     IDocumentMessage,
-    IQuorum,
+    IQuorumClients,
     ISequencedDocumentMessage,
     ISnapshotTree,
     ITreeEntry,
@@ -67,6 +67,7 @@ import {
     ThresholdCounter,
 } from "@fluidframework/telemetry-utils";
 import { CreateProcessingError } from "@fluidframework/container-utils";
+
 import { ContainerRuntime } from "./containerRuntime";
 import {
     dataStoreAttributesBlobName,
@@ -386,7 +387,7 @@ export abstract class FluidDataStoreContext extends TypedEventEmitter<IFluidData
         this.channel?.processSignal(message, local);
     }
 
-    public getQuorum(): IQuorum {
+    public getQuorum(): IQuorumClients {
         return this._containerRuntime.getQuorum();
     }
 
@@ -496,9 +497,19 @@ export abstract class FluidDataStoreContext extends TypedEventEmitter<IFluidData
         }
     }
 
+    /**
+     * Called when a new outbound reference is added to another node. This is used by garbage collection to identify
+     * all references added in the system.
+     * @param srcHandle - The handle of the node that added the reference.
+     * @param outboundHandle - The handle of the outbound node that is referenced.
+     */
+    public addedGCOutboundReference(srcHandle: IFluidHandle, outboundHandle: IFluidHandle) {
+        this._containerRuntime.addedGCOutboundReference(srcHandle, outboundHandle);
+    }
+
     /**
      * Updates the used routes of the channel and its child contexts. The channel must be loaded before calling this.
-     * It is called in these two scenarions:
+     * It is called in these two scenarios:
      * 1. When the used routes of the data store is updated and the data store is loaded.
      * 2. When the data store is realized. This updates the channel's used routes as per last GC run.
      */
@@ -582,7 +593,7 @@ export abstract class FluidDataStoreContext extends TypedEventEmitter<IFluidData
         try
         {
             assert(!this.detachedRuntimeCreation, 0x148 /* "Detached runtime creation on runtime bind" */);
-            assert(this.channelDeferred !== undefined, 0x149 /* "Undefined channel defferal" */);
+            assert(this.channelDeferred !== undefined, 0x149 /* "Undefined channel deferral" */);
             assert(this.pkg !== undefined, 0x14a /* "Undefined package path" */);
 
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
@@ -634,6 +645,13 @@ export abstract class FluidDataStoreContext extends TypedEventEmitter<IFluidData
 
     protected abstract getInitialSnapshotDetails(): Promise<ISnapshotDetails>;
 
+    /**
+     * @deprecated - Sets the datastore as root, for aliasing purposes: #7948
+     * This method should not be used outside of the aliasing context.
+     * It will be removed, as the source of truth for this flag will be the aliasing blob.
+     */
+    public abstract setRoot(): void;
+
     public abstract getInitialGCSummaryDetails(): Promise<IGarbageCollectionSummaryDetails>;
 
     public reSubmit(contents: any, localOpMetadata: unknown) {
@@ -679,6 +697,8 @@ export abstract class FluidDataStoreContext extends TypedEventEmitter<IFluidData
 }
 
 export class RemotedFluidDataStoreContext extends FluidDataStoreContext {
+    private isRootDataStore: boolean | undefined;
+
     constructor(
         id: string,
         private readonly initSnapshotValue: ISnapshotTree | string | undefined,
@@ -750,7 +770,7 @@ export class RemotedFluidDataStoreContext extends FluidDataStoreContext {
              * data stores in older documents are not garbage collected incorrectly. This may lead to additional
              * roots in the document but they won't break.
              */
-            isRootDataStore = attributes.isRootDataStore ?? true;
+            isRootDataStore = this.isRootDataStore === true || (attributes.isRootDataStore ?? true);
 
             if (hasIsolatedChannels(attributes)) {
                 tree = tree.trees[channelsTreeName];
@@ -782,6 +802,15 @@ export class RemotedFluidDataStoreContext extends FluidDataStoreContext {
     public generateAttachMessage(): IAttachMessage {
         throw new Error("Cannot attach remote store");
     }
+
+    /**
+     * @deprecated - Sets the datastore as root, for aliasing purposes: #7948
+     * This method should not be used outside of the aliasing context.
+     * It will be removed, as the source of truth for this flag will be the aliasing blob.
+     */
+    public setRoot(): void {
+        this.isRootDataStore = true;
+    }
 }
 
 /**
@@ -883,7 +912,7 @@ export class LocalFluidDataStoreContextBase extends FluidDataStoreContext {
                 // If there is no isRootDataStore in the attributes blob, set it to true. This ensures that data
                 // stores in older documents are not garbage collected incorrectly. This may lead to additional
                 // roots in the document but they won't break.
-                this.isRootDataStore = attributes.isRootDataStore ?? true;
+                this.isRootDataStore = this.isRootDataStore || (attributes.isRootDataStore ?? true);
             }
         }
         assert(this.pkg !== undefined, 0x152 /* "pkg should be available in local data store" */);
@@ -901,6 +930,15 @@ export class LocalFluidDataStoreContextBase extends FluidDataStoreContext {
         // Local data store does not have initial summary.
         return {};
     }
+
+    /**
+     * @deprecated - Sets the datastore as root, for aliasing purposes: #7948
+     * This method should not be used outside of the aliasing context.
+     * It will be removed, as the source of truth for this flag will be the aliasing blob.
+     */
+    public setRoot(): void {
+        this.isRootDataStore = true;
+    }
 }
 
 /**

package/src/dataStores.ts

@@ -50,6 +50,32 @@ import {
 import { IContainerRuntimeMetadata, nonDataStorePaths, rootHasIsolatedChannels } from "./summaryFormat";
 import { IUsedStateStats } from "./garbageCollection";
 
+type PendingAliasResolve = (success: boolean) => void;
+
+/**
+ * Interface for an op to be used for assigning an
+ * alias to a datastore
+ */
+interface IDataStoreAliasMessage {
+    /** The internal id of the datastore */
+    readonly internalId: string;
+    /** The alias name to be assigned to the datastore */
+    readonly alias: string;
+}
+
+/**
+ * Type guard that returns true if the given alias message is actually an instance of
+ * a class which implements @see IDataStoreAliasMessage
+ * @param maybeDataStoreAliasMessage - message object to be validated
+ * @returns True if the @see IDataStoreAliasMessage is fully implemented, false otherwise
+ */
+const isDataStoreAliasMessage = (
+    maybeDataStoreAliasMessage: any,
+): maybeDataStoreAliasMessage is IDataStoreAliasMessage => {
+    return typeof maybeDataStoreAliasMessage?.internalId === "string"
+        && typeof maybeDataStoreAliasMessage?.alias === "string";
+};
+
  /**
   * This class encapsulates data store handling. Currently it is only used by the container runtime,
   * but eventually could be hosted on any channel once we formalize the channel api boundary.
@@ -81,6 +107,7 @@ export class DataStores implements IDisposable {
         baseLogger: ITelemetryBaseLogger,
         getDataStoreBaseGCDetails: () => Promise<Map<string, IGarbageCollectionSummaryDetails>>,
         private readonly dataStoreChanged: (id: string) => void,
+        private readonly aliasMap: Map<string, string>,
         private readonly contexts: DataStoreContexts = new DataStoreContexts(baseLogger),
     ) {
         this.logger = ChildLogger.create(baseLogger);
@@ -146,6 +173,10 @@ export class DataStores implements IDisposable {
         };
     }
 
+    public aliases(): ReadonlyMap<string, string> {
+        return this.aliasMap;
+    }
+
     public processAttachMessage(message: ISequencedDocumentMessage, local: boolean) {
         const attachMessage = message.contents as InboundAttachMessage;
         // The local object has already been attached
@@ -205,7 +236,6 @@ export class DataStores implements IDisposable {
                 }),
             pkg);
 
-        // Resolve pending gets and store off any new ones
         this.contexts.addBoundOrRemoted(remotedFluidDataStoreContext);
 
         // Equivalent of nextTick() - Prefetch once all current ops have completed
@@ -213,6 +243,55 @@ export class DataStores implements IDisposable {
         Promise.resolve().then(async () => remotedFluidDataStoreContext.realize());
     }
 
+    public processAliasMessage(
+        message: ISequencedDocumentMessage,
+        localOpMetadata: unknown,
+        local: boolean,
+    ): void {
+        const aliasMessage = message.contents as IDataStoreAliasMessage;
+        if (!isDataStoreAliasMessage(aliasMessage)) {
+            throw new DataCorruptionError(
+                "malformedDataStoreAliasMessage",
+                {
+                    ...extractSafePropertiesFromMessage(message),
+                },
+            );
+        }
+
+        const resolve = localOpMetadata as PendingAliasResolve;
+        const aliasResult = this.processAliasMessageCore(aliasMessage);
+        if (local) {
+            resolve(aliasResult);
+        }
+    }
+
+    private processAliasMessageCore(aliasMessage: IDataStoreAliasMessage): boolean {
+        const existingMapping = this.aliasMap.get(aliasMessage.alias);
+        if (existingMapping !== undefined) {
+            return false;
+        }
+
+        // Unlikely scenario, but we may receive an alias OP with the alias value
+        // equal to one of the ids supplied to `createRootDataStore` in the past
+        const maybeContextWithAliasAsId = this.contexts.get(aliasMessage.alias);
+        if (maybeContextWithAliasAsId !== undefined) {
+            return false;
+        }
+
+        const currentContext = this.contexts.get(aliasMessage.internalId);
+        if (currentContext === undefined) {
+            this.logger.sendErrorEvent({
+                eventName: "AliasFluidDataStoreNotFound",
+                fluidDataStoreId: aliasMessage.internalId,
+            });
+            return false;
+        }
+
+        this.aliasMap.set(aliasMessage.alias, currentContext.id);
+        currentContext.setRoot();
+        return true;
+    }
+
     public bindFluidDataStore(fluidDataStoreRuntime: IFluidDataStoreChannel): void {
         const id = fluidDataStoreRuntime.id;
         const localContext = this.contexts.getUnbound(id);
@@ -304,8 +383,9 @@ export class DataStores implements IDisposable {
     }
 
     public async getDataStore(id: string, wait: boolean): Promise<FluidDataStoreContext> {
-        const context = await this.contexts.getBoundOrRemoted(id, wait);
+        const internalId = this.aliasMap.get(id) ?? id;
 
+        const context = await this.contexts.getBoundOrRemoted(internalId, wait);
         if (context === undefined) {
             // The requested data store does not exits. Throw a 404 response exception.
             const request = { url: id };
@@ -421,8 +501,8 @@ export class DataStores implements IDisposable {
     /**
      * Generates data used for garbage collection. It does the following:
      * 1. Calls into each child data store context to get its GC data.
-     * 2. Prefixs the child context's id to the GC nodes in the child's GC data. This makes sure that the node can be
-     *    idenfied as belonging to the child.
+     * 2. Prefixes the child context's id to the GC nodes in the child's GC data. This makes sure that the node can be
+     *    identified as belonging to the child.
      * 3. Adds a GC node for this channel to the nodes received from the children. All these nodes together represent
      *    the GC data of this channel.
      * @param fullGC - true to bypass optimizations and force full generation of GC data.

package/src/garbageCollection.ts

@@ -6,16 +6,17 @@
 import { ITelemetryLogger } from "@fluidframework/common-definitions";
 import { assert, LazyPromise, Timer } from "@fluidframework/common-utils";
 import {
+    cloneGCData,
     concatGarbageCollectionStates,
-    unpackChildNodesGCDetails,
+    concatGarbageCollectionData,
     IGCResult,
     runGarbageCollection,
+    unpackChildNodesGCDetails,
 } from "@fluidframework/garbage-collector";
 import { ISnapshotTree } from "@fluidframework/protocol-definitions";
 import {
     gcBlobKey,
     IGarbageCollectionData,
-    IGarbageCollectionNodeData,
     IGarbageCollectionState,
     IGarbageCollectionSummaryDetails,
     ISummaryTreeWithStats,
@@ -25,11 +26,15 @@ import {
     RefreshSummaryResult,
     SummaryTreeBuilder,
 } from "@fluidframework/runtime-utils";
-import { ChildLogger, PerformanceEvent } from "@fluidframework/telemetry-utils";
+import {
+    ChildLogger,
+    loggerToMonitoringContext,
+    MonitoringContext,
+    PerformanceEvent,
+ } from "@fluidframework/telemetry-utils";
 
 import { IGCRuntimeOptions } from "./containerRuntime";
 import { getSummaryForDatastores } from "./dataStores";
-import { getLocalStorageFeatureGate } from "./localStorageFeatureGates";
 import {
     getGCVersion,
     GCVersion,
@@ -48,11 +53,11 @@ export const gcTreeKey = "gc";
 export const gcBlobPrefix = "__gc";
 
 // Local storage key to turn GC on / off.
-const runGCKey = "FluidRunGC";
+const runGCKey = "Fluid.GarbageCollection.RunGC";
 // Local storage key to turn GC test mode on / off.
-const gcTestModeKey = "FluidGCTestMode";
+const gcTestModeKey = "Fluid.GarbageCollection.GCTestMode";
 // Local storage key to turn GC sweep on / off.
-const runSweepKey = "FluidRunSweep";
+const runSweepKey = "Fluid.GarbageCollection.RunSweep";
 
 const defaultDeleteTimeoutMs = 7 * 24 * 60 * 60 * 1000; // 7 days
 
@@ -104,6 +109,8 @@ export interface IGarbageCollector {
     latestSummaryStateRefreshed(result: RefreshSummaryResult, readAndParseBlob: ReadAndParseBlob): Promise<void>;
     /** Called when a node is changed. Used to detect and log when an inactive node is changed. */
     nodeChanged(id: string): void;
+    /** Called when a reference is added to a node. Used to identify nodes that were referenced between summaries. */
+    addedOutboundReference(fromNodeId: string, toNodeId: string): void;
 }
 
 /**
@@ -148,9 +155,9 @@ class UnreferencedStateTracker {
         if (this.inactive && !this.inactiveEventsLogged.has(eventName)) {
             logger.sendErrorEvent({
                 eventName,
-                unreferencedDuratonMs: currentTimestampMs - this.unreferencedTimestampMs,
-                deleteTimeoutMs,
-                inactiveNodeId,
+                age: currentTimestampMs - this.unreferencedTimestampMs,
+                timeout: deleteTimeoutMs,
+                id: inactiveNodeId,
             });
             this.inactiveEventsLogged.add(eventName);
         }
@@ -217,7 +224,7 @@ export class GarbageCollector implements IGarbageCollector {
     private readonly gcEnabled: boolean;
     private readonly shouldRunSweep: boolean;
     private readonly testMode: boolean;
-    private readonly logger: ITelemetryLogger;
+    private readonly mc: MonitoringContext;
 
     /**
      * Tells whether the GC data should be written to the root of the summary tree. We do this under 2 conditions:
@@ -235,8 +242,11 @@ export class GarbageCollector implements IGarbageCollector {
     // This is the version of GC data in the latest summary being tracked.
     private latestSummaryGCVersion: GCVersion;
 
-    // The current state - each node's GC data and unreferenced timestamp.
-    private currentGCState: IGarbageCollectionState | undefined;
+    // Keeps track of the GC state from the last run.
+    private gcDataFromLastRun: IGarbageCollectionData | undefined;
+    // 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.
+    private readonly referencesSinceLastRun: Map<string, string[]> = new Map();
 
     // Promise when resolved initializes the base state of the nodes from the base summary state.
     private readonly initializeBaseStateP: Promise<void>;
@@ -260,7 +270,8 @@ export class GarbageCollector implements IGarbageCollector {
         existing: boolean,
         metadata?: IContainerRuntimeMetadata,
     ) {
-        this.logger = ChildLogger.create(baseLogger, "GarbageCollector");
+        this.mc = loggerToMonitoringContext(
+            ChildLogger.create(baseLogger, "GarbageCollector"));
 
         this.deleteTimeoutMs = this.gcOptions.deleteTimeoutMs ?? defaultDeleteTimeoutMs;
 
@@ -281,7 +292,7 @@ export class GarbageCollector implements IGarbageCollector {
         this.latestSummaryGCVersion = prevSummaryGCVersion ?? this.currentGCVersion;
 
         // Whether GC should run or not. Can override with localStorage flag.
-        this.shouldRunGC = getLocalStorageFeatureGate(runGCKey) ?? (
+        this.shouldRunGC = this.mc.config.getBoolean(runGCKey) ?? (
             // GC must be enabled for the document.
             this.gcEnabled
             // GC must not be disabled via GC options.
@@ -291,10 +302,10 @@ export class GarbageCollector implements IGarbageCollector {
         // Whether GC sweep phase should run or not. If this is false, only GC mark phase is run. Can override with
         // localStorage flag.
         this.shouldRunSweep = this.shouldRunGC &&
-            (getLocalStorageFeatureGate(runSweepKey) ?? gcOptions.runSweep === true);
+            (this.mc.config.getBoolean(runSweepKey) ?? gcOptions.runSweep === true);
 
         // Whether we are running in test mode. In this mode, unreferenced nodes are immediately deleted.
-        this.testMode = getLocalStorageFeatureGate(gcTestModeKey) ?? gcOptions.runGCInTestMode === true;
+        this.testMode = this.mc.config.getBoolean(gcTestModeKey) ?? gcOptions.runGCInTestMode === true;
 
         // If `writeDataAtRoot` GC option is true, we should write the GC data into the root of the summary tree. This
         // GC option is used for testing only. It will be removed once we start writing GC data into root by default.
@@ -302,9 +313,9 @@ export class GarbageCollector implements IGarbageCollector {
 
         // Get the GC state from the GC blob in the base snapshot. Use LazyPromise because we only want to do
         // this once since it involves fetching blobs from storage which is expensive.
-        const baseSummaryStateP = new LazyPromise<IGarbageCollectionState>(async () => {
+        const baseSummaryStateP = new LazyPromise<IGarbageCollectionState | undefined>(async () => {
             if (baseSnapshot === undefined) {
-                return { gcNodes: {} };
+                return undefined;
             }
 
             // For newer documents, GC data should be present in the GC tree in the root of the snapshot.
@@ -317,6 +328,7 @@ export class GarbageCollector implements IGarbageCollector {
 
             // 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: IGarbageCollectionState = { gcNodes: { "/": { outboundRoutes: [] } } };
             const dataStoreSnaphotTree = getSummaryForDatastores(baseSnapshot, metadata);
             assert(dataStoreSnaphotTree !== undefined,
@@ -353,22 +365,28 @@ export class GarbageCollector implements IGarbageCollector {
                     0x2a9 /* `GC nodes for data store ${dsId} not in GC blob` */);
                 gcState.gcNodes[dsRootId].unreferencedTimestampMs = gcSummaryDetails.unrefTimestamp;
             }
-            return gcState;
+
+            // If there is only one node (root node just added above), either GC is disabled or we are loading from the
+            // very first summary generated by detached container. In both cases, GC was not run - return undefined.
+            return Object.keys(gcState.gcNodes).length === 1 ? undefined : gcState;
         });
 
         // Set up the initializer which initializes the base GC state from the base snapshot. Use lazy promise because
         // we only do this once - the very first time we run GC.
         this.initializeBaseStateP = new LazyPromise<void>(async () => {
-            const baseState = await baseSummaryStateP;
+            const currentTimestampMs = this.getCurrentTimestampMs();
+            const baseState =  await baseSummaryStateP;
+            if (baseState === undefined) {
+                return;
+            }
 
-            const gcNodes: { [ id: string ]: IGarbageCollectionNodeData } = {};
-            // Set up tracking for the nodes in the base summary state and add them to GC nodes.
+            const gcNodes: { [ id: string ]: string[] } = {};
             for (const [nodeId, nodeData] of Object.entries(baseState.gcNodes)) {
                 const unreferencedTimestampMs = nodeData.unreferencedTimestampMs;
                 if (unreferencedTimestampMs !== undefined) {
                     // Get how long it has been since the node was unreferenced. Start a timeout for the remaining time
                     // left for it to be eligible for deletion.
-                    const unreferencedDurationMs = this.getCurrentTimestampMs() - unreferencedTimestampMs;
+                    const unreferencedDurationMs = currentTimestampMs - unreferencedTimestampMs;
                     this.unreferencedNodesState.set(
                         nodeId,
                         new UnreferencedStateTracker(
@@ -377,20 +395,20 @@ export class GarbageCollector implements IGarbageCollector {
                         ),
                     );
                 }
-
-                gcNodes[nodeId] = {
-                    outboundRoutes: Array.from(nodeData.outboundRoutes),
-                    unreferencedTimestampMs,
-                };
+                gcNodes[nodeId] = Array.from(nodeData.outboundRoutes);
             }
-            this.currentGCState = { gcNodes };
+            this.gcDataFromLastRun = { gcNodes };
         });
 
         // Get the GC details for each data store from the GC state in the base summary. This is returned in
         // getDataStoreBaseGCDetails and is used to initialize each data store's base GC details.
         this.dataStoreGCDetailsP = new LazyPromise<Map<string, IGarbageCollectionSummaryDetails>>(async () => {
-            const gcNodes: { [ id: string ]: string[] } = {};
             const baseState = await baseSummaryStateP;
+            if (baseState === undefined) {
+                return new Map();
+            }
+
+            const gcNodes: { [ id: string ]: string[] } = {};
             for (const [nodeId, nodeData] of Object.entries(baseState.gcNodes)) {
                 gcNodes[nodeId] = Array.from(nodeData.outboundRoutes);
             }
@@ -400,7 +418,7 @@ export class GarbageCollector implements IGarbageCollector {
             const usedRoutes = runGarbageCollection(
                 gcNodes,
                 [ "/" ],
-                this.logger,
+                this.mc.logger,
             ).referencedNodeIds;
 
             const dataStoreGCDetailsMap = unpackChildNodesGCDetails({ gcData: { gcNodes }, usedRoutes });
@@ -433,7 +451,7 @@ export class GarbageCollector implements IGarbageCollector {
         },
     ): Promise<IGCStats> {
         const {
-            logger = this.logger,
+            logger = this.mc.logger,
             runSweep = this.shouldRunSweep,
             fullGC = this.gcOptions.runFullGC === true || this.hasGCVersionChanged,
         } = options;
@@ -450,6 +468,9 @@ export class GarbageCollector implements IGarbageCollector {
 
             // Get the runtime's GC data and run GC on the reference graph in it.
             const gcData = await this.provider.getGCData(fullGC);
+
+            this.updateStateSinceLatestRun(gcData);
+
             const gcResult = runGarbageCollection(
                 gcData.gcNodes,
                 [ "/" ],
@@ -489,13 +510,21 @@ export class GarbageCollector implements IGarbageCollector {
      * We current write the entire GC state in a single blob. This can be modified later to write multiple
      * blobs. All the blob keys should start with `gcBlobPrefix`.
      */
-     public summarize(): ISummaryTreeWithStats | undefined {
-        if (!this.shouldRunGC || this.currentGCState === undefined) {
+    public summarize(): ISummaryTreeWithStats | undefined {
+        if (!this.shouldRunGC || this.gcDataFromLastRun === undefined) {
             return;
         }
 
+        const gcState: IGarbageCollectionState = { gcNodes: {} };
+        for (const [nodeId, outboundRoutes] of Object.entries(this.gcDataFromLastRun.gcNodes)) {
+            gcState.gcNodes[nodeId] = {
+                outboundRoutes,
+                unreferencedTimestampMs: this.unreferencedNodesState.get(nodeId)?.unreferencedTimestampMs,
+            };
+        }
+
         const builder = new SummaryTreeBuilder();
-        builder.addBlob(`${gcBlobPrefix}_root`, JSON.stringify(this.currentGCState));
+        builder.addBlob(`${gcBlobPrefix}_root`, JSON.stringify(gcState));
         return builder.getSummaryTree();
     }
 
@@ -537,7 +566,7 @@ export class GarbageCollector implements IGarbageCollector {
         // Prefix "/" if needed to make it relative to the root.
         const nodeId = id.startsWith("/") ? id : `/${id}`;
         this.unreferencedNodesState.get(nodeId)?.logIfInactive(
-            this.logger,
+            this.mc.logger,
             "inactiveObjectChanged",
             this.getCurrentTimestampMs(),
             this.deleteTimeoutMs,
@@ -545,6 +574,19 @@ export class GarbageCollector implements IGarbageCollector {
         );
     }
 
+    /**
+     * Called when an outbound reference is added to a node. This is used to identify all nodes that have been
+     * referenced between summaries so that their unreferenced timestamp can be reset.
+     *
+     * @param fromNodeId - The node from which the reference is added.
+     * @param toNodeId - The node to which the reference is added.
+     */
+    public addedOutboundReference(fromNodeId: string, toNodeId: string) {
+        const outboundRoutes = this.referencesSinceLastRun.get(fromNodeId) ?? [];
+        outboundRoutes.push(toNodeId);
+        this.referencesSinceLastRun.set(fromNodeId, outboundRoutes);
+    }
+
     /**
      * Update the latest summary GC version from the metadata blob in the given snapshot.
      */
@@ -566,15 +608,11 @@ export class GarbageCollector implements IGarbageCollector {
      * @param currentTimestampMs - The current timestamp to be used for unreferenced nodes' timestamp.
      */
     private updateCurrentState(gcData: IGarbageCollectionData, gcResult: IGCResult, currentTimestampMs: number) {
-        this.currentGCState = { gcNodes: {} };
-        for (const [id, outboundRoutes] of Object.entries(gcData.gcNodes)) {
-            this.currentGCState.gcNodes[id] = { outboundRoutes: Array.from(outboundRoutes) };
-        }
+        this.gcDataFromLastRun = cloneGCData(gcData);
+        this.referencesSinceLastRun.clear();
 
         // Iterate through the deleted nodes and start tracking if they became unreferenced in this run.
         for (const nodeId of gcResult.deletedNodeIds) {
-            assert(this.currentGCState.gcNodes[nodeId] !== undefined, 0x2aa /* "Unexpected node when running GC" */);
-
             // The time when the node became unreferenced. This is added to the current GC state.
             let unreferencedTimestampMs: number = currentTimestampMs;
             const nodeStateTracker = this.unreferencedNodesState.get(nodeId);
@@ -587,18 +625,16 @@ export class GarbageCollector implements IGarbageCollector {
                     new UnreferencedStateTracker(unreferencedTimestampMs, this.deleteTimeoutMs),
                 );
             }
-            this.currentGCState.gcNodes[nodeId].unreferencedTimestampMs = unreferencedTimestampMs;
         }
 
         // Iterate through the referenced nodes and stop tracking if they were unreferenced before.
         for (const nodeId of gcResult.referencedNodeIds) {
-            assert(this.currentGCState.gcNodes[nodeId] !== undefined, 0x2ab /* "Unexpected node when running GC" */);
             const nodeStateTracker = this.unreferencedNodesState.get(nodeId);
             if (nodeStateTracker !== undefined) {
                 // If this node has been unreferenced for longer than deleteTimeoutMs and is being referenced,
                 // log an error as this may mean the deleteTimeoutMs is not long enough.
                 nodeStateTracker.logIfInactive(
-                    this.logger,
+                    this.mc.logger,
                     "inactiveObjectRevived",
                     currentTimestampMs,
                     this.deleteTimeoutMs,
@@ -611,6 +647,61 @@ export class GarbageCollector implements IGarbageCollector {
             }
         }
     }
+
+    /**
+     * 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.
+     *
+     * 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.
+     */
+    private updateStateSinceLatestRun(currentGCData: IGarbageCollectionData) {
+        // If we haven't run GC before or no references were added since the last run, there is nothing to do.
+        if (this.gcDataFromLastRun === undefined || this.referencesSinceLastRun.size === 0) {
+            return;
+        }
+
+        /**
+         * Generate a super set of the GC data that contains the nodes and edges from last run, plus any new node and
+         * edges that have been added since then. To do this, combine the GC data from the last run and the current
+         * run, and then add the references since last run.
+         *
+         * Note on why we need to combine the data from previous run, current run and all references in between -
+         * 1. We need data from last run because some of its references may have been deleted since then. If those
+         *    references added new outbound references before getting deleted, we need to detect them.
+         * 2. We need new outbound references since last run because some of them may have been deleted later. If those
+         *    references added new outbound references before getting deleted, we need to detect them.
+         * 3. We need data from the current run because currently we may not detect when DDSs are referenced:
+         *    - We don't require DDSs handles to be stored in a referenced DDS. For this, we need GC at DDS level
+         *      which is tracked by https://github.com/microsoft/FluidFramework/issues/8470.
+         *    - A new data store may have "root" DDSs already created and we don't detect them today.
+         */
+        const gcDataSuperSet = concatGarbageCollectionData(this.gcDataFromLastRun, currentGCData);
+        this.referencesSinceLastRun.forEach((outboundRoutes: string[], sourceNodeId: string) => {
+            if (gcDataSuperSet.gcNodes[sourceNodeId] === undefined) {
+                gcDataSuperSet.gcNodes[sourceNodeId] = outboundRoutes;
+            } else {
+                gcDataSuperSet.gcNodes[sourceNodeId].push(...outboundRoutes);
+            }
+        });
+
+        /**
+         * Run GC on the above reference graph to find all nodes that are referenced. For each one, if they are
+         * 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.
+         */
+        const gcResult = runGarbageCollection(gcDataSuperSet.gcNodes, ["/"], this.mc.logger);
+        for (const nodeId of gcResult.referencedNodeIds) {
+            const nodeStateTracker = this.unreferencedNodesState.get(nodeId);
+            if (nodeStateTracker !== undefined) {
+                // Stop tracking so as to clear out any running timers.
+                nodeStateTracker.stopTracking();
+                // Delete the node as we don't need to track it any more.
+                this.unreferencedNodesState.delete(nodeId);
+            }
+        }
+    }
 }
 
 /**

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/container-runtime";
-export const pkgVersion = "0.53.0";
+export const pkgVersion = "0.54.0-47413";