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

package/src/opLifecycle/opCompressor.ts

@@ -4,11 +4,12 @@
  */
 
 import { ITelemetryLogger } from "@fluidframework/common-definitions";
-import { IsoBuffer } from "@fluidframework/common-utils";
+import { assert, IsoBuffer } from "@fluidframework/common-utils";
 import { UsageError } from "@fluidframework/container-utils";
 import { ChildLogger } from "@fluidframework/telemetry-utils";
 import { compress } from "lz4js";
 import { CompressionAlgorithms } from "../containerRuntime";
+import { estimateSocketSize } from "./batchManager";
 import { IBatch, BatchMessage } from "./definitions";
 
 /**
@@ -24,21 +25,17 @@ export class OpCompressor {
 	}
 
 	public compressBatch(batch: IBatch): IBatch {
+		assert(
+			batch.contentSizeInBytes > 0 && batch.content.length > 0,
+			0x5a4 /* Batch should not be empty */,
+		);
+
 		const compressionStart = Date.now();
 		const contentsAsBuffer = new TextEncoder().encode(this.serializeBatch(batch));
 		const compressedContents = compress(contentsAsBuffer);
 		const compressedContent = IsoBuffer.from(compressedContents).toString("base64");
 		const duration = Date.now() - compressionStart;
 
-		if (batch.contentSizeInBytes > 200000) {
-			this.logger.sendPerformanceEvent({
-				eventName: "CompressedBatch",
-				duration,
-				sizeBeforeCompression: batch.contentSizeInBytes,
-				sizeAfterCompression: compressedContent.length,
-			});
-		}
-
 		const messages: BatchMessage[] = [];
 		messages.push({
 			...batch.content[0],
@@ -47,15 +44,37 @@ export class OpCompressor {
 			compression: CompressionAlgorithms.lz4,
 		});
 
+		// Add empty placeholder messages to reserve the sequence numbers
 		for (const message of batch.content.slice(1)) {
-			messages.push({ ...message, contents: undefined });
+			messages.push({
+				deserializedContent: {
+					contents: undefined,
+					type: message.deserializedContent.type,
+				},
+				localOpMetadata: message.localOpMetadata,
+				metadata: message.metadata,
+				referenceSequenceNumber: message.referenceSequenceNumber,
+			});
 		}
 
-		return {
+		const compressedBatch: IBatch = {
 			contentSizeInBytes: compressedContent.length,
 			content: messages,
 			referenceSequenceNumber: batch.referenceSequenceNumber,
 		};
+
+		if (batch.contentSizeInBytes > 200000) {
+			this.logger.sendPerformanceEvent({
+				eventName: "CompressedBatch",
+				duration,
+				sizeBeforeCompression: batch.contentSizeInBytes,
+				sizeAfterCompression: compressedBatch.contentSizeInBytes,
+				opCount: compressedBatch.content.length,
+				socketSize: estimateSocketSize(compressedBatch),
+			});
+		}
+
+		return compressedBatch;
 	}
 
 	private serializeBatch(batch: IBatch): string {

package/src/opLifecycle/opDecompressor.ts

@@ -6,6 +6,8 @@
 import { decompress } from "lz4js";
 import { ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
 import { assert, IsoBuffer, Uint8ArrayToString } from "@fluidframework/common-utils";
+import { ChildLogger } from "@fluidframework/telemetry-utils";
+import { ITelemetryLogger } from "@fluidframework/common-definitions";
 import { CompressionAlgorithms } from "../containerRuntime";
 import { IMessageProcessingResult } from "./definitions";
 
@@ -21,6 +23,11 @@ export class OpDecompressor {
 	private activeBatch = false;
 	private rootMessageContents: any | undefined;
 	private processedCount = 0;
+	private readonly logger;
+
+	constructor(logger: ITelemetryLogger) {
+		this.logger = ChildLogger.create(logger, "OpDecompressor");
+	}
 
 	public processMessage(message: ISequencedDocumentMessage): IMessageProcessingResult {
 		assert(
@@ -28,7 +35,7 @@ export class OpDecompressor {
 			0x511 /* Only lz4 compression is supported */,
 		);
 
-		if (message.metadata?.batch === true && message.compression === CompressionAlgorithms.lz4) {
+		if (message.metadata?.batch === true && this.isCompressed(message)) {
 			// Beginning of a compressed batch
 			assert(this.activeBatch === false, 0x4b8 /* shouldn't have multiple active batches */);
 			if (message.compression) {
@@ -84,10 +91,7 @@ export class OpDecompressor {
 			};
 		}
 
-		if (
-			message.metadata?.batch === undefined &&
-			message.compression === CompressionAlgorithms.lz4
-		) {
+		if (message.metadata?.batch === undefined && this.isCompressed(message)) {
 			// Single compressed message
 			assert(
 				this.activeBatch === false,
@@ -110,6 +114,46 @@ export class OpDecompressor {
 			state: "Skipped",
 		};
 	}
+
+	private isCompressed(message: ISequencedDocumentMessage) {
+		if (message.compression === CompressionAlgorithms.lz4) {
+			return true;
+		}
+
+		/**
+		 * Back-compat self healing mechanism for ADO:3538, as loaders from
+		 * version client_v2.0.0-internal.1.2.0 to client_v2.0.0-internal.2.2.0 do not
+		 * support adding the proper compression metadata to compressed messages submitted
+		 * by the runtime. Should be removed after the loader reaches sufficient saturation
+		 * for a version greater or equal than client_v2.0.0-internal.2.2.0.
+		 *
+		 * The condition holds true for compressed messages, regardless of metadata. We are ultimately
+		 * looking for a message with a single property `packedContents` inside `contents`, of type 'string'
+		 * with a base64 encoded value.
+		 */
+		try {
+			if (
+				typeof message.contents === "object" &&
+				Object.keys(message.contents).length === 1 &&
+				message.contents?.packedContents !== undefined &&
+				typeof message.contents?.packedContents === "string" &&
+				message.contents.packedContents.length > 0 &&
+				IsoBuffer.from(message.contents.packedContents, "base64").toString("base64") ===
+					message.contents.packedContents
+			) {
+				this.logger.sendTelemetryEvent({
+					eventName: "LegacyCompression",
+					type: message.type,
+					batch: message.metadata?.batch,
+				});
+				return true;
+			}
+		} catch (err) {
+			return false;
+		}
+
+		return false;
+	}
 }
 
 // We should not be mutating the input message nor its metadata

package/src/opLifecycle/opSplitter.ts

@@ -13,6 +13,7 @@ import {
 import { ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
 import { ChildLogger } from "@fluidframework/telemetry-utils";
 import { ContainerMessageType, ContainerRuntimeMessage } from "../containerRuntime";
+import { estimateSocketSize } from "./batchManager";
 import { BatchMessage, IBatch, IChunkedOp, IMessageProcessingResult } from "./definitions";
 
 /**
@@ -28,7 +29,7 @@ export class OpSplitter {
 		private readonly submitBatchFn:
 			| ((batch: IBatchMessage[], referenceSequenceNumber?: number) => number)
 			| undefined,
-		private readonly chunkSizeInBytes: number,
+		public readonly chunkSizeInBytes: number,
 		private readonly maxBatchSizeInBytes: number,
 		logger: ITelemetryLogger,
 	) {
@@ -161,7 +162,15 @@ export class OpSplitter {
 		);
 
 		const restOfMessages = batch.content.slice(1); // we expect these to be empty ops, created to reserve sequence numbers
-		const chunks = splitOp(firstMessage, this.chunkSizeInBytes);
+		const socketSize = estimateSocketSize(batch);
+		const chunks = splitOp(
+			firstMessage,
+			this.chunkSizeInBytes,
+			// If we estimate that the socket batch size will exceed the batch limit
+			// we will inject an empty op to minimize the risk of the payload failing due to
+			// the overhead from the trailing empty ops in the batch.
+			socketSize >= this.maxBatchSizeInBytes,
+		);
 
 		assert(this.submitBatchFn !== undefined, 0x519 /* We don't support old loaders */);
 		// Send the first N-1 chunks immediately
@@ -181,11 +190,13 @@ export class OpSplitter {
 		);
 
 		this.logger.sendPerformanceEvent({
-			eventName: "Chunked compressed batch",
+			// Used to be "Chunked compressed batch"
+			eventName: "CompressedChunkedBatch",
 			length: batch.content.length,
 			sizeInBytes: batch.contentSizeInBytes,
 			chunks: chunks.length,
 			chunkSizeInBytes: this.chunkSizeInBytes,
+			socketSize,
 		});
 
 		return {
@@ -214,7 +225,23 @@ const chunkToBatchMessage = (
 	};
 };
 
-export const splitOp = (op: BatchMessage, chunkSizeInBytes: number): IChunkedOp[] => {
+/**
+ * Splits an op into smaller ops (chunks), based on the size of the op and the `chunkSizeInBytes` parameter.
+ *
+ * The last op of the result will be bundled with empty ops in the same batch. There is a risk of the batch payload
+ * exceeding the 1MB limit due to the overhead from the empty ops. If the last op is large, the risk is even higher.
+ * To minimize the odds, an extra empty op can be added to the result using the `extraOp` parameter.
+ *
+ * @param op - the op to be split
+ * @param chunkSizeInBytes - how large should the chunks be
+ * @param extraOp - should an extra empty op be added to the result
+ * @returns an array of chunked ops
+ */
+export const splitOp = (
+	op: BatchMessage,
+	chunkSizeInBytes: number,
+	extraOp: boolean = false,
+): IChunkedOp[] => {
 	const chunks: IChunkedOp[] = [];
 	assert(
 		op.contents !== undefined && op.contents !== null,
@@ -222,36 +249,33 @@ export const splitOp = (op: BatchMessage, chunkSizeInBytes: number): IChunkedOp[
 	);
 
 	const contentLength = op.contents.length;
-	const chunkCount = Math.floor((contentLength - 1) / chunkSizeInBytes) + 2;
+	const chunkCount = Math.floor((contentLength - 1) / chunkSizeInBytes) + 1 + (extraOp ? 1 : 0);
 	let offset = 0;
-	for (let i = 1; i < chunkCount; i++) {
+	for (let chunkId = 1; chunkId <= chunkCount; chunkId++) {
 		const chunk: IChunkedOp = {
-			chunkId: i,
+			chunkId,
 			contents: op.contents.substr(offset, chunkSizeInBytes),
 			originalType: op.deserializedContent.type,
 			totalChunks: chunkCount,
 		};
 
+		if (chunkId === chunkCount) {
+			// 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,
+			chunkId >= 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,
-	});
-
+	assert(chunks.length === chunkCount, 0x5a5 /* Expected number of chunks */);
 	return chunks;
 };

package/src/opLifecycle/outbox.ts

@@ -15,7 +15,7 @@ import {
 } from "@fluidframework/telemetry-utils";
 import { ICompressionRuntimeOptions } from "../containerRuntime";
 import { PendingStateManager } from "../pendingStateManager";
-import { BatchManager } from "./batchManager";
+import { BatchManager, estimateSocketSize } from "./batchManager";
 import { BatchMessage, IBatch } from "./definitions";
 import { OpCompressor } from "./opCompressor";
 import { OpSplitter } from "./opSplitter";
@@ -175,31 +175,35 @@ export class Outbox {
 		if (
 			batch.content.length === 0 ||
 			this.params.config.compressionOptions === undefined ||
-			this.params.config.compressionOptions.minimumBatchSizeInBytes > batch.contentSizeInBytes
+			this.params.config.compressionOptions.minimumBatchSizeInBytes >
+				batch.contentSizeInBytes ||
+			this.params.containerContext.submitBatchFn === undefined
 		) {
-			// Nothing to do if the batch is empty or if compression is disabled or if we don't need to compress
+			// Nothing to do if the batch is empty or if compression is disabled or not supported, or if we don't need to compress
 			return batch;
 		}
 
 		const compressedBatch = this.params.compressor.compressBatch(batch);
-		if (compressedBatch.contentSizeInBytes <= this.params.config.maxBatchSizeInBytes) {
-			// If we don't reach the maximum supported size of a batch, it can safely be sent as is
-			return compressedBatch;
-		}
 
 		if (this.params.splitter.isBatchChunkingEnabled) {
-			return this.params.splitter.splitCompressedBatch(compressedBatch);
+			return compressedBatch.contentSizeInBytes <= this.params.splitter.chunkSizeInBytes
+				? compressedBatch
+				: this.params.splitter.splitCompressedBatch(compressedBatch);
+		}
+
+		if (compressedBatch.contentSizeInBytes >= this.params.config.maxBatchSizeInBytes) {
+			throw new GenericError("BatchTooLarge", /* error */ undefined, {
+				batchSize: batch.contentSizeInBytes,
+				compressedBatchSize: compressedBatch.contentSizeInBytes,
+				count: compressedBatch.content.length,
+				limit: this.params.config.maxBatchSizeInBytes,
+				chunkingEnabled: this.params.splitter.isBatchChunkingEnabled,
+				compressionOptions: JSON.stringify(this.params.config.compressionOptions),
+				socketSize: estimateSocketSize(batch),
+			});
 		}
 
-		// If we've reached this point, the runtime would attempt to send a batch larger than the allowed size
-		throw new GenericError("BatchTooLarge", /* error */ undefined, {
-			batchSize: batch.contentSizeInBytes,
-			compressedBatchSize: compressedBatch.contentSizeInBytes,
-			count: compressedBatch.content.length,
-			limit: this.params.config.maxBatchSizeInBytes,
-			chunkingEnabled: this.params.splitter.isBatchChunkingEnabled,
-			compressionOptions: JSON.stringify(this.params.config.compressionOptions),
-		});
+		return compressedBatch;
 	}
 
 	/**
@@ -216,15 +220,25 @@ export class Outbox {
 			return;
 		}
 
+		const socketSize = estimateSocketSize(batch);
+		if (socketSize >= this.params.config.maxBatchSizeInBytes) {
+			this.mc.logger.sendPerformanceEvent({
+				eventName: "LargeBatch",
+				length: batch.content.length,
+				sizeInBytes: batch.contentSizeInBytes,
+				socketSize,
+			});
+		}
+
 		if (this.params.containerContext.submitBatchFn === undefined) {
 			// Legacy path - supporting old loader versions. Can be removed only when LTS moves above
 			// version that has support for batches (submitBatchFn)
-			for (const message of batch.content) {
-				// Legacy path doesn't support compressed payloads and will submit uncompressed payload anyways
-				if (message.metadata?.compressed) {
-					delete message.metadata.compressed;
-				}
+			assert(
+				batch.content[0].compression === undefined,
+				0x5a6 /* Compression should not have happened if the loader does not support it */,
+			);
 
+			for (const message of batch.content) {
 				this.params.containerContext.submitFn(
 					MessageType.Operation,
 					message.deserializedContent,

package/src/packageVersion.ts

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

package/src/storageServiceWithAttachBlobs.ts

@@ -0,0 +1,38 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import {
+	IDocumentStorageService,
+	IDocumentStorageServicePolicies,
+} from "@fluidframework/driver-definitions";
+import { DocumentStorageServiceProxy } from "@fluidframework/driver-utils";
+
+/**
+ * IDocumentStorageService proxy which intercepts requests if they can be satisfied by the blobs received in the
+ * attach message. We use this to avoid an unnecessary request to the storage service.
+ */
+export class StorageServiceWithAttachBlobs extends DocumentStorageServiceProxy {
+	constructor(
+		internalStorageService: IDocumentStorageService,
+		private readonly attachBlobs: Map<string, ArrayBufferLike>,
+	) {
+		super(internalStorageService);
+	}
+
+	public get policies(): IDocumentStorageServicePolicies | undefined {
+		return this.internalStorageService.policies;
+	}
+
+	public async readBlob(id: string): Promise<ArrayBufferLike> {
+		const blob = this.attachBlobs.get(id);
+		if (blob !== undefined) {
+			return blob;
+		}
+
+		// Note that it is intentional not to cache the result of this readBlob - we'll trust the real
+		// IDocumentStorageService to cache appropriately, no need to double-cache.
+		return this.internalStorageService.readBlob(id);
+	}
+}

package/src/summary/runWhileConnectedCoordinator.ts

@@ -35,10 +35,7 @@ export class RunWhileConnectedCoordinator implements ICancellableSummarizerContr
 
 	public get cancelled() {
 		if (!this._cancelled) {
-			assert(
-				this.runtime.deltaManager.active,
-				0x25d /* "We should never connect as 'read'" */,
-			);
+			assert(this.active(), 0x25d /* "We should never connect as 'read'" */);
 
 			// This check can't be enabled in current design due to lastSummary flow, where
 			// summarizer for closed container stays around and can produce one more summary.
@@ -63,13 +60,16 @@ export class RunWhileConnectedCoordinator implements ICancellableSummarizerContr
 		return this.stopDeferred.promise;
 	}
 
-	public static async create(runtime: IConnectableRuntime) {
-		const obj = new RunWhileConnectedCoordinator(runtime);
+	public static async create(runtime: IConnectableRuntime, active: () => boolean) {
+		const obj = new RunWhileConnectedCoordinator(runtime, active);
 		await obj.waitStart();
 		return obj;
 	}
 
-	protected constructor(private readonly runtime: IConnectableRuntime) {}
+	protected constructor(
+		private readonly runtime: IConnectableRuntime,
+		private readonly active: () => boolean,
+	) {}
 
 	/**
 	 * Starts and waits for a promise which resolves when connected.

package/src/summary/summarizerTypes.ts

@@ -84,6 +84,7 @@ export interface IConnectableRuntime {
 	readonly disposed: boolean;
 	readonly connected: boolean;
 	readonly clientId: string | undefined;
+	/** @deprecated - Moved to `ISummarizerRuntime` as it's no longer needed here */
 	readonly deltaManager: IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>;
 	once(event: "connected" | "disconnected" | "dispose", listener: () => void): this;
 }
@@ -92,6 +93,7 @@ export interface ISummarizerRuntime extends IConnectableRuntime {
 	readonly logger: ITelemetryLogger;
 	/** clientId of parent (non-summarizing) container that owns summarizer container */
 	readonly summarizerClientId: string | undefined;
+	readonly deltaManager: IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>;
 	disposeFn?(): void;
 	closeFn(): void;
 }