@fluidframework/container-runtime 2.0.0-dev.4.2.0.153917 → 2.0.0-dev.4.3.0.158678

package/src/containerRuntime.ts

@@ -31,6 +31,7 @@ import {
 } from "@fluidframework/container-runtime-definitions";
 import {
 	assert,
+	delay,
 	LazyPromise,
 	Trace,
 	TypedEventEmitter,
@@ -88,9 +89,14 @@ import {
 	CreateChildSummarizerNodeParam,
 	SummarizeInternalFn,
 	channelsTreeName,
-	IAttachMessage,
 	IDataStore,
 	ITelemetryContext,
+	SerializedIdCompressorWithNoSession,
+	IIdCompressor,
+	IIdCompressorCore,
+	IdCreationRange,
+	IdCreationRangeWithStashedState,
+	IAttachMessage,
 } from "@fluidframework/runtime-definitions";
 import {
 	addBlobToSummary,
@@ -123,6 +129,7 @@ import {
 	extractSummaryMetadataMessage,
 	IContainerRuntimeMetadata,
 	ICreateContainerMetadata,
+	idCompressorBlobName,
 	IFetchSnapshotResult,
 	IRootSummarizerNodeWithGC,
 	ISummaryMetadataMessage,
@@ -190,6 +197,13 @@ export enum ContainerMessageType {
 
 	// Sets the alias of a root data store
 	Alias = "alias",
+
+	/**
+	 * An op containing an IdRange of Ids allocated using the runtime's IdCompressor since
+	 * the last allocation op was sent.
+	 * See the [IdCompressor README](./id-compressor/README.md) for more details.
+	 */
+	IdAllocation = "idAllocation",
 }
 
 export interface ContainerRuntimeMessage {
@@ -393,6 +407,13 @@ export interface IContainerRuntimeOptions {
 	 * @experimental Not ready for use.
 	 */
 	readonly chunkSizeInBytes?: number;
+
+	/**
+	 * Enable the IdCompressor in the runtime.
+	 * @experimental Not ready for use.
+	 */
+	readonly enableRuntimeIdCompressor?: boolean;
+
 	/**
 	 * If enabled, the runtime will block all attempts to send an op inside the
 	 * {@link ContainerRuntime#ensureNoDataModelChanges} callback. The callback is used by
@@ -508,6 +529,13 @@ const defaultCompressionConfig = {
 
 const defaultChunkSizeInBytes = 204800;
 
+/**
+ * Instead of refreshing from latest because we do not have 100% confidence in the state
+ * of the current system, we should close the summarizer and let it recover.
+ * This delay's goal is to prevent tight restart loops
+ */
+const defaultCloseSummarizerDelayMs = 10000; // 10 seconds
+
 /**
  * @deprecated - use ContainerRuntimeMessage instead
  */
@@ -653,6 +681,7 @@ export class ContainerRuntime
 			flushMode = defaultFlushMode,
 			compressionOptions = defaultCompressionConfig,
 			maxBatchSizeInBytes = defaultMaxBatchSizeInBytes,
+			enableRuntimeIdCompressor = false,
 			chunkSizeInBytes = defaultChunkSizeInBytes,
 			enableOpReentryCheck = false,
 			enableGroupedBatching = false,
@@ -673,12 +702,14 @@ export class ContainerRuntime
 			}
 		};
 
-		const [chunks, metadata, electedSummarizerData, aliases] = await Promise.all([
-			tryFetchBlob<[string, string[]][]>(chunksBlobName),
-			tryFetchBlob<IContainerRuntimeMetadata>(metadataBlobName),
-			tryFetchBlob<ISerializedElection>(electedSummarizerBlobName),
-			tryFetchBlob<[string, string][]>(aliasBlobName),
-		]);
+		const [chunks, metadata, electedSummarizerData, aliases, serializedIdCompressor] =
+			await Promise.all([
+				tryFetchBlob<[string, string[]][]>(chunksBlobName),
+				tryFetchBlob<IContainerRuntimeMetadata>(metadataBlobName),
+				tryFetchBlob<ISerializedElection>(electedSummarizerBlobName),
+				tryFetchBlob<[string, string][]>(aliasBlobName),
+				tryFetchBlob<SerializedIdCompressorWithNoSession>(idCompressorBlobName),
+			]);
 
 		const loadExisting = existing === true || context.existing === true;
 
@@ -723,6 +754,17 @@ export class ContainerRuntime
 			}
 		}
 
+		const idCompressorEnabled =
+			metadata?.idCompressorEnabled ?? runtimeOptions.enableRuntimeIdCompressor ?? false;
+		let idCompressor: (IIdCompressor & IIdCompressorCore) | undefined;
+		if (idCompressorEnabled) {
+			const { IdCompressor, createSessionId } = await import("./id-compressor");
+			idCompressor =
+				serializedIdCompressor !== undefined
+					? IdCompressor.deserialize(serializedIdCompressor, createSessionId())
+					: new IdCompressor(createSessionId(), logger);
+		}
+
 		const runtime = new containerRuntimeCtor(
 			context,
 			registry,
@@ -738,6 +780,7 @@ export class ContainerRuntime
 				compressionOptions,
 				maxBatchSizeInBytes,
 				chunkSizeInBytes,
+				enableRuntimeIdCompressor,
 				enableOpReentryCheck,
 				enableGroupedBatching,
 			},
@@ -746,6 +789,7 @@ export class ContainerRuntime
 			loadExisting,
 			blobManagerSnapshot,
 			context.storage,
+			idCompressor,
 			requestHandler,
 			undefined, // summaryConfiguration
 			initializeEntryPoint,
@@ -816,6 +860,8 @@ export class ContainerRuntime
 		return this.context.attachState;
 	}
 
+	public idCompressor: (IIdCompressor & IIdCompressorCore) | undefined;
+
 	public get IFluidHandleContext(): IFluidHandleContext {
 		return this.handleContext;
 	}
@@ -910,6 +956,8 @@ export class ContainerRuntime
 	private emitDirtyDocumentEvent = true;
 	private readonly enableOpReentryCheck: boolean;
 	private readonly disableAttachReorder: boolean | undefined;
+	private readonly summaryStateUpdateMethod: string | undefined;
+	private readonly closeSummarizerDelayMs: number;
 
 	private readonly defaultTelemetrySignalSampleCount = 100;
 	private _perfSignalData: IPerfSignalReport = {
@@ -989,6 +1037,11 @@ export class ContainerRuntime
 	 */
 	private readonly telemetryDocumentId: string;
 
+	/**
+	 * If true, the runtime has access to an IdCompressor
+	 */
+	private readonly idCompressorEnabled: boolean;
+
 	/**
 	 * @internal
 	 */
@@ -1005,6 +1058,7 @@ export class ContainerRuntime
 		existing: boolean,
 		blobManagerSnapshot: IBlobManagerLoadInfo,
 		private readonly _storage: IDocumentStorageService,
+		idCompressor: (IIdCompressor & IIdCompressorCore) | undefined,
 		private readonly requestHandler?: (
 			request: IRequest,
 			runtime: IContainerRuntime,
@@ -1022,6 +1076,8 @@ export class ContainerRuntime
 		this.innerDeltaManager = context.deltaManager;
 		this.deltaManager = new DeltaManagerSummarizerProxy(context.deltaManager);
 
+		this.mc = loggerToMonitoringContext(ChildLogger.create(this.logger, "ContainerRuntime"));
+
 		let loadSummaryNumber: number;
 		// Get the container creation metadata. For new container, we initialize these. For existing containers,
 		// get the values from the metadata blob.
@@ -1033,12 +1089,20 @@ export class ContainerRuntime
 			// summaryNumber was renamed from summaryCount. For older docs that haven't been opened for a long time,
 			// the count is reset to 0.
 			loadSummaryNumber = metadata?.summaryNumber ?? 0;
+
+			// Enabling the IdCompressor is a one-way operation and we only want to
+			// allow new containers to turn it on
+			this.idCompressorEnabled = metadata?.idCompressorEnabled ?? false;
 		} else {
 			this.createContainerMetadata = {
 				createContainerRuntimeVersion: pkgVersion,
 				createContainerTimestamp: Date.now(),
 			};
 			loadSummaryNumber = 0;
+
+			this.idCompressorEnabled =
+				this.mc.config.getBoolean("Fluid.ContainerRuntime.IdCompressorEnabled") ??
+				idCompressor !== undefined;
 		}
 		this.nextSummaryNumber = loadSummaryNumber + 1;
 
@@ -1051,8 +1115,6 @@ export class ContainerRuntime
 			this.runtimeOptions.gcOptions[gcTombstoneGenerationOptionName] /* current */,
 		);
 
-		this.mc = loggerToMonitoringContext(ChildLogger.create(this.logger, "ContainerRuntime"));
-
 		this.mc.logger.sendTelemetryEvent({
 			eventName: "GCFeatureMatrix",
 			metadataValue: JSON.stringify(metadata?.gcFeatureMatrix),
@@ -1106,6 +1168,10 @@ export class ContainerRuntime
 		this.maxOpsSinceLastSummary = this.getMaxOpsSinceLastSummary();
 		this.initialSummarizerDelayMs = this.getInitialSummarizerDelayMs();
 
+		if (this.idCompressorEnabled) {
+			this.idCompressor = idCompressor;
+		}
+
 		this.maxConsecutiveReconnects =
 			this.mc.config.getNumber(maxConsecutiveReconnectsKey) ??
 			this.defaultMaxConsecutiveReconnects;
@@ -1212,15 +1278,9 @@ export class ContainerRuntime
 			() => this.storage,
 			(localId: string, blobId?: string) => {
 				if (!this.disposed) {
-					// eslint-disable-next-line @typescript-eslint/no-floating-promises
-					Promise.resolve().then(() => {
-						// Blob attaches need to be in their own batch (grouped batching would hide metadata)
-						this.flush();
-						this.submit(ContainerMessageType.BlobAttach, undefined, undefined, {
-							localId,
-							blobId,
-						});
-						this.flush();
+					this.submit(ContainerMessageType.BlobAttach, undefined, undefined, {
+						localId,
+						blobId,
 					});
 				}
 			},
@@ -1278,12 +1338,24 @@ export class ContainerRuntime
 			},
 			logger: this.mc.logger,
 			groupingManager: opGroupingManager,
+			getCurrentSequenceNumbers: () => ({
+				referenceSequenceNumber: this.deltaManager.lastSequenceNumber,
+				clientSequenceNumber: this._processedClientSequenceNumber,
+			}),
 		});
 
 		this.context.quorum.on("removeMember", (clientId: string) => {
 			this.remoteMessageProcessor.clearPartialMessagesFor(clientId);
 		});
 
+		this.summaryStateUpdateMethod = this.mc.config.getString(
+			"Fluid.ContainerRuntime.Test.SummaryStateUpdateMethod",
+		);
+		const closeSummarizerDelayOverride = this.mc.config.getNumber(
+			"Fluid.ContainerRuntime.Test.CloseSummarizerDelayOverrideMs",
+		);
+		this.closeSummarizerDelayMs = closeSummarizerDelayOverride ?? defaultCloseSummarizerDelayMs;
+
 		this.summaryCollection = new SummaryCollection(this.deltaManager, this.logger);
 
 		this.dirtyContainer =
@@ -1424,6 +1496,9 @@ export class ContainerRuntime
 				disableChunking,
 				disableAttachReorder: this.disableAttachReorder,
 				disablePartialFlush,
+				idCompressorEnabled: this.idCompressorEnabled,
+				summaryStateUpdateMethod: this.summaryStateUpdateMethod,
+				closeSummarizerDelayOverride,
 			}),
 			telemetryDocumentId: this.telemetryDocumentId,
 			groupedBatchingEnabled: this.groupedBatchingEnabled,
@@ -1603,6 +1678,7 @@ export class ContainerRuntime
 				extractSummaryMetadataMessage(this.deltaManager.lastMessage) ??
 				this.messageAtLastSummary,
 			telemetryDocumentId: this.telemetryDocumentId,
+			idCompressorEnabled: this.idCompressorEnabled ? true : undefined,
 		};
 		addBlobToSummary(summaryTree, metadataBlobName, JSON.stringify(metadata));
 	}
@@ -1615,6 +1691,15 @@ export class ContainerRuntime
 	) {
 		this.addMetadataToSummary(summaryTree);
 
+		if (this.idCompressorEnabled) {
+			assert(
+				this.idCompressor !== undefined,
+				0x67a /* IdCompressor should be defined if enabled */,
+			);
+			const idCompressorState = JSON.stringify(this.idCompressor.serialize(false));
+			addBlobToSummary(summaryTree, idCompressorBlobName, idCompressorState);
+		}
+
 		if (this.remoteMessageProcessor.partialMessages.size > 0) {
 			const content = JSON.stringify([...this.remoteMessageProcessor.partialMessages]);
 			addBlobToSummary(summaryTree, chunksBlobName, content);
@@ -1713,15 +1798,32 @@ export class ContainerRuntime
 		this.updateDocumentDirtyState(newState);
 	}
 
-	private async applyStashedOp(
-		type: ContainerMessageType,
-		op: ISequencedDocumentMessage,
-	): Promise<unknown> {
+	/**
+	 * Updates the runtime's IdCompressor with the stashed state present in the given op. This is a bit of a
+	 * hack and is unnecessarily expensive. As it stands, every locally stashed op (all ops that get stored in
+	 * the PendingStateManager) will store their serialized representation locally until ack'd. Upon receiving
+	 * this stashed state, the IdCompressor blindly deserializes to the stashed state and assumes the session.
+	 * Technically only the last stashed state is needed to do this correctly, but we would have to write some
+	 * more hacky code to modify the batch before it gets sent out.
+	 * @param content - An IdAllocationOp with "stashedState", which is a representation of un-ack'd local state.
+	 */
+	private async applyStashedIdAllocationOp(op: IdCreationRangeWithStashedState) {
+		const { IdCompressor } = await import("./id-compressor");
+		this.idCompressor = IdCompressor.deserialize(op.stashedState);
+	}
+
+	private async applyStashedOp(type: ContainerMessageType, contents: unknown): Promise<unknown> {
 		switch (type) {
 			case ContainerMessageType.FluidDataStoreOp:
-				return this.dataStores.applyStashedOp(op);
+				return this.dataStores.applyStashedOp(contents as IEnvelope);
 			case ContainerMessageType.Attach:
-				return this.dataStores.applyStashedAttachOp(op as unknown as IAttachMessage);
+				return this.dataStores.applyStashedAttachOp(contents as IAttachMessage);
+			case ContainerMessageType.IdAllocation:
+				assert(
+					this.idCompressor !== undefined,
+					0x67b /* IdCompressor should be defined if enabled */,
+				);
+				return this.applyStashedIdAllocationOp(contents as IdCreationRangeWithStashedState);
 			case ContainerMessageType.Alias:
 			case ContainerMessageType.BlobAttach:
 				return;
@@ -1846,6 +1948,8 @@ export class ContainerRuntime
 		}
 	}
 
+	private _processedClientSequenceNumber: number | undefined;
+
 	private processCore(
 		message: ISequencedDocumentMessage,
 		local: boolean,
@@ -1856,6 +1960,8 @@ export class ContainerRuntime
 		// messages once a batch has been fully processed.
 		this.scheduleManager.beforeOpProcessing(message);
 
+		this._processedClientSequenceNumber = message.clientSequenceNumber;
+
 		try {
 			let localOpMetadata: unknown;
 			if (local && runtimeMessage && message.type !== ContainerMessageType.ChunkedOp) {
@@ -1882,6 +1988,13 @@ export class ContainerRuntime
 				case ContainerMessageType.BlobAttach:
 					this.blobManager.processBlobAttachOp(message, local);
 					break;
+				case ContainerMessageType.IdAllocation:
+					assert(
+						this.idCompressor !== undefined,
+						0x67c /* IdCompressor should be defined if enabled */,
+					);
+					this.idCompressor.finalizeCreationRange(message.contents as IdCreationRange);
+					break;
 				case ContainerMessageType.ChunkedOp:
 				case ContainerMessageType.Rejoin:
 					break;
@@ -2325,31 +2438,33 @@ export class ContainerRuntime
 			runSweep,
 		});
 
-		let gcStats: IGCStats | undefined;
-		if (runGC) {
-			gcStats = await this.collectGarbage(
-				{ logger: summaryLogger, runSweep, fullGC },
+		try {
+			let gcStats: IGCStats | undefined;
+			if (runGC) {
+				gcStats = await this.collectGarbage(
+					{ logger: summaryLogger, runSweep, fullGC },
+					telemetryContext,
+				);
+			}
+
+			const { stats, summary } = await this.summarizerNode.summarize(
+				fullTree,
+				trackState,
 				telemetryContext,
 			);
-		}
 
-		const { stats, summary } = await this.summarizerNode.summarize(
-			fullTree,
-			trackState,
-			telemetryContext,
-		);
-
-		this.logger.sendTelemetryEvent({
-			eventName: "SummarizeTelemetry",
-			details: telemetryContext.serialize(),
-		});
-
-		assert(
-			summary.type === SummaryType.Tree,
-			0x12f /* "Container Runtime's summarize should always return a tree" */,
-		);
+			assert(
+				summary.type === SummaryType.Tree,
+				0x12f /* "Container Runtime's summarize should always return a tree" */,
+			);
 
-		return { stats, summary, gcStats };
+			return { stats, summary, gcStats };
+		} finally {
+			this.logger.sendTelemetryEvent({
+				eventName: "SummarizeTelemetry",
+				details: telemetryContext.serialize(),
+			});
+		}
 	}
 
 	/**
@@ -2831,6 +2946,40 @@ export class ContainerRuntime
 		return this.blobManager.createBlob(blob);
 	}
 
+	private maybeSubmitIdAllocationOp(type: ContainerMessageType) {
+		if (type !== ContainerMessageType.IdAllocation) {
+			let idAllocationBatchMessage: BatchMessage | undefined;
+			let idRange: IdCreationRange | undefined;
+			if (this.idCompressorEnabled) {
+				assert(
+					this.idCompressor !== undefined,
+					0x67d /* IdCompressor should be defined if enabled */,
+				);
+				idRange = this.idCompressor.takeNextCreationRange();
+				// Don't include the idRange if there weren't any Ids allocated
+				idRange = idRange?.ids?.first !== undefined ? idRange : undefined;
+			}
+
+			if (idRange !== undefined) {
+				const idAllocationMessage: ContainerRuntimeMessage = {
+					type: ContainerMessageType.IdAllocation,
+					contents: idRange,
+				};
+				idAllocationBatchMessage = {
+					contents: JSON.stringify(idAllocationMessage),
+					deserializedContent: idAllocationMessage,
+					referenceSequenceNumber: this.deltaManager.lastSequenceNumber,
+					metadata: undefined,
+					localOpMetadata: this.idCompressor?.serialize(true),
+				};
+			}
+
+			if (idAllocationBatchMessage !== undefined) {
+				this.outbox.submit(idAllocationBatchMessage);
+			}
+		}
+	}
+
 	private submit(
 		type: ContainerMessageType,
 		contents: any,
@@ -2866,6 +3015,12 @@ export class ContainerRuntime
 		};
 
 		try {
+			// Submit an IdAllocation op if any Ids have been generated since
+			// the last op was submitted. Don't submit another if it's an IdAllocation
+			// op as that means we're in resubmission flow and we don't want to send
+			// IdRanges out of order.
+			this.maybeSubmitIdAllocationOp(type);
+
 			// If this is attach message for new data store, and we are in a batch, send this op out of order
 			// Is it safe:
 			//    Yes, this should be safe reordering. Newly created data stores are not visible through API surface.
@@ -3028,6 +3183,7 @@ export class ContainerRuntime
 				break;
 			case ContainerMessageType.Attach:
 			case ContainerMessageType.Alias:
+			case ContainerMessageType.IdAllocation:
 				this.submit(type, content, localOpMetadata);
 				break;
 			case ContainerMessageType.ChunkedOp:
@@ -3093,6 +3249,25 @@ export class ContainerRuntime
 				readAndParseBlob,
 			);
 
+			/**
+			 * back-compat - Older loaders and drivers (pre 2.0.0-internal.1.4) don't have fetchSource as a param in the
+			 * getVersions API. So, they will not fetch the latest snapshot from network in the previous fetch call. For
+			 * these scenarios, fetch the snapshot corresponding to the ack handle to have the same behavior before the
+			 * change that started fetching latest snapshot always.
+			 */
+			if (fetchResult.latestSnapshotRefSeq < summaryRefSeq) {
+				fetchResult = await this.fetchSnapshotFromStorage(
+					summaryLogger,
+					{
+						eventName: "RefreshLatestSummaryAckFetchBackCompat",
+						ackHandle,
+						targetSequenceNumber: summaryRefSeq,
+					},
+					readAndParseBlob,
+					ackHandle,
+				);
+			}
+
 			/**
 			 * If the fetched snapshot is older than the one for which the ack was received, close the container.
 			 * This should never happen because an ack should be sent after the latest summary is updated in the server.
@@ -3104,32 +3279,18 @@ export class ContainerRuntime
 			 * state.
 			 */
 			if (fetchResult.latestSnapshotRefSeq < summaryRefSeq) {
-				/* before failing, let's try to retrieve the latest snapshot for that specific ackHandle */
-				fetchResult = await this.fetchSnapshotFromStorage(
-					summaryLogger,
+				const error = DataProcessingError.create(
+					"Fetched snapshot is older than the received ack",
+					"RefreshLatestSummaryAck",
+					undefined /* sequencedMessage */,
 					{
-						eventName: "RefreshLatestSummaryAckFetch",
 						ackHandle,
-						targetSequenceNumber: summaryRefSeq,
+						summaryRefSeq,
+						fetchedSnapshotRefSeq: fetchResult.latestSnapshotRefSeq,
 					},
-					readAndParseBlob,
-					ackHandle,
 				);
-
-				if (fetchResult.latestSnapshotRefSeq < summaryRefSeq) {
-					const error = DataProcessingError.create(
-						"Fetched snapshot is older than the received ack",
-						"RefreshLatestSummaryAck",
-						undefined /* sequencedMessage */,
-						{
-							ackHandle,
-							summaryRefSeq,
-							fetchedSnapshotRefSeq: fetchResult.latestSnapshotRefSeq,
-						},
-					);
-					this.closeFn(error);
-					throw error;
-				}
+				this.closeFn(error);
+				throw error;
 			}
 
 			// In case we had to retrieve the latest snapshot and it is different than summaryRefSeq,
@@ -3211,27 +3372,7 @@ export class ContainerRuntime
 		readAndParseBlob: ReadAndParseBlob,
 		versionId: string | null,
 	): Promise<{ snapshotTree: ISnapshotTree; versionId: string; latestSnapshotRefSeq: number }> {
-		const recoveryMethod = this.mc.config.getString(
-			"Fluid.ContainerRuntime.Test.SummarizationRecoveryMethod",
-		);
-		if (recoveryMethod === "restart") {
-			const error = new GenericError("Restarting summarizer instead of refreshing");
-			this.mc.logger.sendTelemetryEvent(
-				{
-					...event,
-					eventName: "ClosingSummarizerOnSummaryStale",
-					codePath: event.eventName,
-					message: "Stopping fetch from storage",
-					versionId: versionId != null ? versionId : undefined,
-				},
-				error,
-			);
-			this._summarizer?.stop("latestSummaryStateStale");
-			this.closeFn();
-			throw error;
-		}
-
-		return PerformanceEvent.timedExecAsync(
+		const snapshotResults = await PerformanceEvent.timedExecAsync(
 			logger,
 			event,
 			async (perfEvent: {
@@ -3277,6 +3418,33 @@ export class ContainerRuntime
 				};
 			},
 		);
+
+		// We choose to close the summarizer after the snapshot cache is updated to avoid
+		// situations which the main client (which is likely to be re-elected as the leader again)
+		// loads the summarizer from cache.
+		if (this.summaryStateUpdateMethod === "restart") {
+			const error = new GenericError("Restarting summarizer instead of refreshing");
+
+			this.mc.logger.sendTelemetryEvent(
+				{
+					...event,
+					eventName: "ClosingSummarizerOnSummaryStale",
+					codePath: event.eventName,
+					message: "Stopping fetch from storage",
+					versionId: versionId != null ? versionId : undefined,
+					closeSummarizerDelayMs: this.closeSummarizerDelayMs,
+				},
+				error,
+			);
+
+			// Delay 10 seconds before restarting summarizer to prevent the summarizer from restarting too frequently.
+			await delay(this.closeSummarizerDelayMs);
+			this._summarizer?.stop("latestSummaryStateStale");
+			this.closeFn();
+			throw error;
+		}
+
+		return snapshotResults;
 	}
 
 	public notifyAttaching() {} // do nothing (deprecated method)

package/src/dataStoreContext.ts

@@ -48,6 +48,8 @@ import {
 	ISummarizerNodeWithGC,
 	SummarizeInternalFn,
 	ITelemetryContext,
+	IIdCompressor,
+	IIdCompressorCore,
 	VisibilityState,
 } from "@fluidframework/runtime-definitions";
 import {
@@ -193,6 +195,10 @@ export abstract class FluidDataStoreContext
 		return this._baseSnapshot;
 	}
 
+	public get idCompressor(): (IIdCompressorCore & IIdCompressor) | undefined {
+		return this._containerRuntime.idCompressor;
+	}
+
 	private _disposed = false;
 	public get disposed() {
 		return this._disposed;

package/src/dataStores.ts

@@ -116,7 +116,7 @@ export class DataStores implements IDisposable {
 	constructor(
 		private readonly baseSnapshot: ISnapshotTree | undefined,
 		private readonly runtime: ContainerRuntime,
-		private readonly submitAttachFn: (attachContent: any) => void,
+		private readonly submitAttachFn: (attachContent: IAttachMessage) => void,
 		private readonly getCreateChildSummarizerNodeFn: (
 			id: string,
 			createParam: CreateChildSummarizerNodeParam,
@@ -399,22 +399,19 @@ export class DataStores implements IDisposable {
 	}
 	public readonly dispose = () => this.disposeOnce.value;
 
-	public resubmitDataStoreOp(content: any, localOpMetadata: unknown) {
-		const envelope = content as IEnvelope;
+	public resubmitDataStoreOp(envelope: IEnvelope, localOpMetadata: unknown) {
 		const context = this.contexts.get(envelope.address);
 		assert(!!context, 0x160 /* "There should be a store context for the op" */);
 		context.reSubmit(envelope.contents, localOpMetadata);
 	}
 
-	public rollbackDataStoreOp(content: any, localOpMetadata: unknown) {
-		const envelope = content as IEnvelope;
+	public rollbackDataStoreOp(envelope: IEnvelope, localOpMetadata: unknown) {
 		const context = this.contexts.get(envelope.address);
 		assert(!!context, 0x2e8 /* "There should be a store context for the op" */);
 		context.rollback(envelope.contents, localOpMetadata);
 	}
 
-	public async applyStashedOp(content: any): Promise<unknown> {
-		const envelope = content as IEnvelope;
+	public async applyStashedOp(envelope: IEnvelope): Promise<unknown> {
 		const context = this.contexts.get(envelope.address);
 		assert(!!context, 0x161 /* "There should be a store context for the op" */);
 		return context.applyStashedOp(envelope.contents);

package/src/gc/garbageCollection.ts

@@ -465,6 +465,13 @@ export class GarbageCollector implements IGarbageCollector {
 		const fullGC =
 			options.fullGC ??
 			(this.configs.runFullGC === true || this.summaryStateTracker.doesSummaryStateNeedReset);
+
+		// Add the options that are used to run GC to the telemetry context.
+		telemetryContext?.setMultiple("fluid_GC", "Options", {
+			fullGC,
+			runSweep: options.runSweep,
+		});
+
 		const logger = options.logger
 			? ChildLogger.create(options.logger, undefined, {
 					all: { completedGCRuns: () => this.completedRuns },
@@ -489,12 +496,6 @@ export class GarbageCollector implements IGarbageCollector {
 			return undefined;
 		}
 
-		// Add the options that are used to run GC to the telemetry context.
-		telemetryContext?.setMultiple("fluid_GC", "Options", {
-			fullGC,
-			runSweep: options.runSweep,
-		});
-
 		return PerformanceEvent.timedExecAsync(
 			logger,
 			{ eventName: "GarbageCollection" },