@fluidframework/container-loader 2.0.0-internal.4.3.1 → 2.0.0-internal.4.4.1

package/src/connectionManager.ts

@@ -325,6 +325,7 @@ export class ConnectionManager implements IConnectionManager {
 
 	private static detailsFromConnection(
 		connection: IDocumentDeltaConnection,
+		reason: string,
 	): IConnectionDetailsInternal {
 		return {
 			claims: connection.claims,
@@ -336,6 +337,7 @@ export class ConnectionManager implements IConnectionManager {
 			mode: connection.mode,
 			serviceConfiguration: connection.serviceConfiguration,
 			version: connection.version,
+			reason,
 		};
 	}
 
@@ -457,7 +459,7 @@ export class ConnectionManager implements IConnectionManager {
 			this.props.readonlyChangeHandler(this.readonly);
 			if (reconnect) {
 				// reconnect if we disconnected from before.
-				this.triggerConnect("read");
+				this.triggerConnect("Force Readonly", "read");
 			}
 		}
 	}
@@ -470,14 +472,14 @@ export class ConnectionManager implements IConnectionManager {
 		}
 	}
 
-	public connect(connectionMode?: ConnectionMode) {
-		this.connectCore(connectionMode).catch((error) => {
+	public connect(reason: string, connectionMode?: ConnectionMode) {
+		this.connectCore(reason, connectionMode).catch((error) => {
 			const normalizedError = normalizeError(error, { props: fatalConnectErrorProp });
 			this.props.closeHandler(normalizedError);
 		});
 	}
 
-	private async connectCore(connectionMode?: ConnectionMode): Promise<void> {
+	private async connectCore(reason: string, connectionMode?: ConnectionMode): Promise<void> {
 		assert(!this._disposed, 0x26a /* "not closed" */);
 
 		if (this.connection !== undefined) {
@@ -512,7 +514,7 @@ export class ConnectionManager implements IConnectionManager {
 
 		if (docService.policies?.storageOnly === true) {
 			connection = new NoDeltaStream();
-			this.setupNewSuccessfulConnection(connection, "read");
+			this.setupNewSuccessfulConnection(connection, "read", reason);
 			assert(this.pendingConnection === undefined, 0x2b3 /* "logic error" */);
 			return;
 		}
@@ -639,7 +641,7 @@ export class ConnectionManager implements IConnectionManager {
 			return;
 		}
 
-		this.setupNewSuccessfulConnection(connection, requestedMode);
+		this.setupNewSuccessfulConnection(connection, requestedMode, reason);
 	}
 
 	/**
@@ -647,7 +649,7 @@ export class ConnectionManager implements IConnectionManager {
 	 * And report the error if it escapes for any reason.
 	 * @param args - The connection arguments
 	 */
-	private triggerConnect(connectionMode: ConnectionMode) {
+	private triggerConnect(reason: string, connectionMode: ConnectionMode) {
 		// reconnect() includes async awaits, and that causes potential race conditions
 		// where we might already have a connection. If it were to happen, it's possible that we will connect
 		// with different mode to `connectionMode`. Glancing through the caller chains, it looks like code should be
@@ -658,15 +660,16 @@ export class ConnectionManager implements IConnectionManager {
 		if (this.reconnectMode !== ReconnectMode.Enabled) {
 			return;
 		}
-		this.connect(connectionMode);
+		this.connect(reason, connectionMode);
 	}
 
 	/**
 	 * Disconnect the current connection.
 	 * @param reason - Text description of disconnect reason to emit with disconnect event
+	 * @param error - Error causing the disconnect if any.
 	 * @returns A boolean that indicates if there was an existing connection (or pending connection) to disconnect
 	 */
-	private disconnectFromDeltaStream(reason: string): boolean {
+	private disconnectFromDeltaStream(reason: string, error?: IAnyDriverError): boolean {
 		this.pendingReconnect = false;
 
 		if (this.connection === undefined) {
@@ -699,7 +702,7 @@ export class ConnectionManager implements IConnectionManager {
 		this._outbound.clear();
 		connection.dispose();
 
-		this.props.disconnectHandler(reason);
+		this.props.disconnectHandler(reason, error);
 
 		this._connectionVerboseProps = {};
 
@@ -727,6 +730,7 @@ export class ConnectionManager implements IConnectionManager {
 	private setupNewSuccessfulConnection(
 		connection: IDocumentDeltaConnection,
 		requestedMode: ConnectionMode,
+		reason: string,
 	) {
 		// Old connection should have been cleaned up before establishing a new one
 		assert(
@@ -827,7 +831,7 @@ export class ConnectionManager implements IConnectionManager {
 			this.connectFirstConnection ? "InitialOps" : "ReconnectOps",
 		);
 
-		const details = ConnectionManager.detailsFromConnection(connection);
+		const details = ConnectionManager.detailsFromConnection(connection, reason);
 		details.checkpointSequenceNumber = checkpointSequenceNumber;
 		this.props.connectHandler(details);
 
@@ -894,7 +898,7 @@ export class ConnectionManager implements IConnectionManager {
 		// If we're already disconnected/disconnecting it's not appropriate to call this again.
 		assert(this.connection !== undefined, 0x0eb /* "Missing connection for reconnect" */);
 
-		this.disconnectFromDeltaStream(disconnectMessage);
+		this.disconnectFromDeltaStream(disconnectMessage, error);
 
 		// We will always trigger reconnect, even if canRetry is false.
 		// Any truly fatal error state will result in container close upon attempted reconnect,
@@ -935,7 +939,12 @@ export class ConnectionManager implements IConnectionManager {
 		// should probably live in the driver.
 		await waitForOnline();
 
-		this.triggerConnect(requestedMode);
+		this.triggerConnect(
+			error !== undefined
+				? "Reconnect on Error"
+				: `Reconnecting due to: ${disconnectMessage}`,
+			requestedMode,
+		);
 	}
 
 	public prepareMessageToSend(

package/src/connectionStateHandler.ts

@@ -10,6 +10,7 @@ import {
 } from "@fluidframework/common-definitions";
 import { assert, Timer } from "@fluidframework/common-utils";
 import { IConnectionDetailsInternal, IDeltaManager } from "@fluidframework/container-definitions";
+import { IAnyDriverError } from "@fluidframework/driver-definitions";
 import { ISequencedClient, IClient } from "@fluidframework/protocol-definitions";
 import { PerformanceEvent, loggerToMonitoringContext } from "@fluidframework/telemetry-utils";
 import { ConnectionState } from "./connectionState";
@@ -32,6 +33,7 @@ export interface IConnectionStateHandlerInputs {
 		value: ConnectionState,
 		oldState: ConnectionState,
 		reason?: string | undefined,
+		error?: IAnyDriverError,
 	) => void;
 	/** Whether to expect the client to join in write mode on next connection */
 	shouldClientJoinWrite: () => boolean;
@@ -56,7 +58,7 @@ export interface IConnectionStateHandler {
 	dispose(): void;
 	initProtocol(protocol: IProtocolHandler): void;
 	receivedConnectEvent(details: IConnectionDetailsInternal): void;
-	receivedDisconnectEvent(reason: string): void;
+	receivedDisconnectEvent(reason: string, error?: IAnyDriverError): void;
 }
 
 export function createConnectionStateHandler(
@@ -138,8 +140,8 @@ class ConnectionStateHandlerPassThrough
 	public initProtocol(protocol: IProtocolHandler) {
 		return this.pimpl.initProtocol(protocol);
 	}
-	public receivedDisconnectEvent(reason: string) {
-		return this.pimpl.receivedDisconnectEvent(reason);
+	public receivedDisconnectEvent(reason: string, error?: IAnyDriverError) {
+		return this.pimpl.receivedDisconnectEvent(reason, error);
 	}
 
 	public receivedConnectEvent(details: IConnectionDetailsInternal) {
@@ -157,8 +159,9 @@ class ConnectionStateHandlerPassThrough
 		value: ConnectionState,
 		oldState: ConnectionState,
 		reason?: string | undefined,
+		error?: IAnyDriverError,
 	) {
-		return this.inputs.connectionStateChanged(value, oldState, reason);
+		return this.inputs.connectionStateChanged(value, oldState, reason, error);
 	}
 	public shouldClientJoinWrite() {
 		return this.inputs.shouldClientJoinWrite();
@@ -200,6 +203,7 @@ class ConnectionStateCatchup extends ConnectionStateHandlerPassThrough {
 		value: ConnectionState,
 		oldState: ConnectionState,
 		reason?: string | undefined,
+		error?: IAnyDriverError,
 	) {
 		switch (value) {
 			case ConnectionState.Connected:
@@ -235,7 +239,7 @@ class ConnectionStateCatchup extends ConnectionStateHandlerPassThrough {
 			default:
 		}
 		this._connectionState = value;
-		this.inputs.connectionStateChanged(value, oldState, reason);
+		this.inputs.connectionStateChanged(value, oldState, reason, error);
 	}
 
 	private readonly transitionToConnectedState = () => {
@@ -462,9 +466,9 @@ class ConnectionStateHandler implements IConnectionStateHandler {
 		}
 	}
 
-	public receivedDisconnectEvent(reason: string) {
+	public receivedDisconnectEvent(reason: string, error?: IAnyDriverError) {
 		this.connection = undefined;
-		this.setConnectionState(ConnectionState.Disconnected, reason);
+		this.setConnectionState(ConnectionState.Disconnected, reason, error);
 	}
 
 	private shouldWaitForJoinSignal() {
@@ -507,7 +511,7 @@ class ConnectionStateHandler implements IConnectionStateHandler {
 		this._pendingClientId = details.clientId;
 
 		// IMPORTANT: Report telemetry after we set _pendingClientId, but before transitioning to Connected state
-		this.handler.connectionStateChanged(ConnectionState.CatchingUp, oldState);
+		this.handler.connectionStateChanged(ConnectionState.CatchingUp, oldState, details.reason);
 
 		// Check if we need to wait for join op/signal, and if we need to wait for leave op from previous connection.
 		// Pending clientId could have joined already (i.e. join op/signal already processed):
@@ -527,11 +531,16 @@ class ConnectionStateHandler implements IConnectionStateHandler {
 		// else - We are waiting for Leave op still, do nothing for now, we will transition to Connected later
 	}
 
-	private setConnectionState(value: ConnectionState.Disconnected, reason: string): void;
+	private setConnectionState(
+		value: ConnectionState.Disconnected,
+		reason: string,
+		error?: IAnyDriverError,
+	): void;
 	private setConnectionState(value: ConnectionState.Connected): void;
 	private setConnectionState(
 		value: ConnectionState.Disconnected | ConnectionState.Connected,
 		reason?: string,
+		error?: IAnyDriverError,
 	): void {
 		if (this.connectionState === value) {
 			// Already in the desired state - exit early
@@ -592,7 +601,7 @@ class ConnectionStateHandler implements IConnectionStateHandler {
 		}
 
 		// Report transition before we propagate event across layers
-		this.handler.connectionStateChanged(this._connectionState, oldState, reason);
+		this.handler.connectionStateChanged(this._connectionState, oldState, reason, error);
 	}
 
 	// Helper method to switch between quorum and audience.

package/src/container.ts

@@ -32,6 +32,7 @@ import {
 } from "@fluidframework/container-definitions";
 import { GenericError, UsageError } from "@fluidframework/container-utils";
 import {
+	IAnyDriverError,
 	IDocumentService,
 	IDocumentStorageService,
 	IFluidResolvedUrl,
@@ -758,11 +759,11 @@ export class Container
 		this.connectionStateHandler = createConnectionStateHandler(
 			{
 				logger: this.mc.logger,
-				connectionStateChanged: (value, oldState, reason) => {
+				connectionStateChanged: (value, oldState, reason, error) => {
 					if (value === ConnectionState.Connected) {
 						this._clientId = this.connectionStateHandler.pendingClientId;
 					}
-					this.logConnectionStateChangeTelemetry(value, oldState, reason);
+					this.logConnectionStateChangeTelemetry(value, oldState, reason, error);
 					if (this._lifecycleState === "loaded") {
 						this.propagateConnectionState(
 							false /* initial transition */,
@@ -1843,10 +1844,10 @@ export class Container
 			this.connectionStateHandler.receivedConnectEvent(details);
 		});
 
-		deltaManager.on("disconnect", (reason: string) => {
+		deltaManager.on("disconnect", (reason: string, error?: IAnyDriverError) => {
 			this.collabWindowTracker?.stopSequenceNumberUpdate();
 			if (!this.closed) {
-				this.connectionStateHandler.receivedDisconnectEvent(reason);
+				this.connectionStateHandler.receivedDisconnectEvent(reason, error);
 			}
 		});
 
@@ -1900,6 +1901,7 @@ export class Container
 		value: ConnectionState,
 		oldState: ConnectionState,
 		reason?: string,
+		error?: IAnyDriverError,
 	) {
 		// Log actual event
 		const time = performance.now();
@@ -1928,24 +1930,29 @@ export class Container
 			connectionInitiationReason = this.firstConnection ? "InitialConnect" : "AutoReconnect";
 		}
 
-		this.mc.logger.sendPerformanceEvent({
-			eventName: `ConnectionStateChange_${ConnectionState[value]}`,
-			from: ConnectionState[oldState],
-			duration,
-			durationFromDisconnected,
-			reason,
-			connectionInitiationReason,
-			pendingClientId: this.connectionStateHandler.pendingClientId,
-			clientId: this.clientId,
-			autoReconnect,
-			opsBehind,
-			online: OnlineStatus[isOnline()],
-			lastVisible:
-				this.lastVisible !== undefined ? performance.now() - this.lastVisible : undefined,
-			checkpointSequenceNumber,
-			quorumSize: this._protocolHandler?.quorum.getMembers().size,
-			...this._deltaManager.connectionProps,
-		});
+		this.mc.logger.sendPerformanceEvent(
+			{
+				eventName: `ConnectionStateChange_${ConnectionState[value]}`,
+				from: ConnectionState[oldState],
+				duration,
+				durationFromDisconnected,
+				reason,
+				connectionInitiationReason,
+				pendingClientId: this.connectionStateHandler.pendingClientId,
+				clientId: this.clientId,
+				autoReconnect,
+				opsBehind,
+				online: OnlineStatus[isOnline()],
+				lastVisible:
+					this.lastVisible !== undefined
+						? performance.now() - this.lastVisible
+						: undefined,
+				checkpointSequenceNumber,
+				quorumSize: this._protocolHandler?.quorum.getMembers().size,
+				...this._deltaManager.connectionProps,
+			},
+			error,
+		);
 
 		if (value === ConnectionState.Connected) {
 			this.firstConnection = false;

package/src/contracts.ts

@@ -20,7 +20,7 @@ import {
 	IClientDetails,
 	ISignalMessage,
 } from "@fluidframework/protocol-definitions";
-import { IContainerPackageInfo } from "@fluidframework/driver-definitions";
+import { IAnyDriverError, IContainerPackageInfo } from "@fluidframework/driver-definitions";
 
 export enum ReconnectMode {
 	Never = "Never",
@@ -95,7 +95,7 @@ export interface IConnectionManager {
 	/**
 	 * Initiates connection to relay service (noop if already connected).
 	 */
-	connect(connectionMode?: ConnectionMode): void;
+	connect(reason: string, connectionMode?: ConnectionMode): void;
 
 	/**
 	 * Disposed connection manager
@@ -139,7 +139,7 @@ export interface IConnectionManagerFactoryArgs {
 	/**
 	 * Called whenever connection to relay service is lost.
 	 */
-	readonly disconnectHandler: (reason: string) => void;
+	readonly disconnectHandler: (reason: string, error?: IAnyDriverError) => void;
 
 	/**
 	 * Called whenever new connection to rely service is established

package/src/deltaManager.ts

@@ -26,6 +26,7 @@ import {
 	IDocumentDeltaStorageService,
 	IDocumentService,
 	DriverErrorType,
+	IAnyDriverError,
 } from "@fluidframework/driver-definitions";
 import {
 	IDocumentMessage,
@@ -357,7 +358,8 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
 			reconnectionDelayHandler: (delayMs: number, error: unknown) =>
 				this.emitDelayInfo(this.deltaStreamDelayId, delayMs, error),
 			closeHandler: (error: any) => this.close(error),
-			disconnectHandler: (reason: string) => this.disconnectHandler(reason),
+			disconnectHandler: (reason: string, error?: IAnyDriverError) =>
+				this.disconnectHandler(reason, error),
 			connectHandler: (connection: IConnectionDetailsInternal) =>
 				this.connectHandler(connection),
 			pongHandler: (latency: number) => this.emit("pong", latency),
@@ -539,7 +541,7 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
 			this.fetchMissingDeltas(args.reason);
 		}
 
-		this.connectionManager.connect(args.mode);
+		this.connectionManager.connect(args.reason, args.mode);
 	}
 
 	private async getDeltas(
@@ -700,9 +702,9 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
 		}
 	}
 
-	private disconnectHandler(reason: string) {
+	private disconnectHandler(reason: string, error?: IAnyDriverError) {
 		this.messageBuffer.length = 0;
-		this.emit("disconnect", reason);
+		this.emit("disconnect", reason, error);
 	}
 
 	/**

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/container-loader";
-export const pkgVersion = "2.0.0-internal.4.3.1";
+export const pkgVersion = "2.0.0-internal.4.4.1";