How to Monitor Your MongoDB Database with Vigilmon

MongoDB powers millions of applications worldwide — from small startups using MongoDB Atlas to large enterprises running self-hosted replica sets. Whether you're storing documents for a content platform or handling real-time data for an IoT application, database downtime or degradation can be catastrophic.

This guide shows you how to monitor your MongoDB database with Vigilmon, ensuring you know before your users do when something goes wrong.

What Can Go Wrong with MongoDB

MongoDB is robust, but these issues can and do occur in production:

• Connection failures: Your app can't reach the MongoDB server
• Replica set elections: Primary failover causing brief write unavailability
• Slow queries without indexes: Collection scans blocking other operations
• Oplog running out of space: Causing secondaries to fall off the replica set
• Atlas tier throttling: Free/shared tiers hitting operation limits
• Memory pressure: Working set exceeding RAM causing disk I/O spikes

Creating a MongoDB Health Check Endpoint

Node.js with Mongoose

const mongoose = require('mongoose');

app.get('/health/db', async (req, res) => {
  try {
    const start = Date.now();

    // Check connection state
    if (mongoose.connection.readyState !== 1) {
      return res.status(503).json({
        status: 'error',
        message: 'MongoDB not connected',
        readyState: mongoose.connection.readyState
      });
    }

    // Run a ping command
    await mongoose.connection.db.admin().ping();
    const latency = Date.now() - start;

    res.json({
      status: 'ok',
      latency_ms: latency,
      connection: 'connected'
    });
  } catch (err) {
    res.status(503).json({
      status: 'error',
      message: err.message
    });
  }
});

Python with PyMongo

from pymongo import MongoClient
from flask import Flask, jsonify
import time

app = Flask(__name__)
client = MongoClient(os.getenv('MONGODB_URI'))

@app.route('/health/db')
def database_health():
    try:
        start = time.time()
        client.admin.command('ping')
        latency_ms = (time.time() - start) * 1000

        return jsonify({
            'status': 'ok',
            'latency_ms': round(latency_ms, 2)
        })
    except Exception as e:
        return jsonify({
            'status': 'error',
            'message': str(e)
        }), 503

Go with official MongoDB driver

func healthHandler(client *mongo.Client) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
        defer cancel()

        start := time.Now()
        err := client.Ping(ctx, readpref.Primary())
        latency := time.Since(start).Milliseconds()

        if err != nil {
            w.WriteHeader(http.StatusServiceUnavailable)
            json.NewEncoder(w).Encode(map[string]interface{}{
                "status": "error",
                "message": err.Error(),
            })
            return
        }

        json.NewEncoder(w).Encode(map[string]interface{}{
            "status": "ok",
            "latency_ms": latency,
        })
    }
}

Monitoring MongoDB Atlas

If you're on MongoDB Atlas, you can also monitor the Atlas API endpoint directly:

1. Vigilmon TCP Monitor: Monitor port 27017 (or your Atlas connection port) to detect connection-level failures
2. HTTP Health Check: Use your application's health endpoint as described above
3. Atlas Metrics API: For advanced monitoring, wrap Atlas metrics in a health endpoint

// Monitor replica set state via Atlas API
app.get('/health/db/replicaset', async (req, res) => {
  try {
    const status = await mongoose.connection.db.admin().replSetGetStatus();
    const primary = status.members.find(m => m.stateStr === 'PRIMARY');
    const secondaries = status.members.filter(m => m.stateStr === 'SECONDARY');

    if (!primary) {
      return res.status(503).json({
        status: 'error',
        message: 'No primary elected',
        members: status.members.map(m => ({ name: m.name, state: m.stateStr }))
      });
    }

    res.json({
      status: 'ok',
      primary: primary.name,
      secondaries: secondaries.length,
      members: status.members.map(m => ({ name: m.name, state: m.stateStr }))
    });
  } catch (err) {
    res.status(503).json({ status: 'error', message: err.message });
  }
});

Setting Up Vigilmon Monitors

1. Sign up at vigilmon.online (free, no credit card)
2. Add Monitor → HTTP(S)
3. URL: https://yourapp.com/health/db
4. Check interval: 1 minute
5. Response validation: body contains "status":"ok"
6. Alert channels: Email (instant), optionally Slack or webhook

Advanced: Monitoring Slow Queries

MongoDB's slow query log can reveal performance issues before they become outages. Create an endpoint that checks recent slow queries:

app.get('/health/db/performance', async (req, res) => {
  const db = mongoose.connection.db;

  // Get current operation list (slow queries)
  const ops = await db.admin().command({ currentOp: true });
  const slowOps = ops.inprog.filter(op => op.secs_running > 5);

  if (slowOps.length > 0) {
    return res.status(503).json({
      status: 'degraded',
      slow_operations: slowOps.length,
      operations: slowOps.map(op => ({
        ns: op.ns,
        secs_running: op.secs_running,
        op: op.op
      }))
    });
  }

  res.json({ status: 'ok', slow_operations: 0 });
});

Summary

Monitoring MongoDB properly means checking more than just "is the port open." With Vigilmon + a proper health endpoint, you get:

• Connection monitoring: Know immediately when MongoDB is unreachable
• Performance tracking: Catch slow query degradation before users notice
• Replica set visibility: Monitor primary elections and secondary lag
• Multi-region support: Monitor from multiple locations to catch network partitions

Start monitoring your MongoDB database for free at vigilmon.online.