@fluidframework/container-runtime 2.0.0-dev-rc.5.0.0.263932 → 2.0.0-dev-rc.5.0.0.265721

package/src/index.ts

@@ -97,7 +97,7 @@ export {
 	ICancellableSummarizerController,
 	SubmitSummaryFailureData,
 	SummaryStage,
-	IRetriableFailureResult,
+	IRetriableFailureError,
 	ISummarizeEventProps,
 	IdCompressorMode,
 	IDocumentSchema,

package/src/opLifecycle/outbox.ts

@@ -201,32 +201,7 @@ export class Outbox {
 	public submitIdAllocation(message: BatchMessage) {
 		this.maybeFlushPartialBatch();
 
-		if (
-			!this.idAllocationBatch.push(
-				message,
-				this.isContextReentrant(),
-				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.idAllocationBatch);
-
-			this.addMessageToBatchManager(this.idAllocationBatch, message);
-		}
-
-		// If compression is enabled, we will always successfully receive
-		// attach ops and compress then send them at the next JS turn, regardless
-		// of the overall size of the accumulated ops in the batch.
-		// However, it is more efficient to flush these ops faster, preferably
-		// after they reach a size which would benefit from compression.
-		if (
-			this.idAllocationBatch.contentSizeInBytes >=
-			this.params.config.compressionOptions.minimumBatchSizeInBytes
-		) {
-			this.flushInternal(this.idAllocationBatch);
-		}
+		this.addMessageToBatchManager(this.idAllocationBatch, message);
 	}
 
 	private addMessageToBatchManager(batchManager: BatchManager, message: BatchMessage) {
@@ -434,6 +409,7 @@ export class Outbox {
 		const mainBatch: IBatchCheckpoint = this.mainBatch.checkpoint();
 		return {
 			mainBatch,
+			idAllocationBatch: this.idAllocationBatch.checkpoint(),
 			blobAttachBatch: this.blobAttachBatch.checkpoint(),
 		};
 	}

package/src/packageVersion.ts

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

package/src/summary/index.ts

@@ -63,7 +63,7 @@ export {
 	SummarizeResultPart,
 	SubmitSummaryFailureData,
 	SummaryStage,
-	IRetriableFailureResult,
+	IRetriableFailureError,
 	ISummarizeEventProps,
 } from "./summarizerTypes.js";
 export {

package/src/summary/orderedClientElection.ts

@@ -351,6 +351,7 @@ export class OrderedClientElection
 		/** Serialized state from summary or current sequence number at time of load if new. */
 		initialState: ISerializedElection | number,
 		private readonly isEligibleFn: (c: ITrackedClient) => boolean,
+		private readonly recordPerformanceEvents: boolean = false,
 	) {
 		super();
 		let initialClient: ILinkedClient | undefined;
@@ -410,17 +411,42 @@ export class OrderedClientElection
 	 * Note that this function does no eligibility or suitability checks. If we get here, then
 	 * we will set _electedClient, and we will set _electedParent if this is an interactive client.
 	 */
-	private tryElectingClient(client: ILinkedClient | undefined, sequenceNumber: number): void {
+	private tryElectingClient(
+		client: ILinkedClient | undefined,
+		sequenceNumber: number,
+		reason: string,
+	): void {
+		this.sendPerformanceEvent(
+			"TryElectingClient",
+			client,
+			sequenceNumber,
+			false /* forceSend */,
+			reason,
+		);
 		let change = false;
 		const isSummarizerClient = client?.client.details.type === summarizerClientType;
 		const prevClient = this._electedClient;
 		if (this._electedClient !== client) {
+			this.sendPerformanceEvent(
+				"ClientElected",
+				client,
+				sequenceNumber,
+				true /* forceSend */,
+				reason,
+			);
 			// Changing the elected client. Record the sequence number and note that we have to fire an event.
 			this._electionSequenceNumber = sequenceNumber;
 			this._electedClient = client;
 			change = true;
 		}
 		if (this._electedParent !== client && !isSummarizerClient) {
+			this.sendPerformanceEvent(
+				"InteractiveClientElected",
+				client,
+				sequenceNumber,
+				true /* forceSend */,
+				reason,
+			);
 			// Changing the elected parent as well.
 			this._electedParent = client;
 			change = true;
@@ -430,8 +456,26 @@ export class OrderedClientElection
 		}
 	}
 
-	private tryElectingParent(client: ILinkedClient | undefined, sequenceNumber: number): void {
+	private tryElectingParent(
+		client: ILinkedClient | undefined,
+		sequenceNumber: number,
+		reason: string,
+	): void {
+		this.sendPerformanceEvent(
+			"TryElectingParent",
+			client,
+			sequenceNumber,
+			false /* forceSend */,
+			reason,
+		);
 		if (this._electedParent !== client) {
+			this.sendPerformanceEvent(
+				"ParentElected",
+				client,
+				sequenceNumber,
+				true /* forceSend */,
+				reason,
+			);
 			this._electedParent = client;
 			this.emit("election", this._electedClient, sequenceNumber, this._electedClient);
 		}
@@ -462,6 +506,7 @@ export class OrderedClientElection
 	 * @param sequenceNumber - sequence number when client was added
 	 */
 	private addClient(client: ILinkedClient, sequenceNumber: number): void {
+		this.sendPerformanceEvent("AddClient", client, sequenceNumber);
 		if (this.isEligibleFn(client)) {
 			this._eligibleCount++;
 			const newClientIsSummarizer = client.client.details.type === summarizerClientType;
@@ -472,10 +517,10 @@ export class OrderedClientElection
 				this._electedClient === undefined ||
 				(!electedClientIsSummarizer && newClientIsSummarizer)
 			) {
-				this.tryElectingClient(client, sequenceNumber);
+				this.tryElectingClient(client, sequenceNumber, "AddClient");
 			} else if (this._electedParent === undefined && !newClientIsSummarizer) {
 				// This is an odd case. If the _electedClient is set, the _electedParent should be as well.
-				this.tryElectingParent(client, sequenceNumber);
+				this.tryElectingParent(client, sequenceNumber, "AddClient");
 			}
 		}
 	}
@@ -487,6 +532,7 @@ export class OrderedClientElection
 	 * @param sequenceNumber - sequence number when client was removed
 	 */
 	private removeClient(client: ILinkedClient, sequenceNumber: number): void {
+		this.sendPerformanceEvent("RemoveClient", client, sequenceNumber);
 		if (this.isEligibleFn(client)) {
 			this._eligibleCount--;
 			if (this._electedClient === client) {
@@ -497,14 +543,18 @@ export class OrderedClientElection
 					if (this._electedClient.client.details.type !== summarizerClientType) {
 						throw new UsageError("Elected client should be a summarizer client 1");
 					}
-					this.tryElectingClient(this._electedParent, sequenceNumber);
+					this.tryElectingClient(
+						this._electedParent,
+						sequenceNumber,
+						"RemoveSummarizerClient",
+					);
 				} else {
 					// 2. The _electedClient is an interactive client that has left the quorum.
 					// Automatically shift to next oldest client.
 					const nextClient =
 						this.findFirstEligibleParent(this._electedParent?.youngerClient) ??
 						this.findFirstEligibleParent(this.orderedClientCollection.oldestClient);
-					this.tryElectingClient(nextClient, sequenceNumber);
+					this.tryElectingClient(nextClient, sequenceNumber, "RemoveClient");
 				}
 			} else if (this._electedParent === client) {
 				// Removing the _electedParent (but not _electedClient).
@@ -516,7 +566,7 @@ export class OrderedClientElection
 				const nextParent =
 					this.findFirstEligibleParent(this._electedParent?.youngerClient) ??
 					this.findFirstEligibleParent(this.orderedClientCollection.oldestClient);
-				this.tryElectingParent(nextParent, sequenceNumber);
+				this.tryElectingParent(nextParent, sequenceNumber, "RemoveClient");
 			}
 		}
 	}
@@ -534,11 +584,11 @@ export class OrderedClientElection
 			this.findFirstEligibleParent(this._electedParent?.youngerClient) ??
 			this.findFirstEligibleParent(this.orderedClientCollection.oldestClient);
 		if (this._electedClient === undefined || this._electedClient === this._electedParent) {
-			this.tryElectingClient(nextClient, sequenceNumber);
+			this.tryElectingClient(nextClient, sequenceNumber, "IncrementElectedClient");
 		} else {
 			// The _electedClient is a summarizer and should not be replaced until it leaves the quorum.
 			// Changing the _electedParent will stop the summarizer.
-			this.tryElectingParent(nextClient, sequenceNumber);
+			this.tryElectingParent(nextClient, sequenceNumber, "IncrementElectedClient");
 		}
 	}
 
@@ -549,11 +599,11 @@ export class OrderedClientElection
 	public resetElectedClient(sequenceNumber: number): void {
 		const firstClient = this.findFirstEligibleParent(this.orderedClientCollection.oldestClient);
 		if (this._electedClient === undefined || this._electedClient === this._electedParent) {
-			this.tryElectingClient(firstClient, sequenceNumber);
+			this.tryElectingClient(firstClient, sequenceNumber, "ResetElectedClient");
 		} else {
 			// The _electedClient is a summarizer and should not be replaced until it leaves the quorum.
 			// Changing the _electedParent will stop the summarizer.
-			this.tryElectingParent(firstClient, sequenceNumber);
+			this.tryElectingParent(firstClient, sequenceNumber, "ResetElectedClient");
 		}
 	}
 
@@ -571,4 +621,25 @@ export class OrderedClientElection
 			electedParentId: this.electedParent?.clientId,
 		};
 	}
+
+	private sendPerformanceEvent(
+		eventName: string,
+		client: ILinkedClient | undefined,
+		sequenceNumber: number,
+		forceSend: boolean = false,
+		reason?: string,
+	) {
+		if (this.recordPerformanceEvents || forceSend) {
+			this.logger.sendPerformanceEvent({
+				eventName,
+				clientId: client?.clientId,
+				sequenceNumber,
+				electedClientId: this.electedClient?.clientId,
+				electedParentId: this.electedParent?.clientId,
+				isEligible: client !== undefined ? this.isEligibleFn(client) : false,
+				isSummarizerClient: client?.client.details.type === summarizerClientType,
+				reason,
+			});
+		}
+	}
 }

package/src/summary/runningSummarizer.ts

@@ -38,9 +38,11 @@ import {
 	ISummaryCancellationToken,
 	SubmitSummaryResult,
 	SummarizerStopReason,
+	type IRetriableFailureError,
 } from "./summarizerTypes.js";
 import { IAckedSummary, IClientSummaryWatcher, SummaryCollection } from "./summaryCollection.js";
 import {
+	RetriableSummaryError,
 	SummarizeReason,
 	SummarizeResultBuilder,
 	SummaryGenerator,
@@ -474,7 +476,6 @@ export class RunningSummarizer extends TypedEventEmitter<ISummarizerEvents> impl
 				this.trySummarizeOnce(
 					// summarizeProps
 					{ summarizeReason: "lastSummary" },
-					// ISummarizeOptions, using defaults: { refreshLatestAck: false, fullTree: false }
 					{},
 				);
 			}
@@ -627,9 +628,7 @@ export class RunningSummarizer extends TypedEventEmitter<ISummarizerEvents> impl
 				this.beforeSummaryAction();
 			},
 			async () => {
-				return this.mc.config.getBoolean("Fluid.Summarizer.UseDynamicRetries")
-					? this.trySummarizeWithRetries(reason)
-					: this.trySummarizeWithStaticAttempts(reason);
+				return this.trySummarizeWithRetries(reason);
 			},
 			() => {
 				this.afterSummaryAction();
@@ -639,92 +638,6 @@ export class RunningSummarizer extends TypedEventEmitter<ISummarizerEvents> impl
 		});
 	}
 
-	/**
-	 * Tries to summarize 2 times with pre-defined summary options. If an attempt fails with "retryAfterSeconds"
-	 * param, that attempt is tried once more.
-	 */
-	private async trySummarizeWithStaticAttempts(reason: SummarizeReason) {
-		const attemptOptions: ISummarizeOptions[] = [
-			{ refreshLatestAck: false, fullTree: false },
-			{ refreshLatestAck: true, fullTree: false },
-		];
-		let summaryAttempts = 0;
-		let summaryAttemptsPerPhase = 0;
-		let summaryAttemptPhase = 0;
-		let error: any;
-		while (summaryAttemptPhase < attemptOptions.length) {
-			if (this.cancellationToken.cancelled) {
-				return;
-			}
-
-			// We only want to attempt 1 summary when reason is "lastSummary"
-			if (++summaryAttempts > 1 && reason === "lastSummary") {
-				return;
-			}
-
-			summaryAttemptsPerPhase++;
-
-			const summarizeOptions = attemptOptions[summaryAttemptPhase];
-			const summarizeProps: ISummarizeTelemetryProperties = {
-				summarizeReason: reason,
-				summaryAttempts,
-				summaryAttemptsPerPhase,
-				summaryAttemptPhase: summaryAttemptPhase + 1, // make everything 1-based
-				...summarizeOptions,
-			};
-			const summaryLogger = createChildLogger({
-				logger: this.mc.logger,
-				properties: { all: summarizeProps },
-			});
-			const summaryOptions: ISubmitSummaryOptions = {
-				...summarizeOptions,
-				summaryLogger,
-				cancellationToken: this.cancellationToken,
-				latestSummaryRefSeqNum: this.heuristicData.lastSuccessfulSummary.refSequenceNumber,
-			};
-
-			// Note: no need to account for cancellationToken.waitCancelled here, as
-			// this is accounted SummaryGenerator.summarizeCore that controls receivedSummaryAckOrNack.
-			const resultSummarize = this.generator.summarize(summaryOptions);
-			const ackNackResult = await resultSummarize.receivedSummaryAckOrNack;
-			if (ackNackResult.success) {
-				return;
-			}
-
-			error = ackNackResult.error;
-
-			// Check for retryDelay that can come from summaryNack, upload summary or submit summary flows.
-			// Retry the same step only once per retryAfter response.
-			const submitResult = await resultSummarize.summarySubmitted;
-			const delaySeconds = !submitResult.success
-				? submitResult.data?.retryAfterSeconds
-				: ackNackResult.data?.retryAfterSeconds;
-			if (delaySeconds === undefined || summaryAttemptsPerPhase > 1) {
-				summaryAttemptPhase++;
-				summaryAttemptsPerPhase = 0;
-			}
-
-			if (delaySeconds !== undefined) {
-				this.mc.logger.sendPerformanceEvent({
-					eventName: "SummarizeAttemptDelay",
-					duration: delaySeconds,
-					summaryNackDelay: ackNackResult.data?.retryAfterSeconds !== undefined,
-					...summarizeProps,
-				});
-				await delay(delaySeconds * 1000);
-			}
-		}
-		this.mc.logger.sendErrorEvent(
-			{
-				eventName: "SummarizeFailed",
-				maxAttempts: attemptOptions.length,
-				summaryAttempts: summaryAttemptPhase,
-			},
-			error,
-		);
-		this.stopSummarizerCallback("failToSummarize");
-	}
-
 	/**
 	 * Tries to summarize with retries where retry is based on the failure params.
 	 * For example, summarization may be retried for failures with "retryAfterSeconds" param.
@@ -773,7 +686,7 @@ export class RunningSummarizer extends TypedEventEmitter<ISummarizerEvents> impl
 		let done = false;
 		let status: "success" | "failure" | "canceled" = "success";
 		let results: ISummarizeResults | undefined;
-		let error: any;
+		let error: IRetriableFailureError | undefined;
 		do {
 			currentAttempt++;
 			if (this.cancellationToken.cancelled) {
@@ -793,22 +706,18 @@ export class RunningSummarizer extends TypedEventEmitter<ISummarizerEvents> impl
 				break;
 			}
 
-			// Update max attempts and retry params from the failure result.
-			// If submit summary failed, use the params from "summarySubmitted" result. Else, use the params
-			// from "receivedSummaryAckOrNack" result.
+			// Update max attempts from the failure result.
+			// If submit summary failed, use maxAttemptsForSubmitFailures. Else use the defaultMaxAttempts.
 			// Note: Check "summarySubmitted" result first because if it fails, ack nack would fail as well.
 			const submitSummaryResult = await results.summarySubmitted;
-			if (!submitSummaryResult.success) {
-				maxAttempts = this.maxAttemptsForSubmitFailures;
-				retryAfterSeconds = submitSummaryResult.data?.retryAfterSeconds;
-			} else {
-				maxAttempts = defaultMaxAttempts;
-				retryAfterSeconds = ackNackResult.data?.retryAfterSeconds;
-			}
+			maxAttempts = !submitSummaryResult.success
+				? this.maxAttemptsForSubmitFailures
+				: defaultMaxAttempts;
 
 			// Emit "summarize" event for this failed attempt.
 			status = "failure";
 			error = ackNackResult.error;
+			retryAfterSeconds = error.retryAfterSeconds;
 			const eventProps: ISummarizeEventProps = {
 				result: status,
 				currentAttempt,
@@ -817,27 +726,26 @@ export class RunningSummarizer extends TypedEventEmitter<ISummarizerEvents> impl
 			};
 			this.emit("summarize", eventProps);
 
-			// If the failure doesn't have "retryAfterSeconds" or the max number of attempts have been done, we're done.
+			// Break if the failure doesn't have "retryAfterSeconds" or we are one less from max number of attempts.
+			// Note that the final attempt if "retryAfterSeconds" does exist happens outside of the do..while loop.
 			if (retryAfterSeconds === undefined || currentAttempt >= maxAttempts - 1) {
 				done = true;
 			}
 
-			// If the failure has "retryAfterSeconds", add a delay of that time. In this case, a final attempt will
-			// take place and we need to wait for "retryAfterSeconds" before that.
-			if (retryAfterSeconds !== undefined) {
+			// If the failure has "retryAfterSeconds", add a delay of that time before starting the next attempt.
+			if (retryAfterSeconds !== undefined && retryAfterSeconds > 0) {
 				this.mc.logger.sendPerformanceEvent({
 					eventName: "SummarizeAttemptDelay",
-					duration: retryAfterSeconds,
-					summaryNackDelay: ackNackResult.data?.retryAfterSeconds !== undefined,
+					duration: retryAfterSeconds * 1000,
+					summaryNackDelay: ackNackResult.data !== undefined, // This will only be defined only for nack failures.
 					stage: submitSummaryResult.data?.stage,
-					dynamicRetries: true, // To differentiate this telemetry from regular retry logic
 					...attemptResult.summarizeProps,
 				});
 				await delay(retryAfterSeconds * 1000);
 			}
 		} while (!done);
 
-		// If summarize attempt did not fail, emit "summarize" event and return. A failed attempt may be retried below.
+		// If the attempt was successful, emit "summarize" event and return. A failed attempt may be retried below.
 		if (status !== "failure") {
 			this.emit("summarize", { result: status, currentAttempt, maxAttempts });
 			return results;
@@ -888,7 +796,10 @@ export class RunningSummarizer extends TypedEventEmitter<ISummarizerEvents> impl
 	) {
 		const results = await this.trySummarizeWithRetries(reason);
 		if (results === undefined) {
-			resultsBuilder.fail("Summarization was canceled", undefined);
+			resultsBuilder.fail(
+				"Summarization was canceled",
+				new RetriableSummaryError("Summarization was canceled"),
+			);
 			return resultsBuilder.build();
 		}
 		const submitResult = await results.summarySubmitted;
@@ -906,7 +817,10 @@ export class RunningSummarizer extends TypedEventEmitter<ISummarizerEvents> impl
 		resultsBuilder: SummarizeResultBuilder = new SummarizeResultBuilder(),
 	): ISummarizeResults {
 		if (this.stopping) {
-			resultsBuilder.fail("RunningSummarizer stopped or disposed", undefined);
+			resultsBuilder.fail(
+				"RunningSummarizer stopped or disposed",
+				new RetriableSummaryError("RunningSummarizer stopped or disposed"),
+			);
 			return resultsBuilder.build();
 		}
 		// Check for concurrent summary attempts. If one is found,
@@ -944,7 +858,9 @@ export class RunningSummarizer extends TypedEventEmitter<ISummarizerEvents> impl
 			// Override existing enqueued summarize attempt.
 			this.enqueuedSummary.resultsBuilder.fail(
 				"Aborted; overridden by another enqueue summarize attempt",
-				undefined,
+				new RetriableSummaryError(
+					"Summary was overridden by another enqueue summarize attempt",
+				),
 			);
 			this.enqueuedSummary = undefined;
 			overridden = true;
@@ -995,7 +911,7 @@ export class RunningSummarizer extends TypedEventEmitter<ISummarizerEvents> impl
 		if (this.enqueuedSummary !== undefined) {
 			this.enqueuedSummary.resultsBuilder.fail(
 				"RunningSummarizer stopped or disposed",
-				undefined,
+				new RetriableSummaryError("RunningSummarizer stopped or disposed"),
 			);
 			this.enqueuedSummary = undefined;
 		}

package/src/summary/summarizer.ts

@@ -4,7 +4,7 @@
  */
 
 import { TypedEventEmitter } from "@fluid-internal/client-utils";
-import { IFluidHandleContext } from "@fluidframework/core-interfaces";
+import { IFluidHandleContext } from "@fluidframework/core-interfaces/internal";
 import { Deferred } from "@fluidframework/core-utils/internal";
 import {
 	IFluidErrorBase,
@@ -98,7 +98,10 @@ export class Summarizer extends TypedEventEmitter<ISummarizerEvents> implements
 		) => Promise<ICancellableSummarizerController>,
 	) {
 		super();
-		this.logger = createChildLogger({ logger: this.runtime.logger, namespace: "Summarizer" });
+		this.logger = createChildLogger({
+			logger: this.runtime.baseLogger,
+			namespace: "Summarizer",
+		});
 	}
 
 	public async run(onBehalfOf: string): Promise<SummarizerStopReason> {

package/src/summary/summarizerNode/summarizerNode.ts

@@ -13,8 +13,6 @@ import {
 import {
 	IExperimentalIncrementalSummaryContext,
 	ITelemetryContext,
-} from "@fluidframework/runtime-definitions";
-import {
 	CreateChildSummarizerNodeParam,
 	CreateSummarizerNodeSource,
 	ISummarizeResult,

package/src/summary/summarizerNode/summarizerNodeWithGc.ts

@@ -7,10 +7,8 @@ import { ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
 import { assert, LazyPromise } from "@fluidframework/core-utils/internal";
 import {
 	IExperimentalIncrementalSummaryContext,
-	IGarbageCollectionData,
 	ITelemetryContext,
-} from "@fluidframework/runtime-definitions";
-import {
+	IGarbageCollectionData,
 	CreateChildSummarizerNodeParam,
 	IGarbageCollectionDetailsBase,
 	ISummarizeInternalResult,

package/src/summary/summarizerTypes.ts

@@ -4,13 +4,18 @@
  */
 
 import { IDeltaManager, ContainerWarning } from "@fluidframework/container-definitions/internal";
-import { IEvent, IEventProvider, ITelemetryBaseProperties } from "@fluidframework/core-interfaces";
+import {
+	IEvent,
+	IEventProvider,
+	ITelemetryBaseProperties,
+	ITelemetryBaseLogger,
+} from "@fluidframework/core-interfaces";
 import {
 	IDocumentMessage,
 	ISequencedDocumentMessage,
 	ISummaryTree,
 } from "@fluidframework/protocol-definitions";
-import { ISummaryStats } from "@fluidframework/runtime-definitions";
+import { ISummaryStats } from "@fluidframework/runtime-definitions/internal";
 import {
 	ITelemetryLoggerExt,
 	ITelemetryLoggerPropertyBag,
@@ -90,7 +95,7 @@ export interface IConnectableRuntime {
  * @alpha
  */
 export interface ISummarizerRuntime extends IConnectableRuntime {
-	readonly logger: ITelemetryLoggerExt;
+	readonly baseLogger: ITelemetryBaseLogger;
 	/** clientId of parent (non-summarizing) container that owns summarizer container */
 	readonly summarizerClientId: string | undefined;
 	readonly deltaManager: IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>;
@@ -113,13 +118,6 @@ export interface ISummarizerRuntime extends IConnectableRuntime {
 export interface ISummarizeOptions {
 	/** True to generate the full tree with no handle reuse optimizations; defaults to false */
 	readonly fullTree?: boolean;
-	/**
-	 * True to ask the server what the latest summary is first; defaults to false
-	 *
-	 * @deprecated Summarize will not refresh latest snapshot state anymore. Instead it updates the cache and closes.
-	 * It's expected a new summarizer client will be created, likely by the same parent.
-	 */
-	readonly refreshLatestAck?: boolean;
 }
 
 /**
@@ -183,14 +181,22 @@ export interface IGeneratedSummaryStats extends ISummaryStats {
 	readonly summaryNumber: number;
 }
 
+/**
+ * Type for summarization failures that are retriable.
+ * @alpha
+ */
+export interface IRetriableFailureError extends Error {
+	readonly retryAfterSeconds?: number;
+}
+
 /**
  * Base results for all submitSummary attempts.
  * @alpha
  */
 export interface IBaseSummarizeResult {
 	readonly stage: "base";
-	/** Error object related to failed summarize attempt. */
-	readonly error: Error | undefined;
+	/** Retriable error object related to failed summarize attempt. */
+	readonly error: IRetriableFailureError | undefined;
 	/** Reference sequence number as of the generate summary attempt. */
 	readonly referenceSequenceNumber: number;
 	readonly minimumSequenceNumber: number;
@@ -265,19 +271,11 @@ export type SubmitSummaryResult =
  */
 export type SummaryStage = SubmitSummaryResult["stage"] | "unknown";
 
-/**
- * Type for summarization failures that are retriable.
- * @alpha
- */
-export interface IRetriableFailureResult {
-	readonly retryAfterSeconds?: number;
-}
-
 /**
  * The data in summarizer result when submit summary stage fails.
  * @alpha
  */
-export interface SubmitSummaryFailureData extends IRetriableFailureResult {
+export interface SubmitSummaryFailureData {
 	stage: SummaryStage;
 }
 
@@ -300,7 +298,7 @@ export interface IAckSummaryResult {
 /**
  * @alpha
  */
-export interface INackSummaryResult extends IRetriableFailureResult {
+export interface INackSummaryResult {
 	readonly summaryNackOp: ISummaryNackMessage;
 	readonly ackNackDuration: number;
 }
@@ -317,7 +315,7 @@ export type SummarizeResultPart<TSuccess, TFailure = undefined> =
 			success: false;
 			data: TFailure | undefined;
 			message: string;
-			error: any;
+			error: IRetriableFailureError;
 	  };
 
 /**
@@ -535,10 +533,6 @@ type ISummarizeTelemetryRequiredProperties =
 type ISummarizeTelemetryOptionalProperties =
 	/** Number of attempts within the last time window, used for calculating the throttle delay. */
 	| "summaryAttempts"
-	/** Number of attempts within the current phase (currently capped at 2 ) */
-	| "summaryAttemptsPerPhase"
-	/** One-based count of phases we've attempted (used to index into an array of ISummarizeOptions */
-	| "summaryAttemptPhase"
 	/** Summarization may be attempted multiple times. This tells whether this is the final summarization attempt */
 	| "finalAttempt"
 	| keyof ISummarizeOptions;

package/src/summary/summaryFormat.ts

@@ -14,8 +14,11 @@ import {
 	ISnapshotTree,
 	SummaryType,
 } from "@fluidframework/protocol-definitions";
-import { ISummaryTreeWithStats } from "@fluidframework/runtime-definitions";
-import { channelsTreeName, gcTreeKey } from "@fluidframework/runtime-definitions/internal";
+import {
+	ISummaryTreeWithStats,
+	channelsTreeName,
+	gcTreeKey,
+} from "@fluidframework/runtime-definitions/internal";
 
 import { IGCMetadata } from "../gc/index.js";