fix(http): do not recreate agent for each request

Author: Nicolas Hansse

src/httpClient/httpURLConnectionClient.ts

@@ -18,7 +18,7 @@
  */
 
 import { ClientRequest, IncomingHttpHeaders, IncomingMessage, request as httpRequest } from "http";
-import { Agent, AgentOptions, request as httpsRequest } from "https";
+import { Agent, AgentOptions, globalAgent, request as httpsRequest } from "https";
 import { HttpsProxyAgent } from "https-proxy-agent";
 
 import * as fs from "fs";
@@ -37,7 +37,7 @@ import checkServerIdentity from "../helpers/checkServerIdentity";
 class HttpURLConnectionClient implements ClientInterface {
     private static CHARSET = "utf-8";
     public proxy?: AgentOptions;
-    private agentOptions!: AgentOptions;
+    private agents: Record<string, Agent> = {};
 
     /**
      * Sends an HTTP request to the specified endpoint with the provided JSON payload and configuration.
@@ -64,9 +64,7 @@ class HttpURLConnectionClient implements ClientInterface {
         requestOptions.headers ??= {};
         requestOptions.timeout = config.connectionTimeoutMillis;
 
-        if (config.certificatePath) {
-            this.installCertificateVerifier(config.certificatePath);
-        }
+        const agent = this.selectAgent(config.certificatePath);
 
         const apiKey = config.apiKey;
 
@@ -85,12 +83,12 @@ class HttpURLConnectionClient implements ClientInterface {
 
         requestOptions.headers[ApiConstants.CONTENT_TYPE] = ApiConstants.APPLICATION_JSON_TYPE;
 
-        const httpConnection: ClientRequest = this.createRequest(endpoint, requestOptions, config.applicationName);
+        const httpConnection: ClientRequest = this.createRequest(endpoint, requestOptions, agent, config.applicationName);
         return this.doRequest(httpConnection, json);
     }
 
     // create Request object
-    private createRequest(endpoint: string, requestOptions: IRequest.Options, applicationName?: string): ClientRequest {
+    private createRequest(endpoint: string, requestOptions: IRequest.Options, agent: Agent, applicationName?: string): ClientRequest {
         if (!requestOptions.headers) {
             requestOptions.headers = {};
         }
@@ -114,7 +112,7 @@ class HttpURLConnectionClient implements ClientInterface {
             const { host, port, ...options } = this.proxy;
             requestOptions.agent = new HttpsProxyAgent({ host, port: port || 443, ...options });
         } else {
-            requestOptions.agent = new Agent(this.agentOptions);
+            requestOptions.agent = agent;
         }
 
         requestOptions.headers["Cache-Control"] = "no-cache";
@@ -255,27 +253,6 @@ class HttpURLConnectionClient implements ClientInterface {
         });
     }
 
-    private installCertificateVerifier(terminalCertificatePath: string): void | Promise<HttpClientException> {
-        try {
-            if (terminalCertificatePath == "unencrypted") {
-                this.agentOptions = {
-                    rejectUnauthorized: false
-                };
-            } else {
-                const certificateInput = fs.readFileSync(terminalCertificatePath);
-                this.agentOptions = {
-                    ca: certificateInput,
-                    checkServerIdentity,
-                };
-            }
-
-        } catch (e) {
-            const message = e instanceof Error ? e.message : "undefined";
-            return Promise.reject(new HttpClientException({ message: `Error loading certificate from path: ${message}` }));
-        }
-
-    }
-
     private verifyLocation(location: string): boolean {
         try {
             const url = new URL(location);
@@ -286,6 +263,40 @@ class HttpURLConnectionClient implements ClientInterface {
             return false;
         }
     }
+
+    private selectAgent(terminalCertificatePath?: string): Agent {
+        if (!terminalCertificatePath) return globalAgent;
+
+        if (this.agents[terminalCertificatePath])
+          return this.agents[terminalCertificatePath];
+
+        if (terminalCertificatePath == "unencrypted") {
+          this.agents["unencrypted"] = new Agent({
+            keepAlive: true,
+            scheduling: "lifo",
+            timeout: 5000,
+            rejectUnauthorized: false,
+          });
+          return this.agents["unencrypted"];
+        } else {
+          try {
+            const certificateInput = fs.readFileSync(terminalCertificatePath);
+            this.agents[terminalCertificatePath] = new Agent({
+              keepAlive: true,
+              scheduling: "lifo",
+              timeout: 5000,
+              ca: certificateInput,
+              checkServerIdentity,
+            });
+            return this.agents[terminalCertificatePath];
+          } catch (e) {
+            const message = e instanceof Error ? e.message : "undefined";
+            throw new HttpClientException({
+              message: `Error loading certificate from path: ${message}`,
+            });
+          }
+        }
+  }
 }