fix: improve API request reliability with retry logic and DNS configuration

- Add automatic retry mechanism for transient network failures (EAI_AGAIN, ECONNRESET, ENOTFOUND, ETIMEDOUT)
- Implement exponential backoff for retries (500ms, 1000ms delays)
- Configure up to 2 retry attempts in production, disabled in test environment
- Add explicit timeout configuration (30s) and Connection: close header to prevent keep-alive issues
- Add Google DNS servers (8.8.8.8, 8.8.4.4) to Docker Compose for reliable DNS resolution
- Consolidate all timeout and retry settings into this.options for consistency
- Improve error logging with retry attempt counters and warnings

Fixes socket hang up and DNS resolution errors that prevented the application from displaying data.

Author: igobranco

docker-compose.prod.yml

@@ -6,6 +6,9 @@ services:
         target: production
       environment:
         - NODE_ENV=production
+      dns:
+        - 8.8.8.8
+        - 8.8.4.4
       ports:
         - "3000:3000"
       healthcheck:
@@ -15,6 +18,9 @@ services:
         retries: 3
         start_period: 40s
       restart: unless-stopped
+      # hosts file entries
+      # extra_hosts:
+      #   - "arquivo.pt:194.210.235.20"
       # Security hardening options
       security_opt:
         # Prevents container processes from gaining additional privileges

docker-compose.yml

@@ -6,6 +6,9 @@ services:
         target: development
       environment:
         - NODE_ENV=development
+      dns:
+        - 8.8.8.8
+        - 8.8.4.4
       volumes:
         - ./:/home/node/app
         - /home/node/app/node_modules

src/apis/api-request.js

@@ -40,16 +40,25 @@ class ApiRequest {
         this.defaultApiParams = defaultApiParams;
         this.defaultApiReply = defaultApiReply;
         this.logger = logger('ApiRequest');
-        this.options = { method: 'GET' };
+        this.options = { 
+            method: 'GET',
+            timeout: 30000, // 30 second timeout
+            maxRetries: process.env.NODE_ENV === 'test' ? 0 : 2, // Disable retries in test environment
+            retryDelay: 500, // 500ms between retries
+            headers: {
+                'Connection': 'close' // Prevent keep-alive issues
+            }
+        };
     }
 
     /**
-     * Performs a GET request to the configured API URL
+     * Performs a GET request to the configured API URL with retry logic
      * 
      * @param {URLSearchParams} requestData - Query parameters for the request
      * @param {Function} callback - Callback function(data) invoked with response data
+     * @param {number} attempt - Current retry attempt (internal use)
      */
-    get(requestData, callback) {
+    get(requestData, callback, attempt = 0) {
         let apiReply = '';
         let callbackInvoked = false;
 
@@ -94,16 +103,39 @@ class ApiRequest {
             });
 
             apiReq.on('error', (e) => {
-                this.logger.error(`${this.apiUrl} : Request error: ${e.message}`);
-                safeCallback(this.defaultApiReply);
+                // Retry on DNS failures (EAI_AGAIN) or connection resets
+                const isRetryableError = e.code === 'EAI_AGAIN' || 
+                                        e.code === 'ECONNRESET' || 
+                                        e.code === 'ENOTFOUND' ||
+                                        e.code === 'ETIMEDOUT';
+                
+                // Only retry if not already retrying and retries are enabled
+                const shouldRetry = isRetryableError && 
+                                   attempt < this.options.maxRetries && 
+                                   !callbackInvoked;
+                
+                if (shouldRetry) {
+                    this.logger.warn(`${this.apiUrl} : ${e.message} (attempt ${attempt + 1}/${this.options.maxRetries + 1})`);
+                    setTimeout(() => {
+                        this.get(requestData, callback, attempt + 1);
+                    }, this.options.retryDelay * (attempt + 1)); // Exponential backoff
+                } else {
+                    this.logger.error(`${this.apiUrl} : Request error: ${e.message}`);
+                    safeCallback(this.defaultApiReply);
+                }
             });
 
             apiReq.on('timeout', () => {
-                this.logger.error(`${this.apiUrl} : Timeout (${this.options.timeout || 120000} ms)`);
+                this.logger.error(`${this.apiUrl} : Timeout (${this.options.timeout}ms)`);
                 apiReq.destroy();
                 safeCallback(this.defaultApiReply);
             });
 
+            // Set the timeout on the request
+            if (this.options.timeout) {
+                apiReq.setTimeout(this.options.timeout);
+            }
+
             apiReq.end();
 
         } catch (e) {

src/apis/base-api-request.js

@@ -33,7 +33,15 @@ class BaseApiRequest {
         this.defaultApiParams = defaultApiParams;
         this.defaultApiReply = defaultApiReply;
         this.logger = logger(loggerName);
-        this.options = options || { method: 'GET' };
+        this.options = options || { 
+            method: 'GET',
+            timeout: 30000,
+            maxRetries: process.env.NODE_ENV === 'test' ? 0 : 2,
+            retryDelay: 500,
+            headers: {
+                'Connection': 'close'
+            }
+        };
     }
 
     /**
@@ -62,8 +70,9 @@ class BaseApiRequest {
      * 
      * @param {URLSearchParams} requestData - Query parameters for the request
      * @param {Function} callback - Callback function invoked with response data
+     * @param {number} attempt - Current retry attempt (internal use)
      */
-    get(requestData, callback) {
+    get(requestData, callback, attempt = 0) {
         // Validate callback
         if (typeof callback !== 'function') {
             return;
@@ -90,11 +99,30 @@ class BaseApiRequest {
 
             // Handle request errors
             apiReq.on('error', (e) => {
-                this.logger.error(`${this.apiUrl} : Request error: ${e.message}`);
-                if (!apiReq.destroyed) {
-                    apiReq.destroy();
+                // Retry on DNS failures (EAI_AGAIN) or connection resets
+                const isRetryableError = e.code === 'EAI_AGAIN' || 
+                                        e.code === 'ECONNRESET' || 
+                                        e.code === 'ENOTFOUND' ||
+                                        e.code === 'ETIMEDOUT';
+                
+                // Only retry if we haven't exceeded max retries
+                const shouldRetry = isRetryableError && attempt < this.options.maxRetries;
+                
+                if (shouldRetry) {
+                    this.logger.warn(`${this.apiUrl} : ${e.message} (attempt ${attempt + 1}/${this.options.maxRetries + 1})`);
+                    if (!apiReq.destroyed) {
+                        apiReq.destroy();
+                    }
+                    setTimeout(() => {
+                        this.get(requestData, callback, attempt + 1);
+                    }, this.options.retryDelay * (attempt + 1)); // Exponential backoff
+                } else {
+                    this.logger.error(`${this.apiUrl} : Request error: ${e.message}`);
+                    if (!apiReq.destroyed) {
+                        apiReq.destroy();
+                    }
+                    safeCallback(this.defaultApiReply);
                 }
-                safeCallback(this.defaultApiReply);
             });
 
             // Handle timeout