@fluidframework/container-runtime 2.74.0-370705 → 2.80.0

package/src/blobManager/blobManager.ts

@@ -270,7 +270,6 @@ export class BlobManager {
 	// blobPath's format - `/<basePath>/<localId>`.
 	private readonly isBlobDeleted: (blobPath: string) => boolean;
 	private readonly runtime: IBlobManagerRuntime;
-	private readonly localIdGenerator: () => string;
 
 	private readonly createBlobPayloadPending: boolean;
 
@@ -298,7 +297,6 @@ export class BlobManager {
 		readonly isBlobDeleted: (blobPath: string) => boolean;
 		readonly runtime: IBlobManagerRuntime;
 		pendingBlobs: IPendingBlobs | undefined;
-		readonly localIdGenerator?: (() => string) | undefined;
 		readonly createBlobPayloadPending: boolean;
 	}) {
 		const {
@@ -310,7 +308,6 @@ export class BlobManager {
 			isBlobDeleted,
 			runtime,
 			pendingBlobs,
-			localIdGenerator,
 			createBlobPayloadPending,
 		} = props;
 		this.routeContext = routeContext;
@@ -319,7 +316,6 @@ export class BlobManager {
 		this.blobRequested = blobRequested;
 		this.isBlobDeleted = isBlobDeleted;
 		this.runtime = runtime;
-		this.localIdGenerator = localIdGenerator ?? uuid;
 		this.createBlobPayloadPending = createBlobPayloadPending;
 
 		this.mc = createChildMonitoringContext({
@@ -480,7 +476,7 @@ export class BlobManager {
 		if (signal?.aborted === true) {
 			throw createAbortError();
 		}
-		const localId = this.localIdGenerator();
+		const localId = uuid();
 		this.localBlobCache.set(localId, { state: "uploading", blob });
 		// Blobs created while the container is detached are stored in IDetachedBlobStorage.
 		// The 'IContainerStorageService.createBlob()' call below will respond with a pseudo storage ID.
@@ -497,7 +493,7 @@ export class BlobManager {
 		blob: ArrayBufferLike,
 		signal?: AbortSignal,
 	): Promise<IFluidHandleInternalPayloadPending<ArrayBufferLike>> {
-		const localId = this.localIdGenerator();
+		const localId = uuid();
 		this.localBlobCache.set(localId, { state: "localOnly", blob });
 		await this.uploadAndAttach(localId, signal);
 		return this.getNonPayloadPendingBlobHandle(localId);
@@ -507,7 +503,7 @@ export class BlobManager {
 		blob: ArrayBufferLike,
 		signal?: AbortSignal,
 	): IFluidHandleInternalPayloadPending<ArrayBufferLike> {
-		const localId = this.localIdGenerator();
+		const localId = uuid();
 		this.localBlobCache.set(localId, { state: "localOnly", blob });
 
 		const blobHandle = new BlobHandle(

package/src/channelCollection.ts

@@ -492,9 +492,33 @@ export class ChannelCollection
 				continue;
 			}
 
-			// If a non-local operation then go and create the object, otherwise mark it as officially attached.
+			// Check for collision with local (not yet live / known to other clients) DataStore
+			// This is not a DataCorruption case if we crash the container before the DataStore becomes visible to others (it's a DataProcessingError instead)
+			//
+			// POSSIBLE CAUSES:
+			// - Something with ID creation, e.g. a bug in shortID logic, or somehow a generated ID matches an existing alias.
+			// - An invalid operation by the application or service where an existing container is returned to a new container attach call,
+			// resulting in duplicate accounting for objects that were supposed to be local-only. e.g. if the application patches in custom
+			// logic not supported by Fluid's API.
+			if (this.contexts.getUnbound(attachMessage.id) !== undefined) {
+				const error = DataProcessingError.create(
+					"Local DataStore matches remote DataStore id",
+					"DataStoreAttach",
+					envelope,
+					{ ...tagCodeArtifacts({ dataStoreId: attachMessage.id }) },
+				);
+				throw error;
+			}
+
+			// Check for collision with already processed (attaching/attached or aliased) DataStore
+			// This is presumed to indicate a corrupted op stream, where we'd expect all future sessions to fail here too.
+			//
+			// POSSIBLE CAUSES:
+			// - A bug in the service or driver that results in ops being duplicated
+			// - Similar to above, an existing container being returned to a new container attach call,
+			// where the DataStore in question was already made locally visible before container attach.
+			// (Perhaps future sessions would not fail in this case, but it's hypothetical and hard to differentiate)
 			if (this.alreadyProcessed(attachMessage.id)) {
-				// TODO: dataStoreId may require a different tag from PackageData #7488
 				const error = new DataCorruptionError(
 					// pre-0.58 error message: duplicateDataStoreCreatedWithExistingId
 					"Duplicate DataStore created with existing id",
@@ -769,7 +793,7 @@ export class ChannelCollection
 			| OutboundContainerRuntimeAttachMessage
 			| ContainerRuntimeAliasMessage,
 		localOpMetadata: unknown,
-		squash: boolean | undefined,
+		squash: boolean,
 	): void => {
 		switch (message.type) {
 			case ContainerMessageType.Attach:
@@ -789,7 +813,7 @@ export class ChannelCollection
 	protected readonly resubmitDataStoreOp = (
 		envelope: IEnvelope<FluidDataStoreMessage>,
 		localOpMetadata: unknown,
-		squash: boolean | undefined,
+		squash: boolean,
 	): void => {
 		const context = this.contexts.get(envelope.address);
 		// If the data store has been deleted, log an error and throw an error. If there are local changes for a
@@ -1796,7 +1820,7 @@ export class ComposableChannelCollection
 		type: string,
 		content: unknown,
 		localOpMetadata: unknown,
-		squash?: boolean,
+		squash: boolean,
 	): void {
 		// If the cast is incorrect and type is not one of the three supported,
 		// reSubmitContainerMessage will assert.

package/src/containerRuntime.ts

@@ -1622,10 +1622,11 @@ export class ContainerRuntime
 
 		// Validate that the Loader is compatible with this Runtime.
 		const maybeLoaderCompatDetailsForRuntime = context as FluidObject<ILayerCompatDetails>;
+
 		validateLoaderCompatibility(
 			maybeLoaderCompatDetailsForRuntime.ILayerCompatDetails,
 			this.disposeFn,
-			this.mc.logger,
+			this.mc,
 		);
 
 		// If we support multiple algorithms in the future, then we would need to manage it here carefully.
@@ -1828,7 +1829,9 @@ export class ContainerRuntime
 			validateSummaryHeuristicConfiguration(this.summaryConfiguration);
 		}
 
-		this.summariesDisabled = isSummariesDisabled(this.summaryConfiguration);
+		this.summariesDisabled =
+			isSummariesDisabled(this.summaryConfiguration) ||
+			this.mc.config.getBoolean("Fluid.ContainerRuntime.Test.DisableSummaries") === true;
 
 		this.maxConsecutiveReconnects =
 			this.mc.config.getNumber(maxConsecutiveReconnectsKey) ?? defaultMaxConsecutiveReconnects;
@@ -2294,7 +2297,10 @@ export class ContainerRuntime
 
 			const defaultAction = (): void => {
 				if (summaryCollection.opsSinceLastAck > maxOpsSinceLastSummary) {
-					this.mc.logger.sendTelemetryEvent({ eventName: "SummaryStatus:Behind" });
+					this.mc.logger.sendTelemetryEvent({
+						eventName: "SummaryStatus:Behind",
+						opsWithoutSummary: summaryCollection.opsSinceLastAck,
+					});
 					// unregister default to no log on every op after falling behind
 					// and register summary ack handler to re-register this handler
 					// after successful summary
@@ -2336,8 +2342,9 @@ export class ContainerRuntime
 				"summarizerStop",
 				"summarizerStart",
 				"summarizerStartupFailed",
-			]) {
-				this.summaryManager?.on(eventName, (...args: unknown[]) => {
+				"summarizeTimeout",
+			] as const) {
+				this.summaryManager.on(eventName, (...args: unknown[]) => {
 					this.emit(eventName, ...args);
 				});
 			}
@@ -3930,6 +3937,10 @@ export class ContainerRuntime
 		 * True to run GC sweep phase after the mark phase
 		 */
 		runSweep?: boolean;
+		/**
+		 * Telemetry context to populate during summarization.
+		 */
+		telemetryContext?: TelemetryContext;
 	}): Promise<ISummaryTreeWithStats> {
 		this.verifyNotClosed();
 
@@ -3940,9 +3951,9 @@ export class ContainerRuntime
 			runGC = this.garbageCollector.shouldRunGC,
 			runSweep,
 			fullGC,
+			telemetryContext = new TelemetryContext(),
 		} = options;
 
-		const telemetryContext = new TelemetryContext();
 		// Add the options that are used to generate this summary to the telemetry context.
 		telemetryContext.setMultiple("fluid_Summarize", "Options", {
 			fullTree,
@@ -4183,6 +4194,7 @@ export class ContainerRuntime
 			finalAttempt = false,
 			summaryLogger,
 			latestSummaryRefSeqNum,
+			telemetryContext = new TelemetryContext(),
 		} = options;
 		// The summary number for this summary. This will be updated during the summary process, so get it now and
 		// use it for all events logged during this summary.
@@ -4372,6 +4384,7 @@ export class ContainerRuntime
 					trackState: true,
 					summaryLogger: summaryNumberLogger,
 					runGC: this.garbageCollector.shouldRunGC,
+					telemetryContext,
 				});
 			} catch (error) {
 				return {

package/src/dataStoreContext.ts

@@ -1003,7 +1003,7 @@ export abstract class FluidDataStoreContext
 		validateDatastoreCompatibility(
 			maybeDataStoreCompatDetails.ILayerCompatDetails,
 			this.dispose.bind(this),
-			this.mc.logger,
+			this.mc,
 		);
 
 		// And now mark the runtime active
@@ -1096,7 +1096,7 @@ export abstract class FluidDataStoreContext
 	public reSubmit(
 		message: FluidDataStoreMessage,
 		localOpMetadata: unknown,
-		squash?: boolean,
+		squash: boolean,
 	): void {
 		assert(!!this.channel, 0x14b /* "Channel must exist when resubmitting ops" */);
 		this.channel.reSubmit(message.type, message.content, localOpMetadata, squash);

package/src/dataStoreContexts.ts

@@ -13,27 +13,41 @@ import {
 import type { FluidDataStoreContext, LocalFluidDataStoreContext } from "./dataStoreContext.js";
 
 /**
+ * Manages the collection of data store contexts, tracking their bound/unbound state.
+ *
+ * @remarks
+ * A context is "unbound" when it's created locally but not yet made visible (reachable from root).
+ * A context is "bound" once it's made locally visible, regardless of the Container's attach state.
+ * In attached containers, binding a context immediately sends an attach op and transitions it to Attaching state.
+ *
  * @internal
  */
 export class DataStoreContexts
 	implements Iterable<[string, FluidDataStoreContext]>, IDisposable
 {
+	/**
+	 * Set of IDs for contexts that are unbound (not yet made locally visible).
+	 * These contexts exist locally but aren't known to other clients (even in an attached container).
+	 */
 	private readonly notBoundContexts = new Set<string>();
 
 	/**
-	 * Attached and loaded context proxies
+	 * Map of all data store contexts (both bound and unbound).
 	 */
 	private readonly _contexts = new Map<string, FluidDataStoreContext>();
 
 	/**
 	 * List of pending context waiting either to be bound or to arrive from another client.
 	 * This covers the case where a local context has been created but not yet bound,
-	 * or the case where a client knows a store will exist and is waiting on its creation,
+	 * or the case where a client knows a store will exist (e.g. by alias) and is waiting on its creation,
 	 * so that a caller may await the deferred's promise until such a time as the context is fully ready.
 	 * This is a superset of _contexts, since contexts remain here once the Deferred resolves.
 	 */
 	private readonly deferredContexts = new Map<string, Deferred<FluidDataStoreContext>>();
 
+	/**
+	 * Lazy disposal logic that disposes all contexts when called.
+	 */
 	// eslint-disable-next-line unicorn/consistent-function-scoping -- Property is defined once; no need to extract inner lambda
 	private readonly disposeOnce = new Lazy<void>(() => {
 		// close/stop all store contexts
@@ -73,22 +87,39 @@ export class DataStoreContexts
 	}
 	public readonly dispose = (): void => this.disposeOnce.value;
 
+	/**
+	 * Returns the count of unbound contexts (i.e. local-only on this client)
+	 */
 	public notBoundLength(): number {
 		return this.notBoundContexts.size;
 	}
 
+	/**
+	 * Returns true if the given ID corresponds to an unbound context. (i.e. local-only on this client)
+	 */
 	public isNotBound(id: string): boolean {
 		return this.notBoundContexts.has(id);
 	}
 
+	/**
+	 * Returns true if a context with the given ID exists (bound or unbound).
+	 */
 	public has(id: string): boolean {
 		return this._contexts.has(id);
 	}
 
+	/**
+	 * Returns the context with the given ID, or undefined if not found.
+	 * This returns both bound and unbound contexts.
+	 */
 	public get(id: string): FluidDataStoreContext | undefined {
 		return this._contexts.get(id);
 	}
 
+	/**
+	 * Deletes the context with the given ID from all internal maps.
+	 * @returns True if the context was found and deleted, false otherwise.
+	 */
 	public delete(id: string): boolean {
 		this.deferredContexts.delete(id);
 		this.notBoundContexts.delete(id);
@@ -100,16 +131,24 @@ export class DataStoreContexts
 		return this._contexts.delete(id);
 	}
 
+	/**
+	 * Map of recently deleted contexts for diagnostic purposes for GC.
+	 * Allows retrieval of context information even after deletion for logging/telemetry.
+	 */
 	private readonly _recentlyDeletedContexts: Map<string, FluidDataStoreContext | undefined> =
 		new Map();
 
+	/**
+	 * Returns a recently deleted context by ID, or undefined if not found.
+	 * Used for diagnostic logging for GC, when a deleted context is referenced.
+	 */
 	public getRecentlyDeletedContext(id: string): FluidDataStoreContext | undefined {
 		return this._recentlyDeletedContexts.get(id);
 	}
 
 	/**
-	 * Return the unbound local context with the given id,
-	 * or undefined if it's not found or not unbound.
+	 * Returns the unbound local context with the given ID.
+	 * @returns The unbound context, or undefined if not found or not unbound.
 	 */
 	public getUnbound(id: string): LocalFluidDataStoreContext | undefined {
 		const context = this._contexts.get(id);
@@ -121,7 +160,8 @@ export class DataStoreContexts
 	}
 
 	/**
-	 * Add the given context, marking it as to-be-bound
+	 * Adds the given context to the collection, marking it as unbound (not yet locally visible).
+	 * Asserts that no context with this ID already exists.
 	 */
 	public addUnbound(context: LocalFluidDataStoreContext): void {
 		const id = context.id;
@@ -152,6 +192,10 @@ export class DataStoreContexts
 		return deferredContext.promise;
 	}
 
+	/**
+	 * Gets or creates a deferred promise for the given context ID.
+	 * Used to allow waiting for contexts that don't exist yet.
+	 */
 	private ensureDeferred(id: string): Deferred<FluidDataStoreContext> {
 		const deferred = this.deferredContexts.get(id);
 		if (deferred) {
@@ -164,7 +208,8 @@ export class DataStoreContexts
 	}
 
 	/**
-	 * Update this context as bound
+	 * Marks the context with the given ID as bound (locally visible).
+	 * Removes it from the unbound set and resolves its deferred promise.
 	 */
 	public bind(id: string): void {
 		const removed: boolean = this.notBoundContexts.delete(id);
@@ -191,9 +236,11 @@ export class DataStoreContexts
 	}
 
 	/**
-	 * Add the given context, marking it as not local-only.
-	 * This could be because it's a local context that's been bound, or because it's a remote context.
-	 * @param context - The context to add
+	 * Adds the given context to the collection as already bound or from a remote client.
+	 * This is used when:
+	 * - Adding a local context that's already been bound via the bind() method, OR
+	 * - Adding a remote context that was created by another client.
+	 * The context's deferred promise is resolved immediately.
 	 */
 	public addBoundOrRemoted(context: FluidDataStoreContext): void {
 		const id = context.id;

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/container-runtime";
-export const pkgVersion = "2.74.0-370705";
+export const pkgVersion = "2.80.0";

package/src/runtimeLayerCompatState.ts

@@ -3,9 +3,10 @@
  * Licensed under the MIT License.
  */
 
-import type {
-	ILayerCompatDetails,
-	ILayerCompatSupportRequirements,
+import {
+	generation,
+	type ILayerCompatDetails,
+	type ILayerCompatSupportRequirements,
 } from "@fluid-internal/client-utils";
 import type { ICriticalContainerError } from "@fluidframework/container-definitions";
 import {
@@ -14,11 +15,17 @@ import {
 } from "@fluidframework/runtime-definitions/internal";
 import {
 	validateLayerCompatibility,
-	type ITelemetryLoggerExt,
+	type MonitoringContext,
 } from "@fluidframework/telemetry-utils/internal";
 
 import { pkgVersion } from "./packageVersion.js";
 
+/**
+ * The config key to disable strict loader layer compatibility check.
+ */
+export const disableStrictLoaderLayerCompatibilityCheckKey =
+	"Fluid.ContainerRuntime.DisableStrictLoaderLayerCompatibilityCheck";
+
 /**
  * The core compatibility details of the Runtime layer that is the same across all layer boundaries.
  * @internal
@@ -31,7 +38,7 @@ export const runtimeCoreCompatDetails = {
 	/**
 	 * The current generation of the Runtime layer.
 	 */
-	generation: 2,
+	generation,
 } as const;
 
 /**
@@ -97,8 +104,16 @@ export const dataStoreSupportRequirementsForRuntime: ILayerCompatSupportRequirem
 export function validateLoaderCompatibility(
 	maybeLoaderCompatDetailsForRuntime: ILayerCompatDetails | undefined,
 	disposeFn: (error?: ICriticalContainerError) => void,
-	logger: ITelemetryLoggerExt,
+	mc: MonitoringContext,
 ): void {
+	// By default, use strictCompatibilityCheck here - If the Loader doesn't provide compatibility details,
+	// assume it's a very old version and should be considered incompatible,
+	// since Loader can drift far from the Runtime causing issues.
+	// Can be disabled via config `disableStrictLoaderLayerCompatibilityCheckKey`.
+	const disableStrictLoaderLayerCompatibilityCheck = mc.config.getBoolean(
+		disableStrictLoaderLayerCompatibilityCheckKey,
+	);
+
 	validateLayerCompatibility(
 		"runtime",
 		"loader",
@@ -106,7 +121,8 @@ export function validateLoaderCompatibility(
 		loaderSupportRequirementsForRuntime,
 		maybeLoaderCompatDetailsForRuntime,
 		disposeFn,
-		logger,
+		mc,
+		disableStrictLoaderLayerCompatibilityCheck !== true /* strictCompatibilityCheck */,
 	);
 }
 
@@ -117,7 +133,7 @@ export function validateLoaderCompatibility(
 export function validateDatastoreCompatibility(
 	maybeDataStoreCompatDetailsForRuntime: ILayerCompatDetails | undefined,
 	disposeFn: () => void,
-	logger: ITelemetryLoggerExt,
+	mc: MonitoringContext,
 ): void {
 	validateLayerCompatibility(
 		"runtime",
@@ -126,6 +142,6 @@ export function validateDatastoreCompatibility(
 		dataStoreSupportRequirementsForRuntime,
 		maybeDataStoreCompatDetailsForRuntime,
 		disposeFn,
-		logger,
+		mc,
 	);
 }

package/src/summary/summarizerClientElection.ts

@@ -91,6 +91,7 @@ export class SummarizerClientElection
 						lastSummaryAckSeqForClient: this.lastSummaryAckSeqForClient,
 						electionSequenceNumber,
 						nextElectedClientId: this.clientElection.peekNextElectedClient()?.clientId,
+						opsWithoutSummary,
 					});
 					this.lastReportedSeq = sequenceNumber;
 				}

package/src/summary/summarizerTypes.ts

@@ -22,6 +22,7 @@ import type {
 	ISequencedDocumentMessage,
 } from "@fluidframework/driver-definitions/internal";
 import type { ISummaryStats } from "@fluidframework/runtime-definitions/internal";
+import type { TelemetryContext } from "@fluidframework/runtime-utils/internal";
 import type {
 	ITelemetryLoggerExt,
 	ITelemetryLoggerPropertyBag,
@@ -167,6 +168,10 @@ export interface ISubmitSummaryOptions extends ISummarizeOptions {
 	 * The sequence number of the latest summary used to validate if summary state is correct before summarizing
 	 */
 	readonly latestSummaryRefSeqNum: number;
+	/**
+	 * Shared telemetry context for the current summarize attempt.
+	 */
+	telemetryContext?: TelemetryContext;
 }
 
 /**

package/src/summary/summaryDelayLoadedModule/runningSummarizer.ts

@@ -177,11 +177,6 @@ export class RunningSummarizer
 	private totalSuccessfulAttempts = 0;
 	private initialized = false;
 
-	private readonly runtimeListener: (
-		op: ISequencedDocumentMessage,
-		runtimeMessage?: boolean,
-	) => void;
-
 	/**
 	 * The maximum number of summary attempts to do when submit summary fails.
 	 */
@@ -295,12 +290,6 @@ export class RunningSummarizer
 			this.mc.logger,
 		);
 
-		// Listen to runtime for ops
-		this.runtimeListener = (op: ISequencedDocumentMessage, runtimeMessage?: boolean) => {
-			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.
@@ -312,6 +301,8 @@ export class RunningSummarizer
 			overrideMaxAttempts < defaultMaxAttemptsForSubmitFailures
 				? overrideMaxAttempts
 				: defaultMaxAttemptsForSubmitFailures;
+
+		this.setupEventListeners();
 	}
 
 	private async handleSummaryAck(ack: IAckedSummary): Promise<void> {
@@ -397,7 +388,7 @@ export class RunningSummarizer
 	}
 
 	public dispose(): void {
-		this.runtime.off("op", this.runtimeListener);
+		this.cleanupEventListeners();
 		this.summaryWatcher.dispose();
 		this.heuristicRunner?.dispose();
 		this.heuristicRunner = undefined;
@@ -408,6 +399,33 @@ export class RunningSummarizer
 		this.stopping = true;
 	}
 
+	private readonly eventsCleanup: (() => void)[] = [];
+
+	private setupEventListeners(): void {
+		const runtimeListener: (op: ISequencedDocumentMessage, runtimeMessage?: boolean) => void =
+			(op: ISequencedDocumentMessage, runtimeMessage?: boolean) => {
+				this.handleOp(op, runtimeMessage === true);
+			};
+		this.runtime.on("op", runtimeListener);
+		this.eventsCleanup.push(() => this.runtime.off("op", runtimeListener));
+
+		// Forward events
+		for (const event of ["summarizeTimeout"] as const) {
+			const listener = (...args: unknown[]): void => {
+				this.emit(event, ...args);
+			};
+			this.generator.on(event, listener);
+			this.eventsCleanup.push(() => this.generator.off(event, listener));
+		}
+	}
+
+	private cleanupEventListeners(): void {
+		for (const cleanup of this.eventsCleanup) {
+			cleanup();
+		}
+		this.eventsCleanup.length = 0;
+	}
+
 	/**
 	 * RunningSummarizer's logger includes the sequenced index of the current summary on each event.
 	 * If some other Summarizer code wants that event on their logs they can get it here,
@@ -655,11 +673,12 @@ export class RunningSummarizer
 						numUnsummarizedNonRuntimeOps: this.heuristicData.numNonRuntimeOps,
 						isLastSummary,
 					});
-					this.mc.logger.sendErrorEvent(
+					summaryLogger.sendErrorEvent(
 						{
 							eventName: "SummarizeFailed",
 							maxAttempts: 1,
 							summaryAttempts: 1,
+							isLastSummary,
 						},
 						result.error,
 					);
@@ -708,7 +727,10 @@ export class RunningSummarizer
 				this.afterSummaryAction();
 			},
 		).catch((error) => {
-			this.mc.logger.sendErrorEvent({ eventName: "UnexpectedSummarizeError" }, error);
+			this.mc.logger.sendErrorEvent(
+				{ eventName: "UnexpectedSummarizeError", summarizeReason: reason },
+				error,
+			);
 		});
 	}
 
@@ -718,6 +740,7 @@ export class RunningSummarizer
 	 */
 	private async trySummarizeWithRetries(
 		reason: SummarizeReason,
+		summarizeOptions: ISummarizeOptions = {},
 	): Promise<ISummarizeResults | undefined> {
 		// Helper to set summarize options, telemetry properties and call summarize.
 		const attemptSummarize = (
@@ -727,13 +750,13 @@ export class RunningSummarizer
 			summarizeProps: ISummarizeTelemetryProperties;
 			summarizeResult: ISummarizeResults;
 		} => {
-			const summarizeOptions: ISummarizeOptions = {
-				fullTree: false,
+			const attemptSummarizeOptions: ISummarizeOptions = {
+				fullTree: summarizeOptions.fullTree ?? false,
 			};
 			const summarizeProps: ISummarizeTelemetryProperties = {
 				summarizeReason: reason,
 				summaryAttempts: attemptNumber,
-				...summarizeOptions,
+				...attemptSummarizeOptions,
 				finalAttempt,
 			};
 			const summaryLogger = createChildLogger({
@@ -742,7 +765,7 @@ export class RunningSummarizer
 			});
 
 			const summaryOptions: ISubmitSummaryOptions = {
-				...summarizeOptions,
+				...attemptSummarizeOptions,
 				summaryLogger,
 				cancellationToken: this.cancellationToken,
 				finalAttempt,
@@ -872,6 +895,8 @@ export class RunningSummarizer
 					eventName: "SummarizeFailed",
 					maxAttempts,
 					summaryAttempts: currentAttempt,
+					summarizeReason: reason,
+					isLastSummary: reason === "lastSummary",
 				},
 				error,
 			);
@@ -893,8 +918,9 @@ export class RunningSummarizer
 	private async summarizeOnDemandWithRetries(
 		reason: SummarizeReason,
 		resultsBuilder: SummarizeResultBuilder,
+		summarizeOptions: ISummarizeOptions = {},
 	): Promise<ISummarizeResults> {
-		const results = await this.trySummarizeWithRetries(reason);
+		const results = await this.trySummarizeWithRetries(reason, summarizeOptions);
 		if (results === undefined) {
 			resultsBuilder.fail(
 				"Summarization was canceled",
@@ -932,13 +958,15 @@ export class RunningSummarizer
 			throw new UsageError("Attempted to run an already-running summarizer on demand");
 		}
 
-		const { reason, ...summarizeOptions } = options;
-		if (options.retryOnFailure === true) {
-			this.summarizeOnDemandWithRetries(`onDemand;${reason}`, resultsBuilder).catch(
-				(error: IRetriableFailureError) => {
-					resultsBuilder.fail("summarize failed", error);
-				},
-			);
+		const { reason, retryOnFailure, ...summarizeOptions } = options;
+		if (retryOnFailure === true) {
+			this.summarizeOnDemandWithRetries(
+				`onDemand;${reason}`,
+				resultsBuilder,
+				summarizeOptions,
+			).catch((error: IRetriableFailureError) => {
+				resultsBuilder.fail("summarize failed", error);
+			});
 		} else {
 			this.trySummarizeOnce(
 				{ summarizeReason: `onDemand/${reason}` },