@fluidframework/container-runtime 2.0.0-dev.4.1.0.148229 → 2.0.0-dev.4.3.0.157531

package/src/opLifecycle/outbox.ts

@@ -15,9 +15,15 @@ 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";
 import { OpSplitter } from "./opSplitter";
 
 export interface IOutboxConfig {
@@ -35,6 +41,21 @@ export interface IOutboxParameters {
 	readonly compressor: OpCompressor;
 	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 {
@@ -74,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")),
 			);
 		}
 
@@ -116,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,
@@ -129,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,
@@ -180,15 +216,17 @@ export class Outbox {
 			this.params.containerContext.submitBatchFn === undefined
 		) {
 			// Nothing to do if the batch is empty or if compression is disabled or not supported, or if we don't need to compress
-			return batch;
+			return this.params.groupingManager.groupBatch(batch);
 		}
 
-		const compressedBatch = this.params.compressor.compressBatch(batch);
+		const compressedBatch = this.params.groupingManager.groupBatch(
+			this.params.compressor.compressBatch(batch),
+		);
 
 		if (this.params.splitter.isBatchChunkingEnabled) {
 			return compressedBatch.contentSizeInBytes <= this.params.splitter.chunkSizeInBytes
 				? compressedBatch
-				: this.params.splitter.splitCompressedBatch(compressedBatch);
+				: this.params.splitter.splitFirstBatchMessage(compressedBatch);
 		}
 
 		if (compressedBatch.contentSizeInBytes >= this.params.config.maxBatchSizeInBytes) {

package/src/opLifecycle/remoteMessageProcessor.ts

@@ -6,12 +6,14 @@
 import { ISequencedDocumentMessage, MessageType } from "@fluidframework/protocol-definitions";
 import { ContainerMessageType, ContainerRuntimeMessage } from "../containerRuntime";
 import { OpDecompressor } from "./opDecompressor";
+import { OpGroupingManager } from "./opGroupingManager";
 import { OpSplitter } from "./opSplitter";
 
 export class RemoteMessageProcessor {
 	constructor(
 		private readonly opSplitter: OpSplitter,
 		private readonly opDecompressor: OpDecompressor,
+		private readonly opGroupingManager: OpGroupingManager,
 	) {}
 
 	public get partialMessages(): ReadonlyMap<string, string[]> {
@@ -22,30 +24,44 @@ export class RemoteMessageProcessor {
 		this.opSplitter.clearPartialChunks(clientId);
 	}
 
-	public process(remoteMessage: ISequencedDocumentMessage): ISequencedDocumentMessage {
-		let message = copy(remoteMessage);
-		message = this.opDecompressor.processMessage(message).message;
-		unpackRuntimeMessage(message);
-
-		const chunkProcessingResult = this.opSplitter.processRemoteMessage(message);
-		message = chunkProcessingResult.message;
-		if (chunkProcessingResult.state !== "Processed") {
-			// If the message is not chunked or if the splitter is still rebuilding the original message,
-			// there is no need to continue processing
-			return message;
-		}
+	public process(remoteMessage: ISequencedDocumentMessage): ISequencedDocumentMessage[] {
+		const result: ISequencedDocumentMessage[] = [];
 
-		const decompressionAfterChunking = this.opDecompressor.processMessage(message);
-		message = decompressionAfterChunking.message;
-		if (decompressionAfterChunking.state === "Skipped") {
-			// After chunking, if the original message was not compressed,
-			// there is no need to continue processing
-			return message;
-		}
+		// Ungroup before processing chunks
+		for (let ungroupedMessage of this.opGroupingManager.ungroupOp(copy(remoteMessage))) {
+			ungroupedMessage = this.opDecompressor.processMessage(ungroupedMessage).message;
+			unpackRuntimeMessage(ungroupedMessage);
 
-		// The message needs to be unpacked after chunking + decompression
-		unpack(message);
-		return message;
+			const chunkProcessingResult = this.opSplitter.processRemoteMessage(ungroupedMessage);
+			ungroupedMessage = chunkProcessingResult.message;
+			if (chunkProcessingResult.state !== "Processed") {
+				// If the message is not chunked or if the splitter is still rebuilding the original message,
+				// there is no need to continue processing
+				result.push(ungroupedMessage);
+				continue;
+			}
+
+			// Ungroup the chunked message before decompressing
+			for (let ungroupedMessageAfterChunking of this.opGroupingManager.ungroupOp(
+				ungroupedMessage,
+			)) {
+				const decompressionAfterChunking = this.opDecompressor.processMessage(
+					ungroupedMessageAfterChunking,
+				);
+				ungroupedMessageAfterChunking = decompressionAfterChunking.message;
+				if (decompressionAfterChunking.state === "Skipped") {
+					// After chunking, if the original message was not compressed,
+					// there is no need to continue processing
+					result.push(ungroupedMessageAfterChunking);
+					continue;
+				}
+
+				// The message needs to be unpacked after chunking + decompression
+				unpack(ungroupedMessageAfterChunking);
+				result.push(ungroupedMessageAfterChunking);
+			}
+		}
+		return result;
 	}
 }
 

package/src/packageVersion.ts

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

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,8 +94,9 @@ export {
 	rootHasIsolatedChannels,
 	WriteFluidDataStoreAttributes,
 	wrapSummaryInChannelsTree,
+	idCompressorBlobName,
 } from "./summaryFormat";
-export { SummarizeReason } from "./summaryGenerator";
+export { getFailMessage, SummarizeReason } from "./summaryGenerator";
 export {
 	IConnectedEvents,
 	IConnectedState,

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,14 @@ export class OrderedClientElection
 			change = true;
 		}
 		if (change) {
+			if (isSummarizerClient) {
+				this.logger.sendTelemetryEvent({
+					eventName: "SummarizerClientElected",
+					electedClientId: this._electedClient?.clientId,
+					electedParentId: this._electedParent?.clientId,
+					electionSequenceNumber: sequenceNumber,
+				});
+			}
 			this.emit("election", client, sequenceNumber, prevClient);
 		}
 	}
@@ -423,6 +431,14 @@ export class OrderedClientElection
 	private tryElectingParent(client: ILinkedClient | undefined, sequenceNumber: number): void {
 		if (this._electedParent !== client) {
 			this._electedParent = client;
+			if (client?.client.details.type === summarizerClientType) {
+				this.logger.sendTelemetryEvent({
+					eventName: "SummarizerParentElected",
+					electedClientId: this._electedClient?.clientId,
+					electedParentId: this._electedParent?.clientId,
+					electionSequenceNumber: sequenceNumber,
+				});
+			}
 			this.emit("election", this._electedClient, sequenceNumber, this._electedClient);
 		}
 	}

package/src/summary/runningSummarizer.ts

@@ -46,6 +46,7 @@ import {
 const maxSummarizeAckWaitTime = 10 * 60 * 1000; // 10 minutes
 
 const defaultNumberSummarizationAttempts = 2; // only up to 2 attempts
+
 /**
  * An instance of RunningSummarizer manages the heuristics for summarizing.
  * Until disposed, the instance of RunningSummarizer can assume that it is
@@ -61,7 +62,6 @@ export class RunningSummarizer implements IDisposable {
 		submitSummaryCallback: (options: ISubmitSummaryOptions) => Promise<SubmitSummaryResult>,
 		refreshLatestSummaryAckCallback: (options: IRefreshSummaryAckOptions) => Promise<void>,
 		heuristicData: ISummarizeHeuristicData,
-		raiseSummarizingError: (errorMessage: string) => void,
 		summaryCollection: SummaryCollection,
 		cancellationToken: ISummaryCancellationToken,
 		stopSummarizerCallback: (reason: SummarizerStopReason) => void,
@@ -74,7 +74,6 @@ export class RunningSummarizer implements IDisposable {
 			submitSummaryCallback,
 			refreshLatestSummaryAckCallback,
 			heuristicData,
-			raiseSummarizingError,
 			summaryCollection,
 			cancellationToken,
 			stopSummarizerCallback,
@@ -146,6 +145,9 @@ export class RunningSummarizer implements IDisposable {
 	private totalSuccessfulAttempts = 0;
 	private initialized = false;
 
+	private readonly deltaManagerListener;
+	private readonly runtimeListener;
+
 	private constructor(
 		baseLogger: ITelemetryLogger,
 		private readonly summaryWatcher: IClientSummaryWatcher,
@@ -157,7 +159,6 @@ export class RunningSummarizer implements IDisposable {
 			options: IRefreshSummaryAckOptions,
 		) => Promise<void>,
 		private readonly heuristicData: ISummarizeHeuristicData,
-		private readonly raiseSummarizingError: (errorMessage: string) => void,
 		private readonly summaryCollection: SummaryCollection,
 		private readonly cancellationToken: ISummaryCancellationToken,
 		private readonly stopSummarizerCallback: (reason: SummarizerStopReason) => void,
@@ -198,13 +199,12 @@ export class RunningSummarizer implements IDisposable {
 		const maxAckWaitTime = Math.min(this.configuration.maxAckWaitTime, maxSummarizeAckWaitTime);
 
 		this.pendingAckTimer = new PromiseTimer(maxAckWaitTime, () => {
-			// pre-0.58 error message: summaryAckWaitTimeout
-			this.raiseSummarizingError("Pending summary ack not received in time");
 			// Note: summarizeCount (from ChildLogger definition) may be 0,
 			// since this code path is hit when RunningSummarizer first starts up,
 			// before this instance has kicked off a new summarize run.
 			this.mc.logger.sendErrorEvent({
 				eventName: "SummaryAckWaitTimeout",
+				message: "Pending summary ack not received in time",
 				maxAckWaitTime,
 				referenceSequenceNumber: this.heuristicData.lastAttempt.refSequenceNumber,
 				summarySequenceNumber: this.heuristicData.lastAttempt.summarySequenceNumber,
@@ -227,7 +227,6 @@ export class RunningSummarizer implements IDisposable {
 			this.pendingAckTimer,
 			this.heuristicData,
 			this.submitSummaryCallback,
-			this.raiseSummarizingError,
 			() => {
 				this.totalSuccessfulAttempts++;
 			},
@@ -235,10 +234,25 @@ export class RunningSummarizer implements IDisposable {
 			this.mc.logger,
 		);
 
-		// Listen for ops
-		this.runtime.deltaManager.on("op", (op) => {
-			this.handleOp(op);
-		});
+		// Listen to deltaManager for non-runtime ops
+		this.deltaManagerListener = (op) => {
+			if (!isRuntimeMessage(op)) {
+				this.handleOp(op, false);
+			}
+		};
+
+		// Listen to runtime for runtime ops
+		this.runtimeListener = (op, runtimeMessage) => {
+			if (runtimeMessage) {
+				this.handleOp(op, true);
+			}
+		};
+
+		// Purpose of listening to deltaManager is for back-compat
+		// Can remove and only listen to runtime once loader version is past 2.0.0-internal.1.2.0 (https://github.com/microsoft/FluidFramework/pull/11832)
+		// Tracked by AB#3883
+		this.runtime.deltaManager.on("op", this.deltaManagerListener);
+		this.runtime.on?.("op", this.runtimeListener);
 	}
 
 	private async handleSummaryAck(): Promise<number> {
@@ -248,67 +262,54 @@ export class RunningSummarizer implements IDisposable {
 		if (lastAck !== undefined) {
 			refSequenceNumber = lastAck.summaryOp.referenceSequenceNumber;
 			const summaryLogger = this.tryGetCorrelatedLogger(refSequenceNumber) ?? this.mc.logger;
-			try {
-				const summaryOpHandle = lastAck.summaryOp.contents.handle;
-				const summaryAckHandle = lastAck.summaryAck.contents.handle;
-				while (this.summarizingLock !== undefined) {
-					summaryLogger.sendTelemetryEvent({
-						eventName: "RefreshAttemptWithSummarizerRunning",
-						referenceSequenceNumber: refSequenceNumber,
+			const summaryOpHandle = lastAck.summaryOp.contents.handle;
+			const summaryAckHandle = lastAck.summaryAck.contents.handle;
+			while (this.summarizingLock !== undefined) {
+				summaryLogger.sendTelemetryEvent({
+					eventName: "RefreshAttemptWithSummarizerRunning",
+					referenceSequenceNumber: refSequenceNumber,
+					proposalHandle: summaryOpHandle,
+					ackHandle: summaryAckHandle,
+				});
+				await this.summarizingLock;
+			}
+
+			// Make sure we block any summarizer from being executed/enqueued while
+			// executing the refreshLatestSummaryAck.
+			// https://dev.azure.com/fluidframework/internal/_workitems/edit/779
+			await this.lockedSummaryAction(
+				() => {},
+				async () =>
+					this.refreshLatestSummaryAckCallback({
 						proposalHandle: summaryOpHandle,
 						ackHandle: summaryAckHandle,
-					});
-					await this.summarizingLock;
-				}
-
-				// Make sure we block any summarizer from being executed/enqueued while
-				// executing the refreshLatestSummaryAck.
-				// https://dev.azure.com/fluidframework/internal/_workitems/edit/779
-				await this.lockedSummaryAction(
-					() => {},
-					async () =>
-						this.refreshLatestSummaryAckCallback({
-							proposalHandle: summaryOpHandle,
-							ackHandle: summaryAckHandle,
-							summaryRefSeq: refSequenceNumber,
-							summaryLogger,
-						}).catch(async (error) => {
-							// If the error is 404, so maybe the fetched version no longer exists on server. We just
-							// ignore this error in that case, as that means we will have another summaryAck for the
-							// latest version with which we will refresh the state. However in case of single commit
-							// summary, we might me missing a summary ack, so in that case we are still fine as the
-							// code in `submitSummary` function in container runtime, will refresh the latest state
-							// by calling `refreshLatestSummaryAckFromServer` and we will be fine.
-							if (
-								isFluidError(error) &&
-								error.errorType === DriverErrorType.fileNotFoundOrAccessDeniedError
-							) {
-								summaryLogger.sendTelemetryEvent(
-									{
-										eventName: "HandleSummaryAckErrorIgnored",
-										referenceSequenceNumber: refSequenceNumber,
-										proposalHandle: summaryOpHandle,
-										ackHandle: summaryAckHandle,
-									},
-									error,
-								);
-							} else {
-								throw error;
-							}
-						}),
-					() => {},
-				);
-			} catch (error) {
-				summaryLogger.sendErrorEvent(
-					{
-						eventName: "HandleLastSummaryAckError",
-						referenceSequenceNumber: refSequenceNumber,
-						handle: lastAck?.summaryOp?.contents?.handle,
-						ackHandle: lastAck?.summaryAck?.contents?.handle,
-					},
-					error,
-				);
-			}
+						summaryRefSeq: refSequenceNumber,
+						summaryLogger,
+					}).catch(async (error) => {
+						// If the error is 404, so maybe the fetched version no longer exists on server. We just
+						// ignore this error in that case, as that means we will have another summaryAck for the
+						// latest version with which we will refresh the state. However in case of single commit
+						// summary, we might me missing a summary ack, so in that case we are still fine as the
+						// code in `submitSummary` function in container runtime, will refresh the latest state
+						// by calling `refreshLatestSummaryAckFromServer` and we will be fine.
+						const isIgnoredError =
+							isFluidError(error) &&
+							error.errorType === DriverErrorType.fileNotFoundOrAccessDeniedError;
+
+						summaryLogger.sendTelemetryEvent(
+							{
+								eventName: isIgnoredError
+									? "HandleSummaryAckErrorIgnored"
+									: "HandleLastSummaryAckError",
+								referenceSequenceNumber: refSequenceNumber,
+								proposalHandle: summaryOpHandle,
+								ackHandle: summaryAckHandle,
+							},
+							error,
+						);
+					}),
+				() => {},
+			);
 			refSequenceNumber++;
 		}
 		return refSequenceNumber;
@@ -345,9 +346,8 @@ export class RunningSummarizer implements IDisposable {
 	}
 
 	public dispose(): void {
-		this.runtime.deltaManager.off("op", (op) => {
-			this.handleOp(op);
-		});
+		this.runtime.deltaManager.off("op", this.deltaManagerListener);
+		this.runtime.off?.("op", this.runtimeListener);
 		this.summaryWatcher.dispose();
 		this.heuristicRunner?.dispose();
 		this.heuristicRunner = undefined;
@@ -372,10 +372,10 @@ export class RunningSummarizer implements IDisposable {
 	/** We only want a single heuristic runner micro-task (will provide better optimized grouping of ops) */
 	private heuristicRunnerMicroTaskExists = false;
 
-	public handleOp(op: ISequencedDocumentMessage) {
+	public handleOp(op: ISequencedDocumentMessage, runtimeMessage: boolean) {
 		this.heuristicData.lastOpSequenceNumber = op.sequenceNumber;
 
-		if (isRuntimeMessage(op)) {
+		if (runtimeMessage) {
 			this.heuristicData.numRuntimeOps++;
 		} else {
 			this.heuristicData.numNonRuntimeOps++;
@@ -386,7 +386,7 @@ export class RunningSummarizer implements IDisposable {
 		// Check for enqueued on-demand summaries; Intentionally do nothing otherwise
 		if (
 			this.initialized &&
-			this.opCanTriggerSummary(op) &&
+			this.opCanTriggerSummary(op, runtimeMessage) &&
 			!this.tryRunEnqueuedSummary() &&
 			!this.heuristicRunnerMicroTaskExists
 		) {
@@ -407,14 +407,14 @@ export class RunningSummarizer implements IDisposable {
 	 * @param op - op to check
 	 * @returns true if this op can trigger a summary
 	 */
-	private opCanTriggerSummary(op: ISequencedDocumentMessage): boolean {
+	private opCanTriggerSummary(op: ISequencedDocumentMessage, runtimeMessage: boolean): boolean {
 		switch (op.type) {
 			case MessageType.Summarize:
 			case MessageType.SummaryAck:
 			case MessageType.SummaryNack:
 				return false;
 			default:
-				return isRuntimeMessage(op) || this.nonRuntimeOpCanTriggerSummary();
+				return runtimeMessage || this.nonRuntimeOpCanTriggerSummary();
 		}
 	}
 
@@ -646,6 +646,7 @@ export class RunningSummarizer implements IDisposable {
 					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.
 					overrideDelaySeconds = result.retryAfterSeconds;

package/src/summary/summarizer.ts

@@ -263,14 +263,6 @@ export class Summarizer extends EventEmitter implements ISummarizer {
 				refSequenceNumber: this.runtime.deltaManager.initialSequenceNumber,
 				summaryTime: Date.now(),
 			} as const),
-			(errorMessage: string) => {
-				if (!this._disposed) {
-					this.logger.sendErrorEvent(
-						{ eventName: "summarizingError" },
-						createSummarizingWarning(errorMessage, true),
-					);
-				}
-			},
 			this.summaryCollection,
 			runCoordinator /* cancellationToken */,
 			(reason) => runCoordinator.stop(reason) /* stopSummarizerCallback */,

package/src/summary/summarizerHeuristics.ts

@@ -26,6 +26,10 @@ export class SummarizeHeuristicData implements ISummarizeHeuristicData {
 		return this._lastSuccessfulSummary;
 	}
 
+	public get opsSinceLastSummary(): number {
+		return this.numSystemOpsBefore + this.numNonSystemOpsBefore;
+	}
+
 	public numNonRuntimeOps: number = 0;
 	public totalOpsSize: number = 0;
 	public hasMissingOpData: boolean = false;

package/src/summary/summarizerNode/summarizerNode.ts

@@ -164,7 +164,7 @@ export class SummarizerNode implements IRootSummarizerNode {
 		// complains if this assert isn't done this way
 		assert(
 			this.wipReferenceSequenceNumber !== undefined,
-			"Summarize should not be called when not tracking the summary",
+			0x5df /* Summarize should not be called when not tracking the summary */,
 		);
 		const incrementalSummaryContext: IExperimentalIncrementalSummaryContext | undefined =
 			this._latestSummary !== undefined

package/src/summary/summarizerNode/summarizerNodeWithGc.ts

@@ -69,7 +69,7 @@ class SummaryNodeWithGC extends SummaryNode {
  * - Adds trackState param to summarize. If trackState is false, it bypasses the SummarizerNode and calls
  * directly into summarizeInternal method.
  */
-class SummarizerNodeWithGC extends SummarizerNode implements IRootSummarizerNodeWithGC {
+export class SummarizerNodeWithGC extends SummarizerNode implements IRootSummarizerNodeWithGC {
 	// Tracks the work-in-progress used routes during summary.
 	private wipSerializedUsedRoutes: string | undefined;
 
@@ -536,8 +536,8 @@ class SummarizerNodeWithGC extends SummarizerNode implements IRootSummarizerNode
 						JSON.stringify(newSerializedRoutes),
 						{
 							referenceSequenceNumber: value.referenceSequenceNumber,
-							basePath: value.basePath,
-							localPath: value.localPath,
+							basePath: child.latestSummary.basePath,
+							localPath: child.latestSummary.localPath,
 						},
 					);
 					child.addPendingSummary(key, newLatestSummaryNode);