@fluidframework/container-runtime 2.0.0-rc.3.0.3 → 2.0.0-rc.4.0.1

package/src/channelCollection.ts

@@ -7,14 +7,19 @@ import { AttachState } from "@fluidframework/container-definitions";
 import {
 	FluidObject,
 	IDisposable,
-	IFluidHandle,
 	IRequest,
 	IResponse,
 	ITelemetryBaseLogger,
 } from "@fluidframework/core-interfaces";
+import type { IFluidHandleInternal } from "@fluidframework/core-interfaces/internal";
 import { assert, Lazy, LazyPromise } from "@fluidframework/core-utils/internal";
 import { FluidObjectHandle } from "@fluidframework/datastore/internal";
-import { buildSnapshotTree } from "@fluidframework/driver-utils/internal";
+import {
+	buildSnapshotTree,
+	getSnapshotTree,
+	isInstanceOfISnapshot,
+} from "@fluidframework/driver-utils/internal";
+import type { ISnapshot } from "@fluidframework/driver-definitions/internal";
 import { ISequencedDocumentMessage, ISnapshotTree } from "@fluidframework/protocol-definitions";
 import {
 	IGarbageCollectionData,
@@ -168,6 +173,7 @@ export function wrapContext(context: IFluidParentContext): IFluidParentContext {
 		getAudience: (...args) => {
 			return context.getAudience(...args);
 		},
+		// back-compat, to be removed in 2.0
 		ensureNoDataModelChanges: (...args) => {
 			return context.ensureNoDataModelChanges(...args);
 		},
@@ -254,7 +260,7 @@ export class ChannelCollection implements IFluidDataStoreChannel, IDisposable {
 
 	private readonly disposeOnce = new Lazy<void>(() => this.contexts.dispose());
 
-	public readonly entryPoint: IFluidHandle<FluidObject>;
+	public readonly entryPoint: IFluidHandleInternal<FluidObject>;
 
 	public readonly containerLoadStats: {
 		// number of dataStores during loadContainer
@@ -268,7 +274,7 @@ export class ChannelCollection implements IFluidDataStoreChannel, IDisposable {
 	private dataStoresSinceLastGC: string[] = [];
 	// The handle to the container runtime. This is used mainly for GC purposes to represent outbound reference from
 	// the container runtime to other nodes.
-	private readonly containerRuntimeHandle: IFluidHandle;
+	private readonly containerRuntimeHandle: IFluidHandleInternal;
 	private readonly pendingAliasMap: Map<string, Promise<AliasResult>> = new Map<
 		string,
 		Promise<AliasResult>
@@ -278,7 +284,7 @@ export class ChannelCollection implements IFluidDataStoreChannel, IDisposable {
 	private readonly aliasedDataStores: Set<string>;
 
 	constructor(
-		protected readonly baseSnapshot: ISnapshotTree | undefined,
+		protected readonly baseSnapshot: ISnapshotTree | ISnapshot | undefined,
 		public readonly parentContext: IFluidParentContext,
 		baseLogger: ITelemetryBaseLogger,
 		private readonly gcNodeUpdated: (props: IGCNodeUpdatedProps) => void,
@@ -303,7 +309,8 @@ export class ChannelCollection implements IFluidDataStoreChannel, IDisposable {
 		// Extract stores stored inside the snapshot
 		const fluidDataStores = new Map<string, ISnapshotTree>();
 		if (baseSnapshot) {
-			for (const [key, value] of Object.entries(baseSnapshot.trees)) {
+			const baseSnapshotTree = getSnapshotTree(baseSnapshot);
+			for (const [key, value] of Object.entries(baseSnapshotTree.trees)) {
 				fluidDataStores.set(key, value);
 			}
 		}
@@ -319,9 +326,16 @@ export class ChannelCollection implements IFluidDataStoreChannel, IDisposable {
 			}
 			// If we have a detached container, then create local data store contexts.
 			if (this.parentContext.attachState !== AttachState.Detached) {
+				let snapshotForRemoteFluidDatastoreContext: ISnapshot | ISnapshotTree = value;
+				if (isInstanceOfISnapshot(baseSnapshot)) {
+					snapshotForRemoteFluidDatastoreContext = {
+						...baseSnapshot,
+						snapshotTree: value,
+					};
+				}
 				dataStoreContext = new RemoteFluidDataStoreContext({
 					id: key,
-					snapshotTree: value,
+					snapshot: snapshotForRemoteFluidDatastoreContext,
 					parentContext: this.wrapContextForInnerChannel(key),
 					storage: this.parentContext.storage,
 					scope: this.parentContext.scope,
@@ -442,9 +456,12 @@ export class ChannelCollection implements IFluidDataStoreChannel, IDisposable {
 		}
 
 		const flatAttachBlobs = new Map<string, ArrayBufferLike>();
-		let snapshotTree: ISnapshotTree | undefined;
+		let snapshot: ISnapshotTree | ISnapshot | undefined;
 		if (attachMessage.snapshot) {
-			snapshotTree = buildSnapshotTree(attachMessage.snapshot.entries, flatAttachBlobs);
+			snapshot = buildSnapshotTree(attachMessage.snapshot.entries, flatAttachBlobs);
+			if (isInstanceOfISnapshot(this.baseSnapshot)) {
+				snapshot = { ...this.baseSnapshot, snapshotTree: snapshot };
+			}
 		}
 
 		// Include the type of attach message which is the pkg of the store to be
@@ -452,7 +469,7 @@ export class ChannelCollection implements IFluidDataStoreChannel, IDisposable {
 		const pkg = [attachMessage.type];
 		const remoteFluidDataStoreContext = new RemoteFluidDataStoreContext({
 			id: attachMessage.id,
-			snapshotTree,
+			snapshot,
 			parentContext: this.wrapContextForInnerChannel(attachMessage.id),
 			storage: new StorageServiceWithAttachBlobs(this.parentContext.storage, flatAttachBlobs),
 			scope: this.parentContext.scope,
@@ -562,8 +579,8 @@ export class ChannelCollection implements IFluidDataStoreChannel, IDisposable {
 		 * If the container is detached, this data store will be part of the summary that makes the container attached.
 		 */
 		if (this.parentContext.attachState !== AttachState.Detached) {
-			localContext.setAttachState(AttachState.Attaching);
 			this.submitAttachChannelOp(localContext);
+			localContext.setAttachState(AttachState.Attaching);
 		}
 
 		this.contexts.bind(id);
@@ -643,6 +660,7 @@ export class ChannelCollection implements IFluidDataStoreChannel, IDisposable {
 		createProps?: any,
 		loadingGroupId?: string,
 	) {
+		assert(loadingGroupId !== "", 0x974 /* loadingGroupId should not be the empty string */);
 		const context = new contextCtor({
 			id,
 			pkg,
@@ -1152,7 +1170,7 @@ export class ChannelCollection implements IFluidDataStoreChannel, IDisposable {
 							0x166 /* "BaseSnapshot should be there as detached container loaded from snapshot" */,
 						);
 						dataStoreSummary = convertSnapshotTreeToSummaryTree(
-							this.baseSnapshot.trees[key],
+							getSnapshotTree(this.baseSnapshot).trees[key],
 						);
 					}
 					builder.addWithStats(key, dataStoreSummary);

package/src/connectionTelemetry.ts

@@ -4,18 +4,19 @@
  */
 
 import { performance } from "@fluid-internal/client-utils";
-import { IDeltaManager } from "@fluidframework/container-definitions";
+import { IDeltaManager } from "@fluidframework/container-definitions/internal";
 import { IContainerRuntimeEvents } from "@fluidframework/container-runtime-definitions/internal";
 import { IEventProvider } from "@fluidframework/core-interfaces";
 import { assert } from "@fluidframework/core-utils/internal";
+import { isRuntimeMessage } from "@fluidframework/driver-utils/internal";
 import {
 	IDocumentMessage,
 	ISequencedDocumentMessage,
 	MessageType,
 } from "@fluidframework/protocol-definitions";
-import { ITelemetryLoggerExt } from "@fluidframework/telemetry-utils";
 import {
 	IEventSampler,
+	ITelemetryLoggerExt,
 	ISampledTelemetryLogger,
 	createChildLogger,
 	createSampledLogger,
@@ -80,6 +81,11 @@ class OpPerfTelemetry {
 	private connectionStartTime = 0;
 	private gap = 0;
 
+	/** Count of no-ops sent by this client. This variable is reset everytime the OpStats sampled event is logged */
+	private noOpCountForTelemetry = 0;
+	/** Cumulative size of the ops processed by this client. This variable is reset everytime the OpStats sampled event is logged */
+	private processedOpSizeForTelemetry = 0;
+
 	private readonly logger: ITelemetryLoggerExt;
 
 	private static readonly OP_LATENCY_SAMPLE_RATE = 500;
@@ -88,6 +94,9 @@ class OpPerfTelemetry {
 	private static readonly DELTA_LATENCY_SAMPLE_RATE = 100;
 	private readonly deltaLatencyLogger: ISampledTelemetryLogger;
 
+	private static readonly PROCESSED_OPS_SAMPLE_RATE = 500;
+	private readonly opsLogger: ISampledTelemetryLogger;
+
 	/**
 	 * Create an instance of OpPerfTelemetry which starts monitoring and generating telemetry related to op performance.
 	 *
@@ -142,11 +151,27 @@ class OpPerfTelemetry {
 		// due to complexity of the different asynchronus scenarios of the op message lifecycle.
 		this.opLatencyLogger = createSampledLogger(logger);
 
+		const opsEventSampler: IEventSampler = (() => {
+			let eventCount = 0;
+			return {
+				sample: () => {
+					eventCount++;
+					const shouldSample =
+						eventCount % OpPerfTelemetry.PROCESSED_OPS_SAMPLE_RATE === 0;
+					if (shouldSample) {
+						eventCount = 0;
+						this.noOpCountForTelemetry = 0;
+						this.processedOpSizeForTelemetry = 0;
+					}
+					return shouldSample;
+				},
+			};
+		})();
+		this.opsLogger = createSampledLogger(logger, opsEventSampler);
+
 		this.deltaManager.on("pong", (latency) => this.recordPingTime(latency));
 		this.deltaManager.on("submitOp", (message) => this.beforeOpSubmit(message));
-
 		this.deltaManager.on("op", (message) => this.afterProcessingOp(message));
-
 		this.deltaManager.on("connect", (details, opsBehind) => {
 			if (opsBehind !== undefined) {
 				this.connectionOpSeqNumber = this.deltaManager.lastKnownSeqNumber;
@@ -226,6 +251,9 @@ class OpPerfTelemetry {
 					latencyStats.opPerfData.lengthInboundQueue = this.deltaManager.inbound.length;
 				}
 			}
+			if (isRuntimeMessage(message) && typeof message.contents === "string") {
+				this.processedOpSizeForTelemetry += message.contents.length;
+			}
 		});
 
 		this.deltaManager.inbound.on("idle", (count: number, duration: number) => {
@@ -302,6 +330,12 @@ class OpPerfTelemetry {
 				opPerfData: {},
 			});
 		}
+
+		if (message.type === MessageType.NoOp) {
+			// Count the number of no-ops submitted by this client.
+			// The value is reset when we log the OpStats sampled event.
+			this.noOpCountForTelemetry++;
+		}
 	}
 
 	private afterProcessingOp(message: ISequencedDocumentMessage) {
@@ -335,6 +369,7 @@ class OpPerfTelemetry {
 
 		if (
 			this.clientId === message.clientId &&
+			message.type === MessageType.Operation &&
 			(this.opLatencyLogger.isSamplingDisabled ||
 				this.clientSequenceNumberForLatencyStatistics === message.clientSequenceNumber)
 		) {
@@ -372,9 +407,29 @@ class OpPerfTelemetry {
 					this.deltaManager.lastSequenceNumber - this.deltaManager.minimumSequenceNumber,
 				...latencyData.opPerfData,
 			});
+
 			this.clientSequenceNumberForLatencyStatistics = undefined;
 			this.latencyStatistics.delete(message.clientSequenceNumber);
 		}
+
+		if (isRuntimeMessage(message)) {
+			// Sampled logging of Ops that have been processed by the current client, the NoOp sent and the
+			// size of the ops processed within one sampling window of this log event.
+			// This data will be used to monitor the efficiency of NoOp-heuristics or to get approximate collab window size.
+			this.opsLogger.sendPerformanceEvent({
+				eventName: "OpStats",
+				// Logging as 'details' property to avoid adding new column name to the log tables */
+				details: {
+					// Count of the ops processed by the current client. Note: these counts are after
+					// compression/grouping/chunking (if enabled) of the ops.
+					processedOpCount: OpPerfTelemetry.PROCESSED_OPS_SAMPLE_RATE,
+					// Cumulative size of all the ops processed by the current client since the last OpStats event log
+					processedOpSize: this.processedOpSizeForTelemetry,
+					// Count of all the NoOp sent by the current client since the last OpStats event log
+					submitedNoOpCount: this.noOpCountForTelemetry,
+				},
+			});
+		}
 	}
 }
 export interface IPerfSignalReport {