How to fix connection refused because too many open connections in MongoDB

# Connect to MongoDB shell
mongosh

# Check current connection count
db.serverStatus().connections

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

# Check MongoDB process limits
cat /proc/$(pgrep mongod)/limits | grep "Max open files"

# Check system-wide limits
ulimit -n

# Check MongoDB user limits (if running as mongod user)
sudo -u mongod bash -c "ulimit -n"

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

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

# Add these lines (adjust values as needed)
mongod soft nofile 64000
mongod hard nofile 64000
* soft nofile 64000
* hard nofile 64000

# For systemd systems (Ubuntu 16.04+, CentOS 7+)
sudo nano /etc/systemd/system/mongod.service.d/limits.conf

# Add:
[Service]
LimitNOFILE=64000
LimitNPROC=64000

# Reload systemd and restart MongoDB
sudo systemctl daemon-reload
sudo systemctl restart mongod

# Check current kernel limits
sysctl fs.file-max
sysctl fs.file-nr

# Increase file-max (system-wide limit)
sudo sysctl -w fs.file-max=2097152

# Make permanent
echo "fs.file-max = 2097152" >> /etc/sysctl.conf
sudo sysctl -p

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

const uri = 'mongodb://localhost:27017/mydb';
const client = new MongoClient(uri, {
  maxPoolSize: 100,           // Maximum connections in pool
  minPoolSize: 10,            // Minimum connections to maintain
  maxIdleTimeMS: 60000,       // Close idle connections after 60s
  waitQueueTimeoutMS: 10000,  // Max time to wait for connection
  socketTimeoutMS: 30000,     // Socket operation timeout
  connectTimeoutMS: 10000,    // Connection establishment timeout
  serverSelectionTimeoutMS: 30000, // Server selection timeout
});

const mongoose = require('mongoose');

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

// BAD: Cursor not closed
const cursor = collection.find({});
const results = await cursor.toArray();
// Cursor remains open

// GOOD: Explicitly close cursor
const cursor = collection.find({});
try {
  const results = await cursor.toArray();
  return results;
} finally {
  await cursor.close();
}

// BETTER: Use toArray() which automatically closes
const results = await collection.find({}).toArray();

// BAD: Creating new client for each request
app.get('/users', async (req, res) => {
  const client = new MongoClient(uri); // New connection each time
  await client.connect();
  // ... query
  await client.close(); // Closes connection instead of returning to pool
});

// GOOD: Reuse single client instance
const client = new MongoClient(uri, { maxPoolSize: 100 });
await client.connect(); // Once at startup

app.get('/users', async (req, res) => {
  const db = client.db('mydb');
  const users = await db.collection('users').find({}).toArray();
  res.json(users);
  // Connection automatically returns to pool
});

// BAD: Connection leak on error
async function updateUser(userId, data) {
  const session = client.startSession();
  try {
    session.startTransaction();
    await collection.updateOne({ _id: userId }, { $set: data }, { session });
    await session.commitTransaction();
  } catch (error) {
    await session.abortTransaction();
    throw error;
  }
  // Session not ended - connection leak!
}

// GOOD: Always end session
async function updateUser(userId, data) {
  const session = client.startSession();
  try {
    session.startTransaction();
    await collection.updateOne({ _id: userId }, { $set: data }, { session });
    await session.commitTransaction();
  } catch (error) {
    await session.abortTransaction();
    throw error;
  } finally {
    await session.endSession(); // Always end session
  }
}

const uri = 'mongodb://host1,host2,host3/mydb?' +
  'replicaSet=myReplicaSet&' +
  'maxPoolSize=100&' +
  'minPoolSize=10&' +
  'maxIdleTimeMS=60000&' +
  'waitQueueTimeoutMS=10000&' +
  'socketTimeoutMS=30000&' +
  'connectTimeoutMS=10000&' +
  'serverSelectionTimeoutMS=30000&' +
  'retryWrites=true&' +
  'retryReads=true&' +
  'readPreference=secondaryPreferred&' +
  'maxStalenessSeconds=90';

// Periodic health check
setInterval(async () => {
  try {
    await client.db('admin').command({ ping: 1 });
    console.log('Connection healthy');
  } catch (error) {
    console.error('Connection health check failed:', error);
    // Implement reconnection logic
  }
}, 30000);

// Handle application shutdown
process.on('SIGTERM', async () => {
  console.log('SIGTERM received, closing MongoDB connections...');

  // Close all connections gracefully
  await client.close();

  // Additional cleanup
  await mongoose.disconnect();

  console.log('MongoDB connections closed');
  process.exit(0);
});

// Use different connections for reads and writes
const writeClient = new MongoClient('mongodb://primary-host/mydb', {
  maxPoolSize: 50,
  readPreference: 'primary',
});

const readClient = new MongoClient('mongodb://secondary-host/mydb', {
  maxPoolSize: 100,
  readPreference: 'secondary',
});

// Use write client for mutations
async function createUser(user) {
  const db = writeClient.db('mydb');
  return await db.collection('users').insertOne(user);
}

// Use read client for queries
async function getUsers() {
  const db = readClient.db('mydb');
  return await db.collection('users').find({}).toArray();
}

// Instead of one giant pool, use specialized pools
const userServiceClient = new MongoClient(uri, { maxPoolSize: 50 });
const orderServiceClient = new MongoClient(uri, { maxPoolSize: 30 });
const analyticsClient = new MongoClient(uri, { maxPoolSize: 20 });

// Each service manages its own connection pool

# Enable sharding
mongosh
use admin
sh.enableSharding("mydb")

# Shard a collection
sh.shardCollection("mydb.users", { userId: "hashed" })

# Add shards
sh.addShard("shard1.example.com:27017")
sh.addShard("shard2.example.com:27017")