memento-mcp-server 0.1.0

package/src/test/performance-benchmark.ts

@@ -0,0 +1,565 @@
+/**
+ * 성능 벤치마크 테스트
+ * Memento MCP 서버의 성능 측정 및 분석
+ */
+
+import { createMementoClient } from '../client/index.js';
+import { PerformanceMonitor } from '../services/performance-monitor.js';
+import { CacheService, SearchCacheService } from '../services/cache-service.js';
+import { AsyncTaskQueue } from '../services/async-optimizer.js';
+
+interface BenchmarkResult {
+  testName: string;
+  iterations: number;
+  totalTime: number;
+  averageTime: number;
+  minTime: number;
+  maxTime: number;
+  throughput: number;
+  memoryUsage: {
+    before: NodeJS.MemoryUsage;
+    after: NodeJS.MemoryUsage;
+    delta: NodeJS.MemoryUsage;
+  };
+  successRate: number;
+  errors: string[];
+}
+
+export class PerformanceBenchmark {
+  private client: any;
+  private performanceMonitor: PerformanceMonitor | null = null;
+  private searchCache: SearchCacheService;
+  private taskQueue: AsyncTaskQueue;
+  private results: BenchmarkResult[] = [];
+
+  constructor() {
+    this.client = createMementoClient();
+    this.searchCache = new SearchCacheService(1000, 300000); // 5분 TTL
+    this.taskQueue = new AsyncTaskQueue(4);
+  }
+
+  /**
+   * 전체 벤치마크 실행
+   */
+  async runFullBenchmark(): Promise<void> {
+    console.log('🚀 Memento MCP 서버 성능 벤치마크 시작');
+    
+    try {
+      // 서버 연결
+      await this.client.connect();
+      console.log('✅ 서버 연결 완료');
+
+      // 성능 모니터 초기화
+      this.performanceMonitor = new PerformanceMonitor(this.client.db);
+
+      // 벤치마크 테스트 실행
+      await this.benchmarkMemoryOperations();
+      await this.benchmarkSearchOperations();
+      await this.benchmarkCacheOperations();
+      await this.benchmarkAsyncOperations();
+      await this.benchmarkConcurrentOperations();
+
+      // 결과 리포트 생성
+      this.generateReport();
+
+    } catch (error) {
+      console.error('❌ 벤치마크 실행 실패:', error);
+    } finally {
+      await this.client.disconnect();
+    }
+  }
+
+  /**
+   * 메모리 작업 벤치마크
+   */
+  private async benchmarkMemoryOperations(): Promise<void> {
+    console.log('\n📝 메모리 작업 벤치마크 시작');
+    
+    const iterations = 100;
+    const times: number[] = [];
+    const errors: string[] = [];
+    const beforeMemory = process.memoryUsage();
+
+    for (let i = 0; i < iterations; i++) {
+      const startTime = process.hrtime.bigint();
+      
+      try {
+        await this.client.remember({
+          content: `벤치마크 테스트 메모리 ${i}: 성능 테스트를 위한 샘플 데이터입니다.`,
+          type: 'episodic',
+          tags: ['benchmark', 'test', `iteration-${i}`],
+          importance: 0.5
+        });
+        
+        const endTime = process.hrtime.bigint();
+        const executionTime = Number(endTime - startTime) / 1_000_000;
+        times.push(executionTime);
+        
+      } catch (error) {
+        errors.push(`Iteration ${i}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+      }
+    }
+
+    const afterMemory = process.memoryUsage();
+    const result = this.calculateBenchmarkResult(
+      'Memory Operations',
+      iterations,
+      times,
+      beforeMemory,
+      afterMemory,
+      errors
+    );
+
+    this.results.push(result);
+    this.printResult(result);
+  }
+
+  /**
+   * 검색 작업 벤치마크
+   */
+  private async benchmarkSearchOperations(): Promise<void> {
+    console.log('\n🔍 검색 작업 벤치마크 시작');
+    
+    const searchQueries = [
+      '벤치마크',
+      '테스트',
+      '성능',
+      '메모리',
+      '검색',
+      '데이터',
+      '시스템',
+      '최적화',
+      '알고리즘',
+      '데이터베이스'
+    ];
+
+    const iterations = 50;
+    const times: number[] = [];
+    const errors: string[] = [];
+    const beforeMemory = process.memoryUsage();
+
+    for (let i = 0; i < iterations; i++) {
+      const query = searchQueries[i % searchQueries.length];
+      const startTime = process.hrtime.bigint();
+      
+      try {
+        await this.client.recall({
+          query,
+          limit: 10
+        });
+        
+        const endTime = process.hrtime.bigint();
+        const executionTime = Number(endTime - startTime) / 1_000_000;
+        times.push(executionTime);
+        
+      } catch (error) {
+        errors.push(`Search ${i}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+      }
+    }
+
+    const afterMemory = process.memoryUsage();
+    const result = this.calculateBenchmarkResult(
+      'Search Operations',
+      iterations,
+      times,
+      beforeMemory,
+      afterMemory,
+      errors
+    );
+
+    this.results.push(result);
+    this.printResult(result);
+  }
+
+  /**
+   * 캐시 작업 벤치마크
+   */
+  private async benchmarkCacheOperations(): Promise<void> {
+    console.log('\n💾 캐시 작업 벤치마크 시작');
+    
+    const iterations = 1000;
+    const times: number[] = [];
+    const errors: string[] = [];
+    const beforeMemory = process.memoryUsage();
+
+    // 캐시 데이터 준비
+    const testData = Array.from({ length: 100 }, (_, i) => ({
+      id: `test_${i}`,
+      content: `테스트 데이터 ${i}`,
+      score: Math.random()
+    }));
+
+    for (let i = 0; i < iterations; i++) {
+      const startTime = process.hrtime.bigint();
+      
+      try {
+        const query = `test_${i % 10}`;
+        
+        // 캐시에서 가져오기
+        let results = this.searchCache.getSearchResults(query, {}, 10);
+        
+        if (!results) {
+          // 캐시에 없으면 데이터 생성 후 저장
+          results = testData.filter(item => item.content.includes(query));
+          this.searchCache.setSearchResults(query, results, {}, 10);
+        }
+        
+        const endTime = process.hrtime.bigint();
+        const executionTime = Number(endTime - startTime) / 1_000_000;
+        times.push(executionTime);
+        
+      } catch (error) {
+        errors.push(`Cache ${i}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+      }
+    }
+
+    const afterMemory = process.memoryUsage();
+    const result = this.calculateBenchmarkResult(
+      'Cache Operations',
+      iterations,
+      times,
+      beforeMemory,
+      afterMemory,
+      errors
+    );
+
+    this.results.push(result);
+    this.printResult(result);
+  }
+
+  /**
+   * 비동기 작업 벤치마크 - 최적화된 버전
+   */
+  private async benchmarkAsyncOperations(): Promise<void> {
+    console.log('\n⚡ 비동기 작업 벤치마크 시작');
+    
+    const iterations = 50; // 반복 수 조정
+    const times: number[] = [];
+    const errors: string[] = [];
+    const beforeMemory = process.memoryUsage();
+
+    // 워커 풀 크기 증가
+    this.taskQueue = new AsyncTaskQueue(16);
+    this.taskQueue.start();
+
+    const startTime = process.hrtime.bigint();
+    
+    try {
+      // 작업 추가 및 개별 시간 측정
+      const taskPromises = [];
+      for (let i = 0; i < iterations; i++) {
+        const taskStartTime = process.hrtime.bigint();
+        
+        const taskId = this.taskQueue.addTask({
+          type: 'memory_operation',
+          data: { 
+            operation: 'remember',
+            content: `비동기 최적화 테스트 ${i}`,
+            type: 'episodic',
+            tags: ['async', 'optimized'],
+            importance: 0.5
+          },
+          priority: Math.floor(Math.random() * 10),
+          maxRetries: 2,
+          timeout: 3000
+        });
+        
+        const taskPromise = this.waitForTaskCompletion(taskId).then(result => {
+          const taskEndTime = process.hrtime.bigint();
+          const taskTime = Number(taskEndTime - taskStartTime) / 1_000_000;
+          times.push(taskTime);
+          return result;
+        }).catch(error => {
+          errors.push(`Task ${i}: ${error.message}`);
+          return null;
+        });
+        
+        taskPromises.push(taskPromise);
+      }
+
+      // 모든 작업 완료 대기
+      await Promise.allSettled(taskPromises);
+      
+    } catch (error) {
+      errors.push(`Async ${error instanceof Error ? error.message : 'Unknown error'}`);
+    } finally {
+      this.taskQueue.stop();
+    }
+
+    const afterMemory = process.memoryUsage();
+    const result = this.calculateBenchmarkResult(
+      'Async Operations',
+      iterations,
+      times,
+      beforeMemory,
+      afterMemory,
+      errors
+    );
+
+    this.results.push(result);
+    this.printResult(result);
+  }
+
+  /**
+   * 동시 작업 벤치마크 - 오류 해결 버전
+   */
+  private async benchmarkConcurrentOperations(): Promise<void> {
+    console.log('\n🔄 동시 작업 벤치마크 시작');
+    
+    const concurrentUsers = 8; // 동시 사용자 수 감소 (10 → 8)
+    const operationsPerUser = 15; // 사용자당 작업 수 감소 (20 → 15)
+    const times: number[] = [];
+    const errors: string[] = [];
+    const beforeMemory = process.memoryUsage();
+
+    const startTime = process.hrtime.bigint();
+    
+    try {
+      // 동시 사용자 시뮬레이션 - 개선된 버전
+      const userPromises = Array.from({ length: concurrentUsers }, async (_, userIndex) => {
+        const userTimes: number[] = [];
+        
+        for (let i = 0; i < operationsPerUser; i++) {
+          const operationStart = process.hrtime.bigint();
+          
+          try {
+            // 요청 간 지연 시간 추가 (경합 방지)
+            if (i > 0) {
+              await new Promise(resolve => setTimeout(resolve, Math.random() * 10 + 5));
+            }
+            
+            // 랜덤 작업 선택
+            const operation = Math.random();
+            if (operation < 0.4) {
+              // 메모리 저장 - 재시도 로직 추가
+              await this.retryOperation(async () => {
+                return await this.client.remember({
+                  content: `동시 테스트 사용자 ${userIndex} 작업 ${i}`,
+                  type: 'episodic',
+                  tags: ['concurrent', 'test', `user-${userIndex}`],
+                  importance: 0.5
+                });
+              }, 3);
+            } else if (operation < 0.7) {
+              // 검색 - 재시도 로직 추가
+              await this.retryOperation(async () => {
+                return await this.client.recall({
+                  query: `사용자 ${userIndex}`,
+                  limit: 5
+                });
+              }, 3);
+            } else {
+              // 통계 조회 - 재시도 로직 추가
+              await this.retryOperation(async () => {
+                return await this.client.callTool('forgetting_stats', {});
+              }, 3);
+            }
+            
+            const operationEnd = process.hrtime.bigint();
+            const operationTime = Number(operationEnd - operationStart) / 1_000_000;
+            userTimes.push(operationTime);
+            
+          } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            errors.push(`User ${userIndex} Op ${i}: ${errorMessage}`);
+            console.warn(`⚠️ 동시 작업 오류 (User ${userIndex}, Op ${i}): ${errorMessage}`);
+          }
+        }
+        
+        return userTimes;
+      });
+
+      const allUserTimes = await Promise.allSettled(userPromises);
+      
+      // 성공한 사용자들의 시간만 수집
+      allUserTimes.forEach((result, index) => {
+        if (result.status === 'fulfilled') {
+          times.push(...result.value);
+        } else {
+          errors.push(`User ${index} failed: ${result.reason}`);
+        }
+      });
+      
+    } catch (error) {
+      errors.push(`Concurrent ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+
+    const endTime = process.hrtime.bigint();
+    const totalTime = Number(endTime - startTime) / 1_000_000;
+    
+    const afterMemory = process.memoryUsage();
+    const result = this.calculateBenchmarkResult(
+      'Concurrent Operations',
+      concurrentUsers * operationsPerUser,
+      times,
+      beforeMemory,
+      afterMemory,
+      errors,
+      totalTime
+    );
+
+    this.results.push(result);
+    this.printResult(result);
+  }
+
+  /**
+   * 작업 완료 대기
+   */
+  private async waitForTaskCompletion(taskId: string, maxWait: number = 10000): Promise<void> {
+    const startTime = Date.now();
+    
+    while (Date.now() - startTime < maxWait) {
+      const status = this.taskQueue.getTaskStatus(taskId);
+      if (status === 'completed' || status === 'failed') {
+        return;
+      }
+      await new Promise(resolve => setTimeout(resolve, 100));
+    }
+    
+    throw new Error(`Task ${taskId} did not complete within ${maxWait}ms`);
+  }
+
+  /**
+   * 재시도 로직 - 오류 해결을 위한 헬퍼 메서드
+   */
+  private async retryOperation<T>(
+    operation: () => Promise<T>,
+    maxRetries: number = 3,
+    baseDelay: number = 100
+  ): Promise<T> {
+    let lastError: Error;
+    
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      try {
+        return await operation();
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error('Unknown error');
+        
+        if (attempt === maxRetries) {
+          throw lastError;
+        }
+        
+        // 지수 백오프 지연
+        const delay = baseDelay * Math.pow(2, attempt - 1) + Math.random() * 50;
+        await new Promise(resolve => setTimeout(resolve, delay));
+        
+        console.warn(`⚠️ 작업 재시도 ${attempt}/${maxRetries}: ${lastError.message}`);
+      }
+    }
+    
+    throw lastError!;
+  }
+
+  /**
+   * 벤치마크 결과 계산
+   */
+  private calculateBenchmarkResult(
+    testName: string,
+    iterations: number,
+    times: number[],
+    beforeMemory: NodeJS.MemoryUsage,
+    afterMemory: NodeJS.MemoryUsage,
+    errors: string[],
+    totalTime?: number
+  ): BenchmarkResult {
+    const actualIterations = times.length;
+    const successRate = actualIterations / iterations;
+    
+    const totalTimeMs = totalTime || times.reduce((sum, time) => sum + time, 0);
+    const averageTime = times.length > 0 ? times.reduce((sum, time) => sum + time, 0) / times.length : 0;
+    const minTime = times.length > 0 ? Math.min(...times) : 0;
+    const maxTime = times.length > 0 ? Math.max(...times) : 0;
+    const throughput = actualIterations / (totalTimeMs / 1000);
+
+    const delta: NodeJS.MemoryUsage = {
+      rss: afterMemory.rss - beforeMemory.rss,
+      heapTotal: afterMemory.heapTotal - beforeMemory.heapTotal,
+      heapUsed: afterMemory.heapUsed - beforeMemory.heapUsed,
+      external: afterMemory.external - beforeMemory.external,
+      arrayBuffers: afterMemory.arrayBuffers - beforeMemory.arrayBuffers
+    };
+
+    return {
+      testName,
+      iterations: actualIterations,
+      totalTime: totalTimeMs,
+      averageTime,
+      minTime,
+      maxTime,
+      throughput,
+      memoryUsage: {
+        before: beforeMemory,
+        after: afterMemory,
+        delta
+      },
+      successRate,
+      errors
+    };
+  }
+
+  /**
+   * 결과 출력
+   */
+  private printResult(result: BenchmarkResult): void {
+    console.log(`\n📊 ${result.testName} 결과:`);
+    console.log(`   반복: ${result.iterations}회`);
+    console.log(`   총 시간: ${result.totalTime.toFixed(2)}ms`);
+    console.log(`   평균 시간: ${result.averageTime.toFixed(2)}ms`);
+    console.log(`   최소 시간: ${result.minTime.toFixed(2)}ms`);
+    console.log(`   최대 시간: ${result.maxTime.toFixed(2)}ms`);
+    console.log(`   처리량: ${result.throughput.toFixed(2)} ops/sec`);
+    console.log(`   성공률: ${(result.successRate * 100).toFixed(1)}%`);
+    console.log(`   메모리 증가: ${(result.memoryUsage.delta.heapUsed / 1024 / 1024).toFixed(2)} MB`);
+    
+    if (result.errors.length > 0) {
+      console.log(`   오류: ${result.errors.length}개`);
+    }
+  }
+
+  /**
+   * 전체 리포트 생성
+   */
+  private generateReport(): void {
+    console.log('\n📋 성능 벤치마크 리포트');
+    console.log('='.repeat(50));
+    
+    const totalIterations = this.results.reduce((sum, r) => sum + r.iterations, 0);
+    const totalTime = this.results.reduce((sum, r) => sum + r.totalTime, 0);
+    const averageThroughput = this.results.reduce((sum, r) => sum + r.throughput, 0) / this.results.length;
+    const totalErrors = this.results.reduce((sum, r) => sum + r.errors.length, 0);
+
+    console.log(`\n📈 전체 통계:`);
+    console.log(`   총 반복: ${totalIterations.toLocaleString()}회`);
+    console.log(`   총 시간: ${(totalTime / 1000).toFixed(2)}초`);
+    console.log(`   평균 처리량: ${averageThroughput.toFixed(2)} ops/sec`);
+    console.log(`   총 오류: ${totalErrors}개`);
+
+    console.log(`\n🏆 성능 순위:`);
+    const sortedResults = [...this.results].sort((a, b) => b.throughput - a.throughput);
+    sortedResults.forEach((result, index) => {
+      console.log(`   ${index + 1}. ${result.testName}: ${result.throughput.toFixed(2)} ops/sec`);
+    });
+
+    console.log(`\n💾 메모리 사용량:`);
+    this.results.forEach(result => {
+      const memoryDelta = result.memoryUsage.delta.heapUsed / 1024 / 1024;
+      console.log(`   ${result.testName}: ${memoryDelta > 0 ? '+' : ''}${memoryDelta.toFixed(2)} MB`);
+    });
+
+    console.log('\n✅ 벤치마크 완료!');
+  }
+}
+
+// 벤치마크 실행
+if (process.argv[1] && process.argv[1].endsWith('performance-benchmark.ts')) {
+  const benchmark = new PerformanceBenchmark();
+  benchmark.runFullBenchmark()
+    .then(() => {
+      console.log('🎉 성능 벤치마크 완료');
+      process.exit(0);
+    })
+    .catch((error) => {
+      console.error('❌ 벤치마크 실패:', error);
+      process.exit(1);
+    });
+}

package/src/test/test-alerts-direct.ts

@@ -0,0 +1,136 @@
+/**
+ * 성능 알림 시스템 직접 테스트
+ * MCP 서버 없이 직접 성능 알림 서비스를 테스트
+ */
+
+import { PerformanceAlertService, AlertType, AlertLevel } from '../services/performance-alert-service.js';
+import { PerformanceMonitoringIntegration } from '../services/performance-monitoring-integration.js';
+import Database from 'better-sqlite3';
+
+async function testAlertsDirect() {
+  console.log('🚨 성능 알림 시스템 직접 테스트 시작');
+  
+  try {
+    // 데이터베이스 초기화
+    const db = new Database('./data/memory.db');
+    
+    // 성능 알림 서비스 생성
+    const alertService = new PerformanceAlertService('./logs');
+    
+    // 통합 모니터링 서비스 생성
+    const monitoringIntegration = new PerformanceMonitoringIntegration(
+      db,
+      alertService,
+      {
+        enableRealTimeMonitoring: false, // 수동 테스트를 위해 비활성화
+        monitoringInterval: 30000,
+        alertThresholds: {
+          responseTime: { warning: 50, critical: 100 }, // 낮은 임계값으로 설정
+          memoryUsage: { warning: 10, critical: 20 },   // 낮은 임계값으로 설정
+          errorRate: { warning: 1, critical: 5 },
+          throughput: { warning: 50, critical: 10 }
+        }
+      }
+    );
+
+    console.log('✅ 서비스 초기화 완료');
+
+    // 1. 수동으로 성능 메트릭 체크
+    console.log('\n🔍 수동 성능 메트릭 체크:');
+    
+    // 응답시간 알림 테스트
+    console.log('📊 응답시간 알림 테스트 (60ms - WARNING 임계값 초과):');
+    const responseTimeAlerts = alertService.checkPerformanceMetric(
+      AlertType.RESPONSE_TIME,
+      60, // WARNING 임계값(50ms) 초과
+      { component: 'search_engine', operation: 'search' }
+    );
+    console.log(`생성된 알림 수: ${responseTimeAlerts.length}`);
+
+    // 메모리 사용량 알림 테스트
+    console.log('📊 메모리 사용량 알림 테스트 (15MB - WARNING 임계값 초과):');
+    const memoryAlerts = alertService.checkPerformanceMetric(
+      AlertType.MEMORY_USAGE,
+      15, // WARNING 임계값(10MB) 초과
+      { component: 'memory_manager', heapTotal: 100 }
+    );
+    console.log(`생성된 알림 수: ${memoryAlerts.length}`);
+
+    // 에러율 알림 테스트
+    console.log('📊 에러율 알림 테스트 (3% - WARNING 임계값 초과):');
+    const errorRateAlerts = alertService.checkPerformanceMetric(
+      AlertType.ERROR_RATE,
+      3, // WARNING 임계값(1%) 초과
+      { component: 'system', totalOperations: 100 }
+    );
+    console.log(`생성된 알림 수: ${errorRateAlerts.length}`);
+
+    // 2. 알림 통계 조회
+    console.log('\n📈 알림 통계:');
+    const stats = alertService.getAlertStats(1);
+    console.log(JSON.stringify(stats, null, 2));
+
+    // 3. 활성 알림 조회
+    console.log('\n🔍 활성 알림:');
+    const activeAlerts = alertService.getActiveAlerts();
+    console.log(`활성 알림 수: ${activeAlerts.length}`);
+    activeAlerts.forEach((alert, index) => {
+      console.log(`${index + 1}. ${alert.level.toUpperCase()}: ${alert.message}`);
+    });
+
+    // 4. 알림 해결 테스트
+    if (activeAlerts.length > 0) {
+      const firstAlert = activeAlerts[0];
+      if (firstAlert) {
+        console.log(`\n🔧 알림 해결 테스트: ${firstAlert.id}`);
+        
+        const resolved = alertService.resolveAlert(
+          firstAlert.id,
+          'test_user',
+          '테스트용 해결'
+        );
+        
+        if (resolved) {
+          console.log('✅ 알림 해결 성공');
+        } else {
+          console.log('❌ 알림 해결 실패');
+        }
+      }
+    }
+
+    // 5. 해결 후 통계
+    console.log('\n📊 해결 후 통계:');
+    const finalStats = alertService.getAlertStats(1);
+    console.log(JSON.stringify(finalStats, null, 2));
+
+    // 6. 로그 파일 확인
+    console.log('\n📁 로그 파일 확인:');
+    const fs = require('fs');
+    const logDir = './logs';
+    if (fs.existsSync(logDir)) {
+      const files = fs.readdirSync(logDir);
+      console.log(`로그 파일 수: ${files.length}`);
+      files.forEach((file: string) => {
+        console.log(`- ${file}`);
+      });
+    } else {
+      console.log('로그 디렉토리가 존재하지 않습니다.');
+    }
+
+    // 정리
+    alertService.cleanup();
+    db.close();
+    
+    console.log('\n🎉 성능 알림 시스템 직접 테스트 완료');
+    
+  } catch (error) {
+    console.error('❌ 테스트 실패:', error);
+  }
+}
+
+// 직접 실행
+if (import.meta.url === `file://${process.argv[1]}`) {
+  testAlertsDirect().catch(console.error);
+}
+
+export { testAlertsDirect };