pms_md 1.0.0

package/node-monitor/src/index.js

@@ -0,0 +1,300 @@
+/**
+ * Node Monitor - Main Entry Point
+ * Comprehensive monitoring solution for Node.js applications
+ */
+
+const MonitoringConfig = require('./config/monitoringConfig');
+const ErrorLogger = require('./logger/errorLogger');
+const NotificationManager = require('./notifiers/notificationManager');
+const ApiErrorMonitor = require('./monitors/apiErrorMonitor');
+const ServerHealthMonitor = require('./monitors/serverHealthMonitor');
+const SystemResourceMonitor = require('./monitors/systemResourceMonitor');
+const DbConnectionMonitor = require('./monitors/dbConnectionMonitor');
+
+class NodeMonitor {
+  constructor(userConfig = {}) {
+    // Initialize configuration
+    this.config = new MonitoringConfig(userConfig);
+    
+    // Initialize logger
+    this.logger = new ErrorLogger(this.config.getAll());
+    
+    // Initialize notification manager
+    this.notificationManager = new NotificationManager(this.config.getAll(), this.logger);
+    
+    // Initialize monitors
+    this.apiErrorMonitor = new ApiErrorMonitor(
+      this.config.getAll(),
+      this.logger,
+      this.notificationManager
+    );
+    
+    this.serverHealthMonitor = new ServerHealthMonitor(
+      this.config.getAll(),
+      this.logger,
+      this.notificationManager
+    );
+    
+    this.systemResourceMonitor = new SystemResourceMonitor(
+      this.config.getAll(),
+      this.logger,
+      this.notificationManager
+    );
+    
+    this.dbConnectionMonitor = new DbConnectionMonitor(
+      this.config.getAll(),
+      this.logger,
+      this.notificationManager
+    );
+
+    this.isStarted = false;
+    
+    this.logger.logInfo('Node Monitor initialized', {
+      app: this.config.get('app.name'),
+      version: this.config.get('app.version'),
+      environment: this.config.get('app.environment')
+    });
+  }
+
+  /**
+   * Start all monitoring services
+   */
+  start() {
+    if (this.isStarted) {
+      this.logger.logWarning('monitor_already_started', 'Monitor is already started');
+      return;
+    }
+
+    this.serverHealthMonitor.start();
+    this.systemResourceMonitor.start();
+    this.dbConnectionMonitor.start();
+
+    this.isStarted = true;
+    this.logger.logInfo('All monitoring services started');
+  }
+
+  /**
+   * Stop all monitoring services
+   */
+  stop() {
+    if (!this.isStarted) {
+      return;
+    }
+
+    this.serverHealthMonitor.stop();
+    this.systemResourceMonitor.stop();
+    this.dbConnectionMonitor.stop();
+
+    this.isStarted = false;
+    this.logger.logInfo('All monitoring services stopped');
+  }
+
+  /**
+   * Get Express error handling middleware
+   */
+  errorMiddleware() {
+    return this.apiErrorMonitor.middleware();
+  }
+
+  /**
+   * Get Express request logger middleware
+   */
+  requestLogger() {
+    return this.apiErrorMonitor.requestLogger();
+  }
+
+  /**
+   * Get 404 handler middleware
+   */
+  notFoundHandler() {
+    return this.apiErrorMonitor.notFoundHandler();
+  }
+
+  /**
+   * Get async error handler wrapper
+   */
+  asyncHandler(fn) {
+    return this.apiErrorMonitor.asyncHandler(fn);
+  }
+
+  /**
+   * Get health check endpoint handler
+   */
+  healthCheckEndpoint() {
+    return this.serverHealthMonitor.healthCheckEndpoint();
+  }
+
+  /**
+   * Get basic health info endpoint handler
+   */
+  healthInfoEndpoint() {
+    return this.serverHealthMonitor.healthInfoEndpoint();
+  }
+
+  /**
+   * Register a custom health check
+   */
+  registerHealthCheck(name, checkFunction) {
+    this.serverHealthMonitor.registerHealthCheck(name, checkFunction);
+  }
+
+  /**
+   * Register a database connection for monitoring
+   */
+  registerDatabase(name, type, connection, testQuery = null) {
+    this.dbConnectionMonitor.registerConnection(name, type, connection, testQuery);
+  }
+
+  /**
+   * Setup graceful shutdown handlers
+   */
+  setupGracefulShutdown(server) {
+    this.serverHealthMonitor.setupGracefulShutdown(server);
+  }
+
+  /**
+   * Get current monitoring status
+   */
+  getStatus() {
+    return {
+      isRunning: this.isStarted,
+      health: this.serverHealthMonitor.getStatus(),
+      system: this.systemResourceMonitor.getCurrentMetrics(),
+      databases: this.dbConnectionMonitor.getStatus(),
+      errors: this.apiErrorMonitor.getStats()
+    };
+  }
+
+  /**
+   * Get system information
+   */
+  getSystemInfo() {
+    return this.systemResourceMonitor.getSystemInfo();
+  }
+
+  /**
+   * Get metrics history
+   */
+  getMetricsHistory() {
+    return this.systemResourceMonitor.getMetricsHistory();
+  }
+
+  /**
+   * Get database statistics
+   */
+  async getDatabaseStats(name) {
+    return this.dbConnectionMonitor.getStats(name);
+  }
+
+  /**
+   * Send custom notification
+   */
+  async notify(level, subject, message, details = {}) {
+    switch (level.toLowerCase()) {
+      case 'critical':
+        return this.notificationManager.sendCritical(subject, message, details);
+      case 'warning':
+        return this.notificationManager.sendWarning(subject, message, details);
+      case 'info':
+        return this.notificationManager.sendInfo(subject, message, details);
+      case 'recovery':
+        return this.notificationManager.sendRecovery(subject, message, details);
+      default:
+        return this.notificationManager.sendInfo(subject, message, details);
+    }
+  }
+
+  /**
+   * Log custom error
+   */
+  logError(type, message, details = {}) {
+    return this.logger.logSystemError(type, message, details);
+  }
+
+  /**
+   * Log custom warning
+   */
+  logWarning(type, message, details = {}) {
+    return this.logger.logWarning(type, message, details);
+  }
+
+  /**
+   * Log custom info
+   */
+  logInfo(message, details = {}) {
+    return this.logger.logInfo(message, details);
+  }
+
+  /**
+   * Get Winston logger instance for custom logging
+   */
+  getLogger() {
+    return this.logger.getLogger();
+  }
+
+  /**
+   * Get configuration
+   */
+  getConfig() {
+    return this.config.getSanitized();
+  }
+
+  /**
+   * Update configuration at runtime
+   */
+  updateConfig(path, value) {
+    this.config.set(path, value);
+    this.logger.logInfo('Configuration updated', { path, value });
+  }
+
+  /**
+   * Create a monitoring dashboard endpoint (returns JSON data)
+   */
+  dashboardEndpoint() {
+    return async (req, res) => {
+      try {
+        const status = this.getStatus();
+        const systemInfo = this.getSystemInfo();
+        const metricsHistory = this.getMetricsHistory();
+
+        res.json({
+          status: 'ok',
+          timestamp: new Date().toISOString(),
+          application: {
+            name: this.config.get('app.name'),
+            version: this.config.get('app.version'),
+            environment: this.config.get('app.environment')
+          },
+          monitoring: status,
+          system: systemInfo,
+          metrics: metricsHistory
+        });
+      } catch (error) {
+        res.status(500).json({
+          status: 'error',
+          error: error.message
+        });
+      }
+    };
+  }
+
+  /**
+   * Static method to create error with status code
+   */
+  static createError(message, statusCode = 500, details = {}) {
+    return ApiErrorMonitor.createError(message, statusCode, details);
+  }
+}
+
+// Export the main class
+module.exports = NodeMonitor;
+
+// Also export individual components for advanced usage
+module.exports.MonitoringConfig = MonitoringConfig;
+module.exports.ErrorLogger = ErrorLogger;
+module.exports.NotificationManager = NotificationManager;
+module.exports.ApiErrorMonitor = ApiErrorMonitor;
+module.exports.ServerHealthMonitor = ServerHealthMonitor;
+module.exports.SystemResourceMonitor = SystemResourceMonitor;
+module.exports.DbConnectionMonitor = DbConnectionMonitor;
+

package/node-monitor/src/logger/errorLogger.js

@@ -0,0 +1,297 @@
+/**
+ * Error Logger Module
+ * Winston-based logging with rotation, formatting, and sanitization
+ */
+
+const winston = require('winston');
+const DailyRotateFile = require('winston-daily-rotate-file');
+const path = require('path');
+const fs = require('fs');
+
+class ErrorLogger {
+  constructor(config) {
+    this.config = config;
+    this.logger = null;
+    this.errorCounts = new Map(); // Track error frequency
+    this.initialize();
+  }
+
+  /**
+   * Initialize Winston logger
+   */
+  initialize() {
+    if (!this.config.logging.enabled) {
+      this.logger = this.createNoOpLogger();
+      return;
+    }
+
+    // Ensure log directory exists
+    if (!fs.existsSync(this.config.logging.directory)) {
+      fs.mkdirSync(this.config.logging.directory, { recursive: true });
+    }
+
+    const transports = [];
+
+    // Console transport
+    if (this.config.logging.console) {
+      transports.push(
+        new winston.transports.Console({
+          format: winston.format.combine(
+            winston.format.colorize(),
+            winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }),
+            winston.format.printf(this.consoleFormat.bind(this))
+          )
+        })
+      );
+    }
+
+    // File transport with rotation
+    transports.push(
+      new DailyRotateFile({
+        filename: path.join(this.config.logging.directory, 'application-%DATE%.log'),
+        datePattern: 'YYYY-MM-DD',
+        maxSize: this.config.logging.maxSize,
+        maxFiles: this.config.logging.maxFiles,
+        format: this.getFileFormat()
+      })
+    );
+
+    // Error-specific file transport
+    transports.push(
+      new DailyRotateFile({
+        filename: path.join(this.config.logging.directory, 'error-%DATE%.log'),
+        datePattern: 'YYYY-MM-DD',
+        level: 'error',
+        maxSize: this.config.logging.maxSize,
+        maxFiles: this.config.logging.maxFiles,
+        format: this.getFileFormat()
+      })
+    );
+
+    this.logger = winston.createLogger({
+      level: this.config.logging.level,
+      transports,
+      exitOnError: false
+    });
+  }
+
+  /**
+   * Get file format based on configuration
+   */
+  getFileFormat() {
+    if (this.config.logging.format === 'json') {
+      return winston.format.combine(
+        winston.format.timestamp(),
+        winston.format.errors({ stack: true }),
+        winston.format.json()
+      );
+    }
+
+    return winston.format.combine(
+      winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }),
+      winston.format.errors({ stack: true }),
+      winston.format.printf(this.simpleFormat.bind(this))
+    );
+  }
+
+  /**
+   * Console format
+   */
+  consoleFormat(info) {
+    const { timestamp, level, message, ...meta } = info;
+    let output = `${timestamp} [${level}]: ${message}`;
+    
+    if (Object.keys(meta).length > 0) {
+      output += `\n${JSON.stringify(meta, null, 2)}`;
+    }
+    
+    return output;
+  }
+
+  /**
+   * Simple text format
+   */
+  simpleFormat(info) {
+    const { timestamp, level, message, ...meta } = info;
+    let output = `${timestamp} [${level.toUpperCase()}]: ${message}`;
+    
+    if (Object.keys(meta).length > 0) {
+      output += ` | ${JSON.stringify(meta)}`;
+    }
+    
+    return output;
+  }
+
+  /**
+   * Create no-op logger when logging is disabled
+   */
+  createNoOpLogger() {
+    const noop = () => {};
+    return {
+      info: noop,
+      warn: noop,
+      error: noop,
+      debug: noop,
+      verbose: noop
+    };
+  }
+
+  /**
+   * Sanitize sensitive data from objects
+   */
+  sanitize(data) {
+    if (!this.config.errorTracking.sanitizeSensitiveData) {
+      return data;
+    }
+
+    if (typeof data !== 'object' || data === null) {
+      return data;
+    }
+
+    const sanitized = Array.isArray(data) ? [...data] : { ...data };
+    const sensitiveFields = this.config.errorTracking.sensitiveFields;
+
+    for (const key in sanitized) {
+      if (sensitiveFields.some(field => key.toLowerCase().includes(field.toLowerCase()))) {
+        sanitized[key] = '***REDACTED***';
+      } else if (typeof sanitized[key] === 'object' && sanitized[key] !== null) {
+        sanitized[key] = this.sanitize(sanitized[key]);
+      }
+    }
+
+    return sanitized;
+  }
+
+  /**
+   * Log API error
+   */
+  logApiError(error, req) {
+    const errorData = {
+      type: 'API_ERROR',
+      method: req.method,
+      url: req.originalUrl || req.url,
+      statusCode: error.statusCode || error.status || 500,
+      message: error.message,
+      stack: this.config.errorTracking.captureStackTrace ? error.stack : undefined,
+      headers: this.sanitize(req.headers),
+      query: this.sanitize(req.query),
+      body: this.sanitize(req.body),
+      ip: req.ip || req.connection?.remoteAddress,
+      userAgent: req.get('user-agent') || req.headers['user-agent'] || req.headers['User-Agent'] || 'Unknown',
+      timestamp: new Date().toISOString(),
+      app: this.config.app
+    };
+
+    this.logger.error('API Error', errorData);
+    this.trackErrorFrequency('api_error');
+    
+    return errorData;
+  }
+
+  /**
+   * Log system error
+   */
+  logSystemError(type, message, details = {}) {
+    const errorData = {
+      type: type.toUpperCase(),
+      message,
+      ...details,
+      timestamp: new Date().toISOString(),
+      app: this.config.app
+    };
+
+    this.logger.error(message, errorData);
+    this.trackErrorFrequency(type);
+    
+    return errorData;
+  }
+
+  /**
+   * Log warning
+   */
+  logWarning(type, message, details = {}) {
+    const warningData = {
+      type: type.toUpperCase(),
+      message,
+      ...details,
+      timestamp: new Date().toISOString(),
+      app: this.config.app
+    };
+
+    this.logger.warn(message, warningData);
+    
+    return warningData;
+  }
+
+  /**
+   * Log info
+   */
+  logInfo(message, details = {}) {
+    this.logger.info(message, {
+      ...details,
+      timestamp: new Date().toISOString(),
+      app: this.config.app
+    });
+  }
+
+  /**
+   * Track error frequency for rate detection
+   */
+  trackErrorFrequency(errorType) {
+    const now = Date.now();
+    const key = `${errorType}_${Math.floor(now / 60000)}`; // Per minute bucket
+    
+    const count = (this.errorCounts.get(key) || 0) + 1;
+    this.errorCounts.set(key, count);
+
+    // Clean old entries (older than 5 minutes)
+    const fiveMinutesAgo = Math.floor((now - 300000) / 60000);
+    for (const [k] of this.errorCounts) {
+      const timestamp = parseInt(k.split('_').pop());
+      if (timestamp < fiveMinutesAgo) {
+        this.errorCounts.delete(k);
+      }
+    }
+
+    return count;
+  }
+
+  /**
+   * Get error rate for a specific type
+   */
+  getErrorRate(errorType) {
+    const now = Date.now();
+    const currentMinute = Math.floor(now / 60000);
+    const key = `${errorType}_${currentMinute}`;
+    
+    return this.errorCounts.get(key) || 0;
+  }
+
+  /**
+   * Get total error count across all types
+   */
+  getTotalErrorRate() {
+    const now = Date.now();
+    const currentMinute = Math.floor(now / 60000);
+    let total = 0;
+
+    for (const [key, count] of this.errorCounts) {
+      const timestamp = parseInt(key.split('_').pop());
+      if (timestamp === currentMinute) {
+        total += count;
+      }
+    }
+
+    return total;
+  }
+
+  /**
+   * Get Winston logger instance for custom logging
+   */
+  getLogger() {
+    return this.logger;
+  }
+}
+
+module.exports = ErrorLogger;
+