pms_md 1.0.0

package/node-monitor/src/monitors/apiErrorMonitor.js

@@ -0,0 +1,156 @@
+/**
+ * API Error Monitor
+ * Express/Fastify middleware for tracking API errors
+ */
+
+class ApiErrorMonitor {
+  constructor(config, logger, notificationManager) {
+    this.config = config;
+    this.logger = logger;
+    this.notificationManager = notificationManager;
+    this.errorThreshold = config.thresholds.errorRate;
+    this.lastAlertTime = 0;
+  }
+
+  /**
+   * Express middleware for error tracking
+   */
+  middleware() {
+    return (err, req, res, next) => {
+      // Log the error
+      const errorData = this.logger.logApiError(err, req);
+
+      // Check error rate and send alert if threshold exceeded
+      this.checkErrorRate();
+
+      // Send response if not already sent
+      if (!res.headersSent) {
+        const statusCode = err.statusCode || err.status || 500;
+        res.status(statusCode).json({
+          error: {
+            message: err.message || 'Internal Server Error',
+            statusCode: statusCode,
+            ...(this.config.app.environment === 'development' && { 
+              stack: err.stack 
+            })
+          }
+        });
+      }
+    };
+  }
+
+  /**
+   * Request logger middleware (tracks all requests)
+   */
+  requestLogger() {
+    return (req, res, next) => {
+      const startTime = Date.now();
+
+      // Capture response
+      const originalSend = res.send;
+      res.send = function(data) {
+        res.send = originalSend;
+        const responseTime = Date.now() - startTime;
+        
+        // Log slow requests
+        const threshold = this.config.thresholds.responseTime;
+        if (responseTime > threshold) {
+          this.logger.logWarning('slow_request', 'Slow API response detected', {
+            method: req.method,
+            url: req.originalUrl || req.url,
+            responseTime: `${responseTime}ms`,
+            threshold: `${threshold}ms`,
+            statusCode: res.statusCode
+          });
+        }
+
+        return res.send(data);
+      }.bind(this);
+
+      next();
+    };
+  }
+
+  /**
+   * 404 handler middleware
+   */
+  notFoundHandler() {
+    return (req, res, next) => {
+      this.logger.logWarning('not_found', '404 - Route not found', {
+        method: req.method,
+        url: req.originalUrl || req.url,
+        ip: req.ip || req.connection?.remoteAddress
+      });
+
+      res.status(404).json({
+        error: {
+          message: 'Route not found',
+          statusCode: 404,
+          path: req.originalUrl || req.url
+        }
+      });
+    };
+  }
+
+  /**
+   * Check error rate and send alert if threshold exceeded
+   */
+  async checkErrorRate() {
+    const currentRate = this.logger.getTotalErrorRate();
+    
+    if (currentRate >= this.errorThreshold) {
+      const now = Date.now();
+      const cooldown = this.config.notifications.cooldown;
+      
+      // Only send alert if cooldown period has passed
+      if (now - this.lastAlertTime >= cooldown) {
+        await this.notificationManager.sendWarning(
+          'High Error Rate Detected',
+          `Application is experiencing a high error rate: ${currentRate} errors per minute`,
+          {
+            errorRate: `${currentRate} errors/min`,
+            threshold: `${this.errorThreshold} errors/min`,
+            application: this.config.app.name,
+            environment: this.config.app.environment
+          }
+        );
+        
+        this.lastAlertTime = now;
+      }
+    }
+  }
+
+  /**
+   * Get error statistics
+   */
+  getStats() {
+    return {
+      currentErrorRate: this.logger.getTotalErrorRate(),
+      threshold: this.errorThreshold,
+      apiErrorRate: this.logger.getErrorRate('api_error')
+    };
+  }
+
+  /**
+   * Async error wrapper for route handlers
+   * Usage: app.get('/route', asyncHandler(async (req, res) => { ... }))
+   */
+  asyncHandler(fn) {
+    return (req, res, next) => {
+      Promise.resolve(fn(req, res, next)).catch(next);
+    };
+  }
+
+  /**
+   * Create error with status code
+   */
+  static createError(message, statusCode = 500, details = {}) {
+    const error = new Error(message);
+    error.statusCode = statusCode;
+    error.details = details;
+    return error;
+  }
+}
+
+module.exports = ApiErrorMonitor;
+

package/node-monitor/src/monitors/dbConnectionMonitor.js

@@ -0,0 +1,389 @@
+/**
+ * Database Connection Monitor
+ * Monitors database connections for MongoDB, PostgreSQL, MySQL, and Redis
+ */
+
+const cron = require('node-cron');
+
+class DbConnectionMonitor {
+  constructor(config, logger, notificationManager) {
+    this.config = config;
+    this.logger = logger;
+    this.notificationManager = notificationManager;
+    this.connections = new Map();
+    this.cronJob = null;
+    this.connectionStatus = new Map();
+    this.consecutiveFailures = new Map();
+  }
+
+  /**
+   * Start database monitoring
+   */
+  start() {
+    if (!this.config.database.enabled || this.connections.size === 0) {
+      return;
+    }
+
+    this.logger.logInfo('Database connection monitoring started');
+
+    // Schedule periodic checks
+    const intervalMinutes = Math.max(1, Math.floor(this.config.intervals.database / 60000));
+    const cronExpression = `*/${intervalMinutes} * * * *`;
+
+    this.cronJob = cron.schedule(cronExpression, async () => {
+      await this.checkAllConnections();
+    });
+
+    // Perform initial check
+    this.checkAllConnections();
+  }
+
+  /**
+   * Stop database monitoring
+   */
+  stop() {
+    if (this.cronJob) {
+      this.cronJob.stop();
+      this.logger.logInfo('Database connection monitoring stopped');
+    }
+  }
+
+  /**
+   * Register a database connection
+   */
+  registerConnection(name, type, connection, testQuery = null) {
+    this.connections.set(name, {
+      type,
+      connection,
+      testQuery
+    });
+
+    this.connectionStatus.set(name, true);
+    this.consecutiveFailures.set(name, 0);
+
+    this.logger.logInfo(`Registered database connection: ${name} (${type})`);
+  }
+
+  /**
+   * Check all database connections
+   */
+  async checkAllConnections() {
+    const results = {};
+
+    for (const [name, dbConfig] of this.connections) {
+      try {
+        const isConnected = await this.checkConnection(name, dbConfig);
+        results[name] = {
+          status: isConnected ? 'connected' : 'disconnected',
+          type: dbConfig.type
+        };
+
+        await this.handleConnectionStatus(name, isConnected, dbConfig.type);
+      } catch (error) {
+        results[name] = {
+          status: 'error',
+          type: dbConfig.type,
+          error: error.message
+        };
+
+        await this.handleConnectionStatus(name, false, dbConfig.type, error);
+      }
+    }
+
+    this.logger.logInfo('Database connection check completed', results);
+    return results;
+  }
+
+  /**
+   * Check individual database connection
+   */
+  async checkConnection(name, dbConfig) {
+    const { type, connection, testQuery } = dbConfig;
+
+    switch (type.toLowerCase()) {
+      case 'mongodb':
+      case 'mongoose':
+        return this.checkMongoConnection(connection);
+      
+      case 'postgresql':
+      case 'postgres':
+      case 'pg':
+        return this.checkPostgresConnection(connection, testQuery);
+      
+      case 'mysql':
+        return this.checkMySqlConnection(connection, testQuery);
+      
+      case 'redis':
+        return this.checkRedisConnection(connection);
+      
+      default:
+        throw new Error(`Unsupported database type: ${type}`);
+    }
+  }
+
+  /**
+   * Check MongoDB/Mongoose connection
+   */
+  async checkMongoConnection(connection) {
+    // For Mongoose
+    if (connection.readyState !== undefined) {
+      return connection.readyState === 1; // 1 = connected
+    }
+
+    // For native MongoDB driver
+    if (connection.topology) {
+      return connection.topology.isConnected();
+    }
+
+    // Try ping command
+    try {
+      await connection.db().admin().ping();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Check PostgreSQL connection
+   */
+  async checkPostgresConnection(connection, testQuery = 'SELECT 1') {
+    try {
+      const result = await Promise.race([
+        connection.query(testQuery),
+        this.timeout(this.config.database.queryTimeout)
+      ]);
+      return !!result;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Check MySQL connection
+   */
+  async checkMySqlConnection(connection, testQuery = 'SELECT 1') {
+    try {
+      const [rows] = await Promise.race([
+        connection.query(testQuery),
+        this.timeout(this.config.database.queryTimeout)
+      ]);
+      return !!rows;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Check Redis connection
+   */
+  async checkRedisConnection(connection) {
+    try {
+      const result = await Promise.race([
+        connection.ping(),
+        this.timeout(this.config.database.queryTimeout)
+      ]);
+      return result === 'PONG';
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Handle connection status changes
+   */
+  async handleConnectionStatus(name, isConnected, type, error = null) {
+    const previousStatus = this.connectionStatus.get(name);
+    this.connectionStatus.set(name, isConnected);
+
+    if (!isConnected) {
+      const failures = this.consecutiveFailures.get(name) + 1;
+      this.consecutiveFailures.set(name, failures);
+
+      // Send alert if threshold reached
+      if (failures >= this.config.thresholds.consecutiveFailures) {
+        if (previousStatus) {
+          // Status changed from connected to disconnected
+          await this.notificationManager.sendCritical(
+            'Database Connection Lost',
+            `Connection to ${name} (${type}) has been lost`,
+            {
+              database: name,
+              type: type,
+              consecutiveFailures: failures,
+              error: error?.message || 'Connection check failed'
+            }
+          );
+        }
+      }
+
+      this.logger.logSystemError('db_connection_failed', `Database connection check failed: ${name}`, {
+        database: name,
+        type: type,
+        consecutiveFailures: failures,
+        error: error?.message
+      });
+    } else {
+      const previousFailures = this.consecutiveFailures.get(name);
+      
+      // Recovery notification
+      if (!previousStatus && previousFailures >= this.config.thresholds.consecutiveFailures) {
+        await this.notificationManager.sendRecovery(
+          'Database Connection Restored',
+          `Connection to ${name} (${type}) has been restored`,
+          {
+            database: name,
+            type: type,
+            previousFailures: previousFailures
+          }
+        );
+      }
+
+      this.consecutiveFailures.set(name, 0);
+    }
+  }
+
+  /**
+   * Get connection status for all databases
+   */
+  getStatus() {
+    const status = {};
+
+    for (const [name, dbConfig] of this.connections) {
+      status[name] = {
+        type: dbConfig.type,
+        connected: this.connectionStatus.get(name),
+        consecutiveFailures: this.consecutiveFailures.get(name)
+      };
+    }
+
+    return status;
+  }
+
+  /**
+   * Get connection statistics
+   */
+  async getStats(name) {
+    const dbConfig = this.connections.get(name);
+    if (!dbConfig) {
+      throw new Error(`Database connection not found: ${name}`);
+    }
+
+    const { type, connection } = dbConfig;
+
+    switch (type.toLowerCase()) {
+      case 'mongodb':
+      case 'mongoose':
+        return this.getMongoStats(connection);
+      
+      case 'postgresql':
+      case 'postgres':
+      case 'pg':
+        return this.getPostgresStats(connection);
+      
+      case 'mysql':
+        return this.getMySqlStats(connection);
+      
+      case 'redis':
+        return this.getRedisStats(connection);
+      
+      default:
+        return { type, status: 'unknown' };
+    }
+  }
+
+  /**
+   * Get MongoDB statistics
+   */
+  async getMongoStats(connection) {
+    try {
+      const db = connection.db ? connection.db() : connection;
+      const stats = await db.stats();
+      
+      return {
+        type: 'mongodb',
+        collections: stats.collections,
+        dataSize: stats.dataSize,
+        indexes: stats.indexes,
+        indexSize: stats.indexSize
+      };
+    } catch (error) {
+      return { type: 'mongodb', error: error.message };
+    }
+  }
+
+  /**
+   * Get PostgreSQL statistics
+   */
+  async getPostgresStats(connection) {
+    try {
+      const result = await connection.query(`
+        SELECT count(*) as connections 
+        FROM pg_stat_activity 
+        WHERE datname = current_database()
+      `);
+      
+      return {
+        type: 'postgresql',
+        activeConnections: result.rows[0].connections
+      };
+    } catch (error) {
+      return { type: 'postgresql', error: error.message };
+    }
+  }
+
+  /**
+   * Get MySQL statistics
+   */
+  async getMySqlStats(connection) {
+    try {
+      const [rows] = await connection.query('SHOW STATUS LIKE "Threads_connected"');
+      
+      return {
+        type: 'mysql',
+        threadsConnected: rows[0]?.Value || 0
+      };
+    } catch (error) {
+      return { type: 'mysql', error: error.message };
+    }
+  }
+
+  /**
+   * Get Redis statistics
+   */
+  async getRedisStats(connection) {
+    try {
+      const info = await connection.info();
+      const lines = info.split('\r\n');
+      const stats = {};
+      
+      lines.forEach(line => {
+        const [key, value] = line.split(':');
+        if (key && value) {
+          stats[key] = value;
+        }
+      });
+      
+      return {
+        type: 'redis',
+        connectedClients: stats.connected_clients,
+        usedMemory: stats.used_memory_human,
+        uptime: stats.uptime_in_seconds
+      };
+    } catch (error) {
+      return { type: 'redis', error: error.message };
+    }
+  }
+
+  /**
+   * Timeout helper
+   */
+  timeout(ms) {
+    return new Promise((_, reject) => 
+      setTimeout(() => reject(new Error('Query timeout')), ms)
+    );
+  }
+}
+
+module.exports = DbConnectionMonitor;
+