How to fix Error: cluster.fork() failed (cannot create child process) in Node.js

# Check soft limit (current limit)
ulimit -n

# Check hard limit (maximum you can set)
ulimit -Hn

# View all resource limits
ulimit -a

# Increase to 65536 (adjust as needed)
ulimit -n 65536

# Then run your Node.js application
node app.js

# Edit the limits configuration
sudo nano /etc/security/limits.conf

# Add these lines (adjust username):
your-user soft nofile 65536
your-user hard nofile 65536
* soft nofile 65536
* hard nofile 65536

[Service]
LimitNOFILE=65536

const cluster = require('cluster');
const os = require('os');

if (cluster.isMaster) {
  const numWorkers = os.cpus().length;

  console.log(`Master process ${process.pid} is running`);

  // Fork workers with error handling
  for (let i = 0; i < numWorkers; i++) {
    const worker = cluster.fork();

    // Handle fork errors
    worker.on('error', (err) => {
      console.error(`Worker fork error: ${err.message}`);
    });
  }

  cluster.on('exit', (worker, code, signal) => {
    console.log(`Worker ${worker.process.pid} died`);

    // Implement retry logic with backoff
    if (code !== 0 && !worker.exitedAfterDisconnect) {
      console.log('Starting a new worker...');
      setTimeout(() => {
        cluster.fork();
      }, 5000); // 5 second delay
    }
  });

  // Listen for fork errors
  cluster.on('fork', (worker) => {
    console.log(`Worker ${worker.process.pid} forked`);
  });
}

const cluster = require('cluster');
const os = require('os');

function calculateOptimalWorkers() {
  const cpuCount = os.cpus().length;
  const freeMemory = os.freemem();
  const totalMemory = os.totalmem();

  // Estimate memory per worker (adjust based on your app)
  const estimatedMemoryPerWorker = 512 * 1024 * 1024; // 512 MB

  // Calculate max workers based on available memory
  const maxWorkersByMemory = Math.floor(
    (freeMemory * 0.8) / estimatedMemoryPerWorker
  );

  // Use the smaller of CPU count or memory-constrained count
  const optimalWorkers = Math.min(cpuCount, maxWorkersByMemory);

  console.log(`Optimal workers: ${optimalWorkers}`);
  return Math.max(1, optimalWorkers);
}

if (cluster.isMaster) {
  const numWorkers = calculateOptimalWorkers();

  for (let i = 0; i < numWorkers; i++) {
    cluster.fork();
  }
}

// When shutting down a worker
worker.disconnect();

// Or use kill with proper cleanup
worker.kill();

// Better yet, handle graceful shutdown
process.on('SIGTERM', () => {
  console.log('SIGTERM received, shutting down gracefully');

  // Stop accepting new connections
  Object.values(cluster.workers).forEach(worker => {
    worker.disconnect();
  });

  // Force kill after timeout
  setTimeout(() => {
    Object.values(cluster.workers).forEach(worker => {
      worker.kill();
    });
    process.exit(0);
  }, 10000); // 10 second grace period
});

const fs = require('fs');
const { execSync } = require('child_process');

function checkFileDescriptors() {
  try {
    // On Linux, check /proc for open file descriptors
    const pid = process.pid;
    const fdPath = `/proc/${pid}/fd`;

    if (fs.existsSync(fdPath)) {
      const fdCount = fs.readdirSync(fdPath).length;
      console.log(`Current file descriptors: ${fdCount}`);

      // Get limit
      const limit = execSync('ulimit -n').toString().trim();
      console.log(`FD limit: ${limit}`);

      // Warn if approaching limit
      if (fdCount > parseInt(limit) * 0.8) {
        console.warn('WARNING: Approaching file descriptor limit!');
      }
    }
  } catch (err) {
    console.error('Unable to check file descriptors:', err.message);
  }
}

// Check periodically
setInterval(checkFileDescriptors, 60000); // Every minute