pms_md 1.0.0 → 1.0.2

package/node-monitor/examples/MYSQL_SEQUELIZE_GUIDE.md

@@ -0,0 +1,321 @@
+# MySQL2 & Sequelize Monitoring Guide
+
+This guide shows you how to use the Node Monitor package with MySQL2 and Sequelize.
+
+## 📦 Installation
+
+```bash
+# Install the monitoring package
+npm install pms_md
+
+# Install MySQL2 (required)
+npm install mysql2
+
+# Install Sequelize (optional, if using ORM)
+npm install sequelize
+```
+
+---
+
+## 🔧 MySQL2 Setup
+
+### Option 1: MySQL2 Promise Pool (Recommended)
+
+```javascript
+const mysql = require('mysql2/promise');
+const NodeMonitor = require('pms_md');
+
+// Create MySQL2 connection pool
+const pool = mysql.createPool({
+  host: 'localhost',
+  user: 'root',
+  password: 'your-password',
+  database: 'your-database',
+  waitForConnections: true,
+  connectionLimit: 10,
+  queueLimit: 0
+});
+
+// Initialize monitor
+const monitor = new NodeMonitor({
+  app: {
+    name: 'My App',
+    version: '1.0.0'
+  }
+});
+
+// Register MySQL2 pool for monitoring
+monitor.registerDatabase('mysql', 'mysql2', pool);
+
+// Start monitoring
+monitor.start();
+```
+
+### Option 2: MySQL2 Callback-based Connection
+
+```javascript
+const mysql = require('mysql2');
+
+const connection = mysql.createConnection({
+  host: 'localhost',
+  user: 'root',
+  password: 'your-password',
+  database: 'your-database'
+});
+
+connection.connect();
+
+// Register for monitoring
+monitor.registerDatabase('mysql', 'mysql2', connection);
+```
+
+---
+
+## 🎯 Sequelize Setup
+
+### Basic Sequelize Configuration
+
+```javascript
+const { Sequelize } = require('sequelize');
+const NodeMonitor = require('pms_md');
+
+// Create Sequelize instance
+const sequelize = new Sequelize('database', 'username', 'password', {
+  host: 'localhost',
+  dialect: 'mysql', // or 'postgres', 'sqlite', 'mssql'
+  logging: false,
+  pool: {
+    max: 5,
+    min: 0,
+    acquire: 30000,
+    idle: 10000
+  }
+});
+
+// Initialize monitor
+const monitor = new NodeMonitor({
+  app: {
+    name: 'Sequelize App',
+    version: '1.0.0'
+  },
+  notifications: {
+    email: {
+      enabled: true,
+      host: 'smtp.gmail.com',
+      port: 587,
+      auth: {
+        user: 'your-email@gmail.com',
+        pass: 'your-app-password'
+      },
+      recipients: ['admin@example.com']
+    }
+  }
+});
+
+// Test connection and register
+async function setupDatabase() {
+  try {
+    await sequelize.authenticate();
+    console.log('Database connected successfully');
+    
+    // Register Sequelize instance for monitoring
+    monitor.registerDatabase('mydb', 'sequelize', sequelize);
+    
+    // Start monitoring
+    monitor.start();
+  } catch (error) {
+    console.error('Unable to connect to database:', error);
+  }
+}
+
+setupDatabase();
+```
+
+---
+
+## 🚀 Complete Express + Sequelize Example
+
+```javascript
+const express = require('express');
+const { Sequelize } = require('sequelize');
+const NodeMonitor = require('pms_md');
+
+// Initialize Sequelize
+const sequelize = new Sequelize('myapp', 'root', 'password', {
+  host: 'localhost',
+  dialect: 'mysql'
+});
+
+// Initialize Monitor
+const monitor = new NodeMonitor({
+  app: { name: 'My App', version: '1.0.0' }
+});
+
+const app = express();
+app.use(express.json());
+
+// Add monitoring middleware
+app.use(monitor.requestLogger());
+
+// Health check
+app.get('/health', monitor.healthCheckEndpoint());
+
+// Your routes
+app.get('/users', monitor.asyncHandler(async (req, res) => {
+  const [users] = await sequelize.query('SELECT * FROM users');
+  res.json(users);
+}));
+
+// Error handling
+app.use(monitor.notFoundHandler());
+app.use(monitor.errorMiddleware());
+
+// Start server
+async function start() {
+  await sequelize.authenticate();
+  monitor.registerDatabase('mysql', 'sequelize', sequelize);
+  
+  const server = app.listen(3000, () => {
+    console.log('Server running on port 3000');
+    monitor.start();
+    monitor.setupGracefulShutdown(server);
+  });
+}
+
+start();
+```
+
+---
+
+## 📊 Monitoring Features
+
+### Get Database Statistics
+
+```javascript
+// Get MySQL connection stats
+const stats = await monitor.getDatabaseStats('mysql');
+console.log(stats);
+// Output: { type: 'mysql', threadsConnected: 5 }
+
+// Get Sequelize stats
+const seqStats = await monitor.getDatabaseStats('mydb');
+console.log(seqStats);
+// Output: { 
+//   type: 'sequelize', 
+//   dialect: 'mysql',
+//   database: 'myapp',
+//   host: 'localhost',
+//   pool: { size: 5, available: 3, using: 2, waiting: 0 }
+// }
+```
+
+### Custom Health Checks
+
+```javascript
+// Add custom database health check
+monitor.registerHealthCheck('database', async () => {
+  try {
+    await sequelize.authenticate();
+    return true;
+  } catch {
+    return false;
+  }
+});
+
+// Check health status
+app.get('/health', monitor.healthCheckEndpoint());
+```
+
+### Monitor Connection Status
+
+```javascript
+// Get all database connection statuses
+const status = monitor.getStatus();
+console.log(status.databases);
+// Output: {
+//   mysql: { type: 'sequelize', connected: true, consecutiveFailures: 0 }
+// }
+```
+
+---
+
+## 🔔 Automatic Notifications
+
+The monitor will automatically send notifications when:
+
+- ✅ Database connection is lost
+- ✅ Database connection is restored
+- ✅ Connection check fails multiple times
+- ✅ Query timeout occurs
+
+Configure email notifications:
+
+```javascript
+const monitor = new NodeMonitor({
+  notifications: {
+    email: {
+      enabled: true,
+      host: 'smtp.gmail.com',
+      port: 587,
+      auth: {
+        user: 'your-email@gmail.com',
+        pass: 'your-app-password'
+      },
+      recipients: ['admin@example.com']
+    }
+  }
+});
+```
+
+---
+
+## 🛠️ Troubleshooting
+
+### Connection Issues
+
+```javascript
+// Test Sequelize connection
+try {
+  await sequelize.authenticate();
+  console.log('✅ Connection successful');
+} catch (error) {
+  console.error('❌ Connection failed:', error);
+}
+```
+
+### Check Monitor Logs
+
+```bash
+# View application logs
+cat logs/application-*.log
+
+# View error logs
+cat logs/error-*.log
+```
+
+---
+
+## 📚 Additional Resources
+
+- [Sequelize Documentation](https://sequelize.org/)
+- [MySQL2 Documentation](https://github.com/sidorares/node-mysql2)
+- [Node Monitor README](../README.md)
+- [Getting Started Guide](../GETTING_STARTED.md)
+
+---
+
+## 💡 Best Practices
+
+1. **Use Connection Pooling**: Always use connection pools in production
+2. **Set Timeouts**: Configure appropriate query timeouts
+3. **Monitor Regularly**: Check database health at regular intervals
+4. **Handle Errors**: Always wrap database queries in try-catch blocks
+5. **Graceful Shutdown**: Close database connections on app shutdown
+
+```javascript
+monitor.setupGracefulShutdown(server, async () => {
+  await sequelize.close();
+  console.log('Database connection closed');
+});
+```
+

package/node-monitor/examples/sequelize-mysql-example.js

@@ -0,0 +1,147 @@
+/**
+ * Example: Using Node Monitor with Sequelize and MySQL2
+ * 
+ * This example demonstrates how to integrate the monitoring package
+ * with Sequelize ORM and MySQL2 database.
+ */
+
+const express = require('express');
+const { Sequelize } = require('sequelize');
+const NodeMonitor = require('../src/index');
+
+// Initialize Sequelize with MySQL2
+const sequelize = new Sequelize('asset_tracking', 'root', 'password', {
+  host: 'localhost',
+  dialect: 'mysql',
+  logging: false, // Disable SQL logging
+  pool: {
+    max: 5,
+    min: 0,
+    acquire: 30000,
+    idle: 10000
+  }
+});
+
+// Initialize Node Monitor
+const monitor = new NodeMonitor({
+  app: {
+    name: 'Sequelize MySQL App',
+    version: '1.0.0',
+    environment: process.env.NODE_ENV || 'development'
+  },
+  notifications: {
+    email: {
+      enabled: true,
+      host: 'smtp.gmail.com',
+      port: 587,
+      auth: {
+        user: process.env.EMAIL_USER || 'your-email@gmail.com',
+        pass: process.env.EMAIL_PASS || 'your-app-password'
+      },
+      from: process.env.EMAIL_USER || 'your-email@gmail.com',
+      recipients: [process.env.EMAIL_RECIPIENTS || 'admin@example.com']
+    }
+  },
+  database: {
+    enabled: true,
+    queryTimeout: 5000
+  }
+});
+
+// Create Express app
+const app = express();
+app.use(express.json());
+
+// Add monitoring middleware
+app.use(monitor.requestLogger());
+
+// Health check endpoint
+app.get('/health', monitor.healthCheckEndpoint());
+
+// Dashboard endpoint
+app.get('/dashboard', monitor.dashboardEndpoint());
+
+// Example routes
+app.get('/', (req, res) => {
+  res.json({ 
+    message: 'Sequelize MySQL Monitoring Example',
+    status: 'running'
+  });
+});
+
+// Example database query endpoint
+app.get('/db-test', monitor.asyncHandler(async (req, res) => {
+  // Test database connection
+  await sequelize.authenticate();
+  
+  // Execute a simple query
+  const [results] = await sequelize.query('SELECT 1 + 1 AS result');
+  
+  res.json({
+    message: 'Database connection successful',
+    result: results
+  });
+}));
+
+// Get database stats
+app.get('/db-stats', monitor.asyncHandler(async (req, res) => {
+  const stats = await monitor.getDatabaseStats('mysql');
+  res.json(stats);
+}));
+
+// Error handling middleware (must be last)
+app.use(monitor.notFoundHandler());
+app.use(monitor.errorMiddleware());
+
+// Start server
+async function startServer() {
+  try {
+    // Test database connection
+    console.log('Testing database connection...');
+    await sequelize.authenticate();
+    console.log('✅ Database connection established successfully.');
+
+    // Register database for monitoring
+    monitor.registerDatabase('mysql', 'sequelize', sequelize);
+    console.log('✅ Database registered for monitoring.');
+
+    // Register custom health check for database
+    monitor.registerHealthCheck('database', async () => {
+      try {
+        await sequelize.authenticate();
+        return true;
+      } catch {
+        return false;
+      }
+    });
+
+    // Start the server
+    const PORT = process.env.PORT || 3000;
+    const server = app.listen(PORT, () => {
+      console.log(`\n🚀 Server running on http://localhost:${PORT}`);
+      console.log(`📊 Health check: http://localhost:${PORT}/health`);
+      console.log(`📈 Dashboard: http://localhost:${PORT}/dashboard`);
+      console.log(`🔍 DB Test: http://localhost:${PORT}/db-test`);
+      console.log(`📊 DB Stats: http://localhost:${PORT}/db-stats\n`);
+
+      // Start monitoring
+      monitor.start();
+      console.log('✅ Monitoring started\n');
+
+      // Setup graceful shutdown
+      monitor.setupGracefulShutdown(server, async () => {
+        console.log('Closing database connection...');
+        await sequelize.close();
+        console.log('Database connection closed.');
+      });
+    });
+
+  } catch (error) {
+    console.error('❌ Unable to start server:', error);
+    process.exit(1);
+  }
+}
+
+// Start the application
+startServer();
+

package/node-monitor/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@projectmd/node-monitor",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Comprehensive monitoring solution for Node.js applications with error tracking, health checks, and multi-channel notifications",
   "main": "src/index.js",
   "scripts": {
@@ -47,7 +47,8 @@
     "express": "^4.18.0 || ^5.0.0",
     "mongoose": "^7.0.0 || ^8.0.0",
     "pg": "^8.11.0",
-    "mysql2": "^3.6.0",
+    "mysql2": "^2.0.0 || ^3.0.0",
+    "sequelize": "^6.0.0",
     "ioredis": "^5.3.0"
   },
   "peerDependenciesMeta": {
@@ -63,6 +64,9 @@
     "mysql2": {
       "optional": true
     },
+    "sequelize": {
+      "optional": true
+    },
     "ioredis": {
       "optional": true
     }

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

@@ -104,18 +104,22 @@ class DbConnectionMonitor {
       case 'mongodb':
       case 'mongoose':
         return this.checkMongoConnection(connection);
-      
+
       case 'postgresql':
       case 'postgres':
       case 'pg':
         return this.checkPostgresConnection(connection, testQuery);
-      
+
       case 'mysql':
+      case 'mysql2':
         return this.checkMySqlConnection(connection, testQuery);
-      
+
+      case 'sequelize':
+        return this.checkSequelizeConnection(connection);
+
       case 'redis':
         return this.checkRedisConnection(connection);
-      
+
       default:
         throw new Error(`Unsupported database type: ${type}`);
     }
@@ -160,16 +164,48 @@ class DbConnectionMonitor {
   }
 
   /**
-   * Check MySQL connection
+   * Check MySQL/MySQL2 connection
    */
   async checkMySqlConnection(connection, testQuery = 'SELECT 1') {
     try {
-      const [rows] = await Promise.race([
-        connection.query(testQuery),
+      // Support for mysql2 pool or connection
+      if (connection.query) {
+        const result = await Promise.race([
+          connection.query(testQuery),
+          this.timeout(this.config.database.queryTimeout)
+        ]);
+        // mysql2 returns [rows, fields]
+        return Array.isArray(result) ? !!result[0] : !!result;
+      }
+
+      // Support for mysql2 promise pool
+      if (connection.execute) {
+        const [rows] = await Promise.race([
+          connection.execute(testQuery),
+          this.timeout(this.config.database.queryTimeout)
+        ]);
+        return !!rows;
+      }
+
+      return false;
+    } catch (error) {
+      this.logger.logWarning('mysql_check_failed', `MySQL connection check failed: ${error.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * Check Sequelize connection
+   */
+  async checkSequelizeConnection(connection) {
+    try {
+      await Promise.race([
+        connection.authenticate(),
         this.timeout(this.config.database.queryTimeout)
       ]);
-      return !!rows;
-    } catch {
+      return true;
+    } catch (error) {
+      this.logger.logWarning('sequelize_check_failed', `Sequelize connection check failed: ${error.message}`);
       return false;
     }
   }
@@ -275,18 +311,22 @@ class DbConnectionMonitor {
       case 'mongodb':
       case 'mongoose':
         return this.getMongoStats(connection);
-      
+
       case 'postgresql':
       case 'postgres':
       case 'pg':
         return this.getPostgresStats(connection);
-      
+
       case 'mysql':
+      case 'mysql2':
         return this.getMySqlStats(connection);
-      
+
+      case 'sequelize':
+        return this.getSequelizeStats(connection);
+
       case 'redis':
         return this.getRedisStats(connection);
-      
+
       default:
         return { type, status: 'unknown' };
     }
@@ -333,21 +373,63 @@ class DbConnectionMonitor {
   }
 
   /**
-   * Get MySQL statistics
+   * Get MySQL/MySQL2 statistics
    */
   async getMySqlStats(connection) {
     try {
-      const [rows] = await connection.query('SHOW STATUS LIKE "Threads_connected"');
-      
+      let rows;
+
+      // Try mysql2 format first
+      if (connection.query) {
+        const result = await connection.query('SHOW STATUS LIKE "Threads_connected"');
+        rows = Array.isArray(result) ? result[0] : result;
+      } else if (connection.execute) {
+        [rows] = await connection.execute('SHOW STATUS LIKE "Threads_connected"');
+      }
+
       return {
         type: 'mysql',
-        threadsConnected: rows[0]?.Value || 0
+        threadsConnected: rows?.[0]?.Value || 0
       };
     } catch (error) {
       return { type: 'mysql', error: error.message };
     }
   }
 
+  /**
+   * Get Sequelize statistics
+   */
+  async getSequelizeStats(connection) {
+    try {
+      // Get database dialect
+      const dialect = connection.getDialect();
+
+      // Get pool information if available
+      const poolInfo = connection.connectionManager?.pool
+        ? {
+            size: connection.connectionManager.pool.size || 0,
+            available: connection.connectionManager.pool.available || 0,
+            using: connection.connectionManager.pool.using || 0,
+            waiting: connection.connectionManager.pool.waiting || 0
+          }
+        : null;
+
+      // Get basic connection info
+      const dbName = connection.config?.database || 'unknown';
+      const host = connection.config?.host || 'unknown';
+
+      return {
+        type: 'sequelize',
+        dialect,
+        database: dbName,
+        host,
+        pool: poolInfo
+      };
+    } catch (error) {
+      return { type: 'sequelize', error: error.message };
+    }
+  }
+
   /**
    * Get Redis statistics
    */