@fluidframework/container-loader 2.0.0-internal.6.0.0 → 2.0.0-internal.6.1.1

package/src/connectionManager.ts

@@ -48,6 +48,7 @@ import {
 	IConnectionManager,
 	IConnectionManagerFactoryArgs,
 	IConnectionDetailsInternal,
+	IConnectionStateChangeReason,
 } from "./contracts";
 import { DeltaQueue } from "./deltaQueue";
 import { SignalType } from "./protocol";
@@ -336,7 +337,7 @@ export class ConnectionManager implements IConnectionManager {
 
 	private static detailsFromConnection(
 		connection: IDocumentDeltaConnection,
-		reason: string,
+		reason: IConnectionStateChangeReason,
 	): IConnectionDetailsInternal {
 		return {
 			claims: connection.claims,
@@ -389,7 +390,10 @@ export class ConnectionManager implements IConnectionManager {
 
 		this._outbound.clear();
 
-		const disconnectReason = "Closing DeltaManager";
+		const disconnectReason: IConnectionStateChangeReason = {
+			text: "Closing DeltaManager",
+			error,
+		};
 
 		// This raises "disconnect" event if we have active connection.
 		this.disconnectFromDeltaStream(disconnectReason);
@@ -406,7 +410,7 @@ export class ConnectionManager implements IConnectionManager {
 	 * Enables or disables automatic reconnecting.
 	 * Will throw an error if reconnectMode set to Never.
 	 */
-	public setAutoReconnect(mode: ReconnectMode): void {
+	public setAutoReconnect(mode: ReconnectMode, reason: IConnectionStateChangeReason): void {
 		assert(
 			mode !== ReconnectMode.Never && this._reconnectMode !== ReconnectMode.Never,
 			0x278 /* "API is not supported for non-connecting or closed container" */,
@@ -416,7 +420,7 @@ export class ConnectionManager implements IConnectionManager {
 
 		if (mode !== ReconnectMode.Enabled) {
 			// immediately disconnect - do not rely on service eventually dropping connection.
-			this.disconnectFromDeltaStream("setAutoReconnect");
+			this.disconnectFromDeltaStream(reason);
 		}
 	}
 
@@ -463,12 +467,12 @@ export class ConnectionManager implements IConnectionManager {
 					this.logger.sendErrorEvent({ eventName: "ForceReadonlyPendingChanged" });
 				}
 
-				reconnect = this.disconnectFromDeltaStream("Force readonly");
+				reconnect = this.disconnectFromDeltaStream({ text: "Force readonly" });
 			}
 			this.props.readonlyChangeHandler(this.readonly);
 			if (reconnect) {
 				// reconnect if we disconnected from before.
-				this.triggerConnect("Force Readonly", "read");
+				this.triggerConnect({ text: "Force Readonly" }, "read");
 			}
 		}
 	}
@@ -481,14 +485,17 @@ export class ConnectionManager implements IConnectionManager {
 		}
 	}
 
-	public connect(reason: string, connectionMode?: ConnectionMode) {
-		this.connectCore(reason, connectionMode).catch((error) => {
-			const normalizedError = normalizeError(error, { props: fatalConnectErrorProp });
+	public connect(reason: IConnectionStateChangeReason, connectionMode?: ConnectionMode) {
+		this.connectCore(reason, connectionMode).catch((e) => {
+			const normalizedError = normalizeError(e, { props: fatalConnectErrorProp });
 			this.props.closeHandler(normalizedError);
 		});
 	}
 
-	private async connectCore(reason: string, connectionMode?: ConnectionMode): Promise<void> {
+	private async connectCore(
+		reason: IConnectionStateChangeReason,
+		connectionMode?: ConnectionMode,
+	): Promise<void> {
 		assert(!this._disposed, 0x26a /* "not closed" */);
 
 		if (this.connection !== undefined) {
@@ -664,7 +671,7 @@ export class ConnectionManager implements IConnectionManager {
 	 * And report the error if it escapes for any reason.
 	 * @param args - The connection arguments
 	 */
-	private triggerConnect(reason: string, connectionMode: ConnectionMode) {
+	private triggerConnect(reason: IConnectionStateChangeReason, 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
@@ -684,7 +691,7 @@ export class ConnectionManager implements IConnectionManager {
 	 * @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, error?: IAnyDriverError): boolean {
+	private disconnectFromDeltaStream(reason: IConnectionStateChangeReason): boolean {
 		this.pendingReconnect = false;
 
 		if (this.connection === undefined) {
@@ -717,7 +724,7 @@ export class ConnectionManager implements IConnectionManager {
 		this._outbound.clear();
 		connection.dispose();
 
-		this.props.disconnectHandler(reason, error);
+		this.props.disconnectHandler(reason);
 
 		this._connectionVerboseProps = {};
 
@@ -727,7 +734,7 @@ export class ConnectionManager implements IConnectionManager {
 	/**
 	 * Cancel in-progress connection attempt.
 	 */
-	private cancelConnection(reason: string) {
+	private cancelConnection(reason: IConnectionStateChangeReason) {
 		assert(
 			this.pendingConnection !== undefined,
 			0x345 /* this.pendingConnection is undefined when trying to cancel */,
@@ -735,7 +742,10 @@ export class ConnectionManager implements IConnectionManager {
 		this.pendingConnection.abort();
 		this.pendingConnection = undefined;
 		this.logger.sendTelemetryEvent({ eventName: "ConnectionCancelReceived" });
-		this.props.cancelConnectionHandler(`Cancel Pending Connection due to ${reason}`);
+		this.props.cancelConnectionHandler({
+			text: `Cancel Pending Connection due to ${reason.text}`,
+			error: reason.error,
+		});
 	}
 
 	/**
@@ -746,7 +756,7 @@ export class ConnectionManager implements IConnectionManager {
 	private setupNewSuccessfulConnection(
 		connection: IDocumentDeltaConnection,
 		requestedMode: ConnectionMode,
-		reason: string,
+		reason: IConnectionStateChangeReason,
 	) {
 		// Old connection should have been cleaned up before establishing a new one
 		assert(
@@ -789,7 +799,7 @@ export class ConnectionManager implements IConnectionManager {
 
 		if (this._disposed) {
 			// Raise proper events, Log telemetry event and close connection.
-			this.disconnectFromDeltaStream("ConnectionManager already closed");
+			this.disconnectFromDeltaStream({ text: "ConnectionManager already closed" });
 			return;
 		}
 
@@ -894,7 +904,9 @@ export class ConnectionManager implements IConnectionManager {
 	 * @returns A promise that resolves when the connection is reestablished or we stop trying
 	 */
 	private reconnectOnError(requestedMode: ConnectionMode, error: IAnyDriverError) {
-		this.reconnect(requestedMode, error.message, error).catch(this.props.closeHandler);
+		this.reconnect(requestedMode, { text: error.message, error }).catch(
+			this.props.closeHandler,
+		);
 	}
 
 	/**
@@ -906,26 +918,25 @@ export class ConnectionManager implements IConnectionManager {
 	 */
 	private async reconnect(
 		requestedMode: ConnectionMode,
-		disconnectMessage: string,
-		error?: IAnyDriverError,
+		reason: IConnectionStateChangeReason<IAnyDriverError>,
 	) {
 		// We quite often get protocol errors before / after observing nack/disconnect
 		// we do not want to run through same sequence twice.
 		// 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, error);
+		this.disconnectFromDeltaStream(reason);
 
 		// We will always trigger reconnect, even if canRetry is false.
 		// Any truly fatal error state will result in container close upon attempted reconnect,
 		// which is a preferable to closing abruptly when a live connection fails.
-		if (error !== undefined && !error.canRetry) {
+		if (reason.error?.canRetry === false) {
 			this.logger.sendTelemetryEvent(
 				{
 					eventName: "reconnectingDespiteFatalError",
 					reconnectMode: this.reconnectMode,
 				},
-				error,
+				reason.error,
 			);
 		}
 
@@ -942,9 +953,9 @@ export class ConnectionManager implements IConnectionManager {
 		}
 
 		// If the error tells us to wait before retrying, then do so.
-		const delayMs = getRetryDelayFromError(error);
-		if (error !== undefined && delayMs !== undefined) {
-			this.props.reconnectionDelayHandler(delayMs, error);
+		const delayMs = getRetryDelayFromError(reason.error);
+		if (reason.error !== undefined && delayMs !== undefined) {
+			this.props.reconnectionDelayHandler(delayMs, reason.error);
 			await new Promise<void>((resolve) => {
 				setTimeout(resolve, delayMs);
 			});
@@ -956,9 +967,13 @@ export class ConnectionManager implements IConnectionManager {
 		await waitForOnline();
 
 		this.triggerConnect(
-			error !== undefined
-				? "Reconnecting due to Error"
-				: `Reconnecting due to: ${disconnectMessage}`,
+			{
+				text:
+					reason.error !== undefined
+						? "Reconnecting due to Error"
+						: `Reconnecting due to: ${reason.text}`,
+				error: reason.error,
+			},
 			requestedMode,
 		);
 	}
@@ -1029,7 +1044,7 @@ export class ConnectionManager implements IConnectionManager {
 							// still valid?
 							await this.reconnect(
 								"write", // connectionMode
-								"Switch to write", // message
+								{ text: "Switch to write" }, // message
 							);
 						}
 					})
@@ -1083,7 +1098,7 @@ export class ConnectionManager implements IConnectionManager {
 				// Note - this may close container!
 				this.reconnect(
 					"read", // connectionMode
-					"Switch to read", // message
+					{ text: "Switch to read" }, // message
 				).catch((error) => {
 					this.logger.sendErrorEvent({ eventName: "SwitchToReadConnection" }, error);
 				});

package/src/connectionStateHandler.ts

@@ -6,16 +6,16 @@
 import { ITelemetryProperties, TelemetryEventCategory } from "@fluidframework/core-interfaces";
 import { assert, Timer } from "@fluidframework/common-utils";
 import { IDeltaManager } from "@fluidframework/container-definitions";
-import { IAnyDriverError } from "@fluidframework/driver-definitions";
 import { ISequencedClient, IClient } from "@fluidframework/protocol-definitions";
 import {
 	ITelemetryLoggerExt,
 	PerformanceEvent,
 	loggerToMonitoringContext,
 } from "@fluidframework/telemetry-utils";
+import { IAnyDriverError } from "@fluidframework/driver-definitions";
 import { CatchUpMonitor, ICatchUpMonitor } from "./catchUpMonitor";
 import { ConnectionState } from "./connectionState";
-import { IConnectionDetailsInternal } from "./contracts";
+import { IConnectionDetailsInternal, IConnectionStateChangeReason } from "./contracts";
 import { IProtocolHandler } from "./protocol";
 
 // Based on recent data, it looks like majority of cases where we get stuck are due to really slow or
@@ -33,8 +33,7 @@ export interface IConnectionStateHandlerInputs {
 	connectionStateChanged: (
 		value: ConnectionState,
 		oldState: ConnectionState,
-		reason?: string | undefined,
-		error?: IAnyDriverError,
+		reason?: IConnectionStateChangeReason,
 	) => void;
 	/** Whether to expect the client to join in write mode on next connection */
 	shouldClientJoinWrite: () => boolean;
@@ -61,14 +60,14 @@ export interface IConnectionStateHandler {
 	dispose(): void;
 	initProtocol(protocol: IProtocolHandler): void;
 	receivedConnectEvent(details: IConnectionDetailsInternal): void;
-	receivedDisconnectEvent(reason: string, error?: IAnyDriverError): void;
-	establishingConnection(reason: string): void;
+	receivedDisconnectEvent(reason: IConnectionStateChangeReason): void;
+	establishingConnection(reason: IConnectionStateChangeReason): void;
 	/**
 	 * Switches state to disconnected when we are still establishing connection during container.load(),
 	 * container connect() or reconnect and the container gets closed or disposed or disconnect happens.
 	 * @param reason - reason for cancelling the connection.
 	 */
-	cancelEstablishingConnection(reason: string): void;
+	cancelEstablishingConnection(reason: IConnectionStateChangeReason): void;
 }
 
 export function createConnectionStateHandler(
@@ -150,15 +149,15 @@ class ConnectionStateHandlerPassThrough
 	public initProtocol(protocol: IProtocolHandler) {
 		return this.pimpl.initProtocol(protocol);
 	}
-	public receivedDisconnectEvent(reason: string, error?: IAnyDriverError) {
-		return this.pimpl.receivedDisconnectEvent(reason, error);
+	public receivedDisconnectEvent(reason: IConnectionStateChangeReason<IAnyDriverError>) {
+		return this.pimpl.receivedDisconnectEvent(reason);
 	}
 
-	public establishingConnection(reason: string) {
+	public establishingConnection(reason: IConnectionStateChangeReason) {
 		return this.pimpl.establishingConnection(reason);
 	}
 
-	public cancelEstablishingConnection(reason: string) {
+	public cancelEstablishingConnection(reason: IConnectionStateChangeReason) {
 		return this.pimpl.cancelEstablishingConnection(reason);
 	}
 
@@ -176,10 +175,9 @@ class ConnectionStateHandlerPassThrough
 	public connectionStateChanged(
 		value: ConnectionState,
 		oldState: ConnectionState,
-		reason?: string | undefined,
-		error?: IAnyDriverError,
+		reason?: IConnectionStateChangeReason,
 	) {
-		return this.inputs.connectionStateChanged(value, oldState, reason, error);
+		return this.inputs.connectionStateChanged(value, oldState, reason);
 	}
 	public shouldClientJoinWrite() {
 		return this.inputs.shouldClientJoinWrite();
@@ -223,8 +221,7 @@ class ConnectionStateCatchup extends ConnectionStateHandlerPassThrough {
 	public connectionStateChanged(
 		value: ConnectionState,
 		oldState: ConnectionState,
-		reason?: string | undefined,
-		error?: IAnyDriverError,
+		reason?: IConnectionStateChangeReason<IAnyDriverError>,
 	) {
 		switch (value) {
 			case ConnectionState.Connected:
@@ -268,7 +265,7 @@ class ConnectionStateCatchup extends ConnectionStateHandlerPassThrough {
 			default:
 		}
 		this._connectionState = value;
-		this.inputs.connectionStateChanged(value, oldState, reason, error);
+		this.inputs.connectionStateChanged(value, oldState, reason);
 	}
 
 	private readonly transitionToConnectedState = () => {
@@ -277,11 +274,9 @@ class ConnectionStateCatchup extends ConnectionStateHandlerPassThrough {
 		assert(state === ConnectionState.Connected, 0x3e5 /* invariant broken */);
 		assert(this._connectionState === ConnectionState.CatchingUp, 0x3e6 /* invariant broken */);
 		this._connectionState = ConnectionState.Connected;
-		this.inputs.connectionStateChanged(
-			ConnectionState.Connected,
-			ConnectionState.CatchingUp,
-			"caught up",
-		);
+		this.inputs.connectionStateChanged(ConnectionState.Connected, ConnectionState.CatchingUp, {
+			text: "caught up",
+		});
 	};
 }
 
@@ -495,12 +490,12 @@ class ConnectionStateHandler implements IConnectionStateHandler {
 		}
 	}
 
-	public receivedDisconnectEvent(reason: string, error?: IAnyDriverError) {
+	public receivedDisconnectEvent(reason: IConnectionStateChangeReason<IAnyDriverError>) {
 		this.connection = undefined;
-		this.setConnectionState(ConnectionState.Disconnected, reason, error);
+		this.setConnectionState(ConnectionState.Disconnected, reason);
 	}
 
-	public cancelEstablishingConnection(reason: string) {
+	public cancelEstablishingConnection(reason: IConnectionStateChangeReason) {
 		assert(
 			this._connectionState === ConnectionState.EstablishingConnection,
 			0x6d3 /* Connection state should be EstablishingConnection */,
@@ -511,14 +506,13 @@ class ConnectionStateHandler implements IConnectionStateHandler {
 		this.handler.connectionStateChanged(ConnectionState.Disconnected, oldState, reason);
 	}
 
-	public establishingConnection(reason: string) {
+	public establishingConnection(reason: IConnectionStateChangeReason) {
 		const oldState = this._connectionState;
 		this._connectionState = ConnectionState.EstablishingConnection;
-		this.handler.connectionStateChanged(
-			ConnectionState.EstablishingConnection,
-			oldState,
-			`Establishing Connection due to ${reason}`,
-		);
+		this.handler.connectionStateChanged(ConnectionState.EstablishingConnection, oldState, {
+			text: `Establishing Connection due to ${reason.text}`,
+			error: reason.error,
+		});
 	}
 
 	private shouldWaitForJoinSignal() {
@@ -583,14 +577,12 @@ class ConnectionStateHandler implements IConnectionStateHandler {
 
 	private setConnectionState(
 		value: ConnectionState.Disconnected,
-		reason: string,
-		error?: IAnyDriverError,
+		reason: IConnectionStateChangeReason,
 	): void;
 	private setConnectionState(value: ConnectionState.Connected): void;
 	private setConnectionState(
 		value: ConnectionState.Disconnected | ConnectionState.Connected,
-		reason?: string,
-		error?: IAnyDriverError,
+		reason?: IConnectionStateChangeReason,
 	): void {
 		if (this.connectionState === value) {
 			// Already in the desired state - exit early
@@ -651,7 +643,7 @@ class ConnectionStateHandler implements IConnectionStateHandler {
 		}
 
 		// Report transition before we propagate event across layers
-		this.handler.connectionStateChanged(this._connectionState, oldState, reason, error);
+		this.handler.connectionStateChanged(this._connectionState, oldState, reason);
 	}
 
 	// Helper method to switch between quorum and audience.

package/src/container.ts

@@ -40,17 +40,16 @@ import {
 	IProvideFluidCodeDetailsComparer,
 	IFluidCodeDetailsComparer,
 	IRuntime,
-	isFluidCodeDetails,
-	IThrottlingWarning,
 	ReadOnlyInfo,
+	isFluidCodeDetails,
 } from "@fluidframework/container-definitions";
 import { GenericError, UsageError } from "@fluidframework/container-utils";
 import {
-	IAnyDriverError,
 	IDocumentService,
 	IDocumentServiceFactory,
 	IDocumentStorageService,
 	IResolvedUrl,
+	IThrottlingWarning,
 	IUrlResolver,
 } from "@fluidframework/driver-definitions";
 import {
@@ -60,7 +59,6 @@ import {
 	runWithRetry,
 	isCombinedAppAndProtocolSummary,
 	MessageType2,
-	canBeCoalescedByService,
 } from "@fluidframework/driver-utils";
 import { IQuorumSnapshot } from "@fluidframework/protocol-base";
 import {
@@ -102,6 +100,7 @@ import {
 	IConnectionManagerFactoryArgs,
 	getPackageName,
 	IConnectionDetailsInternal,
+	IConnectionStateChangeReason,
 } from "./contracts";
 import { DeltaManager, IConnectionArgs } from "./deltaManager";
 import { IDetachedBlobStorage, ILoaderOptions, RelativeLoader } from "./loader";
@@ -761,7 +760,19 @@ export class Container
 		this.scope = scope;
 		this.detachedBlobStorage = detachedBlobStorage;
 		this.protocolHandlerBuilder =
-			protocolHandlerBuilder ?? ((...args) => new ProtocolHandler(...args, new Audience()));
+			protocolHandlerBuilder ??
+			((
+				attributes: IDocumentAttributes,
+				quorumSnapshot: IQuorumSnapshot,
+				sendProposal: (key: string, value: any) => number,
+			) =>
+				new ProtocolHandler(
+					attributes,
+					quorumSnapshot,
+					sendProposal,
+					new Audience(),
+					(clientId: string) => this.clientsWhoShouldHaveLeft.has(clientId),
+				));
 
 		// Note that we capture the createProps here so we can replicate the creation call when we want to clone.
 		this.clone = async (
@@ -827,11 +838,11 @@ export class Container
 		this.connectionStateHandler = createConnectionStateHandler(
 			{
 				logger: this.mc.logger,
-				connectionStateChanged: (value, oldState, reason, error) => {
+				connectionStateChanged: (value, oldState, reason) => {
 					if (value === ConnectionState.Connected) {
 						this._clientId = this.connectionStateHandler.pendingClientId;
 					}
-					this.logConnectionStateChangeTelemetry(value, oldState, reason, error);
+					this.logConnectionStateChangeTelemetry(value, oldState, reason);
 					if (this._lifecycleState === "loaded") {
 						this.propagateConnectionState(
 							false /* initial transition */,
@@ -873,8 +884,9 @@ export class Container
 					// Other possible recovery path - move to connected state (i.e. ConnectionStateHandler.joinOpTimer
 					// to call this.applyForConnectedState("addMemberEvent") for "read" connections)
 					if (mode === "read") {
-						this.disconnect();
-						this.connect();
+						const reason = { text: "NoJoinSignal" };
+						this.disconnectInternal(reason);
+						this.connectInternal({ reason, fetchOpsFromStorage: false });
 					}
 				},
 				clientShouldHaveLeft: (clientId: string) => {
@@ -1071,7 +1083,7 @@ export class Container
 		// runtime matches pending ops to successful ones by clientId and client seq num, so we need to close the
 		// container at the same time we get pending state, otherwise this container could reconnect and resubmit with
 		// a new clientId and a future container using stale pending state without the new clientId would resubmit them
-		this.disconnect(); // TODO https://dev.azure.com/fluidframework/internal/_workitems/edit/5127
+		this.disconnectInternal({ text: "closeAndGetPendingLocalState" }); // TODO https://dev.azure.com/fluidframework/internal/_workitems/edit/5127
 		const pendingState = await this.getPendingLocalStateCore({ notifyImminentClosure: true });
 		this.close();
 		return pendingState;
@@ -1267,7 +1279,7 @@ export class Container
 					if (!this.closed) {
 						this.resumeInternal({
 							fetchOpsFromStorage: false,
-							reason: "createDetached",
+							reason: { text: "createDetached" },
 						});
 					}
 				} catch (error) {
@@ -1291,7 +1303,7 @@ export class Container
 		);
 	}
 
-	private setAutoReconnectInternal(mode: ReconnectMode) {
+	private setAutoReconnectInternal(mode: ReconnectMode, reason: IConnectionStateChangeReason) {
 		const currentMode = this._deltaManager.connectionManager.reconnectMode;
 
 		if (currentMode === mode) {
@@ -1310,7 +1322,7 @@ export class Container
 			duration,
 		});
 
-		this._deltaManager.connectionManager.setAutoReconnect(mode);
+		this._deltaManager.connectionManager.setAutoReconnect(mode, reason);
 	}
 
 	public connect() {
@@ -1322,7 +1334,10 @@ export class Container
 			// Note: no need to fetch ops as we do it preemptively as part of DeltaManager.attachOpHandler().
 			// If there is gap, we will learn about it once connected, but the gap should be small (if any),
 			// assuming that connect() is called quickly after initial container boot.
-			this.connectInternal({ reason: "DocumentConnect", fetchOpsFromStorage: false });
+			this.connectInternal({
+				reason: { text: "DocumentConnect" },
+				fetchOpsFromStorage: false,
+			});
 		}
 	}
 
@@ -1338,23 +1353,23 @@ export class Container
 
 		// Set Auto Reconnect Mode
 		const mode = ReconnectMode.Enabled;
-		this.setAutoReconnectInternal(mode);
+		this.setAutoReconnectInternal(mode, args.reason);
 	}
 
 	public disconnect() {
 		if (this.closed) {
 			throw new UsageError(`The Container is closed and cannot be disconnected`);
 		} else {
-			this.disconnectInternal();
+			this.disconnectInternal({ text: "DocumentDisconnect" });
 		}
 	}
 
-	private disconnectInternal() {
+	private disconnectInternal(reason: IConnectionStateChangeReason) {
 		assert(!this.closed, 0x2c7 /* "Attempting to disconnect() a closed Container" */);
 
 		// Set Auto Reconnect Mode
 		const mode = ReconnectMode.Disabled;
-		this.setAutoReconnectInternal(mode);
+		this.setAutoReconnectInternal(mode, reason);
 	}
 
 	private resumeInternal(args: IConnectionArgs) {
@@ -1506,7 +1521,7 @@ export class Container
 		// A) creation flow breaks (as one of the clients "sees" file as existing, and hits #2 above)
 		// B) Once file is created, transition from view-only connection to write does not work - some bugs to be fixed.
 		const connectionArgs: IConnectionArgs = {
-			reason: "DocumentOpen",
+			reason: { text: "DocumentOpen" },
 			mode: "write",
 			fetchOpsFromStorage: false,
 		};
@@ -2009,18 +2024,18 @@ export class Container
 			this.connectionStateHandler.receivedConnectEvent(details);
 		});
 
-		deltaManager.on("establishingConnection", (reason: string) => {
+		deltaManager.on("establishingConnection", (reason: IConnectionStateChangeReason) => {
 			this.connectionStateHandler.establishingConnection(reason);
 		});
 
-		deltaManager.on("cancelEstablishingConnection", (reason: string) => {
+		deltaManager.on("cancelEstablishingConnection", (reason: IConnectionStateChangeReason) => {
 			this.connectionStateHandler.cancelEstablishingConnection(reason);
 		});
 
-		deltaManager.on("disconnect", (reason: string, error?: IAnyDriverError) => {
+		deltaManager.on("disconnect", (reason: IConnectionStateChangeReason) => {
 			this.noopHeuristic?.notifyDisconnect();
 			if (!this.closed) {
-				this.connectionStateHandler.receivedDisconnectEvent(reason, error);
+				this.connectionStateHandler.receivedDisconnectEvent(reason);
 			}
 		});
 
@@ -2073,8 +2088,7 @@ export class Container
 	private logConnectionStateChangeTelemetry(
 		value: ConnectionState,
 		oldState: ConnectionState,
-		reason?: string,
-		error?: IAnyDriverError,
+		reason?: IConnectionStateChangeReason,
 	) {
 		// Log actual event
 		const time = performance.now();
@@ -2113,7 +2127,7 @@ export class Container
 				from: ConnectionState[oldState],
 				duration,
 				durationFromDisconnected,
-				reason,
+				reason: reason?.text,
 				connectionInitiationReason,
 				pendingClientId: this.connectionStateHandler.pendingClientId,
 				clientId: this.clientId,
@@ -2129,7 +2143,7 @@ export class Container
 				isDirty: this.isDirty,
 				...this._deltaManager.connectionProps,
 			},
-			error,
+			reason?.error,
 		);
 
 		if (value === ConnectionState.Connected) {
@@ -2137,7 +2151,10 @@ export class Container
 		}
 	}
 
-	private propagateConnectionState(initialTransition: boolean, disconnectedReason?: string) {
+	private propagateConnectionState(
+		initialTransition: boolean,
+		disconnectedReason?: IConnectionStateChangeReason,
+	) {
 		// When container loaded, we want to propagate initial connection state.
 		// After that, we communicate only transitions to Connected & Disconnected states, skipping all other states.
 		// This can be changed in the future, for example we likely should add "CatchingUp" event on Container.
@@ -2154,7 +2171,7 @@ export class Container
 
 		this.setContextConnectedState(state, this.readOnlyInfo.readonly ?? false);
 		this.protocolHandler.setConnectionState(state, this.clientId);
-		raiseConnectedEvent(this.mc.logger, this, state, this.clientId, disconnectedReason);
+		raiseConnectedEvent(this.mc.logger, this, state, this.clientId, disconnectedReason?.text);
 	}
 
 	// back-compat: ADO #1385: Remove in the future, summary op should come through submitSummaryMessage()
@@ -2247,28 +2264,6 @@ export class Container
 		}
 		const local = this.clientId === message.clientId;
 
-		// Check and report if we're getting messages from a clientId that we previously
-		// flagged should have left, or from a client that's not in the quorum but should be
-		if (message.clientId != null) {
-			const client = this.protocolHandler.quorum.getMember(message.clientId);
-
-			if (client === undefined && message.type !== MessageType.ClientJoin) {
-				// pre-0.58 error message: messageClientIdMissingFromQuorum
-				throw new Error("Remote message's clientId is missing from the quorum");
-			}
-
-			// Here checking canBeCoalescedByService is used as an approximation of "is benign to process despite being unexpected".
-			// It's still not good to see these messages from unexpected clientIds, but since they don't harm the integrity of the
-			// document we don't need to blow up aggressively.
-			if (
-				this.clientsWhoShouldHaveLeft.has(message.clientId) &&
-				!canBeCoalescedByService(message)
-			) {
-				// pre-0.58 error message: messageClientIdShouldHaveLeft
-				throw new Error("Remote message's clientId already should have left");
-			}
-		}
-
 		// Allow the protocol handler to process the message
 		const result = this.protocolHandler.processMessage(message, local);
 
@@ -2413,6 +2408,7 @@ export class Container
 			(error?: ICriticalContainerError) => this.close(error),
 			this.updateDirtyContainerState,
 			this.getAbsoluteUrl,
+			() => this.resolvedUrl?.id,
 			() => this.clientId,
 			() => this.attachState,
 			() => this.connected,