How to fix Error: ENOBUFS: no buffer space available in Node.js

const stream = getWritableStream();

function writeData(data) {
  const canContinue = stream.write(data);

  if (!canContinue) {
    // Buffer is full, wait for drain event
    stream.once('drain', () => {
      console.log('Buffer drained, can write more');
      // Continue writing
    });
  }
}

const CHUNK_SIZE = 64 * 1024; // 64KB chunks

function writeLargeData(socket, buffer) {
  let offset = 0;

  function writeChunk() {
    while (offset < buffer.length) {
      const chunk = buffer.slice(offset, offset + CHUNK_SIZE);
      const canContinue = socket.write(chunk);
      offset += CHUNK_SIZE;

      if (!canContinue) {
        socket.once('drain', writeChunk);
        return;
      }
    }
    socket.end();
  }

  writeChunk();
}

# Backup current configuration
sudo cp /etc/sysctl.conf /etc/sysctl.conf.backup

# Edit the file
sudo nano /etc/sysctl.conf

# Maximum socket receive buffer (16MB)
net.core.rmem_max = 16777216

# Maximum socket send buffer (16MB)
net.core.wmem_max = 16777216

# Default socket receive buffer (256KB)
net.core.rmem_default = 262144

# Default socket send buffer (256KB)
net.core.wmem_default = 262144

# TCP read buffer sizes: min, default, max
net.ipv4.tcp_rmem = 4096 87380 16777216

# TCP write buffer sizes: min, default, max
net.ipv4.tcp_wmem = 4096 65536 16777216

sudo sysctl -p

sysctl net.core.wmem_max net.core.rmem_max

const net = require('net');

const socket = new net.Socket();

// Increase send buffer to 1MB
socket.setNoDelay(true);
socket.bufferSize = 1024 * 1024;

// For HTTP agents, configure socket settings
const http = require('http');

const agent = new http.Agent({
  keepAlive: true,
  maxSockets: 50, // Limit concurrent connections
  maxFreeSockets: 10,
  timeout: 60000,
});

// Use the agent in requests
http.get({
  hostname: 'example.com',
  agent: agent
}, (res) => {
  // Handle response
});

const server = net.createServer((socket) => {
  // Set buffer sizes for each connection
  socket.setKeepAlive(true);
  socket.setNoDelay(true);

  // Handle socket events
  socket.on('error', (err) => {
    if (err.code === 'ENOBUFS') {
      console.error('Buffer exhausted, implementing backoff');
      // Implement retry logic
    }
  });
});

const http = require('http');

// Configure agent with connection limits
const agent = new http.Agent({
  keepAlive: true,
  maxSockets: 50,        // Max concurrent connections per host
  maxTotalSockets: 100,  // Max total connections
  maxFreeSockets: 10,    // Max idle connections
  scheduling: 'lifo',    // Reuse recent connections
});

// Use with fetch or http requests
const options = {
  agent: agent,
  timeout: 30000,
};

class RequestQueue {
  constructor(concurrency = 10) {
    this.concurrency = concurrency;
    this.running = 0;
    this.queue = [];
  }

  async add(fn) {
    while (this.running >= this.concurrency) {
      await new Promise(resolve => this.queue.push(resolve));
    }

    this.running++;
    try {
      return await fn();
    } finally {
      this.running--;
      const next = this.queue.shift();
      if (next) next();
    }
  }
}

const queue = new RequestQueue(10);

// Use the queue
async function makeRequest(url) {
  return queue.add(() => fetch(url));
}

# Check soft limit
ulimit -n

# Check hard limit
ulimit -Hn

ulimit -n 65536

*  soft  nofile  65536
*  hard  nofile  65536

[Service]
LimitNOFILE=65536

fs.file-max = 2097152

sudo sysctl -p

async function writeWithRetry(socket, data, maxRetries = 3) {
  let retries = 0;
  let delay = 100; // Start with 100ms delay

  while (retries < maxRetries) {
    try {
      return await new Promise((resolve, reject) => {
        const canWrite = socket.write(data, (err) => {
          if (err) reject(err);
          else resolve();
        });

        if (!canWrite) {
          socket.once('drain', resolve);
        } else {
          resolve();
        }
      });
    } catch (err) {
      if (err.code === 'ENOBUFS' && retries < maxRetries - 1) {
        console.warn(`ENOBUFS error, retry ${retries + 1}/${maxRetries}`);
        await new Promise(resolve => setTimeout(resolve, delay));
        delay *= 2; // Exponential backoff
        retries++;
      } else {
        throw err;
      }
    }
  }

  throw new Error('Max retries exceeded for ENOBUFS');
}

// Usage
socket.on('error', (err) => {
  if (err.code === 'ENOBUFS') {
    console.error('Buffer space exhausted:', err.message);
    // Implement recovery strategy
  }
});