@fluidframework/container-runtime 2.0.0-internal.3.1.0 → 2.0.0-internal.3.2.1

package/src/gc/gcUnreferencedStateTracker.ts

@@ -0,0 +1,114 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { assert, Timer } from "@fluidframework/common-utils";
+import { UnreferencedState } from "./gcDefinitions";
+
+/** A wrapper around common-utils Timer that requires the timeout when calling start/restart */
+class TimerWithNoDefaultTimeout extends Timer {
+	constructor(private readonly callback: () => void) {
+		// The default timeout/handlers will never be used since start/restart pass overrides below
+		super(0, () => {
+			throw new Error("DefaultHandler should not be used");
+		});
+	}
+
+	start(timeoutMs: number) {
+		super.start(timeoutMs, this.callback);
+	}
+
+	restart(timeoutMs: number): void {
+		super.restart(timeoutMs, this.callback);
+	}
+}
+
+/**
+ * Helper class that tracks the state of an unreferenced node such as the time it was unreferenced and if it can
+ * be deleted by the sweep phase.
+ */
+export class UnreferencedStateTracker {
+	private _state: UnreferencedState = UnreferencedState.Active;
+	public get state(): UnreferencedState {
+		return this._state;
+	}
+
+	/** Timer to indicate when an unreferenced object is considered Inactive */
+	private readonly inactiveTimer: TimerWithNoDefaultTimeout;
+	/** Timer to indicate when an unreferenced object is Sweep-Ready */
+	private readonly sweepTimer: TimerWithNoDefaultTimeout;
+
+	constructor(
+		public readonly unreferencedTimestampMs: number,
+		/** The time after which node transitions to Inactive state. */
+		private readonly inactiveTimeoutMs: number,
+		/** The current reference timestamp used to track how long this node has been unreferenced for. */
+		currentReferenceTimestampMs: number,
+		/** The time after which node transitions to SweepReady state; undefined if session expiry is disabled. */
+		private readonly sweepTimeoutMs: number | undefined,
+	) {
+		if (this.sweepTimeoutMs !== undefined) {
+			assert(
+				this.inactiveTimeoutMs <= this.sweepTimeoutMs,
+				0x3b0 /* inactive timeout must not be greater than the sweep timeout */,
+			);
+		}
+
+		this.sweepTimer = new TimerWithNoDefaultTimeout(() => {
+			this._state = UnreferencedState.SweepReady;
+			assert(
+				!this.inactiveTimer.hasTimer,
+				0x3b1 /* inactiveTimer still running after sweepTimer fired! */,
+			);
+		});
+
+		this.inactiveTimer = new TimerWithNoDefaultTimeout(() => {
+			this._state = UnreferencedState.Inactive;
+
+			// After the node becomes inactive, start the sweep timer after which the node will be ready for sweep.
+			if (this.sweepTimeoutMs !== undefined) {
+				this.sweepTimer.restart(this.sweepTimeoutMs - this.inactiveTimeoutMs);
+			}
+		});
+		this.updateTracking(currentReferenceTimestampMs);
+	}
+
+	/* Updates the unreferenced state based on the provided timestamp. */
+	public updateTracking(currentReferenceTimestampMs: number) {
+		const unreferencedDurationMs = currentReferenceTimestampMs - this.unreferencedTimestampMs;
+
+		// If the node has been unreferenced for sweep timeout amount of time, update the state to SweepReady.
+		if (this.sweepTimeoutMs !== undefined && unreferencedDurationMs >= this.sweepTimeoutMs) {
+			this._state = UnreferencedState.SweepReady;
+			this.clearTimers();
+			return;
+		}
+
+		// If the node has been unreferenced for inactive timeoutMs amount of time, update the state to inactive.
+		// Also, start a timer for the sweep timeout.
+		if (unreferencedDurationMs >= this.inactiveTimeoutMs) {
+			this._state = UnreferencedState.Inactive;
+			this.inactiveTimer.clear();
+
+			if (this.sweepTimeoutMs !== undefined) {
+				this.sweepTimer.restart(this.sweepTimeoutMs - unreferencedDurationMs);
+			}
+			return;
+		}
+
+		// The node is still active. Ensure the inactive timer is running with the proper remaining duration.
+		this.inactiveTimer.restart(this.inactiveTimeoutMs - unreferencedDurationMs);
+	}
+
+	private clearTimers() {
+		this.inactiveTimer.clear();
+		this.sweepTimer.clear();
+	}
+
+	/** Stop tracking this node. Reset the unreferenced timers and state, if any. */
+	public stopTracking() {
+		this.clearTimers();
+		this._state = UnreferencedState.Active;
+	}
+}

package/src/gc/index.ts

@@ -0,0 +1,40 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+export { GarbageCollector } from "./garbageCollection";
+export {
+	currentGCVersion,
+	defaultInactiveTimeoutMs,
+	defaultSessionExpiryDurationMs,
+	disableSweepLogKey,
+	GCNodeType,
+	gcTestModeKey,
+	gcTombstoneGenerationOptionName,
+	GCVersion,
+	gcVersionUpgradeToV2Key,
+	IGarbageCollectionRuntime,
+	IGarbageCollector,
+	IGarbageCollectorCreateParams,
+	IGCMetadata,
+	IGCStats,
+	oneDayMs,
+	runGCKey,
+	runSessionExpiryKey,
+	runSweepKey,
+	stableGCVersion,
+	sweepAttachmentBlobsKey,
+	sweepDatastoresKey,
+	throwOnTombstoneLoadKey,
+	throwOnTombstoneUsageKey,
+	UnreferencedState,
+} from "./gcDefinitions";
+export { sendGCUnexpectedUsageEvent, shouldAllowGcTombstoneEnforcement } from "./gcHelpers";
+export { GCSummaryStateTracker } from "./gcSummaryStateTracker";
+export {
+	skipClosureForXDaysKey,
+	closuresMapLocalStorageKey,
+	SweepReadyUsageDetectionHandler,
+} from "./gcSweepReadyUsageDetection";
+export { UnreferencedStateTracker } from "./gcUnreferencedStateTracker";

package/src/index.ts

@@ -27,15 +27,22 @@ export {
 	CompressionAlgorithms,
 } from "./containerRuntime";
 export { FluidDataStoreRegistry } from "./dataStoreRegistry";
-export { IGCStats } from "./garbageCollection";
+export { IGCStats } from "./gc";
 export {
 	IPendingFlush,
 	IPendingLocalState,
 	IPendingMessage,
 	IPendingState,
 } from "./pendingStateManager";
-export { Summarizer } from "./summarizer";
 export {
+	IAckedSummary,
+	ISummarizer,
+	ISummarizeResults,
+	ISummaryCancellationToken,
+	neverCancelledSummaryToken,
+	Summarizer,
+	SummarizerStopReason,
+	SummaryCollection,
 	EnqueueSummarizeResult,
 	IAckSummaryResult,
 	IBaseSummarizeResult,
@@ -52,20 +59,13 @@ export {
 	ISubmitSummaryOpResult,
 	ISubmitSummaryOptions,
 	ISummarizeOptions,
-	ISummarizeResults,
-	ISummarizer,
 	ISummarizerEvents,
 	ISummarizerInternalsProvider,
 	ISummarizerRuntime,
 	ISummarizingWarning,
-	ISummaryCancellationToken,
 	IUploadSummaryResult,
 	SubmitSummaryResult,
 	SummarizeResultPart,
-	SummarizerStopReason,
-} from "./summarizerTypes";
-export {
-	IAckedSummary,
 	IClientSummaryWatcher,
 	ISummary,
 	ISummaryCollectionOpEvents,
@@ -74,10 +74,6 @@ export {
 	ISummaryOpMessage,
 	OpActionEventListener,
 	OpActionEventName,
-	SummaryCollection,
-} from "./summaryCollection";
-export {
 	ICancellableSummarizerController,
-	neverCancelledSummaryToken,
-} from "./runWhileConnectedCoordinator";
+} from "./summary";
 export { IChunkedOp, unpackRuntimeMessage } from "./opLifecycle";

package/src/opLifecycle/batchManager.ts

@@ -3,14 +3,10 @@
  * Licensed under the MIT License.
  */
 
-import { ITelemetryLogger } from "@fluidframework/common-definitions";
-import { UsageError } from "@fluidframework/driver-utils";
-import { ChildLogger } from "@fluidframework/telemetry-utils";
 import { ICompressionRuntimeOptions } from "../containerRuntime";
 import { BatchMessage, IBatch, IBatchCheckpoint } from "./definitions";
 
 export interface IBatchManagerOptions {
-	readonly enableOpReentryCheck?: boolean;
 	readonly hardLimit: number;
 	readonly softLimit?: number;
 	readonly compressionOptions?: ICompressionRuntimeOptions;
@@ -20,17 +16,8 @@ export interface IBatchManagerOptions {
  * Helper class that manages partial batch & rollback.
  */
 export class BatchManager {
-	private readonly logger;
 	private pendingBatch: BatchMessage[] = [];
 	private batchContentSize = 0;
-	/**
-	 * Track the number of ops which were detected to have a mismatched
-	 * reference sequence number, in order to self-throttle the telemetry events.
-	 *
-	 * This should be removed as part of ADO:2322
-	 */
-	private readonly maxMismatchedOpsToReport = 5;
-	private mismatchedOpsReported = 0;
 
 	public get length() {
 		return this.pendingBatch.length;
@@ -39,13 +26,15 @@ export class BatchManager {
 		return this.batchContentSize;
 	}
 
-	constructor(public readonly options: IBatchManagerOptions, logger: ITelemetryLogger) {
-		this.logger = ChildLogger.create(logger, "BatchManager");
+	public get referenceSequenceNumber(): number | undefined {
+		return this.pendingBatch.length === 0
+			? undefined
+			: this.pendingBatch[this.pendingBatch.length - 1].referenceSequenceNumber;
 	}
 
-	public push(message: BatchMessage): boolean {
-		this.checkReferenceSequenceNumber(message);
+	constructor(public readonly options: IBatchManagerOptions) {}
 
+	public push(message: BatchMessage): boolean {
 		const contentSize = this.batchContentSize + (message.contents?.length ?? 0);
 		const opCount = this.pendingBatch.length;
 
@@ -86,6 +75,7 @@ export class BatchManager {
 		const batch: IBatch = {
 			content: this.pendingBatch,
 			contentSizeInBytes: this.batchContentSize,
+			referenceSequenceNumber: this.referenceSequenceNumber,
 		};
 
 		this.pendingBatch = [];
@@ -112,43 +102,6 @@ export class BatchManager {
 			},
 		};
 	}
-
-	private checkReferenceSequenceNumber(message: BatchMessage) {
-		if (
-			this.pendingBatch.length === 0 ||
-			message.referenceSequenceNumber === this.pendingBatch[0].referenceSequenceNumber
-		) {
-			// The reference sequence numbers are stable
-			return;
-		}
-
-		const telemetryProperties = {
-			referenceSequenceNumber: this.pendingBatch[0].referenceSequenceNumber,
-			messageReferenceSequenceNumber: message.referenceSequenceNumber,
-			type: message.deserializedContent.type,
-			length: this.pendingBatch.length,
-			enableOpReentryCheck: this.options.enableOpReentryCheck === true,
-		};
-		const error = new UsageError("Submission of an out of order message");
-		const eventName = "ReferenceSequenceNumberMismatch";
-
-		if (this.options.enableOpReentryCheck === true) {
-			this.logger.sendErrorEvent({ eventName, ...telemetryProperties }, error);
-			throw error;
-		}
-
-		if (++this.mismatchedOpsReported <= this.maxMismatchedOpsToReport) {
-			this.logger.sendErrorEvent(
-				{
-					eventName,
-					...telemetryProperties,
-					ops: this.mismatchedOpsReported,
-					maxOps: this.maxMismatchedOpsToReport,
-				},
-				error,
-			);
-		}
-	}
 }
 
 const addBatchMetadata = (batch: IBatch): IBatch => {

package/src/opLifecycle/definitions.ts

@@ -30,6 +30,10 @@ export interface IBatch {
 	 * All the messages in the batch
 	 */
 	readonly content: BatchMessage[];
+	/**
+	 * The reference sequence number for the batch
+	 */
+	readonly referenceSequenceNumber: number | undefined;
 }
 
 export interface IBatchCheckpoint {

package/src/opLifecycle/opCompressor.ts

@@ -54,6 +54,7 @@ export class OpCompressor {
 		return {
 			contentSizeInBytes: compressedContent.length,
 			content: messages,
+			referenceSequenceNumber: batch.referenceSequenceNumber,
 		};
 	}
 

package/src/opLifecycle/opSplitter.ts

@@ -25,7 +25,9 @@ export class OpSplitter {
 
 	constructor(
 		chunks: [string, string[]][],
-		private readonly submitBatchFn: ((batch: IBatchMessage[]) => number) | undefined,
+		private readonly submitBatchFn:
+			| ((batch: IBatchMessage[], referenceSequenceNumber?: number) => number)
+			| undefined,
 		private readonly chunkSizeInBytes: number,
 		private readonly maxBatchSizeInBytes: number,
 		logger: ITelemetryLogger,
@@ -138,6 +140,10 @@ export class OpSplitter {
 			batch.contentSizeInBytes > 0 && batch.content.length > 0,
 			0x514 /* Batch needs to be non-empty */,
 		);
+		assert(
+			batch.referenceSequenceNumber !== undefined,
+			0x58a /* Batch must have a reference sequence number if non-empty */,
+		);
 		assert(this.chunkSizeInBytes !== 0, 0x515 /* Chunk size needs to be non-zero */);
 		assert(
 			this.chunkSizeInBytes < this.maxBatchSizeInBytes,
@@ -160,14 +166,17 @@ export class OpSplitter {
 		assert(this.submitBatchFn !== undefined, 0x519 /* We don't support old loaders */);
 		// Send the first N-1 chunks immediately
 		for (const chunk of chunks.slice(0, -1)) {
-			this.submitBatchFn([chunkToBatchMessage(chunk, firstMessage.referenceSequenceNumber)]);
+			this.submitBatchFn(
+				[chunkToBatchMessage(chunk, batch.referenceSequenceNumber)],
+				batch.referenceSequenceNumber,
+			);
 		}
 
 		// The last chunk will be part of the new batch and needs to
 		// preserve the batch metadata of the original batch
 		const lastChunk = chunkToBatchMessage(
 			chunks[chunks.length - 1],
-			firstMessage.referenceSequenceNumber,
+			batch.referenceSequenceNumber,
 			{ batch: firstMessage.metadata?.batch },
 		);
 
@@ -182,6 +191,7 @@ export class OpSplitter {
 		return {
 			content: [lastChunk, ...restOfMessages],
 			contentSizeInBytes: lastChunk.contents?.length ?? 0,
+			referenceSequenceNumber: batch.referenceSequenceNumber,
 		};
 	}
 }
@@ -212,27 +222,36 @@ export const splitOp = (op: BatchMessage, chunkSizeInBytes: number): IChunkedOp[
 	);
 
 	const contentLength = op.contents.length;
-	const chunkN = Math.floor((contentLength - 1) / chunkSizeInBytes) + 1;
+	const chunkCount = Math.floor((contentLength - 1) / chunkSizeInBytes) + 2;
 	let offset = 0;
-	for (let i = 1; i <= chunkN; i++) {
+	for (let i = 1; i < chunkCount; i++) {
 		const chunk: IChunkedOp = {
 			chunkId: i,
 			contents: op.contents.substr(offset, chunkSizeInBytes),
 			originalType: op.deserializedContent.type,
-			totalChunks: chunkN,
+			totalChunks: chunkCount,
 		};
 
-		if (i === chunkN) {
-			// We don't need to port these to all the chunks,
-			// as we rebuild the original op when we process the
-			// last chunk, therefore it is the only one that needs it.
-			chunk.originalMetadata = op.metadata;
-			chunk.originalCompression = op.compression;
-		}
-
 		chunks.push(chunk);
 		offset += chunkSizeInBytes;
+		assert(
+			i === chunkCount - 1 || offset <= contentLength,
+			0x58b /* Content offset within bounds */,
+		);
 	}
 
+	assert(offset >= contentLength, 0x58c /* Content offset equal or larger than content length */);
+	// The last chunk has empty contents, to minimize the risk of the
+	// resulting payload exceeding 1MB due to the overhead from the empty ops
+	// which will be bundled with this op.
+	chunks.push({
+		chunkId: chunkCount,
+		contents: "",
+		originalType: op.deserializedContent.type,
+		totalChunks: chunkCount,
+		originalMetadata: op.metadata,
+		originalCompression: op.compression,
+	});
+
 	return chunks;
 };

package/src/opLifecycle/outbox.ts

@@ -6,8 +6,13 @@
 import { ITelemetryLogger } from "@fluidframework/common-definitions";
 import { assert } from "@fluidframework/common-utils";
 import { IContainerContext } from "@fluidframework/container-definitions";
-import { GenericError } from "@fluidframework/container-utils";
+import { GenericError, UsageError } from "@fluidframework/container-utils";
 import { MessageType } from "@fluidframework/protocol-definitions";
+import {
+	ChildLogger,
+	loggerToMonitoringContext,
+	MonitoringContext,
+} from "@fluidframework/telemetry-utils";
 import { ICompressionRuntimeOptions } from "../containerRuntime";
 import { PendingStateManager } from "../pendingStateManager";
 import { BatchManager } from "./batchManager";
@@ -19,7 +24,7 @@ export interface IOutboxConfig {
 	readonly compressionOptions: ICompressionRuntimeOptions;
 	// The maximum size of a batch that we can send over the wire.
 	readonly maxBatchSizeInBytes: number;
-	readonly enableOpReentryCheck?: boolean;
+	readonly disablePartialFlush: boolean;
 }
 
 export interface IOutboxParameters {
@@ -33,11 +38,22 @@ export interface IOutboxParameters {
 }
 
 export class Outbox {
+	private readonly mc: MonitoringContext;
 	private readonly attachFlowBatch: BatchManager;
 	private readonly mainBatch: BatchManager;
-	private readonly defaultAttachFlowSoftLimitInBytes = 64 * 1024;
+	private readonly defaultAttachFlowSoftLimitInBytes = 320 * 1024;
+
+	/**
+	 * Track the number of ops which were detected to have a mismatched
+	 * reference sequence number, in order to self-throttle the telemetry events.
+	 *
+	 * This should be removed as part of ADO:2322
+	 */
+	private readonly maxMismatchedOpsToReport = 3;
+	private mismatchedOpsReported = 0;
 
 	constructor(private readonly params: IOutboxParameters) {
+		this.mc = loggerToMonitoringContext(ChildLogger.create(params.logger, "Outbox"));
 		const isCompressionEnabled =
 			this.params.config.compressionOptions.minimumBatchSizeInBytes !==
 			Number.POSITIVE_INFINITY;
@@ -45,28 +61,63 @@ export class Outbox {
 		const hardLimit = isCompressionEnabled ? Infinity : this.params.config.maxBatchSizeInBytes;
 		const softLimit = isCompressionEnabled ? Infinity : this.defaultAttachFlowSoftLimitInBytes;
 
-		this.attachFlowBatch = new BatchManager(
-			{
-				hardLimit,
-				softLimit,
-				enableOpReentryCheck: params.config.enableOpReentryCheck,
-			},
-			params.logger,
-		);
-		this.mainBatch = new BatchManager(
-			{
-				hardLimit,
-				enableOpReentryCheck: params.config.enableOpReentryCheck,
-			},
-			params.logger,
-		);
+		this.attachFlowBatch = new BatchManager({ hardLimit, softLimit });
+		this.mainBatch = new BatchManager({ hardLimit });
 	}
 
 	public get isEmpty(): boolean {
 		return this.attachFlowBatch.length === 0 && this.mainBatch.length === 0;
 	}
 
+	/**
+	 * If we detect that the reference sequence number of the incoming message does not match
+	 * what was already in the batch managers, this means that batching has been interrupted so
+	 * we will flush the accumulated messages to account for that and create a new batch with the new
+	 * message as the first message.
+	 *
+	 * @param message - the incoming message
+	 */
+	private maybeFlushPartialBatch(message: BatchMessage) {
+		const mainBatchReference = this.mainBatch.referenceSequenceNumber;
+		const attachFlowBatchReference = this.attachFlowBatch.referenceSequenceNumber;
+		assert(
+			this.params.config.disablePartialFlush ||
+				mainBatchReference === undefined ||
+				attachFlowBatchReference === undefined ||
+				mainBatchReference === attachFlowBatchReference,
+			0x58d /* Reference sequence numbers from both batches must be in sync */,
+		);
+
+		if (
+			(mainBatchReference === undefined ||
+				mainBatchReference === message.referenceSequenceNumber) &&
+			(attachFlowBatchReference === undefined ||
+				attachFlowBatchReference === message.referenceSequenceNumber)
+		) {
+			// The reference sequence numbers are stable, there is nothing to do
+			return;
+		}
+
+		if (++this.mismatchedOpsReported <= this.maxMismatchedOpsToReport) {
+			this.mc.logger.sendErrorEvent(
+				{
+					eventName: "ReferenceSequenceNumberMismatch",
+					mainReferenceSequenceNumber: mainBatchReference,
+					attachReferenceSequenceNumber: attachFlowBatchReference,
+					messageReferenceSequenceNumber: message.referenceSequenceNumber,
+				},
+				new UsageError("Submission of an out of order message"),
+			);
+		}
+
+		if (!this.params.config.disablePartialFlush) {
+			this.flush();
+		}
+	}
+
 	public submit(message: BatchMessage) {
+		this.maybeFlushPartialBatch(message);
+
 		if (!this.mainBatch.push(message)) {
 			throw new GenericError("BatchTooLarge", /* error */ undefined, {
 				opSize: message.contents?.length ?? 0,
@@ -78,6 +129,8 @@ export class Outbox {
 	}
 
 	public submitAttach(message: BatchMessage) {
+		this.maybeFlushPartialBatch(message);
+
 		if (!this.attachFlowBatch.push(message)) {
 			// BatchManager has two limits - soft limit & hard limit. Soft limit is only engaged
 			// when queue is not empty.
@@ -113,9 +166,9 @@ export class Outbox {
 
 	private flushInternal(rawBatch: IBatch) {
 		const processedBatch = this.compressBatch(rawBatch);
-		const clientSequenceNumber = this.sendBatch(processedBatch);
+		this.sendBatch(processedBatch);
 
-		this.persistBatch(clientSequenceNumber, rawBatch.content);
+		this.persistBatch(rawBatch.content);
 	}
 
 	private compressBatch(batch: IBatch): IBatch {
@@ -153,17 +206,14 @@ export class Outbox {
 	 * Sends the batch object to the container context to be sent over the wire.
 	 *
 	 * @param batch - batch to be sent
-	 * @returns the client sequence number of the last batched op which was sent and
-	 * -1 if there are no ops or the container cannot send ops.
 	 */
-	private sendBatch(batch: IBatch): number {
-		let clientSequenceNumber: number = -1;
+	private sendBatch(batch: IBatch) {
 		const length = batch.content.length;
 
 		// Did we disconnect in the middle of turn-based batch?
 		// If so, do nothing, as pending state manager will resubmit it correctly on reconnect.
 		if (length === 0 || !this.params.shouldSend()) {
-			return clientSequenceNumber;
+			return;
 		}
 
 		if (this.params.containerContext.submitBatchFn === undefined) {
@@ -175,7 +225,7 @@ export class Outbox {
 					delete message.metadata.compressed;
 				}
 
-				clientSequenceNumber = this.params.containerContext.submitFn(
+				this.params.containerContext.submitFn(
 					MessageType.Operation,
 					message.deserializedContent,
 					true, // batch
@@ -185,37 +235,33 @@ export class Outbox {
 
 			this.params.containerContext.deltaManager.flush();
 		} else {
-			// returns clientSequenceNumber of last message in a batch
-			clientSequenceNumber = this.params.containerContext.submitBatchFn(
+			assert(
+				batch.referenceSequenceNumber !== undefined,
+				0x58e /* Batch must not be empty */,
+			);
+			this.params.containerContext.submitBatchFn(
 				batch.content.map((message) => ({
 					contents: message.contents,
 					metadata: message.metadata,
 					compression: message.compression,
+					referenceSequenceNumber: message.referenceSequenceNumber,
 				})),
+				batch.referenceSequenceNumber,
 			);
 		}
-
-		// Convert from clientSequenceNumber of last message in the batch to clientSequenceNumber of first message.
-		clientSequenceNumber -= length - 1;
-		assert(clientSequenceNumber >= 0, 0x3d0 /* clientSequenceNumber can't be negative */);
-		return clientSequenceNumber;
 	}
 
-	private persistBatch(initialClientSequenceNumber: number, batch: BatchMessage[]) {
-		let clientSequenceNumber = initialClientSequenceNumber;
+	private persistBatch(batch: BatchMessage[]) {
 		// Let the PendingStateManager know that a message was submitted.
 		// In future, need to shift toward keeping batch as a whole!
 		for (const message of batch) {
 			this.params.pendingStateManager.onSubmitMessage(
 				message.deserializedContent.type,
-				clientSequenceNumber,
 				message.referenceSequenceNumber,
 				message.deserializedContent.contents,
 				message.localOpMetadata,
 				message.metadata,
 			);
-
-			clientSequenceNumber++;
 		}
 	}
 

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/container-runtime";
-export const pkgVersion = "2.0.0-internal.3.1.0";
+export const pkgVersion = "2.0.0-internal.3.2.1";