@fluidframework/container-runtime 2.0.0-internal.5.3.4 → 2.0.0-internal.5.4.2

package/src/pendingStateManager.ts

@@ -9,6 +9,7 @@ import { ICriticalContainerError } from "@fluidframework/container-definitions";
 import { DataProcessingError } from "@fluidframework/container-utils";
 import { Lazy } from "@fluidframework/core-utils";
 import { ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
+import { ITelemetryLoggerExt } from "@fluidframework/telemetry-utils";
 import Deque from "double-ended-queue";
 import { ContainerMessageType } from "./containerRuntime";
 import { pkgVersion } from "./packageVersion";
@@ -65,6 +66,7 @@ export interface IRuntimeStateHandler {
 	applyStashedOp(content: string): Promise<unknown>;
 	reSubmit(message: IPendingBatchMessage): void;
 	reSubmitBatch(batch: IPendingBatchMessage[]): void;
+	isActiveConnection: () => boolean;
 }
 
 /**
@@ -136,6 +138,7 @@ export class PendingStateManager implements IDisposable {
 	constructor(
 		private readonly stateHandler: IRuntimeStateHandler,
 		initialLocalState: IPendingLocalState | undefined,
+		private readonly logger: ITelemetryLoggerExt | undefined,
 	) {
 		/**
 		 * Convert old local state format to the new format (IPendingMessageOld to IPendingMessageNew)
@@ -364,18 +367,16 @@ export class PendingStateManager implements IDisposable {
 			0x174 /* "initial states should be empty before replaying pending" */,
 		);
 
-		let pendingMessagesCount = this.pendingMessages.length;
-		if (pendingMessagesCount === 0) {
-			return;
-		}
+		const initialPendingMessagesCount = this.pendingMessages.length;
+		let remainingPendingMessagesCount = this.pendingMessages.length;
 
 		// Process exactly `pendingMessagesCount` items in the queue as it represents the number of messages that were
 		// pending when we connected. This is important because the `reSubmitFn` might add more items in the queue
 		// which must not be replayed.
-		while (pendingMessagesCount > 0) {
+		while (remainingPendingMessagesCount > 0) {
 			// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 			let pendingMessage = this.pendingMessages.shift()!;
-			pendingMessagesCount--;
+			remainingPendingMessagesCount--;
 			assert(
 				pendingMessage.opMetadata?.batch !== false,
 				0x41b /* We cannot process batches in chunks */,
@@ -388,14 +389,14 @@ export class PendingStateManager implements IDisposable {
 			 */
 			if (pendingMessage.opMetadata?.batch) {
 				assert(
-					pendingMessagesCount > 0,
+					remainingPendingMessagesCount > 0,
 					0x554 /* Last pending message cannot be a batch begin */,
 				);
 
 				const batch: IPendingBatchMessage[] = [];
 
 				// check is >= because batch end may be last pending message
-				while (pendingMessagesCount >= 0) {
+				while (remainingPendingMessagesCount >= 0) {
 					batch.push({
 						content: pendingMessage.content,
 						localOpMetadata: pendingMessage.localOpMetadata,
@@ -405,11 +406,11 @@ export class PendingStateManager implements IDisposable {
 					if (pendingMessage.opMetadata?.batch === false) {
 						break;
 					}
-					assert(pendingMessagesCount > 0, 0x555 /* No batch end found */);
+					assert(remainingPendingMessagesCount > 0, 0x555 /* No batch end found */);
 
 					// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 					pendingMessage = this.pendingMessages.shift()!;
-					pendingMessagesCount--;
+					remainingPendingMessagesCount--;
 					assert(
 						pendingMessage.opMetadata?.batch !== true,
 						0x556 /* Batch start needs a corresponding batch end */,
@@ -425,5 +426,16 @@ export class PendingStateManager implements IDisposable {
 				});
 			}
 		}
+
+		// We replayPendingStates on read connections too - we expect these to get nack'd though, and to then reconnect
+		// on a write connection and replay again. This filters out the replay that happens on the read connection so
+		// we only see the replays on write connections (that have a chance to go through).
+		if (this.stateHandler.isActiveConnection()) {
+			this.logger?.sendTelemetryEvent({
+				eventName: "PendingStatesReplayed",
+				count: initialPendingMessagesCount,
+				clientId: this.stateHandler.clientId(),
+			});
+		}
 	}
 }

package/src/scheduleManager.ts

@@ -5,7 +5,7 @@
 import { EventEmitter } from "events";
 import { IDeltaManager } from "@fluidframework/container-definitions";
 import { IDocumentMessage, ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
-import { ITelemetryLoggerExt, ChildLogger } from "@fluidframework/telemetry-utils";
+import { ITelemetryLoggerExt, createChildLogger } from "@fluidframework/telemetry-utils";
 import { assert, performance } from "@fluidframework/common-utils";
 import { isRuntimeMessage } from "@fluidframework/driver-utils";
 import {
@@ -45,7 +45,7 @@ export class ScheduleManager {
 	) {
 		this.deltaScheduler = new DeltaScheduler(
 			this.deltaManager,
-			ChildLogger.create(this.logger, "DeltaScheduler"),
+			createChildLogger({ logger: this.logger, namespace: "DeltaScheduler" }),
 		);
 		void new ScheduleManagerCore(deltaManager, getClientId, logger);
 	}

package/src/summary/orderedClientElection.ts

@@ -4,7 +4,7 @@
  */
 /* eslint-disable @rushstack/no-new-null */
 import { IEvent, IEventProvider } from "@fluidframework/common-definitions";
-import { ITelemetryLoggerExt, ChildLogger } from "@fluidframework/telemetry-utils";
+import { ITelemetryLoggerExt, createChildLogger } from "@fluidframework/telemetry-utils";
 import { assert, TypedEventEmitter } from "@fluidframework/common-utils";
 import { IDeltaManager } from "@fluidframework/container-definitions";
 import { UsageError } from "@fluidframework/container-utils";
@@ -106,7 +106,7 @@ export class OrderedClientCollection
 		quorum: Pick<IQuorumClients, "getMembers" | "on">,
 	) {
 		super();
-		this.logger = ChildLogger.create(logger, "OrderedClientCollection");
+		this.logger = createChildLogger({ logger, namespace: "OrderedClientCollection" });
 		const members = quorum.getMembers();
 		for (const [clientId, client] of members) {
 			this.addClient(clientId, client);

package/src/summary/runningSummarizer.ts

@@ -3,18 +3,16 @@
  * Licensed under the MIT License.
  */
 
-import { IDisposable } from "@fluidframework/core-interfaces";
+import { IDisposable, ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
 import {
-	ITelemetryLoggerExt,
-	ChildLogger,
 	isFluidError,
-	loggerToMonitoringContext,
 	MonitoringContext,
+	createChildMonitoringContext,
+	createChildLogger,
 } from "@fluidframework/telemetry-utils";
 import { assert, delay, Deferred, PromiseTimer } from "@fluidframework/common-utils";
 import { UsageError } from "@fluidframework/container-utils";
 import { DriverErrorType } from "@fluidframework/driver-definitions";
-import { isRuntimeMessage } from "@fluidframework/driver-utils";
 import { ISequencedDocumentMessage, MessageType } from "@fluidframework/protocol-definitions";
 import { ISummaryConfiguration } from "../containerRuntime";
 import { opSize } from "../opProperties";
@@ -57,7 +55,7 @@ const defaultNumberSummarizationAttempts = 2; // only up to 2 attempts
  */
 export class RunningSummarizer implements IDisposable {
 	public static async start(
-		logger: ITelemetryLoggerExt,
+		logger: ITelemetryBaseLogger,
 		summaryWatcher: IClientSummaryWatcher,
 		configuration: ISummaryConfiguration,
 		submitSummaryCallback: (options: ISubmitSummaryOptions) => Promise<SubmitSummaryResult>,
@@ -90,7 +88,10 @@ export class RunningSummarizer implements IDisposable {
 		// Handle summary acks asynchronously
 		// Note: no exceptions are thrown from processIncomingSummaryAcks handler as it handles all exceptions
 		summarizer.processIncomingSummaryAcks(lastAckRefSeq).catch((error) => {
-			logger.sendErrorEvent({ eventName: "HandleSummaryAckFatalError" }, error);
+			createChildLogger({ logger }).sendErrorEvent(
+				{ eventName: "HandleSummaryAckFatalError" },
+				error,
+			);
 		});
 
 		// Update heuristic counts
@@ -146,11 +147,10 @@ export class RunningSummarizer implements IDisposable {
 	private totalSuccessfulAttempts = 0;
 	private initialized = false;
 
-	private readonly deltaManagerListener;
 	private readonly runtimeListener;
 
 	private constructor(
-		baseLogger: ITelemetryLoggerExt,
+		baseLogger: ITelemetryBaseLogger,
 		private readonly summaryWatcher: IClientSummaryWatcher,
 		private readonly configuration: ISummaryConfiguration,
 		private readonly submitSummaryCallback: (
@@ -170,11 +170,13 @@ export class RunningSummarizer implements IDisposable {
 			summarizerSuccessfulAttempts: () => this.totalSuccessfulAttempts,
 		};
 
-		this.mc = loggerToMonitoringContext(
-			ChildLogger.create(baseLogger, "Running", {
+		this.mc = createChildMonitoringContext({
+			logger: baseLogger,
+			namespace: "Running",
+			properties: {
 				all: telemetryProps,
-			}),
-		);
+			},
+		});
 
 		if (configuration.state !== "disableHeuristics") {
 			assert(
@@ -235,24 +237,10 @@ export class RunningSummarizer implements IDisposable {
 			this.mc.logger,
 		);
 
-		// Listen to deltaManager for non-runtime ops
-		this.deltaManagerListener = (op) => {
-			if (!isRuntimeMessage(op)) {
-				this.handleOp(op, false);
-			}
+		// Listen to runtime for ops
+		this.runtimeListener = (op: ISequencedDocumentMessage, runtimeMessage?: boolean) => {
+			this.handleOp(op, runtimeMessage === true);
 		};
-
-		// Listen to runtime for runtime ops
-		this.runtimeListener = (op, runtimeMessage) => {
-			if (runtimeMessage) {
-				this.handleOp(op, true);
-			}
-		};
-
-		// Purpose of listening to deltaManager is for back-compat
-		// Can remove and only listen to runtime once loader version is past 2.0.0-internal.1.2.0 (https://github.com/microsoft/FluidFramework/pull/11832)
-		// Tracked by AB#3883
-		this.runtime.deltaManager.on("op", this.deltaManagerListener);
 		this.runtime.on("op", this.runtimeListener);
 	}
 
@@ -347,7 +335,6 @@ export class RunningSummarizer implements IDisposable {
 	}
 
 	public dispose(): void {
-		this.runtime.deltaManager.off("op", this.deltaManagerListener);
 		this.runtime.off("op", this.runtimeListener);
 		this.summaryWatcher.dispose();
 		this.heuristicRunner?.dispose();
@@ -610,8 +597,6 @@ export class RunningSummarizer implements IDisposable {
 					throw new UsageError("Invalid number of attempts.");
 				}
 
-				let lastResult: { message: string; error: any } | undefined;
-
 				for (let summaryAttemptPhase = 0; summaryAttemptPhase < totalAttempts; ) {
 					if (this.cancellationToken.cancelled) {
 						return;
@@ -655,7 +640,6 @@ export class RunningSummarizer implements IDisposable {
 						summaryAttemptPhase++;
 						summaryAttemptsPerPhase = 0;
 					}
-					lastResult = result;
 
 					const delaySeconds = overrideDelaySeconds ?? regularDelaySeconds;
 
@@ -670,16 +654,6 @@ export class RunningSummarizer implements IDisposable {
 					}
 				}
 
-				// If all attempts failed, log error (with last attempt info) and close the summarizer container
-				this.mc.logger.sendErrorEvent(
-					{
-						eventName: "FailToSummarize",
-						reason,
-						message: lastResult?.message,
-					},
-					lastResult?.error,
-				);
-
 				this.stopSummarizerCallback("failToSummarize");
 			},
 			() => {

package/src/summary/summarizer.ts

@@ -7,7 +7,7 @@ import { EventEmitter } from "events";
 import { Deferred } from "@fluidframework/common-utils";
 import {
 	ITelemetryLoggerExt,
-	ChildLogger,
+	createChildLogger,
 	IFluidErrorBase,
 	LoggingError,
 	wrapErrorAndLog,
@@ -90,7 +90,7 @@ export class Summarizer extends EventEmitter implements ISummarizer {
 		) => Promise<ICancellableSummarizerController>,
 	) {
 		super();
-		this.logger = ChildLogger.create(this.runtime.logger, "Summarizer");
+		this.logger = createChildLogger({ logger: this.runtime.logger, namespace: "Summarizer" });
 	}
 
 	/**

package/src/summary/summarizerNode/summarizerNode.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { ITelemetryErrorEvent } from "@fluidframework/core-interfaces";
+import { ITelemetryBaseLogger, ITelemetryErrorEvent } from "@fluidframework/core-interfaces";
 import {
 	ISummarizerNode,
 	ISummarizerNodeConfig,
@@ -23,10 +23,11 @@ import {
 } from "@fluidframework/protocol-definitions";
 import {
 	ITelemetryLoggerExt,
-	ChildLogger,
+	createChildLogger,
 	LoggingError,
 	PerformanceEvent,
 	TelemetryDataTag,
+	tagCodeArtifacts,
 } from "@fluidframework/telemetry-utils";
 import { assert, unreachableCase } from "@fluidframework/common-utils";
 import {
@@ -85,30 +86,28 @@ export class SummarizerNode implements IRootSummarizerNode {
 	 * Use createRootSummarizerNode to create root node, or createChild to create child nodes.
 	 */
 	public constructor(
-		baseLogger: ITelemetryLoggerExt,
+		baseLogger: ITelemetryBaseLogger,
 		private readonly summarizeInternalFn: SummarizeInternalFn,
 		config: ISummarizerNodeConfig,
 		private _changeSequenceNumber: number,
 		/** Undefined means created without summary */
 		private _latestSummary?: SummaryNode,
 		private readonly initialSummary?: IInitialSummary,
-		protected wipSummaryLogger?: ITelemetryLoggerExt,
+		protected wipSummaryLogger?: ITelemetryBaseLogger,
 		/** A unique id of this node to be logged when sending telemetry. */
 		protected telemetryNodeId?: string,
 	) {
 		this.canReuseHandle = config.canReuseHandle ?? true;
 		// All logs posted by the summarizer node should include the telemetryNodeId.
-		this.logger = ChildLogger.create(baseLogger, undefined /* namespace */, {
-			all: {
-				id: {
-					tag: TelemetryDataTag.CodeArtifact,
-					value: this.telemetryNodeId,
-				},
+		this.logger = createChildLogger({
+			logger: baseLogger,
+			properties: {
+				all: tagCodeArtifacts({ id: this.telemetryNodeId }),
 			},
 		});
 	}
 
-	public startSummary(referenceSequenceNumber: number, summaryLogger: ITelemetryLoggerExt) {
+	public startSummary(referenceSequenceNumber: number, summaryLogger: ITelemetryBaseLogger) {
 		assert(
 			this.wipSummaryLogger === undefined,
 			0x19f /* "wipSummaryLogger should not be set yet in startSummary" */,
@@ -809,10 +808,9 @@ export class SummarizerNode implements IRootSummarizerNode {
 		const error = new LoggingError(eventProps.eventName, {
 			...eventProps,
 			referenceSequenceNumber: this.wipReferenceSequenceNumber,
-			id: {
-				tag: TelemetryDataTag.CodeArtifact,
-				value: this.telemetryNodeId,
-			},
+			...tagCodeArtifacts({
+				id: this.telemetryNodeId,
+			}),
 		});
 		this.logger.sendErrorEvent(eventProps, error);
 		throw error;

package/src/summary/summarizerNode/summarizerNodeWithGc.ts

@@ -7,6 +7,7 @@ import {
 	ITelemetryLoggerExt,
 	LoggingError,
 	TelemetryDataTag,
+	tagCodeArtifacts,
 } from "@fluidframework/telemetry-utils";
 import { assert } from "@fluidframework/common-utils";
 import { LazyPromise } from "@fluidframework/core-utils";
@@ -25,6 +26,7 @@ import {
 	IExperimentalIncrementalSummaryContext,
 } from "@fluidframework/runtime-definitions";
 import { ReadAndParseBlob, unpackChildNodesUsedRoutes } from "@fluidframework/runtime-utils";
+import { ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
 import {
 	cloneGCData,
 	getGCDataFromSnapshot,
@@ -107,7 +109,7 @@ export class SummarizerNodeWithGC extends SummarizerNode implements IRootSummari
 	 * Use createRootSummarizerNodeWithGC to create root node, or createChild to create child nodes.
 	 */
 	public constructor(
-		logger: ITelemetryLoggerExt,
+		logger: ITelemetryBaseLogger,
 		private readonly summarizeFn: (
 			fullTree: boolean,
 			trackState: boolean,
@@ -119,7 +121,7 @@ export class SummarizerNodeWithGC extends SummarizerNode implements IRootSummari
 		/** Undefined means created without summary */
 		latestSummary?: SummaryNode,
 		initialSummary?: IInitialSummary,
-		wipSummaryLogger?: ITelemetryLoggerExt,
+		wipSummaryLogger?: ITelemetryBaseLogger,
 		private readonly getGCDataFn?: (fullGC?: boolean) => Promise<IGarbageCollectionData>,
 		getBaseGCDetailsFn?: () => Promise<IGarbageCollectionDetailsBase>,
 		/** A unique id of this node to be logged when sending telemetry. */
@@ -370,10 +372,9 @@ export class SummarizerNodeWithGC extends SummarizerNode implements IRootSummari
 					const error = new LoggingError("MissingGCStateInPendingSummary", {
 						proposalHandle,
 						referenceSequenceNumber,
-						id: {
-							tag: TelemetryDataTag.CodeArtifact,
-							value: this.telemetryNodeId,
-						},
+						...tagCodeArtifacts({
+							id: this.telemetryNodeId,
+						}),
 					});
 					this.logger.sendErrorEvent(
 						{
@@ -666,7 +667,7 @@ export class SummarizerNodeWithGC extends SummarizerNode implements IRootSummari
  * @param baseGCDetailsP - Function to get the initial GC details of this node
  */
 export const createRootSummarizerNodeWithGC = (
-	logger: ITelemetryLoggerExt,
+	logger: ITelemetryBaseLogger,
 	summarizeInternalFn: SummarizeInternalFn,
 	changeSequenceNumber: number,
 	referenceSequenceNumber: number | undefined,

package/src/summary/summaryGenerator.ts

@@ -7,7 +7,7 @@ import {
 	ITelemetryLoggerExt,
 	PerformanceEvent,
 	LoggingError,
-	ChildLogger,
+	createChildLogger,
 } from "@fluidframework/telemetry-utils";
 import { ITelemetryProperties } from "@fluidframework/core-interfaces";
 
@@ -240,7 +240,11 @@ export class SummaryGenerator {
 		cancellationToken: ISummaryCancellationToken,
 	): Promise<void> {
 		const { refreshLatestAck, fullTree } = options;
-		const logger = ChildLogger.create(this.logger, undefined, { all: summarizeProps });
+		const logger = createChildLogger({
+			logger: this.logger,
+			namespace: undefined,
+			properties: { all: summarizeProps },
+		});
 
 		// Note: timeSinceLastAttempt and timeSinceLastSummary for the
 		// first summary are basically the time since the summarizer was loaded.

package/src/summary/summaryManager.ts

@@ -4,10 +4,10 @@
  */
 
 import { IEvent, IEventProvider } from "@fluidframework/common-definitions";
-import { IDisposable } from "@fluidframework/core-interfaces";
+import { IDisposable, ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
 import { assert } from "@fluidframework/common-utils";
 import {
-	ChildLogger,
+	createChildLogger,
 	ITelemetryLoggerExt,
 	PerformanceEvent,
 } from "@fluidframework/telemetry-utils";
@@ -97,7 +97,7 @@ export class SummaryManager implements IDisposable {
 			SummaryCollection,
 			"opsSinceLastAck" | "addOpListener" | "removeOpListener"
 		>,
-		parentLogger: ITelemetryLoggerExt,
+		parentLogger: ITelemetryBaseLogger,
 		/** Creates summarizer by asking interactive container to spawn summarizing container and
 		 * get back its Summarizer instance. */
 		private readonly requestSummarizerFn: () => Promise<ISummarizer>,
@@ -108,8 +108,12 @@ export class SummaryManager implements IDisposable {
 		}: Readonly<Partial<ISummaryManagerConfig>> = {},
 		private readonly disableHeuristics?: boolean,
 	) {
-		this.logger = ChildLogger.create(parentLogger, "SummaryManager", {
-			all: { clientId: () => this.latestClientId },
+		this.logger = createChildLogger({
+			logger: parentLogger,
+			namespace: "SummaryManager",
+			properties: {
+				all: { clientId: () => this.latestClientId },
+			},
 		});
 
 		this.connectedState.on("connected", this.handleConnected);