memento-mcp-server 1.6.0 → 1.7.1

package/dist/services/performance-monitor.js

@@ -3,12 +3,16 @@
  * 시스템 성능 지표 수집, 분석, 알림 기능 제공
  */
 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,
@@ -23,7 +27,13 @@ export class PerformanceMonitor {
      */
     initialize(db) {
         this.db = db;
-        this.log('PerformanceMonitor initialized');
+        logger.info('PerformanceMonitor initialized');
+    }
+    /**
+     * 데이터베이스 설정
+     */
+    setDatabase(db) {
+        this.db = db;
     }
     /**
      * 성능 지표 수집
@@ -36,56 +46,49 @@ export class PerformanceMonitor {
         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
+                external: memUsage.external,
+                usagePercent: memoryUsagePercent
             },
             cpu: {
                 user: cpuUsage.user,
-                system: cpuUsage.system
+                system: cpuUsage.system,
+                percent: cpuUsagePercent
             },
-            database: dbMetrics,
-            uptime: process.uptime()
+            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;
-        this.log(`Metrics collected in ${collectionTime}ms`);
+        logger.debug('Performance metrics collected', { collectionTimeMs: collectionTime });
         return metrics;
     }
-    /**
-     * 데이터베이스 지표 수집
-     */
-    async getDatabaseMetrics() {
-        if (!this.db) {
-            return { size: 0, memoryCount: 0, queryTime: 0 };
-        }
-        const startTime = Date.now();
-        try {
-            // DB 크기
-            const pageCount = this.db.prepare('PRAGMA page_count').get();
-            const pageSize = this.db.prepare('PRAGMA page_size').get();
-            const size = pageCount.page_count * pageSize.page_size;
-            // 메모리 개수
-            const memoryCount = this.db.prepare('SELECT COUNT(*) as count FROM memory_item').get();
-            const queryTime = Date.now() - startTime;
-            return {
-                size,
-                memoryCount: memoryCount.count,
-                queryTime
-            };
-        }
-        catch (error) {
-            this.log('Database metrics collection failed:', error);
-            return { size: 0, memoryCount: 0, queryTime: 0 };
-        }
-    }
     /**
      * 알림 검사
      */
@@ -175,11 +178,23 @@ export class PerformanceMonitor {
         // 알림 저장 및 로깅
         for (const alert of alerts) {
             this.alerts.set(alert.id, alert);
-            this.log(`Alert generated: ${alert.type} - ${alert.message}`, {
+            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);
@@ -196,18 +211,6 @@ export class PerformanceMonitor {
             this.metricsHistory = this.metricsHistory.slice(-this.maxHistorySize);
         }
     }
-    /**
-     * 활성 알림 조회
-     */
-    getActiveAlerts() {
-        return Array.from(this.alerts.values()).filter(alert => !alert.resolved);
-    }
-    /**
-     * 모든 알림 조회
-     */
-    getAllAlerts() {
-        return Array.from(this.alerts.values());
-    }
     /**
      * 알림 해결
      */
@@ -215,11 +218,18 @@ export class PerformanceMonitor {
         const alert = this.alerts.get(alertId);
         if (alert) {
             alert.resolved = true;
-            this.log(`Alert resolved: ${alertId}`);
+            logger.info('Performance alert resolved', { alertId });
+            alertNotificationService.acknowledgeAlert(alertId);
             return true;
         }
         return false;
     }
+    /**
+     * 현재 성능 지표 조회
+     */
+    async getMetrics() {
+        return await this.collectMetrics();
+    }
     /**
      * 성능 지표 히스토리 조회
      */
@@ -229,12 +239,316 @@ export class PerformanceMonitor {
         }
         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.getActiveAlerts();
+        const activeAlerts = this.getAlerts();
         const allAlerts = this.getAllAlerts();
         // 트렌드 분석 (최근 10개 지표 기준)
         const recentMetrics = this.metricsHistory.slice(-10);
@@ -252,6 +566,78 @@ export class PerformanceMonitor {
             }
         };
     }
+    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
+            }
+        };
+    }
     /**
      * 트렌드 분석
      */
@@ -274,7 +660,7 @@ export class PerformanceMonitor {
      */
     updateThresholds(newThresholds) {
         this.thresholds = { ...this.thresholds, ...newThresholds };
-        this.log('Thresholds updated', this.thresholds);
+        logger.info('Performance thresholds updated', { ...this.thresholds });
     }
     /**
      * 바이트를 읽기 쉬운 형식으로 변환
@@ -300,8 +686,8 @@ export class PerformanceMonitor {
      * 심각한 알림 처리
      */
     async handleCriticalAlert(alert, metrics) {
-        this.log(`Critical alert handling: ${alert.type}`, {
-            alert: alert,
+        logger.error('Critical performance alert handling', {
+            alert,
             metrics: {
                 memoryUsage: (metrics.memory.heapUsed / metrics.memory.heapTotal) * 100,
                 dbSize: metrics.database.size / (1024 * 1024),
@@ -310,22 +696,22 @@ export class PerformanceMonitor {
         });
         // 메모리 정리 시도
         if (alert.type === 'memory' && global.gc) {
-            this.log('Triggering garbage collection due to high memory usage');
+            logger.warn('Triggering garbage collection due to high memory usage');
             global.gc();
         }
         // 데이터베이스 최적화 시도
         if (alert.type === 'database' && this.db) {
             try {
-                this.log('Running database optimization due to large size');
+                logger.warn('Running database optimization due to large database size');
                 await this.optimizeDatabase();
             }
             catch (error) {
-                this.log('Database optimization failed:', error);
+                logger.error('Database optimization failed', { error: error instanceof Error ? error.message : String(error) });
             }
         }
         // 쿼리 최적화 시도
         if (alert.type === 'query') {
-            this.log('Query optimization recommended due to slow queries');
+            logger.warn('Query optimization recommended due to slow queries');
             // 여기에 쿼리 최적화 로직 추가 가능
         }
     }
@@ -338,16 +724,16 @@ export class PerformanceMonitor {
         try {
             // VACUUM 실행
             this.db.exec('VACUUM');
-            this.log('Database VACUUM completed');
+            logger.info('Database VACUUM completed');
             // ANALYZE 실행
             this.db.exec('ANALYZE');
-            this.log('Database ANALYZE completed');
+            logger.info('Database ANALYZE completed');
             // WAL 체크포인트
             this.db.exec('PRAGMA wal_checkpoint(TRUNCATE)');
-            this.log('WAL checkpoint completed');
+            logger.info('WAL checkpoint completed');
         }
         catch (error) {
-            this.log('Database optimization failed:', error);
+            logger.error('Database optimization failed', { error: error instanceof Error ? error.message : String(error) });
             throw error;
         }
     }
@@ -391,7 +777,7 @@ export class PerformanceMonitor {
             }
         }
         if (removedCount > 0) {
-            this.log(`Cleaned up ${removedCount} old alerts`);
+            logger.info('Old alerts cleaned', { removedCount });
         }
     }
     /**