pms_md 1.0.0 → 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');
@@ -104,18 +105,51 @@ 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 '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}`);
     }
@@ -160,16 +194,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;
     }
   }
@@ -189,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
    */
@@ -275,18 +594,51 @@ 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 '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' };
     }
@@ -333,21 +685,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
    */
@@ -356,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,
@@ -375,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)
     );
   }