@fluidframework/container-runtime 2.0.0-dev.5.2.0.169897 → 2.0.0-dev.6.4.0.191258

package/src/summary/summarizerNode/summarizerNodeUtils.ts

@@ -3,56 +3,48 @@
  * Licensed under the MIT License.
  */
 
-import { ITelemetryLoggerExt } from "@fluidframework/telemetry-utils";
+import { ITelemetryLoggerExt, TelemetryDataTag } from "@fluidframework/telemetry-utils";
 import { ISnapshotTree, ISummaryTree, SummaryObject } from "@fluidframework/protocol-definitions";
 import { channelsTreeName, ISummaryTreeWithStats } from "@fluidframework/runtime-definitions";
-import { ReadAndParseBlob } from "@fluidframework/runtime-utils";
+
+export interface IRefreshSummaryResult {
+	/** Tells whether this summary is tracked by this client. */
+	isSummaryTracked: boolean;
+	/** Tells whether this summary is newer than the latest one tracked by this client. */
+	isSummaryNewer: boolean;
+}
 
 /**
- * Return type of refreshSummaryAck function. There can be three different scenarios based on the passed params:
- *
- * 1. The latest summary was not updated.
- *
- * 2. The latest summary was updated and the summary corresponding to the params was tracked by this client.
- *
- * 3. The latest summary was updated but the summary corresponding to the params was not tracked. In this case, the
- * latest snapshot is fetched and the latest summary state is updated based on it.
+ * Return type of validateSummary function. In case of success, the object returned should have success: true.
+ * In case of failure, the object returned should have success: false and additional properties to indicate what
+ * the failure was, where it was, can it be retried, etc.
  */
-export type RefreshSummaryResult =
-	| {
-			latestSummaryUpdated: false;
-	  }
+export type ValidateSummaryResult =
 	| {
-			latestSummaryUpdated: true;
-			wasSummaryTracked: true;
-			summaryRefSeq: number;
+			success: true;
 	  }
 	| {
-			latestSummaryUpdated: true;
-			wasSummaryTracked: false;
-			snapshotTree: ISnapshotTree;
-			summaryRefSeq: number;
+			success: false;
+			/** The failure reason */
+			reason: string;
+			/** id of the node that failed during validation */
+			id: {
+				tag: TelemetryDataTag.CodeArtifact;
+				value: string | undefined;
+			};
+			/** If the error can be retried, time to wait before retrying */
+			retryAfterSeconds?: number;
 	  };
 
-/**
- * Result of snapshot fetch during refreshing latest summary state.
- */
-export interface IFetchSnapshotResult {
-	snapshotTree: ISnapshotTree;
-	snapshotRefSeq: number;
-}
-
 export interface ISummarizerNodeRootContract {
 	startSummary(referenceSequenceNumber: number, summaryLogger: ITelemetryLoggerExt): void;
-	completeSummary(proposalHandle: string): void;
+	validateSummary(): ValidateSummaryResult;
+	completeSummary(proposalHandle: string, validate: boolean): void;
 	clearSummary(): void;
 	refreshLatestSummary(
-		proposalHandle: string | undefined,
+		proposalHandle: string,
 		summaryRefSeq: number,
-		fetchLatestSnapshot: () => Promise<IFetchSnapshotResult>,
-		readAndParseBlob: ReadAndParseBlob,
-		correlatedSummaryLogger: ITelemetryLoggerExt,
-	): Promise<RefreshSummaryResult>;
+	): Promise<IRefreshSummaryResult>;
 }
 
 /** Path for nodes in a tree with escaped special characters */

package/src/summary/summarizerNode/summarizerNodeWithGc.ts

@@ -7,12 +7,11 @@ import {
 	ITelemetryLoggerExt,
 	LoggingError,
 	TelemetryDataTag,
+	tagCodeArtifacts,
 } from "@fluidframework/telemetry-utils";
-import { assert, LazyPromise } from "@fluidframework/common-utils";
-import { ISnapshotTree } from "@fluidframework/protocol-definitions";
+import { assert, LazyPromise } from "@fluidframework/core-utils";
 import {
 	CreateChildSummarizerNodeParam,
-	gcTreeKey,
 	IGarbageCollectionData,
 	IGarbageCollectionDetailsBase,
 	ISummarizeInternalResult,
@@ -23,21 +22,17 @@ 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";
 
 export interface IRootSummarizerNodeWithGC
@@ -47,7 +42,7 @@ export interface IRootSummarizerNodeWithGC
 // Extend SummaryNode to add used routes tracking to it.
 class SummaryNodeWithGC extends SummaryNode {
 	constructor(
-		public readonly serializedUsedRoutes: string,
+		public readonly serializedUsedRoutes: string | undefined,
 		summary: {
 			readonly referenceSequenceNumber: number;
 			readonly basePath: EscapedPath | undefined;
@@ -105,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,
@@ -117,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. */
@@ -255,45 +250,86 @@ export class SummarizerNodeWithGC extends SummarizerNode implements IRootSummari
 		super.startSummary(referenceSequenceNumber, summaryLogger);
 	}
 
+	/**
+	 * Validates that the in-progress summary is correct for all nodes, i.e., GC should have run for non-skipped nodes.
+	 * @param parentSkipRecursion - true if the parent of this node skipped recursing the child nodes when running GC.
+	 * In that case, the children will not have work-in-progress state.
+	 *
+	 * @returns ValidateSummaryResult which contains a boolean success indicating whether the validation was successful.
+	 * In case of failure, additional information is returned indicating type of failure and where it was.
+	 */
+	protected validateSummaryCore(parentSkipRecursion: boolean): ValidateSummaryResult {
+		if (this.wasGCMissed()) {
+			return {
+				success: false,
+				reason: "NodeDidNotRunGC",
+				id: {
+					tag: TelemetryDataTag.CodeArtifact,
+					value: this.telemetryNodeId,
+				},
+				// These errors are usually transient and should go away when summarize / GC is retried.
+				retryAfterSeconds: 1,
+			};
+		}
+		return super.validateSummaryCore(parentSkipRecursion);
+	}
+
+	private wasGCMissed(): boolean {
+		// If GC is disabled, it should not have run so it was not missed.
+		// Otherwise, GC should have been called on this node and wipSerializedUsedRoutes must be set.
+		if (this.gcDisabled || this.wipSerializedUsedRoutes !== undefined) {
+			return false;
+		}
+		/**
+		 * The absence of wip used routes indicates that GC was not run on this node. This can happen if:
+		 * 1. A child node was created after GC was already run on the parent. For example, a data store
+		 * is realized (loaded) after GC was run on it creating summarizer nodes for its DDSes. In this
+		 * case, the parent will pass on used routes to the child nodes and it will have wip used routes.
+		 * 2. A new node was created but GC was never run on it. This can mean that the GC data generated
+		 * during summarize is incomplete.
+		 *
+		 * This happens due to scenarios such as data store created during summarize. Such errors should go away when
+		 * summarize is attempted again.
+		 */
+		return true;
+	}
+
 	/**
 	 * Called after summary has been uploaded to the server. Add the work-in-progress state to the pending
 	 * summary queue. We track this until we get an ack from the server for this summary.
+	 * @param proposalHandle - The handle of the summary that was uploaded to the server.
+	 * @param parentPath - The path of the parent node which is used to build the path of this node.
+	 * @param parentSkipRecursion - true if the parent of this node skipped recursing the child nodes when summarizing.
+	 * In that case, the children will not have work-in-progress state.
+	 * @param validate - true to validate that the in-progress summary is correct for all nodes.
 	 */
 	protected completeSummaryCore(
 		proposalHandle: string,
 		parentPath: EscapedPath | undefined,
 		parentSkipRecursion: boolean,
+		validate: boolean,
 	) {
+		if (validate && this.wasGCMissed()) {
+			this.throwUnexpectedError({
+				eventName: "NodeDidNotRunGC",
+				proposalHandle,
+			});
+		}
+
 		let wipSerializedUsedRoutes: string | undefined;
 		// If GC is disabled, don't set wip used routes.
 		if (!this.gcDisabled) {
 			wipSerializedUsedRoutes = this.wipSerializedUsedRoutes;
-			/**
-			 * The absence of wip used routes indicates that GC was not run on this node. This can happen if:
-			 * 1. A child node was created after GC was already run on the parent. For example, a data store
-			 * is realized (loaded) after GC was run on it creating summarizer nodes for its DDSes. In this
-			 * case, the used routes of the parent should be passed on the child nodes and it should be fine.
-			 * 2. A new node was created but GC was never run on it. This can mean that the GC data generated
-			 * during summarize is complete . We should not continue, log and throw an error. This will help us
-			 * identify these cases and take appropriate action.
-			 */
-			if (wipSerializedUsedRoutes === undefined) {
-				this.throwUnexpectedError({
-					eventName: "NodeDidNotRunGC",
-					proposalHandle,
-				});
-			}
 		}
 
-		super.completeSummaryCore(proposalHandle, parentPath, parentSkipRecursion);
+		super.completeSummaryCore(proposalHandle, parentPath, parentSkipRecursion, validate);
 
 		// If GC is disabled, skip setting pending summary with GC state.
 		if (!this.gcDisabled) {
 			const summaryNode = this.pendingSummaries.get(proposalHandle);
 			if (summaryNode !== undefined) {
 				const summaryNodeWithGC = new SummaryNodeWithGC(
-					// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-					wipSerializedUsedRoutes!,
+					wipSerializedUsedRoutes,
 					summaryNode,
 				);
 				this.pendingSummaries.set(proposalHandle, summaryNodeWithGC);
@@ -327,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(
 						{
@@ -347,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.
 	 */
@@ -623,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,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { IEvent, IEventProvider, ITelemetryProperties } from "@fluidframework/common-definitions";
+import { IEvent, IEventProvider, ITelemetryProperties } from "@fluidframework/core-interfaces";
 import { ITelemetryLoggerExt, ITelemetryLoggerPropertyBag } from "@fluidframework/telemetry-utils";
 import { ContainerWarning, IDeltaManager } from "@fluidframework/container-definitions";
 import {
@@ -33,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>;
@@ -87,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 {
@@ -213,6 +219,19 @@ export type SubmitSummaryResult =
 	| IUploadSummaryResult
 	| ISubmitSummaryOpResult;
 
+/** 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 extends IRetriableFailureResult {
+	stage: SummaryStage;
+}
+
 export interface IBroadcastSummaryResult {
 	readonly summarizeOp: ISummaryOpMessage;
 	readonly broadcastDuration: number;
@@ -223,7 +242,7 @@ export interface IAckSummaryResult {
 	readonly ackNackDuration: number;
 }
 
-export interface INackSummaryResult {
+export interface INackSummaryResult extends IRetriableFailureResult {
 	readonly summaryNackOp: ISummaryNackMessage;
 	readonly ackNackDuration: number;
 }
@@ -238,12 +257,13 @@ export type SummarizeResultPart<TSuccess, TFailure = undefined> =
 			data: TFailure | undefined;
 			message: string;
 			error: any;
-			retryAfterSeconds?: number;
 	  };
 
 export interface ISummarizeResults {
 	/** Resolves when we generate, upload, and submit the summary. */
-	readonly summarySubmitted: Promise<SummarizeResultPart<SubmitSummaryResult>>;
+	readonly summarySubmitted: Promise<
+		SummarizeResultPart<SubmitSummaryResult, SubmitSummaryFailureData>
+	>;
 	/** Resolves when we observe our summarize op broadcast. */
 	readonly summaryOpBroadcasted: Promise<SummarizeResultPart<IBroadcastSummaryResult>>;
 	/** Resolves when we receive a summaryAck or summaryNack. */
@@ -305,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> {
@@ -427,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. */
@@ -436,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,9 +3,10 @@
  * Licensed under the MIT License.
  */
 
-import { IDisposable, IEvent } from "@fluidframework/common-definitions";
+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,
@@ -71,7 +72,9 @@ class Summary implements ISummary {
 		return new Summary(clientId, clientSequenceNumber);
 	}
 	public static createFromOp(op: ISummaryOpMessage) {
-		const summary = new Summary(op.clientId, op.clientSequenceNumber);
+		// TODO: Verify whether this should be able to handle server-generated ops (with null clientId)
+		// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+		const summary = new Summary(op.clientId as string, op.clientSequenceNumber);
 		summary.broadcast(op);
 		return summary;
 	}
@@ -377,7 +380,9 @@ export class SummaryCollection extends TypedEventEmitter<ISummaryCollectionOpEve
 		let summary: Summary | undefined;
 
 		// Check if summary already being watched, broadcast if so
-		const watcher = this.summaryWatchers.get(op.clientId);
+		// TODO: Verify whether this should be able to handle server-generated ops (with null clientId)
+		// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+		const watcher = this.summaryWatchers.get(op.clientId as string);
 		if (watcher) {
 			summary = watcher.tryGetSummary(op.clientSequenceNumber);
 			if (summary) {

package/src/summary/summaryFormat.ts

@@ -3,9 +3,12 @@
  * 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 } from "@fluidframework/driver-utils";
+import {
+	readAndParse,
+	blobHeadersBlobName as blobNameForBlobHeaders,
+} from "@fluidframework/driver-utils";
 import {
 	ISequencedDocumentMessage,
 	ISnapshotTree,
@@ -153,6 +156,7 @@ export const chunksBlobName = ".chunks";
 export const electedSummarizerBlobName = ".electedSummarizer";
 export const blobsTreeName = ".blobs";
 export const idCompressorBlobName = ".idCompressor";
+export const blobHeadersBlobName = blobNameForBlobHeaders;
 
 export function rootHasIsolatedChannels(metadata?: IContainerRuntimeMetadata): boolean {
 	return !!metadata && !metadata.disableIsolatedChannels;
@@ -183,7 +187,9 @@ export const dataStoreAttributesBlobName = ".component";
  * @param summarizeResult - Summary tree and stats to modify
  *
  * @example
+ *
  * Converts from:
+ *
  * ```typescript
  * {
  *     type: SummaryType.Tree,
@@ -204,6 +210,7 @@ export const dataStoreAttributesBlobName = ".component";
  *     },
  * }
  * ```
+ *
  * And adds +1 to treeNodeCount in stats.
  */
 export function wrapSummaryInChannelsTree(summarizeResult: ISummaryTreeWithStats): void {