@fluidframework/container-runtime 2.0.0-internal.6.1.1 → 2.0.0-internal.6.3.0

package/src/summary/runningSummarizer.ts

@@ -9,10 +9,11 @@ import {
 	MonitoringContext,
 	createChildMonitoringContext,
 	createChildLogger,
+	UsageError,
 } 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 { assert, delay, Deferred, PromiseTimer } from "@fluidframework/core-utils";
+import { TypedEventEmitter } from "@fluid-internal/client-utils";
+import { DriverErrorTypes } from "@fluidframework/driver-definitions";
 import { ISequencedDocumentMessage, MessageType } from "@fluidframework/protocol-definitions";
 import { ISummaryConfiguration } from "../containerRuntime";
 import { opSize } from "../opProperties";
@@ -33,6 +34,8 @@ import {
 	ISummarizerRuntime,
 	ISummarizeRunnerTelemetry,
 	IRefreshSummaryAckOptions,
+	ISummarizerEvents,
+	ISummarizeEventProps,
 } from "./summarizerTypes";
 import { IAckedSummary, IClientSummaryWatcher, SummaryCollection } from "./summaryCollection";
 import {
@@ -44,6 +47,17 @@ import {
 
 const maxSummarizeAckWaitTime = 10 * 60 * 1000; // 10 minutes
 
+/**
+ * The maximum number of summarization attempts that will be done by default in case of failures
+ * that can be retried.
+ */
+export const defaultMaxAttempts = 2;
+/**
+ * The default value for maximum number of summarization attempts that will be done for summarization failures where
+ * submit fails and the failure can be retried.
+ */
+export const defaultMaxAttemptsForSubmitFailures = 5;
+
 /**
  * An instance of RunningSummarizer manages the heuristics for summarizing.
  * Until disposed, the instance of RunningSummarizer can assume that it is
@@ -51,7 +65,7 @@ const maxSummarizeAckWaitTime = 10 * 60 * 1000; // 10 minutes
  * track of summaries that it is generating as they are broadcast and acked/nacked.
  * This object is created and controlled by Summarizer object.
  */
-export class RunningSummarizer implements IDisposable {
+export class RunningSummarizer extends TypedEventEmitter<ISummarizerEvents> implements IDisposable {
 	public static async start(
 		logger: ITelemetryBaseLogger,
 		summaryWatcher: IClientSummaryWatcher,
@@ -137,7 +151,7 @@ export class RunningSummarizer implements IDisposable {
 		| {
 				reason: SummarizeReason;
 				afterSequenceNumber: number;
-				options: ISummarizeOptions;
+				summarizeOptions: ISummarizeOptions;
 				readonly resultsBuilder: SummarizeResultBuilder;
 		  }
 		| undefined;
@@ -147,6 +161,9 @@ export class RunningSummarizer implements IDisposable {
 
 	private readonly runtimeListener;
 
+	/** The maximum number of summary attempts to do when submit summary fails. */
+	private readonly maxAttemptsForSubmitFailures: number;
+
 	private constructor(
 		baseLogger: ITelemetryBaseLogger,
 		private readonly summaryWatcher: IClientSummaryWatcher,
@@ -163,6 +180,8 @@ export class RunningSummarizer implements IDisposable {
 		private readonly stopSummarizerCallback: (reason: SummarizerStopReason) => void,
 		private readonly runtime: ISummarizerRuntime,
 	) {
+		super();
+
 		const telemetryProps: ISummarizeRunnerTelemetry = {
 			summarizeCount: () => this.summarizeCount,
 			summarizerSuccessfulAttempts: () => this.totalSuccessfulAttempts,
@@ -240,6 +259,17 @@ export class RunningSummarizer implements IDisposable {
 			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.
+		const overrideMaxAttempts = this.mc.config.getNumber(
+			"Fluid.Summarizer.AttemptsForSubmitFailures",
+		);
+		this.maxAttemptsForSubmitFailures =
+			overrideMaxAttempts && overrideMaxAttempts < defaultMaxAttemptsForSubmitFailures
+				? overrideMaxAttempts
+				: defaultMaxAttemptsForSubmitFailures;
 	}
 
 	private async handleSummaryAck(): Promise<number> {
@@ -281,7 +311,7 @@ export class RunningSummarizer implements IDisposable {
 						// by calling `refreshLatestSummaryAckFromServer` and we will be fine.
 						const isIgnoredError =
 							isFluidError(error) &&
-							error.errorType === DriverErrorType.fileNotFoundOrAccessDeniedError;
+							error.errorType === DriverErrorTypes.fileNotFoundOrAccessDeniedError;
 
 						summaryLogger.sendTelemetryEvent(
 							{
@@ -429,7 +459,7 @@ export class RunningSummarizer implements IDisposable {
 			if (this.summarizingLock === undefined) {
 				this.trySummarizeOnce(
 					// summarizeProps
-					{ reason: "lastSummary" },
+					{ summarizeReason: "lastSummary" },
 					// ISummarizeOptions, using defaults: { refreshLatestAck: false, fullTree: false }
 					{},
 				);
@@ -524,7 +554,6 @@ export class RunningSummarizer implements IDisposable {
 	private trySummarizeOnce(
 		summarizeProps: ISummarizeTelemetryProperties,
 		options: ISummarizeOptions,
-		cancellationToken = this.cancellationToken,
 		resultsBuilder = new SummarizeResultBuilder(),
 	): ISummarizeResults {
 		this.lockedSummaryAction(
@@ -532,12 +561,16 @@ export class RunningSummarizer implements IDisposable {
 				this.beforeSummaryAction();
 			},
 			async () => {
-				const summarizeResult = this.generator.summarize(
-					summarizeProps,
-					options,
-					cancellationToken,
-					resultsBuilder,
-				);
+				const summaryLogger = createChildLogger({
+					logger: this.mc.logger,
+					properties: { all: summarizeProps },
+				});
+				const summaryOptions: ISubmitSummaryOptions = {
+					...options,
+					summaryLogger,
+					cancellationToken: this.cancellationToken,
+				};
+				const summarizeResult = this.generator.summarize(summaryOptions, resultsBuilder);
 				// ensure we wait till the end of the process
 				return summarizeResult.receivedSummaryAckOrNack;
 			},
@@ -555,10 +588,7 @@ export class RunningSummarizer implements IDisposable {
 	}
 
 	/** Heuristics summarize attempt. */
-	private trySummarize(
-		reason: SummarizeReason,
-		cancellationToken = this.cancellationToken,
-	): void {
+	private trySummarize(reason: SummarizeReason): void {
 		if (this.summarizingLock !== undefined) {
 			// lockedSummaryAction() will retry heuristic-based summary at the end of current attempt
 			// if it's still needed
@@ -571,68 +601,9 @@ export class RunningSummarizer implements IDisposable {
 				this.beforeSummaryAction();
 			},
 			async () => {
-				const attempts: ISummarizeOptions[] = [
-					{ refreshLatestAck: false, fullTree: false },
-					{ refreshLatestAck: true, fullTree: false },
-				];
-				let overrideDelaySeconds: number | undefined;
-				let summaryAttempts = 0;
-				let summaryAttemptsPerPhase = 0;
-				let summaryAttemptPhase = 0;
-				while (summaryAttemptPhase < attempts.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 = attempts[summaryAttemptPhase];
-					const summarizeProps: ISummarizeTelemetryProperties = {
-						reason,
-						summaryAttempts,
-						summaryAttemptsPerPhase,
-						summaryAttemptPhase: summaryAttemptPhase + 1, // make everything 1-based
-						...summarizeOptions,
-					};
-
-					// Note: no need to account for cancellationToken.waitCancelled here, as
-					// this is accounted SummaryGenerator.summarizeCore that controls receivedSummaryAckOrNack.
-					const resultSummarize = this.generator.summarize(
-						summarizeProps,
-						summarizeOptions,
-						cancellationToken,
-					);
-					const result = await resultSummarize.receivedSummaryAckOrNack;
-
-					if (result.success) {
-						return;
-					}
-
-					// Check for retryDelay that can come from summaryNack or upload summary flow.
-					// Retry the same step only once per retryAfter response.
-					const delaySeconds = result.retryAfterSeconds;
-					if (delaySeconds === undefined || summaryAttemptsPerPhase > 1) {
-						summaryAttemptPhase++;
-						summaryAttemptsPerPhase = 0;
-					}
-
-					if (delaySeconds !== undefined) {
-						this.mc.logger.sendPerformanceEvent({
-							eventName: "SummarizeAttemptDelay",
-							duration: delaySeconds,
-							summaryNackDelay: overrideDelaySeconds !== undefined,
-							...summarizeProps,
-						});
-						await delay(delaySeconds * 1000);
-					}
-				}
-
-				this.stopSummarizerCallback("failToSummarize");
+				return this.mc.config.getBoolean("Fluid.Summarizer.UseDynamicRetries")
+					? this.trySummarizeWithRetries(reason)
+					: this.trySummarizeWithStaticAttempts(reason);
 			},
 			() => {
 				this.afterSummaryAction();
@@ -642,10 +613,220 @@ export class RunningSummarizer implements IDisposable {
 		});
 	}
 
+	/**
+	 * 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;
+		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,
+			};
+
+			// 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;
+			}
+
+			// 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.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.
+	 */
+	private async trySummarizeWithRetries(reason: SummarizeReason) {
+		// Helper to set summarize options, telemetry properties and call summarize.
+		const attemptSummarize = (attemptNumber: number, finalAttempt: boolean) => {
+			const summarizeOptions: ISummarizeOptions = {
+				fullTree: false,
+			};
+			const summarizeProps: ISummarizeTelemetryProperties = {
+				summarizeReason: reason,
+				summaryAttempts: attemptNumber,
+				...summarizeOptions,
+				finalAttempt,
+			};
+			const summaryLogger = createChildLogger({
+				logger: this.mc.logger,
+				properties: { all: summarizeProps },
+			});
+			const summaryOptions: ISubmitSummaryOptions = {
+				...summarizeOptions,
+				summaryLogger,
+				cancellationToken: this.cancellationToken,
+				finalAttempt,
+			};
+			const summarizeResult = this.generator.summarize(summaryOptions);
+			return { summarizeProps, summarizeResult };
+		};
+
+		// The max number of attempts are based on the stage at which summarization failed. If it fails before it is
+		// submitted, a different value is used compared to if it fails after submission. Usually, in the former case,
+		// we would retry more often as its cheaper and retries are likely to succeed.
+		// This makes it harder to predict how many attempts would actually happen as that depends on how far an attempt
+		// made. To keep things simple, the max attempts is reset after every attempt based on where it failed. This may
+		// result in some failures not being retried depending on what happened before this attempt. That's fine because
+		// such scenarios are very unlikely and even if it happens, it would resolve when a new summarizer starts over.
+		// For example - When failure switches from one the submit failures to nack failure, only one more retry will
+		// happen irrespective of the value of `defaultMaxAttempts`.
+		let maxAttempts = defaultMaxAttempts;
+		let currentAttempt = 0;
+		let retryAfterSeconds: number | undefined;
+		let done = false;
+		let result: "success" | "failure" | "canceled" = "success";
+		do {
+			currentAttempt++;
+			if (this.cancellationToken.cancelled) {
+				result = "canceled";
+				done = true;
+				break;
+			}
+
+			const { summarizeProps, summarizeResult } = attemptSummarize(
+				currentAttempt,
+				false /* finalAttempt */,
+			);
+
+			// Ack / nack is the final step, so if it succeeds we're done.
+			const ackNackResult = await summarizeResult.receivedSummaryAckOrNack;
+			if (ackNackResult.success) {
+				result = "success";
+				done = true;
+				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.
+			// Note: Check "summarySubmitted" result first because if it fails, ack nack would fail as well.
+			const submitSummaryResult = await summarizeResult.summarySubmitted;
+			if (!submitSummaryResult.success) {
+				maxAttempts = this.maxAttemptsForSubmitFailures;
+				retryAfterSeconds = submitSummaryResult.data?.retryAfterSeconds;
+			} else {
+				maxAttempts = defaultMaxAttempts;
+				retryAfterSeconds = ackNackResult.data?.retryAfterSeconds;
+			}
+
+			// Emit "summarize" event for this failed attempt.
+			result = "failure";
+			const eventProps: ISummarizeEventProps = {
+				result,
+				currentAttempt,
+				maxAttempts,
+				error: ackNackResult.error,
+			};
+			this.emit("summarize", eventProps);
+
+			// If the failure doesn't have "retryAfterSeconds" or the max number of attempts have been done, we're done.
+			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) {
+				this.mc.logger.sendPerformanceEvent({
+					eventName: "SummarizeAttemptDelay",
+					duration: retryAfterSeconds,
+					summaryNackDelay: ackNackResult.data?.retryAfterSeconds !== undefined,
+					stage: submitSummaryResult.data?.stage,
+					dynamicRetries: true, // To differentiate this telemetry from regular retry logic
+					...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 (result !== "failure") {
+			this.emit("summarize", { result, currentAttempt, maxAttempts });
+			return;
+		}
+
+		// If summarization wasn't successful above and the failure contains "retryAfterSeconds", perform one last
+		// attempt. This gives a chance to the runtime to perform additional steps in the last attempt.
+		if (retryAfterSeconds !== undefined) {
+			const { summarizeResult } = attemptSummarize(++currentAttempt, true /* finalAttempt */);
+			// Ack / nack is the final step, so if it succeeds we're done.
+			const ackNackResult = await summarizeResult.receivedSummaryAckOrNack;
+			result = ackNackResult.success ? "success" : "failure";
+			const eventProps: ISummarizeEventProps = {
+				result,
+				currentAttempt,
+				maxAttempts,
+				error: ackNackResult.success ? undefined : ackNackResult.error,
+			};
+			this.emit("summarize", eventProps);
+		}
+
+		// If summarization is still unsuccessful, stop the summarizer.
+		if (result === "failure") {
+			this.stopSummarizerCallback("failToSummarize");
+		}
+	}
+
 	/** {@inheritdoc (ISummarizer:interface).summarizeOnDemand} */
 	public summarizeOnDemand(
+		options: IOnDemandSummarizeOptions,
 		resultsBuilder: SummarizeResultBuilder = new SummarizeResultBuilder(),
-		{ reason, ...options }: IOnDemandSummarizeOptions,
 	): ISummarizeResults {
 		if (this.stopping) {
 			resultsBuilder.fail("RunningSummarizer stopped or disposed", undefined);
@@ -658,23 +839,18 @@ export class RunningSummarizer implements IDisposable {
 			throw new UsageError("Attempted to run an already-running summarizer on demand");
 		}
 
+		const { reason, ...summarizeOptions } = options;
 		const result = this.trySummarizeOnce(
-			{ reason: `onDemand/${reason}` },
-			options,
-			this.cancellationToken,
+			{ summarizeReason: `onDemand/${reason}` },
+			summarizeOptions,
 			resultsBuilder,
 		);
 		return result;
 	}
 
 	/** {@inheritdoc (ISummarizer:interface).enqueueSummarize} */
-	public enqueueSummarize({
-		reason,
-		afterSequenceNumber = 0,
-		override = false,
-		...options
-	}: IEnqueueSummarizeOptions): EnqueueSummarizeResult {
-		const onDemandReason = `enqueue;${reason}` as const;
+	public enqueueSummarize(options: IEnqueueSummarizeOptions): EnqueueSummarizeResult {
+		const { reason, afterSequenceNumber = 0, override = false, ...summarizeOptions } = options;
 		let overridden = false;
 		if (this.enqueuedSummary !== undefined) {
 			if (!override) {
@@ -688,10 +864,11 @@ export class RunningSummarizer implements IDisposable {
 			this.enqueuedSummary = undefined;
 			overridden = true;
 		}
+
 		this.enqueuedSummary = {
-			reason: onDemandReason,
+			reason: `enqueue;${reason}`,
 			afterSequenceNumber,
-			options,
+			summarizeOptions,
 			resultsBuilder: new SummarizeResultBuilder(),
 		};
 		const results = this.enqueuedSummary.resultsBuilder.build();
@@ -718,13 +895,12 @@ export class RunningSummarizer implements IDisposable {
 			// If no enqueued summary is ready or a summary is already in progress, take no action.
 			return false;
 		}
-		const { reason, resultsBuilder, options } = this.enqueuedSummary;
+		const { reason, resultsBuilder, summarizeOptions } = this.enqueuedSummary;
 		// Set to undefined first, so that subsequent enqueue attempt while summarize will occur later.
 		this.enqueuedSummary = undefined;
 		this.trySummarizeOnce(
-			{ reason: `enqueuedSummary/${reason}` },
-			options,
-			this.cancellationToken,
+			{ summarizeReason: `enqueuedSummary/${reason}` },
+			summarizeOptions,
 			resultsBuilder,
 		);
 		return true;

package/src/summary/summarizer.ts

@@ -3,17 +3,17 @@
  * Licensed under the MIT License.
  */
 
-import { EventEmitter } from "events";
-import { Deferred } from "@fluidframework/common-utils";
+import { Deferred } from "@fluidframework/core-utils";
+import { TypedEventEmitter } from "@fluid-internal/client-utils";
 import {
 	ITelemetryLoggerExt,
 	createChildLogger,
 	IFluidErrorBase,
 	LoggingError,
+	UsageError,
 	wrapErrorAndLog,
 } from "@fluidframework/telemetry-utils";
 import { ILoader, LoaderHeader } from "@fluidframework/container-definitions";
-import { UsageError } from "@fluidframework/container-utils";
 import { DriverHeader } from "@fluidframework/driver-definitions";
 import { requestFluidObject } from "@fluidframework/runtime-utils";
 import { FluidObject, IFluidHandleContext, IRequest } from "@fluidframework/core-interfaces";
@@ -30,6 +30,12 @@ import {
 	ISummarizerRuntime,
 	ISummarizingWarning,
 	SummarizerStopReason,
+	IOnDemandSummarizeOptions,
+	ISummarizeResults,
+	IEnqueueSummarizeOptions,
+	EnqueueSummarizeResult,
+	ISummarizerEvents,
+	ISummarizeEventProps,
 } from "./summarizerTypes";
 import { SummarizeHeuristicData } from "./summarizerHeuristics";
 import { SummarizeResultBuilder } from "./summaryGenerator";
@@ -61,7 +67,7 @@ export const createSummarizingWarning = (errorMessage: string, logged: boolean)
  * It is the main entry point for summary work.
  * It is created only by summarizing container (i.e. one with clientType === "summarizer")
  */
-export class Summarizer extends EventEmitter implements ISummarizer {
+export class Summarizer extends TypedEventEmitter<ISummarizerEvents> implements ISummarizer {
 	public get ISummarizer() {
 		return this;
 	}
@@ -277,11 +283,15 @@ export class Summarizer extends EventEmitter implements ISummarizer {
 			this.runtime,
 		);
 		this.runningSummarizer = runningSummarizer;
+		this.runningSummarizer.on("summarize", this.handleSummarizeEvent);
 		this.starting = false;
-
 		return runningSummarizer;
 	}
 
+	private readonly handleSummarizeEvent = (eventProps: ISummarizeEventProps) => {
+		this.emit("summarize", eventProps);
+	};
+
 	/**
 	 * Disposes of resources after running.  This cleanup will
 	 * clear any outstanding timers and reset some of the state
@@ -294,12 +304,13 @@ export class Summarizer extends EventEmitter implements ISummarizer {
 
 		this._disposed = true;
 		if (this.runningSummarizer) {
+			this.runningSummarizer.off("summarize", this.handleSummarizeEvent);
 			this.runningSummarizer.dispose();
 			this.runningSummarizer = undefined;
 		}
 	}
 
-	public readonly summarizeOnDemand: ISummarizer["summarizeOnDemand"] = (...args) => {
+	public summarizeOnDemand(options: IOnDemandSummarizeOptions): ISummarizeResults {
 		try {
 			if (this._disposed || this.runningSummarizer?.disposed) {
 				throw new UsageError("Summarizer is already disposed.");
@@ -318,7 +329,7 @@ export class Summarizer extends EventEmitter implements ISummarizer {
 			const builder = new SummarizeResultBuilder();
 			if (this.runningSummarizer) {
 				// Summarizer is already running. Go ahead and start.
-				return this.runningSummarizer.summarizeOnDemand(builder, ...args);
+				return this.runningSummarizer.summarizeOnDemand(options, builder);
 			}
 
 			// Summarizer isn't running, so we need to start it, which is an async operation.
@@ -335,7 +346,7 @@ export class Summarizer extends EventEmitter implements ISummarizer {
 					startP
 						.then(async (runningSummarizer) => {
 							// Successfully started the summarizer. Run it.
-							runningSummarizer.summarizeOnDemand(builder, ...args);
+							runningSummarizer.summarizeOnDemand(options, builder);
 							// Wait for a command to stop or loss of connectivity before tearing down the summarizer and client.
 							const stopReason = await Promise.race([
 								this.stopDeferred.promise,
@@ -357,9 +368,9 @@ export class Summarizer extends EventEmitter implements ISummarizer {
 		} catch (error) {
 			throw SummarizingWarning.wrap(error, false /* logged */, this.logger);
 		}
-	};
+	}
 
-	public readonly enqueueSummarize: ISummarizer["enqueueSummarize"] = (...args) => {
+	public enqueueSummarize(options: IEnqueueSummarizeOptions): EnqueueSummarizeResult {
 		if (
 			this._disposed ||
 			this.runningSummarizer === undefined ||
@@ -367,8 +378,8 @@ export class Summarizer extends EventEmitter implements ISummarizer {
 		) {
 			throw new UsageError("Summarizer is not running or already disposed.");
 		}
-		return this.runningSummarizer.enqueueSummarize(...args);
-	};
+		return this.runningSummarizer.enqueueSummarize(options);
+	}
 
 	public recordSummaryAttempt?(summaryRefSeqNum?: number) {
 		this._heuristicData?.recordAttempt(summaryRefSeqNum);

package/src/summary/summarizerClientElection.ts

@@ -3,9 +3,9 @@
  * Licensed under the MIT License.
  */
 
-import { IEvent, IEventProvider } from "@fluidframework/common-definitions";
+import { IEvent, IEventProvider } from "@fluidframework/core-interfaces";
 import { ITelemetryLoggerExt } from "@fluidframework/telemetry-utils";
-import { TypedEventEmitter } from "@fluidframework/common-utils";
+import { TypedEventEmitter } from "@fluid-internal/client-utils";
 import { IClientDetails, MessageType } from "@fluidframework/protocol-definitions";
 import {
 	IOrderedClientElection,

package/src/summary/summarizerHeuristics.ts

@@ -4,7 +4,7 @@
  */
 
 import { ITelemetryLoggerExt } from "@fluidframework/telemetry-utils";
-import { Timer } from "@fluidframework/common-utils";
+import { Timer } from "@fluidframework/core-utils";
 import { ISummaryConfigurationHeuristics } from "../containerRuntime";
 import {
 	ISummarizeHeuristicData,

package/src/summary/summarizerNode/index.ts

@@ -4,9 +4,8 @@
  */
 
 export {
-	IFetchSnapshotResult,
+	IRefreshSummaryResult,
 	ISummarizerNodeRootContract,
-	RefreshSummaryResult,
 	ValidateSummaryResult,
 } from "./summarizerNodeUtils";
 export { IRootSummarizerNode, createRootSummarizerNode } from "./summarizerNode";