How to fix Error: HTTP 504 Gateway Timeout (upstream server timeout) in Node.js

# Check Nginx error logs
sudo tail -f /var/log/nginx/error.log

# Check Node.js application logs
pm2 logs your-app

# For AWS environments, check ELB access logs
aws logs tail /aws/elasticloadbalancing/your-lb --follow

server {
    listen 80;
    server_name example.com;

    location / {
        proxy_pass http://localhost:3000;

        # Increase all proxy timeouts
        proxy_connect_timeout 300s;
        proxy_send_timeout 300s;
        proxy_read_timeout 300s;

        # Important: match or exceed your app's processing time
        send_timeout 300s;
    }
}

<VirtualHost *:80>
    ProxyPass / http://localhost:3000/
    ProxyPassReverse / http://localhost:3000/

    # Set timeout to 5 minutes
    ProxyTimeout 300
</VirtualHost>

import express from 'express';

const app = express();
const PORT = 3000;

const server = app.listen(PORT, () => {
  console.log(`Server listening on port ${PORT}`);
});

// Set server timeout to 5 minutes (300,000 ms)
server.timeout = 300000;

// Set headers timeout (should be higher than timeout)
server.headersTimeout = 310000;

// Set keep-alive timeout
server.keepAliveTimeout = 65000; // Higher than proxy keep-alive

import axios from 'axios';

const api = axios.create({
  timeout: 30000, // 30 second timeout
});

// Or per-request
try {
  const response = await axios.get('https://api.example.com/data', {
    timeout: 60000, // 60 seconds for slow endpoints
  });
  console.log(response.data);
} catch (error) {
  if (error.code === 'ECONNABORTED') {
    console.error('Request timed out');
  } else if (error.response?.status === 504) {
    console.error('Upstream gateway timeout');
  }
  throw error;
}

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

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

// Add query logging
import { PrismaClient } from '@prisma/client';

const prisma = new PrismaClient({
  log: [
    { emit: 'event', level: 'query' },
  ],
});

prisma.$on('query', (e) => {
  if (e.duration > 1000) { // Log queries over 1 second
    console.warn(`Slow query (${e.duration}ms): ${e.query}`);
  }
});

import NodeCache from 'node-cache';
const cache = new NodeCache({ stdTTL: 600 }); // 10 minute cache

app.get('/api/expensive-data', async (req, res) => {
  const cacheKey = 'expensive-data';
  const cached = cache.get(cacheKey);

  if (cached) {
    return res.json(cached);
  }

  // Expensive operation
  const data = await fetchFromSlowAPI();
  cache.set(cacheKey, data);
  res.json(data);
});

import Queue from 'bull';
const jobQueue = new Queue('slow-tasks');

app.post('/api/process', async (req, res) => {
  // Don't wait for completion
  const job = await jobQueue.add({ data: req.body });

  // Return immediately
  res.json({ jobId: job.id, status: 'processing' });
});

function timeoutMiddleware(seconds) {
  return (req, res, next) => {
    // Set timeout on request
    req.setTimeout(seconds * 1000, () => {
      console.error(`Request timeout after ${seconds} seconds`);
      if (!res.headersSent) {
        res.status(504).json({
          error: 'Gateway Timeout',
          message: 'Request took too long to process',
        });
      }
    });

    // Set timeout on response
    res.setTimeout(seconds * 1000, () => {
      console.error(`Response timeout after ${seconds} seconds`);
      if (!res.headersSent) {
        res.status(504).json({
          error: 'Gateway Timeout',
          message: 'Response took too long to send',
        });
      }
    });

    next();
  };
}

// Apply globally or to specific routes
app.use(timeoutMiddleware(120)); // 2 minute timeout

// Or per-route for slow endpoints
app.get('/api/slow-report', timeoutMiddleware(300), async (req, res) => {
  const report = await generateSlowReport();
  res.json(report);
});