@ahmedhegazee/nestjs-telescope/dist/telescope/core/services/database-optimizer.service.d.ts

Advanced observability and monitoring solution for NestJS applications with ML-powered analytics, enterprise features, and production-ready scaling

import { OnModuleInit } from '@nestjs/common';
import { Observable } from 'rxjs';
import { TelescopeConfig } from '../interfaces/telescope-config.interface';
export interface DatabaseConfig {
    enabled: boolean;
    type: 'postgresql' | 'mysql' | 'mongodb' | 'sqlite';
    connection: {
        host: string;
        port: number;
        database: string;
        username: string;
        password: string;
        ssl?: boolean;
        poolSize?: number;
        timeout?: number;
    };
    optimization: {
        autoIndexing: boolean;
        queryOptimization: boolean;
        connectionPooling: boolean;
        queryCaching: boolean;
        slowQueryThreshold: number;
        maxQueryTime: number;
    };
    monitoring: {
        enabled: boolean;
        metricsInterval: number;
        slowQueryLogging: boolean;
        performanceAlerts: boolean;
    };
}
export interface QueryMetrics {
    queryHash: string;
    sql: string;
    executionTime: number;
    rowsReturned: number;
    rowsAffected: number;
    timestamp: Date;
    connectionId: string;
    userId?: string;
    application: string;
    slow: boolean;
    optimized: boolean;
}
export interface IndexSuggestion {
    id: string;
    table: string;
    columns: string[];
    type: 'btree' | 'hash' | 'gin' | 'gist' | 'brin';
    reason: string;
    estimatedImprovement: number;
    creationCost: number;
    priority: 'low' | 'medium' | 'high' | 'critical';
    status: 'pending' | 'created' | 'failed' | 'ignored';
}
export interface DatabasePerformance {
    connections: {
        active: number;
        idle: number;
        max: number;
        utilization: number;
    };
    queries: {
        total: number;
        slow: number;
        averageTime: number;
        peakTime: number;
        throughput: number;
    };
    storage: {
        size: number;
        growth: number;
        fragmentation: number;
    };
    cache: {
        hitRate: number;
        size: number;
        evictions: number;
    };
    locks: {
        active: number;
        waiting: number;
        deadlocks: number;
    };
}
export interface OptimizationResult {
    success: boolean;
    operation: string;
    duration: number;
    improvements: {
        queryTime: number;
        throughput: number;
        resourceUsage: number;
    };
    recommendations: string[];
    errors?: string[];
}
export declare class DatabaseOptimizerService implements OnModuleInit {
    private readonly telescopeConfig;
    private readonly logger;
    private readonly queryMetrics;
    private readonly indexSuggestions;
    private readonly performanceSubject;
    private readonly optimizationSubject;
    private readonly config;
    private monitoringInterval;
    private optimizationInterval;
    constructor(telescopeConfig: TelescopeConfig);
    onModuleInit(): Promise<void>;
    private getDefaultDatabaseConfig;
    private initializeOptimizer;
    private initializeConnectionPool;
    private initializeQueryCache;
    private analyzeExistingIndexes;
    private startMonitoring;
    private startOptimization;
    recordQuery(queryMetrics: QueryMetrics): Promise<void>;
    private analyzeSlowQuery;
    private generateIndexSuggestions;
    private analyzeQueryPattern;
    private determineIndexType;
    private estimateIndexImprovement;
    private estimateIndexCreationCost;
    private determineIndexPriority;
    getDatabasePerformance(): Promise<DatabasePerformance>;
    private getConnectionMetrics;
    private getQueryMetrics;
    private getStorageMetrics;
    private getCacheMetrics;
    private getLockMetrics;
    private checkPerformanceAlerts;
    private runOptimizationCycle;
    private analyzeQueryPatterns;
    private processIndexSuggestions;
    private createIndex;
    private optimizeSlowQueries;
    private optimizeQuery;
    private analyzeQueryOptimization;
    private generateOptimizedQuery;
    private testQueryOptimization;
    private cleanupOldData;
    private updateStatistics;
    getPerformanceUpdates(): Observable<DatabasePerformance>;
    getOptimizationUpdates(): Observable<OptimizationResult>;
    getIndexSuggestions(): IndexSuggestion[];
    createIndexManually(suggestion: Omit<IndexSuggestion, 'id' | 'status'>): Promise<OptimizationResult>;
    getQueryAnalysis(queryHash: string): Promise<{
        metrics: QueryMetrics[];
        analysis: {
            totalExecutions: number;
            averageTime: number;
            slowExecutions: number;
            slowRate: number;
            trend: 'improving' | 'degrading' | 'stable';
        };
    } | null>;
    shutdown(): Promise<void>;
}