@fluidframework/container-runtime 2.0.0-internal.3.0.2 → 2.0.0-internal.3.2.0

package/src/opLifecycle/batchManager.ts

@@ -3,161 +3,118 @@
  * 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;
+	readonly hardLimit: number;
+	readonly softLimit?: number;
+	readonly compressionOptions?: ICompressionRuntimeOptions;
 }
 
 /**
  * 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; }
-    public get contentSizeInBytes() { return this.batchContentSize; }
-
-    constructor(
-        public readonly options: IBatchManagerOptions,
-        logger: ITelemetryLogger,
-    ) {
-        this.logger = ChildLogger.create(logger, "BatchManager");
-    }
-
-    public push(message: BatchMessage): boolean {
-        this.checkReferenceSequenceNumber(message);
-
-        const contentSize = this.batchContentSize + (message.contents?.length ?? 0);
-        const opCount = this.pendingBatch.length;
-
-        // Attempt to estimate batch size, aka socket message size.
-        // Each op has pretty large envelope, estimating to be 200 bytes.
-        // Also content will be strigified, and that adds a lot of overhead due to a lot of escape characters.
-        // Not taking it into account, as compression work should help there - compressed payload will be
-        // initially stored as base64, and that requires only 2 extra escape characters.
-        const socketMessageSize = contentSize + 200 * opCount;
-
-        // If we were provided soft limit, check for exceeding it.
-        // But only if we have any ops, as the intention here is to flush existing ops (on exceeding this limit)
-        // and start over. That's not an option if we have no ops.
-        // If compression is enabled, the soft and hard limit are ignored and the message will be pushed anyways.
-        // Cases where the message is still too large will be handled by the maxConsecutiveReconnects path.
-        if (this.options.softLimit !== undefined
-            && this.length > 0
-            && socketMessageSize >= this.options.softLimit) {
-            return false;
-        }
-
-        if (socketMessageSize >= this.options.hardLimit) {
-            return false;
-        }
-
-        this.batchContentSize = contentSize;
-        this.pendingBatch.push(message);
-        return true;
-    }
-
-    public get empty() { return this.pendingBatch.length === 0; }
-
-    public popBatch(): IBatch {
-        const batch: IBatch = {
-            content: this.pendingBatch,
-            contentSizeInBytes: this.batchContentSize,
-        };
-
-        this.pendingBatch = [];
-        this.batchContentSize = 0;
-
-        return addBatchMetadata(batch);
-    }
-
-    /**
-     * Capture the pending state at this point
-     */
-    public checkpoint(): IBatchCheckpoint {
-        const startPoint = this.pendingBatch.length;
-        return {
-            rollback: (process: (message: BatchMessage) => void) => {
-                for (let i = this.pendingBatch.length; i > startPoint;) {
-                    i--;
-                    const message = this.pendingBatch[i];
-                    this.batchContentSize -= message.contents?.length ?? 0;
-                    process(message);
-                }
-
-                this.pendingBatch.length = startPoint;
-            },
-        };
-    }
-
-    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,
-            );
-        }
-    }
+	private pendingBatch: BatchMessage[] = [];
+	private batchContentSize = 0;
+
+	public get length() {
+		return this.pendingBatch.length;
+	}
+	public get contentSizeInBytes() {
+		return this.batchContentSize;
+	}
+
+	public get referenceSequenceNumber(): number | undefined {
+		return this.pendingBatch.length === 0
+			? undefined
+			: this.pendingBatch[this.pendingBatch.length - 1].referenceSequenceNumber;
+	}
+
+	constructor(public readonly options: IBatchManagerOptions) {}
+
+	public push(message: BatchMessage): boolean {
+		const contentSize = this.batchContentSize + (message.contents?.length ?? 0);
+		const opCount = this.pendingBatch.length;
+
+		// Attempt to estimate batch size, aka socket message size.
+		// Each op has pretty large envelope, estimating to be 200 bytes.
+		// Also content will be strigified, and that adds a lot of overhead due to a lot of escape characters.
+		// Not taking it into account, as compression work should help there - compressed payload will be
+		// initially stored as base64, and that requires only 2 extra escape characters.
+		const socketMessageSize = contentSize + 200 * opCount;
+
+		// If we were provided soft limit, check for exceeding it.
+		// But only if we have any ops, as the intention here is to flush existing ops (on exceeding this limit)
+		// and start over. That's not an option if we have no ops.
+		// If compression is enabled, the soft and hard limit are ignored and the message will be pushed anyways.
+		// Cases where the message is still too large will be handled by the maxConsecutiveReconnects path.
+		if (
+			this.options.softLimit !== undefined &&
+			this.length > 0 &&
+			socketMessageSize >= this.options.softLimit
+		) {
+			return false;
+		}
+
+		if (socketMessageSize >= this.options.hardLimit) {
+			return false;
+		}
+
+		this.batchContentSize = contentSize;
+		this.pendingBatch.push(message);
+		return true;
+	}
+
+	public get empty() {
+		return this.pendingBatch.length === 0;
+	}
+
+	public popBatch(): IBatch {
+		const batch: IBatch = {
+			content: this.pendingBatch,
+			contentSizeInBytes: this.batchContentSize,
+			referenceSequenceNumber: this.referenceSequenceNumber,
+		};
+
+		this.pendingBatch = [];
+		this.batchContentSize = 0;
+
+		return addBatchMetadata(batch);
+	}
+
+	/**
+	 * Capture the pending state at this point
+	 */
+	public checkpoint(): IBatchCheckpoint {
+		const startPoint = this.pendingBatch.length;
+		return {
+			rollback: (process: (message: BatchMessage) => void) => {
+				for (let i = this.pendingBatch.length; i > startPoint; ) {
+					i--;
+					const message = this.pendingBatch[i];
+					this.batchContentSize -= message.contents?.length ?? 0;
+					process(message);
+				}
+
+				this.pendingBatch.length = startPoint;
+			},
+		};
+	}
 }
 
 const addBatchMetadata = (batch: IBatch): IBatch => {
-    if (batch.content.length > 1) {
-        batch.content[0].metadata = {
-            ...batch.content[0].metadata,
-            batch: true
-        };
-        batch.content[batch.content.length - 1].metadata = {
-            ...batch.content[batch.content.length - 1].metadata,
-            batch: false
-        };
-    }
-
-    return batch;
+	if (batch.content.length > 1) {
+		batch.content[0].metadata = {
+			...batch.content[0].metadata,
+			batch: true,
+		};
+		batch.content[batch.content.length - 1].metadata = {
+			...batch.content[batch.content.length - 1].metadata,
+			batch: false,
+		};
+	}
+
+	return batch;
 };

package/src/opLifecycle/definitions.ts

@@ -11,38 +11,42 @@ import { CompressionAlgorithms, ContainerMessageType, ContainerRuntimeMessage }
  * Batch message type used internally by the runtime
  */
 export type BatchMessage = IBatchMessage & {
-    localOpMetadata: unknown;
-    deserializedContent: ContainerRuntimeMessage;
-    referenceSequenceNumber: number;
-    compression?: CompressionAlgorithms;
+	localOpMetadata: unknown;
+	deserializedContent: ContainerRuntimeMessage;
+	referenceSequenceNumber: number;
+	compression?: CompressionAlgorithms;
 };
 
 /**
  * Batch interface used internally by the runtime.
  */
 export interface IBatch {
-    /**
-     * Sum of the in-memory content sizes of all messages in the batch.
-     * If the batch is compressed, this number reflects the post-compression size.
-     */
-    readonly contentSizeInBytes: number;
-    /**
-     * All the messages in the batch
-     */
-    readonly content: BatchMessage[];
+	/**
+	 * Sum of the in-memory content sizes of all messages in the batch.
+	 * If the batch is compressed, this number reflects the post-compression size.
+	 */
+	readonly contentSizeInBytes: number;
+	/**
+	 * All the messages in the batch
+	 */
+	readonly content: BatchMessage[];
+	/**
+	 * The reference sequence number for the batch
+	 */
+	readonly referenceSequenceNumber: number | undefined;
 }
 
 export interface IBatchCheckpoint {
-    rollback: (action: (message: BatchMessage) => void) => void;
+	rollback: (action: (message: BatchMessage) => void) => void;
 }
 
 export interface IChunkedOp {
-    chunkId: number;
-    totalChunks: number;
-    contents: string;
-    originalType: MessageType | ContainerMessageType;
-    originalMetadata?: Record<string, unknown>;
-    originalCompression?: string;
+	chunkId: number;
+	totalChunks: number;
+	contents: string;
+	originalType: MessageType | ContainerMessageType;
+	originalMetadata?: Record<string, unknown>;
+	originalCompression?: string;
 }
 
 /**
@@ -58,13 +62,13 @@ export type ProcessingState = "Processed" | "Skipped" | "Accepted";
  * Return type for functions which process remote messages
  */
 export interface IMessageProcessingResult {
-    /**
-     * A shallow copy of the input message if processing happened, or
-     * the original message otherwise
-     */
-    readonly message: ISequencedDocumentMessage;
-    /**
-     * Processing result of the input message.
-     */
-    readonly state: ProcessingState;
+	/**
+	 * A shallow copy of the input message if processing happened, or
+	 * the original message otherwise
+	 */
+	readonly message: ISequencedDocumentMessage;
+	/**
+	 * Processing result of the input message.
+	 */
+	readonly state: ProcessingState;
 }

package/src/opLifecycle/index.ts

@@ -5,11 +5,11 @@
 
 export { BatchManager } from "./batchManager";
 export {
-    BatchMessage,
-    IBatch,
-    IBatchCheckpoint,
-    IChunkedOp,
-    IMessageProcessingResult,
+	BatchMessage,
+	IBatch,
+	IBatchCheckpoint,
+	IChunkedOp,
+	IMessageProcessingResult,
 } from "./definitions";
 export { Outbox } from "./outbox";
 export { OpCompressor } from "./opCompressor";

package/src/opLifecycle/opCompressor.ts

@@ -17,65 +17,67 @@ import { IBatch, BatchMessage } from "./definitions";
  * op to reserve sequence numbers.
  */
 export class OpCompressor {
-    private readonly logger;
+	private readonly logger;
 
-    constructor(logger: ITelemetryLogger) {
-        this.logger = ChildLogger.create(logger, "OpCompressor");
-    }
+	constructor(logger: ITelemetryLogger) {
+		this.logger = ChildLogger.create(logger, "OpCompressor");
+	}
 
-    public compressBatch(batch: IBatch): IBatch {
-        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;
+	public compressBatch(batch: IBatch): IBatch {
+		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,
-            });
-        }
+		if (batch.contentSizeInBytes > 200000) {
+			this.logger.sendPerformanceEvent({
+				eventName: "CompressedBatch",
+				duration,
+				sizeBeforeCompression: batch.contentSizeInBytes,
+				sizeAfterCompression: compressedContent.length,
+			});
+		}
 
-        const messages: BatchMessage[] = [];
-        messages.push({
-            ...batch.content[0], contents: JSON.stringify({ packedContents: compressedContent }),
-            metadata: batch.content[0].metadata,
-            compression: CompressionAlgorithms.lz4,
-        });
+		const messages: BatchMessage[] = [];
+		messages.push({
+			...batch.content[0],
+			contents: JSON.stringify({ packedContents: compressedContent }),
+			metadata: batch.content[0].metadata,
+			compression: CompressionAlgorithms.lz4,
+		});
 
-        for (const message of batch.content.slice(1)) {
-            messages.push({ ...message, contents: undefined });
-        }
+		for (const message of batch.content.slice(1)) {
+			messages.push({ ...message, contents: undefined });
+		}
 
-        return {
-            contentSizeInBytes: compressedContent.length,
-            content: messages,
-        };
-    }
+		return {
+			contentSizeInBytes: compressedContent.length,
+			content: messages,
+			referenceSequenceNumber: batch.referenceSequenceNumber,
+		};
+	}
 
-    private serializeBatch(batch: IBatch): string {
-        try {
-            return JSON.stringify(batch.content.map((message) => message.deserializedContent))
-        } catch (e: any) {
-            if (e.message === "Invalid string length") {
-                // This is how JSON.stringify signals that
-                // the content size exceeds its capacity
-                const error = new UsageError("Payload too large");
-                this.logger.sendErrorEvent(
-                    {
-                        eventName: "BatchTooLarge",
-                        size: batch.contentSizeInBytes,
-                        length: batch.content.length,
-                    },
-                    error,
-                );
-                throw error;
-            }
+	private serializeBatch(batch: IBatch): string {
+		try {
+			return JSON.stringify(batch.content.map((message) => message.deserializedContent));
+		} catch (e: any) {
+			if (e.message === "Invalid string length") {
+				// This is how JSON.stringify signals that
+				// the content size exceeds its capacity
+				const error = new UsageError("Payload too large");
+				this.logger.sendErrorEvent(
+					{
+						eventName: "BatchTooLarge",
+						size: batch.contentSizeInBytes,
+						length: batch.content.length,
+					},
+					error,
+				);
+				throw error;
+			}
 
-            throw e;
-        }
-    }
+			throw e;
+		}
+	}
 }