memento-mcp-server 1.13.1-a0 → 1.13.1-a3

package/dist/services/performance-monitor.js

@@ -1,802 +0,0 @@
-/**
- * 성능 모니터링 서비스
- * 시스템 성능 지표 수집, 분석, 알림 기능 제공
- */
-import Database from 'better-sqlite3';
-import os from 'os';
-import { logger } from '../utils/logger.js';
-import { alertNotificationService } from './alert-notification-service.js';
-export class PerformanceMonitor {
-    db = null;
-    thresholds;
-    alerts = new Map();
-    metricsHistory = [];
-    maxHistorySize = 1000;
-    monitoringInterval = null;
-    constructor(thresholds) {
-        this.thresholds = {
-            memoryUsagePercent: 80,
-            cpuUsagePercent: 70,
-            databaseSizeMB: 100,
-            queryTimeMs: 1000,
-            ...thresholds
-        };
-    }
-    /**
-     * 모니터링 시작
-     */
-    initialize(db) {
-        this.db = db;
-        logger.info('PerformanceMonitor initialized');
-    }
-    /**
-     * 데이터베이스 설정
-     */
-    setDatabase(db) {
-        this.db = db;
-    }
-    /**
-     * 성능 지표 수집
-     */
-    async collectMetrics() {
-        const startTime = Date.now();
-        // 메모리 사용량
-        const memUsage = process.memoryUsage();
-        // CPU 사용량
-        const cpuUsage = process.cpuUsage();
-        // 데이터베이스 지표
-        const dbMetrics = await this.getDatabaseMetrics();
-        const dbMetricsForPerformance = {
-            size: dbMetrics.databaseSize,
-            memoryCount: dbMetrics.totalMemories,
-            queryTime: 0 // 실제 쿼리 시간은 별도로 측정
-        };
-        // 검색 지표
-        const searchMetrics = this.getSearchMetrics();
-        // 시스템 지표
-        const systemMetrics = this.getSystemMetrics();
-        const memoryUsagePercent = memUsage.heapTotal > 0 ? (memUsage.heapUsed / memUsage.heapTotal) * 100 : 0;
-        const cpuUsagePercent = this.calculateCpuUsage(cpuUsage);
-        const metrics = {
-            timestamp: new Date(),
-            database: dbMetricsForPerformance,
-            memory: {
-                rss: memUsage.rss,
-                heapTotal: memUsage.heapTotal,
-                heapUsed: memUsage.heapUsed,
-                external: memUsage.external,
-                usagePercent: memoryUsagePercent
-            },
-            cpu: {
-                user: cpuUsage.user,
-                system: cpuUsage.system,
-                percent: cpuUsagePercent
-            },
-            uptime: process.uptime(),
-            search: {
-                total: searchMetrics.totalSearches,
-                averageTime: searchMetrics.averageSearchTime,
-                byType: searchMetrics.searchByType,
-                cacheHitRate: searchMetrics.cacheHitRate,
-                embeddingSearchRate: searchMetrics.embeddingSearchRate
-            }
-        };
-        // 지표 히스토리에 추가
-        this.addToHistory(metrics);
-        // 알림 검사
-        await this.checkAlerts(metrics);
-        const collectionTime = Date.now() - startTime;
-        logger.debug('Performance metrics collected', { collectionTimeMs: collectionTime });
-        return metrics;
-    }
-    /**
-     * 알림 검사
-     */
-    async checkAlerts(metrics) {
-        const alerts = [];
-        const now = new Date();
-        // 메모리 사용률 검사
-        const memoryUsagePercent = (metrics.memory.heapUsed / metrics.memory.heapTotal) * 100;
-        if (memoryUsagePercent > this.thresholds.memoryUsagePercent) {
-            const alertId = `memory-${now.getTime()}`;
-            const severity = memoryUsagePercent > 90 ? 'critical' : 'warning';
-            // 중복 알림 방지 (같은 타입의 활성 알림이 있으면 스킵)
-            const existingMemoryAlert = Array.from(this.alerts.values())
-                .find(alert => alert.type === 'memory' && !alert.resolved);
-            if (!existingMemoryAlert) {
-                alerts.push({
-                    id: alertId,
-                    type: 'memory',
-                    severity,
-                    message: `High memory usage: ${memoryUsagePercent.toFixed(1)}% (${this.formatBytes(metrics.memory.heapUsed)}/${this.formatBytes(metrics.memory.heapTotal)})`,
-                    value: memoryUsagePercent,
-                    threshold: this.thresholds.memoryUsagePercent,
-                    timestamp: now,
-                    resolved: false
-                });
-            }
-        }
-        // 데이터베이스 크기 검사
-        const dbSizeMB = metrics.database.size / (1024 * 1024);
-        if (dbSizeMB > this.thresholds.databaseSizeMB) {
-            const alertId = `database-${now.getTime()}`;
-            const severity = dbSizeMB > this.thresholds.databaseSizeMB * 1.5 ? 'critical' : 'warning';
-            const existingDbAlert = Array.from(this.alerts.values())
-                .find(alert => alert.type === 'database' && !alert.resolved);
-            if (!existingDbAlert) {
-                alerts.push({
-                    id: alertId,
-                    type: 'database',
-                    severity,
-                    message: `Large database size: ${dbSizeMB.toFixed(1)}MB (${metrics.database.memoryCount} memories)`,
-                    value: dbSizeMB,
-                    threshold: this.thresholds.databaseSizeMB,
-                    timestamp: now,
-                    resolved: false
-                });
-            }
-        }
-        // 쿼리 시간 검사
-        if (metrics.database.queryTime > this.thresholds.queryTimeMs) {
-            const alertId = `query-${now.getTime()}`;
-            const severity = metrics.database.queryTime > this.thresholds.queryTimeMs * 2 ? 'critical' : 'warning';
-            const existingQueryAlert = Array.from(this.alerts.values())
-                .find(alert => alert.type === 'query' && !alert.resolved);
-            if (!existingQueryAlert) {
-                alerts.push({
-                    id: alertId,
-                    type: 'query',
-                    severity,
-                    message: `Slow query detected: ${metrics.database.queryTime}ms (threshold: ${this.thresholds.queryTimeMs}ms)`,
-                    value: metrics.database.queryTime,
-                    threshold: this.thresholds.queryTimeMs,
-                    timestamp: now,
-                    resolved: false
-                });
-            }
-        }
-        // CPU 사용률 검사 (추가)
-        const cpuUsagePercent = this.calculateCpuUsage(metrics.cpu);
-        if (cpuUsagePercent > this.thresholds.cpuUsagePercent) {
-            const alertId = `cpu-${now.getTime()}`;
-            const severity = cpuUsagePercent > 90 ? 'critical' : 'warning';
-            const existingCpuAlert = Array.from(this.alerts.values())
-                .find(alert => alert.type === 'cpu' && !alert.resolved);
-            if (!existingCpuAlert) {
-                alerts.push({
-                    id: alertId,
-                    type: 'cpu',
-                    severity,
-                    message: `High CPU usage: ${cpuUsagePercent.toFixed(1)}%`,
-                    value: cpuUsagePercent,
-                    threshold: this.thresholds.cpuUsagePercent,
-                    timestamp: now,
-                    resolved: false
-                });
-            }
-        }
-        // 알림 저장 및 로깅
-        for (const alert of alerts) {
-            this.alerts.set(alert.id, alert);
-            logger.warn('Performance alert generated', {
-                type: alert.type,
-                severity: alert.severity,
-                value: alert.value,
-                threshold: alert.threshold
-            });
-            alertNotificationService.emitAlert({
-                id: alert.id,
-                source: 'performance',
-                severity: alert.severity,
-                message: alert.message,
-                metadata: {
-                    type: alert.type,
-                    value: alert.value,
-                    threshold: alert.threshold
-                }
-            });
-            // 심각한 알림의 경우 추가 처리
-            if (alert.severity === 'critical') {
-                await this.handleCriticalAlert(alert, metrics);
-            }
-        }
-    }
-    /**
-     * 지표 히스토리에 추가
-     */
-    addToHistory(metrics) {
-        this.metricsHistory.push(metrics);
-        // 히스토리 크기 제한
-        if (this.metricsHistory.length > this.maxHistorySize) {
-            this.metricsHistory = this.metricsHistory.slice(-this.maxHistorySize);
-        }
-    }
-    /**
-     * 알림 해결
-     */
-    resolveAlert(alertId) {
-        const alert = this.alerts.get(alertId);
-        if (alert) {
-            alert.resolved = true;
-            logger.info('Performance alert resolved', { alertId });
-            alertNotificationService.acknowledgeAlert(alertId);
-            return true;
-        }
-        return false;
-    }
-    /**
-     * 현재 성능 지표 조회
-     */
-    async getMetrics() {
-        return await this.collectMetrics();
-    }
-    /**
-     * 성능 지표 히스토리 조회
-     */
-    getMetricsHistory(limit) {
-        if (limit) {
-            return this.metricsHistory.slice(-limit);
-        }
-        return [...this.metricsHistory];
-    }
-    /**
-     * 활성 알림 조회
-     */
-    getAlerts() {
-        return Array.from(this.alerts.values());
-    }
-    getActiveAlerts() {
-        return Array.from(this.alerts.values()).filter(alert => !alert.resolved);
-    }
-    getAllAlerts() {
-        return Array.from(this.alerts.values());
-    }
-    /**
-     * 알림 초기화
-     */
-    clearAlerts() {
-        this.alerts.clear();
-    }
-    /**
-     * 성능 리포트 생성
-     */
-    async getPerformanceReport() {
-        const summary = this.getPerformanceSummary();
-        const metrics = this.getMetricsHistory();
-        const alerts = this.getAlerts();
-        const recommendations = this.generateRecommendations(alerts);
-        const analytics = this.getMetricsAnalytics();
-        return {
-            summary,
-            metrics,
-            alerts,
-            recommendations,
-            analytics,
-            timestamp: new Date()
-        };
-    }
-    /**
-     * 권장사항 생성
-     */
-    generateRecommendations(alerts) {
-        const recommendations = [];
-        const memoryAlerts = alerts.filter(alert => alert.type === 'memory' && !alert.resolved);
-        const cpuAlerts = alerts.filter(alert => alert.type === 'cpu' && !alert.resolved);
-        const dbAlerts = alerts.filter(alert => alert.type === 'database' && !alert.resolved);
-        if (memoryAlerts.length > 0) {
-            recommendations.push('메모리 사용량이 높습니다. 캐시 크기를 줄이거나 메모리 정리를 고려하세요.');
-        }
-        if (cpuAlerts.length > 0) {
-            recommendations.push('CPU 사용량이 높습니다. 쿼리 최적화나 인덱스 추가를 고려하세요.');
-        }
-        if (dbAlerts.length > 0) {
-            recommendations.push('데이터베이스 크기가 큽니다. 오래된 데이터 정리나 아카이빙을 고려하세요.');
-        }
-        if (recommendations.length === 0) {
-            recommendations.push('시스템이 정상적으로 작동하고 있습니다.');
-        }
-        return recommendations;
-    }
-    /**
-     * 모니터링 시작
-     */
-    startMonitoring(intervalMs = 60000) {
-        if (this.monitoringInterval) {
-            clearInterval(this.monitoringInterval);
-        }
-        this.monitoringInterval = setInterval(async () => {
-            try {
-                await this.collectMetrics();
-            }
-            catch (error) {
-                logger.error('성능 모니터링 중 오류', { error: error instanceof Error ? error.message : String(error) });
-            }
-        }, intervalMs);
-    }
-    /**
-     * 모니터링 중지
-     */
-    stopMonitoring() {
-        if (this.monitoringInterval) {
-            clearInterval(this.monitoringInterval);
-            this.monitoringInterval = null;
-        }
-    }
-    /**
-     * 모니터링 상태 확인
-     */
-    isMonitoring() {
-        return this.monitoringInterval !== null;
-    }
-    /**
-     * 검색 통계 기록
-     */
-    recordSearch(type, duration, cacheHit = false) {
-        if (!this.searchStats) {
-            this.searchStats = {
-                totalSearches: 0,
-                totalDuration: 0,
-                totalSearchTime: 0,
-                searchesByType: { text: 0, vector: 0, hybrid: 0 },
-                cacheHits: 0,
-                cacheMisses: 0,
-                embeddingSearches: 0
-            };
-        }
-        const stats = this.searchStats;
-        stats.totalSearches++;
-        stats.totalDuration += duration;
-        stats.totalSearchTime += duration;
-        stats.searchesByType[type]++;
-        if (type === 'vector') {
-            stats.embeddingSearches++;
-        }
-        if (cacheHit) {
-            stats.cacheHits++;
-        }
-        else {
-            stats.cacheMisses++;
-        }
-    }
-    /**
-     * 검색 메트릭 조회
-     */
-    getSearchMetrics() {
-        const stats = this.searchStats || {
-            totalSearches: 0,
-            totalDuration: 0,
-            searchesByType: { text: 0, vector: 0, hybrid: 0 },
-            cacheHits: 0,
-            cacheMisses: 0,
-            embeddingSearches: 0
-        };
-        const averageSearchTime = stats.totalSearches > 0 ? stats.totalDuration / stats.totalSearches : 0;
-        const totalCacheRequests = stats.cacheHits + stats.cacheMisses;
-        const cacheHitRate = totalCacheRequests > 0 ? stats.cacheHits / totalCacheRequests : 0;
-        const embeddingSearchRate = stats.totalSearches > 0 ? stats.embeddingSearches / stats.totalSearches : 0;
-        return {
-            totalSearches: stats.totalSearches,
-            averageSearchTime,
-            searchByType: stats.searchesByType,
-            cacheHitRate,
-            embeddingSearchRate
-        };
-    }
-    /**
-     * 메모리 메트릭 조회
-     */
-    getMemoryMetrics() {
-        const memUsage = process.memoryUsage();
-        const totalMemory = 1024 * 1024 * 1024; // 1GB 가정
-        const usagePercent = (memUsage.heapUsed / totalMemory) * 100;
-        return {
-            heapUsed: memUsage.heapUsed,
-            heapTotal: memUsage.heapTotal,
-            rss: memUsage.rss,
-            external: memUsage.external,
-            usagePercent
-        };
-    }
-    /**
-     * 시스템 메트릭 조회
-     */
-    getSystemMetrics() {
-        const uptime = process.uptime();
-        const cpuUsage = process.cpuUsage();
-        const loadAverage = os.loadavg();
-        return {
-            uptime,
-            cpuUsage: (cpuUsage.user + cpuUsage.system) / 1000000, // 마이크로초를 초로 변환
-            loadAverage
-        };
-    }
-    /**
-     * 데이터베이스 메트릭 조회
-     */
-    async getDatabaseMetrics() {
-        if (!this.db) {
-            return {
-                totalMemories: 0,
-                memoryByType: {},
-                averageMemorySize: 0,
-                databaseSize: 0
-            };
-        }
-        try {
-            const totalMemories = this.db.prepare('SELECT COUNT(*) as count FROM memory_item').get();
-            const memoryByType = this.db.prepare(`
-        SELECT type, COUNT(*) as count 
-        FROM memory_item 
-        GROUP BY type
-      `).all();
-            const typeMap = {};
-            memoryByType.forEach(row => {
-                typeMap[row.type] = row.count;
-            });
-            const averageSize = this.db.prepare(`
-        SELECT AVG(LENGTH(content)) as avgSize 
-        FROM memory_item
-      `).get();
-            const dbSize = this.db.prepare('PRAGMA page_count').get();
-            const pageSize = this.db.prepare('PRAGMA page_size').get();
-            const databaseSize = dbSize.page_count * pageSize.page_size;
-            return {
-                totalMemories: totalMemories.count,
-                memoryByType: typeMap,
-                averageMemorySize: averageSize.avgSize || 0,
-                databaseSize
-            };
-        }
-        catch (error) {
-            return {
-                totalMemories: 0,
-                memoryByType: {},
-                averageMemorySize: 0,
-                databaseSize: 0
-            };
-        }
-    }
-    /**
-     * 통계 초기화
-     */
-    resetStats() {
-        this.searchStats = {
-            totalSearches: 0,
-            totalDuration: 0,
-            totalSearchTime: 0,
-            searchesByType: { text: 0, vector: 0, hybrid: 0 },
-            cacheHits: 0,
-            cacheMisses: 0,
-            embeddingSearches: 0
-        };
-    }
-    /**
-     * 시스템 건강 상태 확인
-     */
-    async isHealthy() {
-        const metrics = await this.collectMetrics();
-        const alerts = this.getActiveAlerts();
-        // 심각한 알림이 있으면 비정상
-        const criticalAlerts = alerts.filter((alert) => alert.severity === 'critical');
-        return criticalAlerts.length === 0;
-    }
-    /**
-     * 메트릭 내보내기
-     */
-    async exportMetrics() {
-        const metrics = this.getMetricsHistory();
-        const alerts = this.getAlerts();
-        const currentMetrics = await this.collectMetrics();
-        return JSON.stringify({
-            database: currentMetrics.database,
-            search: currentMetrics.search,
-            memory: currentMetrics.memory,
-            system: currentMetrics.system,
-            metrics,
-            alerts,
-            exportedAt: new Date().toISOString()
-        });
-    }
-    /**
-     * 메트릭 가져오기
-     */
-    async importMetrics(json) {
-        const data = JSON.parse(json);
-        if (data.metrics) {
-            this.metricsHistory = data.metrics;
-        }
-        if (data.alerts) {
-            this.alerts.clear();
-            data.alerts.forEach((alert) => {
-                this.alerts.set(alert.id, alert);
-            });
-        }
-        // 검색 통계 복원
-        if (data.search) {
-            this.searchStats = {
-                totalSearches: data.search.totalSearches || 0,
-                totalDuration: data.search.averageSearchTime * data.search.totalSearches || 0,
-                totalSearchTime: data.search.averageSearchTime * data.search.totalSearches || 0,
-                searchesByType: data.search.searchByType || { text: 0, vector: 0, hybrid: 0 },
-                cacheHits: Math.round((data.search.cacheHitRate || 0) * data.search.totalSearches),
-                cacheMisses: Math.round((1 - (data.search.cacheHitRate || 0)) * data.search.totalSearches),
-                embeddingSearches: Math.round((data.search.embeddingSearchRate || 0) * data.search.totalSearches)
-            };
-        }
-        // 메트릭 히스토리 복원
-        if (data.metrics && Array.isArray(data.metrics)) {
-            this.metricsHistory = data.metrics;
-        }
-        // 데이터베이스 메트릭 복원 (테스트용)
-        if (data.database) {
-            // 현재 메트릭 수집
-            const currentMetrics = await this.collectMetrics();
-            if (currentMetrics) {
-                // 데이터베이스 메트릭을 직접 설정
-                currentMetrics.database = {
-                    totalMemories: data.database.totalMemories || 0,
-                    memoryByType: data.database.memoryByType || {},
-                    averageMemorySize: data.database.averageMemorySize || 0,
-                    databaseSize: data.database.databaseSize || 0
-                };
-                this.addToHistory(currentMetrics);
-            }
-        }
-    }
-    /**
-     * 성능 통계 요약
-     */
-    getPerformanceSummary() {
-        const current = this.metricsHistory[this.metricsHistory.length - 1] || null;
-        const activeAlerts = this.getAlerts();
-        const allAlerts = this.getAllAlerts();
-        // 트렌드 분석 (최근 10개 지표 기준)
-        const recentMetrics = this.metricsHistory.slice(-10);
-        const memoryTrend = this.analyzeTrend(recentMetrics.map(m => m.memory.heapUsed));
-        const dbSizeTrend = this.analyzeTrend(recentMetrics.map(m => m.database.size));
-        return {
-            current,
-            alerts: {
-                active: activeAlerts.length,
-                total: allAlerts.length
-            },
-            trends: {
-                memoryTrend,
-                dbSizeTrend
-            }
-        };
-    }
-    getMetricsAnalytics(limit = 50) {
-        const history = this.metricsHistory.slice(-limit);
-        if (!history.length) {
-            return {
-                memory: {
-                    averageHeapUsedMB: 0,
-                    peakHeapUsedMB: 0,
-                    averageUsagePercent: 0,
-                    history: []
-                },
-                cpu: {
-                    averagePercent: 0,
-                    peakPercent: 0,
-                    history: []
-                },
-                database: {
-                    averageSizeMB: 0,
-                    lastSizeMB: 0,
-                    growthRate: 0
-                },
-                search: {
-                    totalSearches: 0,
-                    averageSearchTime: 0,
-                    cacheHitRate: 0,
-                    textShare: 0,
-                    vectorShare: 0,
-                    hybridShare: 0
-                }
-            };
-        }
-        const toMb = (bytes) => bytes / (1024 * 1024);
-        const average = (values) => values.length ? values.reduce((sum, value) => sum + value, 0) / values.length : 0;
-        const memoryUsed = history.map(m => m.memory.heapUsed);
-        const memoryPercentHistory = history.map(m => m.memory.usagePercent ?? (m.memory.heapTotal ? (m.memory.heapUsed / m.memory.heapTotal) * 100 : 0));
-        const cpuPercentHistory = history.map(m => m.cpu.percent ?? this.calculateCpuUsage(m.cpu));
-        const dbSizesMB = history.map(m => toMb(m.database.size));
-        const latestEntry = history[history.length - 1];
-        const latestSearch = latestEntry?.search;
-        const totalSearches = latestSearch?.total ?? 0;
-        const totalByType = latestSearch?.byType ?? { text: 0, vector: 0, hybrid: 0 };
-        const totalByTypeSum = totalByType.text + totalByType.vector + totalByType.hybrid;
-        const lastDbSize = dbSizesMB[dbSizesMB.length - 1] ?? 0;
-        const firstDbSize = dbSizesMB[0] ?? 0;
-        return {
-            memory: {
-                averageHeapUsedMB: toMb(average(memoryUsed)),
-                peakHeapUsedMB: toMb(Math.max(...memoryUsed)),
-                averageUsagePercent: average(memoryPercentHistory),
-                history: memoryPercentHistory
-            },
-            cpu: {
-                averagePercent: average(cpuPercentHistory),
-                peakPercent: Math.max(...cpuPercentHistory),
-                history: cpuPercentHistory
-            },
-            database: {
-                averageSizeMB: average(dbSizesMB),
-                lastSizeMB: lastDbSize,
-                growthRate: dbSizesMB.length > 1 && firstDbSize > 0
-                    ? (lastDbSize - firstDbSize) / firstDbSize
-                    : 0
-            },
-            search: {
-                totalSearches,
-                averageSearchTime: latestSearch?.averageTime ?? 0,
-                cacheHitRate: latestSearch?.cacheHitRate ?? 0,
-                textShare: totalByTypeSum > 0 ? totalByType.text / totalByTypeSum : 0,
-                vectorShare: totalByTypeSum > 0 ? totalByType.vector / totalByTypeSum : 0,
-                hybridShare: totalByTypeSum > 0 ? totalByType.hybrid / totalByTypeSum : 0
-            }
-        };
-    }
-    /**
-     * 트렌드 분석
-     */
-    analyzeTrend(values) {
-        if (values.length < 2)
-            return 'stable';
-        const first = values[0];
-        const last = values[values.length - 1];
-        if (first === undefined || last === undefined || first === 0)
-            return 'stable';
-        const change = (last - first) / first;
-        if (change > 0.1)
-            return 'increasing';
-        if (change < -0.1)
-            return 'decreasing';
-        return 'stable';
-    }
-    /**
-     * 임계값 업데이트
-     */
-    updateThresholds(newThresholds) {
-        this.thresholds = { ...this.thresholds, ...newThresholds };
-        logger.info('Performance thresholds updated', { ...this.thresholds });
-    }
-    /**
-     * 바이트를 읽기 쉬운 형식으로 변환
-     */
-    formatBytes(bytes) {
-        if (bytes === 0)
-            return '0 Bytes';
-        const k = 1024;
-        const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
-        const i = Math.floor(Math.log(bytes) / Math.log(k));
-        return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
-    }
-    /**
-     * CPU 사용률 계산
-     */
-    calculateCpuUsage(cpu) {
-        // 간단한 CPU 사용률 추정 (실제로는 더 정교한 계산 필요)
-        const totalCpuTime = cpu.user + cpu.system;
-        const cpuUsagePercent = Math.min(100, (totalCpuTime / 1000000) * 100); // 마이크로초를 백분율로 변환
-        return cpuUsagePercent;
-    }
-    /**
-     * 심각한 알림 처리
-     */
-    async handleCriticalAlert(alert, metrics) {
-        logger.error('Critical performance alert handling', {
-            alert,
-            metrics: {
-                memoryUsage: (metrics.memory.heapUsed / metrics.memory.heapTotal) * 100,
-                dbSize: metrics.database.size / (1024 * 1024),
-                queryTime: metrics.database.queryTime
-            }
-        });
-        // 메모리 정리 시도
-        if (alert.type === 'memory' && global.gc) {
-            logger.warn('Triggering garbage collection due to high memory usage');
-            global.gc();
-        }
-        // 데이터베이스 최적화 시도
-        if (alert.type === 'database' && this.db) {
-            try {
-                logger.warn('Running database optimization due to large database size');
-                await this.optimizeDatabase();
-            }
-            catch (error) {
-                logger.error('Database optimization failed', { error: error instanceof Error ? error.message : String(error) });
-            }
-        }
-        // 쿼리 최적화 시도
-        if (alert.type === 'query') {
-            logger.warn('Query optimization recommended due to slow queries');
-            // 여기에 쿼리 최적화 로직 추가 가능
-        }
-    }
-    /**
-     * 데이터베이스 최적화
-     */
-    async optimizeDatabase() {
-        if (!this.db)
-            return;
-        try {
-            // VACUUM 실행
-            this.db.exec('VACUUM');
-            logger.info('Database VACUUM completed');
-            // ANALYZE 실행
-            this.db.exec('ANALYZE');
-            logger.info('Database ANALYZE completed');
-            // WAL 체크포인트
-            this.db.exec('PRAGMA wal_checkpoint(TRUNCATE)');
-            logger.info('WAL checkpoint completed');
-        }
-        catch (error) {
-            logger.error('Database optimization failed', { error: error instanceof Error ? error.message : String(error) });
-            throw error;
-        }
-    }
-    /**
-     * 알림 통계 조회
-     */
-    getAlertStats() {
-        const allAlerts = Array.from(this.alerts.values());
-        const activeAlerts = allAlerts.filter(alert => !alert.resolved);
-        const resolvedAlerts = allAlerts.filter(alert => alert.resolved);
-        const byType = allAlerts.reduce((acc, alert) => {
-            acc[alert.type] = (acc[alert.type] || 0) + 1;
-            return acc;
-        }, {});
-        const bySeverity = allAlerts.reduce((acc, alert) => {
-            acc[alert.severity] = (acc[alert.severity] || 0) + 1;
-            return acc;
-        }, {});
-        const recent = allAlerts
-            .sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime())
-            .slice(0, 10);
-        return {
-            total: allAlerts.length,
-            active: activeAlerts.length,
-            resolved: resolvedAlerts.length,
-            byType,
-            bySeverity,
-            recent
-        };
-    }
-    /**
-     * 알림 정리 (오래된 해결된 알림 제거)
-     */
-    cleanupOldAlerts(maxAgeHours = 24) {
-        const cutoffTime = new Date(Date.now() - maxAgeHours * 60 * 60 * 1000);
-        let removedCount = 0;
-        for (const [id, alert] of this.alerts) {
-            if (alert.resolved && alert.timestamp < cutoffTime) {
-                this.alerts.delete(id);
-                removedCount++;
-            }
-        }
-        if (removedCount > 0) {
-            logger.info('Old alerts cleaned', { removedCount });
-        }
-    }
-    /**
-     * 로깅
-     */
-    log(message, data) {
-        const timestamp = new Date().toISOString();
-        console.log(`[${timestamp}] [PerformanceMonitor] ${message}`, data ? JSON.stringify(data, null, 2) : '');
-    }
-}
-// 싱글톤 인스턴스
-let monitorInstance = null;
-export function getPerformanceMonitor() {
-    if (!monitorInstance) {
-        monitorInstance = new PerformanceMonitor();
-    }
-    return monitorInstance;
-}
-export function createPerformanceMonitor(thresholds) {
-    return new PerformanceMonitor(thresholds);
-}
-//# sourceMappingURL=performance-monitor.js.map