Merge pull request #356 from plivo/VT-9003

VT-9003: Plivo SDK API Response Time Degrades Over Time

Author: manjunath-plivo

CHANGELOG.md

@@ -1,5 +1,11 @@
 # Change Log
 
+## [v4.71.0](https://github.com/plivo/plivo-node/tree/v4.71.0) (2025-06-13)
+**Bug Fix**
+- Added HTTP/HTTPS agent configuration with connection pooling to prevent progressive API latency increase.
+- Fixed memory leak in retryWrapper interceptors that accumulated over time causing CPU spikes and performance degradation.
+- Improved resource cleanup in voice request handling to maintain stable memory usage and eliminate need for server restarts
+
 ## [v4.70.0](https://github.com/plivo/plivo-node/tree/v4.70.0) (2025-04-30)
 **Feature - New Param added for Start Recording API.**
 - Support `record_channel_type` in Start Recording API and `recordChannelType` in Record XML.

lib/rest/axios.js

@@ -3,9 +3,33 @@ import * as _ from "lodash";
 
 import axios from 'axios';
 import queryString from 'querystring';
+import http from 'http';
+import https from 'https';
 
 var HttpsProxyAgent = require('https-proxy-agent');
 
+const httpAgent = new http.Agent({
+  keepAlive: true,
+  keepAliveMsecs: 1000,
+  maxSockets: 100,         // Maximum sockets per host - requests queue when limit reached
+  maxFreeSockets: 20,      // Maximum free sockets per host (increased proportionally)
+  timeout: 60000,          // Socket timeout - requests fail if this timeout is reached
+  freeSocketTimeout: 30000 // Free socket timeout
+});
+
+const httpsAgent = new https.Agent({
+  keepAlive: true,
+  keepAliveMsecs: 1000,
+  maxSockets: 100,         // Requests queue when limit reached, don't fail immediately
+  maxFreeSockets: 20,      // Increased proportionally with maxSockets
+  timeout: 60000,          // Only fail if timeout reached while waiting for socket
+  freeSocketTimeout: 30000
+});
+
+// Set default agents for axios
+axios.defaults.httpAgent = httpAgent;
+axios.defaults.httpsAgent = httpsAgent;
+
 export function Axios(config) {
   let auth = 'Basic ' + new Buffer(config.authId + ':' + config.authToken)
     .toString('base64');
@@ -24,20 +48,37 @@ export function Axios(config) {
     return code == 403 && method.toLowerCase() == "post" && GeoPermissionEndpoints.some(endpoint => url.endsWith(endpoint))
   }
 
-  const retryWrapper = (axios, options) => {
+  const retryWrapper = (axiosInstance, options) => {
     const max_time = options.retryTime;
     let counter = 0;
-    axios.interceptors.response.use(null, (error) => {
+
+    // Create a dedicated axios instance for this request to avoid global interceptor pollution
+    const requestAxios = axios.create({
+      httpAgent: axiosInstance.defaults.httpAgent,
+      httpsAgent: axiosInstance.defaults.httpsAgent,
+      timeout: axiosInstance.defaults.timeout
+    });
+
+    // Add interceptor with proper cleanup
+    const interceptorId = requestAxios.interceptors.response.use(null, (error) => {
       const config = error.config;
       if (counter < max_time && error.response && error.response.status >= 500) {
         counter++;
         config.url = options.urls[counter] + options.authId + '/' + options.action;
         return new Promise((resolve) => {
-          resolve(axios(config));
-        })
+          resolve(requestAxios(config));
+        });
+      }
+      return Promise.reject(error);
+    });
+
+    return {
+      axios: requestAxios,
+      cleanup: () => {
+        // Clean up the interceptor when done
+        requestAxios.interceptors.response.eject(interceptorId);
       }
-      return Promise.reject(error)
-    })
+    };
   }
 
   return (method, action, params) => {
@@ -189,7 +230,15 @@ export function Axios(config) {
     }
 
     if (typeof config.proxy !== 'undefined') {
-      options.httpsAgent = new HttpsProxyAgent(config.proxy);
+      // Create proxy agent with connection pooling settings
+      options.httpsAgent = new HttpsProxyAgent(config.proxy, {
+        keepAlive: true,
+        keepAliveMsecs: 1000,
+        maxSockets: 100,         // Match the main configuration
+        maxFreeSockets: 20,      // Match the main configuration
+        timeout: 60000,
+        freeSocketTimeout: 30000
+      });
     }
 
     if (typeof config.timeout !== 'undefined') {
@@ -201,77 +250,85 @@ export function Axios(config) {
 
     return new Promise((resolve, reject) => {
       if (isVoiceReq) {
-        retryWrapper(axios, {retryTime: 2, urls: apiVoiceUris, authId: config.authId, action: action});
-          options.url = apiVoiceUris[0] + config.authId + '/' + action;
-          if (method === 'GET' && options.data !== '') {
-            let query = '?' + queryString.stringify(params);
-            options.url += query;
-            delete options.data
+        // Set up retry wrapper with proper cleanup
+        const retrySetup = retryWrapper(axios, {retryTime: 2, urls: apiVoiceUris, authId: config.authId, action: action});
+        const retryAxios = retrySetup.axios;
+
+        options.url = apiVoiceUris[0] + config.authId + '/' + action;
+        if (method === 'GET' && options.data !== '') {
+          let query = '?' + queryString.stringify(params);
+          options.url += query;
+          delete options.data
+        }
+
+        retryAxios(options).then(response => {
+          var exceptionClass = {
+            400: Exceptions.InvalidRequestError,
+            401: Exceptions.AuthenticationError,
+            404: Exceptions.ResourceNotFoundError,
+            405: Exceptions.InvalidRequestError,
+            406: Exceptions.NotAcceptableError,
+            500: Exceptions.ServerError,
+            409: Exceptions.InvalidRequestError,
+            422: Exceptions.InvalidRequestError,
+            207: Exceptions.InvalidRequestError,
+          } [response.status] || Error;
+
+          if (isGeoPermissionError(response)) {
+            exceptionClass = Exceptions.GeoPermissionError
           }
-          axios(options).then(response => {
-            var exceptionClass = {
-              400: Exceptions.InvalidRequestError,
-              401: Exceptions.AuthenticationError,
-              404: Exceptions.ResourceNotFoundError,
-              405: Exceptions.InvalidRequestError,
-              406: Exceptions.NotAcceptableError,
-              500: Exceptions.ServerError,
-              409: Exceptions.InvalidRequestError,
-              422: Exceptions.InvalidRequestError,
-              207: Exceptions.InvalidRequestError,
-            } [response.status] || Error;
-
-            if (isGeoPermissionError(response)) {
-              exceptionClass = Exceptions.GeoPermissionError
-            }
-  
-            if (!_.inRange(response.status, 200, 300)) {
-              let body = response.data;
-              if (typeof body === 'object') {
-                reject(new exceptionClass(JSON.stringify(body)));
-              }
-              else {
-                reject(new exceptionClass(body));
-              }
-            }
-            resolve({
-              response: response,
-              body: response.data
-            });
-          })
-          .catch(function (error) {
-            if (error.response == undefined){
-              return reject(error.stack );
+
+          if (!_.inRange(response.status, 200, 300)) {
+            let body = response.data;
+            if (typeof body === 'object') {
+              reject(new exceptionClass(JSON.stringify(body)));
             }
-            var exceptionClass = {
-              400: Exceptions.InvalidRequestError,
-              401: Exceptions.AuthenticationError,
-              404: Exceptions.ResourceNotFoundError,
-              405: Exceptions.InvalidRequestError,
-              406: Exceptions.NotAcceptableError,
-              500: Exceptions.ServerError,
-              409: Exceptions.InvalidRequestError,
-              422: Exceptions.InvalidRequestError,
-              207: Exceptions.InvalidRequestError,
-            } [error.response.status] || Error;
-
-            if (isGeoPermissionError(error.response)) {
-              exceptionClass = Exceptions.GeoPermissionError
+            else {
+              reject(new exceptionClass(body));
             }
-  
-            if (!_.inRange(error.response.status, 200, 300)) {
-              let body = error.response.data;
-              if (typeof body === 'object') {
-                reject(new exceptionClass(error));
-              }  else {
-                if (error.response.status >= 500) {
-                  reject(new Exceptions.ServerError(error));
-                }
-                reject(new exceptionClass(error));
+          }
+          resolve({
+            response: response,
+            body: response.data
+          });
+        })
+        .catch(function (error) {
+          if (error.response == undefined){
+            return reject(error.stack );
+          }
+          var exceptionClass = {
+            400: Exceptions.InvalidRequestError,
+            401: Exceptions.AuthenticationError,
+            404: Exceptions.ResourceNotFoundError,
+            405: Exceptions.InvalidRequestError,
+            406: Exceptions.NotAcceptableError,
+            500: Exceptions.ServerError,
+            409: Exceptions.InvalidRequestError,
+            422: Exceptions.InvalidRequestError,
+            207: Exceptions.InvalidRequestError,
+          } [error.response.status] || Error;
+
+          if (isGeoPermissionError(error.response)) {
+            exceptionClass = Exceptions.GeoPermissionError
+          }
+
+          if (!_.inRange(error.response.status, 200, 300)) {
+            let body = error.response.data;
+            if (typeof body === 'object') {
+              reject(new exceptionClass(error));
+            }  else {
+              if (error.response.status >= 500) {
+                reject(new Exceptions.ServerError(error));
               }
+              reject(new exceptionClass(error));
             }
-            reject(error.stack + '\n' + JSON.stringify(error.response.data));
-          })
+          }
+          reject(error.stack + '\n' + JSON.stringify(error.response.data));
+        })
+        .finally(() => {
+          // Clean up interceptors in all cases - success, error, or unexpected exception
+          retrySetup.cleanup();
+        })
       }
       else {
         axios(options).then(response => {

package.json

@@ -1,6 +1,6 @@
 {
   "name": "plivo",
-  "version": "4.70.0",
+  "version": "4.71.0",
   "description": "A Node.js SDK to make voice calls and send SMS using Plivo and to generate Plivo XML",
   "homepage": "https://github.com/plivo/plivo-node",
   "files": [