How to fix OutOfDiskSpace: Disk space is critically low in MongoDB

# Check disk usage on Linux/Unix
df -h /var/lib/mongodb  # or your MongoDB data directory

# Check inode usage (important for some filesystems)
df -i /var/lib/mongodb

# Check detailed disk usage by directory
du -sh /var/lib/mongodb/*
du -sh /var/lib/mongodb/*/* 2>/dev/null | sort -hr | head -20

# For Windows
wmic logicaldisk get size,freespace,caption
dir /s "C:\Program Files\MongoDB\Server\data"

// In mongosh or mongo shell
use admin

// Check database sizes
show dbs

// Check collection sizes for each database
db.getCollectionNames().forEach(function(coll) {
  var stats = db[coll].stats();
  print(coll + ': ' + stats.size + ' bytes (' +
        Math.round(stats.size / 1024 / 1024) + ' MB)');
});

// Check index sizes
db.getCollectionNames().forEach(function(coll) {
  var stats = db[coll].stats();
  print(coll + ' indexes: ' + stats.totalIndexSize + ' bytes');
});

// Run in each database
db.getCollectionNames().forEach(function(coll) {
  var size = db[coll].stats().size;
  if (size > 100 * 1024 * 1024) { // Larger than 100MB
    print('Large collection: ' + coll + ' - ' +
          Math.round(size / 1024 / 1024) + ' MB');
  }
});

# Rotate and compress MongoDB logs
sudo logrotate -f /etc/logrotate.d/mongod

# Remove old log files (keep last 7 days)
find /var/log/mongodb -name "*.log*" -mtime +7 -delete

# Compress large log files
find /var/log/mongodb -name "*.log" -size +100M -exec gzip {} ;

# Check for orphaned temporary files
find /var/lib/mongodb -name "*.tmp" -mtime +1 -delete
find /var/lib/mongodb -name "mongodb-*.sock" -delete
find /tmp -name "mongodb-*" -mtime +1 -delete

# Clean package manager cache
sudo apt-get clean  # Debian/Ubuntu
sudo yum clean all  # RHEL/CentOS

# Remove old kernel versions (Linux)
sudo apt-get autoremove --purge  # Debian/Ubuntu

# Clear systemd journal logs
sudo journalctl --vacuum-time=3d
sudo journalctl --vacuum-size=500M

# Compress backup files if present
find /var/backups -name "*.gz" -exec gzip -f {} \;

# Check for core dumps
find / -name "core.*" -size +100M -delete 2>/dev/null

// Find old data that can be archived
use yourDatabase

// Example: Find documents older than 1 year
var oldData = db.yourCollection.count({
  createdAt: { $lt: new Date(Date.now() - 365 * 24 * 60 * 60 * 1000) }
});
print('Documents older than 1 year: ' + oldData);

// Check for duplicate or temporary data
db.yourCollection.aggregate([
  { $match: { status: 'temporary' } },
  { $count: 'temporaryDocuments' }
]);

# Use mongodump to archive old data
mongodump --db yourDatabase --collection yourCollection   --query '{"createdAt": {"$lt": {"$date": "2024-01-01T00:00:00Z"}}}'   --out /path/to/archive/

# Compress the archive
tar -czf /path/to/archive/mongodb-archive-$(date +%Y%m%d).tar.gz /path/to/archive/yourDatabase

// Remove old data after verifying archive
use yourDatabase

// First, create index for efficient deletion
db.yourCollection.createIndex({ createdAt: 1 });

// Delete in batches to avoid overwhelming the system
var batchSize = 1000;
var cutoffDate = new Date(Date.now() - 365 * 24 * 60 * 60 * 1000);

while (true) {
  var result = db.yourCollection.deleteMany({
    createdAt: { $lt: cutoffDate }
  }).limit(batchSize);

  print('Deleted ' + result.deletedCount + ' documents');

  if (result.deletedCount < batchSize) {
    break;
  }

  // Small pause between batches
  sleep(100);
}

// Create TTL index to automatically remove old documents
db.yourCollection.createIndex(
  { createdAt: 1 },
  { expireAfterSeconds: 365 * 24 * 60 * 60 } // 1 year
);

// For time-series collections (MongoDB 5.0+)
db.createCollection("logs", {
  timeseries: {
    timeField: "timestamp",
    metaField: "metadata",
    granularity: "hours"
  },
  expireAfterSeconds: 30 * 24 * 60 * 60 // 30 days
});

// For WiredTiger storage engine (default)
use yourDatabase

// Run compact on specific collections
db.runCommand({ compact: 'yourCollection' });

// Monitor progress (run in another shell)
db.currentOp({ "command.compact": { $exists: true } });

// Check storage statistics before and after
var beforeStats = db.yourCollection.storageStats();

// Force storage reclamation
db.runCommand({
  compact: 'yourCollection',
  force: true  // Force compaction even if little gain expected
});

var afterStats = db.yourCollection.storageStats();
print('Space reclaimed: ' +
      (beforeStats.size - afterStats.size) + ' bytes');

// Rebuild all indexes on a collection
db.yourCollection.reIndex();

// Check index sizes before and after
db.yourCollection.aggregate([
  { $indexStats: {} },
  { $group: {
      _id: null,
      totalSize: { $sum: "$size" }
    }
  }
]);

// Create new collection with snappy compression (default)
db.createCollection("newCollection", {
  storageEngine: {
    wiredTiger: {
      configString: "block_compressor=snappy"
    }
  }
});

// For better compression (more CPU)
db.createCollection("highlyCompressed", {
  storageEngine: {
    wiredTiger: {
      configString: "block_compressor=zlib"
    }
  }
});

// Use mongodump/mongorestore to change compression
// 1. Dump the collection
// 2. Drop the collection
// 3. Create with desired compression
// 4. Restore the data

# AWS EBS volume resize
aws ec2 modify-volume --volume-id vol-12345 --size 100

# Then extend filesystem
sudo growpart /dev/xvdf 1
sudo resize2fs /dev/xvdf1  # ext4
# or
sudo xfs_growfs /mount/point  # xfs

# Azure Disk resize
az disk update --resource-group myRG --name myDisk --size-gb 200

# Google Cloud Persistent Disk
gcloud compute disks resize my-disk --size=200GB --zone=us-central1-a

# Add new volume and mount it
sudo mkdir /mnt/mongodb_data2
sudo mount /dev/sdb1 /mnt/mongodb_data2

# Update MongoDB configuration
sudo nano /etc/mongod.conf
# Change storage.dbPath to new location

# Create monitoring script
cat > /usr/local/bin/check_mongodb_disk.sh << 'EOF'
#!/bin/bash
THRESHOLD=20  # Percentage free space threshold
DATA_DIR="/var/lib/mongodb"

FREE_PCT=$(df --output=pcent "$DATA_DIR" | tail -1 | tr -d '% ')
if [ "$FREE_PCT" -gt "$THRESHOLD" ]; then
  echo "OK: $FREE_PCT% free space in $DATA_DIR"
  exit 0
else
  echo "CRITICAL: Only $FREE_PCT% free space in $DATA_DIR"
  exit 2
fi
EOF

chmod +x /usr/local/bin/check_mongodb_disk.sh

# Schedule regular checks
echo "*/5 * * * * root /usr/local/bin/check_mongodb_disk.sh" | sudo tee /etc/cron.d/mongodb-disk-check

# In /etc/mongod.conf
storage:
  dbPath: /var/lib/mongodb
  journal:
    enabled: true
  # Optional: Limit total data size
  # maxSize: 100GB

  wiredTiger:
    engineConfig:
      # Cache size (default: 50% of RAM - 1GB)
      cacheSizeGB: 4
      # Journal compressor
      journalCompressor: snappy
      # Directory for temporary files (can be on different volume)
      # directoryForIndexes: /mnt/fast_ssd
    collectionConfig:
      blockCompressor: snappy
    indexConfig:
      prefixCompression: true

// Regular cleanup job
db.createCollection("cleanupJobs", {
  validator: {
    $jsonSchema: {
      bsonType: "object",
      required: ["collection", "query", "schedule"],
      properties: {
        collection: { bsonType: "string" },
        query: { bsonType: "object" },
        schedule: { bsonType: "string" },
        lastRun: { bsonType: "date" },
        enabled: { bsonType: "bool" }
      }
    }
  }
});

// Example cleanup job document
db.cleanupJobs.insertOne({
  collection: "logs",
  query: { timestamp: { $lt: new Date(Date.now() - 30 * 24 * 60 * 60 * 1000) } },
  schedule: "0 2 * * *",  // Daily at 2 AM
  lastRun: null,
  enabled: true
});

// Create capped collection (fixed size, FIFO)
db.createCollection("recentEvents", {
  capped: true,
  size: 100 * 1024 * 1024,  // 100MB
  max: 100000  // Maximum document count
});

// Convert existing collection to time-series (MongoDB 5.0+)
db.logs.convertToCapped(100 * 1024 * 1024);

// Enable sharding on database
sh.enableSharding("yourDatabase");

// Shard collection by date range
sh.shardCollection("yourDatabase.logs", { timestamp: 1 });

// Add shards as needed
sh.addShard("shard1/mongodb1:27017");
sh.addShard("shard2/mongodb2:27017");

# Backup script with rotation
#!/bin/bash
BACKUP_DIR="/backups/mongodb"
RETENTION_DAYS=30

# Create backup
mongodump --out "$BACKUP_DIR/$(date +%Y%m%d_%H%M%S)"

# Compress backup
find "$BACKUP_DIR" -name "*.bson" -exec gzip {} ;

# Remove old backups
find "$BACKUP_DIR" -type f -mtime +$RETENTION_DAYS -delete

# Keep only last N backups
ls -t "$BACKUP_DIR"/*.gz | tail -n +6 | xargs rm -f

// Growth monitoring query
db.getCollectionNames().forEach(function(coll) {
  var stats = db[coll].stats();
  var growthRate = (stats.size - stats.avgObjSize * stats.count) /
                   (1024 * 1024 * 1024); // GB
  if (growthRate > 1) { // Growing > 1GB
    print('Rapid growth in ' + coll + ': ' + growthRate.toFixed(2) + ' GB');
  }
});