Revert "feat(Container): Add IContainer.closedWithError to access the error that closed or disposed the container"

packages/common/container-definitions/api-report/container-definitions.legacy.alpha.api.md

@@ -100,7 +100,6 @@ export interface IContainer extends IEventProvider<IContainerEvents> {
     readonly clientId?: string | undefined;
     close(error?: ICriticalContainerError): void;
     readonly closed: boolean;
-    readonly closedWithError?: ICriticalContainerError | undefined;
     connect(): void;
     readonly connectionState: ConnectionState;
     containerMetadata: Record<string, string>;

packages/common/container-definitions/src/loader.ts

@@ -374,14 +374,6 @@ export interface IContainer extends IEventProvider<IContainerEvents> {
 	 */
 	readonly disposed?: boolean;
 
-	/**
-	 * The error that caused the container to close or dispose.
-	 *
-	 * @remarks If the container is closed first and then later disposed,
-	 * this will be the error from the close (even if undefined), not the dispose.
-	 */
-	readonly closedWithError?: ICriticalContainerError | undefined;
-
 	/**
 	 * Whether or not there are any local changes that have not been saved.
 	 */

packages/loader/container-loader/src/container.ts

@@ -579,11 +579,6 @@ export class Container
 		return this._lifecycleState === "disposing" || this._lifecycleState === "disposed";
 	}
 
-	public get closedWithError(): ICriticalContainerError | undefined {
-		return this._closedWithError;
-	}
-	private _closedWithError?: ICriticalContainerError;
-
 	private readonly storageAdapter: ContainerStorageAdapter;
 
 	private readonly _deltaManager: DeltaManager<ConnectionManager>;
@@ -1113,7 +1108,6 @@ export class Container
 				);
 
 				this._lifecycleState = "closing";
-				this._closedWithError = error;
 
 				// Back-compat for Old driver
 				if (this.service?.off !== undefined) {
@@ -1155,24 +1149,15 @@ export class Container
 				this.mc.logger.sendTelemetryEvent(
 					{
 						eventName: "ContainerDispose",
-						// Use error category if there's an error, unless we already closed with an error (i.e. _closedWithError is set)
-						category:
-							error !== undefined && this._closedWithError === undefined ? "error" : "generic",
-						details: {
-							closedWithErrorType: this._closedWithError?.errorType,
-							closedWithErrorMessage: this._closedWithError?.message,
-						},
+						// Only log error if container isn't closed
+						category: !this.closed && error !== undefined ? "error" : "generic",
 					},
 					error,
 				);
 
 				// ! Progressing from "closed" to "disposing" is not allowed
 				if (this._lifecycleState !== "closed") {
 					this._lifecycleState = "disposing";
-
-					// Only set _closedWithError if we're "disposing and closing" all at once
-					// (disposing from a non-closed state)
-					this._closedWithError = error;
 				}
 
 				this._protocolHandler?.close();

packages/test/test-end-to-end-tests/src/test/container.spec.ts

@@ -691,7 +691,7 @@ describeCompat("Container", "NoCompat", (getTestObjectProvider) => {
 				() => runtimeDispose++,
 			);
 
-			container.dispose(new DataCorruptionError("dispose error", {}));
+			container.dispose(new DataCorruptionError("expected", {}));
 			assert.strictEqual(
 				containerDisposed,
 				1,
@@ -717,11 +717,6 @@ describeCompat("Container", "NoCompat", (getTestObjectProvider) => {
 				1,
 				"IContainerRuntime should send dispose event on container dispose",
 			);
-			assert.strictEqual(
-				container.closedWithError?.message,
-				"dispose error",
-				"Expected the error that disposed the container",
-			);
 		},
 	);
 
@@ -749,56 +744,13 @@ describeCompat("Container", "NoCompat", (getTestObjectProvider) => {
 				() => runtimeDispose++,
 			);
 
-			container.close(new DataCorruptionError("close error", {}));
-			container.dispose(new DataCorruptionError("dispose error", {}));
+			container.close(new DataCorruptionError("expected", {}));
+			container.dispose(new DataCorruptionError("expected", {}));
 			assert.strictEqual(containerDisposed, 1, "Container should send disposed event");
 			assert.strictEqual(containerClosed, 1, "Container should send closed event");
 			assert.strictEqual(deltaManagerDisposed, 1, "DeltaManager should send disposed event");
 			assert.strictEqual(deltaManagerClosed, 1, "DeltaManager should send closed event");
 			assert.strictEqual(runtimeDispose, 1, "IContainerRuntime should send dispose event");
-			assert.strictEqual(
-				container.closedWithError?.message,
-				"close error",
-				"Expected the error that closed the container (not the dispose one)",
-			);
-		},
-	);
-
-	itExpects(
-		"Closing (no error) then disposing (with error) container leaves closedWithError unset",
-		[
-			{ eventName: "fluid:telemetry:Container:ContainerClose", category: "generic" },
-			{ eventName: "fluid:telemetry:Container:ContainerDispose", category: "error" },
-		],
-		async () => {
-			const container = await createConnectedContainer();
-			container.close();
-			container.dispose(new DataCorruptionError("dispose error", {}));
-
-			assert.strictEqual(
-				container.closedWithError,
-				undefined,
-				"Expected undefined since the container was closed without error",
-			);
-		},
-	);
-
-	itExpects(
-		"Closing (with error) then disposing (no error) container should set closedWithError properly",
-		[
-			{ eventName: "fluid:telemetry:Container:ContainerClose", category: "error" },
-			{ eventName: "fluid:telemetry:Container:ContainerDispose", category: "generic" },
-		],
-		async () => {
-			const container = await createConnectedContainer();
-			container.close(new DataCorruptionError("close error", {}));
-			container.dispose();
-
-			assert.strictEqual(
-				container.closedWithError?.message,
-				"close error",
-				"Expected the error that closed the container",
-			);
 		},
 	);