            privateKey: this.getPrivateKey() || undefined,
            securityMode: this.securityMode
        });
        this._requests = {};

        this.messageBuilder
            .on("message", (response: Response, msgType: string, requestId: number) => {
                this._on_message_received(response, msgType, requestId);
            })
            .on("start_chunk", () => {
                //
                if (doPerfMonitoring) {
                    this._tick2 = get_clock_tick();
                }
            })
            .on("error", (err, requestId) => {
                //
                let requestData = this._requests[requestId];

                if (doDebug) {
                    debugLog("request id = ", requestId, err);
                    debugLog(" message was ");
                    debugLog(requestData);
                }

                if (!requestData) {
                    requestData = this._requests[requestId + 1];
                    if (doTraceClientRequestContent) {
                        errorLog(" message was 2:", requestData ? requestData.request.toString() : "<null>");
                    }
                }
            });

        this.__in_normal_close_operation = false;

        this._timeout_request_count = 0;

        this._securityTokenTimeoutId = null;

        this.transportTimeout = options.transportTimeout || ClientSecureChannelLayer.defaultTransportTimeout;

        this.channelId = 0;

        this.connectionStrategy = coerceConnectionStrategy(options.connectionStrategy);
    }

The software does not properly control the allocation and maintenance of a limited resource, thereby enabling an actor to influence the amount of resources consumed, eventually leading to the exhaustion of available resources.