@fluidframework/container-runtime 2.0.0-dev.5.3.2.178189 → 2.0.0-dev.6.4.0.191457

package/src/summary/summarizerNode/summarizerNodeWithGc.ts

@@ -7,13 +7,11 @@ import {
 	ITelemetryLoggerExt,
 	LoggingError,
 	TelemetryDataTag,
+	tagCodeArtifacts,
 } from "@fluidframework/telemetry-utils";
-import { assert } from "@fluidframework/common-utils";
-import { LazyPromise } from "@fluidframework/core-utils";
-import { ISnapshotTree } from "@fluidframework/protocol-definitions";
+import { assert, LazyPromise } from "@fluidframework/core-utils";
 import {
 	CreateChildSummarizerNodeParam,
-	gcTreeKey,
 	IGarbageCollectionData,
 	IGarbageCollectionDetailsBase,
 	ISummarizeInternalResult,
@@ -24,20 +22,15 @@ import {
 	ITelemetryContext,
 	IExperimentalIncrementalSummaryContext,
 } from "@fluidframework/runtime-definitions";
-import { ReadAndParseBlob, unpackChildNodesUsedRoutes } from "@fluidframework/runtime-utils";
-import {
-	cloneGCData,
-	getGCDataFromSnapshot,
-	runGarbageCollection,
-	unpackChildNodesGCDetails,
-} from "../../gc";
+import { unpackChildNodesUsedRoutes } from "@fluidframework/runtime-utils";
+import { ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
+import { cloneGCData, unpackChildNodesGCDetails } from "../../gc";
 import { SummarizerNode } from "./summarizerNode";
 import {
 	EscapedPath,
 	ICreateChildDetails,
 	IInitialSummary,
 	ISummarizerNodeRootContract,
-	parseSummaryForSubtrees,
 	SummaryNode,
 	ValidateSummaryResult,
 } from "./summarizerNodeUtils";
@@ -107,7 +100,7 @@ export class SummarizerNodeWithGC extends SummarizerNode implements IRootSummari
 	 * Use createRootSummarizerNodeWithGC to create root node, or createChild to create child nodes.
 	 */
 	public constructor(
-		logger: ITelemetryLoggerExt,
+		logger: ITelemetryBaseLogger,
 		private readonly summarizeFn: (
 			fullTree: boolean,
 			trackState: boolean,
@@ -119,7 +112,7 @@ export class SummarizerNodeWithGC extends SummarizerNode implements IRootSummari
 		/** Undefined means created without summary */
 		latestSummary?: SummaryNode,
 		initialSummary?: IInitialSummary,
-		wipSummaryLogger?: ITelemetryLoggerExt,
+		wipSummaryLogger?: ITelemetryBaseLogger,
 		private readonly getGCDataFn?: (fullGC?: boolean) => Promise<IGarbageCollectionData>,
 		getBaseGCDetailsFn?: () => Promise<IGarbageCollectionDetailsBase>,
 		/** A unique id of this node to be logged when sending telemetry. */
@@ -370,10 +363,9 @@ export class SummarizerNodeWithGC extends SummarizerNode implements IRootSummari
 					const error = new LoggingError("MissingGCStateInPendingSummary", {
 						proposalHandle,
 						referenceSequenceNumber,
-						id: {
-							tag: TelemetryDataTag.CodeArtifact,
-							value: this.telemetryNodeId,
-						},
+						...tagCodeArtifacts({
+							id: this.telemetryNodeId,
+						}),
 					});
 					this.logger.sendErrorEvent(
 						{
@@ -390,117 +382,6 @@ export class SummarizerNodeWithGC extends SummarizerNode implements IRootSummari
 		return super.refreshLatestSummaryFromPending(proposalHandle, referenceSequenceNumber);
 	}
 
-	/**
-	 * Called when we need to upload the reference state from the given summary.
-	 */
-	protected async refreshLatestSummaryFromSnapshot(
-		referenceSequenceNumber: number,
-		snapshotTree: ISnapshotTree,
-		basePath: EscapedPath | undefined,
-		localPath: EscapedPath,
-		correlatedSummaryLogger: ITelemetryLoggerExt,
-		readAndParseBlob: ReadAndParseBlob,
-	): Promise<void> {
-		await this.refreshGCStateFromSnapshot(
-			referenceSequenceNumber,
-			snapshotTree,
-			readAndParseBlob,
-		);
-		return super.refreshLatestSummaryFromSnapshot(
-			referenceSequenceNumber,
-			snapshotTree,
-			basePath,
-			localPath,
-			correlatedSummaryLogger,
-			readAndParseBlob,
-		);
-	}
-
-	/**
-	 * Updates GC state from the given snapshot if GC is enabled and the snapshot is newer than the one this node
-	 * is tracking.
-	 */
-	private async refreshGCStateFromSnapshot(
-		referenceSequenceNumber: number,
-		snapshotTree: ISnapshotTree,
-		readAndParseBlob: ReadAndParseBlob,
-	): Promise<void> {
-		// If GC is disabled or we have seen a newer summary, skip updating GC state.
-		if (this.gcDisabled || this.referenceSequenceNumber >= referenceSequenceNumber) {
-			return;
-		}
-
-		// Load the base GC details before proceeding because if that happens later it can overwrite the GC details
-		// written by the following code.
-		await this.loadBaseGCDetails();
-
-		// Possible re-entrancy. We may already have processed this while loading base GC details.
-		if (this.referenceSequenceNumber >= referenceSequenceNumber) {
-			return;
-		}
-
-		/**
-		 * GC data is written at root of the snapshot tree under "gc" sub-tree. This data needs to be propagated to
-		 * all the nodes in the container.
-		 * The root summarizer node reads the GC data from the "gc" sub-tree, runs GC on it to get used routes in
-		 * the container and updates its GC data and referenced used routes. It then gets the GC data and used
-		 * routes of all its children and adds it to their snapshot tree.
-		 * All the other nodes gets the GC data and used routes from their snapshot tree and updates their state.
-		 * They get the GC data and used routes of their children and add it to their snapshot tree and so on.
-		 *
-		 * Note that if the snapshot does not have GC tree, GC data will be set to undefined and used routes will be
-		 * set to self-route (meaning referenced) for all nodes. This is important because the GC data needs to be
-		 * regenerated in the next summary.
-		 */
-		let gcDetails: IGarbageCollectionDetailsBase | undefined;
-		const gcSnapshotTree = snapshotTree.trees[gcTreeKey];
-		if (gcSnapshotTree !== undefined) {
-			// If there is a GC tree in the snapshot, this is the root summarizer node. Read GC data from the tree
-			// process it as explained above.
-			const gcSnapshotData = await getGCDataFromSnapshot(gcSnapshotTree, readAndParseBlob);
-
-			if (gcSnapshotData.gcState !== undefined) {
-				const gcNodes: { [id: string]: string[] } = {};
-				for (const [nodeId, nodeData] of Object.entries(gcSnapshotData.gcState.gcNodes)) {
-					gcNodes[nodeId] = Array.from(nodeData.outboundRoutes);
-				}
-				// Run GC on the nodes in the snapshot to get the used routes for each node in the container.
-				const usedRoutes = runGarbageCollection(gcNodes, ["/"]).referencedNodeIds;
-				gcDetails = { gcData: { gcNodes }, usedRoutes };
-			}
-		} else {
-			// If there is a GC blob in the snapshot, it's a non-root summarizer nodes - The root summarizer node
-			// writes GC blob in the snapshot of child nodes. Get  GC data and used routes from the blob.
-			const gcDetailsBlob = snapshotTree.blobs[gcTreeKey];
-			if (gcDetailsBlob !== undefined) {
-				gcDetails = JSON.parse(gcDetailsBlob) as IGarbageCollectionDetailsBase;
-			}
-		}
-
-		// Update this node to the same GC state it was when the ack corresponding to this summary was processed.
-		this.gcData = gcDetails?.gcData !== undefined ? cloneGCData(gcDetails.gcData) : undefined;
-		this.referenceUsedRoutes =
-			gcDetails?.usedRoutes !== undefined ? Array.from(gcDetails.usedRoutes) : undefined;
-		// If there are no used routes in the GC details, set it to have self route which will make the node
-		// referenced. This scenario can only happen if the snapshot is from a client where GC was not run or
-		// disabled. In both the cases, the node should be referenced.
-		this.usedRoutes =
-			gcDetails?.usedRoutes !== undefined ? Array.from(gcDetails.usedRoutes) : [""];
-
-		if (gcDetails === undefined) {
-			return;
-		}
-
-		// Generate the GC data and used routes of children GC nodes and add it to their snapshot tree.
-		const gcDetailsMap = unpackChildNodesGCDetails(gcDetails);
-		const { childrenTree } = parseSummaryForSubtrees(snapshotTree);
-		gcDetailsMap.forEach((childGCDetails: IGarbageCollectionDetailsBase, childId: string) => {
-			if (childrenTree.trees[childId] !== undefined) {
-				childrenTree.trees[childId].blobs[gcTreeKey] = JSON.stringify(childGCDetails);
-			}
-		});
-	}
-
 	/**
 	 * Override the createChild method to return an instance of SummarizerNodeWithGC.
 	 */
@@ -666,7 +547,7 @@ export class SummarizerNodeWithGC extends SummarizerNode implements IRootSummari
  * @param baseGCDetailsP - Function to get the initial GC details of this node
  */
 export const createRootSummarizerNodeWithGC = (
-	logger: ITelemetryLoggerExt,
+	logger: ITelemetryBaseLogger,
 	summarizeInternalFn: SummarizeInternalFn,
 	changeSequenceNumber: number,
 	referenceSequenceNumber: number | undefined,

package/src/summary/summarizerTypes.ts

@@ -3,8 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { IEvent, IEventProvider } from "@fluidframework/common-definitions";
-import { ITelemetryProperties } from "@fluidframework/core-interfaces";
+import { IEvent, IEventProvider, ITelemetryProperties } from "@fluidframework/core-interfaces";
 import { ITelemetryLoggerExt, ITelemetryLoggerPropertyBag } from "@fluidframework/telemetry-utils";
 import { ContainerWarning, IDeltaManager } from "@fluidframework/container-definitions";
 import {
@@ -34,6 +33,20 @@ export interface ICancellationToken<T> {
 /* Similar to AbortSignal, but using promise instead of events */
 export type ISummaryCancellationToken = ICancellationToken<SummarizerStopReason>;
 
+/**
+ * Data required to update internal tracking state after receiving a Summary Ack.
+ */
+export interface IRefreshSummaryAckOptions {
+	/** Handle from the ack's summary op. */
+	readonly proposalHandle: string | undefined;
+	/** Handle from the summary ack just received */
+	readonly ackHandle: string;
+	/** Reference sequence number from the ack's summary op */
+	readonly summaryRefSeq: number;
+	/** Telemetry logger to which telemetry events will be forwarded. */
+	readonly summaryLogger: ITelemetryLoggerExt;
+}
+
 export interface ISummarizerInternalsProvider {
 	/** Encapsulates the work to walk the internals of the running container to generate a summary */
 	submitSummary(options: ISubmitSummaryOptions): Promise<SubmitSummaryResult>;
@@ -88,29 +101,21 @@ 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 */
+	/**
+	 * True to ask the server what the latest summary is first; defaults to false
+	 *
+	 * @deprecated - Summarize will not refresh latest snapshot state anymore.
+	 */
 	readonly refreshLatestAck?: boolean;
 }
 
-/**
- * Data required to update internal tracking state after receiving a Summary Ack.
- */
-export interface IRefreshSummaryAckOptions {
-	/** Handle from the ack's summary op. */
-	readonly proposalHandle: string | undefined;
-	/** Handle from the summary ack just received */
-	readonly ackHandle: string;
-	/** Reference sequence number from the ack's summary op */
-	readonly summaryRefSeq: number;
-	/** Telemetry logger to which telemetry events will be forwarded. */
-	readonly summaryLogger: ITelemetryLoggerExt;
-}
-
 export interface ISubmitSummaryOptions extends ISummarizeOptions {
 	/** Logger to use for correlated summary events */
 	readonly summaryLogger: ITelemetryLoggerExt;
 	/** Tells when summary process should be cancelled */
 	readonly cancellationToken: ISummaryCancellationToken;
+	/** Summarization may be attempted multiple times. This tells whether this is the final summarization attempt. */
+	readonly finalAttempt?: boolean;
 }
 
 export interface IOnDemandSummarizeOptions extends ISummarizeOptions {
@@ -216,8 +221,14 @@ export type SubmitSummaryResult =
 
 /** The stages of Summarize, used to describe how far progress succeeded in case of a failure at a later stage. */
 export type SummaryStage = SubmitSummaryResult["stage"] | "unknown";
+
+/** Type for summarization failures that are retriable. */
+export interface IRetriableFailureResult {
+	readonly retryAfterSeconds?: number;
+}
+
 /** The data in summarizer result when submit summary stage fails. */
-export interface SubmitSummaryFailureData {
+export interface SubmitSummaryFailureData extends IRetriableFailureResult {
 	stage: SummaryStage;
 }
 
@@ -231,7 +242,7 @@ export interface IAckSummaryResult {
 	readonly ackNackDuration: number;
 }
 
-export interface INackSummaryResult {
+export interface INackSummaryResult extends IRetriableFailureResult {
 	readonly summaryNackOp: ISummaryNackMessage;
 	readonly ackNackDuration: number;
 }
@@ -246,7 +257,6 @@ export type SummarizeResultPart<TSuccess, TFailure = undefined> =
 			data: TFailure | undefined;
 			message: string;
 			error: any;
-			retryAfterSeconds?: number;
 	  };
 
 export interface ISummarizeResults {
@@ -315,11 +325,14 @@ export type SummarizerStopReason =
 	 */
 	| "latestSummaryStateStale";
 
+export interface ISummarizeEventProps {
+	result: "success" | "failure" | "canceled";
+	currentAttempt: number;
+	maxAttempts: number;
+	error?: any;
+}
 export interface ISummarizerEvents extends IEvent {
-	/**
-	 * An event indicating that the Summarizer is having problems summarizing
-	 */
-	(event: "summarizingError", listener: (error: ISummarizingWarning) => void);
+	(event: "summarize", listener: (props: ISummarizeEventProps) => void);
 }
 
 export interface ISummarizer extends IEventProvider<ISummarizerEvents> {
@@ -437,7 +450,7 @@ export interface ISummarizeHeuristicRunner {
 
 type ISummarizeTelemetryRequiredProperties =
 	/** Reason code for attempting to summarize */
-	"reason";
+	"summarizeReason";
 
 type ISummarizeTelemetryOptionalProperties =
 	/** Number of attempts within the last time window, used for calculating the throttle delay. */
@@ -446,6 +459,8 @@ type ISummarizeTelemetryOptionalProperties =
 	| "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;
 
 export type ISummarizeTelemetryProperties = Pick<

package/src/summary/summaryCollection.ts

@@ -3,10 +3,10 @@
  * Licensed under the MIT License.
  */
 
-import { IEvent } from "@fluidframework/common-definitions";
-import { IDisposable } from "@fluidframework/core-interfaces";
+import { IDisposable, IEvent } from "@fluidframework/core-interfaces";
 import { ITelemetryLoggerExt } from "@fluidframework/telemetry-utils";
-import { Deferred, assert, TypedEventEmitter } from "@fluidframework/common-utils";
+import { Deferred, assert } from "@fluidframework/core-utils";
+import { TypedEventEmitter } from "@fluid-internal/client-utils";
 import { IDeltaManager } from "@fluidframework/container-definitions";
 import {
 	IDocumentMessage,

package/src/summary/summaryFormat.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { assert } from "@fluidframework/common-utils";
+import { assert } from "@fluidframework/core-utils";
 import { IDocumentStorageService } from "@fluidframework/driver-definitions";
 import {
 	readAndParse,
@@ -187,7 +187,9 @@ export const dataStoreAttributesBlobName = ".component";
  * @param summarizeResult - Summary tree and stats to modify
  *
  * @example
+ *
  * Converts from:
+ *
  * ```typescript
  * {
  *     type: SummaryType.Tree,
@@ -208,6 +210,7 @@ export const dataStoreAttributesBlobName = ".component";
  *     },
  * }
  * ```
+ *
  * And adds +1 to treeNodeCount in stats.
  */
 export function wrapSummaryInChannelsTree(summarizeResult: ISummaryTreeWithStats): void {

package/src/summary/summaryGenerator.ts

@@ -7,7 +7,6 @@ import {
 	ITelemetryLoggerExt,
 	PerformanceEvent,
 	LoggingError,
-	ChildLogger,
 } from "@fluidframework/telemetry-utils";
 import { ITelemetryProperties } from "@fluidframework/core-interfaces";
 
@@ -17,14 +16,13 @@ import {
 	IPromiseTimer,
 	IPromiseTimerResult,
 	Timer,
-} from "@fluidframework/common-utils";
+} from "@fluidframework/core-utils";
 import { MessageType } from "@fluidframework/protocol-definitions";
 import { getRetryDelaySecondsFromError } from "@fluidframework/driver-utils";
-import { DriverErrorType } from "@fluidframework/driver-definitions";
+import { DriverErrorTypes } from "@fluidframework/driver-definitions";
 import {
 	IAckSummaryResult,
 	INackSummaryResult,
-	ISummarizeOptions,
 	IBroadcastSummaryResult,
 	ISummarizeResults,
 	ISummarizeHeuristicData,
@@ -32,9 +30,7 @@ import {
 	SubmitSummaryResult,
 	SummarizeResultPart,
 	ISummaryCancellationToken,
-	ISummarizeTelemetryProperties,
 	SummaryGeneratorTelemetry,
-	SummaryStage,
 	SubmitSummaryFailureData,
 } from "./summarizerTypes";
 import { IClientSummaryWatcher } from "./summaryCollection";
@@ -143,12 +139,17 @@ export class SummarizeResultBuilder {
 		SummarizeResultPart<IAckSummaryResult, INackSummaryResult>
 	>();
 
+	/**
+	 * Fails one or more of the three results as per the passed params.
+	 * If submit fails, all three results fail.
+	 * If op broadcast fails, only op broadcast result and ack nack result fails.
+	 * If ack nack fails, only ack nack result fails.
+	 */
 	public fail(
 		message: string,
 		error: any,
-		stage: SummaryStage = "unknown",
+		submitFailureResult?: SubmitSummaryFailureData,
 		nackSummaryResult?: INackSummaryResult,
-		retryAfterSeconds?: number,
 	) {
 		assert(
 			!this.receivedSummaryAckOrNack.isCompleted,
@@ -160,9 +161,11 @@ export class SummarizeResultBuilder {
 			message,
 			data: undefined,
 			error,
-			retryAfterSeconds,
 		} as const;
-		this.summarySubmitted.resolve({ ...result, data: { stage } });
+
+		// Note that if any of these are already resolved, it will be a no-op. For example, if ack nack failed but
+		// submit summary and op broadcast has already been resolved as passed, only ack nack result will get modified.
+		this.summarySubmitted.resolve({ ...result, data: submitFailureResult });
 		this.summaryOpBroadcasted.resolve(result);
 		this.receivedSummaryAckOrNack.resolve({ ...result, data: nackSummaryResult });
 	}
@@ -217,30 +220,23 @@ export class SummaryGenerator {
 	 * fullTree to generate tree without any summary handles even if unchanged
 	 */
 	public summarize(
-		summarizeProps: ISummarizeTelemetryProperties,
-		options: ISummarizeOptions,
-		cancellationToken: ISummaryCancellationToken,
+		summaryOptions: ISubmitSummaryOptions,
 		resultsBuilder = new SummarizeResultBuilder(),
 	): ISummarizeResults {
-		this.summarizeCore(summarizeProps, options, resultsBuilder, cancellationToken).catch(
-			(error) => {
-				const message = "UnexpectedSummarizeError";
-				this.logger.sendErrorEvent({ eventName: message, ...summarizeProps }, error);
-				resultsBuilder.fail(message, error);
-			},
-		);
+		this.summarizeCore(summaryOptions, resultsBuilder).catch((error) => {
+			const message = "UnexpectedSummarizeError";
+			summaryOptions.summaryLogger.sendErrorEvent({ eventName: message }, error);
+			resultsBuilder.fail(message, error);
+		});
 
 		return resultsBuilder.build();
 	}
 
 	private async summarizeCore(
-		summarizeProps: ISummarizeTelemetryProperties,
-		options: ISummarizeOptions,
+		submitSummaryOptions: ISubmitSummaryOptions,
 		resultsBuilder: SummarizeResultBuilder,
-		cancellationToken: ISummaryCancellationToken,
 	): Promise<void> {
-		const { refreshLatestAck, fullTree } = options;
-		const logger = ChildLogger.create(this.logger, undefined, { all: summarizeProps });
+		const { summaryLogger, cancellationToken, ...summarizeOptions } = submitSummaryOptions;
 
 		// Note: timeSinceLastAttempt and timeSinceLastSummary for the
 		// first summary are basically the time since the summarizer was loaded.
@@ -248,37 +244,40 @@ export class SummaryGenerator {
 		const timeSinceLastSummary =
 			Date.now() - this.heuristicData.lastSuccessfulSummary.summaryTime;
 		let summarizeTelemetryProps: SummaryGeneratorTelemetry = {
-			fullTree,
+			...summarizeOptions,
+			fullTree: summarizeOptions.fullTree ?? false,
 			timeSinceLastAttempt,
 			timeSinceLastSummary,
 		};
 
 		const summarizeEvent = PerformanceEvent.start(
-			logger,
+			summaryLogger,
 			{
 				eventName: "Summarize",
-				refreshLatestAck,
 				...summarizeTelemetryProps,
 			},
 			{ start: true, end: true, cancel: "generic" },
 		);
 
 		let summaryData: SubmitSummaryResult | undefined;
+
+		/**
+		 * Summarization can fail during submit, during op broadcast or during nack.
+		 * For submit failures, submitFailureResult should be provided. For nack failures, nackSummaryResult should
+		 * be provided. For op broadcast failures, only errors / properties should be provided.
+		 */
 		const fail = (
 			errorCode: keyof typeof summarizeErrors,
 			error?: any,
 			properties?: SummaryGeneratorTelemetry,
+			submitFailureResult?: SubmitSummaryFailureData,
 			nackSummaryResult?: INackSummaryResult,
 		) => {
-			// UploadSummary may fail with 429 and retryAfter - respect that
-			// Summary Nack also can have retryAfter, it's parsed below and comes as a property.
-			const retryAfterSeconds = getRetryDelaySecondsFromError(error);
-
 			// Report any failure as an error unless it was due to cancellation (like "disconnected" error)
 			// If failure happened on upload, we may not yet realized that socket disconnected, so check
 			// offlineError too.
 			const category =
-				cancellationToken.cancelled || error?.errorType === DriverErrorType.offlineError
+				cancellationToken.cancelled || error?.errorType === DriverErrorTypes.offlineError
 					? "generic"
 					: "error";
 
@@ -288,15 +287,14 @@ export class SummaryGenerator {
 					...properties,
 					reason,
 					category,
-					retryAfterSeconds,
+					retryAfterSeconds:
+						submitFailureResult?.retryAfterSeconds ??
+						nackSummaryResult?.retryAfterSeconds,
 				},
 				error ?? reason,
 			); // disconnect & summaryAckTimeout do not have proper error.
 
-			// If summarize did not hit an unexpected error, summaryData would be available. Otherwise, the state is
-			// unknown.
-			const stage = summaryData?.stage ?? "unknown";
-			resultsBuilder.fail(reason, error, stage, nackSummaryResult, retryAfterSeconds);
+			resultsBuilder.fail(reason, error, submitFailureResult, nackSummaryResult);
 		};
 
 		// Wait to generate and send summary
@@ -305,12 +303,7 @@ export class SummaryGenerator {
 			// Need to save refSeqNum before we record new attempt (happens as part of submitSummaryCallback)
 			const lastAttemptRefSeqNum = this.heuristicData.lastAttempt.refSequenceNumber;
 
-			summaryData = await this.submitSummaryCallback({
-				fullTree,
-				refreshLatestAck,
-				summaryLogger: logger,
-				cancellationToken,
-			});
+			summaryData = await this.submitSummaryCallback(submitSummaryOptions);
 
 			// Cumulatively add telemetry properties based on how far generateSummary went.
 			const referenceSequenceNumber = summaryData.referenceSequenceNumber;
@@ -330,7 +323,10 @@ export class SummaryGenerator {
 			);
 
 			if (summaryData.stage !== "submit") {
-				return fail("submitSummaryFailure", summaryData.error, summarizeTelemetryProps);
+				return fail("submitSummaryFailure", summaryData.error, summarizeTelemetryProps, {
+					stage: summaryData.stage,
+					retryAfterSeconds: getRetryDelaySecondsFromError(summaryData.error),
+				});
 			}
 
 			/**
@@ -343,14 +339,14 @@ export class SummaryGenerator {
 			 * state change of multiple data stores. So, the total number of data stores that are summarized should not
 			 * exceed the number of ops since last summary + number of data store whose reference state changed.
 			 */
-			if (!fullTree && !summaryData.forcedFullTree) {
+			if (!submitSummaryOptions.fullTree && !summaryData.forcedFullTree) {
 				const { summarizedDataStoreCount, gcStateUpdatedDataStoreCount = 0 } =
 					summaryData.summaryStats;
 				if (
 					summarizedDataStoreCount >
 					gcStateUpdatedDataStoreCount + this.heuristicData.opsSinceLastSummary
 				) {
-					logger.sendErrorEvent({
+					summaryLogger.sendErrorEvent({
 						eventName: "IncrementalSummaryViolation",
 						summarizedDataStoreCount,
 						gcStateUpdatedDataStoreCount,
@@ -363,7 +359,10 @@ export class SummaryGenerator {
 			summarizeEvent.reportEvent("generate", { ...summarizeTelemetryProps });
 			resultsBuilder.summarySubmitted.resolve({ success: true, data: summaryData });
 		} catch (error) {
-			return fail("submitSummaryFailure", error);
+			return fail("submitSummaryFailure", error, undefined /* properties */, {
+				stage: "unknown",
+				retryAfterSeconds: getRetryDelaySecondsFromError(error),
+			});
 		} finally {
 			if (summaryData === undefined) {
 				this.heuristicData.recordAttempt();
@@ -382,10 +381,10 @@ export class SummaryGenerator {
 				cancellationToken,
 			);
 			if (waitBroadcastResult.result === "cancelled") {
-				return fail("disconnect", summaryData.stage);
+				return fail("disconnect");
 			}
 			if (waitBroadcastResult.result !== "done") {
-				return fail("summaryOpWaitTimeout", summaryData.stage);
+				return fail("summaryOpWaitTimeout");
 			}
 			const summarizeOp = waitBroadcastResult.value;
 
@@ -396,7 +395,7 @@ export class SummaryGenerator {
 			});
 
 			this.heuristicData.lastAttempt.summarySequenceNumber = summarizeOp.sequenceNumber;
-			logger.sendTelemetryEvent({
+			summaryLogger.sendTelemetryEvent({
 				eventName: "Summarize_Op",
 				duration: broadcastDuration,
 				referenceSequenceNumber: summarizeOp.referenceSequenceNumber,
@@ -465,7 +464,8 @@ export class SummaryGenerator {
 					"summaryNack",
 					error,
 					{ ...summarizeTelemetryProps, nackRetryAfter: retryAfterSeconds },
-					{ summaryNackOp: ackNackOp, ackNackDuration },
+					undefined /* submitFailureResult */,
+					{ summaryNackOp: ackNackOp, ackNackDuration, retryAfterSeconds },
 				);
 			}
 		} finally {