@berthojoris/mcp-mysql-server 1.10.3 → 1.10.4

package/dist/tools/performanceTools.js

@@ -17,28 +17,28 @@ class PerformanceTools {
         try {
             const metrics = {};
             // Get query performance metrics
-            const perfQuery = `
-        SELECT
-          SUM(TIMER_WAIT) / 1000000000000 as total_execution_time_sec,
-          SUM(LOCK_TIME) / 1000000000000 as total_lock_time_sec,
-          SUM(ROWS_EXAMINED) as total_rows_examined,
-          SUM(ROWS_SENT) as total_rows_sent,
-          SUM(ROWS_AFFECTED) as total_rows_affected,
-          SUM(SELECT_FULL_JOIN) as full_table_scans,
-          SUM(NO_INDEX_USED) as queries_without_indexes,
-          SUM(NO_GOOD_INDEX_USED) as queries_with_bad_indexes,
-          COUNT(*) as total_queries
-        FROM performance_schema.events_statements_summary_global_by_event_name
-        WHERE EVENT_NAME LIKE 'statement/sql/%'
+            const perfQuery = `
+        SELECT
+          SUM(TIMER_WAIT) / 1000000000000 as total_execution_time_sec,
+          SUM(LOCK_TIME) / 1000000000000 as total_lock_time_sec,
+          SUM(ROWS_EXAMINED) as total_rows_examined,
+          SUM(ROWS_SENT) as total_rows_sent,
+          SUM(ROWS_AFFECTED) as total_rows_affected,
+          SUM(SELECT_FULL_JOIN) as full_table_scans,
+          SUM(NO_INDEX_USED) as queries_without_indexes,
+          SUM(NO_GOOD_INDEX_USED) as queries_with_bad_indexes,
+          COUNT(*) as total_queries
+        FROM performance_schema.events_statements_summary_global_by_event_name
+        WHERE EVENT_NAME LIKE 'statement/sql/%'
       `;
             const perfResult = await this.db.query(perfQuery);
             metrics.query_performance = perfResult[0] || {};
             // Get connection metrics
-            const connQuery = `
-        SHOW GLOBAL STATUS WHERE Variable_name IN (
-          'Threads_connected', 'Threads_running', 'Threads_created',
-          'Connections', 'Max_used_connections', 'Aborted_connects', 'Aborted_clients'
-        )
+            const connQuery = `
+        SHOW GLOBAL STATUS WHERE Variable_name IN (
+          'Threads_connected', 'Threads_running', 'Threads_created',
+          'Connections', 'Max_used_connections', 'Aborted_connects', 'Aborted_clients'
+        )
       `;
             const connResult = await this.db.query(connQuery);
             metrics.connections = {};
@@ -46,11 +46,11 @@ class PerformanceTools {
                 metrics.connections[row.Variable_name.toLowerCase()] = row.Value;
             }
             // Get table cache metrics
-            const cacheQuery = `
-        SHOW GLOBAL STATUS WHERE Variable_name IN (
-          'Open_tables', 'Opened_tables', 'Table_open_cache_hits',
-          'Table_open_cache_misses', 'Table_open_cache_overflows'
-        )
+            const cacheQuery = `
+        SHOW GLOBAL STATUS WHERE Variable_name IN (
+          'Open_tables', 'Opened_tables', 'Table_open_cache_hits',
+          'Table_open_cache_misses', 'Table_open_cache_overflows'
+        )
       `;
             const cacheResult = await this.db.query(cacheQuery);
             metrics.table_cache = {};
@@ -58,15 +58,15 @@ class PerformanceTools {
                 metrics.table_cache[row.Variable_name.toLowerCase()] = row.Value;
             }
             // Get InnoDB metrics
-            const innodbQuery = `
-        SHOW GLOBAL STATUS WHERE Variable_name LIKE 'Innodb_%'
-        AND Variable_name IN (
-          'Innodb_buffer_pool_reads', 'Innodb_buffer_pool_read_requests',
-          'Innodb_buffer_pool_pages_total', 'Innodb_buffer_pool_pages_free',
-          'Innodb_buffer_pool_pages_data', 'Innodb_buffer_pool_pages_dirty',
-          'Innodb_row_lock_waits', 'Innodb_row_lock_time', 'Innodb_rows_read',
-          'Innodb_rows_inserted', 'Innodb_rows_updated', 'Innodb_rows_deleted'
-        )
+            const innodbQuery = `
+        SHOW GLOBAL STATUS WHERE Variable_name LIKE 'Innodb_%'
+        AND Variable_name IN (
+          'Innodb_buffer_pool_reads', 'Innodb_buffer_pool_read_requests',
+          'Innodb_buffer_pool_pages_total', 'Innodb_buffer_pool_pages_free',
+          'Innodb_buffer_pool_pages_data', 'Innodb_buffer_pool_pages_dirty',
+          'Innodb_row_lock_waits', 'Innodb_row_lock_time', 'Innodb_rows_read',
+          'Innodb_rows_inserted', 'Innodb_rows_updated', 'Innodb_rows_deleted'
+        )
       `;
             const innodbResult = await this.db.query(innodbQuery);
             metrics.innodb = {};
@@ -74,14 +74,16 @@ class PerformanceTools {
                 metrics.innodb[row.Variable_name.toLowerCase()] = row.Value;
             }
             // Calculate buffer pool hit ratio
-            if (metrics.innodb.innodb_buffer_pool_read_requests && metrics.innodb.innodb_buffer_pool_reads) {
+            if (metrics.innodb.innodb_buffer_pool_read_requests &&
+                metrics.innodb.innodb_buffer_pool_reads) {
                 const requests = parseFloat(metrics.innodb.innodb_buffer_pool_read_requests);
                 const reads = parseFloat(metrics.innodb.innodb_buffer_pool_reads);
-                metrics.innodb.buffer_pool_hit_ratio = ((requests - reads) / requests * 100).toFixed(2) + '%';
+                metrics.innodb.buffer_pool_hit_ratio =
+                    (((requests - reads) / requests) * 100).toFixed(2) + "%";
             }
             // Get slow query metrics
-            const slowQuery = `
-        SHOW GLOBAL STATUS WHERE Variable_name IN ('Slow_queries', 'Questions')
+            const slowQuery = `
+        SHOW GLOBAL STATUS WHERE Variable_name IN ('Slow_queries', 'Questions')
       `;
             const slowResult = await this.db.query(slowQuery);
             metrics.slow_queries = {};
@@ -92,19 +94,18 @@ class PerformanceTools {
             if (metrics.slow_queries.questions && metrics.slow_queries.slow_queries) {
                 const total = parseFloat(metrics.slow_queries.questions);
                 const slow = parseFloat(metrics.slow_queries.slow_queries);
-                metrics.slow_queries.slow_query_percentage = ((slow / total) * 100).toFixed(4) + '%';
+                metrics.slow_queries.slow_query_percentage =
+                    ((slow / total) * 100).toFixed(4) + "%";
             }
             return {
-                status: 'success',
+                status: "success",
                 data: metrics,
-                queryLog: this.db.getFormattedQueryLogs(5)
             };
         }
         catch (error) {
             return {
-                status: 'error',
+                status: "error",
                 error: error.message,
-                queryLog: this.db.getFormattedQueryLogs(1)
             };
         }
     }
@@ -115,38 +116,39 @@ class PerformanceTools {
         try {
             const limit = params?.limit || 10;
             if (!Number.isInteger(limit) || limit <= 0 || limit > 100) {
-                return { status: 'error', error: 'Limit must be a positive integer between 1 and 100' };
-            }
-            const query = `
-        SELECT
-          DIGEST_TEXT as query_pattern,
-          COUNT_STAR as execution_count,
-          ROUND(AVG_TIMER_WAIT / 1000000000000, 6) as avg_execution_time_sec,
-          ROUND(MAX_TIMER_WAIT / 1000000000000, 6) as max_execution_time_sec,
-          ROUND(SUM_TIMER_WAIT / 1000000000000, 6) as total_execution_time_sec,
-          ROUND(SUM_LOCK_TIME / 1000000000000, 6) as total_lock_time_sec,
-          SUM_ROWS_EXAMINED as rows_examined,
-          SUM_ROWS_SENT as rows_sent,
-          SUM_ROWS_AFFECTED as rows_affected,
-          FIRST_SEEN,
-          LAST_SEEN
-        FROM performance_schema.events_statements_summary_by_digest
-        WHERE DIGEST_TEXT IS NOT NULL
-        ORDER BY SUM_TIMER_WAIT DESC
-        LIMIT ${limit}
+                return {
+                    status: "error",
+                    error: "Limit must be a positive integer between 1 and 100",
+                };
+            }
+            const query = `
+        SELECT
+          DIGEST_TEXT as query_pattern,
+          COUNT_STAR as execution_count,
+          ROUND(AVG_TIMER_WAIT / 1000000000000, 6) as avg_execution_time_sec,
+          ROUND(MAX_TIMER_WAIT / 1000000000000, 6) as max_execution_time_sec,
+          ROUND(SUM_TIMER_WAIT / 1000000000000, 6) as total_execution_time_sec,
+          ROUND(SUM_LOCK_TIME / 1000000000000, 6) as total_lock_time_sec,
+          SUM_ROWS_EXAMINED as rows_examined,
+          SUM_ROWS_SENT as rows_sent,
+          SUM_ROWS_AFFECTED as rows_affected,
+          FIRST_SEEN,
+          LAST_SEEN
+        FROM performance_schema.events_statements_summary_by_digest
+        WHERE DIGEST_TEXT IS NOT NULL
+        ORDER BY SUM_TIMER_WAIT DESC
+        LIMIT ${limit}
       `;
             const results = await this.db.query(query);
             return {
-                status: 'success',
+                status: "success",
                 data: results,
-                queryLog: this.db.getFormattedQueryLogs(1)
             };
         }
         catch (error) {
             return {
-                status: 'error',
+                status: "error",
                 error: error.message,
-                queryLog: this.db.getFormattedQueryLogs(1)
             };
         }
     }
@@ -157,36 +159,37 @@ class PerformanceTools {
         try {
             const limit = params?.limit || 10;
             if (!Number.isInteger(limit) || limit <= 0 || limit > 100) {
-                return { status: 'error', error: 'Limit must be a positive integer between 1 and 100' };
-            }
-            const query = `
-        SELECT
-          DIGEST_TEXT as query_pattern,
-          COUNT_STAR as execution_count,
-          ROUND(AVG_TIMER_WAIT / 1000000000000, 6) as avg_execution_time_sec,
-          ROUND(MAX_TIMER_WAIT / 1000000000000, 6) as max_execution_time_sec,
-          ROUND(SUM_TIMER_WAIT / 1000000000000, 6) as total_execution_time_sec,
-          SUM_ROWS_EXAMINED as rows_examined,
-          SUM_ROWS_SENT as rows_sent,
-          FIRST_SEEN,
-          LAST_SEEN
-        FROM performance_schema.events_statements_summary_by_digest
-        WHERE DIGEST_TEXT IS NOT NULL
-        ORDER BY COUNT_STAR DESC
-        LIMIT ${limit}
+                return {
+                    status: "error",
+                    error: "Limit must be a positive integer between 1 and 100",
+                };
+            }
+            const query = `
+        SELECT
+          DIGEST_TEXT as query_pattern,
+          COUNT_STAR as execution_count,
+          ROUND(AVG_TIMER_WAIT / 1000000000000, 6) as avg_execution_time_sec,
+          ROUND(MAX_TIMER_WAIT / 1000000000000, 6) as max_execution_time_sec,
+          ROUND(SUM_TIMER_WAIT / 1000000000000, 6) as total_execution_time_sec,
+          SUM_ROWS_EXAMINED as rows_examined,
+          SUM_ROWS_SENT as rows_sent,
+          FIRST_SEEN,
+          LAST_SEEN
+        FROM performance_schema.events_statements_summary_by_digest
+        WHERE DIGEST_TEXT IS NOT NULL
+        ORDER BY COUNT_STAR DESC
+        LIMIT ${limit}
       `;
             const results = await this.db.query(query);
             return {
-                status: 'success',
+                status: "success",
                 data: results,
-                queryLog: this.db.getFormattedQueryLogs(1)
             };
         }
         catch (error) {
             return {
-                status: 'error',
+                status: "error",
                 error: error.message,
-                queryLog: this.db.getFormattedQueryLogs(1)
             };
         }
     }
@@ -198,42 +201,46 @@ class PerformanceTools {
             const limit = params?.limit || 10;
             const thresholdSec = params?.threshold_seconds || 1;
             if (!Number.isInteger(limit) || limit <= 0 || limit > 100) {
-                return { status: 'error', error: 'Limit must be a positive integer between 1 and 100' };
+                return {
+                    status: "error",
+                    error: "Limit must be a positive integer between 1 and 100",
+                };
             }
-            if (typeof thresholdSec !== 'number' || thresholdSec <= 0) {
-                return { status: 'error', error: 'Threshold must be a positive number' };
+            if (typeof thresholdSec !== "number" || thresholdSec <= 0) {
+                return {
+                    status: "error",
+                    error: "Threshold must be a positive number",
+                };
             }
             const thresholdPico = thresholdSec * 1000000000000;
-            const query = `
-        SELECT
-          DIGEST_TEXT as query_pattern,
-          COUNT_STAR as execution_count,
-          ROUND(AVG_TIMER_WAIT / 1000000000000, 6) as avg_execution_time_sec,
-          ROUND(MAX_TIMER_WAIT / 1000000000000, 6) as max_execution_time_sec,
-          ROUND(SUM_TIMER_WAIT / 1000000000000, 6) as total_execution_time_sec,
-          ROUND(SUM_LOCK_TIME / 1000000000000, 6) as total_lock_time_sec,
-          SUM_ROWS_EXAMINED as rows_examined,
-          SUM_ROWS_SENT as rows_sent,
-          SUM_NO_INDEX_USED as no_index_used_count,
-          FIRST_SEEN,
-          LAST_SEEN
-        FROM performance_schema.events_statements_summary_by_digest
-        WHERE DIGEST_TEXT IS NOT NULL AND AVG_TIMER_WAIT > ${thresholdPico}
-        ORDER BY AVG_TIMER_WAIT DESC
-        LIMIT ${limit}
+            const query = `
+        SELECT
+          DIGEST_TEXT as query_pattern,
+          COUNT_STAR as execution_count,
+          ROUND(AVG_TIMER_WAIT / 1000000000000, 6) as avg_execution_time_sec,
+          ROUND(MAX_TIMER_WAIT / 1000000000000, 6) as max_execution_time_sec,
+          ROUND(SUM_TIMER_WAIT / 1000000000000, 6) as total_execution_time_sec,
+          ROUND(SUM_LOCK_TIME / 1000000000000, 6) as total_lock_time_sec,
+          SUM_ROWS_EXAMINED as rows_examined,
+          SUM_ROWS_SENT as rows_sent,
+          SUM_NO_INDEX_USED as no_index_used_count,
+          FIRST_SEEN,
+          LAST_SEEN
+        FROM performance_schema.events_statements_summary_by_digest
+        WHERE DIGEST_TEXT IS NOT NULL AND AVG_TIMER_WAIT > ${thresholdPico}
+        ORDER BY AVG_TIMER_WAIT DESC
+        LIMIT ${limit}
       `;
             const results = await this.db.query(query);
             return {
-                status: 'success',
+                status: "success",
                 data: results,
-                queryLog: this.db.getFormattedQueryLogs(1)
             };
         }
         catch (error) {
             return {
-                status: 'error',
+                status: "error",
                 error: error.message,
-                queryLog: this.db.getFormattedQueryLogs(1)
             };
         }
     }
@@ -245,23 +252,26 @@ class PerformanceTools {
             const limit = params?.limit || 20;
             const schema = params?.table_schema;
             if (!Number.isInteger(limit) || limit <= 0 || limit > 100) {
-                return { status: 'error', error: 'Limit must be a positive integer between 1 and 100' };
-            }
-            let query = `
-        SELECT
-          OBJECT_SCHEMA as table_schema,
-          OBJECT_NAME as table_name,
-          COUNT_READ as read_operations,
-          COUNT_WRITE as write_operations,
-          COUNT_FETCH as fetch_operations,
-          COUNT_INSERT as insert_operations,
-          COUNT_UPDATE as update_operations,
-          COUNT_DELETE as delete_operations,
-          ROUND(SUM_TIMER_READ / 1000000000000, 6) as total_read_time_sec,
-          ROUND(SUM_TIMER_WRITE / 1000000000000, 6) as total_write_time_sec,
-          ROUND(SUM_TIMER_FETCH / 1000000000000, 6) as total_fetch_time_sec
-        FROM performance_schema.table_io_waits_summary_by_table
-        WHERE OBJECT_SCHEMA NOT IN ('mysql', 'performance_schema', 'information_schema', 'sys')
+                return {
+                    status: "error",
+                    error: "Limit must be a positive integer between 1 and 100",
+                };
+            }
+            let query = `
+        SELECT
+          OBJECT_SCHEMA as table_schema,
+          OBJECT_NAME as table_name,
+          COUNT_READ as read_operations,
+          COUNT_WRITE as write_operations,
+          COUNT_FETCH as fetch_operations,
+          COUNT_INSERT as insert_operations,
+          COUNT_UPDATE as update_operations,
+          COUNT_DELETE as delete_operations,
+          ROUND(SUM_TIMER_READ / 1000000000000, 6) as total_read_time_sec,
+          ROUND(SUM_TIMER_WRITE / 1000000000000, 6) as total_write_time_sec,
+          ROUND(SUM_TIMER_FETCH / 1000000000000, 6) as total_fetch_time_sec
+        FROM performance_schema.table_io_waits_summary_by_table
+        WHERE OBJECT_SCHEMA NOT IN ('mysql', 'performance_schema', 'information_schema', 'sys')
       `;
             if (schema) {
                 query += ` AND OBJECT_SCHEMA = '${schema.replace(/'/g, "''")}'`;
@@ -269,16 +279,14 @@ class PerformanceTools {
             query += ` ORDER BY (COUNT_READ + COUNT_WRITE) DESC LIMIT ${limit}`;
             const results = await this.db.query(query);
             return {
-                status: 'success',
+                status: "success",
                 data: results,
-                queryLog: this.db.getFormattedQueryLogs(1)
             };
         }
         catch (error) {
             return {
-                status: 'error',
+                status: "error",
                 error: error.message,
-                queryLog: this.db.getFormattedQueryLogs(1)
             };
         }
     }
@@ -290,23 +298,26 @@ class PerformanceTools {
             const limit = params?.limit || 20;
             const schema = params?.table_schema;
             if (!Number.isInteger(limit) || limit <= 0 || limit > 100) {
-                return { status: 'error', error: 'Limit must be a positive integer between 1 and 100' };
-            }
-            let query = `
-        SELECT
-          OBJECT_SCHEMA as table_schema,
-          OBJECT_NAME as table_name,
-          INDEX_NAME as index_name,
-          COUNT_STAR as usage_count,
-          COUNT_READ as read_count,
-          COUNT_WRITE as write_count,
-          COUNT_FETCH as fetch_count,
-          COUNT_INSERT as insert_count,
-          COUNT_UPDATE as update_count,
-          COUNT_DELETE as delete_count
-        FROM performance_schema.table_io_waits_summary_by_index_usage
-        WHERE OBJECT_SCHEMA NOT IN ('mysql', 'performance_schema', 'information_schema', 'sys')
-        AND INDEX_NAME IS NOT NULL
+                return {
+                    status: "error",
+                    error: "Limit must be a positive integer between 1 and 100",
+                };
+            }
+            let query = `
+        SELECT
+          OBJECT_SCHEMA as table_schema,
+          OBJECT_NAME as table_name,
+          INDEX_NAME as index_name,
+          COUNT_STAR as usage_count,
+          COUNT_READ as read_count,
+          COUNT_WRITE as write_count,
+          COUNT_FETCH as fetch_count,
+          COUNT_INSERT as insert_count,
+          COUNT_UPDATE as update_count,
+          COUNT_DELETE as delete_count
+        FROM performance_schema.table_io_waits_summary_by_index_usage
+        WHERE OBJECT_SCHEMA NOT IN ('mysql', 'performance_schema', 'information_schema', 'sys')
+        AND INDEX_NAME IS NOT NULL
       `;
             if (schema) {
                 query += ` AND OBJECT_SCHEMA = '${schema.replace(/'/g, "''")}'`;
@@ -314,16 +325,14 @@ class PerformanceTools {
             query += ` ORDER BY COUNT_STAR DESC LIMIT ${limit}`;
             const results = await this.db.query(query);
             return {
-                status: 'success',
+                status: "success",
                 data: results,
-                queryLog: this.db.getFormattedQueryLogs(1)
             };
         }
         catch (error) {
             return {
-                status: 'error',
+                status: "error",
                 error: error.message,
-                queryLog: this.db.getFormattedQueryLogs(1)
             };
         }
     }
@@ -333,26 +342,26 @@ class PerformanceTools {
     async getUnusedIndexes(params) {
         try {
             const schema = params?.table_schema;
-            let query = `
-        SELECT
-          t.TABLE_SCHEMA as table_schema,
-          t.TABLE_NAME as table_name,
-          s.INDEX_NAME as index_name,
-          s.COLUMN_NAME as column_name,
-          s.SEQ_IN_INDEX as sequence_in_index,
-          s.NON_UNIQUE as is_non_unique
-        FROM information_schema.STATISTICS s
-        LEFT JOIN performance_schema.table_io_waits_summary_by_index_usage p
-          ON s.TABLE_SCHEMA = p.OBJECT_SCHEMA
-          AND s.TABLE_NAME = p.OBJECT_NAME
-          AND s.INDEX_NAME = p.INDEX_NAME
-        JOIN information_schema.TABLES t
-          ON s.TABLE_SCHEMA = t.TABLE_SCHEMA
-          AND s.TABLE_NAME = t.TABLE_NAME
-        WHERE s.TABLE_SCHEMA NOT IN ('mysql', 'performance_schema', 'information_schema', 'sys')
-          AND s.INDEX_NAME != 'PRIMARY'
-          AND (p.INDEX_NAME IS NULL OR p.COUNT_STAR = 0)
-          AND t.TABLE_TYPE = 'BASE TABLE'
+            let query = `
+        SELECT
+          t.TABLE_SCHEMA as table_schema,
+          t.TABLE_NAME as table_name,
+          s.INDEX_NAME as index_name,
+          s.COLUMN_NAME as column_name,
+          s.SEQ_IN_INDEX as sequence_in_index,
+          s.NON_UNIQUE as is_non_unique
+        FROM information_schema.STATISTICS s
+        LEFT JOIN performance_schema.table_io_waits_summary_by_index_usage p
+          ON s.TABLE_SCHEMA = p.OBJECT_SCHEMA
+          AND s.TABLE_NAME = p.OBJECT_NAME
+          AND s.INDEX_NAME = p.INDEX_NAME
+        JOIN information_schema.TABLES t
+          ON s.TABLE_SCHEMA = t.TABLE_SCHEMA
+          AND s.TABLE_NAME = t.TABLE_NAME
+        WHERE s.TABLE_SCHEMA NOT IN ('mysql', 'performance_schema', 'information_schema', 'sys')
+          AND s.INDEX_NAME != 'PRIMARY'
+          AND (p.INDEX_NAME IS NULL OR p.COUNT_STAR = 0)
+          AND t.TABLE_TYPE = 'BASE TABLE'
       `;
             if (schema) {
                 query += ` AND s.TABLE_SCHEMA = '${schema.replace(/'/g, "''")}'`;
@@ -360,16 +369,14 @@ class PerformanceTools {
             query += ` ORDER BY s.TABLE_SCHEMA, s.TABLE_NAME, s.INDEX_NAME, s.SEQ_IN_INDEX`;
             const results = await this.db.query(query);
             return {
-                status: 'success',
+                status: "success",
                 data: results,
-                queryLog: this.db.getFormattedQueryLogs(1)
             };
         }
         catch (error) {
             return {
-                status: 'error',
+                status: "error",
                 error: error.message,
-                queryLog: this.db.getFormattedQueryLogs(1)
             };
         }
     }
@@ -378,25 +385,25 @@ class PerformanceTools {
      */
     async getConnectionPoolStats() {
         try {
-            const statusQuery = `
-        SHOW GLOBAL STATUS WHERE Variable_name IN (
-          'Threads_connected', 'Threads_running', 'Threads_created', 'Threads_cached',
-          'Connections', 'Max_used_connections', 'Max_used_connections_time',
-          'Aborted_connects', 'Aborted_clients', 'Connection_errors_max_connections'
-        )
+            const statusQuery = `
+        SHOW GLOBAL STATUS WHERE Variable_name IN (
+          'Threads_connected', 'Threads_running', 'Threads_created', 'Threads_cached',
+          'Connections', 'Max_used_connections', 'Max_used_connections_time',
+          'Aborted_connects', 'Aborted_clients', 'Connection_errors_max_connections'
+        )
       `;
-            const variablesQuery = `
-        SHOW GLOBAL VARIABLES WHERE Variable_name IN (
-          'max_connections', 'thread_cache_size', 'connect_timeout',
-          'wait_timeout', 'interactive_timeout'
-        )
+            const variablesQuery = `
+        SHOW GLOBAL VARIABLES WHERE Variable_name IN (
+          'max_connections', 'thread_cache_size', 'connect_timeout',
+          'wait_timeout', 'interactive_timeout'
+        )
       `;
             const statusResult = await this.db.query(statusQuery);
             const variablesResult = await this.db.query(variablesQuery);
             const stats = {
                 current_status: {},
                 configuration: {},
-                health_indicators: {}
+                health_indicators: {},
             };
             for (const row of statusResult) {
                 stats.current_status[row.Variable_name.toLowerCase()] = row.Value;
@@ -405,36 +412,40 @@ class PerformanceTools {
                 stats.configuration[row.Variable_name.toLowerCase()] = row.Value;
             }
             // Calculate health indicators
-            const threadsConnected = parseInt(stats.current_status.threads_connected || '0');
-            const maxConnections = parseInt(stats.configuration.max_connections || '0');
-            const maxUsedConnections = parseInt(stats.current_status.max_used_connections || '0');
+            const threadsConnected = parseInt(stats.current_status.threads_connected || "0");
+            const maxConnections = parseInt(stats.configuration.max_connections || "0");
+            const maxUsedConnections = parseInt(stats.current_status.max_used_connections || "0");
             if (maxConnections > 0) {
-                stats.health_indicators.connection_usage_percentage = ((threadsConnected / maxConnections) * 100).toFixed(2) + '%';
-                stats.health_indicators.max_usage_percentage = ((maxUsedConnections / maxConnections) * 100).toFixed(2) + '%';
-                stats.health_indicators.available_connections = maxConnections - threadsConnected;
+                stats.health_indicators.connection_usage_percentage =
+                    ((threadsConnected / maxConnections) * 100).toFixed(2) + "%";
+                stats.health_indicators.max_usage_percentage =
+                    ((maxUsedConnections / maxConnections) * 100).toFixed(2) + "%";
+                stats.health_indicators.available_connections =
+                    maxConnections - threadsConnected;
             }
             // Connection efficiency
-            const totalConnections = parseInt(stats.current_status.connections || '0');
-            const abortedConnects = parseInt(stats.current_status.aborted_connects || '0');
+            const totalConnections = parseInt(stats.current_status.connections || "0");
+            const abortedConnects = parseInt(stats.current_status.aborted_connects || "0");
             if (totalConnections > 0) {
-                stats.health_indicators.aborted_connection_percentage = ((abortedConnects / totalConnections) * 100).toFixed(4) + '%';
+                stats.health_indicators.aborted_connection_percentage =
+                    ((abortedConnects / totalConnections) * 100).toFixed(4) + "%";
             }
             // Thread cache efficiency
-            const threadsCreated = parseInt(stats.current_status.threads_created || '0');
+            const threadsCreated = parseInt(stats.current_status.threads_created || "0");
             if (totalConnections > 0) {
-                stats.health_indicators.thread_cache_hit_rate = (((totalConnections - threadsCreated) / totalConnections) * 100).toFixed(2) + '%';
+                stats.health_indicators.thread_cache_hit_rate =
+                    (((totalConnections - threadsCreated) / totalConnections) *
+                        100).toFixed(2) + "%";
             }
             return {
-                status: 'success',
+                status: "success",
                 data: stats,
-                queryLog: this.db.getFormattedQueryLogs(2)
             };
         }
         catch (error) {
             return {
-                status: 'error',
+                status: "error",
                 error: error.message,
-                queryLog: this.db.getFormattedQueryLogs(1)
             };
         }
     }
@@ -444,14 +455,14 @@ class PerformanceTools {
     async getDatabaseHealthCheck() {
         try {
             const health = {
-                overall_status: 'healthy',
+                overall_status: "healthy",
                 checks: [],
                 warnings: [],
-                errors: []
+                errors: [],
             };
             // Check 1: Connection usage
-            const connQuery = `
-        SHOW GLOBAL STATUS WHERE Variable_name IN ('Threads_connected', 'Max_used_connections')
+            const connQuery = `
+        SHOW GLOBAL STATUS WHERE Variable_name IN ('Threads_connected', 'Max_used_connections')
       `;
             const maxConnQuery = `SHOW GLOBAL VARIABLES WHERE Variable_name = 'max_connections'`;
             const connResult = await this.db.query(connQuery);
@@ -460,9 +471,9 @@ class PerformanceTools {
             let maxUsedConnections = 0;
             let maxConnections = 0;
             for (const row of connResult) {
-                if (row.Variable_name === 'Threads_connected')
+                if (row.Variable_name === "Threads_connected")
                     threadsConnected = parseInt(row.Value);
-                if (row.Variable_name === 'Max_used_connections')
+                if (row.Variable_name === "Max_used_connections")
                     maxUsedConnections = parseInt(row.Value);
             }
             for (const row of maxConnResult) {
@@ -471,122 +482,124 @@ class PerformanceTools {
             const connUsage = (threadsConnected / maxConnections) * 100;
             const maxConnUsage = (maxUsedConnections / maxConnections) * 100;
             health.checks.push({
-                name: 'Connection Usage',
-                status: connUsage < 80 ? 'healthy' : connUsage < 90 ? 'warning' : 'critical',
+                name: "Connection Usage",
+                status: connUsage < 80 ? "healthy" : connUsage < 90 ? "warning" : "critical",
                 current: threadsConnected,
                 max: maxConnections,
-                usage_percentage: connUsage.toFixed(2) + '%'
+                usage_percentage: connUsage.toFixed(2) + "%",
             });
             if (connUsage >= 90) {
-                health.errors.push('Connection usage is critically high (>90%)');
-                health.overall_status = 'critical';
+                health.errors.push("Connection usage is critically high (>90%)");
+                health.overall_status = "critical";
             }
             else if (connUsage >= 80) {
-                health.warnings.push('Connection usage is high (>80%)');
-                if (health.overall_status === 'healthy')
-                    health.overall_status = 'warning';
+                health.warnings.push("Connection usage is high (>80%)");
+                if (health.overall_status === "healthy")
+                    health.overall_status = "warning";
             }
             // Check 2: Buffer pool hit ratio
-            const bufferQuery = `
-        SHOW GLOBAL STATUS WHERE Variable_name IN ('Innodb_buffer_pool_read_requests', 'Innodb_buffer_pool_reads')
+            const bufferQuery = `
+        SHOW GLOBAL STATUS WHERE Variable_name IN ('Innodb_buffer_pool_read_requests', 'Innodb_buffer_pool_reads')
       `;
             const bufferResult = await this.db.query(bufferQuery);
             let readRequests = 0;
             let reads = 0;
             for (const row of bufferResult) {
-                if (row.Variable_name === 'Innodb_buffer_pool_read_requests')
+                if (row.Variable_name === "Innodb_buffer_pool_read_requests")
                     readRequests = parseInt(row.Value);
-                if (row.Variable_name === 'Innodb_buffer_pool_reads')
+                if (row.Variable_name === "Innodb_buffer_pool_reads")
                     reads = parseInt(row.Value);
             }
             const hitRatio = readRequests > 0 ? ((readRequests - reads) / readRequests) * 100 : 100;
             health.checks.push({
-                name: 'Buffer Pool Hit Ratio',
-                status: hitRatio > 95 ? 'healthy' : hitRatio > 85 ? 'warning' : 'critical',
-                hit_ratio: hitRatio.toFixed(2) + '%'
+                name: "Buffer Pool Hit Ratio",
+                status: hitRatio > 95 ? "healthy" : hitRatio > 85 ? "warning" : "critical",
+                hit_ratio: hitRatio.toFixed(2) + "%",
             });
             if (hitRatio <= 85) {
-                health.errors.push('Buffer pool hit ratio is too low (<85%)');
-                health.overall_status = 'critical';
+                health.errors.push("Buffer pool hit ratio is too low (<85%)");
+                health.overall_status = "critical";
             }
             else if (hitRatio <= 95) {
-                health.warnings.push('Buffer pool hit ratio could be improved (<95%)');
-                if (health.overall_status === 'healthy')
-                    health.overall_status = 'warning';
+                health.warnings.push("Buffer pool hit ratio could be improved (<95%)");
+                if (health.overall_status === "healthy")
+                    health.overall_status = "warning";
             }
             // Check 3: Aborted connections
-            const abortQuery = `
-        SHOW GLOBAL STATUS WHERE Variable_name IN ('Connections', 'Aborted_connects')
+            const abortQuery = `
+        SHOW GLOBAL STATUS WHERE Variable_name IN ('Connections', 'Aborted_connects')
       `;
             const abortResult = await this.db.query(abortQuery);
             let totalConnections = 0;
             let abortedConnects = 0;
             for (const row of abortResult) {
-                if (row.Variable_name === 'Connections')
+                if (row.Variable_name === "Connections")
                     totalConnections = parseInt(row.Value);
-                if (row.Variable_name === 'Aborted_connects')
+                if (row.Variable_name === "Aborted_connects")
                     abortedConnects = parseInt(row.Value);
             }
             const abortRate = totalConnections > 0 ? (abortedConnects / totalConnections) * 100 : 0;
             health.checks.push({
-                name: 'Aborted Connections',
-                status: abortRate < 1 ? 'healthy' : abortRate < 5 ? 'warning' : 'critical',
+                name: "Aborted Connections",
+                status: abortRate < 1 ? "healthy" : abortRate < 5 ? "warning" : "critical",
                 aborted: abortedConnects,
                 total: totalConnections,
-                abort_rate: abortRate.toFixed(4) + '%'
+                abort_rate: abortRate.toFixed(4) + "%",
             });
             if (abortRate >= 5) {
-                health.errors.push('High rate of aborted connections (>5%)');
-                if (health.overall_status !== 'critical')
-                    health.overall_status = 'warning';
+                health.errors.push("High rate of aborted connections (>5%)");
+                if (health.overall_status !== "critical")
+                    health.overall_status = "warning";
             }
             else if (abortRate >= 1) {
-                health.warnings.push('Elevated rate of aborted connections (>1%)');
-                if (health.overall_status === 'healthy')
-                    health.overall_status = 'warning';
+                health.warnings.push("Elevated rate of aborted connections (>1%)");
+                if (health.overall_status === "healthy")
+                    health.overall_status = "warning";
             }
             // Check 4: Slow queries
-            const slowQuery = `
-        SHOW GLOBAL STATUS WHERE Variable_name IN ('Questions', 'Slow_queries')
+            const slowQuery = `
+        SHOW GLOBAL STATUS WHERE Variable_name IN ('Questions', 'Slow_queries')
       `;
             const slowResult = await this.db.query(slowQuery);
             let questions = 0;
             let slowQueries = 0;
             for (const row of slowResult) {
-                if (row.Variable_name === 'Questions')
+                if (row.Variable_name === "Questions")
                     questions = parseInt(row.Value);
-                if (row.Variable_name === 'Slow_queries')
+                if (row.Variable_name === "Slow_queries")
                     slowQueries = parseInt(row.Value);
             }
             const slowQueryRate = questions > 0 ? (slowQueries / questions) * 100 : 0;
             health.checks.push({
-                name: 'Slow Queries',
-                status: slowQueryRate < 1 ? 'healthy' : slowQueryRate < 5 ? 'warning' : 'critical',
+                name: "Slow Queries",
+                status: slowQueryRate < 1
+                    ? "healthy"
+                    : slowQueryRate < 5
+                        ? "warning"
+                        : "critical",
                 slow_queries: slowQueries,
                 total_queries: questions,
-                slow_query_rate: slowQueryRate.toFixed(4) + '%'
+                slow_query_rate: slowQueryRate.toFixed(4) + "%",
             });
             if (slowQueryRate >= 5) {
-                health.warnings.push('High rate of slow queries (>5%)');
-                if (health.overall_status === 'healthy')
-                    health.overall_status = 'warning';
+                health.warnings.push("High rate of slow queries (>5%)");
+                if (health.overall_status === "healthy")
+                    health.overall_status = "warning";
             }
             else if (slowQueryRate >= 1) {
-                health.warnings.push('Elevated rate of slow queries (>1%)');
-                if (health.overall_status === 'healthy')
-                    health.overall_status = 'warning';
+                health.warnings.push("Elevated rate of slow queries (>1%)");
+                if (health.overall_status === "healthy")
+                    health.overall_status = "warning";
             }
             return {
-                status: 'success',
+                status: "success",
                 data: health,
-                queryLog: this.db.getFormattedQueryLogs(6)
             };
         }
         catch (error) {
             return {
-                status: 'error',
+                status: "error",
                 error: error.message,
-                queryLog: this.db.getFormattedQueryLogs(1)
             };
         }
     }
@@ -597,25 +610,23 @@ class PerformanceTools {
         try {
             // Truncate performance schema summary tables
             const tables = [
-                'events_statements_summary_by_digest',
-                'events_statements_summary_global_by_event_name',
-                'table_io_waits_summary_by_table',
-                'table_io_waits_summary_by_index_usage'
+                "events_statements_summary_by_digest",
+                "events_statements_summary_global_by_event_name",
+                "table_io_waits_summary_by_table",
+                "table_io_waits_summary_by_index_usage",
             ];
             for (const table of tables) {
                 await this.db.query(`TRUNCATE TABLE performance_schema.${table}`);
             }
             return {
-                status: 'success',
-                message: 'Performance statistics reset successfully',
-                queryLog: this.db.getFormattedQueryLogs(tables.length)
+                status: "success",
+                message: "Performance statistics reset successfully",
             };
         }
         catch (error) {
             return {
-                status: 'error',
+                status: "error",
                 error: error.message,
-                queryLog: this.db.getFormattedQueryLogs(1)
             };
         }
     }