memento-mcp-server 0.1.0

package/src/services/performance-monitoring-integration.ts.bak

@@ -0,0 +1,276 @@
+/**
+ * 성능 모니터링 통합 서비스
+ * 기존 성능 모니터와 알림 서비스를 통합하여 실시간 모니터링 제공
+ */
+
+import { PerformanceMonitor } from './performance-monitor.js';
+import { PerformanceAlertService, AlertType, AlertLevel } from './performance-alert-service.js';
+import Database from 'better-sqlite3';
+
+export interface MonitoringConfig {
+  enableRealTimeMonitoring: boolean;
+  monitoringInterval: number; // 밀리초
+  alertThresholds: {
+    responseTime: { warning: number; critical: number };
+    memoryUsage: { warning: number; critical: number };
+    errorRate: { warning: number; critical: number };
+    throughput: { warning: number; critical: number };
+  };
+}
+
+export class PerformanceMonitoringIntegration {
+  private performanceMonitor: PerformanceMonitor;
+  private alertService: PerformanceAlertService;
+  private config: MonitoringConfig;
+  private monitoringInterval: NodeJS.Timeout | null = null;
+  private isMonitoring: boolean = false;
+
+  constructor(
+    db: Database.Database,
+    alertService: PerformanceAlertService,
+    config: MonitoringConfig
+  ) {
+    this.performanceMonitor = new PerformanceMonitor();
+    this.performanceMonitor.initialize(db);
+    this.alertService = alertService;
+    this.config = config;
+  }
+
+  /**
+   * 실시간 모니터링 시작
+   */
+  startRealTimeMonitoring(): void {
+    if (this.isMonitoring) {
+      console.warn('⚠️ 실시간 모니터링이 이미 실행 중입니다');
+      return;
+    }
+
+    if (!this.config.enableRealTimeMonitoring) {
+      console.log('ℹ️ 실시간 모니터링이 비활성화되어 있습니다');
+      return;
+    }
+
+    this.isMonitoring = true;
+    console.log('🚀 실시간 성능 모니터링 시작');
+
+    this.monitoringInterval = setInterval(async () => {
+      await this.performMonitoringCycle();
+    }, this.config.monitoringInterval);
+  }
+
+  /**
+   * 실시간 모니터링 중지
+   */
+  stopRealTimeMonitoring(): void {
+    if (this.monitoringInterval) {
+      clearInterval(this.monitoringInterval);
+      this.monitoringInterval = null;
+    }
+    this.isMonitoring = false;
+    console.log('🛑 실시간 성능 모니터링 중지');
+  }
+
+  /**
+   * 모니터링 사이클 실행
+   */
+  private async performMonitoringCycle(): Promise<void> {
+    try {
+      const metrics = await this.performanceMonitor.collectMetrics();
+      
+      // 응답시간 체크
+      if (metrics.search.averageSearchTime > 0) {
+        this.alertService.checkPerformanceMetric(
+          AlertType.RESPONSE_TIME,
+          metrics.search.averageSearchTime,
+          {
+            component: 'search_engine',
+            operation: 'search',
+            totalSearches: metrics.search.totalSearches
+          }
+        );
+      }
+
+      // 메모리 사용량 체크
+      const memoryUsageMB = metrics.memory.heapUsed / 1024 / 1024;
+      this.alertService.checkPerformanceMetric(
+        AlertType.MEMORY_USAGE,
+        memoryUsageMB,
+        {
+          component: 'memory_manager',
+          heapTotal: metrics.memory.heapTotal,
+          rss: metrics.memory.rss
+        }
+      );
+
+      // 에러율 체크 (간접적으로)
+      const errorRate = this.calculateErrorRate(metrics);
+      if (errorRate > 0) {
+        this.alertService.checkPerformanceMetric(
+          AlertType.ERROR_RATE,
+          errorRate,
+          {
+            component: 'system',
+            totalOperations: metrics.database.totalMemories + metrics.search.totalSearches
+          }
+        );
+      }
+
+      // 처리량 체크
+      const throughput = this.calculateThroughput(metrics);
+      if (throughput > 0) {
+        this.alertService.checkPerformanceMetric(
+          AlertType.THROUGHPUT,
+          throughput,
+          {
+            component: 'system',
+            totalOperations: metrics.database.totalMemories + metrics.search.totalSearches
+          }
+        );
+      }
+
+      // 데이터베이스 성능 체크
+      if (metrics.database.queryPerformance.averageQueryTime > 0) {
+        this.alertService.checkPerformanceMetric(
+          AlertType.DATABASE_PERFORMANCE,
+          metrics.database.queryPerformance.averageQueryTime,
+          {
+            component: 'database',
+            operation: 'query',
+            totalMemories: metrics.database.totalMemories
+          }
+        );
+      }
+
+      // 캐시 성능 체크
+      if (metrics.search.cacheHitRate > 0) {
+        this.alertService.checkPerformanceMetric(
+          AlertType.CACHE_PERFORMANCE,
+          metrics.search.cacheHitRate * 100, // 백분율로 변환
+          {
+            component: 'cache',
+            operation: 'search',
+            totalSearches: metrics.search.totalSearches
+          }
+        );
+      }
+
+    } catch (error) {
+      console.error('❌ 모니터링 사이클 실행 중 오류:', error);
+    }
+  }
+
+  /**
+   * 에러율 계산 (간접적)
+   */
+  private calculateErrorRate(metrics: any): number {
+    // 실제 에러율 계산 로직 (현재는 간단한 추정)
+    const totalOperations = metrics.database.totalMemories + metrics.search.totalSearches;
+    if (totalOperations === 0) return 0;
+    
+    // 느린 쿼리 비율을 에러율로 간접 추정
+    const slowQueries = metrics.database.queryPerformance.slowQueries.length;
+    return (slowQueries / totalOperations) * 100;
+  }
+
+  /**
+   * 처리량 계산
+   */
+  private calculateThroughput(metrics: any): number {
+    const totalOperations = metrics.database.totalMemories + metrics.search.totalSearches;
+    const uptimeSeconds = metrics.system.uptime / 1000;
+    
+    if (uptimeSeconds === 0) return 0;
+    
+    return totalOperations / uptimeSeconds; // ops/sec
+  }
+
+  /**
+   * 수동 성능 체크
+   */
+  async performManualCheck(): Promise<void> {
+    console.log('🔍 수동 성능 체크 실행');
+    await this.performMonitoringCycle();
+  }
+
+  /**
+   * 알림 임계값 업데이트
+   */
+  updateAlertThresholds(thresholds: Partial<MonitoringConfig['alertThresholds']>): void {
+    if (thresholds.responseTime) {
+      this.alertService.updateThreshold(
+        AlertType.RESPONSE_TIME,
+        AlertLevel.WARNING,
+        { threshold: thresholds.responseTime.warning, operator: 'gt' }
+      );
+      this.alertService.updateThreshold(
+        AlertType.RESPONSE_TIME,
+        AlertLevel.CRITICAL,
+        { threshold: thresholds.responseTime.critical, operator: 'gt' }
+      );
+    }
+
+    if (thresholds.memoryUsage) {
+      this.alertService.updateThreshold(
+        AlertType.MEMORY_USAGE,
+        AlertLevel.WARNING,
+        { threshold: thresholds.memoryUsage.warning, operator: 'gt' }
+      );
+      this.alertService.updateThreshold(
+        AlertType.MEMORY_USAGE,
+        AlertLevel.CRITICAL,
+        { threshold: thresholds.memoryUsage.critical, operator: 'gt' }
+      );
+    }
+
+    if (thresholds.errorRate) {
+      this.alertService.updateThreshold(
+        AlertType.ERROR_RATE,
+        AlertLevel.WARNING,
+        { threshold: thresholds.errorRate.warning, operator: 'gt' }
+      );
+      this.alertService.updateThreshold(
+        AlertType.ERROR_RATE,
+        AlertLevel.CRITICAL,
+        { threshold: thresholds.errorRate.critical, operator: 'gt' }
+      );
+    }
+
+    if (thresholds.throughput) {
+      this.alertService.updateThreshold(
+        AlertType.THROUGHPUT,
+        AlertLevel.WARNING,
+        { threshold: thresholds.throughput.warning, operator: 'lt' }
+      );
+      this.alertService.updateThreshold(
+        AlertType.THROUGHPUT,
+        AlertLevel.CRITICAL,
+        { threshold: thresholds.throughput.critical, operator: 'lt' }
+      );
+    }
+
+    console.log('✅ 알림 임계값 업데이트 완료');
+  }
+
+  /**
+   * 모니터링 상태 확인
+   */
+  getMonitoringStatus(): {
+    isMonitoring: boolean;
+    config: MonitoringConfig;
+    alertService: PerformanceAlertService;
+  } {
+    return {
+      isMonitoring: this.isMonitoring,
+      config: this.config,
+      alertService: this.alertService
+    };
+  }
+
+  /**
+   * 서비스 정리
+   */
+  cleanup(): void {
+    this.stopRealTimeMonitoring();
+    this.alertService.cleanup();
+  }
+}

package/src/services/unified-embedding-service.spec.ts

@@ -0,0 +1,224 @@
+/**
+ * 통합 임베딩 서비스 테스트
+ * TDD 방식으로 구현
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { UnifiedEmbeddingService } from './unified-embedding-service.js';
+import { EmbeddingProviderFactory } from './embedding-provider-factory.js';
+import type { EmbeddingServiceInterface, EmbeddingResult, SimilarityResult, EmbeddingData } from '../types/embedding.types.js';
+
+// 팩토리 모킹
+const mockFactory = {
+  getProvider: vi.fn(),
+  getAvailableProviders: vi.fn(),
+  selectProvider: vi.fn()
+};
+
+vi.mock('./embedding-provider-factory.js', () => ({
+  EmbeddingProviderFactory: {
+    getInstance: vi.fn(() => mockFactory)
+  }
+}));
+
+// Mock 제공자 클래스
+class MockEmbeddingService implements EmbeddingServiceInterface {
+  constructor(private available: boolean = true, private shouldFail: boolean = false) {}
+
+  async generateEmbedding(text: string): Promise<EmbeddingResult | null> {
+    if (this.shouldFail) {
+      throw new Error('Mock service failed');
+    }
+    return {
+      embedding: [0.1, 0.2, 0.3],
+      model: 'mock-model',
+      usage: { prompt_tokens: 10, total_tokens: 10 }
+    };
+  }
+
+  async searchSimilar(query: string, embeddings: EmbeddingData[], limit?: number, threshold?: number): Promise<SimilarityResult[]> {
+    if (this.shouldFail) {
+      throw new Error('Mock service failed');
+    }
+    return [
+      { id: '1', content: 'test', similarity: 0.8, score: 0.8 }
+    ];
+  }
+
+  isAvailable(): boolean {
+    return this.available;
+  }
+
+  getModelInfo() {
+    return { model: 'mock-model', dimensions: 384, maxTokens: 256 };
+  }
+}
+
+describe('UnifiedEmbeddingService', () => {
+  let service: UnifiedEmbeddingService;
+  let mockProvider: MockEmbeddingService;
+
+  beforeEach(() => {
+    mockProvider = new MockEmbeddingService();
+    
+    // 팩토리 모킹 설정
+    mockFactory.getProvider.mockReturnValue(mockProvider);
+    mockFactory.getAvailableProviders.mockReturnValue([
+      { name: 'minilm', available: true, priority: 1, cost: 'free', performance: 'high' },
+      { name: 'openai', available: true, priority: 2, cost: 'paid', performance: 'high' },
+      { name: 'gemini', available: true, priority: 3, cost: 'paid', performance: 'high' },
+      { name: 'tfidf', available: true, priority: 4, cost: 'free', performance: 'low' }
+    ]);
+    mockFactory.selectProvider.mockReturnValue(mockProvider);
+    
+    service = new UnifiedEmbeddingService();
+  });
+
+  describe('생성자', () => {
+    it('서비스가 올바르게 초기화되어야 한다', () => {
+      expect(service).toBeDefined();
+      expect(EmbeddingProviderFactory.getInstance).toHaveBeenCalled();
+    });
+  });
+
+  describe('generateEmbedding', () => {
+    it('빈 텍스트에 대해 에러를 던져야 한다', async () => {
+      await expect(service.generateEmbedding('')).rejects.toThrow('텍스트가 비어있습니다');
+      await expect(service.generateEmbedding('   ')).rejects.toThrow('텍스트가 비어있습니다');
+    });
+
+    it('유효한 텍스트에 대해 임베딩을 생성해야 한다', async () => {
+      const mockProvider = new MockEmbeddingService();
+      mockFactory.selectProvider.mockReturnValue(mockProvider);
+
+      const result = await service.generateEmbedding('테스트 텍스트');
+      
+      expect(result).toBeDefined();
+      expect(result?.embedding).toEqual([0.1, 0.2, 0.3]);
+      expect(result?.model).toBe('mock-model');
+    });
+
+    it('제공자 실패 시 폴백을 시도해야 한다', async () => {
+      const failingProvider = new MockEmbeddingService(true, true);
+      const fallbackProvider = new MockEmbeddingService();
+      
+      mockFactory.selectProvider.mockReturnValue(failingProvider);
+      mockFactory.getProvider
+        .mockReturnValueOnce(failingProvider) // 첫 번째 시도
+        .mockReturnValueOnce(fallbackProvider); // 폴백 시도
+
+      const result = await service.generateEmbedding('테스트 텍스트');
+      
+      expect(result).toBeDefined();
+      expect(result?.model).toBe('mock-model');
+    });
+
+    it('모든 제공자 실패 시 에러를 던져야 한다', async () => {
+      const failingProvider = new MockEmbeddingService(true, true);
+      mockFactory.selectProvider.mockReturnValue(failingProvider);
+      mockFactory.getProvider.mockReturnValue(failingProvider);
+
+      await expect(service.generateEmbedding('테스트 텍스트')).rejects.toThrow('모든 임베딩 제공자 실패');
+    });
+  });
+
+  describe('searchSimilar', () => {
+    const mockEmbeddings: EmbeddingData[] = [
+      { id: '1', content: '테스트 내용', embedding: [0.1, 0.2, 0.3] }
+    ];
+
+    it('빈 쿼리에 대해 에러를 던져야 한다', async () => {
+      await expect(service.searchSimilar('', mockEmbeddings)).rejects.toThrow('텍스트가 비어있습니다');
+    });
+
+    it('유효한 쿼리에 대해 검색 결과를 반환해야 한다', async () => {
+      const mockProvider = new MockEmbeddingService();
+      mockFactory.selectProvider.mockReturnValue(mockProvider);
+
+      const results = await service.searchSimilar('쿼리', mockEmbeddings);
+      
+      expect(results).toHaveLength(1);
+      expect(results[0].id).toBe('1');
+      expect(results[0].similarity).toBe(0.8);
+    });
+
+    it('제공자 실패 시 폴백을 시도해야 한다', async () => {
+      const failingProvider = new MockEmbeddingService(true, true);
+      const fallbackProvider = new MockEmbeddingService();
+      
+      mockFactory.selectProvider.mockReturnValue(failingProvider);
+      mockFactory.getProvider
+        .mockReturnValueOnce(failingProvider)
+        .mockReturnValueOnce(fallbackProvider);
+
+      const results = await service.searchSimilar('쿼리', mockEmbeddings);
+      
+      expect(results).toHaveLength(1);
+    });
+  });
+
+  describe('isAvailable', () => {
+    it('사용 가능한 제공자가 있으면 true를 반환해야 한다', () => {
+      mockFactory.getAvailableProviders.mockReturnValue([
+        { name: 'minilm', available: true },
+        { name: 'tfidf', available: false }
+      ]);
+
+      expect(service.isAvailable()).toBe(true);
+    });
+
+    it('사용 가능한 제공자가 없으면 false를 반환해야 한다', () => {
+      mockFactory.getAvailableProviders.mockReturnValue([
+        { name: 'minilm', available: false },
+        { name: 'tfidf', available: false }
+      ]);
+
+      expect(service.isAvailable()).toBe(false);
+    });
+  });
+
+  describe('getModelInfo', () => {
+    it('현재 제공자가 있으면 해당 정보를 반환해야 한다', () => {
+      const mockProvider = new MockEmbeddingService();
+      mockFactory.selectProvider.mockReturnValue(mockProvider);
+      
+      // 임베딩 생성으로 현재 제공자 설정
+      service.generateEmbedding('test');
+      
+      const info = service.getModelInfo();
+      expect(info.model).toBe('mock-model');
+      expect(info.dimensions).toBe(384);
+    });
+
+    it('현재 제공자가 없으면 기본값을 반환해야 한다', () => {
+      const info = service.getModelInfo();
+      expect(info.model).toBe('unified-embedding');
+      expect(info.dimensions).toBe(384);
+    });
+  });
+
+  describe('getCurrentProviderName', () => {
+    it('현재 제공자 이름을 반환해야 한다', () => {
+      const mockProvider = new MockEmbeddingService();
+      mockFactory.selectProvider.mockReturnValue(mockProvider);
+      mockFactory.getAvailableProviders.mockReturnValue([
+        { name: 'minilm', available: true }
+      ]);
+      mockFactory.getProvider.mockReturnValue(mockProvider);
+      
+      service.generateEmbedding('test');
+      
+      expect(service.getCurrentProviderName()).toBe('minilm');
+    });
+  });
+
+  describe('setFallbackProviders', () => {
+    it('폴백 제공자를 설정해야 한다', () => {
+      const newFallbacks = ['tfidf', 'minilm'];
+      service.setFallbackProviders(newFallbacks);
+      
+      // 내부 상태 확인은 어려우므로, 에러 없이 실행되는지 확인
+      expect(() => service.setFallbackProviders(newFallbacks)).not.toThrow();
+    });
+  });
+});