How to fix Error: socket hang up in MongoDB

const { MongoClient } = require('mongodb');

// Increase socketTimeoutMS to 30000ms (30 seconds)
const uri = 'mongodb://localhost:27017/mydb?socketTimeoutMS=30000&connectTimeoutMS=30000';
const client = new MongoClient(uri);

// Or with connection options
const client = new MongoClient(uri, {
  socketTimeoutMS: 30000,
  connectTimeoutMS: 30000,
  serverSelectionTimeoutMS: 30000,
});

const mongoose = require('mongoose');

mongoose.connect('mongodb://localhost:27017/mydb', {
  socketTimeoutMS: 30000,
  connectTimeoutMS: 30000,
  serverSelectionTimeoutMS: 30000,
});

# In mongosh or mongo shell
db.serverStatus().connections

# In mongosh
db.adminCommand({getParameter: 1, maxIncomingConnections: 1})

# /etc/mongod.conf
net:
  port: 27017
  maxIncomingConnections: 1000  # Increase from default 65536 if needed

# Continuous monitoring
watch -n 5 "echo 'db.serverStatus().connections' | mongosh --quiet"

const client = new MongoClient(uri, {
  maxPoolSize: 50,           // Maximum connections in pool
  minPoolSize: 10,           // Minimum connections to maintain
  maxIdleTimeMS: 60000,      // Close idle connections after 60s
  waitQueueTimeoutMS: 10000, // Wait 10s for connection from pool
});

mongoose.connect(uri, {
  maxPoolSize: 50,
  minPoolSize: 10,
  socketTimeoutMS: 30000,
});

// Log pool metrics periodically
setInterval(() => {
  const poolStats = client.topology?.s?.pool?.poolStats;
  if (poolStats) {
    console.log('Pool stats:', {
      total: poolStats.totalConnectionCount,
      available: poolStats.availableConnectionCount,
      waitQueue: poolStats.waitQueueSize,
    });
  }
}, 30000);

# Test basic connectivity
ping mongodb-host

# Test MongoDB port
nc -zv mongodb-host 27017

# Test with timeout
timeout 30 nc -zv mongodb-host 27017

# Linux iptables
sudo iptables -L -n | grep 27017

# Linux firewalld
sudo firewall-cmd --list-all | grep 27017

# Windows firewall
netsh advfirewall firewall show rule name=all | findstr 27017

# Nginx example - increase proxy timeout
location / {
    proxy_pass http://mongodb-backend;
    proxy_connect_timeout 30s;
    proxy_send_timeout 30s;
    proxy_read_timeout 30s;
}

aws elb modify-load-balancer-attributes \
  --load-balancer-name my-lb \
  --load-balancer-attributes "{\"ConnectionSettings\":{\"IdleTimeout\":300}}"

async function queryWithRetry(collection, query, maxRetries = 3) {
  let lastError;

  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      return await collection.find(query).toArray();
    } catch (error) {
      lastError = error;

      // Only retry on socket hang up or network errors
      if (error.message.includes('socket hang up') ||
          error.name === 'MongoNetworkError') {

        const delay = Math.min(1000 * Math.pow(2, attempt), 10000);
        console.log('Attempt ' + attempt + ' failed, retrying in ' + delay + 'ms');
        await new Promise(resolve => setTimeout(resolve, delay));
        continue;
      }

      // Non-retryable error
      throw error;
    }
  }

  throw lastError;
}

// Usage
const results = await queryWithRetry(db.collection('users'), { active: true });

npm install p-retry

const retry = require('p-retry');

async function runQuery() {
  return await db.collection('users').find({ active: true }).toArray();
}

const result = await retry(runQuery, {
  retries: 3,
  factor: 2, // exponential backoff factor
  minTimeout: 1000,
  maxTimeout: 10000,
  onFailedAttempt: error => {
    console.log('Attempt ' + error.attemptNumber + ' failed. ' + error.retriesLeft + ' retries left');
  },
});

const client = new MongoClient(uri, {
  retryWrites: true,
  retryReads: true,
  // Driver will automatically retry certain operations
});

# Enable profiling
db.setProfilingLevel(1, { slowms: 100 })

# Check profiled queries
db.system.profile.find().sort({ ts: -1 }).limit(10).pretty()

// In your application
const explain = await collection.find({ userId: '123' })
  .explain('executionStats');
console.log('Query stats:', explain.executionStats);

// Create index on frequently queried fields
await collection.createIndex({ userId: 1 });
await collection.createIndex({ createdAt: -1 });
await collection.createIndex({ status: 1, priority: -1 });

// Bad: Fetching all documents
const allUsers = await collection.find({}).toArray();

// Good: Use pagination
const users = await collection.find({})
  .limit(100)
  .skip(0)
  .toArray();

// Good: Use projection to fetch only needed fields
const users = await collection.find({}, {
  projection: { name: 1, email: 1, _id: 0 }
}).toArray();

// Bad: Single large insert
await collection.insertMany(millionDocuments);

// Good: Batch in chunks
const batchSize = 1000;
for (let i = 0; i < millionDocuments.length; i += batchSize) {
  const batch = millionDocuments.slice(i, i + batchSize);
  await collection.insertMany(batch);
  console.log('Inserted ' + (i + batchSize) + ' documents');
}