How to fix Error: IPC channel error in forked process (communication failed) in Node.js

const { fork } = require('child_process');

const child = fork('./worker.js');

// Listen for disconnection
child.on('disconnect', () => {
  console.log('Child process disconnected');
});

// Listen for exit
child.on('exit', (code, signal) => {
  console.log(`Child exited with code ${code} and signal ${signal}`);
});

// Listen for errors
child.on('error', (err) => {
  console.error('Child process error:', err);
});

// Check connection status before sending
if (child.connected) {
  child.send({ message: 'Hello' });
} else {
  console.log('Cannot send - child is disconnected');
}

// worker.js
process.on('uncaughtException', (err) => {
  console.error('Uncaught exception in child:', err);
  // Gracefully disconnect
  if (process.connected) {
    process.disconnect();
  }
  process.exit(1);
});

process.on('unhandledRejection', (reason, promise) => {
  console.error('Unhandled rejection in child:', reason);
  if (process.connected) {
    process.disconnect();
  }
  process.exit(1);
});

process.on('message', async (msg) => {
  try {
    // Process message
    const result = await doWork(msg);

    // Check connection before responding
    if (process.connected) {
      process.send({ result });
    }
  } catch (err) {
    console.error('Error processing message:', err);
    if (process.connected) {
      process.send({ error: err.message });
    }
  }
});

function sendWithRetry(child, message, maxRetries = 3) {
  return new Promise((resolve, reject) => {
    let attempt = 0;

    function trySend() {
      if (!child.connected) {
        if (attempt < maxRetries) {
          attempt++;
          const delay = Math.pow(2, attempt) * 100; // Exponential backoff
          console.log(`Retry attempt ${attempt} after ${delay}ms`);
          setTimeout(trySend, delay);
        } else {
          reject(new Error('IPC channel disconnected after retries'));
        }
        return;
      }

      try {
        child.send(message, (err) => {
          if (err) {
            console.error('Send error:', err);
            if (attempt < maxRetries) {
              attempt++;
              const delay = Math.pow(2, attempt) * 100;
              setTimeout(trySend, delay);
            } else {
              reject(err);
            }
          } else {
            resolve();
          }
        });
      } catch (err) {
        reject(err);
      }
    }

    trySend();
  });
}

// Usage
sendWithRetry(child, { task: 'process data' })
  .then(() => console.log('Message sent successfully'))
  .catch(err => console.error('Failed to send message:', err));

# Check current limits (Linux/macOS)
ulimit -n

# Check current usage
lsof -p <pid> | wc -l

# Increase soft limit temporarily
ulimit -n 4096

# Increase limit permanently (edit /etc/security/limits.conf)
* soft nofile 4096
* hard nofile 8192

// In PM2 ecosystem.config.js
module.exports = {
  apps: [{
    name: 'app',
    script: './app.js',
    max_restarts: 10,
    max_memory_restart: '500M',
    error_file: './logs/err.log',
    out_file: './logs/out.log'
  }]
};

const workers = [];

// Parent process
function createWorker() {
  const worker = fork('./worker.js');
  workers.push(worker);
  return worker;
}

function gracefulShutdown() {
  console.log('Shutting down gracefully...');

  // Send shutdown signal to all workers
  const shutdownPromises = workers.map(worker => {
    return new Promise((resolve) => {
      if (worker.connected) {
        worker.send({ type: 'shutdown' });

        // Wait for worker to disconnect
        worker.on('disconnect', resolve);

        // Force kill after timeout
        setTimeout(() => {
          if (worker.connected) {
            worker.kill('SIGTERM');
          }
          resolve();
        }, 5000);
      } else {
        resolve();
      }
    });
  });

  Promise.all(shutdownPromises).then(() => {
    console.log('All workers shut down');
    process.exit(0);
  });
}

process.on('SIGTERM', gracefulShutdown);
process.on('SIGINT', gracefulShutdown);

// Child process
process.on('message', (msg) => {
  if (msg.type === 'shutdown') {
    // Clean up resources
    cleanup().then(() => {
      process.disconnect();
      process.exit(0);
    });
  }
});