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

package/src/blobManager.ts

@@ -28,7 +28,7 @@ import {
 	IContainerRuntime,
 	IContainerRuntimeEvents,
 } from "@fluidframework/container-runtime-definitions";
-import { AttachState } from "@fluidframework/container-definitions";
+import { AttachState, ICriticalContainerError } from "@fluidframework/container-definitions";
 import {
 	ChildLogger,
 	loggerToMonitoringContext,
@@ -40,6 +40,7 @@ import {
 	ISummaryTreeWithStats,
 	ITelemetryContext,
 } from "@fluidframework/runtime-definitions";
+import { GenericError } from "@fluidframework/container-utils";
 import { ContainerRuntime, TombstoneResponseHeaderKey } from "./containerRuntime";
 import { sendGCUnexpectedUsageEvent, sweepAttachmentBlobsKey, throwOnTombstoneLoadKey } from "./gc";
 import { Throttler, formExponentialFn, IThrottler } from "./throttler";
@@ -132,14 +133,13 @@ interface PendingBlob {
 	status: PendingBlobStatus;
 	storageId?: string;
 	handleP: Deferred<IFluidHandle<ArrayBufferLike>>;
-	uploadP: Promise<ICreateBlobResponse>;
-	localUploadTime?: number;
-	serverUploadTime?: number;
+	uploadP?: Promise<ICreateBlobResponse>;
+	uploadTime?: number;
 	minTTLInSeconds?: number;
 }
 
 export interface IPendingBlobs {
-	[id: string]: { blob: string };
+	[id: string]: { blob: string; uploadTime?: number; minTTLInSeconds?: number };
 }
 
 export interface IBlobManagerEvents {
@@ -191,6 +191,8 @@ export class BlobManager extends TypedEventEmitter<IBlobManagerEvents> {
 	 */
 	private readonly tombstonedBlobs: Set<string> = new Set();
 
+	private readonly sendBlobAttachOp: (localId: string, storageId?: string) => void;
+
 	constructor(
 		private readonly routeContext: IFluidHandleContext,
 		snapshot: IBlobManagerLoadInfo,
@@ -205,7 +207,7 @@ export class BlobManager extends TypedEventEmitter<IBlobManagerEvents> {
 		 * knowledge of which they cannot request the blob from storage. It's important that this op is sequenced
 		 * before any ops that reference the local ID, otherwise, an invalid handle could be added to the document.
 		 */
-		private readonly sendBlobAttachOp: (localId: string, storageId?: string) => void,
+		sendBlobAttachOp: (localId: string, storageId?: string) => void,
 		// Called when a blob node is requested. blobPath is the path of the blob's node in GC's graph.
 		// blobPath's format - `/<BlobManager.basePath>/<blobId>`.
 		private readonly blobRequested: (blobPath: string) => void,
@@ -214,7 +216,7 @@ export class BlobManager extends TypedEventEmitter<IBlobManagerEvents> {
 		private readonly isBlobDeleted: (blobPath: string) => boolean,
 		private readonly runtime: IBlobManagerRuntime,
 		stashedBlobs: IPendingBlobs = {},
-		private readonly getCurrentReferenceTimestampMs: () => number | undefined,
+		private readonly closeContainer: (error?: ICriticalContainerError) => void,
 	) {
 		super();
 		this.mc = loggerToMonitoringContext(ChildLogger.create(this.runtime.logger, "BlobManager"));
@@ -230,6 +232,21 @@ export class BlobManager extends TypedEventEmitter<IBlobManagerEvents> {
 		// Begin uploading stashed blobs from previous container instance
 		Object.entries(stashedBlobs).forEach(([localId, entry]) => {
 			const blob = stringToBuffer(entry.blob, "base64");
+			if (entry.minTTLInSeconds && entry.uploadTime) {
+				const timeLapseSinceLocalUpload = (Date.now() - entry.uploadTime) / 1000;
+				// stashed entries with more than half-life in storage will not be reuploaded
+				if (entry.minTTLInSeconds - timeLapseSinceLocalUpload > entry.minTTLInSeconds / 2) {
+					this.pendingBlobs.set(localId, {
+						blob,
+						status: PendingBlobStatus.OfflinePendingOp,
+						handleP: new Deferred(),
+						uploadP: undefined,
+						uploadTime: entry.uploadTime,
+						minTTLInSeconds: entry.minTTLInSeconds,
+					});
+					return;
+				}
+			}
 			this.pendingBlobs.set(localId, {
 				blob,
 				status: PendingBlobStatus.OfflinePendingUpload,
@@ -237,6 +254,37 @@ export class BlobManager extends TypedEventEmitter<IBlobManagerEvents> {
 				uploadP: this.uploadBlob(localId, blob),
 			});
 		});
+
+		this.sendBlobAttachOp = (localId: string, blobId?: string) => {
+			const pendingEntry = this.pendingBlobs.get(localId);
+			if (pendingEntry?.uploadTime && pendingEntry?.minTTLInSeconds) {
+				const secondsSinceUpload = (Date.now() - pendingEntry.uploadTime) / 1000;
+				const expired = pendingEntry.minTTLInSeconds - secondsSinceUpload < 0;
+				this.mc.logger.sendTelemetryEvent({
+					eventName: "sendBlobAttach",
+					entryStatus: pendingEntry.status,
+					secondsSinceUpload,
+					minTTLInSeconds: pendingEntry.minTTLInSeconds,
+					expired,
+				});
+				if (expired) {
+					// we want to avoid submitting ops with broken handles
+					this.closeContainer(
+						new GenericError(
+							"Trying to submit a BlobAttach for expired blob",
+							undefined,
+							{
+								localId,
+								blobId,
+								entryStatus: pendingEntry.status,
+								secondsSinceUpload,
+							},
+						),
+					);
+				}
+			}
+			return sendBlobAttachOp(localId, blobId);
+		};
 	}
 
 	private get pendingOfflineUploads() {
@@ -428,9 +476,8 @@ export class BlobManager extends TypedEventEmitter<IBlobManagerEvents> {
 			0x386 /* Must have pending blob entry for uploaded blob */,
 		);
 		entry.storageId = response.id;
-		entry.localUploadTime = Date.now();
+		entry.uploadTime = Date.now();
 		entry.minTTLInSeconds = response.minTTLInSeconds;
-		entry.serverUploadTime = this.getCurrentReferenceTimestampMs();
 		if (this.runtime.connected) {
 			if (entry.status === PendingBlobStatus.OnlinePendingUpload) {
 				// Send a blob attach op. This serves two purposes:
@@ -438,7 +485,6 @@ export class BlobManager extends TypedEventEmitter<IBlobManagerEvents> {
 				//    until its storage ID is added to the next summary.
 				// 2. It will create a local ID to storage ID mapping in all clients which is needed to retrieve the
 				//    blob from the server via the storage ID.
-				this.logTimeInfo(entry, "sendBlobAttachResolveTTL");
 				this.sendBlobAttachOp(localId, response.id);
 				if (this.storageIds.has(response.id)) {
 					// The blob is de-duped. Set up a local ID to storage ID mapping and return the blob. Since this is
@@ -512,7 +558,6 @@ export class BlobManager extends TypedEventEmitter<IBlobManagerEvents> {
 		 * is called on reconnection.
 		 */
 		if (entry.status !== PendingBlobStatus.OnlinePendingOp) {
-			this.logTimeInfo(entry, "sendBlobAttachTransitionOfflineTTL");
 			this.sendBlobAttachOp(localId, entry.storageId);
 		}
 
@@ -534,9 +579,7 @@ export class BlobManager extends TypedEventEmitter<IBlobManagerEvents> {
 		const { localId, blobId }: { localId?: string; blobId?: string } = metadata;
 		assert(localId !== undefined, 0x50d /* local ID not available on reSubmit */);
 		const pendingEntry = this.pendingBlobs.get(localId);
-		if (pendingEntry) {
-			this.logTimeInfo(pendingEntry, "sendBlobAttachResubmitTTL");
-		}
+
 		if (!blobId) {
 			// We submitted this op while offline. The blob should have been uploaded by now.
 			assert(
@@ -549,32 +592,6 @@ export class BlobManager extends TypedEventEmitter<IBlobManagerEvents> {
 		return this.sendBlobAttachOp(localId, blobId);
 	}
 
-	private logTimeInfo(pendingEntry: PendingBlob, eventName: string) {
-		let timeLapseSinceLocalUpload: number = 0;
-		let timeLapseSinceServerUpload: number = 0;
-		let expiredUsingLocalTime;
-		let expiredUsingServerTime;
-		if (pendingEntry.localUploadTime) {
-			timeLapseSinceLocalUpload = (Date.now() - pendingEntry.localUploadTime) / 1000;
-			expiredUsingLocalTime =
-				(pendingEntry.minTTLInSeconds ?? 0) - timeLapseSinceLocalUpload < 0 ? true : false;
-		}
-		if (pendingEntry.serverUploadTime) {
-			timeLapseSinceServerUpload = (Date.now() - pendingEntry.serverUploadTime) / 1000;
-			expiredUsingServerTime =
-				(pendingEntry.minTTLInSeconds ?? 0) - timeLapseSinceServerUpload < 0 ? true : false;
-		}
-		this.mc.logger.sendTelemetryEvent({
-			eventName,
-			entryStatus: pendingEntry.status,
-			timeLapseSinceLocalUpload,
-			timeLapseSinceServerUpload,
-			minTTLInSeconds: pendingEntry.minTTLInSeconds,
-			expiredUsingLocalTime,
-			expiredUsingServerTime,
-		});
-	}
-
 	public processBlobAttachOp(message: ISequencedDocumentMessage, local: boolean) {
 		const localId = message.metadata?.localId;
 		const blobId = message.metadata?.blobId;
@@ -887,7 +904,13 @@ export class BlobManager extends TypedEventEmitter<IBlobManagerEvents> {
 	public getPendingBlobs(): IPendingBlobs {
 		const blobs = {};
 		for (const [key, entry] of this.pendingBlobs) {
-			blobs[key] = { blob: bufferToString(entry.blob, "base64") };
+			blobs[key] = entry.minTTLInSeconds
+				? {
+						blob: bufferToString(entry.blob, "base64"),
+						uploadTime: entry.uploadTime,
+						minTTLInSeconds: entry.minTTLInSeconds,
+				  }
+				: { blob: bufferToString(entry.blob, "base64") };
 		}
 		return blobs;
 	}

package/src/containerRuntime.ts

@@ -168,6 +168,7 @@ import {
 	Outbox,
 	OpSplitter,
 	RemoteMessageProcessor,
+	OpGroupingManager,
 } from "./opLifecycle";
 import { DeltaManagerSummarizerProxy } from "./deltaManagerSummarizerProxy";
 
@@ -205,7 +206,7 @@ export interface ISummaryBaseConfiguration {
 	/**
 	 * Defines the maximum allowed time to wait for a pending summary ack.
 	 * The maximum amount of time client will wait for a summarize is the minimum of
-	 * maxSummarizeAckWaitTime (currently 10 * 60 * 1000) and maxAckWaitTime.
+	 * maxSummarizeAckWaitTime (currently 3 * 60 * 1000) and maxAckWaitTime.
 	 */
 	maxAckWaitTime: number;
 	/**
@@ -301,7 +302,7 @@ export const DefaultSummaryConfiguration: ISummaryConfiguration = {
 
 	minOpsForLastSummaryAttempt: 10,
 
-	maxAckWaitTime: 10 * 60 * 1000, // 10 mins.
+	maxAckWaitTime: 3 * 60 * 1000, // 3 mins.
 
 	maxOpsSinceLastSummary: 7000,
 
@@ -402,6 +403,17 @@ export interface IContainerRuntimeOptions {
 	 * can be used to disable it at runtime.
 	 */
 	readonly enableOpReentryCheck?: boolean;
+	/**
+	 * If enabled, the runtime will group messages within a batch into a single
+	 * message to be sent to the service.
+	 * The grouping an ungrouping of such messages is handled by the "OpGroupingManager".
+	 *
+	 * By default, the feature is disabled. If enabled from options, the `Fluid.ContainerRuntime.DisableGroupedBatching`
+	 * flag can be used to disable it at runtime.
+	 *
+	 * @experimental Not ready for use.
+	 */
+	readonly enableGroupedBatching?: boolean;
 }
 
 /**
@@ -643,6 +655,7 @@ export class ContainerRuntime
 			maxBatchSizeInBytes = defaultMaxBatchSizeInBytes,
 			chunkSizeInBytes = defaultChunkSizeInBytes,
 			enableOpReentryCheck = false,
+			enableGroupedBatching = false,
 		} = runtimeOptions;
 
 		const registry = new FluidDataStoreRegistry(registryEntries);
@@ -726,6 +739,7 @@ export class ContainerRuntime
 				maxBatchSizeInBytes,
 				chunkSizeInBytes,
 				enableOpReentryCheck,
+				enableGroupedBatching,
 			},
 			containerScope,
 			logger,
@@ -1056,6 +1070,9 @@ export class ContainerRuntime
 		const disableChunking = this.mc.config.getBoolean(
 			"Fluid.ContainerRuntime.CompressionChunkingDisabled",
 		);
+
+		const opGroupingManager = new OpGroupingManager(this.groupedBatchingEnabled);
+
 		const opSplitter = new OpSplitter(
 			chunks,
 			this.context.submitBatchFn,
@@ -1063,9 +1080,11 @@ export class ContainerRuntime
 			runtimeOptions.maxBatchSizeInBytes,
 			this.mc.logger,
 		);
+
 		this.remoteMessageProcessor = new RemoteMessageProcessor(
 			opSplitter,
 			new OpDecompressor(this.mc.logger),
+			opGroupingManager,
 		);
 
 		this.handleContext = new ContainerFluidHandleContext("", this);
@@ -1193,9 +1212,15 @@ export class ContainerRuntime
 			() => this.storage,
 			(localId: string, blobId?: string) => {
 				if (!this.disposed) {
-					this.submit(ContainerMessageType.BlobAttach, undefined, undefined, {
-						localId,
-						blobId,
+					// 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();
 					});
 				}
 			},
@@ -1203,7 +1228,7 @@ export class ContainerRuntime
 			(blobPath: string) => this.garbageCollector.isNodeDeleted(blobPath),
 			this,
 			pendingRuntimeState?.pendingAttachmentBlobs,
-			() => this.getCurrentReferenceTimestampMs(),
+			(error?: ICriticalContainerError) => this.closeFn(error),
 		);
 
 		this.scheduleManager = new ScheduleManager(
@@ -1252,6 +1277,7 @@ export class ContainerRuntime
 				disablePartialFlush: disablePartialFlush === true,
 			},
 			logger: this.mc.logger,
+			groupingManager: opGroupingManager,
 		});
 
 		this.context.quorum.on("removeMember", (clientId: string) => {
@@ -1400,6 +1426,7 @@ export class ContainerRuntime
 				disablePartialFlush,
 			}),
 			telemetryDocumentId: this.telemetryDocumentId,
+			groupedBatchingEnabled: this.groupedBatchingEnabled,
 		});
 
 		ReportOpPerfTelemetry(this.context.clientId, this.deltaManager, this.logger);
@@ -1814,8 +1841,16 @@ export class ContainerRuntime
 
 		// Do shallow copy of message, as the processing flow will modify it.
 		const messageCopy = { ...messageArg };
-		const message = this.remoteMessageProcessor.process(messageCopy);
+		for (const message of this.remoteMessageProcessor.process(messageCopy)) {
+			this.processCore(message, local, runtimeMessage);
+		}
+	}
 
+	private processCore(
+		message: ISequencedDocumentMessage,
+		local: boolean,
+		runtimeMessage: boolean,
+	) {
 		// Surround the actual processing of the operation with messages to the schedule manager indicating
 		// the beginning and end. This allows it to emit appropriate events and/or pause the processing of new
 		// messages once a batch has been fully processed.
@@ -1870,8 +1905,7 @@ export class ContainerRuntime
 					}
 			}
 
-			// For back-compat, notify only about runtime messages for now.
-			if (runtimeMessage) {
+			if (runtimeMessage || this.groupedBatchingEnabled) {
 				this.emit("op", message, runtimeMessage);
 			}
 
@@ -3177,6 +3211,26 @@ 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(
 			logger,
 			event,
@@ -3316,6 +3370,13 @@ export class ContainerRuntime
 			);
 		}
 	}
+
+	private get groupedBatchingEnabled(): boolean {
+		const killSwitch = this.mc.config.getBoolean(
+			"Fluid.ContainerRuntime.DisableGroupedBatching",
+		);
+		return killSwitch !== true && this.runtimeOptions.enableGroupedBatching;
+	}
 }
 
 /**

package/src/gc/gcHelpers.ts

@@ -169,7 +169,7 @@ export function concatGarbageCollectionStates(
 			) {
 				assert(
 					nodeData.unreferencedTimestampMs === combineNodeData.unreferencedTimestampMs,
-					"Two entries for the same GC node with different unreferenced timestamp",
+					0x5d7 /* Two entries for the same GC node with different unreferenced timestamp */,
 				);
 			}
 			combineNodeData = {
@@ -253,7 +253,7 @@ export async function getGCDataFromSnapshot(
 			continue;
 		}
 		const gcState = await readAndParseBlob<IGarbageCollectionState>(blobId);
-		assert(gcState !== undefined, "GC blob missing from snapshot");
+		assert(gcState !== undefined, 0x5d8 /* GC blob missing from snapshot */);
 		// Merge the GC state of this blob into the root GC state.
 		rootGCState = concatGarbageCollectionStates(rootGCState, gcState);
 	}
@@ -280,7 +280,7 @@ export function unpackChildNodesGCDetails(gcDetails: IGarbageCollectionDetailsBa
 			continue;
 		}
 
-		assert(id.startsWith("/"), "node id should always be an absolute route");
+		assert(id.startsWith("/"), 0x5d9 /* node id should always be an absolute route */);
 		const childId = id.split("/")[1];
 		let childGCNodeId = id.slice(childId.length + 1);
 		// GC node id always begins with "/". Handle the special case where a child's id in the parent's GC nodes is
@@ -294,7 +294,10 @@ export function unpackChildNodesGCDetails(gcDetails: IGarbageCollectionDetailsBa
 			childGCDetails = { gcData: { gcNodes: {} }, usedRoutes: [] };
 		}
 		// gcData should not undefined as its always at least initialized as  empty above.
-		assert(childGCDetails.gcData !== undefined, "Child GC data should have been initialized");
+		assert(
+			childGCDetails.gcData !== undefined,
+			0x5da /* Child GC data should have been initialized */,
+		);
 		childGCDetails.gcData.gcNodes[childGCNodeId] = [...new Set(outboundRoutes)];
 		childGCDetailsMap.set(childId, childGCDetails);
 	}
@@ -306,14 +309,14 @@ export function unpackChildNodesGCDetails(gcDetails: IGarbageCollectionDetailsBa
 	// Remove the node's self used route, if any, and generate the children used routes.
 	const usedRoutes = gcDetails.usedRoutes.filter((route) => route !== "" && route !== "/");
 	for (const route of usedRoutes) {
-		assert(route.startsWith("/"), "Used route should always be an absolute route");
+		assert(route.startsWith("/"), 0x5db /* Used route should always be an absolute route */);
 		const childId = route.split("/")[1];
 		const childUsedRoute = route.slice(childId.length + 1);
 
 		const childGCDetails = childGCDetailsMap.get(childId);
 		assert(
 			childGCDetails?.usedRoutes !== undefined,
-			"This should have be initialized when generate GC nodes above",
+			0x5dc /* This should have be initialized when generate GC nodes above */,
 		);
 
 		childGCDetails.usedRoutes.push(childUsedRoute);

package/src/opLifecycle/README.md

@@ -12,10 +12,12 @@ By default, the runtime is configured with a max batch size of `716800` bytes, w
 
 -   [Introduction](#introduction)
     -   [Compression](#compression)
+    -   [Grouped batching](#grouped-batching)
     -   [Chunking for compression](#chunking-for-compression)
     -   [Disabling in case of emergency](#disabling-in-case-of-emergency)
     -   [Example configs](#example-configs)
     -   [How it works](#how-it-works)
+    -   [How grouped batching works](#how-grouped-batching-works)
 
 ## Compression
 
@@ -26,6 +28,16 @@ By default, the runtime is configured with a max batch size of `716800` bytes, w
 -   `minimumBatchSizeInBytes` – the minimum size of the batch for which compression should kick in. If the payload is too small, compression may not yield too many benefits. To target the original 1MB issue, a good value here would be to match the default maxBatchSizeInBytes (972800), however, experimentally, a good lower value could be at around 614400 bytes. Setting this value to `Number.POSITIVE_INFINITY` will disable compression.
 -   `compressionAlgorithm` – currently, only `lz4` is supported.
 
+## Grouped batching
+
+**Note: This feature is currently considered experimental and is not ready for production usage.**
+
+The `IContainerRuntimeOptions.enableGroupedBatching` option has been added to the container runtime layer and is **off by default**. This option will group all batch messages under a new "grouped" message to be sent to the service. Upon receiving this new "grouped" message, the batch messages will be extracted and given the sequence number of the parent "grouped" message.
+
+The purpose for enabling grouped batching on top of compression is that regular compression won't include the empty messages in the chunks. Thus, if we have batches with many messages (i.e. more than 4k), we will go over the batch size limit just on empty op envelopes alone.
+
+See [below](#how-grouped-batching-works) for an example.
+
 ## Chunking for compression
 
 **Op chunking for compression targets payloads which exceed the max batch size after compression.** So, only payloads which are already compressed. By default, the feature is enabled.
@@ -39,6 +51,7 @@ This config would govern chunking compressed batches only. We will not be enabli
 If the features are enabled using the configs, they can be disabled at runtime via feature gates as following:
 
 -   `Fluid.ContainerRuntime.CompressionDisabled` - if set to true, will disable compression (this has a side effect of also disabling chunking, as chunking is invoked only for compressed payloads).
+-   `Fluid.ContainerRuntime.DisableGroupedBatching` - if set to true, will disable grouped batching.
 -   `Fluid.ContainerRuntime.CompressionChunkingDisabled` - if set to true, will disable chunking for compression.
 
 ## Example configs
@@ -75,6 +88,14 @@ To disable compression (will also disable chunking, as chunking works only for c
     }
 ```
 
+To enable grouped batching:
+
+```
+    const runtimeOptions: IContainerRuntimeOptions = {
+        enableGroupedBatching: true,
+    }
+```
+
 ## How it works
 
 Compression currently works as a runtime layer over the regular op sending/receiving pipeline.
@@ -155,3 +176,88 @@ Notice that the sequence numbers don’t matter here, as all ops will be based o
 Additionally, as compression preserves the original uncompressed batch layout in terms of the number of ops by using empty ops to reserve the sequence numbers, this ensures that the clients will always receive the exact count of ops to rebuild the uncompressed batch sequentially.
 
 On the receiving end, the client will accumulate chunks 1 and 2 and keep them in memory. When chunk 3 is received, the original large, decompressed op will be rebuilt, and the runtime will then process the batch as if it is a compressed batch.
+
+## How grouped batching works
+
+**Note: There are plans to replace empty ops with something more efficient when doing grouped batching AB#4092**
+
+Given the following baseline batch:
+
+```
++---------------+---------------+---------------+---------------+---------------+
+| Op 1          | Op 2          | Op 3          | Op 4          | Op 5          |
+| Contents: "a" | Contents: "b" | Contents: "c" | Contents: "d" | Contents: "e" |
++---------------+---------------+---------------+---------------+---------------+
+```
+
+Compressed batch:
+
+```
++--------------------+-----------------+-----------------+-----------------+-----------------+
+| Op 1               | Op 2            | Op 3            | Op 4            | Op 5            |
+| Contents: "abcde"  | Contents: empty | Contents: empty | Contents: empty | Contents: empty |
+| Compression: 'lz4' |                 |                 |                 |                 |
++--------------------+-----------------+-----------------+-----------------+-----------------+
+```
+
+Grouped batch:
+
+```
++---------------------------------------------------------------------------------------------------------------------------------+
+| Op 1                   Contents: +--------------------+-----------------+-----------------+-----------------+-----------------+ |
+| SeqNum: 1                        | Op 1               | Op 2            | Op 3            | Op 4            | Op 5            | |
+| Type: "groupedBatch"             | Contents: "abcde"  | Contents: empty | Contents: empty | Contents: empty | Contents: empty | |
+|                                  | Compression: 'lz4' |                 |                 |                 |                 | |
+|                                  +--------------------+-----------------+-----------------+-----------------+-----------------+ |
++---------------------------------------------------------------------------------------------------------------------------------+
+```
+
+Can produce the following chunks:
+
+```
++-------------------------------------------------+
+| Chunk 1/2    Contents: +----------------------+ |
+| SeqNum: 1              |  +-----------------+ | |
+|                        |  | Contents: "abc" | | |
+|                        |  +-----------------+ | |
+|                        +----------------------+ |
++-------------------------------------------------+
+```
+
+```
++--------------------------------------------------------------------------------------------------------------------------+
+| Chunk 2/2    Contents: +---------------------------------------------------------------------------------------------+ | |
+| SeqNum: 2              |  +----------------+-----------------+-----------------+-----------------+-----------------+ | | |
+|                        |  | Contents: "de" | Contents: empty | Contents: empty | Contents: empty | Contents: empty | | | |
+|                        |  +----------------+-----------------+-----------------+-----------------+-----------------+ | | |
+|                        +---------------------------------------------------------------------------------------------+ | |
++--------------------------------------------------------------------------------------------------------------------------+
+```
+
+-   Send to service
+-   Service acks ops sent
+-   Receive chunks from service
+-   Recompile to the grouped batch step
+
+Ungrouped batch:
+
+```
++--------------------+-----------------+-----------------+-----------------+-----------------+
+| Op 1               | Op 2            | Op 3            | Op 4            | Op 5            |
+| Contents: "abcde"  | Contents: empty | Contents: empty | Contents: empty | Contents: empty |
+| SeqNum: 2          | SeqNum: 2       | SeqNum: 2       | SeqNum: 2       | SeqNum: 2       |
+| ClientSeqNum: 1    | ClientSeqNum: 2 | ClientSeqNum: 3 | ClientSeqNum: 4 | ClientSeqNum: 5 |
+| Compression: 'lz4' |                 |                 |                 |                 |
++--------------------+-----------------+-----------------+-----------------+-----------------+
+```
+
+Uncompressed batch:
+
+```
++-----------------+-----------------+-----------------+-----------------+-----------------+
+| Op 1            | Op 2            | Op 3            | Op 4            | Op 5            |
+| Contents: "a"   | Contents: "b"   | Contents: "c"   | Contents: "d"   | Contents: "e"   |
+| SeqNum: 2       | SeqNum: 2       | SeqNum: 2       | SeqNum: 2       | SeqNum: 2       |
+| ClientSeqNum: 1 | ClientSeqNum: 2 | ClientSeqNum: 3 | ClientSeqNum: 4 | ClientSeqNum: 5 |
++-----------------+-----------------+-----------------+-----------------+-----------------+
+```

package/src/opLifecycle/index.ts

@@ -16,3 +16,4 @@ export { OpCompressor } from "./opCompressor";
 export { OpDecompressor } from "./opDecompressor";
 export { OpSplitter, splitOp } from "./opSplitter";
 export { RemoteMessageProcessor, unpackRuntimeMessage } from "./remoteMessageProcessor";
+export { OpGroupingManager } from "./opGroupingManager";

package/src/opLifecycle/opDecompressor.ts

@@ -133,6 +133,7 @@ export class OpDecompressor {
 		 */
 		try {
 			if (
+				message.contents !== null &&
 				typeof message.contents === "object" &&
 				Object.keys(message.contents).length === 1 &&
 				message.contents?.packedContents !== undefined &&

package/src/opLifecycle/opGroupingManager.ts

@@ -0,0 +1,78 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { assert } from "@fluidframework/common-utils";
+import { ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
+import { ContainerRuntimeMessage } from "..";
+import { IBatch } from "./definitions";
+
+interface IGroupedMessage {
+	contents?: unknown;
+	metadata?: Record<string, unknown>;
+	compression?: string;
+}
+
+export class OpGroupingManager {
+	static groupedBatchOp = "groupedBatch";
+
+	constructor(private readonly groupedBatchingEnabled: boolean) {}
+
+	public groupBatch(batch: IBatch): IBatch {
+		if (batch.content.length < 2 || !this.groupedBatchingEnabled) {
+			return batch;
+		}
+
+		for (const message of batch.content) {
+			if (message.metadata) {
+				const keys = Object.keys(message.metadata);
+				assert(keys.length < 2, 0x5dd /* cannot group ops with metadata */);
+				assert(
+					keys.length === 0 || keys[0] === "batch",
+					0x5de /* unexpected op metadata */,
+				);
+			}
+		}
+
+		// Need deserializedContent for back-compat
+		const deserializedContent = {
+			type: OpGroupingManager.groupedBatchOp,
+			contents: batch.content.map<IGroupedMessage>((message) => ({
+				contents: message.contents === undefined ? undefined : JSON.parse(message.contents),
+				metadata: message.metadata,
+				compression: message.compression,
+			})),
+		};
+
+		const groupedBatch: IBatch = {
+			...batch,
+			content: [
+				{
+					localOpMetadata: undefined,
+					metadata: undefined,
+					referenceSequenceNumber: batch.content[0].referenceSequenceNumber,
+					deserializedContent: deserializedContent as ContainerRuntimeMessage,
+					contents: JSON.stringify(deserializedContent),
+				},
+			],
+		};
+		return groupedBatch;
+	}
+
+	public ungroupOp(op: ISequencedDocumentMessage): ISequencedDocumentMessage[] {
+		if (op.contents?.type !== OpGroupingManager.groupedBatchOp) {
+			return [op];
+		}
+
+		const messages = op.contents.contents as IGroupedMessage[];
+		let fakeCsn = 1;
+		return messages.map((subMessage) => ({
+			...op,
+			clientSequenceNumber: fakeCsn++,
+			contents: subMessage.contents,
+			metadata: subMessage.metadata,
+			compression: subMessage.compression,
+		}));
+	}
+}