@tdengine/websocket 3.2.3 → 3.3.0

package/lib/src/client/wsConnector.js

@@ -3,60 +3,193 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WebSocketConnector = void 0;
+exports.WebSocketConnector = exports.RetryConfig = void 0;
 const websocket_1 = require("websocket");
+const addressConnectionTracker_1 = require("../common/addressConnectionTracker");
 const wsError_1 = require("../common/wsError");
 const wsEventCallback_1 = require("./wsEventCallback");
 const log_1 = __importDefault(require("../common/log"));
-const reqid_1 = require("../common/reqid");
 const utils_1 = require("../common/utils");
-class WebSocketConnector {
-    constructor(url, timeout) {
-        this._timeout = 5000;
-        if (url) {
-            this._wsURL = url;
-            let origin = url.origin;
-            let pathname = url.pathname;
-            let search = url.search;
-            if (timeout) {
-                this._timeout = timeout;
-            }
-            this._wsConn = new websocket_1.w3cwebsocket(origin.concat(pathname).concat(search), undefined, undefined, undefined, undefined, {
-                maxReceivedFrameSize: 0x60000000,
-                maxReceivedMessageSize: 0x60000000,
-            });
-            this._wsConn.onerror = function (err) {
-                log_1.default.error(`webSocket connection failed, url: ${(0, utils_1.maskUrlForLog)(new URL(this.url))}, error: ${err.message}`);
-            };
-            this._wsConn.onclose = this._onclose;
-            this._wsConn.onmessage = this._onmessage;
-            this._wsConn._binaryType = "arraybuffer";
+class InflightRequestStore {
+    constructor() {
+        this.nextMsgId = 1n;
+        this.reqIdToMsgId = new Map();
+        this.msgIdToRequest = new Map();
+    }
+    insert(req) {
+        const msgId = this.nextMsgId;
+        this.nextMsgId += 1n;
+        this.reqIdToMsgId.set(req.reqId, msgId);
+        this.msgIdToRequest.set(msgId, req);
+    }
+    remove(reqId) {
+        const msgId = this.reqIdToMsgId.get(reqId);
+        if (msgId === undefined) {
+            return;
         }
-        else {
+        this.reqIdToMsgId.delete(reqId);
+        this.msgIdToRequest.delete(msgId);
+    }
+    getRequests() {
+        return Array.from(this.msgIdToRequest.entries())
+            .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
+            .map(([, req]) => req);
+    }
+    clear() {
+        this.nextMsgId = 1n;
+        this.reqIdToMsgId.clear();
+        this.msgIdToRequest.clear();
+    }
+}
+const RETRIABLE_ACTIONS = new Set(["insert", "options_connection", "poll", "subscribe"]);
+// TDengine websocket binary op codes that are safe to replay after reconnect.
+const BINARY_RETRIABLE_ACTIONS = new Set([4n, 5n, 6n, 10n]);
+const DEFAULT_RETRIES = 5;
+const DEFAULT_BACKOFF_MS = 200;
+const DEFAULT_BACKOFF_MAX_MS = 2000;
+const NETWORK_ERROR_CODES = new Set([
+    "econnreset",
+    "econnrefused",
+    "ehostunreach",
+    "enotfound",
+    "eai_again",
+    "epipe",
+    "etimedout",
+    "err_socket_closed",
+    "err_stream_write_after_end",
+]);
+const NETWORK_ERROR_MESSAGE_PATTERNS = [
+    "not connected",
+    "socket",
+    "network",
+    "econnreset",
+    "econnrefused",
+    "epipe",
+    "etimedout",
+    "write after end",
+    "broken pipe",
+    "connection reset",
+    "connection closed",
+];
+function parseNonNegativeInt(value, fallback) {
+    return parseIntWithValidation(value, fallback, (parsed) => parsed >= 0);
+}
+function parsePositiveInt(value, fallback) {
+    return parseIntWithValidation(value, fallback, (parsed) => parsed > 0);
+}
+function parseIntWithValidation(value, fallback, isValid) {
+    if (value === undefined || value === null || value.length === 0) {
+        return fallback;
+    }
+    const parsed = Number.parseInt(value, 10);
+    if (Number.isNaN(parsed) || !isValid(parsed)) {
+        return fallback;
+    }
+    return parsed;
+}
+class RetryConfig {
+    constructor(retries, retryBackoffMs, retryBackoffMaxMs) {
+        this.retries = retries;
+        this.retryBackoffMs = retryBackoffMs;
+        this.retryBackoffMaxMs = Math.max(retryBackoffMs, retryBackoffMaxMs);
+    }
+    getBackoffDelay(attempt) {
+        const safeAttempt = Math.max(0, attempt);
+        const rawDelay = this.retryBackoffMs * Math.pow(2, safeAttempt);
+        const finiteDelay = Number.isFinite(rawDelay) ? rawDelay : this.retryBackoffMaxMs;
+        return Math.min(finiteDelay, this.retryBackoffMaxMs);
+    }
+    static fromDsn(dsn) {
+        const retries = parseNonNegativeInt(dsn.params.get("retries"), DEFAULT_RETRIES);
+        const retryBackoffMs = parsePositiveInt(dsn.params.get("retry_backoff_ms"), DEFAULT_BACKOFF_MS);
+        const retryBackoffMaxMs = parsePositiveInt(dsn.params.get("retry_backoff_max_ms"), DEFAULT_BACKOFF_MAX_MS);
+        return new RetryConfig(retries, retryBackoffMs, retryBackoffMaxMs);
+    }
+}
+exports.RetryConfig = RetryConfig;
+class WebSocketConnector {
+    constructor(dsn, poolKey, timeout) {
+        this._suppressedSockets = new WeakSet();
+        this._reconnectLock = null;
+        this._isReconnecting = false;
+        this._allowReconnect = true;
+        this._connectionReady = Promise.resolve();
+        this._sessionRecoveryHook = null;
+        this._timeout = 60000;
+        if (!dsn || dsn.addresses.length === 0) {
             throw new wsError_1.WebSocketQueryError(wsError_1.ErrorCode.ERR_INVALID_URL, "websocket URL must be defined");
         }
+        this._poolKey = poolKey;
+        this._dsn = dsn;
+        this._currentAddress = this.selectLeastConnectedAddress();
+        this._retryConfig = RetryConfig.fromDsn(dsn);
+        this._inflightStore = new InflightRequestStore();
+        if (timeout) {
+            this._timeout = timeout;
+        }
+        log_1.default.info(`Initial websocket address selected: ${this.getCurrentAddress()}`);
+        this.createConnection();
     }
-    async ready() {
-        return new Promise((resolve, reject) => {
-            let reqId = reqid_1.ReqId.getReqID();
-            wsEventCallback_1.WsEventCallback.instance().registerCallback({
-                action: "websocket_connection",
-                req_id: BigInt(reqId),
-                timeout: this._timeout,
-                id: BigInt(reqId),
-            }, resolve, reject);
-            this._wsConn.onopen = () => {
+    refreshRetryConfig(dsn) {
+        this._retryConfig = RetryConfig.fromDsn(dsn);
+    }
+    buildUrl(addr) {
+        const path = this._dsn.path();
+        const url = new URL(`${this._dsn.scheme}://${addr.host}:${addr.port}/${path}`);
+        const forwardedParams = ["token", "bearer_token"];
+        for (const key of forwardedParams) {
+            const value = this._dsn.params.get(key);
+            if (value !== undefined) {
+                url.searchParams.set(key, value);
+            }
+        }
+        return url.toString();
+    }
+    createConnection() {
+        const conn = new websocket_1.w3cwebsocket(this.buildUrl(this._currentAddress), undefined, undefined, undefined, undefined, {
+            maxReceivedFrameSize: 0x60000000,
+            maxReceivedMessageSize: 0x60000000,
+        });
+        conn._binaryType = "arraybuffer";
+        conn.onmessage = this._onmessage;
+        this._connectionReady = new Promise((resolve, reject) => {
+            let settled = false;
+            const settle = (handler) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                clearTimeout(timeoutId);
+                handler();
+            };
+            const timeoutId = setTimeout(() => {
+                settle(() => {
+                    reject(new wsError_1.WebSocketQueryError(wsError_1.ErrorCode.ERR_WEBSOCKET_QUERY_TIMEOUT, `websocket connection timeout with ${this._timeout} milliseconds`));
+                });
+            }, this._timeout);
+            conn.onopen = () => {
                 log_1.default.debug("websocket connection opened");
-                wsEventCallback_1.WsEventCallback.instance().handleEventCallback({
-                    id: BigInt(reqId),
-                    action: "websocket_connection",
-                    req_id: BigInt(reqId),
-                }, wsEventCallback_1.OnMessageType.MESSAGE_TYPE_CONNECTION, this);
+                addressConnectionTracker_1.AddressConnectionTracker.instance().increment(this.getCurrentAddress());
+                settle(resolve);
+            };
+            conn.onerror = (err) => {
+                log_1.default.error(`webSocket connection failed, url: ${(0, utils_1.maskUrlForLog)(new URL(conn.url))}, error: ${err.message}`);
+                if (conn.readyState !== websocket_1.w3cwebsocket.OPEN) {
+                    settle(() => reject(err));
+                }
+                void this.handleDisconnect(conn);
+            };
+            conn.onclose = (e) => {
+                log_1.default.info(`websocket connection closed, code: ${e.code}, reason: ${e.reason}`);
+                if (conn.readyState !== websocket_1.w3cwebsocket.OPEN) {
+                    settle(() => {
+                        reject(new wsError_1.WebSocketQueryError(wsError_1.ErrorCode.ERR_WEBSOCKET_CONNECTION_FAIL, `websocket connection closed: ${e.code} ${e.reason}`));
+                    });
+                }
+                void this.handleDisconnect(conn, e);
             };
         });
-    }
-    async _onclose(e) {
-        log_1.default.info("websocket connection closed");
+        this._conn = conn;
     }
     _onmessage(event) {
         let data = event.data;
@@ -74,85 +207,371 @@ class WebSocketConnector {
             throw new wsError_1.TDWebSocketClientError(wsError_1.ErrorCode.ERR_INVALID_MESSAGE_TYPE, `invalid message type ${Object.prototype.toString.call(data)}`);
         }
     }
-    close() {
-        if (this._wsConn) {
-            this._wsConn.close();
+    shouldSkipReconnect(conn) {
+        if (!this.isReconnectAllowed()) {
+            return true;
         }
-        else {
-            throw new wsError_1.TDWebSocketClientError(wsError_1.ErrorCode.ERR_WEBSOCKET_CONNECTION_FAIL, "WebSocket connection is undefined.");
+        return this._suppressedSockets.has(conn);
+    }
+    async failNonRetriableCallbacksOnDisconnect() {
+        const keepReqIds = new Set(this._inflightStore.getRequests().map((req) => req.reqId));
+        await wsEventCallback_1.WsEventCallback.instance().rejectCallbacksExceptReqIds(keepReqIds, new wsError_1.TDWebSocketClientError(wsError_1.ErrorCode.ERR_CONNECTION_CLOSED, "websocket connection closed before response was received"), this._poolKey);
+    }
+    async handleDisconnect(conn, event) {
+        if (this.shouldSkipReconnect(conn) || this._isReconnecting) {
+            return;
+        }
+        if (event && event.code === 1000) {
+            log_1.default.info("Websocket closed normally, skipping reconnect.");
+            return;
+        }
+        await this.failNonRetriableCallbacksOnDisconnect();
+        try {
+            await this.triggerReconnect();
+        }
+        catch (err) {
+            const type = event ? 'close' : 'error';
+            const message = err instanceof Error ? err.message : String(err);
+            log_1.default.error(`Reconnect failed after websocket ${type}: ${message}`);
         }
     }
-    readyState() {
-        return this._wsConn.readyState;
+    extractReqId(reqId) {
+        if (reqId === undefined || reqId === null) {
+            return null;
+        }
+        try {
+            return BigInt(reqId);
+        }
+        catch (err) {
+            return null;
+        }
     }
-    async sendMsgNoResp(message) {
-        log_1.default.debug("[wsClient.sendMsgNoResp()]===>" + message);
-        let msg = JSON.parse(message);
-        if (msg.args.id !== undefined) {
-            msg.args.id = BigInt(msg.args.id);
+    isRetriableAction(action) {
+        return RETRIABLE_ACTIONS.has(action);
+    }
+    extractBinaryAction(message) {
+        if (message.byteLength < 24) {
+            return -1n;
         }
-        return new Promise((resolve, reject) => {
-            if (this._wsConn && this._wsConn.readyState === websocket_1.w3cwebsocket.OPEN) {
-                this._wsConn.send(message);
-                resolve();
+        return new DataView(message, 16, 8).getBigInt64(0, true);
+    }
+    isRetriableBinaryAction(action) {
+        return BINARY_RETRIABLE_ACTIONS.has(action);
+    }
+    isNetworkError(err) {
+        if (!this._conn || this._conn.readyState !== websocket_1.w3cwebsocket.OPEN) {
+            return true;
+        }
+        const errObj = err;
+        const code = errObj?.code;
+        if (typeof code === "number" && code === wsError_1.ErrorCode.ERR_CONNECTION_CLOSED) {
+            return true;
+        }
+        if (typeof code === "string") {
+            const loweredCode = code.toLowerCase();
+            if (loweredCode.length > 0 && NETWORK_ERROR_CODES.has(loweredCode)) {
+                return true;
+            }
+        }
+        const message = err instanceof Error
+            ? err.message
+            : typeof errObj?.message === "string"
+                ? errObj.message
+                : String(err);
+        const lowered = message.toLowerCase();
+        return NETWORK_ERROR_MESSAGE_PATTERNS.some((pattern) => lowered.includes(pattern));
+    }
+    send(message, triggerReconnect = true) {
+        try {
+            this._conn.send(message);
+        }
+        catch (err) {
+            if (triggerReconnect && this.isNetworkError(err)) {
+                void this.triggerReconnect().catch((err) => {
+                    const message = err instanceof Error ? err.message : String(err);
+                    log_1.default.error(`Reconnect trigger failed: ${message}`);
+                });
             }
-            else {
-                reject(new wsError_1.WebSocketQueryError(wsError_1.ErrorCode.ERR_WEBSOCKET_CONNECTION_FAIL, `WebSocket connection is not ready, status: ${this._wsConn?.readyState}`));
+            throw err;
+        }
+    }
+    async ready() {
+        if (this._conn && this._conn.readyState === websocket_1.w3cwebsocket.OPEN) {
+            return;
+        }
+        if (this._reconnectLock) {
+            await this._reconnectLock;
+            return;
+        }
+        try {
+            await this._connectionReady;
+        }
+        catch (err) {
+            if (this._reconnectLock) {
+                await this._reconnectLock;
+                return;
             }
+            throw err;
+        }
+    }
+    getCurrentAddress() {
+        return `${this._currentAddress.host}:${this._currentAddress.port}`;
+    }
+    selectLeastConnectedAddress(excludedAddresses = new Set()) {
+        const candidates = this._dsn.addresses.filter((address) => {
+            const addressKey = `${address.host}:${address.port}`;
+            return !excludedAddresses.has(addressKey);
         });
+        const selectableAddresses = candidates.length > 0 ? candidates : this._dsn.addresses;
+        const selectedIndex = addressConnectionTracker_1.AddressConnectionTracker.instance()
+            .selectLeastConnected(selectableAddresses);
+        return selectableAddresses[selectedIndex];
     }
-    async sendMsg(message, register = true) {
-        if (log_1.default.isDebugEnabled()) {
-            log_1.default.debug("[wsClient.sendMessage()]===>" + (0, utils_1.maskSensitiveForLog)(message));
+    async sleep(ms) {
+        await new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    isReconnectAllowed() {
+        return this._allowReconnect;
+    }
+    async triggerReconnect() {
+        if (!this.isReconnectAllowed()) {
+            return;
         }
-        let msg = JSON.parse(message);
-        if (msg.args.id !== undefined) {
-            msg.args.id = BigInt(msg.args.id);
+        if (!this._reconnectLock) {
+            this._reconnectLock = this._doReconnect();
         }
-        return new Promise((resolve, reject) => {
-            if (this._wsConn && this._wsConn.readyState === websocket_1.w3cwebsocket.OPEN) {
-                if (register) {
-                    wsEventCallback_1.WsEventCallback.instance().registerCallback({
-                        action: msg.action,
-                        req_id: msg.args.req_id,
-                        timeout: this._timeout,
-                        id: msg.args.id === undefined ? msg.args.id : BigInt(msg.args.id),
-                    }, resolve, reject);
+        const lock = this._reconnectLock;
+        try {
+            await lock;
+        }
+        finally {
+            if (this._reconnectLock === lock) {
+                this._reconnectLock = null;
+            }
+        }
+    }
+    async _doReconnect() {
+        if (!this.isReconnectAllowed()) {
+            return;
+        }
+        this._isReconnecting = true;
+        try {
+            await this.attemptReconnect();
+        }
+        catch (err) {
+            const reconnectError = err instanceof Error
+                ? err
+                : new Error("unknown reconnect error");
+            this.failAllInflightRequests(reconnectError);
+            throw reconnectError;
+        }
+        finally {
+            this._isReconnecting = false;
+        }
+    }
+    async reconnect() {
+        if (this._conn) {
+            addressConnectionTracker_1.AddressConnectionTracker.instance().decrement(this.getCurrentAddress());
+            this._suppressedSockets.add(this._conn);
+            this._conn.close();
+        }
+        this.createConnection();
+        await this._connectionReady;
+    }
+    async attemptReconnect() {
+        const totalAddresses = this._dsn.addresses.length;
+        const failedAddresses = new Set();
+        for (let i = 0; i < totalAddresses; i++) {
+            for (let retry = 0; retry < this._retryConfig.retries; retry++) {
+                if (!this.isReconnectAllowed()) {
+                    return;
                 }
-                if (log_1.default.isDebugEnabled()) {
-                    log_1.default.debug("[wsClient.sendMessage.msg]===>" + (0, utils_1.maskSensitiveForLog)(message));
+                try {
+                    log_1.default.info(`Reconnecting to ${this.getCurrentAddress()}, attempt ${retry + 1}`);
+                    await this.reconnect();
+                    await this.recoverSessionContext();
+                    await this.replayRequests();
+                    log_1.default.info(`Reconnection successful to ${this.getCurrentAddress()}`);
+                    return;
                 }
-                this._wsConn.send(message);
+                catch (err) {
+                    log_1.default.warn(`Reconnect failed: ${err.message}`);
+                    if (retry < this._retryConfig.retries - 1) {
+                        const delay = this._retryConfig.getBackoffDelay(retry);
+                        await this.sleep(delay);
+                    }
+                }
+            }
+            if (i < totalAddresses - 1) {
+                failedAddresses.add(this.getCurrentAddress());
+                this._currentAddress = this.selectLeastConnectedAddress(failedAddresses);
+                log_1.default.info(`Switching to least-connected address: ${this.getCurrentAddress()}`);
             }
-            else {
-                reject(new wsError_1.WebSocketQueryError(wsError_1.ErrorCode.ERR_WEBSOCKET_CONNECTION_FAIL, `WebSocket connection is not ready, status: ${this._wsConn?.readyState}`));
+        }
+        throw new wsError_1.TDWebSocketClientError(wsError_1.ErrorCode.ERR_WEBSOCKET_CONNECTION_FAIL, "Failed to reconnect to any available address");
+    }
+    async replayRequests() {
+        log_1.default.info("Replaying requests after reconnection");
+        for (const req of this._inflightStore.getRequests()) {
+            try {
+                this.send(req.message, false);
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                if (this.isNetworkError(err)) {
+                    log_1.default.warn(`Network error while replaying inflight request, stopping current replay round: ${message}`);
+                    throw err;
+                }
+                log_1.default.error(`Failed to replay inflight request: ${req}, error: ${message}`);
+                req.reject(err);
             }
+        }
+    }
+    failAllInflightRequests(error) {
+        for (const req of this._inflightStore.getRequests()) {
+            req.reject(error);
+        }
+        this._inflightStore.clear();
+    }
+    close() {
+        this._allowReconnect = false;
+        this.failAllInflightRequests(new wsError_1.TDWebSocketClientError(wsError_1.ErrorCode.ERR_CONNECTION_CLOSED, "websocket connection closed"));
+        if (this._conn) {
+            addressConnectionTracker_1.AddressConnectionTracker.instance().decrement(this.getCurrentAddress());
+            this._suppressedSockets.add(this._conn);
+            this._conn.close();
+        }
+        else {
+            log_1.default.warn("close() called but websocket connection is undefined");
+        }
+    }
+    readyState() {
+        return this._conn.readyState;
+    }
+    setSessionRecoveryHook(hook) {
+        this._sessionRecoveryHook = hook || null;
+    }
+    async recoverSessionContext() {
+        if (!this._sessionRecoveryHook) {
+            return;
+        }
+        await this._sessionRecoveryHook();
+    }
+    async sendMsgDirect(message) {
+        if (log_1.default.isDebugEnabled()) {
+            log_1.default.debug("[wsClient.sendMsgDirect]===>" + (0, utils_1.maskSensitiveForLog)(message));
+        }
+        const msg = JSON.parse(message);
+        const reqId = this.extractReqId(msg?.args?.req_id) ?? BigInt(0);
+        let resolveResp = () => { };
+        let rejectResp = () => { };
+        const responsePromise = new Promise((resolve, reject) => {
+            resolveResp = resolve;
+            rejectResp = reject;
         });
+        await wsEventCallback_1.WsEventCallback.instance().registerCallback({
+            action: msg.action,
+            req_id: reqId,
+            timeout: this._timeout,
+            poolKey: this._poolKey,
+        }, resolveResp, rejectResp);
+        try {
+            this.send(message, false);
+            return await responsePromise;
+        }
+        catch (err) {
+            await wsEventCallback_1.WsEventCallback.instance().unregisterCallback(reqId);
+            throw err;
+        }
+    }
+    async sendMsgNoResp(message) {
+        log_1.default.debug("[wsClient.sendMsgNoResp]===>" + message);
+        if (this._reconnectLock) {
+            await this._reconnectLock;
+        }
+        this.send(message);
+    }
+    async sendMsg(message) {
+        if (log_1.default.isDebugEnabled()) {
+            log_1.default.debug("[wsConnector.sendMsg]===>" + (0, utils_1.maskSensitiveForLog)(message));
+        }
+        const msg = JSON.parse(message);
+        const id = msg?.args?.id !== undefined ? BigInt(msg.args.id) : undefined;
+        const reqId = this.extractReqId(msg?.args?.req_id) ?? BigInt(0);
+        return this.sendAndTrackResponse(reqId, msg.action, message, this.isRetriableAction(msg.action), id);
     }
-    async sendBinaryMsg(reqId, action, message, register = true) {
+    async sendBinaryMsg(reqId, action, message) {
+        return this.sendAndTrackResponse(reqId, action, message, this.isRetriableBinaryAction(this.extractBinaryAction(message)), reqId);
+    }
+    async sendAndTrackResponse(reqId, action, message, retriable, callbackId) {
+        if (this._reconnectLock) {
+            await this._reconnectLock;
+        }
         return new Promise((resolve, reject) => {
-            if (this._wsConn && this._wsConn.readyState === websocket_1.w3cwebsocket.OPEN) {
-                if (register) {
-                    wsEventCallback_1.WsEventCallback.instance().registerCallback({
-                        action: action,
-                        req_id: reqId,
-                        timeout: this._timeout,
-                        id: reqId,
-                    }, resolve, reject);
+            let settled = false;
+            const safeResolve = (result) => {
+                if (settled) {
+                    return;
                 }
-                log_1.default.debug("[wsClient.sendBinaryMsg()]===>" +
-                    reqId +
-                    action +
-                    message.byteLength);
-                this._wsConn.send(message);
-            }
-            else {
-                reject(new wsError_1.WebSocketQueryError(wsError_1.ErrorCode.ERR_WEBSOCKET_CONNECTION_FAIL, `WebSocket connection is not ready, status: ${this._wsConn?.readyState}`));
-            }
+                settled = true;
+                if (retriable) {
+                    this._inflightStore.remove(reqId);
+                }
+                resolve(result);
+            };
+            const safeReject = (error) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                if (retriable) {
+                    this._inflightStore.remove(reqId);
+                }
+                void wsEventCallback_1.WsEventCallback.instance().unregisterCallback(reqId);
+                reject(error);
+            };
+            const registerAndSend = async () => {
+                if (retriable) {
+                    this._inflightStore.insert({
+                        reqId,
+                        action,
+                        id: callbackId,
+                        message,
+                        resolve: safeResolve,
+                        reject: safeReject,
+                    });
+                }
+                await wsEventCallback_1.WsEventCallback.instance().registerCallback({
+                    action,
+                    req_id: reqId,
+                    timeout: this._timeout,
+                    id: callbackId,
+                    poolKey: this._poolKey,
+                }, safeResolve, safeReject);
+                if (settled) {
+                    await wsEventCallback_1.WsEventCallback.instance().unregisterCallback(reqId);
+                    return;
+                }
+                try {
+                    this.send(message);
+                }
+                catch (err) {
+                    if (retriable && this.isNetworkError(err)) {
+                        return;
+                    }
+                    safeReject(err);
+                }
+            };
+            void registerAndSend().catch((error) => {
+                safeReject(error);
+            });
         });
     }
-    getWsURL() {
-        return this._wsURL;
+    getPoolKey() {
+        return this._poolKey;
+    }
+    getReconnectRetries() {
+        return this._retryConfig.retries;
     }
 }
 exports.WebSocketConnector = WebSocketConnector;

package/lib/src/client/wsConnectorPool.d.ts

@@ -1,3 +1,4 @@
+import { Dsn } from "../common/dsn";
 import { WebSocketConnector } from "./wsConnector";
 export declare class WebSocketConnectionPool {
     private static _instance?;
@@ -7,7 +8,10 @@ export declare class WebSocketConnectionPool {
     private static sharedArray;
     private constructor();
     static instance(maxConnections?: number): WebSocketConnectionPool;
-    getConnection(url: URL, timeout: number | undefined | null): Promise<WebSocketConnector>;
+    private maskPoolKeyForLog;
+    private buildAuthScope;
+    private getPoolKey;
+    getConnection(dsn: Dsn, timeout: number | undefined | null): Promise<WebSocketConnector>;
     releaseConnection(connector: WebSocketConnector): Promise<void>;
     destroyed(): void;
 }