@fluidframework/container-runtime 2.0.0-dev.4.2.0.153917 → 2.0.0-dev.4.3.0.158678

package/src/id-compressor/utils.ts

@@ -0,0 +1,114 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+/**
+ * Remove `readonly` from all fields.
+ */
+export type Mutable<T> = { -readonly [P in keyof T]: T[P] };
+
+/** A union type of the first `N` positive integers */
+export type TakeWholeNumbers<N extends number, A extends never[] = []> = N extends A["length"]
+	? never
+	: A["length"] | TakeWholeNumbers<N, [never, ...A]>;
+
+/** Returns a tuple type with exactly `Length` elements of type `T` */
+export type ArrayOfLength<T, Length extends number, A extends T[] = []> = Length extends A["length"]
+	? A
+	: ArrayOfLength<T, Length, [T, ...A]>;
+
+/**
+ * Fails true iff `array` has at least `length` elements
+ */
+export function hasAtLeastLength<T, Len extends TakeWholeNumbers<16>>(
+	array: readonly T[],
+	length: Len,
+): array is [...ArrayOfLength<T, Len>, ...T[]] {
+	return array.length >= length;
+}
+
+/**
+ * A numeric comparator used for sorting in ascending order.
+ *
+ * Handles +/-0 like Map: -0 is equal to +0.
+ */
+export function compareFiniteNumbers<T extends number>(a: T, b: T): number {
+	return a - b;
+}
+
+/**
+ * A numeric comparator used for sorting in descending order.
+ *
+ * Handles +/-0 like Map: -0 is equal to +0.
+ */
+export function compareFiniteNumbersReversed<T extends number>(a: T, b: T): number {
+	return b - a;
+}
+
+/**
+ * Compare two maps and return true if their contents are equivalent.
+ * @param mapA - The first array to compare
+ * @param mapB - The second array to compare
+ * @param elementComparator - The function used to check if two `T`s are equivalent.
+ * Defaults to `Object.is()` equality (a shallow compare)
+ */
+export function compareMaps<K, V>(
+	mapA: ReadonlyMap<K, V>,
+	mapB: ReadonlyMap<K, V>,
+	elementComparator: (a: V, b: V) => boolean = Object.is,
+): boolean {
+	if (mapA.size !== mapB.size) {
+		return false;
+	}
+
+	for (const [keyA, valueA] of mapA) {
+		const valueB = mapB.get(keyA);
+		if (valueB === undefined || !elementComparator(valueA, valueB)) {
+			return false;
+		}
+	}
+
+	return true;
+}
+
+/**
+ * Retrieve a value from a map with the given key, or create a new entry if the key is not in the map.
+ * @param map - The map to query/update
+ * @param key - The key to lookup in the map
+ * @param defaultValue - a function which returns a default value. This is called and used to set an initial value for the given key in the map if none exists
+ * @returns either the existing value for the given key, or the newly-created value (the result of `defaultValue`)
+ */
+export function getOrCreate<K, V>(map: Map<K, V>, key: K, defaultValue: (key: K) => V): V {
+	let value = map.get(key);
+	if (value === undefined) {
+		value = defaultValue(key);
+		map.set(key, value);
+	}
+	return value;
+}
+
+/**
+ * Compares strings lexically to form a strict partial ordering.
+ */
+export function compareStrings<T extends string>(a: T, b: T): number {
+	return a > b ? 1 : a === b ? 0 : -1;
+}
+
+export function fail(message: string): never {
+	throw new Error(message);
+}
+
+/**
+ * Sets a property in such a way that it is only set on `destination` if the provided value is not undefined.
+ * This avoids having explicit undefined values under properties that would cause `Object.hasOwnProperty` to return true.
+ */
+export function setPropertyIfDefined<TDst, P extends keyof TDst>(
+	value: TDst[P] | undefined,
+	destination: TDst,
+	property: P,
+): void {
+	if (value !== undefined) {
+		destination[property] = value;
+	}
+}

package/src/id-compressor/uuidUtilities.ts

@@ -0,0 +1,123 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { assert } from "@fluidframework/common-utils";
+import { StableId, UuidString } from "@fluidframework/runtime-definitions";
+import { v4, NIL } from "uuid";
+
+const hexadecimalCharCodes = Array.from("09afAF").map((c) => c.charCodeAt(0)) as [
+	zero: number,
+	nine: number,
+	a: number,
+	f: number,
+	A: number,
+	F: number,
+];
+
+function isHexadecimalCharacter(charCode: number): boolean {
+	return (
+		(charCode >= hexadecimalCharCodes[0] && charCode <= hexadecimalCharCodes[1]) ||
+		(charCode >= hexadecimalCharCodes[2] && charCode <= hexadecimalCharCodes[3]) ||
+		(charCode >= hexadecimalCharCodes[4] && charCode <= hexadecimalCharCodes[5])
+	);
+}
+
+/** The null (lowest/all-zeros) UUID */
+export const nilUuid = assertIsUuidString(NIL);
+
+/**
+ * Asserts that the given string is a UUID
+ */
+export function assertIsUuidString(uuidString: string): UuidString {
+	assert(isUuidString(uuidString), 0x4a2 /* Expected an UuidString */);
+	return uuidString;
+}
+
+/**
+ * Returns true iff the given string is a valid UUID-like string of hexadecimal characters
+ * 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'
+ */
+export function isUuidString(str: string): str is UuidString {
+	for (let i = 0; i < str.length; i++) {
+		switch (i) {
+			case 8:
+			case 13:
+			case 18:
+			case 23:
+				if (str.charAt(i) !== "-") {
+					return false;
+				}
+				break;
+
+			default:
+				if (!isHexadecimalCharacter(str.charCodeAt(i))) {
+					return false;
+				}
+				break;
+		}
+	}
+
+	return true;
+}
+
+/**
+ * Generate a random stable ID
+ */
+export function generateStableId(): StableId {
+	return assertIsStableId(v4());
+}
+
+/**
+ * Asserts that the given string is a stable ID.
+ */
+export function assertIsStableId(stableId: string): StableId {
+	assert(isStableId(stableId), 0x4a3 /* Expected a StableId */);
+	return stableId;
+}
+
+/**
+ * Returns true iff the given string is a valid Version 4, variant 2 UUID
+ * 'xxxxxxxx-xxxx-4xxx-vxxx-xxxxxxxxxxxx'
+ */
+export function isStableId(str: string): str is StableId {
+	if (str.length !== 36) {
+		return false;
+	}
+
+	for (let i = 0; i < str.length; i++) {
+		switch (i) {
+			case 8:
+			case 13:
+			case 18:
+			case 23:
+				if (str.charAt(i) !== "-") {
+					return false;
+				}
+				break;
+
+			case 14:
+				if (str.charAt(i) !== "4") {
+					return false;
+				}
+				break;
+
+			case 19: {
+				const char = str.charAt(i);
+				if (char !== "8" && char !== "9" && char !== "a" && char !== "b") {
+					return false;
+				}
+				break;
+			}
+
+			default:
+				if (!isHexadecimalCharacter(str.charCodeAt(i))) {
+					return false;
+				}
+				break;
+		}
+	}
+
+	return true;
+}

package/src/index.ts

@@ -69,3 +69,4 @@ export {
 	ICancellableSummarizerController,
 } from "./summary";
 export { IChunkedOp, unpackRuntimeMessage } from "./opLifecycle";
+export { generateStableId, isStableId, assertIsStableId } from "./id-compressor";

package/src/opLifecycle/README.md

@@ -13,6 +13,7 @@ By default, the runtime is configured with a max batch size of `716800` bytes, w
 -   [Introduction](#introduction)
     -   [Compression](#compression)
     -   [Grouped batching](#grouped-batching)
+        -   [Risks](#risks)
     -   [Chunking for compression](#chunking-for-compression)
     -   [Disabling in case of emergency](#disabling-in-case-of-emergency)
     -   [Example configs](#example-configs)
@@ -38,6 +39,18 @@ The purpose for enabling grouped batching on top of compression is that regular
 
 See [below](#how-grouped-batching-works) for an example.
 
+### Risks
+
+This option is experimental and should not be enabled yet in production. This option should **ONLY** be enabled after observing that 99.9% of your application sessions contains these changes (runtime version "2.0.0-internal.4.1.0" or later). Containers created with this option may not open in future versions of the framework.
+
+This option will change a couple of expectations around message structure and runtime layer expectations. Only enable this option after testing
+and verifying that the following expectation changes won't have any effects:
+
+-   batch messages observed at the runtime layer will not match messages seen at the loader layer (i.e. grouped form at loader layer, ungrouped form at runtime layer)
+-   messages within the same batch will have the same sequence number
+-   client sequence numbers on batch messages can only be used to order messages with the same sequenceNumber
+-   requires all ops to be processed by runtime layer (version "2.0.0-internal.1.2.0" or later https://github.com/microsoft/FluidFramework/pull/11832)
+
 ## Chunking for compression
 
 **Op chunking for compression targets payloads which exceed the max batch size after compression.** So, only payloads which are already compressed. By default, the feature is enabled.

package/src/opLifecycle/batchManager.ts

@@ -12,6 +12,11 @@ export interface IBatchManagerOptions {
 	readonly compressionOptions?: ICompressionRuntimeOptions;
 }
 
+export interface BatchSequenceNumbers {
+	referenceSequenceNumber?: number;
+	clientSequenceNumber?: number;
+}
+
 /**
  * Estimated size of the stringification overhead for an op accumulated
  * from runtime to loader to the service.
@@ -32,15 +37,24 @@ export class BatchManager {
 		return this.batchContentSize;
 	}
 
-	public get referenceSequenceNumber(): number | undefined {
+	public get sequenceNumbers(): BatchSequenceNumbers {
+		return {
+			referenceSequenceNumber: this.referenceSequenceNumber,
+			clientSequenceNumber: this.clientSequenceNumber,
+		};
+	}
+
+	private get referenceSequenceNumber(): number | undefined {
 		return this.pendingBatch.length === 0
 			? undefined
 			: this.pendingBatch[this.pendingBatch.length - 1].referenceSequenceNumber;
 	}
 
+	private clientSequenceNumber: number | undefined;
+
 	constructor(public readonly options: IBatchManagerOptions) {}
 
-	public push(message: BatchMessage): boolean {
+	public push(message: BatchMessage, currentClientSequenceNumber?: number): boolean {
 		const contentSize = this.batchContentSize + (message.contents?.length ?? 0);
 		const opCount = this.pendingBatch.length;
 
@@ -68,6 +82,10 @@ export class BatchManager {
 			return false;
 		}
 
+		if (this.pendingBatch.length === 0) {
+			this.clientSequenceNumber = currentClientSequenceNumber;
+		}
+
 		this.batchContentSize = contentSize;
 		this.pendingBatch.push(message);
 		return true;
@@ -86,6 +104,7 @@ export class BatchManager {
 
 		this.pendingBatch = [];
 		this.batchContentSize = 0;
+		this.clientSequenceNumber = undefined;
 
 		return addBatchMetadata(batch);
 	}
@@ -136,3 +155,17 @@ const addBatchMetadata = (batch: IBatch): IBatch => {
 export const estimateSocketSize = (batch: IBatch): number => {
 	return batch.contentSizeInBytes + opOverhead * batch.content.length;
 };
+
+export const sequenceNumbersMatch = (
+	seqNums: BatchSequenceNumbers,
+	otherSeqNums: BatchSequenceNumbers,
+): boolean => {
+	return (
+		(seqNums.referenceSequenceNumber === undefined ||
+			otherSeqNums.referenceSequenceNumber === undefined ||
+			seqNums.referenceSequenceNumber === otherSeqNums.referenceSequenceNumber) &&
+		(seqNums.clientSequenceNumber === undefined ||
+			otherSeqNums.clientSequenceNumber === undefined ||
+			seqNums.clientSequenceNumber === otherSeqNums.clientSequenceNumber)
+	);
+};

package/src/opLifecycle/index.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-export { BatchManager, estimateSocketSize } from "./batchManager";
+export { BatchManager, estimateSocketSize, BatchSequenceNumbers } from "./batchManager";
 export {
 	BatchMessage,
 	IBatch,

package/src/opLifecycle/opGroupingManager.ts

@@ -5,7 +5,7 @@
 
 import { assert } from "@fluidframework/common-utils";
 import { ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
-import { ContainerRuntimeMessage } from "..";
+import { ContainerMessageType, ContainerRuntimeMessage } from "..";
 import { IBatch } from "./definitions";
 
 interface IGroupedMessage {
@@ -25,6 +25,10 @@ export class OpGroupingManager {
 		}
 
 		for (const message of batch.content) {
+			// Blob attaches cannot be grouped (grouped batching would hide metadata)
+			if (message.deserializedContent.type === ContainerMessageType.BlobAttach) {
+				return batch;
+			}
 			if (message.metadata) {
 				const keys = Object.keys(message.metadata);
 				assert(keys.length < 2, 0x5dd /* cannot group ops with metadata */);

package/src/opLifecycle/outbox.ts

@@ -15,7 +15,12 @@ import {
 } from "@fluidframework/telemetry-utils";
 import { ICompressionRuntimeOptions } from "../containerRuntime";
 import { PendingStateManager } from "../pendingStateManager";
-import { BatchManager, estimateSocketSize } from "./batchManager";
+import {
+	BatchManager,
+	BatchSequenceNumbers,
+	estimateSocketSize,
+	sequenceNumbersMatch,
+} from "./batchManager";
 import { BatchMessage, IBatch } from "./definitions";
 import { OpCompressor } from "./opCompressor";
 import { OpGroupingManager } from "./opGroupingManager";
@@ -37,6 +42,20 @@ export interface IOutboxParameters {
 	readonly splitter: OpSplitter;
 	readonly logger: ITelemetryLogger;
 	readonly groupingManager: OpGroupingManager;
+	readonly getCurrentSequenceNumbers: () => BatchSequenceNumbers;
+}
+
+function getLongStack(action: () => Error): Error {
+	// Increase the stack trace limit temporarily, so as to debug better in case it occurs.
+	try {
+		const originalStackTraceLimit = (Error as any).stackTraceLimit;
+		(Error as any).stackTraceLimit = 50;
+		const result = action();
+		(Error as any).stackTraceLimit = originalStackTraceLimit;
+		return result;
+	} catch (error) {
+		return action();
+	}
 }
 
 export class Outbox {
@@ -76,39 +95,39 @@ export class Outbox {
 	 * what was already in the batch managers, this means that batching has been interrupted so
 	 * we will flush the accumulated messages to account for that and create a new batch with the new
 	 * message as the first message.
-	 *
-	 * @param message - the incoming message
 	 */
-	private maybeFlushPartialBatch(message: BatchMessage) {
-		const mainBatchReference = this.mainBatch.referenceSequenceNumber;
-		const attachFlowBatchReference = this.attachFlowBatch.referenceSequenceNumber;
+	private maybeFlushPartialBatch() {
+		const mainBatchSeqNums = this.mainBatch.sequenceNumbers;
+		const attachFlowBatchSeqNums = this.attachFlowBatch.sequenceNumbers;
 		assert(
 			this.params.config.disablePartialFlush ||
-				mainBatchReference === undefined ||
-				attachFlowBatchReference === undefined ||
-				mainBatchReference === attachFlowBatchReference,
+				sequenceNumbersMatch(mainBatchSeqNums, attachFlowBatchSeqNums),
 			0x58d /* Reference sequence numbers from both batches must be in sync */,
 		);
 
+		const currentSequenceNumbers = this.params.getCurrentSequenceNumbers();
+
 		if (
-			(mainBatchReference === undefined ||
-				mainBatchReference === message.referenceSequenceNumber) &&
-			(attachFlowBatchReference === undefined ||
-				attachFlowBatchReference === message.referenceSequenceNumber)
+			sequenceNumbersMatch(mainBatchSeqNums, currentSequenceNumbers) &&
+			sequenceNumbersMatch(attachFlowBatchSeqNums, currentSequenceNumbers)
 		) {
 			// The reference sequence numbers are stable, there is nothing to do
 			return;
 		}
 
 		if (++this.mismatchedOpsReported <= this.maxMismatchedOpsToReport) {
-			this.mc.logger.sendErrorEvent(
+			this.mc.logger.sendTelemetryEvent(
 				{
+					category: this.params.config.disablePartialFlush ? "error" : "generic",
 					eventName: "ReferenceSequenceNumberMismatch",
-					mainReferenceSequenceNumber: mainBatchReference,
-					attachReferenceSequenceNumber: attachFlowBatchReference,
-					messageReferenceSequenceNumber: message.referenceSequenceNumber,
+					mainReferenceSequenceNumber: mainBatchSeqNums.referenceSequenceNumber,
+					mainClientSequenceNumber: mainBatchSeqNums.clientSequenceNumber,
+					attachReferenceSequenceNumber: attachFlowBatchSeqNums.referenceSequenceNumber,
+					attachClientSequenceNumber: attachFlowBatchSeqNums.clientSequenceNumber,
+					currentReferenceSequenceNumber: currentSequenceNumbers.referenceSequenceNumber,
+					currentClientSequenceNumber: currentSequenceNumbers.clientSequenceNumber,
 				},
-				new UsageError("Submission of an out of order message"),
+				getLongStack(() => new UsageError("Submission of an out of order message")),
 			);
 		}
 
@@ -118,9 +137,14 @@ export class Outbox {
 	}
 
 	public submit(message: BatchMessage) {
-		this.maybeFlushPartialBatch(message);
+		this.maybeFlushPartialBatch();
 
-		if (!this.mainBatch.push(message)) {
+		if (
+			!this.mainBatch.push(
+				message,
+				this.params.getCurrentSequenceNumbers().clientSequenceNumber,
+			)
+		) {
 			throw new GenericError("BatchTooLarge", /* error */ undefined, {
 				opSize: message.contents?.length ?? 0,
 				batchSize: this.mainBatch.contentSizeInBytes,
@@ -131,14 +155,24 @@ export class Outbox {
 	}
 
 	public submitAttach(message: BatchMessage) {
-		this.maybeFlushPartialBatch(message);
+		this.maybeFlushPartialBatch();
 
-		if (!this.attachFlowBatch.push(message)) {
+		if (
+			!this.attachFlowBatch.push(
+				message,
+				this.params.getCurrentSequenceNumbers().clientSequenceNumber,
+			)
+		) {
 			// BatchManager has two limits - soft limit & hard limit. Soft limit is only engaged
 			// when queue is not empty.
 			// Flush queue & retry. Failure on retry would mean - single message is bigger than hard limit
 			this.flushInternal(this.attachFlowBatch.popBatch());
-			if (!this.attachFlowBatch.push(message)) {
+			if (
+				!this.attachFlowBatch.push(
+					message,
+					this.params.getCurrentSequenceNumbers().clientSequenceNumber,
+				)
+			) {
 				throw new GenericError("BatchTooLarge", /* error */ undefined, {
 					opSize: message.contents?.length ?? 0,
 					batchSize: this.attachFlowBatch.contentSizeInBytes,

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/container-runtime";
-export const pkgVersion = "2.0.0-dev.4.2.0.153917";
+export const pkgVersion = "2.0.0-dev.4.3.0.158678";

package/src/pendingStateManager.ts

@@ -49,10 +49,7 @@ export interface IRuntimeStateHandler {
 	connected(): boolean;
 	clientId(): string | undefined;
 	close(error?: ICriticalContainerError): void;
-	applyStashedOp: (
-		type: ContainerMessageType,
-		content: ISequencedDocumentMessage,
-	) => Promise<unknown>;
+	applyStashedOp: (type: ContainerMessageType, content: unknown) => Promise<unknown>;
 	reSubmit(
 		type: ContainerMessageType,
 		content: any,
@@ -110,9 +107,20 @@ export class PendingStateManager implements IDisposable {
 			return {
 				// delete localOpMetadata since it may not be serializable
 				// and will be regenerated by applyStashedOp()
-				pendingStates: this.pendingMessages
-					.toArray()
-					.map((message) => ({ ...message, localOpMetadata: undefined })),
+				pendingStates: this.pendingMessages.toArray().map((message) =>
+					// IdAllocations need their localOpMetadata stashed in the contents
+					// of the op to correctly resume the session when processing stashed ops
+					message.messageType === ContainerMessageType.IdAllocation
+						? {
+								...message,
+								content: {
+									...message.content,
+									stashedState: message.localOpMetadata,
+								},
+								localOpMetadata: undefined,
+						  }
+						: { ...message, localOpMetadata: undefined },
+				),
 			};
 		}
 	}
@@ -211,6 +219,12 @@ export class PendingStateManager implements IDisposable {
 			);
 			nextMessage.localOpMetadata = localOpMetadata;
 
+			if (nextMessage.messageType === ContainerMessageType.IdAllocation) {
+				// Remove the stashed state from the op
+				// so that it doesn't go over the wire
+				delete nextMessage.content.stashedState;
+			}
+
 			// then we push onto pendingMessages which will cause PendingStateManager to resubmit when we connect
 			// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 			this.pendingMessages.push(this.initialMessages.shift()!);

package/src/summary/index.ts

@@ -94,6 +94,7 @@ export {
 	rootHasIsolatedChannels,
 	WriteFluidDataStoreAttributes,
 	wrapSummaryInChannelsTree,
+	idCompressorBlobName,
 } from "./summaryFormat";
 export { getFailMessage, SummarizeReason } from "./summaryGenerator";
 export {

package/src/summary/orderedClientElection.ts

@@ -336,7 +336,7 @@ export class OrderedClientElection
 	}
 
 	constructor(
-		logger: ITelemetryLogger,
+		private readonly logger: ITelemetryLogger,
 		private readonly orderedClientCollection: IOrderedClientCollection,
 		/** Serialized state from summary or current sequence number at time of load if new. */
 		initialState: ISerializedElection | number,
@@ -416,6 +416,13 @@ export class OrderedClientElection
 			change = true;
 		}
 		if (change) {
+			this.logger.sendTelemetryEvent({
+				eventName: "SummarizerClientElected",
+				electedClientId: this._electedClient?.clientId,
+				electedParentId: this._electedParent?.clientId,
+				electionSequenceNumber: sequenceNumber,
+				isSummarizerClient,
+			});
 			this.emit("election", client, sequenceNumber, prevClient);
 		}
 	}
@@ -423,6 +430,12 @@ export class OrderedClientElection
 	private tryElectingParent(client: ILinkedClient | undefined, sequenceNumber: number): void {
 		if (this._electedParent !== client) {
 			this._electedParent = client;
+			this.logger.sendTelemetryEvent({
+				eventName: "SummarizerParentElected",
+				electedClientId: this._electedClient?.clientId,
+				electedParentId: this._electedParent?.clientId,
+				electionSequenceNumber: sequenceNumber,
+			});
 			this.emit("election", this._electedClient, sequenceNumber, this._electedClient);
 		}
 	}
@@ -457,7 +470,7 @@ export class OrderedClientElection
 			const newClientIsSummarizer = client.client.details.type === summarizerClientType;
 			const electedClientIsSummarizer =
 				this._electedClient?.client.details.type === summarizerClientType;
-			// Note that we allow a summarizer client to supercede an interactive client as elected client.
+			// Note that we allow a summarizer client to supersede an interactive client as elected client.
 			if (
 				this._electedClient === undefined ||
 				(!electedClientIsSummarizer && newClientIsSummarizer)

package/src/summary/runningSummarizer.ts

@@ -46,7 +46,6 @@ import {
 const maxSummarizeAckWaitTime = 10 * 60 * 1000; // 10 minutes
 
 const defaultNumberSummarizationAttempts = 2; // only up to 2 attempts
-const numberOfAttemptsOnRestartAsRecovery = 1; // Only summarize once
 
 /**
  * An instance of RunningSummarizer manages the heuristics for summarizing.
@@ -133,7 +132,6 @@ export class RunningSummarizer implements IDisposable {
 	private heuristicRunner?: ISummarizeHeuristicRunner;
 	private readonly generator: SummaryGenerator;
 	private readonly mc: MonitoringContext;
-	private readonly shouldAbortOnSummaryFailure: boolean;
 
 	private enqueuedSummary:
 		| {
@@ -177,10 +175,6 @@ export class RunningSummarizer implements IDisposable {
 			}),
 		);
 
-		this.shouldAbortOnSummaryFailure =
-			this.mc.config.getString("Fluid.ContainerRuntime.Test.SummarizationRecoveryMethod") ===
-			"restart";
-
 		if (configuration.state !== "disableHeuristics") {
 			assert(
 				this.configuration.state === "enabled",
@@ -601,10 +595,9 @@ export class RunningSummarizer implements IDisposable {
 				let summaryAttempts = 0;
 				let summaryAttemptsPerPhase = 0;
 				// Reducing the default number of attempts to defaultNumberofSummarizationAttempts.
-				let totalAttempts = this.shouldAbortOnSummaryFailure
-					? numberOfAttemptsOnRestartAsRecovery
-					: this.mc.config.getNumber("Fluid.Summarizer.Attempts") ??
-					  defaultNumberSummarizationAttempts;
+				let totalAttempts =
+					this.mc.config.getNumber("Fluid.Summarizer.Attempts") ??
+					defaultNumberSummarizationAttempts;
 
 				if (totalAttempts > attempts.length) {
 					this.mc.logger.sendTelemetryEvent({
@@ -676,20 +669,6 @@ export class RunningSummarizer implements IDisposable {
 					}
 				}
 
-				if (this.shouldAbortOnSummaryFailure) {
-					this.mc.logger.sendTelemetryEvent(
-						{
-							eventName: "ClosingSummarizerOnSummaryStale",
-							reason,
-							message: lastResult?.message,
-						},
-						lastResult?.error,
-					);
-
-					this.stopSummarizerCallback("latestSummaryStateStale");
-					this.runtime.closeFn();
-					return;
-				}
 				// If all attempts failed, log error (with last attempt info) and close the summarizer container
 				this.mc.logger.sendErrorEvent(
 					{