How to fix Error: HPE_UNEXPECTED_EOF (unexpected end of HTTP) in Node.js

const http = require('http');

function makeRequestWithRetry(options, maxRetries = 3) {
  return new Promise((resolve, reject) => {
    let attempt = 0;

    function attemptRequest() {
      attempt++;

      const req = http.request(options, (res) => {
        let data = '';

        res.on('data', (chunk) => {
          data += chunk;
        });

        res.on('end', () => {
          resolve(data);
        });

        res.on('error', handleError);
      });

      req.on('error', handleError);

      function handleError(err) {
        if (err.code === 'HPE_UNEXPECTED_EOF' && attempt < maxRetries) {
          const delay = Math.pow(2, attempt) * 100; // Exponential backoff
          console.log(`Retry attempt ${attempt} after ${delay}ms`);
          setTimeout(attemptRequest, delay);
        } else {
          reject(err);
        }
      }

      req.end();
    }

    attemptRequest();
  });
}

const http = require('http');

const options = {
  hostname: 'example.com',
  path: '/api/data',
  method: 'GET',
  timeout: 30000, // 30 second timeout
  // Ensure server keep-alive is longer than client timeout
  headers: {
    'Connection': 'keep-alive',
    'Keep-Alive': 'timeout=5, max=100'
  }
};

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

// Handle timeout specifically
req.on('timeout', () => {
  console.error('Request timed out');
  req.destroy(); // Destroy the request
});

req.on('error', (err) => {
  if (err.code === 'HPE_UNEXPECTED_EOF') {
    console.error('Server closed connection prematurely');
  }
});

req.end();

const server = http.createServer((req, res) => {
  // Handle requests
});

// Set server keep-alive timeout to 65 seconds
// (longer than typical client 60s timeout)
server.keepAliveTimeout = 65000;
server.headersTimeout = 66000; // Slightly longer than keepAliveTimeout

server.listen(3000);

// Using axios with retry logic
const axios = require('axios');
const axiosRetry = require('axios-retry');

const client = axios.create({
  timeout: 30000,
  httpAgent: new http.Agent({
    keepAlive: true,
    keepAliveMsecs: 30000
  })
});

// Configure automatic retries
axiosRetry(client, {
  retries: 3,
  retryDelay: axiosRetry.exponentialDelay,
  retryCondition: (error) => {
    return axiosRetry.isNetworkOrIdempotentRequestError(error) ||
           error.code === 'HPE_UNEXPECTED_EOF';
  }
});

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

const got = require('got');

try {
  const response = await got('https://api.example.com/data', {
    timeout: {
      request: 30000
    },
    retry: {
      limit: 3,
      methods: ['GET', 'POST'],
      statusCodes: [408, 413, 429, 500, 502, 503, 504],
      errorCodes: [
        'ETIMEDOUT',
        'ECONNRESET',
        'EADDRINUSE',
        'ECONNREFUSED',
        'EPIPE',
        'ENOTFOUND',
        'ENETUNREACH',
        'EAI_AGAIN',
        'HPE_UNEXPECTED_EOF'
      ]
    }
  });

  console.log(response.body);
} catch (error) {
  console.error('Request failed:', error.message);
}

const http = require('http');

const server = http.createServer((req, res) => {
  // Always set appropriate headers
  res.setHeader('Content-Type', 'application/json');

  const responseData = JSON.stringify({ message: 'Success' });

  // Explicitly set Content-Length
  res.setHeader('Content-Length', Buffer.byteLength(responseData));

  // Ensure complete response is sent before ending
  res.writeHead(200);
  res.end(responseData); // Use end() with data, not separate write() + end()
});

// Handle server errors
server.on('error', (err) => {
  console.error('Server error:', err);
});

// Handle client errors
server.on('clientError', (err, socket) => {
  console.error('Client error:', err);
  // Send proper 400 response instead of abrupt close
  if (socket.writable) {
    socket.end('HTTP/1.1 400 Bad Request\r\n\r\n');
  } else {
    socket.destroy();
  }
});

server.listen(3000);

// DON'T DO THIS
res.write('Some data');
socket.destroy(); // Abrupt close causes HPE_UNEXPECTED_EOF

// DO THIS INSTEAD
res.write('Some data');
res.end(); // Proper response termination

# Check if proxy is closing connections
curl -v https://api.example.com/endpoint

# Test direct connection bypassing proxy
curl -v --noproxy '*' https://api.example.com/endpoint

# /etc/nginx/nginx.conf
http {
    # Client body timeout
    client_body_timeout 60s;

    # Client header timeout
    client_header_timeout 60s;

    # Keepalive timeout
    keepalive_timeout 65s;

    # Proxy read timeout
    proxy_read_timeout 60s;

    # Proxy connect timeout
    proxy_connect_timeout 60s;

    # Proxy send timeout
    proxy_send_timeout 60s;
}