Logging Monitoring Failures in Adonisjs with Mongodb

AdonisJS, a Node.js web framework, relies on structured logging and explicit error handling to surface issues during request processing. When paired with MongoDB as the persistence layer, incomplete logging around database interactions can obscure the root cause of failures, leading to insufficient monitoring. Without clear correlation between application logs and MongoDB operation results, intermittent errors such as network timeouts, authentication failures, or schema mismatches may go unnoticed in production.

Specifically, if AdonisJS routes or controllers do not capture and log the full result or error from MongoDB operations—such as insertOne, find, or aggregate—operators lack visibility into whether queries returned empty results, wrote incorrect data, or were rejected due to permissions. This gap is pronounced when using unvalidated inputs that produce malformed queries or when connection strings are misconfigured, as the resulting exceptions may be caught by generic error handlers and recorded only as 500-level HTTP statuses without details.

Another dimension involves asynchronous operations and unhandled promise rejections. AdonisJS applications often use async/await with MongoDB drivers; if rejections are not explicitly caught and logged with stack traces and query context, monitoring systems receive incomplete signals. For example, a dropped network connection or an unreachable MongoDB instance may manifest as a generic timeout in logs, making it difficult to distinguish between application code bugs and infrastructure issues. This lack of granularity also hampers detection of slow operations, where queries exceed expected latency but do not trigger alerts due to missing duration logging.

Finally, schema validation and type coercion failures in Mongoose-like patterns or raw MongoDB drivers can produce silent failures if AdonisJS middleware does not log validation errors or transformation results. When incoming JSON payloads do not match expected document structures, the absence of detailed logs prevents rapid identification of malformed requests or insecure client data. Combined with insufficient rate-limiting visibility, this can mask abuse patterns or injection attempts that would otherwise be detectable through request and response logging correlated with MongoDB operation outcomes.

To strengthen logging and monitoring for MongoDB in AdonisJS, ensure every database interaction explicitly logs operation type, filter, result count, and errors with sufficient context. Use AdonisJS providers or middleware to wrap MongoDB calls so logs include request identifiers, user context (if authenticated), timestamps, and duration. Below are concrete code examples for common scenarios.

1. Logging raw MongoDB operations with request context

Wrap your MongoDB client calls to capture both success and error paths. This example uses the native MongoDB driver within an AdonisJS service class:

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

class UserRepository {
  constructor() {
    this.client = new MongoClient(process.env.MONGO_URI);
  }

  async getUserByEmail(email) {
    await this.client.connect();
    const db = this.client.db('appdb');
    const start = Date.now();
    try {
      const result = await db.collection('users').findOne({ email: email });
      const duration = Date.now() - start;
      console.info({
        level: 'info',
        message: 'MongoDB findOne success',
        collection: 'users',
        filter: { email },
        resultPresent: !!result,
        duration_ms: duration,
        requestId: 'req-123' // ideally from request context
      });
      return result;
    } catch (error) {
      const duration = Date.now() - start;
      console.error({
        level: 'error',
        message: 'MongoDB findOne failure',
        collection: 'users',
        filter: { email },
        error: error.message,
        code: error.code,
        duration_ms: duration,
        requestId: 'req-123'
      });
      throw error;
    } finally {
      await this.client.close();
    }
  }
}

module.exports = UserRepository;

2. Logging Mongoose-like validation errors in AdonisJS models

If using an ODM/ORM layer that resembles Mongoose patterns, ensure validation failures are logged with the invalid fields and values. Here is an example using a model hook:

const Model = use('Model');

class User extends Model {
  static boot() {
    super.boot();

    this.addHook('beforeSave', async (instance) => {
      // Simulate validation; in practice use AdonisJS validator or custom rules
      if (!instance.email || !instance.email.includes('@')) {
        const error = new Error('Invalid email');
        error.name = 'ValidationError';
        console.warn({
          level: 'warn',
          message: 'Validation failed beforeSave',
          model: 'User',
          invalidFields: { email: instance.email },
          error: error.message
        });
        throw error;
      }
    });
  }
}

module.exports = User;

3. Centralized error handling and logging in controllers

Use AdonisJS exception handlers to ensure MongoDB errors are logged with request metadata before returning responses:

const Logger = use('Logger');
const { ExceptionHandler } = require('@adonisjs/core/build/standalone')

class ExceptionHandler extends ExceptionHandler {
  report(error) {
    if (error.name === 'MongoNetworkError' || error.code === 112) {
      Logger.error({
        message: 'MongoDB network error',
        code: error.code,
        stack: error.stack,
        url: error.address,
        port: error.port
      });
    } else if (error.name === 'MongoServerError') {
      Logger.error({
        message: 'MongoDB server error',
        code: error.code,
        errmsg: error.errmsg,
        operation: error.operation,
        stack: error.stack
      });
    } else {
      super.report(error);
    }
  }
}

module.exports = ExceptionHandler;

4. Monitoring aggregation and slow operation logging

Log command durations and cursor batch sizes to detect performance regressions:

async function listUsers(page = 1, limit = 10) {
  await this.client.connect();
  const db = this.client.db('appdb');
  const skip = (page - 1) * limit;
  const start = Date.now();
  const cursor = db.collection('users').find({}, { projection: { password: 0 } }).skip(skip).limit(limit);
  const count = await cursor.count();
  const docs = await cursor.toArray();
  const duration = Date.now() - start;
  console.info({
    level: 'info',
    message: 'MongoDB aggregate list',
    collection: 'users',
    skip,
    limit,
    returned: docs.length,
    total: count,
    duration_ms: duration,
    slow: duration > 500
  });
  return docs;
}