@fluidframework/container-loader 2.0.0-internal.4.3.0 → 2.0.0-internal.5.0.0

package/src/container.ts

@@ -7,11 +7,7 @@
 import merge from "lodash/merge";
 
 import { v4 as uuid } from "uuid";
-import {
-	ITelemetryLogger,
-	ITelemetryProperties,
-	TelemetryEventCategory,
-} from "@fluidframework/common-definitions";
+import { ITelemetryProperties, TelemetryEventCategory } from "@fluidframework/common-definitions";
 import { assert, performance, unreachableCase } from "@fluidframework/common-utils";
 import { IRequest, IResponse, IFluidRouter, FluidObject } from "@fluidframework/core-interfaces";
 import {
@@ -29,22 +25,24 @@ import {
 	IFluidCodeDetails,
 	isFluidCodeDetails,
 	IBatchMessage,
+	ICodeDetailsLoader,
+	IHostLoader,
 } from "@fluidframework/container-definitions";
 import { GenericError, UsageError } from "@fluidframework/container-utils";
 import {
+	IAnyDriverError,
 	IDocumentService,
+	IDocumentServiceFactory,
 	IDocumentStorageService,
-	IFluidResolvedUrl,
 	IResolvedUrl,
+	IUrlResolver,
 } from "@fluidframework/driver-definitions";
 import {
 	readAndParse,
 	OnlineStatus,
 	isOnline,
-	ensureFluidResolvedUrl,
 	combineAppAndProtocolSummary,
 	runWithRetry,
-	isFluidResolvedUrl,
 	isCombinedAppAndProtocolSummary,
 } from "@fluidframework/driver-utils";
 import { IQuorumSnapshot } from "@fluidframework/protocol-base";
@@ -79,13 +77,14 @@ import {
 	MonitoringContext,
 	loggerToMonitoringContext,
 	wrapError,
+	ITelemetryLoggerExt,
 } from "@fluidframework/telemetry-utils";
 import { Audience } from "./audience";
 import { ContainerContext } from "./containerContext";
 import { ReconnectMode, IConnectionManagerFactoryArgs, getPackageName } from "./contracts";
 import { DeltaManager, IConnectionArgs } from "./deltaManager";
 import { DeltaManagerProxy } from "./deltaManagerProxy";
-import { ILoaderOptions, Loader, RelativeLoader } from "./loader";
+import { IDetachedBlobStorage, ILoaderOptions, RelativeLoader } from "./loader";
 import { pkgVersion } from "./packageVersion";
 import {
 	ContainerStorageAdapter,
@@ -116,44 +115,82 @@ const dirtyContainerEvent = "dirty";
 const savedContainerEvent = "saved";
 
 /**
- * @deprecated this is an internal interface and will not longer be exported in future versions
  * @internal
  */
-export interface IContainerLoadOptions {
-	/**
-	 * Disables the Container from reconnecting if false, allows reconnect otherwise.
-	 */
-	canReconnect?: boolean;
+export interface IContainerLoadProps {
 	/**
-	 * Client details provided in the override will be merged over the default client.
+	 * The resolved url of the container being loaded
 	 */
-	clientDetailsOverride?: IClientDetails;
-	resolvedUrl: IFluidResolvedUrl;
+	readonly resolvedUrl: IResolvedUrl;
 	/**
 	 * Control which snapshot version to load from.  See IParsedUrl for detailed information.
 	 */
-	version: string | undefined;
+	readonly version: string | undefined;
 	/**
 	 * Loads the Container in paused state if true, unpaused otherwise.
 	 */
-	loadMode?: IContainerLoadMode;
+	readonly loadMode?: IContainerLoadMode;
+
+	/**
+	 * The pending state serialized from a pervious container instance
+	 */
+	readonly pendingLocalState?: IPendingContainerState;
 }
 
 /**
- * @deprecated this is an internal interface and will not longer be exported in future versions
  * @internal
  */
-export interface IContainerConfig {
-	resolvedUrl?: IFluidResolvedUrl;
-	canReconnect?: boolean;
+export interface IContainerCreateProps {
+	/**
+	 * Disables the Container from reconnecting if false, allows reconnect otherwise.
+	 */
+	readonly canReconnect?: boolean;
 	/**
 	 * Client details provided in the override will be merged over the default client.
 	 */
-	clientDetailsOverride?: IClientDetails;
+	readonly clientDetailsOverride?: IClientDetails;
+
+	/**
+	 * The url resolver used by the loader for resolving external urls
+	 * into Fluid urls such that the container specified by the
+	 * external url can be loaded.
+	 */
+	readonly urlResolver: IUrlResolver;
+	/**
+	 * The document service factory take the Fluid url provided
+	 * by the resolved url and constructs all the necessary services
+	 * for communication with the container's server.
+	 */
+	readonly documentServiceFactory: IDocumentServiceFactory;
 	/**
-	 * Serialized state from a previous instance of this container
+	 * The code loader handles loading the necessary code
+	 * for running a container once it is loaded.
 	 */
-	serializedContainerState?: IPendingContainerState;
+	readonly codeLoader: ICodeDetailsLoader;
+
+	/**
+	 * A property bag of options used by various layers
+	 * to control features
+	 */
+	readonly options: ILoaderOptions;
+
+	/**
+	 * Scope is provided to all container and is a set of shared
+	 * services for container's to integrate with their host environment.
+	 */
+	readonly scope: FluidObject;
+
+	/**
+	 * The logger downstream consumers should construct their loggers from
+	 */
+	readonly subLogger: ITelemetryLoggerExt;
+
+	/**
+	 * Blobs storage for detached containers.
+	 */
+	readonly detachedBlobStorage?: IDetachedBlobStorage;
+
+	readonly protocolHandlerBuilder?: ProtocolHandlerBuilder;
 }
 
 /**
@@ -259,7 +296,7 @@ const getCodeProposal =
  * @param action - functor to call and measure
  */
 export async function ReportIfTooLong(
-	logger: ITelemetryLogger,
+	logger: ITelemetryLoggerExt,
 	eventName: string,
 	action: () => Promise<ITelemetryProperties>,
 ) {
@@ -273,7 +310,6 @@ export async function ReportIfTooLong(
 /**
  * State saved by a container at close time, to be used to load a new instance
  * of the container to the same state
- * @deprecated this is an internal interface and will not longer be exported in future versions
  * @internal
  */
 export interface IPendingContainerState {
@@ -300,49 +336,46 @@ export interface IPendingContainerState {
 
 const summarizerClientType = "summarizer";
 
-/**
- * @deprecated - In the next release Container will no longer be exported, IContainer should be used in its place.
- */
 export class Container
 	extends EventEmitterWithErrorHandling<IContainerEvents>
 	implements IContainer, IContainerExperimental
 {
 	public static version = "^0.1.0";
 
+	public static async clone(
+		container: Container,
+		loadProps: IContainerLoadProps,
+		createParamOverrides: Partial<IContainerCreateProps>,
+	) {
+		return this.load(loadProps, {
+			...container.createProps,
+			...createParamOverrides,
+		});
+	}
+
 	/**
 	 * Load an existing container.
 	 * @internal
 	 */
 	public static async load(
-		loader: Loader,
-		loadOptions: IContainerLoadOptions,
-		pendingLocalState?: IPendingContainerState,
-		protocolHandlerBuilder?: ProtocolHandlerBuilder,
+		loadProps: IContainerLoadProps,
+		createProps: IContainerCreateProps,
 	): Promise<Container> {
-		const container = new Container(
-			loader,
-			{
-				clientDetailsOverride: loadOptions.clientDetailsOverride,
-				resolvedUrl: loadOptions.resolvedUrl,
-				canReconnect: loadOptions.canReconnect,
-				serializedContainerState: pendingLocalState,
-			},
-			protocolHandlerBuilder,
-		);
+		const { version, pendingLocalState, loadMode, resolvedUrl } = loadProps;
+
+		const container = new Container(createProps, loadProps);
 
 		return PerformanceEvent.timedExecAsync(
 			container.mc.logger,
 			{ eventName: "Load" },
 			async (event) =>
 				new Promise<Container>((resolve, reject) => {
-					const version = loadOptions.version;
-
 					const defaultMode: IContainerLoadMode = { opsBeforeReturn: "cached" };
 					// if we have pendingLocalState, anything we cached is not useful and we shouldn't wait for connection
 					// to return container, so ignore this value and use undefined for opsBeforeReturn
 					const mode: IContainerLoadMode = pendingLocalState
-						? { ...(loadOptions.loadMode ?? defaultMode), opsBeforeReturn: undefined }
-						: loadOptions.loadMode ?? defaultMode;
+						? { ...(loadMode ?? defaultMode), opsBeforeReturn: undefined }
+						: loadMode ?? defaultMode;
 
 					const onClosed = (err?: ICriticalContainerError) => {
 						// pre-0.58 error message: containerClosedWithoutErrorDuringLoad
@@ -353,13 +386,13 @@ export class Container
 					container.on("closed", onClosed);
 
 					container
-						.load(version, mode, pendingLocalState)
+						.load(version, mode, resolvedUrl, pendingLocalState)
 						.finally(() => {
 							container.removeListener("closed", onClosed);
 						})
 						.then(
 							(props) => {
-								event.end({ ...props, ...loadOptions.loadMode });
+								event.end({ ...props, ...loadMode });
 								resolve(container);
 							},
 							(error) => {
@@ -380,11 +413,10 @@ export class Container
 	 * Create a new container in a detached state.
 	 */
 	public static async createDetached(
-		loader: Loader,
+		createProps: IContainerCreateProps,
 		codeDetails: IFluidCodeDetails,
-		protocolHandlerBuilder?: ProtocolHandlerBuilder,
 	): Promise<Container> {
-		const container = new Container(loader, {}, protocolHandlerBuilder);
+		const container = new Container(createProps);
 
 		return PerformanceEvent.timedExecAsync(
 			container.mc.logger,
@@ -402,11 +434,10 @@ export class Container
 	 * snapshot from a previous detached container.
 	 */
 	public static async rehydrateDetachedFromSnapshot(
-		loader: Loader,
+		createProps: IContainerCreateProps,
 		snapshot: string,
-		protocolHandlerBuilder?: ProtocolHandlerBuilder,
 	): Promise<Container> {
-		const container = new Container(loader, {}, protocolHandlerBuilder);
+		const container = new Container(createProps);
 
 		return PerformanceEvent.timedExecAsync(
 			container.mc.logger,
@@ -502,7 +533,6 @@ export class Container
 	private readonly connectionTransitionTimes: number[] = [];
 	private messageCountAfterDisconnection: number = 0;
 	private _loadedFromVersion: IVersion | undefined;
-	private _resolvedUrl: IFluidResolvedUrl | undefined;
 	private attachStarted = false;
 	private _dirtyContainer = false;
 	private readonly savedOps: ISequencedDocumentMessage[] = [];
@@ -526,7 +556,18 @@ export class Container
 	}
 
 	public get resolvedUrl(): IResolvedUrl | undefined {
-		return this._resolvedUrl;
+		/**
+		 * All attached containers will have a document service,
+		 * this is required, as attached containers are attached to
+		 * a service. Detached containers will neither have a document
+		 * service or a resolved url as they only exist locally.
+		 * in order to create a document service a resolved url must
+		 * first be obtained, this is how the container is identified.
+		 * Because of this, the document service's resolved url
+		 * is always the same as the containers, as we had to
+		 * obtain the resolved url, and then create the service from it.
+		 */
+		return this.service?.resolvedUrl;
 	}
 
 	public get loadedFromVersion(): IVersion | undefined {
@@ -632,17 +673,17 @@ export class Container
 	}
 
 	private get serviceFactory() {
-		return this.loader.services.documentServiceFactory;
+		return this.createProps.documentServiceFactory;
 	}
 	private get urlResolver() {
-		return this.loader.services.urlResolver;
+		return this.createProps.urlResolver;
 	}
 	public readonly options: ILoaderOptions;
 	private get scope() {
-		return this.loader.services.scope;
+		return this.createProps.scope;
 	}
 	private get codeLoader() {
-		return this.loader.services.codeLoader;
+		return this.createProps.codeLoader;
 	}
 
 	/**
@@ -684,9 +725,8 @@ export class Container
 	 * @internal
 	 */
 	constructor(
-		private readonly loader: Loader,
-		config: IContainerConfig,
-		private readonly protocolHandlerBuilder?: ProtocolHandlerBuilder,
+		private readonly createProps: IContainerCreateProps,
+		loadProps?: IContainerLoadProps,
 	) {
 		super((name, error) => {
 			this.mc.logger.sendErrorEvent(
@@ -698,10 +738,9 @@ export class Container
 			);
 		});
 
-		this.clientDetailsOverride = config.clientDetailsOverride;
-		this._resolvedUrl = config.resolvedUrl;
-		if (config.canReconnect !== undefined) {
-			this._canReconnect = config.canReconnect;
+		this.clientDetailsOverride = createProps.clientDetailsOverride;
+		if (createProps.canReconnect !== undefined) {
+			this._canReconnect = createProps.canReconnect;
 		}
 
 		// Create logger for data stores to use
@@ -712,15 +751,15 @@ export class Container
 		}`;
 		// Need to use the property getter for docId because for detached flow we don't have the docId initially.
 		// We assign the id later so property getter is used.
-		this.subLogger = ChildLogger.create(loader.services.subLogger, undefined, {
+		this.subLogger = ChildLogger.create(createProps.subLogger, undefined, {
 			all: {
 				clientType, // Differentiating summarizer container from main container
 				containerId: uuid(),
-				docId: () => this._resolvedUrl?.id ?? undefined,
+				docId: () => this.resolvedUrl?.id,
 				containerAttachState: () => this._attachState,
 				containerLifecycleState: () => this._lifecycleState,
 				containerConnectionState: () => ConnectionState[this.connectionState],
-				serializedContainer: config.serializedContainerState !== undefined,
+				serializedContainer: loadProps?.pendingLocalState !== undefined,
 			},
 			// we need to be judicious with our logging here to avoid generating too much data
 			// all data logged here should be broadly applicable, and not specific to a
@@ -750,7 +789,7 @@ export class Container
 		// all clients that were loaded from the same loader (including summarizer clients).
 		// Tracking alternative ways to handle this in AB#4129.
 		this.options = {
-			...this.loader.services.options,
+			...this.createProps.options,
 		};
 
 		this._deltaManager = this.createDeltaManager();
@@ -758,11 +797,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 */,
@@ -773,7 +812,7 @@ export class Container
 					}
 				},
 				shouldClientJoinWrite: () => this._deltaManager.connectionManager.shouldJoinWrite(),
-				maxClientLeaveWaitTime: this.loader.services.options.maxClientLeaveWaitTime,
+				maxClientLeaveWaitTime: this.createProps.options.maxClientLeaveWaitTime,
 				logConnectionIssue: (
 					eventName: string,
 					category: TelemetryEventCategory,
@@ -810,7 +849,7 @@ export class Container
 				},
 			},
 			this.deltaManager,
-			config.serializedContainerState?.clientId,
+			loadProps?.pendingLocalState?.clientId,
 		);
 
 		this.on(savedContainerEvent, () => {
@@ -829,12 +868,12 @@ export class Container
 		// Even if not forced on via this flag, combined summaries may still be enabled by service policy.
 		const forceEnableSummarizeProtocolTree =
 			this.mc.config.getBoolean("Fluid.Container.summarizeProtocolTree2") ??
-			this.loader.services.options.summarizeProtocolTree;
+			this.createProps.options.summarizeProtocolTree;
 
 		this.storageAdapter = new ContainerStorageAdapter(
-			this.loader.services.detachedBlobStorage,
+			this.createProps.detachedBlobStorage,
 			this.mc.logger,
-			config.serializedContainerState?.snapshotBlobs,
+			loadProps?.pendingLocalState?.snapshotBlobs,
 			addProtocolSummaryIfMissing,
 			forceEnableSummarizeProtocolTree,
 		);
@@ -868,7 +907,7 @@ export class Container
 		return this.protocolHandler.quorum;
 	}
 
-	public dispose?(error?: ICriticalContainerError) {
+	public dispose(error?: ICriticalContainerError) {
 		this._deltaManager.close(error, true /* doDispose */);
 		this.verifyClosed();
 	}
@@ -920,15 +959,6 @@ export class Container
 				this._protocolHandler?.close();
 
 				this.connectionStateHandler.dispose();
-
-				this._context?.dispose(error !== undefined ? new Error(error.message) : undefined);
-
-				this.storageAdapter.dispose();
-
-				// Notify storage about critical errors. They may be due to disconnect between client & server knowledge
-				// about file, like file being overwritten in storage, but client having stale local cache.
-				// Driver need to ensure all caches are cleared on critical errors
-				this.service?.dispose(error);
 			} catch (exception) {
 				this.mc.logger.sendErrorEvent({ eventName: "ContainerCloseException" }, exception);
 			}
@@ -1048,10 +1078,7 @@ export class Container
 		const protocolSummary = this.captureProtocolSummary();
 		const combinedSummary = combineAppAndProtocolSummary(appSummary, protocolSummary);
 
-		if (
-			this.loader.services.detachedBlobStorage &&
-			this.loader.services.detachedBlobStorage.size > 0
-		) {
+		if (this.createProps.detachedBlobStorage && this.createProps.detachedBlobStorage.size > 0) {
 			combinedSummary.tree[".hasAttachmentBlobs"] = {
 				type: SummaryType.Blob,
 				content: "true",
@@ -1081,8 +1108,8 @@ export class Container
 
 				// If attachment blobs were uploaded in detached state we will go through a different attach flow
 				const hasAttachmentBlobs =
-					this.loader.services.detachedBlobStorage !== undefined &&
-					this.loader.services.detachedBlobStorage.size > 0;
+					this.createProps.detachedBlobStorage !== undefined &&
+					this.createProps.detachedBlobStorage.size > 0;
 
 				try {
 					assert(
@@ -1113,11 +1140,11 @@ export class Container
 					}
 
 					// Actually go and create the resolved document
-					const createNewResolvedUrl = await this.urlResolver.resolve(request);
-					ensureFluidResolvedUrl(createNewResolvedUrl);
 					if (this.service === undefined) {
+						const createNewResolvedUrl = await this.urlResolver.resolve(request);
 						assert(
-							this.client.details.type !== summarizerClientType,
+							this.client.details.type !== summarizerClientType &&
+								createNewResolvedUrl !== undefined,
 							0x2c4 /* "client should not be summarizer before container is created" */,
 						);
 						this.service = await runWithRetry(
@@ -1135,15 +1162,12 @@ export class Container
 							}, // progress
 						);
 					}
-					const resolvedUrl = this.service.resolvedUrl;
-					ensureFluidResolvedUrl(resolvedUrl);
-					this._resolvedUrl = resolvedUrl;
 					await this.storageAdapter.connectToService(this.service);
 
 					if (hasAttachmentBlobs) {
 						// upload blobs to storage
 						assert(
-							!!this.loader.services.detachedBlobStorage,
+							!!this.createProps.detachedBlobStorage,
 							0x24e /* "assertion for type narrowing" */,
 						);
 
@@ -1151,13 +1175,14 @@ export class Container
 						// support blob handles that only know about the local IDs
 						const redirectTable = new Map<string, string>();
 						// if new blobs are added while uploading, upload them too
-						while (redirectTable.size < this.loader.services.detachedBlobStorage.size) {
-							const newIds = this.loader.services.detachedBlobStorage
+						while (redirectTable.size < this.createProps.detachedBlobStorage.size) {
+							const newIds = this.createProps.detachedBlobStorage
 								.getBlobIds()
 								.filter((id) => !redirectTable.has(id));
 							for (const id of newIds) {
-								const blob =
-									await this.loader.services.detachedBlobStorage.readBlob(id);
+								const blob = await this.createProps.detachedBlobStorage.readBlob(
+									id,
+								);
 								const response = await this.storageAdapter.createBlob(blob);
 								redirectTable.set(id, response.id);
 							}
@@ -1196,12 +1221,8 @@ export class Container
 				} catch (error) {
 					// add resolved URL on error object so that host has the ability to find this document and delete it
 					const newError = normalizeError(error);
-					const resolvedUrl = this.resolvedUrl;
-					if (isFluidResolvedUrl(resolvedUrl)) {
-						newError.addTelemetryProperties({ resolvedUrl: resolvedUrl.url });
-					}
+					newError.addTelemetryProperties({ resolvedUrl: this.resolvedUrl?.url });
 					this.close(newError);
-					this.dispose?.(newError);
 					throw newError;
 				}
 			},
@@ -1348,7 +1369,6 @@ export class Container
 		// pre-0.58 error message: existingContextDoesNotSatisfyIncomingProposal
 		const error = new GenericError("Existing context does not satisfy incoming proposal");
 		this.close(error);
-		this.dispose?.(error);
 	}
 
 	private async getVersion(version: string | null): Promise<IVersion | undefined> {
@@ -1381,13 +1401,11 @@ export class Container
 	private async load(
 		specifiedVersion: string | undefined,
 		loadMode: IContainerLoadMode,
+		resolvedUrl: IResolvedUrl,
 		pendingLocalState?: IPendingContainerState,
 	) {
-		if (this._resolvedUrl === undefined) {
-			throw new Error("Attempting to load without a resolved url");
-		}
 		this.service = await this.serviceFactory.createDocumentService(
-			this._resolvedUrl,
+			resolvedUrl,
 			this.subLogger,
 			this.client.details.type === summarizerClientType,
 		);
@@ -1419,7 +1437,6 @@ export class Container
 			// if we have pendingLocalState we can load without storage; don't wait for connection
 			this.storageAdapter.connectToService(this.service).catch((error) => {
 				this.close(error);
-				this.dispose?.(error);
 			});
 		}
 
@@ -1602,8 +1619,8 @@ export class Container
 	private async rehydrateDetachedFromSnapshot(detachedContainerSnapshot: ISummaryTree) {
 		if (detachedContainerSnapshot.tree[".hasAttachmentBlobs"] !== undefined) {
 			assert(
-				!!this.loader.services.detachedBlobStorage &&
-					this.loader.services.detachedBlobStorage.size > 0,
+				!!this.createProps.detachedBlobStorage &&
+					this.createProps.detachedBlobStorage.size > 0,
 				0x250 /* "serialized container with attachment blobs must be rehydrated with detached blob storage" */,
 			);
 			delete detachedContainerSnapshot.tree[".hasAttachmentBlobs"];
@@ -1701,7 +1718,7 @@ export class Container
 		quorumSnapshot: IQuorumSnapshot,
 	): void {
 		const protocolHandlerBuilder =
-			this.protocolHandlerBuilder ??
+			this.createProps.protocolHandlerBuilder ??
 			((...args) => new ProtocolHandler(...args, new Audience()));
 		const protocol = protocolHandlerBuilder(attributes, quorumSnapshot, (key, value) =>
 			this.submitMessage(MessageType.Propose, JSON.stringify({ key, value })),
@@ -1732,7 +1749,6 @@ export class Container
 				this.processCodeProposal().catch((error) => {
 					const normalizedError = normalizeError(error);
 					this.close(normalizedError);
-					this.dispose?.(normalizedError);
 					throw error;
 				});
 			}
@@ -1843,10 +1859,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 +1916,7 @@ export class Container
 		value: ConnectionState,
 		oldState: ConnectionState,
 		reason?: string,
+		error?: IAnyDriverError,
 	) {
 		// Log actual event
 		const time = performance.now();
@@ -1928,24 +1945,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;
@@ -2006,7 +2028,6 @@ export class Container
 					{ messageType: type },
 				);
 				this.close(newError);
-				this.dispose?.(newError);
 				return -1;
 			}
 		}
@@ -2176,7 +2197,8 @@ export class Container
 
 		// The relative loader will proxy requests to '/' to the loader itself assuming no non-cache flags
 		// are set. Global requests will still go directly to the loader
-		const loader = new RelativeLoader(this, this.loader);
+		const maybeLoader: FluidObject<IHostLoader> = this.scope;
+		const loader = new RelativeLoader(this, maybeLoader.ILoader);
 		this._context = await ContainerContext.createOrLoad(
 			this,
 			this.scope,
@@ -2193,7 +2215,7 @@ export class Container
 			(batch: IBatchMessage[], referenceSequenceNumber?: number) =>
 				this.submitBatch(batch, referenceSequenceNumber),
 			(message) => this.submitSignal(message),
-			(error?: ICriticalContainerError) => this.dispose?.(error),
+			(error?: ICriticalContainerError) => this.dispose(error),
 			(error?: ICriticalContainerError) => this.close(error),
 			Container.version,
 			(dirty: boolean) => this.updateDirtyContainerState(dirty),