@fluidframework/container-runtime 2.0.0-dev-rc.5.0.0.271262 → 2.0.0-dev-rc.5.0.0.272251

package/src/channelCollection.ts

@@ -400,7 +400,7 @@ export class ChannelCollection implements IFluidDataStoreChannel, IDisposable {
 		const foundGCData = processAttachMessageGCData(attachMessage.snapshot, (nodeId, toPath) => {
 			// nodeId is the relative path under the node being attached. Always starts with "/", but no trailing "/" after an id
 			const fromPath = `/${attachMessage.id}${nodeId === "/" ? "" : nodeId}`;
-			this.parentContext.addedGCOutboundRoute(fromPath, toPath);
+			this.parentContext.addedGCOutboundRoute(fromPath, toPath, message.timestamp);
 		});
 
 		// Only log once per container to avoid noise/cost.
@@ -495,13 +495,18 @@ export class ChannelCollection implements IFluidDataStoreChannel, IDisposable {
 		const aliasResult = this.processAliasMessageCore(
 			aliasMessage.internalId,
 			aliasMessage.alias,
+			message.timestamp,
 		);
 		if (local) {
 			resolve(aliasResult);
 		}
 	}
 
-	public processAliasMessageCore(internalId: string, alias: string): boolean {
+	public processAliasMessageCore(
+		internalId: string,
+		alias: string,
+		messageTimestampMs?: number,
+	): boolean {
 		if (this.alreadyProcessed(alias)) {
 			return false;
 		}
@@ -521,7 +526,11 @@ export class ChannelCollection implements IFluidDataStoreChannel, IDisposable {
 			return false;
 		}
 
-		this.parentContext.addedGCOutboundRoute("/", `/${internalId}`);
+		// If message timestamp doesn't exist, this is called in a detached container. Don't notify GC in that case
+		// because it doesn't run in detached container and doesn't need to know about this route.
+		if (messageTimestampMs) {
+			this.parentContext.addedGCOutboundRoute("/", `/${internalId}`, messageTimestampMs);
+		}
 
 		this.aliasMap.set(alias, context.id);
 		this.aliasedDataStores.add(context.id);
@@ -829,7 +838,11 @@ export class ChannelCollection implements IFluidDataStoreChannel, IDisposable {
 					envelope.address,
 					transformed.contents,
 					(fromPath: string, toPath: string) =>
-						this.parentContext.addedGCOutboundRoute(fromPath, toPath),
+						this.parentContext.addedGCOutboundRoute(
+							fromPath,
+							toPath,
+							message.timestamp,
+						),
 				);
 				break;
 			}
@@ -1075,86 +1088,30 @@ export class ChannelCollection implements IFluidDataStoreChannel, IDisposable {
 		return this.contexts.size;
 	}
 
-	public async summarize(
-		fullTree: boolean,
-		trackState: boolean,
-		telemetryContext?: ITelemetryContext,
-	): Promise<ISummaryTreeWithStats> {
-		const summaryBuilder = new SummaryTreeBuilder();
-
-		// Iterate over each store and ask it to snapshot
-		await Promise.all(
-			Array.from(this.contexts)
-				.filter(([_, context]) => {
-					// Summarizer works only with clients with no local changes. A data store in attaching
-					// state indicates an op was sent to attach a local data store, and the the attach op
-					// had not yet round tripped back to the client.
-					if (context.attachState === AttachState.Attaching) {
-						// Formerly assert 0x588
-						const error = DataProcessingError.create(
-							"Local data store detected in attaching state during summarize",
-							"summarize",
-						);
-						throw error;
-					}
-					return context.attachState === AttachState.Attached;
-				})
-				.map(async ([contextId, context]) => {
-					const contextSummary = await context.summarize(
-						fullTree,
-						trackState,
-						telemetryContext,
-					);
-					summaryBuilder.addWithStats(contextId, contextSummary);
-				}),
-		);
-
-		return summaryBuilder.getSummaryTree();
-	}
-
 	/**
 	 * Create a summary. Used when attaching or serializing a detached container.
 	 */
 	public getAttachSummary(telemetryContext?: ITelemetryContext): ISummaryTreeWithStats {
 		const builder = new SummaryTreeBuilder();
-		// Attaching graph of some stores can cause other stores to get bound too.
-		// So keep taking summary until no new stores get bound.
-		let notBoundContextsLength: number;
-		do {
-			const builderTree = builder.summary.tree;
-			notBoundContextsLength = this.contexts.notBoundLength();
-			// Iterate over each data store and ask it to snapshot
-			Array.from(this.contexts)
-				.filter(
-					([key, _]) =>
-						// Take summary of bounded data stores only, make sure we haven't summarized them already
-						// and no attach op has been fired for that data store because for loader versions <= 0.24
-						// we set attach state as "attaching" before taking createNew summary.
-						!(
-							this.contexts.isNotBound(key) ||
-							builderTree[key] ||
-							this.attachOpFiredForDataStore.has(key)
-						),
-				)
-				.map(([key, value]) => {
-					let dataStoreSummary: ISummarizeResult;
-					if (value.isLoaded) {
-						dataStoreSummary = value.getAttachSummary(telemetryContext);
-					} else {
-						// If this data store is not yet loaded, then there should be no changes in the snapshot from
-						// which it was created as it is detached container. So just use the previous snapshot.
-						assert(
-							!!this.baseSnapshot,
-							0x166 /* "BaseSnapshot should be there as detached container loaded from snapshot" */,
-						);
-						dataStoreSummary = convertSnapshotTreeToSummaryTree(
-							getSnapshotTree(this.baseSnapshot).trees[key],
-						);
-					}
-					builder.addWithStats(key, dataStoreSummary);
-				});
-		} while (notBoundContextsLength !== this.contexts.notBoundLength());
-
+		this.visitLocalBoundContextsDuringAttach(
+			(contextId: string, context: FluidDataStoreContext) => {
+				let dataStoreSummary: ISummarizeResult;
+				if (context.isLoaded) {
+					dataStoreSummary = context.getAttachSummary(telemetryContext);
+				} else {
+					// If this data store is not yet loaded, then there should be no changes in the snapshot from
+					// which it was created as it is detached container. So just use the previous snapshot.
+					assert(
+						!!this.baseSnapshot,
+						0x166 /* "BaseSnapshot should be there as detached container loaded from snapshot" */,
+					);
+					dataStoreSummary = convertSnapshotTreeToSummaryTree(
+						getSnapshotTree(this.baseSnapshot).trees[contextId],
+					);
+				}
+				builder.addWithStats(contextId, dataStoreSummary);
+			},
+		);
 		return builder.getSummaryTree();
 	}
 
@@ -1163,31 +1120,100 @@ export class ChannelCollection implements IFluidDataStoreChannel, IDisposable {
 	 */
 	public getAttachGCData(telemetryContext?: ITelemetryContext): IGarbageCollectionData {
 		const builder = new GCDataBuilder();
-		// Attaching graph of some stores can cause other stores to get bound too.
-		// So keep taking summary until no new stores get bound.
-		let notBoundContextsLength: number;
-		do {
-			notBoundContextsLength = this.contexts.notBoundLength();
-			// Iterate over each data store and ask for its GC data.
-			Array.from(this.contexts)
-				.filter(
-					([key, _]) =>
-						// Take GC data of bounded data stores only.
-						!this.contexts.isNotBound(key),
-				)
-				.map(([key, value]) => {
-					const contextGCData = value.getAttachGCData(telemetryContext);
-					// Prefix the child's id to the ids of its GC nodes so they can be identified as belonging to the child.
-					// This also gradually builds the id of each node to be a path from the root.
-					builder.prefixAndAddNodes(key, contextGCData.gcNodes);
-				});
-		} while (notBoundContextsLength !== this.contexts.notBoundLength());
-
+		this.visitLocalBoundContextsDuringAttach(
+			(contextId: string, context: FluidDataStoreContext) => {
+				const contextGCData = context.getAttachGCData(telemetryContext);
+				// Prefix the child's id to the ids of its GC nodes so they can be identified as belonging to the child.
+				// This also gradually builds the id of each node to be a path from the root.
+				builder.prefixAndAddNodes(contextId, contextGCData.gcNodes);
+			},
+		);
 		// Get the outbound routes (aliased data stores) and add a GC node for this channel.
 		builder.addNode("/", Array.from(this.aliasedDataStores));
 		return builder.getGCData();
 	}
 
+	/**
+	 * Helper method for preparing to attach this channel.
+	 * Runs the callback for each bound context to incorporate its data however the caller specifies
+	 */
+	private visitLocalBoundContextsDuringAttach(
+		visitor: (contextId: string, context: FluidDataStoreContext) => void,
+	): void {
+		const visitedContexts = new Set<string>();
+		let visitedLength = -1;
+		let notBoundContextsLength = -1;
+		while (
+			visitedLength !== visitedContexts.size &&
+			notBoundContextsLength !== this.contexts.notBoundLength()
+		) {
+			// detect changes in the visitedContexts set, as on visiting a context
+			// it could could make contexts available by removing other contexts
+			// from the not bound context list, so we need to ensure those get processed as well.
+			// only once the loop can run with no new contexts added to the visitedContexts set do we
+			// know for sure all possible contexts have been visited.
+			visitedLength = visitedContexts.size;
+			notBoundContextsLength = this.contexts.notBoundLength();
+			for (const [contextId, context] of this.contexts) {
+				if (
+					!(
+						visitedContexts.has(contextId) ||
+						this.contexts.isNotBound(contextId) ||
+						this.attachOpFiredForDataStore.has(contextId)
+					)
+				) {
+					visitor(contextId, context);
+					visitedContexts.add(contextId);
+				}
+			}
+		}
+	}
+
+	/**
+	 * Helper method for preparing to summarize this channel.
+	 * Runs the callback for each bound context to incorporate its data however the caller specifies
+	 */
+	private async visitContextsDuringSummary(
+		visitor: (contextId: string, context: FluidDataStoreContext) => Promise<void>,
+	): Promise<void> {
+		for (const [contextId, context] of this.contexts) {
+			// Summarizer client and hence GC works only with clients with no local changes. A data store in
+			// attaching state indicates an op was sent to attach a local data store, and the the attach op
+			// had not yet round tripped back to the client.
+			// Formerly assert 0x589
+			if (context.attachState === AttachState.Attaching) {
+				const error = DataProcessingError.create(
+					"Local data store detected in attaching state",
+					"summarize/getGCData",
+				);
+				throw error;
+			}
+
+			if (context.attachState === AttachState.Attached) {
+				await visitor(contextId, context);
+			}
+		}
+	}
+
+	public async summarize(
+		fullTree: boolean,
+		trackState: boolean,
+		telemetryContext?: ITelemetryContext,
+	): Promise<ISummaryTreeWithStats> {
+		const summaryBuilder = new SummaryTreeBuilder();
+		await this.visitContextsDuringSummary(
+			async (contextId: string, context: FluidDataStoreContext) => {
+				const contextSummary = await context.summarize(
+					fullTree,
+					trackState,
+					telemetryContext,
+				);
+				summaryBuilder.addWithStats(contextId, contextSummary);
+			},
+		);
+		return summaryBuilder.getSummaryTree();
+	}
+
 	/**
 	 * Generates data used for garbage collection. It does the following:
 	 *
@@ -1203,30 +1229,13 @@ export class ChannelCollection implements IFluidDataStoreChannel, IDisposable {
 	 */
 	public async getGCData(fullGC: boolean = false): Promise<IGarbageCollectionData> {
 		const builder = new GCDataBuilder();
-		// Iterate over each store and get their GC data.
-		await Promise.all(
-			Array.from(this.contexts)
-				.filter(([_, context]) => {
-					// Summarizer client and hence GC works only with clients with no local changes. A data store in
-					// attaching state indicates an op was sent to attach a local data store, and the the attach op
-					// had not yet round tripped back to the client.
-					// Formerly assert 0x589
-					if (context.attachState === AttachState.Attaching) {
-						const error = DataProcessingError.create(
-							"Local data store detected in attaching state while running GC",
-							"getGCData",
-						);
-						throw error;
-					}
-
-					return context.attachState === AttachState.Attached;
-				})
-				.map(async ([contextId, context]) => {
-					const contextGCData = await context.getGCData(fullGC);
-					// Prefix the child's id to the ids of its GC nodes so they can be identified as belonging to the child.
-					// This also gradually builds the id of each node to be a path from the root.
-					builder.prefixAndAddNodes(contextId, contextGCData.gcNodes);
-				}),
+		await this.visitContextsDuringSummary(
+			async (contextId: string, context: FluidDataStoreContext) => {
+				const contextGCData = await context.getGCData(fullGC);
+				// Prefix the child's id to the ids of its GC nodes so they can be identified as belonging to the child.
+				// This also gradually builds the id of each node to be a path from the root.
+				builder.prefixAndAddNodes(contextId, contextGCData.gcNodes);
+			},
 		);
 
 		// Get the outbound routes and add a GC node for this channel.
@@ -1432,6 +1441,7 @@ export class ChannelCollection implements IFluidDataStoreChannel, IDisposable {
 			packagePath: details.pkg,
 			request,
 			headerData,
+			timestampMs: undefined, // This will be added by the parent context if needed.
 		});
 
 		const dataStore = await dataStoreContext.realize();

package/src/containerRuntime.ts

@@ -121,6 +121,7 @@ import {
 	loggerToMonitoringContext,
 	raiseConnectedEvent,
 	wrapError,
+	tagCodeArtifacts,
 } from "@fluidframework/telemetry-utils/internal";
 import { v4 as uuid } from "uuid";
 
@@ -1663,7 +1664,11 @@ export class ContainerRuntime
 			snapshot,
 			parentContext,
 			this.mc.logger,
-			(props) => this.garbageCollector.nodeUpdated(props),
+			(props) =>
+				this.garbageCollector.nodeUpdated({
+					...props,
+					timestampMs: props.timestampMs ?? this.getCurrentReferenceTimestampMs(),
+				}),
 			(path: string) => this.garbageCollector.isNodeDeleted(path),
 			new Map<string, string>(dataStoreAliasMap),
 			async (runtime: ChannelCollection) => provideEntryPoint,
@@ -1689,6 +1694,7 @@ export class ContainerRuntime
 				this.garbageCollector.nodeUpdated({
 					node: { type: "Blob", path: blobPath },
 					reason: "Loaded",
+					timestampMs: this.getCurrentReferenceTimestampMs(),
 				}),
 			isBlobDeleted: (blobPath: string) => this.garbageCollector.isNodeDeleted(blobPath),
 			runtime: this,
@@ -2715,7 +2721,11 @@ export class ContainerRuntime
 				}
 				break;
 			case ContainerMessageType.GC:
-				this.garbageCollector.processMessage(messageWithContext.message, local);
+				this.garbageCollector.processMessage(
+					messageWithContext.message,
+					messageWithContext.message.timestamp,
+					local,
+				);
 				break;
 			case ContainerMessageType.ChunkedOp:
 				// From observability POV, we should not exppse the rest of the system (including "op" events on object) to these messages.
@@ -2949,6 +2959,7 @@ export class ContainerRuntime
 			node: { type: "DataStore", path: `/${internalId}` },
 			reason: "Loaded",
 			packagePath: context.packagePath,
+			timestampMs: this.getCurrentReferenceTimestampMs(),
 		});
 		return channel.entryPoint;
 	}
@@ -3402,9 +3413,25 @@ export class ContainerRuntime
 	 * all references added in the system.
 	 * @param fromPath - The absolute path of the node that added the reference.
 	 * @param toPath - The absolute path of the outbound node that is referenced.
+	 * @param messageTimestampMs - The timestamp of the message that added the reference.
 	 */
-	public addedGCOutboundRoute(fromPath: string, toPath: string) {
-		this.garbageCollector.addedOutboundReference(fromPath, toPath);
+	public addedGCOutboundRoute(fromPath: string, toPath: string, messageTimestampMs?: number) {
+		// This is always called when processing an op so messageTimestampMs should exist. Due to back-compat
+		// across the data store runtime / container runtime boundary, this may be undefined and if so, get
+		// the timestamp from the last processed message which should exist.
+		// If a timestamp doesn't exist, log so we can learn about these cases and return.
+		const timestampMs = messageTimestampMs ?? this.getCurrentReferenceTimestampMs();
+		if (timestampMs === undefined) {
+			this.mc.logger.sendTelemetryEvent({
+				eventName: "NoTimestampInGCOutboundRoute",
+				...tagCodeArtifacts({
+					id: toPath,
+					fromId: fromPath,
+				}),
+			});
+			return;
+		}
+		this.garbageCollector.addedOutboundReference(fromPath, toPath, timestampMs);
 	}
 
 	/**

package/src/dataStoreContext.ts

@@ -719,9 +719,10 @@ export abstract class FluidDataStoreContext
 	 *
 	 * @param fromPath - The absolute path of the node that added the reference.
 	 * @param toPath - The absolute path of the outbound node that is referenced.
+	 * @param messageTimestampMs - The timestamp of the message that added the reference.
 	 */
-	public addedGCOutboundRoute(fromPath: string, toPath: string) {
-		this.parentContext.addedGCOutboundRoute(fromPath, toPath);
+	public addedGCOutboundRoute(fromPath: string, toPath: string, messageTimestampMs?: number) {
+		this.parentContext.addedGCOutboundRoute(fromPath, toPath, messageTimestampMs);
 	}
 
 	/**

package/src/gc/garbageCollection.ts

@@ -892,9 +892,14 @@ export class GarbageCollector implements IGarbageCollector {
 	/**
 	 * Process a GC message.
 	 * @param message - The GC message from the container runtime.
+	 * @param messageTimestampMs - The timestamp of the message.
 	 * @param local - Whether it was send by this client.
 	 */
-	public processMessage(message: ContainerRuntimeGCMessage, local: boolean) {
+	public processMessage(
+		message: ContainerRuntimeGCMessage,
+		messageTimestampMs: number,
+		local: boolean,
+	) {
 		const gcMessageType = message.contents.type;
 		switch (gcMessageType) {
 			case GarbageCollectionMessageType.Sweep: {
@@ -909,7 +914,12 @@ export class GarbageCollector implements IGarbageCollector {
 
 				// Mark the node as referenced to ensure it isn't Swept
 				const tombstonedNodePath = message.contents.nodePath;
-				this.addedOutboundReference("/", tombstonedNodePath, true /* autorecovery */);
+				this.addedOutboundReference(
+					"/",
+					tombstonedNodePath,
+					messageTimestampMs,
+					true /* autorecovery */,
+				);
 
 				// In case the cause of the TombstoneLoaded event is incorrect GC Data (i.e. the object is actually reachable),
 				// do fullGC on the next run to get a chance to repair (in the likely case the bug is not deterministic)
@@ -990,7 +1000,9 @@ export class GarbageCollector implements IGarbageCollector {
 		request,
 		headerData,
 	}: IGCNodeUpdatedProps) {
-		if (!this.shouldRunGC) {
+		// 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 (!this.shouldRunGC || timestampMs === undefined) {
 			return;
 		}
 
@@ -1005,8 +1017,7 @@ export class GarbageCollector implements IGarbageCollector {
 		this.telemetryTracker.nodeUsed(trackedId, {
 			id: fullPath,
 			usageType: reason,
-			currentReferenceTimestampMs:
-				timestampMs ?? this.runtime.getCurrentReferenceTimestampMs(),
+			currentReferenceTimestampMs: timestampMs,
 			packagePath,
 			completedGCRuns: this.completedRuns,
 			isTombstoned,
@@ -1096,9 +1107,15 @@ export class GarbageCollector implements IGarbageCollector {
 	 *
 	 * @param fromNodePath - The node from which the reference is added.
 	 * @param toNodePath - The node to which the reference is added.
+	 * @param timestampMs - The timestamp of the message that added the reference.
 	 * @param autorecovery - This reference is added artificially, for autorecovery. Used for logging.
 	 */
-	public addedOutboundReference(fromNodePath: string, toNodePath: string, autorecovery?: true) {
+	public addedOutboundReference(
+		fromNodePath: string,
+		toNodePath: string,
+		timestampMs: number,
+		autorecovery?: true,
+	) {
 		if (!this.shouldRunGC) {
 			return;
 		}
@@ -1129,7 +1146,7 @@ export class GarbageCollector implements IGarbageCollector {
 			id: toNodePath,
 			fromId: fromNodePath,
 			usageType: "Revived",
-			currentReferenceTimestampMs: this.runtime.getCurrentReferenceTimestampMs(),
+			currentReferenceTimestampMs: timestampMs,
 			packagePath: undefined,
 			completedGCRuns: this.completedRuns,
 			isTombstoned: this.tombstones.includes(trackedId),

package/src/gc/gcDefinitions.ts

@@ -365,9 +365,18 @@ export interface IGarbageCollector {
 	 */
 	nodeUpdated(props: IGCNodeUpdatedProps): void;
 	/** Called when a reference is added to a node. Used to identify nodes that were referenced between summaries. */
-	addedOutboundReference(fromNodePath: string, toNodePath: string, autorecovery?: true): void;
+	addedOutboundReference(
+		fromNodePath: string,
+		toNodePath: string,
+		timestampMs: number,
+		autorecovery?: true,
+	): void;
 	/** Called to process a garbage collection message. */
-	processMessage(message: ContainerRuntimeGCMessage, local: boolean): void;
+	processMessage(
+		message: ContainerRuntimeGCMessage,
+		messageTimestampMs: number,
+		local: boolean,
+	): void;
 	/** Returns true if this node has been deleted by GC during sweep phase. */
 	isNodeDeleted(nodePath: string): boolean;
 	setConnectionState(connected: boolean, clientId?: string): void;
@@ -383,8 +392,11 @@ export interface IGCNodeUpdatedProps {
 	node: { type: (typeof GCNodeType)["DataStore" | "Blob"]; path: string };
 	/** Whether the node (or a subpath) was loaded or changed. */
 	reason: "Loaded" | "Changed";
-	/** The op-based timestamp when the node changed, if applicable */
-	timestampMs?: number;
+	/**
+	 * The op-based timestamp when the node changed. If the update is from receiving an op, this should
+	 * be the timestamp of the op. If not, this should be the timestamp of the last op processed.
+	 */
+	timestampMs: number | undefined;
 	/** The package path of the node. This may not be available if the node hasn't been loaded yet */
 	packagePath?: readonly string[];
 	/** The original request for loads to preserve it in telemetry */

package/src/gc/gcTelemetry.ts

@@ -63,7 +63,7 @@ interface INodeUsageProps extends ICommonProps {
 	/** The full path (in GC Path format) to the node in question */
 	id: string;
 	/** Latest timestamp received from the server, as a baseline for computing GC state/age */
-	currentReferenceTimestampMs: number | undefined;
+	currentReferenceTimestampMs: number;
 	/** The package path of the node. This may not be available if the node hasn't been loaded yet */
 	packagePath: readonly string[] | undefined;
 	/** In case of Revived - what node added the reference? */
@@ -165,12 +165,6 @@ export class GCTelemetryTracker {
 			...otherNodeUsageProps
 		}: INodeUsageProps,
 	) {
-		// 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 (currentReferenceTimestampMs === undefined) {
-			return;
-		}
-
 		// Note: For SubDataStore Load usage, trackedId will be the DataStore's id, not the full path in question.
 		// This is necessary because the SubDataStore path may be unrecognized by GC (if suited for a custom request handler)
 		const nodeStateTracker = this.getNodeStateTracker(trackedId);

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/container-runtime";
-export const pkgVersion = "2.0.0-dev-rc.5.0.0.271262";
+export const pkgVersion = "2.0.0-dev-rc.5.0.0.272251";

package/tsdoc.json

@@ -0,0 +1,4 @@
+{
+	"$schema": "https://developer.microsoft.com/json-schemas/tsdoc/v0/tsdoc.schema.json",
+	"extends": ["../../../common/build/build-common/tsdoc-base.json"]
+}