pms_md 1.0.2 → 1.0.3

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

@@ -1,6 +1,7 @@
 /**
  * Database Connection Monitor
- * Monitors database connections for MongoDB, PostgreSQL, MySQL, and Redis
+ * Monitors database connections for MongoDB, PostgreSQL, MySQL, MSSQL, SQLite,
+ * MariaDB, Redis, CouchDB, Cassandra, and more
  */
 
 const cron = require('node-cron');
@@ -114,12 +115,41 @@ class DbConnectionMonitor {
       case 'mysql2':
         return this.checkMySqlConnection(connection, testQuery);
 
+      case 'mariadb':
+        return this.checkMariaDBConnection(connection, testQuery);
+
+      case 'mssql':
+      case 'sqlserver':
+      case 'tedious':
+        return this.checkMSSQLConnection(connection, testQuery);
+
+      case 'sqlite':
+      case 'sqlite3':
+        return this.checkSQLiteConnection(connection, testQuery);
+
       case 'sequelize':
         return this.checkSequelizeConnection(connection);
 
       case 'redis':
         return this.checkRedisConnection(connection);
 
+      case 'couchdb':
+      case 'nano':
+        return this.checkCouchDBConnection(connection);
+
+      case 'cassandra':
+        return this.checkCassandraConnection(connection);
+
+      case 'elasticsearch':
+      case 'elastic':
+        return this.checkElasticsearchConnection(connection);
+
+      case 'dynamodb':
+        return this.checkDynamoDBConnection(connection);
+
+      case 'neo4j':
+        return this.checkNeo4jConnection(connection);
+
       default:
         throw new Error(`Unsupported database type: ${type}`);
     }
@@ -225,6 +255,259 @@ class DbConnectionMonitor {
     }
   }
 
+  /**
+   * Check MariaDB connection
+   */
+  async checkMariaDBConnection(connection, testQuery = 'SELECT 1') {
+    try {
+      // MariaDB uses same interface as MySQL
+      if (connection.query) {
+        const result = await Promise.race([
+          connection.query(testQuery),
+          this.timeout(this.config.database.queryTimeout)
+        ]);
+        return Array.isArray(result) ? !!result[0] : !!result;
+      }
+
+      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('mariadb_check_failed', `MariaDB connection check failed: ${error.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * Check MSSQL connection
+   */
+  async checkMSSQLConnection(connection, testQuery = 'SELECT 1') {
+    try {
+      // For mssql package (ConnectionPool)
+      if (connection.connected !== undefined) {
+        if (!connection.connected) {
+          return false;
+        }
+      }
+
+      // Try to execute a query
+      if (connection.query) {
+        const result = await Promise.race([
+          connection.query(testQuery),
+          this.timeout(this.config.database.queryTimeout)
+        ]);
+        return !!result;
+      }
+
+      // For tedious connection
+      if (connection.request) {
+        const request = connection.request();
+        const result = await Promise.race([
+          request.query(testQuery),
+          this.timeout(this.config.database.queryTimeout)
+        ]);
+        return !!result;
+      }
+
+      return false;
+    } catch (error) {
+      this.logger.logWarning('mssql_check_failed', `MSSQL connection check failed: ${error.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * Check SQLite connection
+   */
+  async checkSQLiteConnection(connection, testQuery = 'SELECT 1') {
+    try {
+      // For sqlite3 package
+      if (connection.get) {
+        return new Promise((resolve) => {
+          const timeout = setTimeout(() => resolve(false), this.config.database.queryTimeout);
+
+          connection.get(testQuery, (err) => {
+            clearTimeout(timeout);
+            resolve(!err);
+          });
+        });
+      }
+
+      // For better-sqlite3 package
+      if (connection.prepare) {
+        const stmt = connection.prepare(testQuery);
+        const result = stmt.get();
+        return !!result || result === undefined;
+      }
+
+      return false;
+    } catch (error) {
+      this.logger.logWarning('sqlite_check_failed', `SQLite connection check failed: ${error.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * Check CouchDB connection
+   */
+  async checkCouchDBConnection(connection) {
+    try {
+      // For nano package
+      if (connection.db && connection.db.list) {
+        const result = await Promise.race([
+          connection.db.list(),
+          this.timeout(this.config.database.queryTimeout)
+        ]);
+        return !!result;
+      }
+
+      // For direct HTTP client
+      if (connection.info) {
+        const result = await Promise.race([
+          connection.info(),
+          this.timeout(this.config.database.queryTimeout)
+        ]);
+        return !!result;
+      }
+
+      return false;
+    } catch (error) {
+      this.logger.logWarning('couchdb_check_failed', `CouchDB connection check failed: ${error.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * Check Cassandra connection
+   */
+  async checkCassandraConnection(connection) {
+    try {
+      // For cassandra-driver package
+      if (connection.execute) {
+        const result = await Promise.race([
+          connection.execute('SELECT now() FROM system.local'),
+          this.timeout(this.config.database.queryTimeout)
+        ]);
+        return !!result;
+      }
+
+      // Check connection state
+      if (connection.getState) {
+        const state = connection.getState();
+        return state && state.getConnectedHosts && state.getConnectedHosts().length > 0;
+      }
+
+      return false;
+    } catch (error) {
+      this.logger.logWarning('cassandra_check_failed', `Cassandra connection check failed: ${error.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * Check Elasticsearch connection
+   */
+  async checkElasticsearchConnection(connection) {
+    try {
+      // For @elastic/elasticsearch package
+      if (connection.ping) {
+        const result = await Promise.race([
+          connection.ping(),
+          this.timeout(this.config.database.queryTimeout)
+        ]);
+        return !!result;
+      }
+
+      // Alternative: check cluster health
+      if (connection.cluster && connection.cluster.health) {
+        const result = await Promise.race([
+          connection.cluster.health(),
+          this.timeout(this.config.database.queryTimeout)
+        ]);
+        return !!result;
+      }
+
+      return false;
+    } catch (error) {
+      this.logger.logWarning('elasticsearch_check_failed', `Elasticsearch connection check failed: ${error.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * Check DynamoDB connection
+   */
+  async checkDynamoDBConnection(connection) {
+    try {
+      // For AWS SDK DynamoDB client
+      if (connection.listTables) {
+        const result = await Promise.race([
+          connection.listTables({ Limit: 1 }).promise(),
+          this.timeout(this.config.database.queryTimeout)
+        ]);
+        return !!result;
+      }
+
+      // For AWS SDK v3
+      if (connection.send) {
+        const { ListTablesCommand } = require('@aws-sdk/client-dynamodb');
+        const result = await Promise.race([
+          connection.send(new ListTablesCommand({ Limit: 1 })),
+          this.timeout(this.config.database.queryTimeout)
+        ]);
+        return !!result;
+      }
+
+      return false;
+    } catch (error) {
+      this.logger.logWarning('dynamodb_check_failed', `DynamoDB connection check failed: ${error.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * Check Neo4j connection
+   */
+  async checkNeo4jConnection(connection) {
+    try {
+      // For neo4j-driver package
+      if (connection.verifyConnectivity) {
+        await Promise.race([
+          connection.verifyConnectivity(),
+          this.timeout(this.config.database.queryTimeout)
+        ]);
+        return true;
+      }
+
+      // Alternative: run a simple query
+      if (connection.session) {
+        const session = connection.session();
+        try {
+          const result = await Promise.race([
+            session.run('RETURN 1'),
+            this.timeout(this.config.database.queryTimeout)
+          ]);
+          await session.close();
+          return !!result;
+        } catch (error) {
+          await session.close();
+          throw error;
+        }
+      }
+
+      return false;
+    } catch (error) {
+      this.logger.logWarning('neo4j_check_failed', `Neo4j connection check failed: ${error.message}`);
+      return false;
+    }
+  }
+
   /**
    * Handle connection status changes
    */
@@ -321,12 +604,41 @@ class DbConnectionMonitor {
       case 'mysql2':
         return this.getMySqlStats(connection);
 
+      case 'mariadb':
+        return this.getMariaDBStats(connection);
+
+      case 'mssql':
+      case 'sqlserver':
+      case 'tedious':
+        return this.getMSSQLStats(connection);
+
+      case 'sqlite':
+      case 'sqlite3':
+        return this.getSQLiteStats(connection);
+
       case 'sequelize':
         return this.getSequelizeStats(connection);
 
       case 'redis':
         return this.getRedisStats(connection);
 
+      case 'couchdb':
+      case 'nano':
+        return this.getCouchDBStats(connection);
+
+      case 'cassandra':
+        return this.getCassandraStats(connection);
+
+      case 'elasticsearch':
+      case 'elastic':
+        return this.getElasticsearchStats(connection);
+
+      case 'dynamodb':
+        return this.getDynamoDBStats(connection);
+
+      case 'neo4j':
+        return this.getNeo4jStats(connection);
+
       default:
         return { type, status: 'unknown' };
     }
@@ -438,14 +750,14 @@ class DbConnectionMonitor {
       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,
@@ -457,11 +769,231 @@ class DbConnectionMonitor {
     }
   }
 
+  /**
+   * Get MariaDB statistics
+   */
+  async getMariaDBStats(connection) {
+    try {
+      let rows;
+
+      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: 'mariadb',
+        threadsConnected: rows?.[0]?.Value || 0
+      };
+    } catch (error) {
+      return { type: 'mariadb', error: error.message };
+    }
+  }
+
+  /**
+   * Get MSSQL statistics
+   */
+  async getMSSQLStats(connection) {
+    try {
+      let result;
+
+      if (connection.query) {
+        result = await connection.query('SELECT @@VERSION as version, @@CONNECTIONS as connections');
+      } else if (connection.request) {
+        const request = connection.request();
+        result = await request.query('SELECT @@VERSION as version, @@CONNECTIONS as connections');
+      }
+
+      return {
+        type: 'mssql',
+        version: result?.recordset?.[0]?.version || 'unknown',
+        connections: result?.recordset?.[0]?.connections || 0,
+        connected: connection.connected || false
+      };
+    } catch (error) {
+      return { type: 'mssql', error: error.message };
+    }
+  }
+
+  /**
+   * Get SQLite statistics
+   */
+  async getSQLiteStats(connection) {
+    try {
+      let stats = { type: 'sqlite' };
+
+      // For sqlite3
+      if (connection.get) {
+        return new Promise((resolve) => {
+          connection.get('PRAGMA database_list', (err, row) => {
+            if (!err && row) {
+              stats.database = row.file || row.name;
+            }
+            resolve(stats);
+          });
+        });
+      }
+
+      // For better-sqlite3
+      if (connection.name) {
+        stats.database = connection.name;
+        stats.inTransaction = connection.inTransaction || false;
+      }
+
+      return stats;
+    } catch (error) {
+      return { type: 'sqlite', error: error.message };
+    }
+  }
+
+  /**
+   * Get CouchDB statistics
+   */
+  async getCouchDBStats(connection) {
+    try {
+      let info;
+
+      if (connection.db && connection.db.list) {
+        const databases = await connection.db.list();
+        info = { type: 'couchdb', databases: databases.length };
+      } else if (connection.info) {
+        const serverInfo = await connection.info();
+        info = {
+          type: 'couchdb',
+          version: serverInfo.version,
+          vendor: serverInfo.vendor?.name
+        };
+      }
+
+      return info || { type: 'couchdb' };
+    } catch (error) {
+      return { type: 'couchdb', error: error.message };
+    }
+  }
+
+  /**
+   * Get Cassandra statistics
+   */
+  async getCassandraStats(connection) {
+    try {
+      const stats = { type: 'cassandra' };
+
+      if (connection.getState) {
+        const state = connection.getState();
+        const hosts = state.getConnectedHosts();
+        stats.connectedHosts = hosts.length;
+        stats.hosts = hosts.map(h => h.address);
+      }
+
+      if (connection.metadata) {
+        stats.keyspaces = Object.keys(connection.metadata.keyspaces || {}).length;
+      }
+
+      return stats;
+    } catch (error) {
+      return { type: 'cassandra', error: error.message };
+    }
+  }
+
+  /**
+   * Get Elasticsearch statistics
+   */
+  async getElasticsearchStats(connection) {
+    try {
+      const stats = { type: 'elasticsearch' };
+
+      // Get cluster health
+      if (connection.cluster && connection.cluster.health) {
+        const health = await connection.cluster.health();
+        stats.clusterName = health.cluster_name;
+        stats.status = health.status;
+        stats.numberOfNodes = health.number_of_nodes;
+        stats.activeShards = health.active_shards;
+      }
+
+      // Get cluster info
+      if (connection.info) {
+        const info = await connection.info();
+        stats.version = info.version?.number;
+      }
+
+      return stats;
+    } catch (error) {
+      return { type: 'elasticsearch', error: error.message };
+    }
+  }
+
+  /**
+   * Get DynamoDB statistics
+   */
+  async getDynamoDBStats(connection) {
+    try {
+      const stats = { type: 'dynamodb' };
+
+      // For AWS SDK v2
+      if (connection.listTables) {
+        const result = await connection.listTables().promise();
+        stats.tableCount = result.TableNames?.length || 0;
+      }
+
+      // For AWS SDK v3
+      if (connection.send) {
+        const { ListTablesCommand } = require('@aws-sdk/client-dynamodb');
+        const result = await connection.send(new ListTablesCommand({}));
+        stats.tableCount = result.TableNames?.length || 0;
+      }
+
+      return stats;
+    } catch (error) {
+      return { type: 'dynamodb', error: error.message };
+    }
+  }
+
+  /**
+   * Get Neo4j statistics
+   */
+  async getNeo4jStats(connection) {
+    try {
+      const stats = { type: 'neo4j' };
+
+      // Get server info
+      if (connection.getServerInfo) {
+        const serverInfo = await connection.getServerInfo();
+        stats.version = serverInfo.version;
+        stats.address = serverInfo.address;
+      }
+
+      // Run a query to get database stats
+      if (connection.session) {
+        const session = connection.session();
+        try {
+          const result = await session.run('CALL dbms.components() YIELD name, versions, edition');
+          const record = result.records[0];
+          if (record) {
+            stats.name = record.get('name');
+            stats.versions = record.get('versions');
+            stats.edition = record.get('edition');
+          }
+          await session.close();
+        } catch (error) {
+          await session.close();
+          stats.queryError = error.message;
+        }
+      }
+
+      return stats;
+    } catch (error) {
+      return { type: 'neo4j', error: error.message };
+    }
+  }
+
   /**
    * Timeout helper
    */
   timeout(ms) {
-    return new Promise((_, reject) => 
+    return new Promise((_, reject) =>
       setTimeout(() => reject(new Error('Query timeout')), ms)
     );
   }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pms_md",
-  "version": "1.0.2",
-  "description": "Comprehensive monitoring solution for Node.js applications with error tracking, health checks, and multi-channel notifications",
+  "version": "1.0.3",
+  "description": "Comprehensive monitoring solution for Node.js applications with error tracking, health checks, multi-database support (MongoDB, PostgreSQL, MySQL, MSSQL, SQLite, Redis, Cassandra, Elasticsearch, DynamoDB, Neo4j, CouchDB), and multi-channel notifications",
   "main": "index.js",
   "scripts": {
     "test": "jest",
@@ -47,8 +47,19 @@
     "mongoose": "^7.0.0 || ^8.0.0",
     "pg": "^8.0.0",
     "mysql2": "^2.0.0 || ^3.0.0",
+    "mariadb": "^3.0.0",
+    "mssql": "^9.0.0 || ^10.0.0",
+    "tedious": "^15.0.0 || ^16.0.0",
+    "sqlite3": "^5.0.0",
+    "better-sqlite3": "^8.0.0 || ^9.0.0",
     "sequelize": "^6.0.0",
-    "ioredis": "^5.0.0"
+    "ioredis": "^5.0.0",
+    "nano": "^10.0.0",
+    "cassandra-driver": "^4.0.0",
+    "@elastic/elasticsearch": "^8.0.0",
+    "@aws-sdk/client-dynamodb": "^3.0.0",
+    "aws-sdk": "^2.0.0",
+    "neo4j-driver": "^5.0.0"
   },
   "peerDependenciesMeta": {
     "express": {
@@ -63,11 +74,44 @@
     "mysql2": {
       "optional": true
     },
+    "mariadb": {
+      "optional": true
+    },
+    "mssql": {
+      "optional": true
+    },
+    "tedious": {
+      "optional": true
+    },
+    "sqlite3": {
+      "optional": true
+    },
+    "better-sqlite3": {
+      "optional": true
+    },
     "sequelize": {
       "optional": true
     },
     "ioredis": {
       "optional": true
+    },
+    "nano": {
+      "optional": true
+    },
+    "cassandra-driver": {
+      "optional": true
+    },
+    "@elastic/elasticsearch": {
+      "optional": true
+    },
+    "@aws-sdk/client-dynamodb": {
+      "optional": true
+    },
+    "aws-sdk": {
+      "optional": true
+    },
+    "neo4j-driver": {
+      "optional": true
     }
   },
   "devDependencies": {