How to fix Error: request timeout after 30000ms (HTTP request did not complete) in Node.js

const axios = require('axios');

// Set timeout for specific request
const response = await axios.get('https://api.example.com/data', {
  timeout: 60000 // 60 seconds
});

// Or configure globally
const client = axios.create({
  timeout: 60000,
  baseURL: 'https://api.example.com'
});

const controller = new AbortController();
const timeoutId = setTimeout(() => controller.abort(), 60000);

try {
  const response = await fetch('https://api.example.com/data', {
    signal: controller.signal
  });
  clearTimeout(timeoutId);
} catch (error) {
  if (error.name === 'AbortError') {
    console.error('Request timed out');
  }
}

const https = require('https');

const options = {
  hostname: 'api.example.com',
  path: '/data',
  timeout: 60000
};

const req = https.get(options, (res) => {
  // Handle response
});

req.on('timeout', () => {
  req.destroy();
  console.error('Request timed out');
});

const axios = require('axios');

async function fetchWithRetry(url, maxRetries = 3, baseDelay = 1000) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      const response = await axios.get(url, { timeout: 30000 });
      return response.data;
    } catch (error) {
      if (error.code === 'ECONNABORTED' && i < maxRetries - 1) {
        const delay = baseDelay * Math.pow(2, i);
        console.log(`Request timeout, retrying in ${delay}ms...`);
        await new Promise(resolve => setTimeout(resolve, delay));
        continue;
      }
      throw error;
    }
  }
}

// Usage
try {
  const data = await fetchWithRetry('https://api.example.com/data');
  console.log(data);
} catch (error) {
  console.error('Request failed after retries:', error.message);
}

const axios = require('axios');
const http = require('http');
const https = require('https');

// Create HTTP agents with connection pooling
const httpAgent = new http.Agent({
  keepAlive: true,
  keepAliveMsecs: 30000,
  maxSockets: 50,
  maxFreeSockets: 10,
  timeout: 60000
});

const httpsAgent = new https.Agent({
  keepAlive: true,
  keepAliveMsecs: 30000,
  maxSockets: 50,
  maxFreeSockets: 10,
  timeout: 60000
});

// Use agents with axios
const client = axios.create({
  httpAgent,
  httpsAgent,
  timeout: 30000
});

const axios = require('axios');

async function makeRequest(url) {
  try {
    const response = await axios.get(url, { timeout: 30000 });
    return response.data;
  } catch (error) {
    if (error.code === 'ECONNABORTED' || error.code === 'ETIMEDOUT') {
      console.error('Request timeout:', {
        url: error.config?.url,
        timeout: error.config?.timeout,
        duration: Date.now() - error.config?.startTime
      });
      // Return cached data, default value, or rethrow
      throw new Error('Service temporarily unavailable');
    }
    
    if (error.response) {
      // Server responded with error status
      console.error('Server error:', error.response.status);
    } else if (error.request) {
      // Request made but no response received
      console.error('No response received');
    }
    
    throw error;
  }
}

// Add request timing for debugging
axios.interceptors.request.use(config => {
  config.startTime = Date.now();
  return config;
});

axios.interceptors.response.use(
  response => {
    const duration = Date.now() - response.config.startTime;
    console.log(`Request completed in ${duration}ms`);
    return response;
  },
  error => {
    if (error.config?.startTime) {
      const duration = Date.now() - error.config.startTime;
      console.error(`Request failed after ${duration}ms`);
    }
    return Promise.reject(error);
  }
);

const axios = require('axios');
const { performance } = require('perf_hooks');

// Create detailed timing logger
function createTimingLogger() {
  return {
    dnsLookupStart: 0,
    tcpConnectionStart: 0,
    tlsHandshakeStart: 0,
    requestStart: 0,
    responseStart: 0,
    responseEnd: 0
  };
}

// Log request with detailed timing
async function debugRequest(url) {
  const timing = createTimingLogger();
  const startTime = performance.now();
  
  try {
    const response = await axios.get(url, {
      timeout: 30000,
      onDownloadProgress: (progressEvent) => {
        if (!timing.responseStart) {
          timing.responseStart = performance.now() - startTime;
        }
      }
    });
    
    timing.responseEnd = performance.now() - startTime;
    
    console.log('Request timing breakdown:', {
      total: `${timing.responseEnd.toFixed(2)}ms`,
      url,
      size: response.headers['content-length'],
      status: response.status
    });
    
    return response;
  } catch (error) {
    const failTime = performance.now() - startTime;
    console.error('Request failed:', {
      url,
      duration: `${failTime.toFixed(2)}ms`,
      error: error.code || error.message,
      timeout: error.config?.timeout
    });
    throw error;
  }
}

// Usage
debugRequest('https://api.example.com/data');

# Test DNS resolution time
time nslookup api.example.com

# Test connection time
time curl -o /dev/null -s -w "Total time: %{time_total}s\n" https://api.example.com/data

# Trace route to identify network hops
traceroute api.example.com