@fluidframework/container-runtime 2.74.0 → 2.81.0

package/src/summary/summaryDelayLoadedModule/runningSummarizer.ts

@@ -177,11 +177,6 @@ export class RunningSummarizer
 	private totalSuccessfulAttempts = 0;
 	private initialized = false;
 
-	private readonly runtimeListener: (
-		op: ISequencedDocumentMessage,
-		runtimeMessage?: boolean,
-	) => void;
-
 	/**
 	 * The maximum number of summary attempts to do when submit summary fails.
 	 */
@@ -295,12 +290,6 @@ export class RunningSummarizer
 			this.mc.logger,
 		);
 
-		// Listen to runtime for ops
-		this.runtimeListener = (op: ISequencedDocumentMessage, runtimeMessage?: boolean) => {
-			this.handleOp(op, runtimeMessage === true);
-		};
-		this.runtime.on("op", this.runtimeListener);
-
 		// The max attempts for submit failures can be overridden via a feature flag. This allows us to
 		// tweak this as per telemetry data until we arrive at a stable number.
 		// If its set to a number higher than `defaultMaxAttemptsForSubmitFailures`, it will be ignored.
@@ -312,6 +301,8 @@ export class RunningSummarizer
 			overrideMaxAttempts < defaultMaxAttemptsForSubmitFailures
 				? overrideMaxAttempts
 				: defaultMaxAttemptsForSubmitFailures;
+
+		this.setupEventListeners();
 	}
 
 	private async handleSummaryAck(ack: IAckedSummary): Promise<void> {
@@ -397,7 +388,7 @@ export class RunningSummarizer
 	}
 
 	public dispose(): void {
-		this.runtime.off("op", this.runtimeListener);
+		this.cleanupEventListeners();
 		this.summaryWatcher.dispose();
 		this.heuristicRunner?.dispose();
 		this.heuristicRunner = undefined;
@@ -408,6 +399,33 @@ export class RunningSummarizer
 		this.stopping = true;
 	}
 
+	private readonly eventsCleanup: (() => void)[] = [];
+
+	private setupEventListeners(): void {
+		const runtimeListener: (op: ISequencedDocumentMessage, runtimeMessage?: boolean) => void =
+			(op: ISequencedDocumentMessage, runtimeMessage?: boolean) => {
+				this.handleOp(op, runtimeMessage === true);
+			};
+		this.runtime.on("op", runtimeListener);
+		this.eventsCleanup.push(() => this.runtime.off("op", runtimeListener));
+
+		// Forward events
+		for (const event of ["summarizeTimeout"] as const) {
+			const listener = (...args: unknown[]): void => {
+				this.emit(event, ...args);
+			};
+			this.generator.on(event, listener);
+			this.eventsCleanup.push(() => this.generator.off(event, listener));
+		}
+	}
+
+	private cleanupEventListeners(): void {
+		for (const cleanup of this.eventsCleanup) {
+			cleanup();
+		}
+		this.eventsCleanup.length = 0;
+	}
+
 	/**
 	 * RunningSummarizer's logger includes the sequenced index of the current summary on each event.
 	 * If some other Summarizer code wants that event on their logs they can get it here,
@@ -655,11 +673,12 @@ export class RunningSummarizer
 						numUnsummarizedNonRuntimeOps: this.heuristicData.numNonRuntimeOps,
 						isLastSummary,
 					});
-					this.mc.logger.sendErrorEvent(
+					summaryLogger.sendErrorEvent(
 						{
 							eventName: "SummarizeFailed",
 							maxAttempts: 1,
 							summaryAttempts: 1,
+							isLastSummary,
 						},
 						result.error,
 					);
@@ -708,7 +727,10 @@ export class RunningSummarizer
 				this.afterSummaryAction();
 			},
 		).catch((error) => {
-			this.mc.logger.sendErrorEvent({ eventName: "UnexpectedSummarizeError" }, error);
+			this.mc.logger.sendErrorEvent(
+				{ eventName: "UnexpectedSummarizeError", summarizeReason: reason },
+				error,
+			);
 		});
 	}
 
@@ -718,6 +740,7 @@ export class RunningSummarizer
 	 */
 	private async trySummarizeWithRetries(
 		reason: SummarizeReason,
+		summarizeOptions: ISummarizeOptions = {},
 	): Promise<ISummarizeResults | undefined> {
 		// Helper to set summarize options, telemetry properties and call summarize.
 		const attemptSummarize = (
@@ -727,13 +750,13 @@ export class RunningSummarizer
 			summarizeProps: ISummarizeTelemetryProperties;
 			summarizeResult: ISummarizeResults;
 		} => {
-			const summarizeOptions: ISummarizeOptions = {
-				fullTree: false,
+			const attemptSummarizeOptions: ISummarizeOptions = {
+				fullTree: summarizeOptions.fullTree ?? false,
 			};
 			const summarizeProps: ISummarizeTelemetryProperties = {
 				summarizeReason: reason,
 				summaryAttempts: attemptNumber,
-				...summarizeOptions,
+				...attemptSummarizeOptions,
 				finalAttempt,
 			};
 			const summaryLogger = createChildLogger({
@@ -742,7 +765,7 @@ export class RunningSummarizer
 			});
 
 			const summaryOptions: ISubmitSummaryOptions = {
-				...summarizeOptions,
+				...attemptSummarizeOptions,
 				summaryLogger,
 				cancellationToken: this.cancellationToken,
 				finalAttempt,
@@ -872,6 +895,8 @@ export class RunningSummarizer
 					eventName: "SummarizeFailed",
 					maxAttempts,
 					summaryAttempts: currentAttempt,
+					summarizeReason: reason,
+					isLastSummary: reason === "lastSummary",
 				},
 				error,
 			);
@@ -893,8 +918,9 @@ export class RunningSummarizer
 	private async summarizeOnDemandWithRetries(
 		reason: SummarizeReason,
 		resultsBuilder: SummarizeResultBuilder,
+		summarizeOptions: ISummarizeOptions = {},
 	): Promise<ISummarizeResults> {
-		const results = await this.trySummarizeWithRetries(reason);
+		const results = await this.trySummarizeWithRetries(reason, summarizeOptions);
 		if (results === undefined) {
 			resultsBuilder.fail(
 				"Summarization was canceled",
@@ -932,13 +958,15 @@ export class RunningSummarizer
 			throw new UsageError("Attempted to run an already-running summarizer on demand");
 		}
 
-		const { reason, ...summarizeOptions } = options;
-		if (options.retryOnFailure === true) {
-			this.summarizeOnDemandWithRetries(`onDemand;${reason}`, resultsBuilder).catch(
-				(error: IRetriableFailureError) => {
-					resultsBuilder.fail("summarize failed", error);
-				},
-			);
+		const { reason, retryOnFailure, ...summarizeOptions } = options;
+		if (retryOnFailure === true) {
+			this.summarizeOnDemandWithRetries(
+				`onDemand;${reason}`,
+				resultsBuilder,
+				summarizeOptions,
+			).catch((error: IRetriableFailureError) => {
+				resultsBuilder.fail("summarize failed", error);
+			});
 		} else {
 			this.trySummarizeOnce(
 				{ summarizeReason: `onDemand/${reason}` },

package/src/summary/summaryDelayLoadedModule/summarizer.ts

@@ -301,7 +301,7 @@ export class Summarizer extends TypedEventEmitter<ISummarizerEvents> implements
 			this.runtime,
 		);
 		this.runningSummarizer = runningSummarizer;
-		this.setupForwardedEvents();
+		this.setupForwardedEvents(runningSummarizer);
 		this.starting = false;
 		return runningSummarizer;
 	}
@@ -399,24 +399,26 @@ export class Summarizer extends TypedEventEmitter<ISummarizerEvents> implements
 		this._heuristicData?.recordAttempt(summaryRefSeqNum);
 	}
 
-	private readonly forwardedEvents = new Map<string, () => void>();
+	private readonly forwardedEventsCleanup: (() => void)[] = [];
 
-	private setupForwardedEvents(): void {
-		for (const event of ["summarize", "summarizeAllAttemptsFailed"]) {
+	private setupForwardedEvents(runningSummarizer: RunningSummarizer): void {
+		for (const event of [
+			"summarize",
+			"summarizeAllAttemptsFailed",
+			"summarizeTimeout",
+		] as const) {
 			const listener = (...args: unknown[]): void => {
 				this.emit(event, ...args);
 			};
-			// TODO: better typing here
-			// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
-			this.runningSummarizer?.on(event as any, listener);
-			this.forwardedEvents.set(event, listener);
+			runningSummarizer.on(event, listener);
+			this.forwardedEventsCleanup.push(() => runningSummarizer.off(event, listener));
 		}
 	}
 
 	private cleanupForwardedEvents(): void {
-		for (const [event, listener] of this.forwardedEvents.entries()) {
-			this.runningSummarizer?.off(event, listener);
+		for (const cleanup of this.forwardedEventsCleanup) {
+			cleanup();
 		}
-		this.forwardedEvents.clear();
+		this.forwardedEventsCleanup.length = 0;
 	}
 }

package/src/summary/summaryDelayLoadedModule/summaryGenerator.ts

@@ -3,9 +3,12 @@
  * Licensed under the MIT License.
  */
 
+import { TypedEventEmitter } from "@fluid-internal/client-utils";
+import type { ISummarizerEvents } from "@fluidframework/container-runtime-definitions/internal";
 import { assert, type IPromiseTimer, Timer } from "@fluidframework/core-utils/internal";
 import { DriverErrorTypes, MessageType } from "@fluidframework/driver-definitions/internal";
 import { getRetryDelaySecondsFromError } from "@fluidframework/driver-utils/internal";
+import { TelemetryContext } from "@fluidframework/runtime-utils/internal";
 import {
 	isFluidError,
 	type ITelemetryLoggerExt,
@@ -40,8 +43,9 @@ const maxSummarizeTimeoutCount = 5; // Double and resend 5 times
 /**
  * This class generates and tracks a summary attempt.
  */
-export class SummaryGenerator {
+export class SummaryGenerator extends TypedEventEmitter<ISummarizerEvents> {
 	private readonly summarizeTimer: Timer;
+	private activeTelemetryContext?: TelemetryContext;
 	constructor(
 		private readonly pendingAckTimer: IPromiseTimer,
 		private readonly heuristicData: ISummarizeHeuristicData,
@@ -55,6 +59,7 @@ export class SummaryGenerator {
 		private readonly summaryWatcher: Pick<IClientSummaryWatcher, "watchSummary">,
 		private readonly logger: ITelemetryLoggerExt,
 	) {
+		super();
 		this.summarizeTimer = new Timer(maxSummarizeTimeoutTime, () =>
 			this.summarizeTimerHandler(maxSummarizeTimeoutTime, 1),
 		);
@@ -85,7 +90,16 @@ export class SummaryGenerator {
 		submitSummaryOptions: ISubmitSummaryOptions,
 		resultsBuilder: SummarizeResultBuilder,
 	): Promise<void> {
-		const { summaryLogger, cancellationToken, ...summarizeOptions } = submitSummaryOptions;
+		const {
+			summaryLogger,
+			cancellationToken,
+			telemetryContext = new TelemetryContext(),
+			...summarizeOptions
+		} = submitSummaryOptions;
+
+		telemetryContext.setCurrentSummarizeStep("submitSummary");
+		const submitOptions = { ...submitSummaryOptions, telemetryContext };
+		this.activeTelemetryContext = telemetryContext;
 
 		// Note: timeSinceLastAttempt and timeSinceLastSummary for the
 		// first summary are basically the time since the summarizer was loaded.
@@ -97,6 +111,8 @@ export class SummaryGenerator {
 			fullTree: summarizeOptions.fullTree ?? false,
 			timeSinceLastAttempt,
 			timeSinceLastSummary,
+			nonRuntimeOpsSinceLastSummary: this.heuristicData.numNonRuntimeOps,
+			runtimeOpsSinceLastSummary: this.heuristicData.numRuntimeOps,
 		};
 
 		const summarizeEvent = PerformanceEvent.start(
@@ -115,7 +131,7 @@ export class SummaryGenerator {
 		 * For submit failures, submitFailureResult should be provided. For nack failures, nackSummaryResult should
 		 * be provided. For op broadcast failures, only errors / properties should be provided.
 		 */
-		const fail = (
+		const summaryFail = (
 			errorCode: SummarizeErrorCode,
 			error: IRetriableFailureError,
 			properties?: SummaryGeneratorTelemetry,
@@ -148,10 +164,12 @@ export class SummaryGenerator {
 		// Wait to generate and send summary
 		this.summarizeTimer.start();
 		try {
+			telemetryContext.setCurrentSummarizeStep("generateSummary");
 			// Need to save refSeqNum before we record new attempt (happens as part of submitSummaryCallback)
 			const lastAttemptRefSeqNum = this.heuristicData.lastAttempt.refSequenceNumber;
 
-			summaryData = await this.submitSummaryCallback(submitSummaryOptions);
+			summaryData = await this.submitSummaryCallback(submitOptions);
+			telemetryContext.setCurrentSummarizeStep("submitSummaryOp");
 
 			// Cumulatively add telemetry properties based on how far generateSummary went.
 			const referenceSequenceNumber = summaryData.referenceSequenceNumber;
@@ -173,7 +191,7 @@ export class SummaryGenerator {
 				const errorCode: SummarizeErrorCode = "submitSummaryFailure";
 				const retriableError =
 					summaryData.error ?? new RetriableSummaryError(getFailMessage(errorCode));
-				return fail(errorCode, retriableError, summarizeTelemetryProps, {
+				return summaryFail(errorCode, retriableError, summarizeTelemetryProps, {
 					stage: summaryData.stage,
 				});
 			}
@@ -189,6 +207,7 @@ export class SummaryGenerator {
 			 * exceed the number of ops since last summary + number of data store whose reference state changed.
 			 */
 			if (submitSummaryOptions.fullTree !== true) {
+				telemetryContext.setCurrentSummarizeStep("watchSummary");
 				const { summarizedDataStoreCount, gcStateUpdatedDataStoreCount = 0 } =
 					summaryData.summaryStats;
 				if (
@@ -208,7 +227,7 @@ export class SummaryGenerator {
 			summarizeEvent.reportEvent("generate", { ...summarizeTelemetryProps });
 			resultsBuilder.summarySubmitted.resolve({ success: true, data: summaryData });
 		} catch (error) {
-			return fail(
+			return summaryFail(
 				"submitSummaryFailure",
 				wrapError(
 					error,
@@ -227,6 +246,8 @@ export class SummaryGenerator {
 			this.summarizeTimer.clear();
 		}
 
+		telemetryContext.setCurrentSummarizeStep("waitForSummaryAck");
+
 		try {
 			const pendingTimeoutP = this.pendingAckTimer.start();
 			const summary = this.summaryWatcher.watchSummary(summaryData.clientSequenceNumber);
@@ -239,13 +260,13 @@ export class SummaryGenerator {
 			);
 			if (waitBroadcastResult.result === "cancelled") {
 				const errorCode: SummarizeErrorCode = "disconnect";
-				return fail(errorCode, new RetriableSummaryError(getFailMessage(errorCode)));
+				return summaryFail(errorCode, new RetriableSummaryError(getFailMessage(errorCode)));
 			}
 			if (waitBroadcastResult.result !== "done") {
 				// The summary op may not have been received within the timeout due to a transient error. So,
 				// fail with a retriable error to re-attempt the summary if possible.
 				const errorCode: SummarizeErrorCode = "summaryOpWaitTimeout";
-				return fail(
+				return summaryFail(
 					errorCode,
 					new RetriableSummaryError(getFailMessage(errorCode), 0 /* retryAfterSeconds */),
 				);
@@ -275,13 +296,13 @@ export class SummaryGenerator {
 			);
 			if (waitAckNackResult.result === "cancelled") {
 				const errorCode: SummarizeErrorCode = "disconnect";
-				return fail(errorCode, new RetriableSummaryError(getFailMessage(errorCode)));
+				return summaryFail(errorCode, new RetriableSummaryError(getFailMessage(errorCode)));
 			}
 			if (waitAckNackResult.result !== "done") {
 				const errorCode: SummarizeErrorCode = "summaryAckWaitTimeout";
 				// The summary ack may not have been received within the timeout due to a transient error. So,
 				// fail with a retriable error to re-attempt the summary if possible.
-				return fail(
+				return summaryFail(
 					errorCode,
 					new RetriableSummaryError(getFailMessage(errorCode), 0 /* retryAfterSeconds */),
 				);
@@ -300,6 +321,7 @@ export class SummaryGenerator {
 				...summarizeTelemetryProps,
 			};
 			if (ackNackOp.type === MessageType.SummaryAck) {
+				telemetryContext.setCurrentSummarizeStep("ackReceived");
 				this.heuristicData.markLastAttemptAsSuccessful();
 				this.successfulSummaryCallback();
 				summarizeEvent.end({
@@ -324,6 +346,7 @@ export class SummaryGenerator {
 			} else {
 				// Check for retryDelay in summaryNack response.
 				assert(ackNackOp.type === MessageType.SummaryNack, 0x274 /* "type check" */);
+				telemetryContext.setCurrentSummarizeStep("nackReceived");
 				const summaryNack = ackNackOp.contents;
 				const errorMessage = summaryNack?.message;
 				const retryAfterSeconds = summaryNack?.retryAfter;
@@ -340,7 +363,7 @@ export class SummaryGenerator {
 					0x25f /* "retryAfterSeconds" */,
 				);
 				// This will only set resultsBuilder.receivedSummaryAckOrNack, as other promises are already set.
-				return fail(
+				return summaryFail(
 					errorCode,
 					error,
 					{ ...summarizeTelemetryProps, nackRetryAfter: retryAfterSeconds },
@@ -350,6 +373,7 @@ export class SummaryGenerator {
 			}
 		} finally {
 			this.pendingAckTimer.clear();
+			this.activeTelemetryContext = undefined;
 		}
 	}
 
@@ -390,8 +414,6 @@ export class SummaryGenerator {
 					clientSequenceNumber: summaryData.clientSequenceNumber,
 					hasMissingOpData: this.heuristicData.hasMissingOpData,
 					opsSizesSinceLastSummary: this.heuristicData.totalOpsSize,
-					nonRuntimeOpsSinceLastSummary: this.heuristicData.numNonRuntimeOps,
-					runtimeOpsSinceLastSummary: this.heuristicData.numRuntimeOps,
 				};
 			}
 
@@ -408,6 +430,13 @@ export class SummaryGenerator {
 			eventName: "SummarizeTimeout",
 			timeoutTime: time,
 			timeoutCount: count,
+			currentSummarizeStep: this.activeTelemetryContext?.getCurrentSummarizeStep(),
+		});
+		this.emit("summarizeTimeout", {
+			timeoutCount: count,
+			currentSummarizeStep: this.activeTelemetryContext?.getCurrentSummarizeStep(),
+			numUnsummarizedRuntimeOps: this.heuristicData.numRuntimeOps,
+			numUnsummarizedNonRuntimeOps: this.heuristicData.numNonRuntimeOps,
 		});
 		if (count < maxSummarizeTimeoutCount) {
 			// Double and start a new timer
@@ -420,5 +449,6 @@ export class SummaryGenerator {
 
 	public dispose(): void {
 		this.summarizeTimer.clear();
+		this.activeTelemetryContext = undefined;
 	}
 }

package/src/summary/summaryManager.ts

@@ -274,7 +274,7 @@ export class SummaryManager
 
 				const summarizer = await this.createSummarizerFn();
 				this.summarizer = summarizer;
-				this.setupForwardedEvents();
+				this.setupForwardedEvents(summarizer);
 
 				// Re-validate that it need to be running. Due to asynchrony, it may be not the case anymore
 				// If we can't run the LastSummary, simply return as to avoid paying the cost of launching
@@ -456,31 +456,32 @@ export class SummaryManager
 		this._disposed = true;
 	}
 
-	private readonly forwardedEvents = new Map<string, () => void>();
+	private readonly forwardedEventsCleanup: (() => void)[] = [];
 
-	private setupForwardedEvents(): void {
+	private setupForwardedEvents(summarizer: ISummarizer): void {
 		for (const event of [
 			"summarize",
 			"summarizeAllAttemptsFailed",
 			"summarizerStop",
 			"summarizerStart",
 			"summarizerStartupFailed",
-		]) {
+			"summarizeTimeout",
+		] as const) {
 			const listener = (...args: unknown[]): void => {
 				this.emit(event, ...args);
 			};
 			// TODO: better typing here
 			// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
-			this.summarizer?.on(event as any, listener);
-			this.forwardedEvents.set(event, listener);
+			summarizer.on(event as any, listener);
+			// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
+			this.forwardedEventsCleanup.push(() => summarizer.off(event as any, listener));
 		}
 	}
 
 	private cleanupForwardedEvents(): void {
-		for (const [event, listener] of this.forwardedEvents.entries()) {
-			// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
-			this.summarizer?.off(event as any, listener);
+		for (const cleanup of this.forwardedEventsCleanup) {
+			cleanup();
 		}
-		this.forwardedEvents.clear();
+		this.forwardedEventsCleanup.length = 0;
 	}
 }

package/.eslintrc.cjs

@@ -1,30 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-
-module.exports = {
-	extends: [require.resolve("@fluidframework/eslint-config-fluid/recommended"), "prettier"],
-	parserOptions: {
-		project: ["./tsconfig.json", "./src/test/tsconfig.json"],
-	},
-	rules: {
-		// AB#51780: temporarily disabled because of crashes in typescript-eslint on destructuring in promise chains.
-		// See: channelCollection.ts:1070
-		"@typescript-eslint/unbound-method": "off",
-	},
-	overrides: [
-		{
-			// Rules only for test files
-			files: ["*.spec.ts", "src/test/**"],
-			rules: {
-				// TODO: remove these overrides and fix violations
-				"@typescript-eslint/explicit-function-return-type": "off",
-				"unicorn/consistent-function-scoping": "off",
-
-				// Test files are run in node only so additional node libraries can be used.
-				"import-x/no-nodejs-modules": ["error", { allow: ["node:assert", "node:crypto"] }],
-			},
-		},
-	],
-};