@fluidframework/container-runtime 2.0.0-dev-rc.3.0.0.254866 → 2.0.0-dev-rc.4.0.0.261659

package/src/summary/documentSchema.ts

@@ -228,7 +228,10 @@ const documentSchemaSupportedConfigs = {
  * If schema is not compatible with current code, it throws an exception.
  * @param documentSchema - current schema
  */
-function checkRuntimeCompatibility(documentSchema?: IDocumentSchema) {
+function checkRuntimeCompatibility(
+	documentSchema: IDocumentSchema | undefined,
+	schemaName: string,
+) {
 	// Back-compat - we can't do anything about legacy documents.
 	// There is no way to validate them, so we are taking a guess that safe deployment processes used by a given app
 	// do not run into compat problems.
@@ -245,6 +248,7 @@ function checkRuntimeCompatibility(documentSchema?: IDocumentSchema) {
 			{
 				runtimeSchemaVersion: documentSchema.version,
 				currentRuntimeSchemaVersion: currentDocumentVersionSchema,
+				schemaName,
 			},
 		);
 	}
@@ -276,6 +280,7 @@ function checkRuntimeCompatibility(documentSchema?: IDocumentSchema) {
 				codeVersion: currentDocumentVersionSchema,
 				property: unknownProperty,
 				value,
+				schemaName,
 			},
 		);
 	}
@@ -432,8 +437,8 @@ export class DocumentsSchemaController {
 	private futureSchema: IDocumentSchemaCurrent | undefined;
 
 	// Current schema this session operates with.
-	// 1) Legacy mode: this is same as desired schema - all options that were requested to be on are on, and all options requested to be off are off.
-	// 2) Non-legacy mode: this is AND() of document schema and desired schema. Only options that are enabled in both are enabled here.
+	// 1) Legacy mode (explicitSchemaControl === false): this is same as desired schema - all options that were requested to be on are on, and all options requested to be off are off.
+	// 2) Non-legacy mode (explicitSchemaControl === true): this is AND() of document schema and desired schema. Only options that are enabled in both are enabled here.
 	//    If there are any options that are not enabled in document schema, but are enabled in desired schema, then attempt to change schema
 	//    (and enable such options) will be made through the session.
 	public sessionSchema: IDocumentSchemaCurrent;
@@ -447,16 +452,15 @@ export class DocumentsSchemaController {
 	 */
 	constructor(
 		existing: boolean,
+		snapshotSequenceNumber: number,
 		documentMetadataSchema: IDocumentSchema | undefined,
 		features: IDocumentSchemaFeatures,
 		private readonly onSchemaChange: (schema: IDocumentSchemaCurrent) => void,
 	) {
-		checkRuntimeCompatibility(documentMetadataSchema);
-
 		// For simplicity, let's only support new schema features for explicit schema control mode
 		assert(
 			features.disallowedVersions.length === 0 || features.explicitSchemaControl,
-			"not supported",
+			0x949 /* not supported */,
 		);
 
 		// Desired schema by this session - almost all props are coming from arguments
@@ -491,6 +495,9 @@ export class DocumentsSchemaController {
 					},
 			  } satisfies IDocumentSchemaCurrent);
 
+		checkRuntimeCompatibility(this.documentSchema, "document");
+		this.validateSeqNumber(this.documentSchema.refSeq, snapshotSequenceNumber, "summary");
+
 		// Use legacy behavior only if both document and options tell us to use legacy.
 		// Otherwise it's no longer legacy time!
 		this.explicitSchemaControl =
@@ -505,22 +512,23 @@ export class DocumentsSchemaController {
 			assert(
 				boolToProp(this.explicitSchemaControl) ===
 					this.sessionSchema.runtime.explicitSchemaControl,
-				"explicitSchemaControl",
+				0x94a /* explicitSchemaControl */,
 			);
 			this.futureSchema = undefined;
 		} else {
 			this.sessionSchema = and(this.documentSchema, this.desiredSchema);
 			this.futureSchema = or(this.documentSchema, this.desiredSchema);
-			assert(this.sessionSchema.runtime.explicitSchemaControl === true, "legacy");
-			assert(this.futureSchema.runtime.explicitSchemaControl === true, "legacy");
+			assert(this.sessionSchema.runtime.explicitSchemaControl === true, 0x94b /* legacy */);
+			assert(this.futureSchema.runtime.explicitSchemaControl === true, 0x94c /* legacy */);
 			if (same(this.documentSchema, this.futureSchema)) {
 				this.futureSchema = undefined;
 			}
 		}
 
 		// Validate that schema we are operating in is actually a schema we consider compatible with current runtime.
-		checkRuntimeCompatibility(this.sessionSchema);
-		checkRuntimeCompatibility(this.futureSchema);
+		checkRuntimeCompatibility(this.desiredSchema, "desired");
+		checkRuntimeCompatibility(this.sessionSchema, "session");
+		checkRuntimeCompatibility(this.futureSchema, "future");
 	}
 
 	public summarizeDocumentSchema(refSeq: number): IDocumentSchemaCurrent | undefined {
@@ -537,7 +545,10 @@ export class DocumentsSchemaController {
 		// race conditions. If we put any other number (including latest seq number), then we will have two clients
 		// (loading from two different summaries) with different numbers, and eventual consistency will be broken as schema
 		// change ops will be interpretted differently by those two clients.
-		assert(this.explicitSchemaControl || schema.refSeq === 0, "refSeq should be zero");
+		assert(
+			this.explicitSchemaControl || schema.refSeq === 0,
+			0x94d /* refSeq should be zero */,
+		);
 
 		return schema;
 	}
@@ -545,21 +556,37 @@ export class DocumentsSchemaController {
 	/**
 	 * Called by Container runtime whenever it is about to send some op.
 	 * It gives opportunity for controller to issue its own ops - we do not want to send ops if there are no local changes in document.
+	 * Please consider note above constructor about race conditions - current design is to send op only once in a session lifetime.
 	 * @returns Optional message to send.
 	 */
 	public maybeSendSchemaMessage(): IDocumentSchemaChangeMessage | undefined {
 		if (this.sendOp && this.futureSchema !== undefined) {
+			this.sendOp = false;
 			assert(
 				this.explicitSchemaControl &&
 					this.futureSchema.runtime.explicitSchemaControl === true,
-				"not legacy",
+				0x94e /* not legacy */,
 			);
 			return {
 				...this.futureSchema,
 				refSeq: this.documentSchema.refSeq,
 			};
 		}
-		this.sendOp = false;
+	}
+
+	private validateSeqNumber(schemaSeqNumber: number, lastKnowSeqNumber, message: string) {
+		if (!Number.isInteger(schemaSeqNumber) || !(schemaSeqNumber <= lastKnowSeqNumber)) {
+			throw DataProcessingError.create(
+				"DocSchema: Incorrect sequence number",
+				"checkRuntimeCompat3",
+				undefined, // message
+				{
+					schemaSeqNumber,
+					sequenceNumber: lastKnowSeqNumber,
+					message,
+				},
+			);
+		}
 	}
 
 	/**
@@ -575,8 +602,14 @@ export class DocumentsSchemaController {
 		local: boolean,
 		sequenceNumber: number,
 	) {
-		assert(content.refSeq <= this.documentSchema.refSeq, "did we lose a message somewhere?");
-		assert(this.documentSchema.refSeq < sequenceNumber, "time should move forward only!");
+		this.validateSeqNumber(content.refSeq, this.documentSchema.refSeq, "content.refSeq");
+		this.validateSeqNumber(this.documentSchema.refSeq, sequenceNumber, "refSeq");
+		// validate is strickly less, not equal
+		assert(
+			this.documentSchema.refSeq < sequenceNumber,
+			0x950 /* time should move forward only! */,
+		);
+
 		if (content.refSeq !== this.documentSchema.refSeq) {
 			// CAS failed
 			return false;
@@ -586,15 +619,16 @@ export class DocumentsSchemaController {
 		// This will ensure we do not trip on our own messages that are no longer wanted as we processed someone else schema change message.
 		assert(
 			!local || (this.explicitSchemaControl && this.futureSchema !== undefined),
-			"not sending ops",
+			0x951 /* not sending ops */,
 		);
 
 		// Changes are in effect. Immediately check that this client understands these changes
-		checkRuntimeCompatibility(content);
+		checkRuntimeCompatibility(content, "change");
 
 		const schema: IDocumentSchema = { ...content, refSeq: sequenceNumber };
 		this.documentSchema = schema as IDocumentSchemaCurrent;
 		this.sessionSchema = and(this.documentSchema, this.desiredSchema);
+		assert(this.sessionSchema.refSeq === sequenceNumber, "seq#");
 
 		// legacy behavior is automatically off for the document once someone sends a schema op -
 		// from now on it's fully controlled by ops.

package/src/summary/orderedClientElection.ts

@@ -10,8 +10,11 @@ import { IDeltaManager } from "@fluidframework/container-definitions";
 import { IEvent, IEventProvider, ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
 import { assert } from "@fluidframework/core-utils/internal";
 import { IClient, IQuorumClients, ISequencedClient } from "@fluidframework/protocol-definitions";
-import { ITelemetryLoggerExt } from "@fluidframework/telemetry-utils";
-import { UsageError, createChildLogger } from "@fluidframework/telemetry-utils/internal";
+import {
+	ITelemetryLoggerExt,
+	UsageError,
+	createChildLogger,
+} from "@fluidframework/telemetry-utils/internal";
 
 import { summarizerClientType } from "./summarizerClientElection.js";
 

package/src/summary/summarizer.ts

@@ -6,9 +6,9 @@
 import { TypedEventEmitter } from "@fluid-internal/client-utils";
 import { IFluidHandleContext } from "@fluidframework/core-interfaces";
 import { Deferred } from "@fluidframework/core-utils/internal";
-import { ITelemetryLoggerExt } from "@fluidframework/telemetry-utils";
 import {
 	IFluidErrorBase,
+	ITelemetryLoggerExt,
 	LoggingError,
 	UsageError,
 	createChildLogger,

package/src/summary/summarizerClientElection.ts

@@ -6,7 +6,7 @@
 import { TypedEventEmitter } from "@fluid-internal/client-utils";
 import { IEvent, IEventProvider } from "@fluidframework/core-interfaces";
 import { IClientDetails, MessageType } from "@fluidframework/protocol-definitions";
-import { ITelemetryLoggerExt } from "@fluidframework/telemetry-utils";
+import { ITelemetryLoggerExt } from "@fluidframework/telemetry-utils/internal";
 
 import {
 	IOrderedClientElection,

package/src/summary/summarizerHeuristics.ts

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

package/src/summary/summarizerNode/summarizerNode.ts

@@ -23,8 +23,9 @@ import {
 	SummarizeInternalFn,
 } from "@fluidframework/runtime-definitions/internal";
 import { mergeStats } from "@fluidframework/runtime-utils/internal";
-import { type ITelemetryErrorEventExt, ITelemetryLoggerExt } from "@fluidframework/telemetry-utils";
+import { type ITelemetryErrorEventExt } from "@fluidframework/telemetry-utils/internal";
 import {
+	ITelemetryLoggerExt,
 	LoggingError,
 	PerformanceEvent,
 	TelemetryDataTag,
@@ -310,12 +311,11 @@ export class SummarizerNode implements IRootSummarizerNode {
 	 * 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.
 	 */
-	public completeSummary(proposalHandle: string, validate: boolean) {
+	public completeSummary(proposalHandle: string) {
 		this.completeSummaryCore(
 			proposalHandle,
 			undefined /* parentPath */,
 			false /* parentSkipRecursion */,
-			validate,
 		);
 	}
 
@@ -331,15 +331,7 @@ export class SummarizerNode implements IRootSummarizerNode {
 		proposalHandle: string,
 		parentPath: EscapedPath | undefined,
 		parentSkipRecursion: boolean,
-		validate: boolean,
 	) {
-		if (validate && this.wasSummarizeMissed(parentSkipRecursion)) {
-			this.throwUnexpectedError({
-				eventName: "NodeDidNotSummarize",
-				proposalHandle,
-			});
-		}
-
 		assert(this.wipReferenceSequenceNumber !== undefined, 0x1a4 /* "Not tracking a summary" */);
 		let localPathsToUse = this.wipLocalPaths;
 
@@ -382,7 +374,6 @@ export class SummarizerNode implements IRootSummarizerNode {
 				proposalHandle,
 				fullPathForChildren,
 				this.wipSkipRecursion || parentSkipRecursion,
-				validate,
 			);
 		}
 		// Note that this overwrites existing pending summary with

package/src/summary/summarizerNode/summarizerNodeUtils.ts

@@ -5,8 +5,7 @@
 
 import { ISnapshotTree, SummaryObject } from "@fluidframework/protocol-definitions";
 import { channelsTreeName } from "@fluidframework/runtime-definitions/internal";
-import { ITelemetryLoggerExt } from "@fluidframework/telemetry-utils";
-import { TelemetryDataTag } from "@fluidframework/telemetry-utils/internal";
+import { ITelemetryLoggerExt, TelemetryDataTag } from "@fluidframework/telemetry-utils/internal";
 
 export interface IRefreshSummaryResult {
 	/** Tells whether this summary is tracked by this client. */
@@ -53,7 +52,7 @@ export interface ISummarizerNodeRootContract {
 		latestSummaryRefSeqNum: number,
 	): IStartSummaryResult;
 	validateSummary(): ValidateSummaryResult;
-	completeSummary(proposalHandle: string, validate: boolean): void;
+	completeSummary(proposalHandle: string): void;
 	clearSummary(): void;
 	refreshLatestSummary(
 		proposalHandle: string,

package/src/summary/summarizerNode/summarizerNodeWithGc.ts

@@ -306,28 +306,19 @@ export class SummarizerNodeWithGC extends SummarizerNode implements IRootSummari
 	 * @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;
 		}
 
-		super.completeSummaryCore(proposalHandle, parentPath, parentSkipRecursion, validate);
+		super.completeSummaryCore(proposalHandle, parentPath, parentSkipRecursion);
 
 		// If GC is disabled, skip setting pending summary with GC state.
 		if (!this.gcDisabled) {

package/src/summary/summarizerTypes.ts

@@ -12,8 +12,10 @@ import {
 	ISummaryTree,
 } from "@fluidframework/protocol-definitions";
 import { ISummaryStats } from "@fluidframework/runtime-definitions";
-import { ITelemetryLoggerExt } from "@fluidframework/telemetry-utils";
-import { ITelemetryLoggerPropertyBag } from "@fluidframework/telemetry-utils/internal";
+import {
+	ITelemetryLoggerExt,
+	ITelemetryLoggerPropertyBag,
+} from "@fluidframework/telemetry-utils/internal";
 
 import { ISummaryConfigurationHeuristics } from "../containerRuntime.js";
 
@@ -189,7 +191,7 @@ export interface IGeneratedSummaryStats extends ISummaryStats {
 export interface IBaseSummarizeResult {
 	readonly stage: "base";
 	/** Error object related to failed summarize attempt. */
-	readonly error: any;
+	readonly error: Error | undefined;
 	/** Reference sequence number as of the generate summary attempt. */
 	readonly referenceSequenceNumber: number;
 	readonly minimumSequenceNumber: number;

package/src/summary/summaryCollection.ts

@@ -15,7 +15,7 @@ import {
 	ISummaryNack,
 	MessageType,
 } from "@fluidframework/protocol-definitions";
-import { ITelemetryLoggerExt } from "@fluidframework/telemetry-utils";
+import { ITelemetryLoggerExt } from "@fluidframework/telemetry-utils/internal";
 
 /**
  * Interface for summary op messages with typed contents.

package/src/summary/summaryGenerator.ts

@@ -14,8 +14,13 @@ import {
 import { DriverErrorTypes } from "@fluidframework/driver-definitions";
 import { getRetryDelaySecondsFromError } from "@fluidframework/driver-utils/internal";
 import { MessageType } from "@fluidframework/protocol-definitions";
-import { ITelemetryLoggerExt } from "@fluidframework/telemetry-utils";
-import { LoggingError, PerformanceEvent } from "@fluidframework/telemetry-utils/internal";
+import {
+	isFluidError,
+	ITelemetryLoggerExt,
+	LoggingError,
+	PerformanceEvent,
+	wrapError,
+} from "@fluidframework/telemetry-utils/internal";
 
 import {
 	IAckSummaryResult,
@@ -269,7 +274,7 @@ export class SummaryGenerator {
 		 */
 		const fail = (
 			errorCode: keyof typeof summarizeErrors,
-			error?: any,
+			error?: Error,
 			properties?: SummaryGeneratorTelemetry,
 			submitFailureResult?: SubmitSummaryFailureData,
 			nackSummaryResult?: INackSummaryResult,
@@ -278,7 +283,8 @@ export class SummaryGenerator {
 			// If failure happened on upload, we may not yet realized that socket disconnected, so check
 			// offlineError too.
 			const category =
-				cancellationToken.cancelled || error?.errorType === DriverErrorTypes.offlineError
+				cancellationToken.cancelled ||
+				(isFluidError(error) && error?.errorType === DriverErrorTypes.offlineError)
 					? "generic"
 					: "error";
 
@@ -360,10 +366,15 @@ export class SummaryGenerator {
 			summarizeEvent.reportEvent("generate", { ...summarizeTelemetryProps });
 			resultsBuilder.summarySubmitted.resolve({ success: true, data: summaryData });
 		} catch (error) {
-			return fail("submitSummaryFailure", error, undefined /* properties */, {
-				stage: "unknown",
-				retryAfterSeconds: getRetryDelaySecondsFromError(error),
-			});
+			return fail(
+				"submitSummaryFailure",
+				wrapError(error, (message) => new LoggingError(message)),
+				undefined /* properties */,
+				{
+					stage: "unknown",
+					retryAfterSeconds: getRetryDelaySecondsFromError(error),
+				},
+			);
 		} finally {
 			if (summaryData === undefined) {
 				this.heuristicData.recordAttempt();

package/src/summary/summaryManager.ts

@@ -12,8 +12,11 @@ import {
 } from "@fluidframework/core-interfaces";
 import { assert } from "@fluidframework/core-utils/internal";
 import { DriverErrorTypes } from "@fluidframework/driver-definitions";
-import { ITelemetryLoggerExt } from "@fluidframework/telemetry-utils";
-import { PerformanceEvent, createChildLogger } from "@fluidframework/telemetry-utils/internal";
+import {
+	ITelemetryLoggerExt,
+	PerformanceEvent,
+	createChildLogger,
+} from "@fluidframework/telemetry-utils/internal";
 
 import { IThrottler } from "../throttler.js";