@fluidframework/driver-base 1.4.0-121020 → 2.0.0-dev-rc.1.0.0.224419

package/dist/{documentDeltaConnection.js → documentDeltaConnection.cjs}

@@ -5,32 +5,55 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DocumentDeltaConnection = void 0;
-const common_utils_1 = require("@fluidframework/common-utils");
+const core_utils_1 = require("@fluidframework/core-utils");
 const driver_utils_1 = require("@fluidframework/driver-utils");
 const protocol_definitions_1 = require("@fluidframework/protocol-definitions");
+const core_interfaces_1 = require("@fluidframework/core-interfaces");
 const telemetry_utils_1 = require("@fluidframework/telemetry-utils");
 // For now, this package is versioned and released in unison with the specific drivers
-const packageVersion_1 = require("./packageVersion");
+const packageVersion_1 = require("./packageVersion.cjs");
 /**
- * Represents a connection to a stream of delta updates
+ * Represents a connection to a stream of delta updates.
+ * @internal
  */
 class DocumentDeltaConnection extends telemetry_utils_1.EventEmitterWithErrorHandling {
+    get hasDetails() {
+        return !!this._details;
+    }
+    get disposed() {
+        (0, core_utils_1.assert)(this._disposed || this.socket.connected, 0x244 /* "Socket is closed, but connection is not!" */);
+        return this._disposed;
+    }
+    /**
+     * @deprecated Implementors should manage their own logger or monitoring context
+     */
+    get logger() {
+        return this.mc.logger;
+    }
+    get details() {
+        if (!this._details) {
+            throw new Error("Internal error: calling method before _details is initialized!");
+        }
+        return this._details;
+    }
     /**
      * @param socket - websocket to be used
      * @param documentId - ID of the document
      * @param logger - for reporting telemetry events
      * @param enableLongPollingDowngrades - allow connection to be downgraded to long-polling on websocket failure
      */
-    constructor(socket, documentId, logger, enableLongPollingDowngrades = false) {
+    constructor(socket, documentId, logger, enableLongPollingDowngrades = false, connectionId) {
         super((name, error) => {
+            this.addPropsToError(error);
             logger.sendErrorEvent({
                 eventName: "DeltaConnection:EventException",
-                name,
+                name: name,
             }, error);
         });
         this.socket = socket;
         this.documentId = documentId;
         this.enableLongPollingDowngrades = enableLongPollingDowngrades;
+        this.connectionId = connectionId;
         // Listen for ops sent before we receive a response to connect_document
         this.queuedMessages = [];
         this.queuedSignals = [];
@@ -52,14 +75,19 @@ class DocumentDeltaConnection extends telemetry_utils_1.EventEmitterWithErrorHan
             this.queuedMessages.push(...msgs);
         };
         this.earlySignalHandler = (msg) => {
-            this.queuedSignals.push(msg);
+            if (Array.isArray(msg)) {
+                this.queuedSignals.push(...msg);
+            }
+            else {
+                this.queuedSignals.push(msg);
+            }
         };
-        this.mc = (0, telemetry_utils_1.loggerToMonitoringContext)(telemetry_utils_1.ChildLogger.create(logger, "DeltaConnection"));
-        this.on("newListener", (event, listener) => {
-            (0, common_utils_1.assert)(!this.disposed, 0x20a /* "register for event on disposed object" */);
+        this.mc = (0, telemetry_utils_1.createChildMonitoringContext)({ logger, namespace: "DeltaConnection" });
+        this.on("newListener", (event, _listener) => {
+            (0, core_utils_1.assert)(!this.disposed, 0x20a /* "register for event on disposed object" */);
             // Some events are already forwarded - see this.addTrackedListener() calls in initialize().
             if (DocumentDeltaConnection.eventsAlwaysForwarded.includes(event)) {
-                (0, common_utils_1.assert)(this.trackedListeners.has(event), 0x245 /* "tracked listener" */);
+                (0, core_utils_1.assert)(this.trackedListeners.has(event), 0x245 /* "tracked listener" */);
                 return;
             }
             if (!DocumentDeltaConnection.eventsToForward.includes(event)) {
@@ -70,33 +98,31 @@ class DocumentDeltaConnection extends telemetry_utils_1.EventEmitterWithErrorHan
             // and that there are no "internal" listeners installed (like "error" case we skip above)
             // Better flow might be to always unconditionally register all handlers on successful connection,
             // though some logic (naming assert in initialMessages getter) might need to be adjusted (it becomes noop)
-            (0, common_utils_1.assert)((this.listeners(event).length !== 0) === this.trackedListeners.has(event), 0x20b /* "mismatch" */);
+            (0, core_utils_1.assert)((this.listeners(event).length !== 0) === this.trackedListeners.has(event), 0x20b /* "mismatch" */);
             if (!this.trackedListeners.has(event)) {
-                this.addTrackedListener(event, (...args) => {
-                    this.emit(event, ...args);
-                });
+                if (event === "pong") {
+                    // Empty callback for tracking purposes in this class
+                    this.trackedListeners.set("pong", () => { });
+                    const sendPingLoop = () => {
+                        const start = Date.now();
+                        this.socket.volatile?.emit("ping", () => {
+                            this.emit("pong", Date.now() - start);
+                            // Schedule another ping event in 1 minute
+                            this.trackLatencyTimeout = setTimeout(() => {
+                                sendPingLoop();
+                            }, 1000 * 60);
+                        });
+                    };
+                    sendPingLoop();
+                }
+                else {
+                    this.addTrackedListener(event, (...args) => {
+                        this.emit(event, ...args);
+                    });
+                }
             }
         });
     }
-    get hasDetails() {
-        return !!this._details;
-    }
-    get disposed() {
-        (0, common_utils_1.assert)(this._disposed || this.socket.connected, 0x244 /* "Socket is closed, but connection is not!" */);
-        return this._disposed;
-    }
-    /**
-     * @deprecated - Implementors should manage their own logger or monitoring context
-     */
-    get logger() {
-        return this.mc.logger;
-    }
-    get details() {
-        if (!this._details) {
-            throw new Error("Internal error: calling method before _details is initialized!");
-        }
-        return this._details;
-    }
     /**
      * Get the ID of the client who is sending the message
      *
@@ -149,8 +175,8 @@ class DocumentDeltaConnection extends telemetry_utils_1.EventEmitterWithErrorHan
     get serviceConfiguration() {
         return this.details.serviceConfiguration;
     }
-    checkNotClosed() {
-        (0, common_utils_1.assert)(!this.disposed, 0x20c /* "connection disposed" */);
+    checkNotDisposed() {
+        (0, core_utils_1.assert)(!this.disposed, 0x20c /* "connection disposed" */);
     }
     /**
      * Get messages sent during the connection
@@ -158,12 +184,12 @@ class DocumentDeltaConnection extends telemetry_utils_1.EventEmitterWithErrorHan
      * @returns messages sent during the connection
      */
     get initialMessages() {
-        this.checkNotClosed();
+        this.checkNotDisposed();
         // If we call this when the earlyOpHandler is not attached, then the queuedMessages may not include the
         // latest ops.  This could possibly indicate that initialMessages was called twice.
-        (0, common_utils_1.assert)(this.earlyOpHandlerAttached, 0x08e /* "Potentially missed initial messages" */);
+        (0, core_utils_1.assert)(this.earlyOpHandlerAttached, 0x08e /* "Potentially missed initial messages" */);
         // We will lose ops and perf will tank as we need to go to storage to become current!
-        (0, common_utils_1.assert)(this.listeners("op").length !== 0, 0x08f /* "No op handler is setup!" */);
+        (0, core_utils_1.assert)(this.listeners("op").length !== 0, 0x08f /* "No op handler is setup!" */);
         this.removeEarlyOpHandler();
         if (this.queuedMessages.length > 0) {
             // Some messages were queued.
@@ -180,8 +206,8 @@ class DocumentDeltaConnection extends telemetry_utils_1.EventEmitterWithErrorHan
      * @returns signals sent during the connection
      */
     get initialSignals() {
-        this.checkNotClosed();
-        (0, common_utils_1.assert)(this.listeners("signal").length !== 0, 0x090 /* "No signal handler is setup!" */);
+        this.checkNotDisposed();
+        (0, core_utils_1.assert)(this.listeners("signal").length !== 0, 0x090 /* "No signal handler is setup!" */);
         this.removeEarlySignalHandler();
         if (this.queuedSignals.length > 0) {
             // Some signals were queued.
@@ -197,7 +223,7 @@ class DocumentDeltaConnection extends telemetry_utils_1.EventEmitterWithErrorHan
      * @returns initial client list sent during the connection
      */
     get initialClients() {
-        this.checkNotClosed();
+        this.checkNotDisposed();
         return this.details.initialClients;
     }
     emitMessages(type, messages) {
@@ -208,59 +234,89 @@ class DocumentDeltaConnection extends telemetry_utils_1.EventEmitterWithErrorHan
             this.socket.emit(type, this.clientId, messages);
         }
     }
-    submitCore(type, messages) {
-        this.emitMessages(type, [messages]);
-    }
     /**
      * Submits a new delta operation to the server
      *
      * @param message - delta operation to submit
      */
     submit(messages) {
-        this.checkNotClosed();
-        this.submitCore("submitOp", messages);
+        this.checkNotDisposed();
+        this.emitMessages("submitOp", [messages]);
     }
     /**
      * Submits a new signal to the server
      *
-     * @param message - signal to submit
+     * @param content - Content of the signal.
+     * @param targetClientId - When specified, the signal is only sent to the provided client id.
+     */
+    submitSignal(content, targetClientId) {
+        this.checkNotDisposed();
+        if (targetClientId && this.details.supportedFeatures?.submit_signals_v2 !== true) {
+            throw new driver_utils_1.UsageError("Sending signals to specific client ids is not supported.");
+        }
+        this.emitMessages("submitSignal", [[content]]);
+    }
+    /**
+     * Disconnect from the websocket and close the websocket too.
      */
-    submitSignal(message) {
-        this.checkNotClosed();
-        this.submitCore("submitSignal", [message]);
+    closeSocket(error) {
+        if (this._disposed) {
+            // This would be rare situation due to complexity around socket emitting events.
+            return;
+        }
+        this.closeSocketCore(error);
+    }
+    closeSocketCore(error) {
+        this.disconnect(error);
     }
     /**
-     * Disconnect from the websocket, and permanently disable this DocumentDeltaConnection.
+     * Disconnect from the websocket, and permanently disable this DocumentDeltaConnection and close the socket.
+     * However the OdspDocumentDeltaConnection differ in dispose as in there we don't close the socket. There is no
+     * multiplexing here, so we need to close the socket here.
      */
     dispose() {
-        this.disposeCore(false, // socketProtocolError
-        (0, driver_utils_1.createGenericNetworkError)(
+        this.logger.sendTelemetryEvent({
+            eventName: "ClientClosingDeltaConnection",
+            driverVersion: packageVersion_1.pkgVersion,
+            details: JSON.stringify({
+                ...this.getConnectionDetailsProps(),
+            }),
+        });
+        this.disconnect((0, driver_utils_1.createGenericNetworkError)(
         // pre-0.58 error message: clientClosingConnection
         "Client closing delta connection", { canRetry: true }, { driverVersion: packageVersion_1.pkgVersion }));
     }
-    disposeCore(socketProtocolError, err) {
+    disconnect(err) {
         // Can't check this.disposed here, as we get here on socket closure,
         // so _disposed & socket.connected might be not in sync while processing
         // "dispose" event.
         if (this._disposed) {
             return;
         }
+        if (this.trackLatencyTimeout !== undefined) {
+            clearTimeout(this.trackLatencyTimeout);
+            this.trackLatencyTimeout = undefined;
+        }
         // We set the disposed flag as a part of the contract for overriding the disconnect method. This is used by
         // DocumentDeltaConnection to determine if emitting messages (ops) on the socket is allowed, which is
         // important since OdspDocumentDeltaConnection reuses the socket rather than truly disconnecting it. Note that
         // OdspDocumentDeltaConnection may still send disconnect_document which is allowed; this is only intended
         // to prevent normal messages from being emitted.
         this._disposed = true;
+        // Remove all listeners listening on the socket. These are listeners on socket and not on this connection
+        // object. Anyway since we have disposed this connection object, nobody should listen to event on socket
+        // anymore.
         this.removeTrackedListeners();
-        this.disconnect(socketProtocolError, err);
+        // Clear the connection/socket before letting the deltaManager/connection manager know about the disconnect.
+        this.disconnectCore();
+        // Let user of connection object know about disconnect.
+        this.emit("disconnect", err);
     }
     /**
      * Disconnect from the websocket.
-     * @param socketProtocolError - true if error happened on socket / socket.io protocol level
-     *  (not on Fluid protocol level)
      * @param reason - reason for disconnect
      */
-    disconnect(socketProtocolError, reason) {
+    disconnectCore() {
         this.socket.disconnect();
     }
     async initialize(connectMessage, timeout) {
@@ -270,23 +326,56 @@ class DocumentDeltaConnection extends telemetry_utils_1.EventEmitterWithErrorHan
         // Socket.io's reconnect_attempt event is unreliable, so we track connect_error count instead.
         let internalSocketConnectionFailureCount = 0;
         const isInternalSocketReconnectionEnabled = () => this.socket.io.reconnection();
-        const getMaxInternalSocketReconnectionAttempts = () => isInternalSocketReconnectionEnabled()
-            ? this.socket.io.reconnectionAttempts()
-            : 0;
+        const getMaxInternalSocketReconnectionAttempts = () => isInternalSocketReconnectionEnabled() ? this.socket.io.reconnectionAttempts() : 0;
         const getMaxAllowedInternalSocketConnectionFailures = () => getMaxInternalSocketReconnectionAttempts() + 1;
         this._details = await new Promise((resolve, reject) => {
-            const fail = (socketProtocolError, err) => {
-                this.disposeCore(socketProtocolError, err);
+            const failAndCloseSocket = (err) => {
+                try {
+                    this.closeSocket(err);
+                }
+                catch (failError) {
+                    const normalizedError = this.addPropsToError(failError);
+                    this.logger.sendErrorEvent({ eventName: "CloseSocketError" }, normalizedError);
+                }
+                reject(err);
+            };
+            const failConnection = (err) => {
+                try {
+                    this.disconnect(err);
+                }
+                catch (failError) {
+                    const normalizedError = this.addPropsToError(failError);
+                    this.logger.sendErrorEvent({ eventName: "FailConnectionError" }, normalizedError);
+                }
                 reject(err);
             };
+            // Immediately set the connection timeout.
+            // Give extra 2 seconds for handshake on top of socket connection timeout.
+            this.socketConnectionTimeout = setTimeout(() => {
+                failConnection(this.createErrorObject("orderingServiceHandshakeTimeout"));
+            }, timeout + 2000);
             // Listen for connection issues
             this.addConnectionListener("connect_error", (error) => {
-                var _a;
                 internalSocketConnectionFailureCount++;
                 let isWebSocketTransportError = false;
                 try {
-                    const description = error === null || error === void 0 ? void 0 : error.description;
-                    if (description && typeof description === "object") {
+                    const description = error?.description;
+                    const context = error?.context;
+                    if (context && typeof context === "object") {
+                        const statusText = context.statusText?.code;
+                        // Self-Signed Certificate ErrorCode Found in error.context
+                        if (statusText === "DEPTH_ZERO_SELF_SIGNED_CERT") {
+                            failAndCloseSocket(this.createErrorObject("connect_error", error, false));
+                            return;
+                        }
+                    }
+                    else if (description && typeof description === "object") {
+                        const errorCode = description.error?.code;
+                        // Self-Signed Certificate ErrorCode Found in error.description
+                        if (errorCode === "DEPTH_ZERO_SELF_SIGNED_CERT") {
+                            failAndCloseSocket(this.createErrorObject("connect_error", error, false));
+                            return;
+                        }
                         if (error.type === "TransportError") {
                             isWebSocketTransportError = true;
                         }
@@ -298,7 +387,7 @@ class DocumentDeltaConnection extends telemetry_utils_1.EventEmitterWithErrorHan
                 // Handle socket transport downgrading when not offline.
                 if (isWebSocketTransportError &&
                     this.enableLongPollingDowngrades &&
-                    ((_a = this.socket.io.opts.transports) === null || _a === void 0 ? void 0 : _a[0]) !== "polling") {
+                    this.socket.io.opts.transports?.[0] !== "polling") {
                     // Downgrade transports to polling upgrade mechanism.
                     this.socket.io.opts.transports = ["polling", "websocket"];
                     // Don't alter reconnection behavior if already enabled.
@@ -310,15 +399,16 @@ class DocumentDeltaConnection extends telemetry_utils_1.EventEmitterWithErrorHan
                 }
                 // Allow built-in socket.io reconnection handling.
                 if (isInternalSocketReconnectionEnabled() &&
-                    internalSocketConnectionFailureCount < getMaxAllowedInternalSocketConnectionFailures()) {
+                    internalSocketConnectionFailureCount <
+                        getMaxAllowedInternalSocketConnectionFailures()) {
                     // Reconnection is enabled and maximum reconnect attempts have not been reached.
                     return;
                 }
-                fail(true, this.createErrorObject("connect_error", error));
+                failAndCloseSocket(this.createErrorObject("connect_error", error));
             });
             // Listen for timeouts
             this.addConnectionListener("connect_timeout", () => {
-                fail(true, this.createErrorObject("connect_timeout"));
+                failAndCloseSocket(this.createErrorObject("connect_timeout"));
             });
             this.addConnectionListener("connect_document_success", (response) => {
                 // If we sent a nonce and the server supports nonces, check that the nonces match
@@ -334,16 +424,20 @@ class DocumentDeltaConnection extends telemetry_utils_1.EventEmitterWithErrorHan
                     // The only time we expect a mismatch in requested/actual is if we lack write permissions
                     // In this case we will get "read", even if we requested "write"
                     if (actualMode !== requestedMode) {
-                        fail(false, this.createErrorObject("connect_document_success", "Connected in a different mode than was requested", false));
+                        failConnection(this.createErrorObject("connect_document_success", "Connected in a different mode than was requested", false));
                         return;
                     }
                 }
                 else {
                     if (actualMode === "write") {
-                        fail(false, this.createErrorObject("connect_document_success", "Connected in write mode without write permissions", false));
+                        failConnection(this.createErrorObject("connect_document_success", "Connected in write mode without write permissions", false));
                         return;
                     }
                 }
+                this.logger.sendTelemetryEvent({
+                    eventName: "ConnectDocumentSuccess",
+                    pendingClientId: response.clientId,
+                }, undefined, core_interfaces_1.LogLevel.verbose);
                 this.checkpointSequenceNumber = response.checkpointSequenceNumber;
                 this.removeConnectionListeners();
                 resolve(response);
@@ -351,20 +445,20 @@ class DocumentDeltaConnection extends telemetry_utils_1.EventEmitterWithErrorHan
             // Socket can be disconnected while waiting for Fluid protocol messages
             // (connect_document_error / connect_document_success), as well as before DeltaManager
             // had a chance to register its handlers.
-            this.addTrackedListener("disconnect", (reason) => {
-                const err = this.createErrorObject("disconnect", reason);
-                this.emit("disconnect", err);
-                fail(true, err);
+            this.addTrackedListener("disconnect", (reason, details) => {
+                failAndCloseSocket(this.createErrorObjectWithProps("disconnect", reason, {
+                    socketErrorType: details?.context?.type,
+                    // https://www.rfc-editor.org/rfc/rfc6455#section-7.4
+                    socketCode: details?.context?.code,
+                }));
             });
-            this.addTrackedListener("error", ((error) => {
-                // First, raise an error event, to give clients a chance to observe error contents
+            this.addTrackedListener("error", (error) => {
                 // This includes "Invalid namespace" error, which we consider critical (reconnecting will not help)
                 const err = this.createErrorObject("error", error, error !== "Invalid namespace");
-                this.emit("error", err);
                 // Disconnect socket - required if happened before initial handshake
-                fail(true, err);
-            }));
-            this.addConnectionListener("connect_document_error", ((error) => {
+                failAndCloseSocket(err);
+            });
+            this.addConnectionListener("connect_document_error", (error) => {
                 // If we sent a nonce and the server supports nonces, check that the nonces match
                 if (connectMessage.nonce !== undefined &&
                     error.nonce !== undefined &&
@@ -373,15 +467,29 @@ class DocumentDeltaConnection extends telemetry_utils_1.EventEmitterWithErrorHan
                 }
                 // This is not an socket.io error - it's Fluid protocol error.
                 // In this case fail connection and indicate that we were unable to create connection
-                fail(false, this.createErrorObject("connect_document_error", error));
-            }));
+                failConnection(this.createErrorObject("connect_document_error", error));
+            });
             this.socket.emit("connect_document", connectMessage);
-            // Give extra 2 seconds for handshake on top of socket connection timeout
-            this.socketConnectionTimeout = setTimeout(() => {
-                fail(false, this.createErrorObject("orderingServiceHandshakeTimeout"));
-            }, timeout + 2000);
         });
-        (0, common_utils_1.assert)(!this.disposed, 0x246 /* "checking consistency of socket & _disposed flags" */);
+        (0, core_utils_1.assert)(!this.disposed, 0x246 /* "checking consistency of socket & _disposed flags" */);
+    }
+    addPropsToError(errorToBeNormalized) {
+        const normalizedError = (0, telemetry_utils_1.normalizeError)(errorToBeNormalized, {
+            props: {
+                details: JSON.stringify({
+                    ...this.getConnectionDetailsProps(),
+                }),
+            },
+        });
+        return normalizedError;
+    }
+    getConnectionDetailsProps() {
+        return {
+            disposed: this._disposed,
+            socketConnected: this.socket?.connected,
+            clientId: this._details?.clientId,
+            connectionId: this.connectionId,
+        };
     }
     removeEarlyOpHandler() {
         this.socket.removeListener("op", this.earlyOpHandler);
@@ -391,15 +499,15 @@ class DocumentDeltaConnection extends telemetry_utils_1.EventEmitterWithErrorHan
         this.socket.removeListener("signal", this.earlySignalHandler);
     }
     addConnectionListener(event, listener) {
-        (0, common_utils_1.assert)(!DocumentDeltaConnection.eventsAlwaysForwarded.includes(event), 0x247 /* "Use addTrackedListener instead" */);
-        (0, common_utils_1.assert)(!DocumentDeltaConnection.eventsToForward.includes(event), 0x248 /* "should not subscribe to forwarded events" */);
+        (0, core_utils_1.assert)(!DocumentDeltaConnection.eventsAlwaysForwarded.includes(event), 0x247 /* "Use addTrackedListener instead" */);
+        (0, core_utils_1.assert)(!DocumentDeltaConnection.eventsToForward.includes(event), 0x248 /* "should not subscribe to forwarded events" */);
         this.socket.on(event, listener);
-        (0, common_utils_1.assert)(!this.connectionListeners.has(event), 0x20d /* "double connection listener" */);
+        (0, core_utils_1.assert)(!this.connectionListeners.has(event), 0x20d /* "double connection listener" */);
         this.connectionListeners.set(event, listener);
     }
     addTrackedListener(event, listener) {
         this.socket.on(event, listener);
-        (0, common_utils_1.assert)(!this.trackedListeners.has(event), 0x20e /* "double tracked listener" */);
+        (0, core_utils_1.assert)(!this.trackedListeners.has(event), 0x20e /* "double tracked listener" */);
         this.trackedListeners.set(event, listener);
     }
     removeTrackedListeners() {
@@ -421,29 +529,36 @@ class DocumentDeltaConnection extends telemetry_utils_1.EventEmitterWithErrorHan
         }
         this.connectionListeners.clear();
     }
+    getErrorMessage(error) {
+        if (error?.type !== "TransportError") {
+            return (0, telemetry_utils_1.extractLogSafeErrorProperties)(error, true).message;
+        }
+        // JSON.stringify drops Error.message
+        const messagePrefix = error?.message !== undefined ? `${error.message}: ` : "";
+        // Websocket errors reported by engine.io-client.
+        // They are Error objects with description containing WS error and description = "TransportError"
+        // Please see https://github.com/socketio/engine.io-client/blob/7245b80/lib/transport.ts#L44,
+        return `${messagePrefix}${JSON.stringify(error, (0, telemetry_utils_1.getCircularReplacer)())}`;
+    }
+    createErrorObjectWithProps(handler, error, props, canRetry = true) {
+        return (0, driver_utils_1.createGenericNetworkError)(`socket.io (${handler}): ${this.getErrorMessage(error)}`, { canRetry }, {
+            ...props,
+            driverVersion: packageVersion_1.pkgVersion,
+            details: JSON.stringify({
+                ...this.getConnectionDetailsProps(),
+            }),
+        });
+    }
     /**
      * Error raising for socket.io issues
      */
     createErrorObject(handler, error, canRetry = true) {
-        // Note: we suspect the incoming error object is either:
-        // - a string: log it in the message (if not a string, it may contain PII but will print as [object Object])
-        // - an Error object thrown by socket.io engine. Be careful with not recording PII!
-        let message;
-        if ((error === null || error === void 0 ? void 0 : error.type) === "TransportError") {
-            // JSON.stringify drops Error.message
-            const messagePrefix = ((error === null || error === void 0 ? void 0 : error.message) !== undefined)
-                ? `${error.message}: `
-                : "";
-            // Websocket errors reported by engine.io-client.
-            // They are Error objects with description containing WS error and description = "TransportError"
-            // Please see https://github.com/socketio/engine.io-client/blob/7245b80/lib/transport.ts#L44,
-            message = `${messagePrefix}${JSON.stringify(error, (0, telemetry_utils_1.getCircularReplacer)())}`;
-        }
-        else {
-            message = (0, common_utils_1.extractLogSafeErrorProperties)(error).message;
-        }
-        const errorObj = (0, driver_utils_1.createGenericNetworkError)(`socket.io (${handler}): ${message}`, { canRetry }, { driverVersion: packageVersion_1.pkgVersion });
-        return errorObj;
+        return (0, driver_utils_1.createGenericNetworkError)(`socket.io (${handler}): ${this.getErrorMessage(error)}`, { canRetry }, {
+            driverVersion: packageVersion_1.pkgVersion,
+            details: JSON.stringify({
+                ...this.getConnectionDetailsProps(),
+            }),
+        });
     }
 }
 exports.DocumentDeltaConnection = DocumentDeltaConnection;
@@ -451,4 +566,4 @@ DocumentDeltaConnection.eventsToForward = ["nack", "op", "signal", "pong"];
 // WARNING: These are critical events that we can't miss, so registration for them has to be in place at all times!
 // Including before handshake is over, and after that (but before DeltaManager had a chance to put its own handlers)
 DocumentDeltaConnection.eventsAlwaysForwarded = ["disconnect", "error"];
-//# sourceMappingURL=documentDeltaConnection.js.map
+//# sourceMappingURL=documentDeltaConnection.cjs.map