@fluidframework/container-runtime 2.0.0-internal.5.3.1 → 2.0.0-internal.5.4.0

package/src/dataStore.ts

@@ -62,6 +62,9 @@ class DataStore implements IDataStore {
 	private readonly pendingAliases: Map<string, Promise<AliasResult>>;
 	private aliasResult: Promise<AliasResult> | undefined;
 
+	/**
+	 * {@inheritDoc @fluidframework/runtime-definitions#IDataStore.trySetAlias}
+	 */
 	async trySetAlias(alias: string): Promise<AliasResult> {
 		if (alias.includes("/")) {
 			throw new UsageError(`The alias cannot contain slashes: '${alias}'`);

package/src/dataStoreContext.ts

@@ -54,19 +54,14 @@ import {
 	IIdCompressorCore,
 	VisibilityState,
 } from "@fluidframework/runtime-definitions";
+import { addBlobToSummary, convertSummaryTreeToITree } from "@fluidframework/runtime-utils";
 import {
-	addBlobToSummary,
-	convertSummaryTreeToITree,
-	packagePathToTelemetryProperty,
-} from "@fluidframework/runtime-utils";
-import {
-	ChildLogger,
+	createChildMonitoringContext,
 	generateStack,
 	ITelemetryLoggerExt,
-	loggerToMonitoringContext,
 	LoggingError,
 	MonitoringContext,
-	TelemetryDataTag,
+	tagCodeArtifacts,
 	ThresholdCounter,
 } from "@fluidframework/telemetry-utils";
 import {
@@ -316,9 +311,16 @@ export abstract class FluidDataStoreContext
 			async (fullGC?: boolean) => this.getGCDataInternal(fullGC),
 		);
 
-		this.mc = loggerToMonitoringContext(
-			ChildLogger.create(this.logger, "FluidDataStoreContext"),
-		);
+		this.mc = createChildMonitoringContext({
+			logger: this.logger,
+			namespace: "FluidDataStoreContext",
+			properties: {
+				all: tagCodeArtifacts({
+					fluidDataStoreId: this.id,
+					fullPackageName: this.pkg?.join("/"),
+				}),
+			},
+		});
 		this.thresholdOpsCounter = new ThresholdCounter(
 			FluidDataStoreContext.pendingOpsCountThreshold,
 			this.mc.logger,
@@ -374,10 +376,13 @@ export abstract class FluidDataStoreContext
 		failedPkgPath?: string,
 		fullPackageName?: readonly string[],
 	): never {
-		throw new LoggingError(reason, {
-			failedPkgPath: { value: failedPkgPath, tag: TelemetryDataTag.CodeArtifact },
-			fullPackageName: packagePathToTelemetryProperty(fullPackageName),
-		});
+		throw new LoggingError(
+			reason,
+			tagCodeArtifacts({
+				failedPkgPath,
+				packagePath: fullPackageName?.join("/"),
+			}),
+		);
 	}
 
 	public async realize(): Promise<IFluidDataStoreChannel> {
@@ -389,13 +394,12 @@ export abstract class FluidDataStoreContext
 					error,
 					"realizeFluidDataStoreContext",
 				);
-				errorWrapped.addTelemetryProperties({
-					fluidDataStoreId: {
-						value: this.id,
-						tag: TelemetryDataTag.CodeArtifact,
-					},
-					packageName: packagePathToTelemetryProperty(this.pkg),
-				});
+				errorWrapped.addTelemetryProperties(
+					tagCodeArtifacts({
+						fullPackageName: this.pkg?.join("/"),
+						fluidDataStoreId: this.id,
+					}),
+				);
 				this.channelDeferred?.reject(errorWrapped);
 				this.mc.logger.sendErrorEvent({ eventName: "RealizeError" }, errorWrapped);
 			});
@@ -790,10 +794,6 @@ export abstract class FluidDataStoreContext
 			this.mc.logger.sendErrorEvent(
 				{
 					eventName: "BindRuntimeError",
-					fluidDataStoreId: {
-						value: this.id,
-						tag: TelemetryDataTag.CodeArtifact,
-					},
 				},
 				error,
 			);
@@ -917,11 +917,6 @@ export abstract class FluidDataStoreContext
 		this.mc.logger.sendTelemetryEvent({
 			eventName,
 			type,
-			fluidDataStoreId: {
-				value: this.id,
-				tag: TelemetryDataTag.CodeArtifact,
-			},
-			packageName: packagePathToTelemetryProperty(this.pkg),
 			isSummaryInProgress: this.summarizerNode.isSummaryInProgress?.(),
 			stack: generateStack(),
 		});
@@ -943,8 +938,11 @@ export abstract class FluidDataStoreContext
 			);
 	}
 
-	public async uploadBlob(blob: ArrayBufferLike): Promise<IFluidHandle<ArrayBufferLike>> {
-		return this.containerRuntime.uploadBlob(blob);
+	public async uploadBlob(
+		blob: ArrayBufferLike,
+		signal?: AbortSignal,
+	): Promise<IFluidHandle<ArrayBufferLike>> {
+		return this.containerRuntime.uploadBlob(blob, signal);
 	}
 }
 

package/src/dataStoreContexts.ts

@@ -7,7 +7,7 @@ import { ITelemetryBaseLogger } from "@fluidframework/common-definitions";
 import { assert, Deferred } from "@fluidframework/common-utils";
 import { Lazy } from "@fluidframework/core-utils";
 import { IDisposable } from "@fluidframework/core-interfaces";
-import { ChildLogger, ITelemetryLoggerExt } from "@fluidframework/telemetry-utils";
+import { createChildLogger, ITelemetryLoggerExt } from "@fluidframework/telemetry-utils";
 import { FluidDataStoreContext, LocalFluidDataStoreContext } from "./dataStoreContext";
 
 export class DataStoreContexts implements Iterable<[string, FluidDataStoreContext]>, IDisposable {
@@ -47,7 +47,7 @@ export class DataStoreContexts implements Iterable<[string, FluidDataStoreContex
 	private readonly _logger: ITelemetryLoggerExt;
 
 	constructor(baseLogger: ITelemetryBaseLogger) {
-		this._logger = ChildLogger.create(baseLogger);
+		this._logger = createChildLogger({ logger: baseLogger });
 	}
 
 	[Symbol.iterator](): Iterator<[string, FluidDataStoreContext]> {

package/src/dataStores.ts

@@ -42,11 +42,10 @@ import {
 	unpackChildNodesUsedRoutes,
 } from "@fluidframework/runtime-utils";
 import {
-	ChildLogger,
-	loggerToMonitoringContext,
 	LoggingError,
 	MonitoringContext,
-	TelemetryDataTag,
+	createChildMonitoringContext,
+	tagCodeArtifacts,
 } from "@fluidframework/telemetry-utils";
 import { AttachState } from "@fluidframework/container-definitions";
 import { buildSnapshotTree } from "@fluidframework/driver-utils";
@@ -137,7 +136,7 @@ export class DataStores implements IDisposable {
 		private readonly aliasMap: Map<string, string>,
 		private readonly contexts: DataStoreContexts = new DataStoreContexts(baseLogger),
 	) {
-		this.mc = loggerToMonitoringContext(ChildLogger.create(baseLogger));
+		this.mc = createChildMonitoringContext({ logger: baseLogger });
 		this.containerRuntimeHandle = new FluidObjectHandle(
 			this.runtime,
 			"/",
@@ -243,10 +242,7 @@ export class DataStores implements IDisposable {
 				"Duplicate DataStore created with existing id",
 				{
 					...extractSafePropertiesFromMessage(message),
-					dataStoreId: {
-						value: attachMessage.id,
-						tag: TelemetryDataTag.CodeArtifact,
-					},
+					...tagCodeArtifacts({ dataStoreId: attachMessage.id }),
 				},
 			);
 			throw error;
@@ -550,19 +546,18 @@ export class DataStores implements IDisposable {
 		}
 	}
 
-	public processSignal(address: string, message: IInboundSignalMessage, local: boolean) {
-		const request = { url: address };
-		this.validateNotDeleted(address, request);
-		const context = this.contexts.get(address);
+	public processSignal(fluidDataStoreId: string, message: IInboundSignalMessage, local: boolean) {
+		const request = { url: fluidDataStoreId };
+		this.validateNotDeleted(fluidDataStoreId, request);
+		const context = this.contexts.get(fluidDataStoreId);
 		if (!context) {
 			// Attach message may not have been processed yet
 			assert(!local, 0x163 /* "Missing datastore for local signal" */);
 			this.mc.logger.sendTelemetryEvent({
 				eventName: "SignalFluidDataStoreNotFound",
-				fluidDataStoreId: {
-					value: address,
-					tag: TelemetryDataTag.CodeArtifact,
-				},
+				...tagCodeArtifacts({
+					fluidDataStoreId,
+				}),
 			});
 			return;
 		}
@@ -571,7 +566,7 @@ export class DataStores implements IDisposable {
 	}
 
 	public setConnectionState(connected: boolean, clientId?: string) {
-		for (const [fluidDataStore, context] of this.contexts) {
+		for (const [fluidDataStoreId, context] of this.contexts) {
 			try {
 				context.setConnectionState(connected, clientId);
 			} catch (error) {
@@ -579,7 +574,9 @@ export class DataStores implements IDisposable {
 					{
 						eventName: "SetConnectionStateError",
 						clientId,
-						fluidDataStore,
+						...tagCodeArtifacts({
+							fluidDataStoreId,
+						}),
 						details: JSON.stringify({
 							runtimeConnected: this.runtime.connected,
 							connected,

package/src/deltaManagerSummarizerProxy.ts

@@ -41,6 +41,8 @@ export class DeltaManagerSummarizerProxy
 
 	constructor(deltaManager: IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>) {
 		super(deltaManager);
+		// We are expecting this class to have many listeners, so we suppress noisy "MaxListenersExceededWarning" logging.
+		super.setMaxListeners(0);
 		this.isSummarizerClient = this.deltaManager.clientDetails.type === summarizerClientType;
 	}
 }

package/src/deltaScheduler.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { ITelemetryLoggerExt, TelemetryLogger } from "@fluidframework/telemetry-utils";
+import { ITelemetryLoggerExt, formatTick } from "@fluidframework/telemetry-utils";
 import { performance } from "@fluidframework/common-utils";
 import { IDeltaManager } from "@fluidframework/container-definitions";
 import { IDocumentMessage, ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
@@ -111,20 +111,16 @@ export class DeltaScheduler {
 					if (this.schedulingLog) {
 						this.logger.sendTelemetryEvent({
 							eventName: "InboundOpsPartialProcessingTime",
-							duration: TelemetryLogger.formatTick(elapsedTime),
+							duration: formatTick(elapsedTime),
 							opsProcessed:
 								this.schedulingLog.lastSequenceNumber -
 								this.schedulingLog.firstSequenceNumber +
 								1,
 							opsRemainingToProcess: this.deltaManager.inbound.length,
-							processingTime: TelemetryLogger.formatTick(
-								this.schedulingLog.totalProcessingTime,
-							),
+							processingTime: formatTick(this.schedulingLog.totalProcessingTime),
 							numberOfTurns: this.schedulingLog.numberOfTurns,
 							batchesProcessed: this.schedulingLog.numberOfBatchesProcessed,
-							timeToResume: TelemetryLogger.formatTick(
-								performance.now() - currentTime,
-							),
+							timeToResume: formatTick(performance.now() - currentTime),
 						});
 					}
 					this.deltaManager.inbound.resume();
@@ -147,13 +143,13 @@ export class DeltaScheduler {
 				eventName: "InboundOpsProcessingTime",
 				opsRemainingToProcess: this.schedulingLog.opsRemainingToProcess,
 				numberOfTurns: this.schedulingLog.numberOfTurns,
-				processingTime: TelemetryLogger.formatTick(this.schedulingLog.totalProcessingTime),
+				processingTime: formatTick(this.schedulingLog.totalProcessingTime),
 				opsProcessed:
 					this.schedulingLog.lastSequenceNumber -
 					this.schedulingLog.firstSequenceNumber +
 					1,
 				batchesProcessed: this.schedulingLog.numberOfBatchesProcessed,
-				duration: TelemetryLogger.formatTick(currentTime - this.schedulingLog.startTime),
+				duration: formatTick(currentTime - this.schedulingLog.startTime),
 				schedulingCount: this.schedulingCount,
 			});
 

package/src/gc/garbageCollection.ts

@@ -16,9 +16,9 @@ import {
 } from "@fluidframework/runtime-definitions";
 import { ReadAndParseBlob } from "@fluidframework/runtime-utils";
 import {
-	ChildLogger,
+	createChildLogger,
+	createChildMonitoringContext,
 	ITelemetryLoggerExt,
-	loggerToMonitoringContext,
 	MonitoringContext,
 	PerformanceEvent,
 } from "@fluidframework/telemetry-utils";
@@ -137,11 +137,13 @@ export class GarbageCollector implements IGarbageCollector {
 		const baseSnapshot = createParams.baseSnapshot;
 		const readAndParseBlob = createParams.readAndParseBlob;
 
-		this.mc = loggerToMonitoringContext(
-			ChildLogger.create(createParams.baseLogger, "GarbageCollector", {
+		this.mc = createChildMonitoringContext({
+			logger: createParams.baseLogger,
+			namespace: "GarbageCollector",
+			properties: {
 				all: { completedGCRuns: () => this.completedRuns },
-			}),
-		);
+			},
+		});
 
 		this.configs = generateGCConfigs(this.mc, createParams);
 
@@ -466,8 +468,11 @@ export class GarbageCollector implements IGarbageCollector {
 		});
 
 		const logger = options.logger
-			? ChildLogger.create(options.logger, undefined, {
-					all: { completedGCRuns: () => this.completedRuns },
+			? createChildLogger({
+					logger: options.logger,
+					properties: {
+						all: { completedGCRuns: () => this.completedRuns },
+					},
 			  })
 			: this.mc.logger;
 

package/src/gc/gcHelpers.ts

@@ -307,6 +307,7 @@ export function trimLeadingAndTrailingSlashes(str: string) {
 
 /**
  * Tags the passed value as a CodeArtifact and returns the tagged value.
+ * @deprecated - Use telemetry-utils tagCodeArtifacts instead
  */
 export function tagAsCodeArtifact(value: string) {
 	return {

package/src/gc/gcTelemetry.ts

@@ -10,6 +10,7 @@ import {
 	generateStack,
 	ITelemetryLoggerExt,
 	MonitoringContext,
+	tagCodeArtifacts,
 } from "@fluidframework/telemetry-utils";
 import { ICreateContainerMetadata } from "../summary";
 import {
@@ -161,7 +162,6 @@ export class GCTelemetryTracker {
 		const { usageType, currentReferenceTimestampMs, packagePath, id, fromId, ...propsToLog } =
 			nodeUsageProps;
 		const eventProps: Omit<IUnreferencedEventProps, "state" | "usageType"> = {
-			id: tagAsCodeArtifact(id),
 			type: nodeType,
 			unrefTime: nodeStateTracker.unreferencedTimestampMs,
 			age:
@@ -171,7 +171,7 @@ export class GCTelemetryTracker {
 				state === UnreferencedState.Inactive
 					? this.configs.inactiveTimeoutMs
 					: this.configs.sweepTimeoutMs,
-			fromId: fromId ? tagAsCodeArtifact(fromId) : undefined,
+			...tagCodeArtifacts({ id, fromId }),
 			...propsToLog,
 			...this.createContainerMetadata,
 		};
@@ -277,8 +277,10 @@ export class GCTelemetryTracker {
 			if (missingExplicitRoutes.length > 0) {
 				logger.sendErrorEvent({
 					eventName: "gcUnknownOutboundReferences",
-					id: tagAsCodeArtifact(nodeId),
-					routes: tagAsCodeArtifact(JSON.stringify(missingExplicitRoutes)),
+					...tagCodeArtifacts({
+						id: nodeId,
+						routes: JSON.stringify(missingExplicitRoutes),
+					}),
 				});
 			}
 		}
@@ -318,8 +320,10 @@ export class GCTelemetryTracker {
 					}),
 					id,
 					fromId,
-					pkg: pkg ? tagAsCodeArtifact(pkg.join("/")) : undefined,
-					fromPkg: fromPkg ? tagAsCodeArtifact(fromPkg.join("/")) : undefined,
+					...tagCodeArtifacts({
+						pkg: pkg?.join("/"),
+						fromPkg: fromPkg?.join("/"),
+					}),
 				};
 
 				if (state === UnreferencedState.Inactive) {
@@ -379,7 +383,7 @@ export class GCTelemetryTracker {
 					lastSummaryTime,
 					...this.createContainerMetadata,
 				}),
-				id: tagAsCodeArtifact(JSON.stringify(deletedNodeIds)),
+				...tagCodeArtifacts({ id: JSON.stringify(deletedNodeIds) }),
 			});
 		}
 	}
@@ -398,7 +402,7 @@ export function sendGCUnexpectedUsageEvent(
 	packagePath: readonly string[] | undefined,
 	error?: unknown,
 ) {
-	event.pkg = packagePathToTelemetryProperty(packagePath);
+	event.pkg = tagCodeArtifacts({ pkg: packagePath?.join("/") })?.pkg;
 	event.tombstoneFlags = JSON.stringify({
 		DisableTombstone: mc.config.getBoolean(disableTombstoneKey),
 		ThrowOnTombstoneUsage: mc.config.getBoolean(throwOnTombstoneUsageKey),

package/src/id-compressor/idCompressor.ts

@@ -5,7 +5,6 @@
 
 /* eslint-disable @typescript-eslint/restrict-plus-operands */
 
-import { ITelemetryLoggerExt } from "@fluidframework/telemetry-utils";
 import { assert } from "@fluidframework/common-utils";
 import {
 	IIdCompressor,
@@ -31,6 +30,8 @@ import type {
 	VersionedSerializedIdCompressor,
 } from "@fluidframework/runtime-definitions";
 import BTree from "sorted-btree";
+import { ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
+import { ITelemetryLoggerExt, createChildLogger } from "@fluidframework/telemetry-utils";
 import {
 	hasAtLeastLength,
 	compareFiniteNumbers,
@@ -305,15 +306,15 @@ export class IdCompressor implements IIdCompressorCore, IIdCompressor {
 	private readonly finalIdToCluster: AppendOnlySortedMap<FinalCompressedId, IdCluster> =
 		new AppendOnlySortedMap(compareFiniteNumbers);
 
+	private readonly logger: ITelemetryLoggerExt;
+
 	/**
 	 * @param localSessionId - the `IdCompressor`'s current local session ID.
 	 * {@link generateStableId}.
 	 */
-	public constructor(
-		public readonly localSessionId: SessionId,
-		private readonly logger?: ITelemetryLoggerExt,
-	) {
+	public constructor(public readonly localSessionId: SessionId, logger?: ITelemetryBaseLogger) {
 		this.localSession = this.createSession(localSessionId);
+		this.logger = createChildLogger({ logger });
 	}
 
 	/**

package/src/opLifecycle/opCompressor.ts

@@ -3,10 +3,11 @@
  * Licensed under the MIT License.
  */
 
-import { ITelemetryLoggerExt, ChildLogger } from "@fluidframework/telemetry-utils";
+import { createChildLogger } from "@fluidframework/telemetry-utils";
 import { assert, IsoBuffer } from "@fluidframework/common-utils";
 import { UsageError } from "@fluidframework/container-utils";
 import { compress } from "lz4js";
+import { ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
 import { CompressionAlgorithms } from "../containerRuntime";
 import { estimateSocketSize } from "./batchManager";
 import { IBatch, BatchMessage } from "./definitions";
@@ -19,8 +20,8 @@ import { IBatch, BatchMessage } from "./definitions";
 export class OpCompressor {
 	private readonly logger;
 
-	constructor(logger: ITelemetryLoggerExt) {
-		this.logger = ChildLogger.create(logger, "OpCompressor");
+	constructor(logger: ITelemetryBaseLogger) {
+		this.logger = createChildLogger({ logger, namespace: "OpCompressor" });
 	}
 
 	public compressBatch(batch: IBatch): IBatch {

package/src/opLifecycle/opDecompressor.ts

@@ -6,7 +6,8 @@
 import { decompress } from "lz4js";
 import { ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
 import { assert, IsoBuffer, Uint8ArrayToString } from "@fluidframework/common-utils";
-import { ChildLogger, ITelemetryLoggerExt } from "@fluidframework/telemetry-utils";
+import { createChildLogger } from "@fluidframework/telemetry-utils";
+import { ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
 import { CompressionAlgorithms } from "../containerRuntime";
 import { IBatchMetadata } from "../metadata";
 import { IMessageProcessingResult } from "./definitions";
@@ -32,8 +33,8 @@ export class OpDecompressor {
 	private processedCount = 0;
 	private readonly logger;
 
-	constructor(logger: ITelemetryLoggerExt) {
-		this.logger = ChildLogger.create(logger, "OpDecompressor");
+	constructor(logger: ITelemetryBaseLogger) {
+		this.logger = createChildLogger({ logger, namespace: "OpDecompressor" });
 	}
 
 	public processMessage(message: ISequencedDocumentMessage): IMessageProcessingResult {

package/src/opLifecycle/opSplitter.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { ITelemetryLoggerExt, ChildLogger } from "@fluidframework/telemetry-utils";
+import { createChildLogger } from "@fluidframework/telemetry-utils";
 import { assert } from "@fluidframework/common-utils";
 import { IBatchMessage } from "@fluidframework/container-definitions";
 import {
@@ -11,6 +11,7 @@ import {
 	extractSafePropertiesFromMessage,
 } from "@fluidframework/container-utils";
 import { ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
+import { ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
 import { ContainerMessageType, ContainerRuntimeMessage } from "../containerRuntime";
 import { estimateSocketSize } from "./batchManager";
 import { BatchMessage, IBatch, IChunkedOp, IMessageProcessingResult } from "./definitions";
@@ -30,10 +31,10 @@ export class OpSplitter {
 			| undefined,
 		public readonly chunkSizeInBytes: number,
 		private readonly maxBatchSizeInBytes: number,
-		logger: ITelemetryLoggerExt,
+		logger: ITelemetryBaseLogger,
 	) {
 		this.chunkMap = new Map<string, string[]>(chunks);
-		this.logger = ChildLogger.create(logger, "OpSplitter");
+		this.logger = createChildLogger({ logger, namespace: "OpSplitter" });
 	}
 
 	public get isBatchChunkingEnabled(): boolean {

package/src/opLifecycle/outbox.ts

@@ -3,16 +3,11 @@
  * Licensed under the MIT License.
  */
 
-import {
-	ITelemetryLoggerExt,
-	ChildLogger,
-	loggerToMonitoringContext,
-	MonitoringContext,
-} from "@fluidframework/telemetry-utils";
+import { createChildMonitoringContext, MonitoringContext } from "@fluidframework/telemetry-utils";
 import { assert } from "@fluidframework/common-utils";
-import { IContainerContext, ICriticalContainerError } from "@fluidframework/container-definitions";
+import { IBatchMessage, ICriticalContainerError } from "@fluidframework/container-definitions";
 import { GenericError, UsageError } from "@fluidframework/container-utils";
-import { MessageType } from "@fluidframework/protocol-definitions";
+import { ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
 import { ICompressionRuntimeOptions } from "../containerRuntime";
 import { IPendingBatchMessage, PendingStateManager } from "../pendingStateManager";
 import {
@@ -37,11 +32,14 @@ export interface IOutboxConfig {
 export interface IOutboxParameters {
 	readonly shouldSend: () => boolean;
 	readonly pendingStateManager: PendingStateManager;
-	readonly containerContext: IContainerContext;
+	readonly submitBatchFn:
+		| ((batch: IBatchMessage[], referenceSequenceNumber?: number) => number)
+		| undefined;
+	readonly legacySendBatchFn: (batch: IBatch) => void;
 	readonly config: IOutboxConfig;
 	readonly compressor: OpCompressor;
 	readonly splitter: OpSplitter;
-	readonly logger: ITelemetryLoggerExt;
+	readonly logger: ITelemetryBaseLogger;
 	readonly groupingManager: OpGroupingManager;
 	readonly getCurrentSequenceNumbers: () => BatchSequenceNumbers;
 	readonly reSubmit: (message: IPendingBatchMessage) => void;
@@ -100,7 +98,7 @@ export class Outbox {
 	private mismatchedOpsReported = 0;
 
 	constructor(private readonly params: IOutboxParameters) {
-		this.mc = loggerToMonitoringContext(ChildLogger.create(params.logger, "Outbox"));
+		this.mc = createChildMonitoringContext({ logger: params.logger, namespace: "Outbox" });
 		const isCompressionEnabled =
 			this.params.config.compressionOptions.minimumBatchSizeInBytes !==
 			Number.POSITIVE_INFINITY;
@@ -326,7 +324,7 @@ export class Outbox {
 			this.params.config.compressionOptions === undefined ||
 			this.params.config.compressionOptions.minimumBatchSizeInBytes >
 				batch.contentSizeInBytes ||
-			this.params.containerContext.submitBatchFn === undefined
+			this.params.submitBatchFn === undefined
 		) {
 			// 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 disableGroupedBatching ? batch : this.params.groupingManager.groupBatch(batch);
@@ -381,7 +379,7 @@ export class Outbox {
 			});
 		}
 
-		if (this.params.containerContext.submitBatchFn === undefined) {
+		if (this.params.submitBatchFn === undefined) {
 			// Legacy path - supporting old loader versions. Can be removed only when LTS moves above
 			// version that has support for batches (submitBatchFn)
 			assert(
@@ -389,23 +387,13 @@ export class Outbox {
 				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,
-					// For back-compat (submitFn only works on deserialized content)
-					message.contents === undefined ? undefined : JSON.parse(message.contents),
-					true, // batch
-					message.metadata,
-				);
-			}
-
-			this.params.containerContext.deltaManager.flush();
+			this.params.legacySendBatchFn(batch);
 		} else {
 			assert(
 				batch.referenceSequenceNumber !== undefined,
 				0x58e /* Batch must not be empty */,
 			);
-			this.params.containerContext.submitBatchFn(
+			this.params.submitBatchFn(
 				batch.content.map((message) => ({
 					contents: message.contents,
 					metadata: message.metadata,

package/src/opLifecycle/remoteMessageProcessor.ts

@@ -24,6 +24,11 @@ export class RemoteMessageProcessor {
 		this.opSplitter.clearPartialChunks(clientId);
 	}
 
+	/**
+	 * Ungroups and Unchunks the runtime ops encapsulated by the single remoteMessage received over the wire
+	 * @param remoteMessage - A message from another client, likely a chunked/grouped op
+	 * @returns the ungrouped, unchunked, unpacked SequencedContainerRuntimeMessage encapsulated in the remote message
+	 */
 	public process(remoteMessage: ISequencedDocumentMessage): ISequencedDocumentMessage[] {
 		const result: ISequencedDocumentMessage[] = [];
 
@@ -32,11 +37,12 @@ export class RemoteMessageProcessor {
 			const message = this.opDecompressor.processMessage(ungroupedMessage).message;
 
 			for (let ungroupedMessage2 of this.opGroupingManager.ungroupOp(message)) {
+				// unpack and unchunk the ungrouped message in place
 				unpackRuntimeMessage(ungroupedMessage2);
-
 				const chunkProcessingResult =
 					this.opSplitter.processRemoteMessage(ungroupedMessage2);
 				ungroupedMessage2 = chunkProcessingResult.message;
+
 				if (chunkProcessingResult.state !== "Processed") {
 					// If the message is not chunked or if the splitter is still rebuilding the original message,
 					// there is no need to continue processing
@@ -106,7 +112,7 @@ const unpack = (message: ISequencedDocumentMessage) => {
  *
  * @remarks This API makes no promises regarding backward-compatibility. This is internal API.
  * @param message - message (as it observed in storage / service)
- * @returns unpacked runtime message
+ * @returns whether the given message was unpacked
  *
  * @internal
  */

package/src/packageVersion.ts

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