@fluidframework/container-loader 0.52.0 → 0.54.0-47413

package/dist/container.js

@@ -21,6 +21,7 @@ const protocol_definitions_1 = require("@fluidframework/protocol-definitions");
 const telemetry_utils_1 = require("@fluidframework/telemetry-utils");
 const audience_1 = require("./audience");
 const containerContext_1 = require("./containerContext");
+const contracts_1 = require("./contracts");
 const deltaManager_1 = require("./deltaManager");
 const deltaManagerProxy_1 = require("./deltaManagerProxy");
 const loader_1 = require("./loader");
@@ -32,6 +33,7 @@ const containerStorageAdapter_1 = require("./containerStorageAdapter");
 const utils_1 = require("./utils");
 const quorum_1 = require("./quorum");
 const collabWindowTracker_1 = require("./collabWindowTracker");
+const connectionManager_1 = require("./connectionManager");
 const detachedContainerRefSeqNumber = 0;
 const dirtyContainerEvent = "dirty";
 const savedContainerEvent = "saved";
@@ -98,6 +100,8 @@ async function waitContainerToCatchUp(container) {
             waitForOps();
         };
         container.on(telemetry_utils_1.connectedEventName, callback);
+        // TODO: Remove null check after next release #8523
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
         container.resume();
     });
 }
@@ -144,7 +148,6 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         this.subLogger = telemetry_utils_1.ChildLogger.create(loader.services.subLogger, undefined, {
             all: {
                 clientType,
-                loaderVersion: packageVersion_1.pkgVersion,
                 containerId: uuid_1.v4(),
                 docId: () => this.id,
                 containerAttachState: () => this._attachState,
@@ -173,7 +176,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         this.connectionStateHandler = new connectionStateHandler_1.ConnectionStateHandler({
             protocolHandler: () => this._protocolHandler,
             logConnectionStateChangeTelemetry: (value, oldState, reason) => this.logConnectionStateChangeTelemetry(value, oldState, reason),
-            shouldClientJoinWrite: () => this._deltaManager.shouldJoinWrite(),
+            shouldClientJoinWrite: () => this._deltaManager.connectionManager.shouldJoinWrite(),
             maxClientLeaveWaitTime: this.loader.services.options.maxClientLeaveWaitTime,
             logConnectionIssue: (eventName) => {
                 // We get here when socket does not receive any ops on "write" connection, including
@@ -229,22 +232,22 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                 switch (event) {
                     case dirtyContainerEvent:
                         if (this._dirtyContainer) {
-                            listener(dirtyContainerEvent);
+                            listener();
                         }
                         break;
                     case savedContainerEvent:
                         if (!this._dirtyContainer) {
-                            listener(savedContainerEvent);
+                            listener();
                         }
                         break;
                     case telemetry_utils_1.connectedEventName:
                         if (this.connected) {
-                            listener(event, this.clientId);
+                            listener(this.clientId);
                         }
                         break;
                     case telemetry_utils_1.disconnectedEventName:
                         if (!this.connected) {
-                            listener(event);
+                            listener();
                         }
                         break;
                     default:
@@ -291,16 +294,18 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                 container.close(err);
                 onClosed(err);
             });
-        }), { start: true, end: true, cancel: "error" });
+        }), { start: true, end: true, cancel: "generic" });
     }
     /**
      * Create a new container in a detached state.
      */
     static async createDetached(loader, codeDetails) {
         const container = new Container(loader, {});
-        container._lifecycleState = "loading";
-        await container.createDetached(codeDetails);
-        return container;
+        return telemetry_utils_1.PerformanceEvent.timedExecAsync(container.logger, { eventName: "CreateDetached" }, async (_event) => {
+            container._lifecycleState = "loading";
+            await container.createDetached(codeDetails);
+            return container;
+        }, { start: true, end: true, cancel: "generic" });
     }
     /**
      * Create a new container in a detached state that is initialized with a
@@ -308,10 +313,12 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
      */
     static async rehydrateDetachedFromSnapshot(loader, snapshot) {
         const container = new Container(loader, {});
-        const deserializedSummary = JSON.parse(snapshot);
-        container._lifecycleState = "loading";
-        await container.rehydrateDetachedFromSnapshot(deserializedSummary);
-        return container;
+        return telemetry_utils_1.PerformanceEvent.timedExecAsync(container.logger, { eventName: "RehydrateDetachedFromSnapshot" }, async (_event) => {
+            const deserializedSummary = JSON.parse(snapshot);
+            container._lifecycleState = "loading";
+            await container.rehydrateDetachedFromSnapshot(deserializedSummary);
+            return container;
+        }, { start: true, end: true, cancel: "generic" });
     }
     get loaded() {
         return (this._lifecycleState !== "created" && this._lifecycleState !== "loading");
@@ -349,6 +356,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         }
         return this._protocolHandler;
     }
+    get connectionMode() { return this._deltaManager.connectionManager.connectionMode; }
     get IFluidRouter() { return this; }
     get resolvedUrl() {
         return this._resolvedUrl;
@@ -356,31 +364,6 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
     get loadedFromVersion() {
         return this._loadedFromVersion;
     }
-    /**
-     * Tells if container is in read-only mode.
-     * Data stores should listen for "readonly" notifications and disallow user making changes to data stores.
-     * Readonly state can be because of no storage write permission,
-     * or due to host forcing readonly mode for container.
-     *
-     * We do not differentiate here between no write access to storage vs. host disallowing changes to container -
-     * in all cases container runtime and data stores should respect readonly state and not allow local changes.
-     *
-     * It is undefined if we have not yet established websocket connection
-     * and do not know if user has write access to a file.
-     * @deprecated - use readOnlyInfo
-     */
-    get readonly() {
-        return this._deltaManager.readonly;
-    }
-    /**
-     * Tells if user has no write permissions for file in storage
-     * It is undefined if we have not yet established websocket connection
-     * and do not know if user has write access to a file.
-     * @deprecated - use readOnlyInfo
-     */
-    get readonlyPermissions() {
-        return this._deltaManager.readonlyPermissions;
-    }
     get readOnlyInfo() {
         return this._deltaManager.readOnlyInfo;
     }
@@ -388,7 +371,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
      * Tracks host requiring read-only mode.
      */
     forceReadonly(readonly) {
-        this._deltaManager.forceReadonly(readonly);
+        this._deltaManager.connectionManager.forceReadonly(readonly);
     }
     get id() {
         var _a, _b;
@@ -422,7 +405,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
      * Set once this.connected is true, otherwise undefined
      */
     get scopes() {
-        return this._deltaManager.scopes;
+        return this._deltaManager.connectionManager.scopes;
     }
     get clientDetails() {
         return this._deltaManager.clientDetails;
@@ -489,6 +472,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             try {
                 this._deltaManager.close(error);
                 (_a = this._protocolHandler) === null || _a === void 0 ? void 0 : _a.close();
+                this.connectionStateHandler.dispose();
                 (_b = this._context) === null || _b === void 0 ? void 0 : _b.dispose(error !== undefined ? new Error(error.message) : undefined);
                 common_utils_1.assert(this.connectionState === ConnectionState.Disconnected, 0x0cf /* "disconnect event was not raised!" */);
                 (_c = this._storageService) === null || _c === void 0 ? void 0 : _c.dispose();
@@ -538,89 +522,88 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         return JSON.stringify(combinedSummary);
     }
     async attach(request) {
-        if (this._lifecycleState !== "loaded") {
-            throw new container_utils_1.UsageError(`containerNotValidForAttach [${this._lifecycleState}]`);
-        }
-        // If container is already attached or attach is in progress, throw an error.
-        common_utils_1.assert(this._attachState === container_definitions_1.AttachState.Detached && !this.attachStarted, 0x205 /* "attach() called more than once" */);
-        this.attachStarted = true;
-        // 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;
-        try {
-            common_utils_1.assert(this.deltaManager.inbound.length === 0, 0x0d6 /* "Inbound queue should be empty when attaching" */);
-            let summary;
-            if (!hasAttachmentBlobs) {
-                // Get the document state post attach - possibly can just call attach but we need to change the
-                // semantics around what the attach means as far as async code goes.
-                const appSummary = this.context.createSummary();
-                const protocolSummary = this.captureProtocolSummary();
-                summary = driver_utils_1.combineAppAndProtocolSummary(appSummary, protocolSummary);
-                // Set the state as attaching as we are starting the process of attaching container.
-                // This should be fired after taking the summary because it is the place where we are
-                // starting to attach the container to storage.
-                // Also, this should only be fired in detached container.
-                this._attachState = container_definitions_1.AttachState.Attaching;
-                this.context.notifyAttaching();
-            }
-            // Actually go and create the resolved document
-            const createNewResolvedUrl = await this.urlResolver.resolve(request);
-            driver_utils_1.ensureFluidResolvedUrl(createNewResolvedUrl);
-            if (this.service === undefined) {
-                this.service = await driver_utils_1.runWithRetry(async () => this.serviceFactory.createContainer(summary, createNewResolvedUrl, this.subLogger), "containerAttach", this.logger, {});
+        await telemetry_utils_1.PerformanceEvent.timedExecAsync(this.logger, { eventName: "Attach" }, async () => {
+            if (this._lifecycleState !== "loaded") {
+                throw new container_utils_1.UsageError(`containerNotValidForAttach [${this._lifecycleState}]`);
             }
-            const resolvedUrl = this.service.resolvedUrl;
-            driver_utils_1.ensureFluidResolvedUrl(resolvedUrl);
-            this._resolvedUrl = resolvedUrl;
-            await this.connectStorageService();
-            if (hasAttachmentBlobs) {
-                // upload blobs to storage
-                common_utils_1.assert(!!this.loader.services.detachedBlobStorage, 0x24e /* "assertion for type narrowing" */);
-                // build a table mapping IDs assigned locally to IDs assigned by storage and pass it to runtime to
-                // support blob handles that only know about the local IDs
-                const redirectTable = new Map();
-                // if new blobs are added while uploading, upload them too
-                while (redirectTable.size < this.loader.services.detachedBlobStorage.size) {
-                    const newIds = this.loader.services.detachedBlobStorage.getBlobIds().filter((id) => !redirectTable.has(id));
-                    for (const id of newIds) {
-                        const blob = await this.loader.services.detachedBlobStorage.readBlob(id);
-                        const response = await this.storageService.createBlob(blob);
-                        redirectTable.set(id, response.id);
+            // If container is already attached or attach is in progress, throw an error.
+            common_utils_1.assert(this._attachState === container_definitions_1.AttachState.Detached && !this.attachStarted, 0x205 /* "attach() called more than once" */);
+            this.attachStarted = true;
+            // 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;
+            try {
+                common_utils_1.assert(this.deltaManager.inbound.length === 0, 0x0d6 /* "Inbound queue should be empty when attaching" */);
+                let summary;
+                if (!hasAttachmentBlobs) {
+                    // Get the document state post attach - possibly can just call attach but we need to change the
+                    // semantics around what the attach means as far as async code goes.
+                    const appSummary = this.context.createSummary();
+                    const protocolSummary = this.captureProtocolSummary();
+                    summary = driver_utils_1.combineAppAndProtocolSummary(appSummary, protocolSummary);
+                    // Set the state as attaching as we are starting the process of attaching container.
+                    // This should be fired after taking the summary because it is the place where we are
+                    // starting to attach the container to storage.
+                    // Also, this should only be fired in detached container.
+                    this._attachState = container_definitions_1.AttachState.Attaching;
+                    this.context.notifyAttaching();
+                }
+                // Actually go and create the resolved document
+                const createNewResolvedUrl = await this.urlResolver.resolve(request);
+                driver_utils_1.ensureFluidResolvedUrl(createNewResolvedUrl);
+                if (this.service === undefined) {
+                    this.service = await driver_utils_1.runWithRetry(async () => this.serviceFactory.createContainer(summary, createNewResolvedUrl, this.subLogger), "containerAttach", this.logger, {});
+                }
+                const resolvedUrl = this.service.resolvedUrl;
+                driver_utils_1.ensureFluidResolvedUrl(resolvedUrl);
+                this._resolvedUrl = resolvedUrl;
+                await this.connectStorageService();
+                if (hasAttachmentBlobs) {
+                    // upload blobs to storage
+                    common_utils_1.assert(!!this.loader.services.detachedBlobStorage, 0x24e /* "assertion for type narrowing" */);
+                    // build a table mapping IDs assigned locally to IDs assigned by storage and pass it to runtime to
+                    // support blob handles that only know about the local IDs
+                    const redirectTable = new Map();
+                    // if new blobs are added while uploading, upload them too
+                    while (redirectTable.size < this.loader.services.detachedBlobStorage.size) {
+                        const newIds = this.loader.services.detachedBlobStorage.getBlobIds().filter((id) => !redirectTable.has(id));
+                        for (const id of newIds) {
+                            const blob = await this.loader.services.detachedBlobStorage.readBlob(id);
+                            const response = await this.storageService.createBlob(blob);
+                            redirectTable.set(id, response.id);
+                        }
                     }
+                    // take summary and upload
+                    const appSummary = this.context.createSummary(redirectTable);
+                    const protocolSummary = this.captureProtocolSummary();
+                    summary = driver_utils_1.combineAppAndProtocolSummary(appSummary, protocolSummary);
+                    this._attachState = container_definitions_1.AttachState.Attaching;
+                    this.context.notifyAttaching();
+                    await this.storageService.uploadSummaryWithContext(summary, {
+                        referenceSequenceNumber: 0,
+                        ackHandle: undefined,
+                        proposalHandle: undefined,
+                    });
+                }
+                this._attachState = container_definitions_1.AttachState.Attached;
+                this.emit("attached");
+                // Propagate current connection state through the system.
+                this.propagateConnectionState();
+                if (!this.closed) {
+                    this.resumeInternal({ fetchOpsFromStorage: false, reason: "createDetached" });
                 }
-                // take summary and upload
-                const appSummary = this.context.createSummary(redirectTable);
-                const protocolSummary = this.captureProtocolSummary();
-                summary = driver_utils_1.combineAppAndProtocolSummary(appSummary, protocolSummary);
-                this._attachState = container_definitions_1.AttachState.Attaching;
-                this.context.notifyAttaching();
-                await this.storageService.uploadSummaryWithContext(summary, {
-                    referenceSequenceNumber: 0,
-                    ackHandle: undefined,
-                    proposalHandle: undefined,
-                });
-            }
-            this._attachState = container_definitions_1.AttachState.Attached;
-            this.emit("attached");
-            // Propagate current connection state through the system.
-            this.propagateConnectionState();
-            if (!this.closed) {
-                this.resumeInternal({ fetchOpsFromStorage: false, reason: "createDetached" });
             }
-        }
-        catch (error) {
-            // we should retry upon any retriable errors, so we shouldn't see them here
-            common_utils_1.assert(!driver_utils_1.canRetryOnError(error), 0x24f /* "retriable error thrown from attach()" */);
-            // add resolved URL on error object so that host has the ability to find this document and delete it
-            const newError = telemetry_utils_1.normalizeError(error);
-            const resolvedUrl = this.resolvedUrl;
-            if (resolvedUrl) {
-                driver_utils_1.ensureFluidResolvedUrl(resolvedUrl);
-                newError.addTelemetryProperties({ resolvedUrl: resolvedUrl.url });
+            catch (error) {
+                // add resolved URL on error object so that host has the ability to find this document and delete it
+                const newError = telemetry_utils_1.normalizeError(error);
+                const resolvedUrl = this.resolvedUrl;
+                if (driver_utils_1.isFluidResolvedUrl(resolvedUrl)) {
+                    newError.addTelemetryProperties({ resolvedUrl: resolvedUrl.url });
+                }
+                this.close(newError);
+                throw newError;
             }
-            this.close(newError);
-            throw newError;
-        }
+        }, { start: true, end: true, cancel: "generic" });
     }
     async request(path) {
         return telemetry_utils_1.PerformanceEvent.timedExecAsync(this.logger, { eventName: "Request" }, async () => this.context.request(path), { end: true, cancel: "error" });
@@ -648,8 +631,8 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         if (this.closed) {
             throw new Error("Attempting to setAutoReconnect() a closed Container");
         }
-        const mode = reconnect ? deltaManager_1.ReconnectMode.Enabled : deltaManager_1.ReconnectMode.Disabled;
-        const currentMode = this._deltaManager.reconnectMode;
+        const mode = reconnect ? contracts_1.ReconnectMode.Enabled : contracts_1.ReconnectMode.Disabled;
+        const currentMode = this._deltaManager.connectionManager.reconnectMode;
         if (currentMode === mode) {
             return;
         }
@@ -658,11 +641,11 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         this.setAutoReconnectTime = now;
         this.logger.sendTelemetryEvent({
             eventName: reconnect ? "AutoReconnectEnabled" : "AutoReconnectDisabled",
-            connectionMode: this._deltaManager.connectionMode,
+            connectionMode: this.connectionMode,
             connectionState: ConnectionState[this.connectionState],
             duration,
         });
-        this._deltaManager.setAutoReconnect(mode);
+        this._deltaManager.connectionManager.setAutoReconnect(mode);
         // If container state is not attached and resumed, then don't connect to delta stream. Also don't set the
         // manual reconnection flag to true as we haven't made the initial connection yet.
         if (reconnect && this._attachState === container_definitions_1.AttachState.Attached && this.resumedOpProcessingAfterLoad) {
@@ -671,13 +654,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                 this.manualReconnectInProgress = true;
             }
             // Ensure connection to web socket
-            this.connectToDeltaStream({ reason: "autoReconnect" }).catch((error) => {
-                // All errors are reported through events ("error" / "disconnected") and telemetry in DeltaManager
-                // So there shouldn't be a need to record error here.
-                // But we have number of cases where reconnects do not happen, and no errors are recorded, so
-                // adding this log point for easier diagnostics
-                this.logger.sendTelemetryEvent({ eventName: "setAutoReconnectError" }, error);
-            });
+            this.connectToDeltaStream({ reason: "autoReconnect" });
         }
     }
     resume() {
@@ -697,8 +674,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             this._deltaManager.inboundSignal.resume();
         }
         // Ensure connection to web socket
-        // All errors are reported through events ("error" / "disconnected") and telemetry in DeltaManager
-        this.connectToDeltaStream(args).catch(() => { });
+        this.connectToDeltaStream(args);
     }
     /**
      * Raise non-critical error to host. Calling this API will not close container.
@@ -825,13 +801,13 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             this.connectionTransitionTimes[ConnectionState.Disconnected] = common_utils_1.performance.now();
         }
     }
-    async connectToDeltaStream(args) {
+    connectToDeltaStream(args) {
         this.recordConnectStartTime();
         // All agents need "write" access, including summarizer.
         if (!this._canReconnect || !this.client.details.capabilities.interactive) {
             args.mode = "write";
         }
-        return this._deltaManager.connect(args);
+        this._deltaManager.connect(args);
     }
     /**
      * Load container.
@@ -845,7 +821,6 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             throw new Error("Attempting to load without a resolved url");
         }
         this.service = await this.serviceFactory.createDocumentService(this._resolvedUrl, this.subLogger);
-        let startConnectionP;
         // Ideally we always connect as "read" by default.
         // Currently that works with SPO & r11s, because we get "write" connection when connecting to non-existing file.
         // We should not rely on it by (one of them will address the issue, but we need to address both)
@@ -859,8 +834,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         // Start websocket connection as soon as possible. Note that there is no op handler attached yet, but the
         // DeltaManager is resilient to this and will wait to start processing ops until after it is attached.
         if (loadMode.deltaConnection === undefined) {
-            startConnectionP = this.connectToDeltaStream(connectionArgs);
-            startConnectionP.catch((error) => { });
+            this.connectToDeltaStream(connectionArgs);
         }
         await this.connectStorageService();
         this._attachState = container_definitions_1.AttachState.Attached;
@@ -1114,6 +1088,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         if (this.clientDetailsOverride !== undefined) {
             merge_1.default(client.details, this.clientDetailsOverride);
         }
+        client.details.environment = [client.details.environment, ` loaderVersion:${packageVersion_1.pkgVersion}`].join(";");
         return client;
     }
     /**
@@ -1123,17 +1098,12 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
      * If it's not true, runtime is not in position to send ops.
      */
     activeConnection() {
-        const active = this.connectionState === ConnectionState.Connected &&
-            this._deltaManager.connectionMode === "write";
-        // Check for presence of current client in quorum for "write" connections - inactive clients
-        // would get leave op after some long timeout (5 min) and that should automatically transition
-        // state to "read" mode.
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        common_utils_1.assert(!active || this.getQuorum().getMember(this.clientId) !== undefined, 0x276 /* "active connection not present in quorum" */);
-        return active;
+        return this.connectionState === ConnectionState.Connected &&
+            this.connectionMode === "write";
     }
     createDeltaManager() {
-        const deltaManager = new deltaManager_1.DeltaManager(() => this.service, this.client, telemetry_utils_1.ChildLogger.create(this.subLogger, "DeltaManager"), this._canReconnect, () => this.activeConnection());
+        const serviceProvider = () => this.service;
+        const deltaManager = new deltaManager_1.DeltaManager(serviceProvider, telemetry_utils_1.ChildLogger.create(this.subLogger, "DeltaManager"), () => this.activeConnection(), (props) => new connectionManager_1.ConnectionManager(serviceProvider, this.client, this._canReconnect, telemetry_utils_1.ChildLogger.create(this.subLogger, "ConnectionManager"), props));
         // Disable inbound queues as Container is not ready to accept any ops until we are fully loaded!
         // eslint-disable-next-line @typescript-eslint/no-floating-promises
         deltaManager.inbound.pause();
@@ -1141,12 +1111,12 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         deltaManager.inboundSignal.pause();
         deltaManager.on("connect", (details, opsBehind) => {
             var _a;
-            this.connectionStateHandler.receivedConnectEvent(this._deltaManager.connectionMode, details);
             // Back-compat for new client and old server.
             this._audience.clear();
             for (const priorClient of (_a = details.initialClients) !== null && _a !== void 0 ? _a : []) {
                 this._audience.addMember(priorClient.clientId, priorClient.client);
             }
+            this.connectionStateHandler.receivedConnectEvent(this.connectionMode, details);
         });
         deltaManager.on("disconnect", (reason) => {
             this.manualReconnectInProgress = false;
@@ -1184,7 +1154,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         let checkpointSequenceNumber;
         let opsBehind;
         if (value === ConnectionState.Disconnected) {
-            autoReconnect = this._deltaManager.reconnectMode;
+            autoReconnect = this._deltaManager.connectionManager.reconnectMode;
         }
         else {
             if (value === ConnectionState.Connected) {
@@ -1211,8 +1181,8 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         this.logger.sendPerformanceEvent(Object.assign({ eventName: `ConnectionStateChange_${ConnectionState[value]}`, from: ConnectionState[oldState], duration,
             durationFromDisconnected,
             reason,
-            connectionInitiationReason, socketDocumentId: this._deltaManager.socketDocumentId, pendingClientId: this.connectionStateHandler.pendingClientId, clientId: this.clientId, autoReconnect,
-            opsBehind, online: driver_utils_1.OnlineStatus[driver_utils_1.isOnline()], lastVisible: this.lastVisible !== undefined ? common_utils_1.performance.now() - this.lastVisible : undefined, checkpointSequenceNumber }, this._deltaManager.connectionProps()));
+            connectionInitiationReason, pendingClientId: this.connectionStateHandler.pendingClientId, clientId: this.clientId, autoReconnect,
+            opsBehind, online: driver_utils_1.OnlineStatus[driver_utils_1.isOnline()], lastVisible: this.lastVisible !== undefined ? common_utils_1.performance.now() - this.lastVisible : undefined, checkpointSequenceNumber }, this._deltaManager.connectionProps));
         if (value === ConnectionState.Connected) {
             this.firstConnection = false;
             this.manualReconnectInProgress = false;
@@ -1221,7 +1191,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
     propagateConnectionState() {
         const logOpsOnReconnect = this.connectionState === ConnectionState.Connected &&
             !this.firstConnection &&
-            this._deltaManager.connectionMode === "write";
+            this.connectionMode === "write";
         if (logOpsOnReconnect) {
             this.messageCountAfterDisconnection = 0;
         }