noormme 1.0.0 → 1.0.2

package/dist/esm/performance/services/metrics-collector.js

@@ -0,0 +1,402 @@
+/// <reference types="./metrics-collector.d.ts" />
+import { Logger } from '../../logging/logger.js';
+/**
+ * Service for collecting and analyzing performance metrics
+ */
+export class MetricsCollector {
+    queryHistory = [];
+    warnings = [];
+    recentQueries = new Map();
+    config;
+    logger;
+    cleanupTimer;
+    constructor(config = {}, logger) {
+        this.logger = logger || new Logger('MetricsCollector');
+        this.config = {
+            enabled: process.env.NODE_ENV === 'development',
+            slowQueryThreshold: 1000, // 1 second
+            nPlusOneDetection: true,
+            missingIndexDetection: true,
+            largeResultSetThreshold: 1000,
+            maxHistorySize: 10000,
+            warningRetentionDays: 7,
+            ...config
+        };
+        this.startCleanupTimer();
+    }
+    /**
+     * Record a query execution
+     */
+    recordQuery(query, executionTime, options = {}) {
+        if (!this.config.enabled)
+            return;
+        const metrics = {
+            query: this.normalizeQuery(query),
+            executionTime,
+            timestamp: Date.now(),
+            table: options.table,
+            operation: options.operation,
+            resultCount: options.resultCount,
+            error: options.error
+        };
+        this.queryHistory.push(metrics);
+        // Keep history size under control
+        if (this.queryHistory.length > this.config.maxHistorySize) {
+            this.queryHistory = this.queryHistory.slice(-this.config.maxHistorySize);
+        }
+        // Track recent queries for pattern detection
+        this.trackRecentQuery(metrics);
+        // Analyze for warnings
+        this.analyzeQuery(metrics);
+    }
+    /**
+     * Get performance statistics
+     */
+    getPerformanceStats() {
+        const totalQueries = this.queryHistory.length;
+        const slowQueries = this.queryHistory.filter(q => q.executionTime > this.config.slowQueryThreshold).length;
+        const averageExecutionTime = totalQueries > 0
+            ? this.queryHistory.reduce((sum, q) => sum + q.executionTime, 0) / totalQueries
+            : 0;
+        const errorRate = totalQueries > 0
+            ? this.queryHistory.filter(q => q.error).length / totalQueries
+            : 0;
+        const warningCount = {};
+        for (const warning of this.warnings) {
+            warningCount[warning.type] = (warningCount[warning.type] || 0) + 1;
+        }
+        const topSlowQueries = this.getTopSlowQueries();
+        const queryPatterns = this.getQueryPatterns();
+        return {
+            totalQueries,
+            averageExecutionTime,
+            slowQueries,
+            errorRate,
+            warningCount,
+            topSlowQueries,
+            queryPatterns
+        };
+    }
+    /**
+     * Get recent warnings
+     */
+    getRecentWarnings(limit = 50) {
+        return this.warnings
+            .sort((a, b) => b.timestamp - a.timestamp)
+            .slice(0, limit);
+    }
+    /**
+     * Get warnings by type
+     */
+    getWarningsByType(type) {
+        return this.warnings.filter(w => w.type === type);
+    }
+    /**
+     * Get query history
+     */
+    getQueryHistory(limit) {
+        const history = this.queryHistory
+            .sort((a, b) => b.timestamp - a.timestamp);
+        return limit ? history.slice(0, limit) : history;
+    }
+    /**
+     * Get slow queries
+     */
+    getSlowQueries(threshold) {
+        const actualThreshold = threshold || this.config.slowQueryThreshold;
+        return this.queryHistory
+            .filter(q => q.executionTime > actualThreshold)
+            .sort((a, b) => b.executionTime - a.executionTime);
+    }
+    /**
+     * Get N+1 query patterns
+     */
+    getNPlusOnePatterns() {
+        const patterns = new Map();
+        // Group queries by normalized pattern
+        for (const query of this.queryHistory) {
+            if (!patterns.has(query.query)) {
+                patterns.set(query.query, []);
+            }
+            patterns.get(query.query).push(query);
+        }
+        const nPlusOnePatterns = [];
+        // Analyze each pattern for N+1 behavior
+        for (const [pattern, queries] of patterns.entries()) {
+            if (queries.length < 5)
+                continue;
+            const timeWindows = [5000, 10000, 30000]; // 5s, 10s, 30s
+            for (const windowMs of timeWindows) {
+                let maxCountInWindow = 0;
+                for (const query of queries) {
+                    const windowStart = query.timestamp - windowMs;
+                    const countInWindow = queries.filter(q => q.timestamp >= windowStart && q.timestamp <= query.timestamp).length;
+                    maxCountInWindow = Math.max(maxCountInWindow, countInWindow);
+                }
+                if (maxCountInWindow >= 5) {
+                    let severity = 'low';
+                    if (maxCountInWindow >= 20)
+                        severity = 'high';
+                    else if (maxCountInWindow >= 10)
+                        severity = 'medium';
+                    nPlusOnePatterns.push({
+                        pattern,
+                        count: maxCountInWindow,
+                        timeWindow: windowMs,
+                        severity
+                    });
+                    break;
+                }
+            }
+        }
+        return nPlusOnePatterns.sort((a, b) => b.count - a.count);
+    }
+    /**
+     * Clear all metrics
+     */
+    clear() {
+        this.queryHistory = [];
+        this.warnings = [];
+        this.recentQueries.clear();
+        this.logger.info('Metrics cleared');
+    }
+    /**
+     * Export metrics data
+     */
+    exportMetrics() {
+        return {
+            config: this.config,
+            stats: this.getPerformanceStats(),
+            warnings: this.warnings,
+            queries: this.queryHistory
+        };
+    }
+    /**
+     * Shutdown metrics collector
+     */
+    shutdown() {
+        if (this.cleanupTimer) {
+            clearInterval(this.cleanupTimer);
+        }
+        this.logger.info('Metrics collector shutdown');
+    }
+    /**
+     * Track recent query for pattern detection
+     */
+    trackRecentQuery(metrics) {
+        const normalizedQuery = metrics.query;
+        if (!this.recentQueries.has(normalizedQuery)) {
+            this.recentQueries.set(normalizedQuery, []);
+        }
+        this.recentQueries.get(normalizedQuery).push(metrics);
+        // Clean up old recent queries (keep last 10 seconds)
+        const cutoff = Date.now() - 10000;
+        for (const [query, queries] of this.recentQueries.entries()) {
+            const recent = queries.filter(q => q.timestamp >= cutoff);
+            if (recent.length === 0) {
+                this.recentQueries.delete(query);
+            }
+            else {
+                this.recentQueries.set(query, recent);
+            }
+        }
+    }
+    /**
+     * Analyze query for performance issues
+     */
+    analyzeQuery(metrics) {
+        const warnings = [];
+        // Check for slow queries
+        if (metrics.executionTime > this.config.slowQueryThreshold) {
+            warnings.push({
+                type: 'slow_query',
+                message: `Slow query detected: ${metrics.executionTime}ms`,
+                suggestion: 'Consider adding indexes or optimizing the query',
+                query: metrics.query,
+                table: metrics.table,
+                severity: metrics.executionTime > this.config.slowQueryThreshold * 3 ? 'high' : 'medium',
+                timestamp: Date.now()
+            });
+        }
+        // Check for N+1 queries
+        if (this.config.nPlusOneDetection) {
+            const nPlusOneWarning = this.detectNPlusOne(metrics);
+            if (nPlusOneWarning) {
+                warnings.push(nPlusOneWarning);
+            }
+        }
+        // Check for large result sets
+        if (metrics.resultCount && metrics.resultCount > this.config.largeResultSetThreshold) {
+            warnings.push({
+                type: 'large_result_set',
+                message: `Large result set: ${metrics.resultCount} rows returned`,
+                suggestion: 'Consider using pagination or filtering to reduce result size',
+                query: metrics.query,
+                table: metrics.table,
+                severity: metrics.resultCount > this.config.largeResultSetThreshold * 5 ? 'high' : 'medium',
+                timestamp: Date.now()
+            });
+        }
+        // Log warnings
+        for (const warning of warnings) {
+            this.addWarning(warning);
+        }
+    }
+    /**
+     * Detect N+1 query patterns
+     */
+    detectNPlusOne(metrics) {
+        const recentQueries = this.recentQueries.get(metrics.query) || [];
+        // Look for the same query executed multiple times in quick succession
+        if (recentQueries.length >= 5) {
+            const timeWindow = 5000; // 5 seconds
+            const recentInWindow = recentQueries.filter(q => Date.now() - q.timestamp < timeWindow);
+            if (recentInWindow.length >= 5) {
+                return {
+                    type: 'n_plus_one',
+                    message: `Potential N+1 query detected: same query executed ${recentInWindow.length} times`,
+                    suggestion: 'Consider using joins or batch loading to reduce query count',
+                    query: metrics.query,
+                    table: metrics.table,
+                    severity: 'high',
+                    timestamp: Date.now()
+                };
+            }
+        }
+        return null;
+    }
+    /**
+     * Add warning to collection
+     */
+    addWarning(warning) {
+        this.warnings.push(warning);
+        this.logWarning(warning);
+    }
+    /**
+     * Log performance warning
+     */
+    logWarning(warning) {
+        const emoji = this.getWarningEmoji(warning.type);
+        const message = `${emoji} Performance Warning [${warning.severity.toUpperCase()}]: ${warning.message}`;
+        switch (warning.severity) {
+            case 'high':
+                this.logger.warn(message);
+                break;
+            case 'medium':
+                this.logger.info(message);
+                break;
+            case 'low':
+                this.logger.debug(message);
+                break;
+        }
+        this.logger.debug(`  Suggestion: ${warning.suggestion}`);
+        if (warning.query) {
+            this.logger.debug(`  Query: ${warning.query}`);
+        }
+    }
+    /**
+     * Get emoji for warning type
+     */
+    getWarningEmoji(type) {
+        const emojis = {
+            'n_plus_one': '🔄',
+            'missing_index': '📇',
+            'slow_query': '🐌',
+            'full_table_scan': '🔍',
+            'large_result_set': '📊'
+        };
+        return emojis[type] || '⚠️';
+    }
+    /**
+     * Normalize query for comparison
+     */
+    normalizeQuery(query) {
+        return query
+            .replace(/\$\d+/g, '?') // Replace PostgreSQL parameters
+            .replace(/'[^']*'/g, '?') // Replace string literals
+            .replace(/\b\d+\b/g, '?') // Replace numbers
+            .replace(/\s+/g, ' ') // Normalize whitespace
+            .trim();
+    }
+    /**
+     * Get top slow queries
+     */
+    getTopSlowQueries() {
+        const queryMap = new Map();
+        for (const metrics of this.queryHistory) {
+            if (metrics.executionTime > this.config.slowQueryThreshold) {
+                if (!queryMap.has(metrics.query)) {
+                    queryMap.set(metrics.query, { totalTime: 0, count: 0 });
+                }
+                const entry = queryMap.get(metrics.query);
+                entry.totalTime += metrics.executionTime;
+                entry.count++;
+            }
+        }
+        return Array.from(queryMap.entries())
+            .map(([query, { totalTime, count }]) => ({
+            query,
+            averageTime: totalTime / count,
+            count
+        }))
+            .sort((a, b) => b.averageTime - a.averageTime)
+            .slice(0, 10);
+    }
+    /**
+     * Get query patterns
+     */
+    getQueryPatterns() {
+        const patternMap = new Map();
+        for (const metrics of this.queryHistory) {
+            if (!patternMap.has(metrics.query)) {
+                patternMap.set(metrics.query, { totalTime: 0, count: 0 });
+            }
+            const entry = patternMap.get(metrics.query);
+            entry.totalTime += metrics.executionTime;
+            entry.count++;
+        }
+        return Array.from(patternMap.entries())
+            .map(([pattern, { totalTime, count }]) => ({
+            pattern,
+            frequency: count,
+            averageTime: totalTime / count
+        }))
+            .sort((a, b) => b.frequency - a.frequency)
+            .slice(0, 20);
+    }
+    /**
+     * Start cleanup timer
+     */
+    startCleanupTimer() {
+        this.cleanupTimer = setInterval(() => {
+            this.cleanup();
+        }, 60000); // Cleanup every minute
+    }
+    /**
+     * Cleanup old data
+     */
+    cleanup() {
+        const cutoffTime = Date.now() - (this.config.warningRetentionDays * 24 * 60 * 60 * 1000);
+        // Remove old warnings
+        this.warnings = this.warnings.filter(w => w.timestamp > cutoffTime);
+        // Remove old queries (keep last 24 hours)
+        const queryCutoff = Date.now() - (24 * 60 * 60 * 1000);
+        this.queryHistory = this.queryHistory.filter(q => q.timestamp > queryCutoff);
+        // Clean up recent queries
+        for (const [query, queries] of this.recentQueries.entries()) {
+            const recent = queries.filter(q => q.timestamp > queryCutoff);
+            if (recent.length === 0) {
+                this.recentQueries.delete(query);
+            }
+            else {
+                this.recentQueries.set(query, recent);
+            }
+        }
+    }
+}
+/**
+ * Factory function to create metrics collector
+ */
+export function createMetricsCollector(config, logger) {
+    return new MetricsCollector(config, logger);
+}

package/dist/esm/performance/utils/query-parser.d.ts

@@ -0,0 +1,123 @@
+/**
+ * Query parsing utilities for performance analysis and optimization
+ */
+export interface ParsedQuery {
+    type: 'SELECT' | 'INSERT' | 'UPDATE' | 'DELETE' | 'OTHER';
+    tables: string[];
+    whereColumns: string[];
+    joinColumns: Array<{
+        table: string;
+        column: string;
+    }>;
+    orderByColumns: string[];
+    groupByColumns: string[];
+    hasLimit: boolean;
+    hasAggregates: boolean;
+    isComplex: boolean;
+}
+export interface QueryPattern {
+    normalized: string;
+    original: string;
+    frequency: number;
+    averageTime: number;
+    tables: string[];
+}
+/**
+ * Utility class for parsing and analyzing SQL queries
+ */
+export declare class QueryParser {
+    /**
+     * Parse a SQL query into structured components
+     */
+    static parseQuery(query: string): ParsedQuery;
+    /**
+     * Normalize query for comparison (remove dynamic values)
+     */
+    static normalizeQuery(query: string): string;
+    /**
+     * Extract query type from SQL statement
+     */
+    static extractQueryType(query: string): ParsedQuery['type'];
+    /**
+     * Extract table names from query
+     */
+    static extractTables(query: string): string[];
+    /**
+     * Extract columns used in WHERE clauses
+     */
+    static extractWhereColumns(query: string): string[];
+    /**
+     * Extract columns used in JOIN conditions
+     */
+    static extractJoinColumns(query: string): Array<{
+        table: string;
+        column: string;
+    }>;
+    /**
+     * Extract columns used in ORDER BY clauses
+     */
+    static extractOrderByColumns(query: string): string[];
+    /**
+     * Extract columns used in GROUP BY clauses
+     */
+    static extractGroupByColumns(query: string): string[];
+    /**
+     * Check if query contains aggregate functions
+     */
+    static hasAggregates(query: string): boolean;
+    /**
+     * Check if query is complex (joins, subqueries, etc.)
+     */
+    static isComplexQuery(query: string): boolean;
+    /**
+     * Check if query could return many rows
+     */
+    static couldReturnManyRows(query: string): boolean;
+    /**
+     * Extract the primary table from a query
+     */
+    static extractPrimaryTable(query: string): string | null;
+    /**
+     * Check if query is a SELECT statement
+     */
+    static isSelectQuery(query: string): boolean;
+    /**
+     * Check if query is a JOIN statement
+     */
+    static isJoinQuery(query: string): boolean;
+    /**
+     * Check if query is an aggregate statement
+     */
+    static isAggregateQuery(query: string): boolean;
+    /**
+     * Generate a cache key for a query
+     */
+    static generateCacheKey(query: string, params?: any[]): string;
+    /**
+     * Check if query should be cached
+     */
+    static shouldCache(query: string, executionTime: number): boolean;
+    /**
+     * Extract operation type from query
+     */
+    static extractOperation(query: string): string;
+    /**
+     * Analyze query patterns from a list of queries
+     */
+    static analyzePatterns(queries: Array<{
+        query: string;
+        executionTime: number;
+    }>): QueryPattern[];
+    /**
+     * Detect potential N+1 query patterns
+     */
+    static detectNPlusOnePatterns(queries: Array<{
+        query: string;
+        timestamp: number;
+    }>): Array<{
+        pattern: string;
+        count: number;
+        timeWindow: number;
+        severity: 'low' | 'medium' | 'high';
+    }>;
+}