autosnippet 3.2.9 → 3.2.11

package/lib/infrastructure/monitoring/ErrorTracker.js

@@ -1,341 +0,0 @@
-/**
- * 错误追踪系统
- * 捕获、记录和分析应用程序错误
- */
-
-import fs from 'node:fs';
-import path from 'node:path';
-import Logger from '../logging/Logger.js';
-
-export class ErrorTracker {
-  constructor(options = {}) {
-    this.config = {
-      logDirectory: options.logDirectory || path.join(process.cwd(), 'logs', 'errors'),
-      maxErrorsInMemory: options.maxErrorsInMemory || 500,
-      enableFileLogging: options.enableFileLogging !== false,
-      enableConsoleLogging: options.enableConsoleLogging !== false,
-      alertThreshold: options.alertThreshold || 10, // 每分钟错误数阈值
-    };
-
-    this.errors = [];
-    this.errorCounts = new Map(); // 错误类型计数
-    this.recentErrors = []; // 最近错误
-    this.criticalErrors = []; // 关键错误
-
-    // 确保日志目录存在
-    if (this.config.enableFileLogging) {
-      this._ensureLogDirectory();
-    }
-
-    // 定期生成错误报告（unref 避免阻止进程退出）
-    this.reportInterval = setInterval(() => this._generateReport(), 60000);
-    if (this.reportInterval.unref) {
-      this.reportInterval.unref();
-    }
-  }
-
-  /**
-   * 确保日志目录存在
-   */
-  _ensureLogDirectory() {
-    try {
-      if (!fs.existsSync(this.config.logDirectory)) {
-        fs.mkdirSync(this.config.logDirectory, { recursive: true });
-      }
-    } catch (error) {
-      Logger.error('创建错误日志目录失败', { error: error.message });
-    }
-  }
-
-  /**
-   * Express 错误处理中间件
-   */
-  errorHandler() {
-    return (err, req, res, next) => {
-      const errorData = {
-        message: err.message,
-        stack: err.stack,
-        type: err.name || 'UnknownError',
-        statusCode: err.statusCode || 500,
-        route: `${req.method} ${req.path}`,
-        method: req.method,
-        path: req.path,
-        query: req.query,
-        ip: req.ip,
-        userAgent: req.get('user-agent'),
-        timestamp: new Date().toISOString(),
-        severity: err.statusCode >= 500 ? 'critical' : 'error',
-      };
-
-      this.trackError(errorData);
-
-      // 发送响应
-      res.status(errorData.statusCode).json({
-        success: false,
-        error: {
-          code: err.code || 'INTERNAL_ERROR',
-          message: err.message,
-          ...(process.env.NODE_ENV === 'development' && { stack: err.stack }),
-        },
-      });
-    };
-  }
-
-  /**
-   * 记录错误
-   */
-  trackError(errorData) {
-    // 添加到内存
-    this.errors.push(errorData);
-    if (this.errors.length > this.config.maxErrorsInMemory) {
-      this.errors.shift();
-    }
-
-    // 最近错误
-    this.recentErrors.unshift(errorData);
-    if (this.recentErrors.length > 50) {
-      this.recentErrors.pop();
-    }
-
-    // 关键错误
-    if (errorData.severity === 'critical') {
-      this.criticalErrors.unshift(errorData);
-      if (this.criticalErrors.length > 100) {
-        this.criticalErrors.pop();
-      }
-    }
-
-    // 错误类型计数
-    const errorType = errorData.type;
-    this.errorCounts.set(errorType, (this.errorCounts.get(errorType) || 0) + 1);
-
-    // 控制台日志
-    if (this.config.enableConsoleLogging) {
-      if (errorData.severity === 'critical') {
-        Logger.error(`🔴 关键错误: ${errorData.message}`, {
-          route: errorData.route,
-          statusCode: errorData.statusCode,
-        });
-      } else {
-        Logger.warn(`⚠️  错误: ${errorData.message}`, {
-          route: errorData.route,
-        });
-      }
-    }
-
-    // 文件日志
-    if (this.config.enableFileLogging) {
-      this._writeToFile(errorData);
-    }
-
-    // 检查是否需要告警
-    this._checkAlertThreshold();
-  }
-
-  /**
-   * 写入文件
-   */
-  _writeToFile(errorData) {
-    try {
-      const date = new Date().toISOString().split('T')[0];
-      const fileName = `errors-${date}.log`;
-      const filePath = path.join(this.config.logDirectory, fileName);
-
-      const logEntry = `${JSON.stringify({
-        ...errorData,
-        _timestamp: Date.now(),
-      })}\n`;
-
-      fs.appendFileSync(filePath, logEntry, 'utf8');
-    } catch (error) {
-      Logger.error('写入错误日志文件失败', { error: error.message });
-    }
-  }
-
-  /**
-   * 检查告警阈值
-   */
-  _checkAlertThreshold() {
-    const oneMinuteAgo = Date.now() - 60000;
-    const recentErrorCount = this.errors.filter(
-      (err) => new Date(err.timestamp).getTime() > oneMinuteAgo
-    ).length;
-
-    if (recentErrorCount >= this.config.alertThreshold) {
-      Logger.error(`🚨 告警: 最近1分钟错误数过高 (${recentErrorCount} 个)`);
-      // 这里可以集成通知服务（邮件、Slack 等）
-    }
-  }
-
-  /**
-   * 生成错误报告
-   */
-  _generateReport() {
-    const now = Date.now();
-    const oneHourAgo = now - 3600000;
-
-    const recentErrorsCount = this.errors.filter(
-      (err) => new Date(err.timestamp).getTime() > oneHourAgo
-    ).length;
-
-    if (recentErrorsCount > 0) {
-      Logger.info('📋 错误报告 (最近1小时)', {
-        totalErrors: recentErrorsCount,
-        criticalErrors: this.criticalErrors.filter(
-          (err) => new Date(err.timestamp).getTime() > oneHourAgo
-        ).length,
-        topErrorTypes: this._getTopErrorTypes(5),
-      });
-    }
-  }
-
-  /**
-   * 获取最常见错误类型
-   */
-  _getTopErrorTypes(limit = 10) {
-    return Array.from(this.errorCounts.entries())
-      .sort((a, b) => b[1] - a[1])
-      .slice(0, limit)
-      .map(([type, count]) => ({ type, count }));
-  }
-
-  /**
-   * 获取错误统计
-   */
-  getStats() {
-    const now = Date.now();
-    const oneHourAgo = now - 3600000;
-    const oneDayAgo = now - 86400000;
-
-    const lastHourErrors = this.errors.filter(
-      (err) => new Date(err.timestamp).getTime() > oneHourAgo
-    );
-
-    const last24HoursErrors = this.errors.filter(
-      (err) => new Date(err.timestamp).getTime() > oneDayAgo
-    );
-
-    return {
-      summary: {
-        totalErrors: this.errors.length,
-        criticalErrors: this.criticalErrors.length,
-        lastHourErrors: lastHourErrors.length,
-        last24HoursErrors: last24HoursErrors.length,
-        uniqueErrorTypes: this.errorCounts.size,
-      },
-      topErrorTypes: this._getTopErrorTypes(10),
-      recentErrors: this.recentErrors.slice(0, 10).map((err) => ({
-        type: err.type,
-        message: err.message,
-        route: err.route,
-        statusCode: err.statusCode,
-        severity: err.severity,
-        timestamp: err.timestamp,
-      })),
-      criticalErrors: this.criticalErrors.slice(0, 10).map((err) => ({
-        type: err.type,
-        message: err.message,
-        route: err.route,
-        timestamp: err.timestamp,
-      })),
-      errorsByRoute: this._getErrorsByRoute(),
-    };
-  }
-
-  /**
-   * 按路由统计错误
-   */
-  _getErrorsByRoute() {
-    const routeErrors = new Map();
-
-    this.errors.forEach((err) => {
-      const route = err.route;
-      routeErrors.set(route, (routeErrors.get(route) || 0) + 1);
-    });
-
-    return Array.from(routeErrors.entries())
-      .sort((a, b) => b[1] - a[1])
-      .slice(0, 10)
-      .map(([route, count]) => ({ route, count }));
-  }
-
-  /**
-   * 清除错误记录
-   */
-  clearErrors() {
-    this.errors = [];
-    this.recentErrors = [];
-    this.criticalErrors = [];
-    this.errorCounts.clear();
-    Logger.info('错误追踪记录已清除');
-  }
-
-  /**
-   * 搜索错误
-   */
-  searchErrors(options = {}) {
-    let results = [...this.errors];
-
-    if (options.type) {
-      results = results.filter((err) => err.type === options.type);
-    }
-
-    if (options.route) {
-      results = results.filter((err) => err.route.includes(options.route));
-    }
-
-    if (options.severity) {
-      results = results.filter((err) => err.severity === options.severity);
-    }
-
-    if (options.startDate) {
-      const startTime = new Date(options.startDate).getTime();
-      results = results.filter((err) => new Date(err.timestamp).getTime() >= startTime);
-    }
-
-    if (options.endDate) {
-      const endTime = new Date(options.endDate).getTime();
-      results = results.filter((err) => new Date(err.timestamp).getTime() <= endTime);
-    }
-
-    return results.slice(0, options.limit || 100);
-  }
-
-  /**
-   * 停止错误追踪
-   */
-  shutdown() {
-    if (this.reportInterval) {
-      clearInterval(this.reportInterval);
-    }
-    Logger.info('错误追踪已停止');
-  }
-}
-
-// 单例实例
-let errorTrackerInstance = null;
-
-/**
- * 初始化错误追踪
- */
-export function initErrorTracker(options) {
-  if (errorTrackerInstance) {
-    return errorTrackerInstance;
-  }
-
-  errorTrackerInstance = new ErrorTracker(options);
-  Logger.info('✅ 错误追踪已启用');
-  return errorTrackerInstance;
-}
-
-/**
- * 获取错误追踪实例
- */
-export function getErrorTracker() {
-  if (!errorTrackerInstance) {
-    throw new Error('错误追踪未初始化，请先调用 initErrorTracker()');
-  }
-  return errorTrackerInstance;
-}
-
-export default ErrorTracker;

package/lib/infrastructure/monitoring/PerformanceMonitor.js

@@ -1,281 +0,0 @@
-/**
- * 性能监控中间件
- * 记录 API 请求的响应时间、吞吐量和错误率
- */
-
-import Logger from '../logging/Logger.js';
-
-export class PerformanceMonitor {
-  constructor() {
-    this.metrics = {
-      requests: {
-        total: 0,
-        success: 0,
-        errors: 0,
-      },
-      endpoints: new Map(), // 各端点统计
-      responseTimes: [], // 最近 1000 个请求的响应时间
-      slowRequests: [], // 慢请求队列（> 1s）
-      errorRate: 0,
-      averageResponseTime: 0,
-      startTime: Date.now(),
-    };
-
-    this.config = {
-      slowRequestThreshold: 1000, // 慢请求阈值（毫秒）
-      maxResponseTimeSamples: 1000, // 保留样本数
-      maxSlowRequests: 100, // 最多保留慢请求数
-    };
-
-    // 定期计算统计数据（unref 避免阻止进程退出）
-    this.statsInterval = setInterval(() => this.calculateStats(), 30000);
-    if (this.statsInterval.unref) {
-      this.statsInterval.unref();
-    }
-  }
-
-  /**
-   * Express 中间件
-   */
-  middleware() {
-    return (req, res, next) => {
-      const startTime = Date.now();
-      const route = `${req.method} ${req.path}`;
-
-      // 响应完成时记录
-      res.on('finish', () => {
-        const duration = Date.now() - startTime;
-        const statusCode = res.statusCode;
-
-        this.recordRequest({
-          route,
-          method: req.method,
-          path: req.path,
-          statusCode,
-          duration,
-          userAgent: req.get('user-agent'),
-          ip: req.ip,
-          timestamp: new Date().toISOString(),
-        });
-      });
-
-      next();
-    };
-  }
-
-  /**
-   * 记录请求
-   */
-  recordRequest(requestData) {
-    const { route, statusCode, duration } = requestData;
-
-    // 总体统计
-    this.metrics.requests.total++;
-    if (statusCode >= 200 && statusCode < 400) {
-      this.metrics.requests.success++;
-    } else if (statusCode >= 400) {
-      this.metrics.requests.errors++;
-    }
-
-    // 端点统计（限制 Map 上限避免内存泄漏）
-    if (!this.metrics.endpoints.has(route)) {
-      if (this.metrics.endpoints.size >= 500) {
-        // 淘汰最少访问的端点
-        let minKey = null,
-          minCount = Infinity;
-        for (const [k, v] of this.metrics.endpoints) {
-          if (v.count < minCount) {
-            minCount = v.count;
-            minKey = k;
-          }
-        }
-        if (minKey) {
-          this.metrics.endpoints.delete(minKey);
-        }
-      }
-      this.metrics.endpoints.set(route, {
-        count: 0,
-        errors: 0,
-        totalDuration: 0,
-        minDuration: Infinity,
-        maxDuration: 0,
-        avgDuration: 0,
-      });
-    }
-
-    const endpointStats = this.metrics.endpoints.get(route);
-    endpointStats.count++;
-    endpointStats.totalDuration += duration;
-    endpointStats.minDuration = Math.min(endpointStats.minDuration, duration);
-    endpointStats.maxDuration = Math.max(endpointStats.maxDuration, duration);
-    endpointStats.avgDuration = endpointStats.totalDuration / endpointStats.count;
-
-    if (statusCode >= 400) {
-      endpointStats.errors++;
-    }
-
-    // 响应时间样本
-    this.metrics.responseTimes.push(duration);
-    if (this.metrics.responseTimes.length > this.config.maxResponseTimeSamples) {
-      this.metrics.responseTimes.shift();
-    }
-
-    // 慢请求记录（排除设计上就是长耗时的 long-poll 端点）
-    const isLongPoll = route.includes('/remote/wait');
-    if (duration > this.config.slowRequestThreshold && !isLongPoll) {
-      this.metrics.slowRequests.push({
-        ...requestData,
-        duration,
-      });
-
-      if (this.metrics.slowRequests.length > this.config.maxSlowRequests) {
-        this.metrics.slowRequests.shift();
-      }
-
-      Logger.warn(`🐢 慢请求: ${route} - ${duration}ms`);
-    }
-  }
-
-  /**
-   * 计算统计数据
-   */
-  calculateStats() {
-    const { total, errors } = this.metrics.requests;
-
-    // 错误率
-    this.metrics.errorRate = total > 0 ? ((errors / total) * 100).toFixed(2) : 0;
-
-    // 平均响应时间
-    if (this.metrics.responseTimes.length > 0) {
-      const sum = this.metrics.responseTimes.reduce((acc, val) => acc + val, 0);
-      this.metrics.averageResponseTime = Math.round(sum / this.metrics.responseTimes.length);
-    }
-
-    // 每分钟请求数 (RPM)
-    const uptime = (Date.now() - this.metrics.startTime) / 1000 / 60; // 分钟
-    this.metrics.rpm = uptime > 0 ? Math.round(total / uptime) : 0;
-
-    // P95, P99 响应时间
-    if (this.metrics.responseTimes.length > 0) {
-      const sorted = [...this.metrics.responseTimes].sort((a, b) => a - b);
-      const p95Index = Math.floor(sorted.length * 0.95);
-      const p99Index = Math.floor(sorted.length * 0.99);
-
-      this.metrics.p95 = sorted[p95Index] || 0;
-      this.metrics.p99 = sorted[p99Index] || 0;
-    }
-
-    Logger.info('📊 性能统计已更新', {
-      requests: total,
-      errors,
-      errorRate: `${this.metrics.errorRate}%`,
-      avgResponseTime: `${this.metrics.averageResponseTime}ms`,
-      rpm: this.metrics.rpm,
-    });
-  }
-
-  /**
-   * 获取统计信息
-   */
-  getStats() {
-    this.calculateStats(); // 实时计算
-
-    const topEndpoints = Array.from(this.metrics.endpoints.entries())
-      .sort((a, b) => b[1].count - a[1].count)
-      .slice(0, 10)
-      .map(([route, stats]) => ({
-        route,
-        ...stats,
-        avgDuration: Math.round(stats.avgDuration),
-      }));
-
-    const slowestEndpoints = Array.from(this.metrics.endpoints.entries())
-      .sort((a, b) => b[1].avgDuration - a[1].avgDuration)
-      .slice(0, 10)
-      .map(([route, stats]) => ({
-        route,
-        avgDuration: Math.round(stats.avgDuration),
-        count: stats.count,
-      }));
-
-    return {
-      summary: {
-        totalRequests: this.metrics.requests.total,
-        successfulRequests: this.metrics.requests.success,
-        failedRequests: this.metrics.requests.errors,
-        errorRate: `${this.metrics.errorRate}%`,
-        averageResponseTime: `${this.metrics.averageResponseTime}ms`,
-        requestsPerMinute: this.metrics.rpm,
-        p95ResponseTime: `${this.metrics.p95 || 0}ms`,
-        p99ResponseTime: `${this.metrics.p99 || 0}ms`,
-        uptime: Math.round((Date.now() - this.metrics.startTime) / 1000), // 秒
-      },
-      topEndpoints,
-      slowestEndpoints,
-      recentSlowRequests: this.metrics.slowRequests.slice(-10).map((req) => ({
-        route: req.route,
-        duration: `${req.duration}ms`,
-        timestamp: req.timestamp,
-        statusCode: req.statusCode,
-      })),
-    };
-  }
-
-  /**
-   * 重置统计
-   */
-  reset() {
-    this.metrics = {
-      requests: {
-        total: 0,
-        success: 0,
-        errors: 0,
-      },
-      endpoints: new Map(),
-      responseTimes: [],
-      slowRequests: [],
-      errorRate: 0,
-      averageResponseTime: 0,
-      startTime: Date.now(),
-    };
-    Logger.info('性能监控统计已重置');
-  }
-
-  /**
-   * 停止监控
-   */
-  shutdown() {
-    if (this.statsInterval) {
-      clearInterval(this.statsInterval);
-    }
-    Logger.info('性能监控已停止');
-  }
-}
-
-// 单例实例
-let performanceMonitorInstance = null;
-
-/**
- * 初始化性能监控
- */
-export function initPerformanceMonitor() {
-  if (performanceMonitorInstance) {
-    return performanceMonitorInstance;
-  }
-
-  performanceMonitorInstance = new PerformanceMonitor();
-  Logger.info('✅ 性能监控已启用');
-  return performanceMonitorInstance;
-}
-
-/**
- * 获取性能监控实例
- */
-export function getPerformanceMonitor() {
-  if (!performanceMonitorInstance) {
-    throw new Error('性能监控未初始化，请先调用 initPerformanceMonitor()');
-  }
-  return performanceMonitorInstance;
-}
-
-export default PerformanceMonitor;