📚 第十六章：性能优化与监控

16.1 性能架构概览

性能优化与监控是低代码平台稳定运行的关键保障。本章将介绍如何构建高性能的低代码平台，并实现全面的性能监控体系。

// 性能管理器接口
interface PerformanceManager {
  // 性能监控
  startMonitoring(): Promise<void>;
  stopMonitoring(): Promise<void>;
  getMetrics(query: MetricsQuery): Promise<PerformanceMetrics[]>;
  
  // 性能优化
  optimizeQuery(query: any): Promise<OptimizedQuery>;
  optimizeCache(config: CacheConfig): Promise<CacheOptimization>;
  optimizeMemory(): Promise<MemoryOptimization>;
  
  // 性能分析
  analyzePerformance(timeRange: TimeRange): Promise<PerformanceAnalysis>;
  generateReport(config: ReportConfig): Promise<PerformanceReport>;
  
  // 告警管理
  createAlert(alert: CreateAlertRequest): Promise<PerformanceAlert>;
  getAlerts(query: AlertQuery): Promise<PerformanceAlert[]>;
  updateAlert(alertId: string, update: UpdateAlertRequest): Promise<PerformanceAlert>;
  deleteAlert(alertId: string): Promise<void>;
}

// 性能管理器实现
class LowCodePerformanceManager implements PerformanceManager {
  private metricsCollector: MetricsCollector;
  private cacheManager: CacheManager;
  private queryOptimizer: QueryOptimizer;
  private memoryManager: MemoryManager;
  private alertManager: AlertManager;
  private reportGenerator: ReportGenerator;
  private isMonitoring: boolean = false;
  
  constructor(
    metricsCollector: MetricsCollector,
    cacheManager: CacheManager,
    queryOptimizer: QueryOptimizer,
    memoryManager: MemoryManager,
    alertManager: AlertManager,
    reportGenerator: ReportGenerator
  ) {
    this.metricsCollector = metricsCollector;
    this.cacheManager = cacheManager;
    this.queryOptimizer = queryOptimizer;
    this.memoryManager = memoryManager;
    this.alertManager = alertManager;
    this.reportGenerator = reportGenerator;
  }
  
  async startMonitoring(): Promise<void> {
    if (this.isMonitoring) {
      throw new Error('Monitoring is already running');
    }
    
    await this.metricsCollector.start();
    await this.alertManager.start();
    this.isMonitoring = true;
    
    console.log('Performance monitoring started');
  }
  
  async stopMonitoring(): Promise<void> {
    if (!this.isMonitoring) {
      throw new Error('Monitoring is not running');
    }
    
    await this.metricsCollector.stop();
    await this.alertManager.stop();
    this.isMonitoring = false;
    
    console.log('Performance monitoring stopped');
  }
  
  async getMetrics(query: MetricsQuery): Promise<PerformanceMetrics[]> {
    return await this.metricsCollector.getMetrics(query);
  }
  
  async optimizeQuery(query: any): Promise<OptimizedQuery> {
    return await this.queryOptimizer.optimize(query);
  }
  
  async optimizeCache(config: CacheConfig): Promise<CacheOptimization> {
    return await this.cacheManager.optimize(config);
  }
  
  async optimizeMemory(): Promise<MemoryOptimization> {
    return await this.memoryManager.optimize();
  }
  
  async analyzePerformance(timeRange: TimeRange): Promise<PerformanceAnalysis> {
    const metrics = await this.metricsCollector.getMetrics({
      startTime: timeRange.start,
      endTime: timeRange.end
    });
    
    return this.analyzeMetrics(metrics);
  }
  
  async generateReport(config: ReportConfig): Promise<PerformanceReport> {
    return await this.reportGenerator.generate(config);
  }
  
  async createAlert(alert: CreateAlertRequest): Promise<PerformanceAlert> {
    return await this.alertManager.createAlert(alert);
  }
  
  async getAlerts(query: AlertQuery): Promise<PerformanceAlert[]> {
    return await this.alertManager.getAlerts(query);
  }
  
  async updateAlert(alertId: string, update: UpdateAlertRequest): Promise<PerformanceAlert> {
    return await this.alertManager.updateAlert(alertId, update);
  }
  
  async deleteAlert(alertId: string): Promise<void> {
    await this.alertManager.deleteAlert(alertId);
  }
  
  private analyzeMetrics(metrics: PerformanceMetrics[]): PerformanceAnalysis {
    // 实现性能分析逻辑
    const analysis: PerformanceAnalysis = {
      summary: this.generateSummary(metrics),
      trends: this.analyzeTrends(metrics),
      bottlenecks: this.identifyBottlenecks(metrics),
      recommendations: this.generateRecommendations(metrics)
    };
    
    return analysis;
  }
  
  private generateSummary(metrics: PerformanceMetrics[]): PerformanceSummary {
    // 生成性能摘要
    return {
      totalRequests: metrics.reduce((sum, m) => sum + (m.requestCount || 0), 0),
      averageResponseTime: this.calculateAverage(metrics.map(m => m.responseTime || 0)),
      errorRate: this.calculateErrorRate(metrics),
      throughput: this.calculateThroughput(metrics)
    };
  }
  
  private analyzeTrends(metrics: PerformanceMetrics[]): PerformanceTrend[] {
    // 分析性能趋势
    return [
      {
        metric: 'responseTime',
        trend: this.calculateTrend(metrics.map(m => m.responseTime || 0)),
        direction: 'increasing'
      }
    ];
  }
  
  private identifyBottlenecks(metrics: PerformanceMetrics[]): PerformanceBottleneck[] {
    // 识别性能瓶颈
    return [
      {
        type: 'database',
        severity: 'high',
        description: 'Database query performance degradation detected',
        impact: 'High response times for data-intensive operations'
      }
    ];
  }
  
  private generateRecommendations(metrics: PerformanceMetrics[]): PerformanceRecommendation[] {
    // 生成优化建议
    return [
      {
        type: 'caching',
        priority: 'high',
        description: 'Implement query result caching',
        expectedImprovement: '30-50% reduction in response time'
      }
    ];
  }
  
  private calculateAverage(values: number[]): number {
    return values.length > 0 ? values.reduce((sum, val) => sum + val, 0) / values.length : 0;
  }
  
  private calculateErrorRate(metrics: PerformanceMetrics[]): number {
    const totalRequests = metrics.reduce((sum, m) => sum + (m.requestCount || 0), 0);
    const totalErrors = metrics.reduce((sum, m) => sum + (m.errorCount || 0), 0);
    return totalRequests > 0 ? (totalErrors / totalRequests) * 100 : 0;
  }
  
  private calculateThroughput(metrics: PerformanceMetrics[]): number {
    // 计算吞吐量（请求/秒）
    return metrics.reduce((sum, m) => sum + (m.requestCount || 0), 0) / metrics.length;
  }
  
  private calculateTrend(values: number[]): number {
    // 简单的线性趋势计算
    if (values.length < 2) return 0;
    
    const n = values.length;
    const sumX = (n * (n - 1)) / 2;
    const sumY = values.reduce((sum, val) => sum + val, 0);
    const sumXY = values.reduce((sum, val, index) => sum + val * index, 0);
    const sumX2 = values.reduce((sum, _, index) => sum + index * index, 0);
    
    return (n * sumXY - sumX * sumY) / (n * sumX2 - sumX * sumX);
  }
}

16.9 使用示例

// 性能优化与监控完整示例
class LowCodePerformanceDemo {
  private performanceManager: PerformanceManager;
  private metricsCollector: MetricsCollector;
  private queryOptimizer: QueryOptimizer;
  private cacheManager: CacheManager;
  private memoryManager: MemoryManager;
  private alertManager: AlertManager;
  private reportGenerator: ReportGenerator;
  
  constructor() {
    // 初始化组件
    this.metricsCollector = new ComprehensiveMetricsCollector();
    this.queryOptimizer = new LowCodeQueryOptimizer();
    this.cacheManager = new LowCodeCacheManager();
    this.memoryManager = new LowCodeMemoryManager();
    
    const notificationService = new EmailNotificationService(new MockEmailService());
    this.alertManager = new LowCodeAlertManager(this.metricsCollector, notificationService);
    
    const templateEngine = new SimpleTemplateEngine();
    this.reportGenerator = new LowCodeReportGenerator(this.metricsCollector, templateEngine);
    
    this.performanceManager = new LowCodePerformanceManager(
      this.metricsCollector,
      this.queryOptimizer,
      this.cacheManager,
      this.memoryManager,
      this.alertManager,
      this.reportGenerator
    );
  }
  
  async runDemo(): Promise<void> {
    console.log('=== 低代码平台性能优化与监控演示 ===\n');
    
    // 1. 启动性能管理器
    await this.startPerformanceManager();
    
    // 2. 演示指标收集
    await this.demonstrateMetricsCollection();
    
    // 3. 演示查询优化
    await this.demonstrateQueryOptimization();
    
    // 4. 演示缓存管理
    await this.demonstrateCacheManagement();
    
    // 5. 演示内存管理
    await this.demonstrateMemoryManagement();
    
    // 6. 演示告警管理
    await this.demonstrateAlertManagement();
    
    // 7. 演示报告生成
    await this.demonstrateReportGeneration();
    
    // 8. 停止性能管理器
    await this.stopPerformanceManager();
  }
  
  private async startPerformanceManager(): Promise<void> {
    console.log('1. 启动性能管理器');
    
    await this.performanceManager.start();
    
    console.log('✓ 性能管理器已启动\n');
  }
  
  private async demonstrateMetricsCollection(): Promise<void> {
    console.log('2. 指标收集演示');
    
    // 收集系统指标
    await this.metricsCollector.collectMetrics();
    
    // 获取最近的指标
    const metrics = await this.metricsCollector.getMetrics({
      startTime: new Date(Date.now() - 60000), // 最近1分钟
      endTime: new Date(),
      limit: 10
    });
    
    console.log(`✓ 收集到 ${metrics.length} 条指标数据`);
    if (metrics.length > 0) {
      const latest = metrics[0];
      console.log(`  - CPU使用率: ${latest.cpuUsage?.toFixed(2)}%`);
      console.log(`  - 内存使用率: ${latest.memoryUsage?.toFixed(2)}%`);
      console.log(`  - 响应时间: ${latest.responseTime?.toFixed(2)}ms`);
    }
    console.log();
  }
  
  private async demonstrateQueryOptimization(): Promise<void> {
    console.log('3. 查询优化演示');
    
    const query: DatabaseQuery = {
      sql: 'SELECT * FROM users WHERE age > 25 AND city = "Beijing" ORDER BY created_at DESC',
      parameters: [],
      database: 'lowcode_db',
      table: 'users'
    };
    
    // 分析查询
    const analysis = await this.queryOptimizer.analyzeQuery(query);
    console.log(`✓ 查询分析完成`);
    console.log(`  - 执行时间: ${analysis.executionTime}ms`);
    console.log(`  - 扫描行数: ${analysis.rowsScanned}`);
    console.log(`  - 瓶颈数量: ${analysis.bottlenecks.length}`);
    
    // 优化查询
    const optimized = await this.queryOptimizer.optimizeQuery(query);
    console.log(`✓ 查询优化完成`);
    console.log(`  - 优化后SQL: ${optimized.sql}`);
    console.log(`  - 预期提升: ${optimized.estimatedImprovement}%`);
    
    // 获取索引建议
    const suggestions = await this.queryOptimizer.suggestIndexes(query);
    console.log(`✓ 索引建议: ${suggestions.length} 个`);
    suggestions.forEach((suggestion, index) => {
      console.log(`  ${index + 1}. ${suggestion.indexName}: ${suggestion.columns.join(', ')}`);
    });
    console.log();
  }
  
  private async demonstrateCacheManagement(): Promise<void> {
    console.log('4. 缓存管理演示');
    
    // 设置缓存
    await this.cacheManager.set('user:123', { id: 123, name: 'John Doe' }, 300);
    await this.cacheManager.set('user:456', { id: 456, name: 'Jane Smith' }, 300);
    
    // 获取缓存
    const user = await this.cacheManager.get('user:123');
    console.log(`✓ 缓存获取: ${user ? JSON.stringify(user) : '未找到'}`);
    
    // 获取缓存统计
    const stats = await this.cacheManager.getStats();
    console.log(`✓ 缓存统计:`);
    console.log(`  - 总大小: ${stats.totalSize} 字节`);
    console.log(`  - 条目数量: ${stats.itemCount}`);
    console.log(`  - 命中率: ${(stats.hitRate * 100).toFixed(2)}%`);
    
    // 优化缓存
    const optimized = await this.cacheManager.optimize();
    console.log(`✓ 缓存优化: 清理了 ${optimized.itemsRemoved} 个过期条目`);
    console.log();
  }
  
  private async demonstrateMemoryManagement(): Promise<void> {
    console.log('5. 内存管理演示');
    
    // 获取内存使用情况
    const usage = await this.memoryManager.getMemoryUsage();
    console.log(`✓ 内存使用情况:`);
    console.log(`  - 已使用: ${(usage.used / 1024 / 1024).toFixed(2)} MB`);
    console.log(`  - 总内存: ${(usage.total / 1024 / 1024).toFixed(2)} MB`);
    console.log(`  - 使用率: ${(usage.percentage * 100).toFixed(2)}%`);
    
    // 检测内存泄漏
    const leaks = await this.memoryManager.detectMemoryLeaks();
    console.log(`✓ 内存泄漏检测: 发现 ${leaks.length} 个潜在问题`);
    leaks.forEach((leak, index) => {
      console.log(`  ${index + 1}. ${leak.type}: ${leak.description}`);
    });
    
    // 优化内存
    const optimization = await this.memoryManager.optimizeMemory();
    console.log(`✓ 内存优化: 释放了 ${(optimization.freedMemory / 1024 / 1024).toFixed(2)} MB`);
    console.log();
  }
  
  private async demonstrateAlertManagement(): Promise<void> {
    console.log('6. 告警管理演示');
    
    // 启动告警管理器
    await this.alertManager.start();
    
    // 创建告警
    const alert = await this.alertManager.createAlert({
      name: 'CPU使用率过高',
      description: 'CPU使用率超过80%时触发告警',
      condition: {
        metric: 'cpu_usage',
        operator: ComparisonOperator.GREATER_THAN,
        threshold: 80,
        duration: 300000 // 5分钟
      },
      severity: AlertSeverity.HIGH
    });
    
    console.log(`✓ 创建告警: ${alert.name} (ID: ${alert.id})`);
    
    // 获取告警列表
    const alerts = await this.alertManager.getAlerts({
      status: AlertStatus.ACTIVE,
      limit: 10
    });
    
    console.log(`✓ 活跃告警: ${alerts.length} 个`);
    
    // 检查告警条件
    await this.alertManager.checkAlerts();
    console.log(`✓ 告警检查完成`);
    
    // 停止告警管理器
    await this.alertManager.stop();
    console.log();
  }
  
  private async demonstrateReportGeneration(): Promise<void> {
    console.log('7. 报告生成演示');
    
    const reportConfig: ReportConfig = {
      title: '性能监控报告',
      timeRange: {
        start: new Date(Date.now() - 3600000), // 最近1小时
        end: new Date()
      },
      format: ReportFormat.HTML,
      sections: [
        {
          title: '系统概览',
          type: SectionType.SUMMARY,
          metrics: ['cpu_usage', 'memory_usage', 'response_time']
        },
        {
          title: '性能趋势',
          type: SectionType.CHART,
          metrics: ['cpu_usage', 'memory_usage'],
          chartType: ChartType.LINE
        },
        {
          title: '详细数据',
          type: SectionType.TABLE,
          metrics: ['cpu_usage', 'memory_usage', 'response_time', 'request_count']
        }
      ]
    };
    
    // 生成报告
    const report = await this.reportGenerator.generate(reportConfig);
    console.log(`✓ 生成报告: ${report.title} (ID: ${report.id})`);
    console.log(`  - 时间范围: ${report.timeRange.start.toISOString()} - ${report.timeRange.end.toISOString()}`);
    console.log(`  - 章节数量: ${report.sections.length}`);
    
    // 生成HTML格式
    const html = await this.reportGenerator.generateHTML(report);
    console.log(`✓ HTML报告生成完成 (${html.length} 字符)`);
    
    // 生成CSV格式
    const csv = await this.reportGenerator.generateCSV(report);
    console.log(`✓ CSV报告生成完成 (${csv.length} 字符)`);
    console.log();
  }
  
  private async stopPerformanceManager(): Promise<void> {
    console.log('8. 停止性能管理器');
    
    await this.performanceManager.stop();
    
    console.log('✓ 性能管理器已停止\n');
  }
}

// 模拟邮件服务
class MockEmailService implements EmailService {
  async send(email: EmailMessage): Promise<void> {
    console.log(`📧 发送邮件: ${email.subject} -> ${email.recipients.join(', ')}`);
  }
}

// 运行演示
async function runPerformanceDemo() {
  const demo = new LowCodePerformanceDemo();
  await demo.runDemo();
}

// 导出演示函数
export { runPerformanceDemo, LowCodePerformanceDemo };

16.10 Web API 集成

// Express.js 集成示例
import express from 'express';
import { LowCodePerformanceManager } from './performance-manager';

const app = express();
app.use(express.json());

// 性能管理器实例
const performanceManager = new LowCodePerformanceManager(
  // ... 初始化参数
);

// 启动性能管理器
app.post('/api/performance/start', async (req, res) => {
  try {
    await performanceManager.start();
    res.json({ success: true, message: '性能管理器已启动' });
  } catch (error) {
    res.status(500).json({ success: false, error: error.message });
  }
});

// 停止性能管理器
app.post('/api/performance/stop', async (req, res) => {
  try {
    await performanceManager.stop();
    res.json({ success: true, message: '性能管理器已停止' });
  } catch (error) {
    res.status(500).json({ success: false, error: error.message });
  }
});

// 获取性能指标
app.get('/api/performance/metrics', async (req, res) => {
  try {
    const { startTime, endTime, limit } = req.query;
    
    const query: MetricsQuery = {
      startTime: startTime ? new Date(startTime as string) : new Date(Date.now() - 3600000),
      endTime: endTime ? new Date(endTime as string) : new Date(),
      limit: limit ? parseInt(limit as string) : 100
    };
    
    const metrics = await performanceManager.getMetrics(query);
    res.json({ success: true, data: metrics });
  } catch (error) {
    res.status(500).json({ success: false, error: error.message });
  }
});

// 分析性能
app.post('/api/performance/analyze', async (req, res) => {
  try {
    const { timeRange, metrics } = req.body;
    
    const analysis = await performanceManager.analyzePerformance({
      timeRange: {
        start: new Date(timeRange.start),
        end: new Date(timeRange.end)
      },
      metrics: metrics || ['cpu_usage', 'memory_usage', 'response_time']
    });
    
    res.json({ success: true, data: analysis });
  } catch (error) {
    res.status(500).json({ success: false, error: error.message });
  }
});

// 优化查询
app.post('/api/performance/optimize-query', async (req, res) => {
  try {
    const { query } = req.body;
    
    const optimized = await performanceManager.optimizeQuery(query);
    res.json({ success: true, data: optimized });
  } catch (error) {
    res.status(500).json({ success: false, error: error.message });
  }
});

// 获取索引建议
app.post('/api/performance/suggest-indexes', async (req, res) => {
  try {
    const { query } = req.body;
    
    const suggestions = await performanceManager.suggestIndexes(query);
    res.json({ success: true, data: suggestions });
  } catch (error) {
    res.status(500).json({ success: false, error: error.message });
  }
});

// 缓存管理
app.get('/api/performance/cache/stats', async (req, res) => {
  try {
    const stats = await performanceManager.getCacheStats();
    res.json({ success: true, data: stats });
  } catch (error) {
    res.status(500).json({ success: false, error: error.message });
  }
});

app.post('/api/performance/cache/optimize', async (req, res) => {
  try {
    const result = await performanceManager.optimizeCache();
    res.json({ success: true, data: result });
  } catch (error) {
    res.status(500).json({ success: false, error: error.message });
  }
});

app.delete('/api/performance/cache/clear', async (req, res) => {
  try {
    await performanceManager.clearCache();
    res.json({ success: true, message: '缓存已清空' });
  } catch (error) {
    res.status(500).json({ success: false, error: error.message });
  }
});

// 内存管理
app.get('/api/performance/memory/usage', async (req, res) => {
  try {
    const usage = await performanceManager.getMemoryUsage();
    res.json({ success: true, data: usage });
  } catch (error) {
    res.status(500).json({ success: false, error: error.message });
  }
});

app.post('/api/performance/memory/optimize', async (req, res) => {
  try {
    const result = await performanceManager.optimizeMemory();
    res.json({ success: true, data: result });
  } catch (error) {
    res.status(500).json({ success: false, error: error.message });
  }
});

app.get('/api/performance/memory/leaks', async (req, res) => {
  try {
    const leaks = await performanceManager.detectMemoryLeaks();
    res.json({ success: true, data: leaks });
  } catch (error) {
    res.status(500).json({ success: false, error: error.message });
  }
});

// 告警管理
app.post('/api/performance/alerts', async (req, res) => {
  try {
    const alert = await performanceManager.createAlert(req.body);
    res.json({ success: true, data: alert });
  } catch (error) {
    res.status(500).json({ success: false, error: error.message });
  }
});

app.get('/api/performance/alerts', async (req, res) => {
  try {
    const { status, severity, limit } = req.query;
    
    const query: AlertQuery = {
      status: status as AlertStatus,
      severity: severity as AlertSeverity,
      limit: limit ? parseInt(limit as string) : undefined
    };
    
    const alerts = await performanceManager.getAlerts(query);
    res.json({ success: true, data: alerts });
  } catch (error) {
    res.status(500).json({ success: false, error: error.message });
  }
});

app.put('/api/performance/alerts/:id', async (req, res) => {
  try {
    const { id } = req.params;
    const alert = await performanceManager.updateAlert(id, req.body);
    res.json({ success: true, data: alert });
  } catch (error) {
    res.status(500).json({ success: false, error: error.message });
  }
});

app.delete('/api/performance/alerts/:id', async (req, res) => {
  try {
    const { id } = req.params;
    await performanceManager.deleteAlert(id);
    res.json({ success: true, message: '告警已删除' });
  } catch (error) {
    res.status(500).json({ success: false, error: error.message });
  }
});

// 报告生成
app.post('/api/performance/reports', async (req, res) => {
  try {
    const report = await performanceManager.generateReport(req.body);
    res.json({ success: true, data: report });
  } catch (error) {
    res.status(500).json({ success: false, error: error.message });
  }
});

app.get('/api/performance/reports/:id/html', async (req, res) => {
  try {
    const { id } = req.params;
    const html = await performanceManager.getReportHTML(id);
    res.setHeader('Content-Type', 'text/html');
    res.send(html);
  } catch (error) {
    res.status(500).json({ success: false, error: error.message });
  }
});

app.get('/api/performance/reports/:id/csv', async (req, res) => {
  try {
    const { id } = req.params;
    const csv = await performanceManager.getReportCSV(id);
    res.setHeader('Content-Type', 'text/csv');
    res.setHeader('Content-Disposition', `attachment; filename="report-${id}.csv"`);
    res.send(csv);
  } catch (error) {
    res.status(500).json({ success: false, error: error.message });
  }
});

// 启动服务器
const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(`性能监控API服务器运行在端口 ${PORT}`);
});

export default app;

16.11 小结

本章详细介绍了低代码平台的性能优化与监控系统，涵盖了以下核心功能：

核心功能

1. 性能监控

   • 实时指标收集
   • 系统资源监控
   • 应用性能监控
   • 业务指标监控
   • 自定义指标支持

2. 查询优化

   • SQL查询分析
   • 性能瓶颈识别
   • 查询重写优化
   • 索引建议生成
   • 成本估算

3. 缓存管理

   • 多级缓存策略
   • 智能驱逐算法
   • 缓存统计分析
   • 自动优化清理
   • 缓存预热

4. 内存管理

   • 内存使用监控
   • 内存泄漏检测
   • 垃圾回收优化
   • 内存阈值管理
   • 自动内存清理

5. 告警管理

   • 灵活的告警条件
   • 多级告警严重性
   • 实时告警检查
   • 多渠道通知
   • 告警生命周期管理

6. 报告生成

   • 多格式报告输出
   • 可配置报告模板
   • 自动报告调度
   • 数据可视化
   • 报告分发

技术特色

1. 全面的性能监控

   • 覆盖系统、应用、业务各层面
   • 支持自定义指标扩展
   • 实时数据收集和分析

2. 智能优化算法

   • 基于机器学习的查询优化
   • 自适应缓存策略
   • 智能内存管理

3. 高可用性设计

   • 分布式架构支持
   • 故障自动恢复
   • 数据持久化保障

4. 易于集成

   • 标准化API接口
   • 插件化架构
   • 多平台支持

5. 可扩展性

   • 模块化设计
   • 水平扩展支持
   • 云原生架构

6. 用户友好

   • 直观的监控界面
   • 丰富的可视化图表
   • 智能告警提醒

通过本章的学习，您已经掌握了如何构建一个完整的性能优化与监控系统，能够为低代码平台提供全方位的性能保障。下一章我们将学习低代码平台的测试与质量保证。

16.2 核心数据结构

// 性能指标
interface PerformanceMetrics {
  id?: string;
  timestamp: Date;
  source: string;
  type: MetricType;
  
  // 请求指标
  requestCount?: number;
  responseTime?: number;
  errorCount?: number;
  
  // 系统指标
  cpuUsage?: number;
  memoryUsage?: number;
  diskUsage?: number;
  networkIO?: number;
  
  // 应用指标
  activeUsers?: number;
  cacheHitRate?: number;
  databaseConnections?: number;
  queueLength?: number;
  
  // 自定义指标
  customMetrics?: Record<string, number>;
  tags?: Record<string, string>;
}

// 指标类型
enum MetricType {
  SYSTEM = 'system',
  APPLICATION = 'application',
  BUSINESS = 'business',
  CUSTOM = 'custom'
}

// 指标查询
interface MetricsQuery {
  startTime?: Date;
  endTime?: Date;
  source?: string;
  type?: MetricType;
  tags?: Record<string, string>;
  aggregation?: AggregationType;
  interval?: string;
  limit?: number;
}

// 聚合类型
enum AggregationType {
  AVG = 'avg',
  SUM = 'sum',
  MIN = 'min',
  MAX = 'max',
  COUNT = 'count',
  PERCENTILE = 'percentile'
}

// 时间范围
interface TimeRange {
  start: Date;
  end: Date;
}

// 优化查询
interface OptimizedQuery {
  originalQuery: any;
  optimizedQuery: any;
  optimizations: QueryOptimization[];
  estimatedImprovement: number;
}

// 查询优化
interface QueryOptimization {
  type: OptimizationType;
  description: string;
  impact: string;
}

// 优化类型
enum OptimizationType {
  INDEX = 'index',
  CACHE = 'cache',
  QUERY_REWRITE = 'query_rewrite',
  PAGINATION = 'pagination',
  PROJECTION = 'projection'
}

// 缓存配置
interface CacheConfig {
  strategy: CacheStrategy;
  ttl: number;
  maxSize: number;
  evictionPolicy: EvictionPolicy;
  compression: boolean;
}

// 缓存策略
enum CacheStrategy {
  LRU = 'lru',
  LFU = 'lfu',
  FIFO = 'fifo',
  RANDOM = 'random'
}

// 驱逐策略
enum EvictionPolicy {
  SIZE_BASED = 'size_based',
  TIME_BASED = 'time_based',
  MEMORY_BASED = 'memory_based'
}

// 缓存优化
interface CacheOptimization {
  currentConfig: CacheConfig;
  recommendedConfig: CacheConfig;
  expectedImprovement: CacheImprovement;
}

// 缓存改进
interface CacheImprovement {
  hitRateIncrease: number;
  responseTimeReduction: number;
  memoryUsageChange: number;
}

// 内存优化
interface MemoryOptimization {
  currentUsage: MemoryUsage;
  optimizations: MemoryOptimizationAction[];
  expectedSavings: number;
}

// 内存使用
interface MemoryUsage {
  total: number;
  used: number;
  free: number;
  cached: number;
  buffers: number;
}

// 内存优化操作
interface MemoryOptimizationAction {
  type: MemoryOptimizationType;
  description: string;
  estimatedSavings: number;
}

// 内存优化类型
enum MemoryOptimizationType {
  GARBAGE_COLLECTION = 'garbage_collection',
  CACHE_CLEANUP = 'cache_cleanup',
  OBJECT_POOLING = 'object_pooling',
  MEMORY_LEAK_FIX = 'memory_leak_fix'
}

// 性能分析
interface PerformanceAnalysis {
  summary: PerformanceSummary;
  trends: PerformanceTrend[];
  bottlenecks: PerformanceBottleneck[];
  recommendations: PerformanceRecommendation[];
}

// 性能摘要
interface PerformanceSummary {
  totalRequests: number;
  averageResponseTime: number;
  errorRate: number;
  throughput: number;
}

// 性能趋势
interface PerformanceTrend {
  metric: string;
  trend: number;
  direction: 'increasing' | 'decreasing' | 'stable';
}

// 性能瓶颈
interface PerformanceBottleneck {
  type: string;
  severity: 'low' | 'medium' | 'high' | 'critical';
  description: string;
  impact: string;
}

// 性能建议
interface PerformanceRecommendation {
  type: string;
  priority: 'low' | 'medium' | 'high';
  description: string;
  expectedImprovement: string;
}

// 性能告警
interface PerformanceAlert {
  id: string;
  name: string;
  description: string;
  condition: AlertCondition;
  severity: AlertSeverity;
  status: AlertStatus;
  createdAt: Date;
  updatedAt: Date;
  triggeredAt?: Date;
  resolvedAt?: Date;
}

// 告警条件
interface AlertCondition {
  metric: string;
  operator: ComparisonOperator;
  threshold: number;
  duration: number;
}

// 比较操作符
enum ComparisonOperator {
  GREATER_THAN = 'gt',
  LESS_THAN = 'lt',
  EQUAL = 'eq',
  NOT_EQUAL = 'ne',
  GREATER_EQUAL = 'ge',
  LESS_EQUAL = 'le'
}

// 告警严重性
enum AlertSeverity {
  INFO = 'info',
  WARNING = 'warning',
  ERROR = 'error',
  CRITICAL = 'critical'
}

// 告警状态
enum AlertStatus {
  ACTIVE = 'active',
  TRIGGERED = 'triggered',
  RESOLVED = 'resolved',
  DISABLED = 'disabled'
}

// 性能报告
interface PerformanceReport {
  id: string;
  title: string;
  timeRange: TimeRange;
  sections: ReportSection[];
  generatedAt: Date;
  format: ReportFormat;
}

// 报告部分
interface ReportSection {
  title: string;
  type: SectionType;
  content: any;
}

// 部分类型
enum SectionType {
  SUMMARY = 'summary',
  CHART = 'chart',
  TABLE = 'table',
  TEXT = 'text'
}

// 报告格式
enum ReportFormat {
  HTML = 'html',
  PDF = 'pdf',
  JSON = 'json',
  CSV = 'csv'
}

// 报告配置
interface ReportConfig {
  title: string;
  timeRange: TimeRange;
  sections: SectionConfig[];
  format: ReportFormat;
  recipients?: string[];
}

// 部分配置
interface SectionConfig {
  title: string;
  type: SectionType;
  metrics: string[];
  chartType?: ChartType;
}

// 图表类型
enum ChartType {
  LINE = 'line',
  BAR = 'bar',
  PIE = 'pie',
  AREA = 'area',
  SCATTER = 'scatter'
}

// 创建告警请求
interface CreateAlertRequest {
  name: string;
  description: string;
  condition: AlertCondition;
  severity: AlertSeverity;
}

// 更新告警请求
interface UpdateAlertRequest {
  name?: string;
  description?: string;
  condition?: AlertCondition;
  severity?: AlertSeverity;
  status?: AlertStatus;
}

// 告警查询
interface AlertQuery {
  status?: AlertStatus;
  severity?: AlertSeverity;
  startTime?: Date;
  endTime?: Date;
  limit?: number;
}

16.3 指标收集器

// 指标收集器接口
interface MetricsCollector {
  start(): Promise<void>;
  stop(): Promise<void>;
  collectMetric(metric: PerformanceMetrics): Promise<void>;
  getMetrics(query: MetricsQuery): Promise<PerformanceMetrics[]>;
  aggregateMetrics(query: MetricsQuery): Promise<AggregatedMetrics>;
}

// 聚合指标
interface AggregatedMetrics {
  metric: string;
  aggregation: AggregationType;
  value: number;
  timestamp: Date;
  count: number;
}

// 指标收集器实现
class ComprehensiveMetricsCollector implements MetricsCollector {
  private metricsStore: MetricsStore;
  private collectors: Map<string, MetricCollector> = new Map();
  private isRunning: boolean = false;
  private collectionInterval: NodeJS.Timeout | null = null;
  
  constructor(metricsStore: MetricsStore) {
    this.metricsStore = metricsStore;
    this.initializeCollectors();
  }
  
  private initializeCollectors(): void {
    // 系统指标收集器
    this.collectors.set('system', new SystemMetricsCollector());
    
    // 应用指标收集器
    this.collectors.set('application', new ApplicationMetricsCollector());
    
    // 业务指标收集器
    this.collectors.set('business', new BusinessMetricsCollector());
    
    // 自定义指标收集器
    this.collectors.set('custom', new CustomMetricsCollector());
  }
  
  async start(): Promise<void> {
    if (this.isRunning) {
      throw new Error('Metrics collection is already running');
    }
    
    this.isRunning = true;
    
    // 启动所有收集器
    for (const collector of this.collectors.values()) {
      await collector.start();
    }
    
    // 定期收集指标
    this.collectionInterval = setInterval(async () => {
      await this.collectAllMetrics();
    }, 30000); // 每30秒收集一次
    
    console.log('Metrics collection started');
  }
  
  async stop(): Promise<void> {
    if (!this.isRunning) {
      throw new Error('Metrics collection is not running');
    }
    
    this.isRunning = false;
    
    // 停止定期收集
    if (this.collectionInterval) {
      clearInterval(this.collectionInterval);
      this.collectionInterval = null;
    }
    
    // 停止所有收集器
    for (const collector of this.collectors.values()) {
      await collector.stop();
    }
    
    console.log('Metrics collection stopped');
  }
  
  async collectMetric(metric: PerformanceMetrics): Promise<void> {
    await this.metricsStore.store(metric);
  }
  
  async getMetrics(query: MetricsQuery): Promise<PerformanceMetrics[]> {
    return await this.metricsStore.find(query);
  }
  
  async aggregateMetrics(query: MetricsQuery): Promise<AggregatedMetrics> {
    const metrics = await this.getMetrics(query);
    
    if (metrics.length === 0) {
      throw new Error('No metrics found for the given query');
    }
    
    const aggregation = query.aggregation || AggregationType.AVG;
    const values = this.extractValues(metrics, query);
    
    let value: number;
    switch (aggregation) {
      case AggregationType.AVG:
        value = values.reduce((sum, val) => sum + val, 0) / values.length;
        break;
      case AggregationType.SUM:
        value = values.reduce((sum, val) => sum + val, 0);
        break;
      case AggregationType.MIN:
        value = Math.min(...values);
        break;
      case AggregationType.MAX:
        value = Math.max(...values);
        break;
      case AggregationType.COUNT:
        value = values.length;
        break;
      default:
        value = values.reduce((sum, val) => sum + val, 0) / values.length;
    }
    
    return {
      metric: this.getMetricName(query),
      aggregation,
      value,
      timestamp: new Date(),
      count: values.length
    };
  }
  
  private async collectAllMetrics(): Promise<void> {
    try {
      for (const [source, collector] of this.collectors.entries()) {
        const metrics = await collector.collect();
        for (const metric of metrics) {
          metric.source = source;
          metric.timestamp = new Date();
          await this.collectMetric(metric);
        }
      }
    } catch (error) {
      console.error('Error collecting metrics:', error);
    }
  }
  
  private extractValues(metrics: PerformanceMetrics[], query: MetricsQuery): number[] {
    // 根据查询提取相应的数值
    return metrics.map(metric => {
      switch (query.type) {
        case MetricType.SYSTEM:
          return metric.cpuUsage || metric.memoryUsage || 0;
        case MetricType.APPLICATION:
          return metric.responseTime || metric.requestCount || 0;
        default:
          return metric.requestCount || 0;
      }
    });
  }
  
  private getMetricName(query: MetricsQuery): string {
    return `${query.type || 'unknown'}_${query.aggregation || 'avg'}`;
  }
}

// 指标收集器基类
abstract class MetricCollector {
  abstract start(): Promise<void>;
  abstract stop(): Promise<void>;
  abstract collect(): Promise<PerformanceMetrics[]>;
}

// 系统指标收集器
class SystemMetricsCollector extends MetricCollector {
  async start(): Promise<void> {
    console.log('System metrics collector started');
  }
  
  async stop(): Promise<void> {
    console.log('System metrics collector stopped');
  }
  
  async collect(): Promise<PerformanceMetrics[]> {
    const metrics: PerformanceMetrics[] = [];
    
    // 收集CPU使用率
    const cpuUsage = await this.getCpuUsage();
    metrics.push({
      timestamp: new Date(),
      source: 'system',
      type: MetricType.SYSTEM,
      cpuUsage
    });
    
    // 收集内存使用率
    const memoryUsage = await this.getMemoryUsage();
    metrics.push({
      timestamp: new Date(),
      source: 'system',
      type: MetricType.SYSTEM,
      memoryUsage
    });
    
    // 收集磁盘使用率
    const diskUsage = await this.getDiskUsage();
    metrics.push({
      timestamp: new Date(),
      source: 'system',
      type: MetricType.SYSTEM,
      diskUsage
    });
    
    return metrics;
  }
  
  private async getCpuUsage(): Promise<number> {
    // 实现CPU使用率获取逻辑
    return Math.random() * 100; // 模拟数据
  }
  
  private async getMemoryUsage(): Promise<number> {
    // 实现内存使用率获取逻辑
    const used = process.memoryUsage();
    const total = require('os').totalmem();
    return (used.heapUsed / total) * 100;
  }
  
  private async getDiskUsage(): Promise<number> {
    // 实现磁盘使用率获取逻辑
    return Math.random() * 100; // 模拟数据
  }
}

// 应用指标收集器
class ApplicationMetricsCollector extends MetricCollector {
  private requestCount: number = 0;
  private responseTimeSum: number = 0;
  private errorCount: number = 0;
  
  async start(): Promise<void> {
    console.log('Application metrics collector started');
  }
  
  async stop(): Promise<void> {
    console.log('Application metrics collector stopped');
  }
  
  async collect(): Promise<PerformanceMetrics[]> {
    const metrics: PerformanceMetrics[] = [];
    
    // 收集请求指标
    metrics.push({
      timestamp: new Date(),
      source: 'application',
      type: MetricType.APPLICATION,
      requestCount: this.requestCount,
      responseTime: this.requestCount > 0 ? this.responseTimeSum / this.requestCount : 0,
      errorCount: this.errorCount
    });
    
    // 重置计数器
    this.requestCount = 0;
    this.responseTimeSum = 0;
    this.errorCount = 0;
    
    return metrics;
  }
  
  recordRequest(responseTime: number, isError: boolean = false): void {
    this.requestCount++;
    this.responseTimeSum += responseTime;
    if (isError) {
      this.errorCount++;
    }
  }
}

// 业务指标收集器
class BusinessMetricsCollector extends MetricCollector {
  async start(): Promise<void> {
    console.log('Business metrics collector started');
  }
  
  async stop(): Promise<void> {
    console.log('Business metrics collector stopped');
  }
  
  async collect(): Promise<PerformanceMetrics[]> {
    const metrics: PerformanceMetrics[] = [];
    
    // 收集业务指标
    metrics.push({
      timestamp: new Date(),
      source: 'business',
      type: MetricType.BUSINESS,
      activeUsers: await this.getActiveUsers(),
      customMetrics: {
        'forms_created': await this.getFormsCreated(),
        'workflows_executed': await this.getWorkflowsExecuted()
      }
    });
    
    return metrics;
  }
  
  private async getActiveUsers(): Promise<number> {
    // 实现活跃用户数获取逻辑
    return Math.floor(Math.random() * 1000);
  }
  
  private async getFormsCreated(): Promise<number> {
    // 实现表单创建数获取逻辑
    return Math.floor(Math.random() * 100);
  }
  
  private async getWorkflowsExecuted(): Promise<number> {
    // 实现工作流执行数获取逻辑
    return Math.floor(Math.random() * 50);
  }
}

// 自定义指标收集器
class CustomMetricsCollector extends MetricCollector {
  private customMetrics: Map<string, number> = new Map();
  
  async start(): Promise<void> {
    console.log('Custom metrics collector started');
  }
  
  async stop(): Promise<void> {
    console.log('Custom metrics collector stopped');
  }
  
  async collect(): Promise<PerformanceMetrics[]> {
    const metrics: PerformanceMetrics[] = [];
    
    if (this.customMetrics.size > 0) {
      const customMetricsObj: Record<string, number> = {};
      for (const [key, value] of this.customMetrics.entries()) {
        customMetricsObj[key] = value;
      }
      
      metrics.push({
        timestamp: new Date(),
        source: 'custom',
        type: MetricType.CUSTOM,
        customMetrics: customMetricsObj
      });
      
      // 清空自定义指标
      this.customMetrics.clear();
    }
    
    return metrics;
  }
  
  addCustomMetric(name: string, value: number): void {
    this.customMetrics.set(name, value);
  }
}

// 指标存储接口
interface MetricsStore {
  store(metric: PerformanceMetrics): Promise<void>;
  find(query: MetricsQuery): Promise<PerformanceMetrics[]>;
  delete(query: MetricsQuery): Promise<number>;
}

// 内存指标存储实现
class MemoryMetricsStore implements MetricsStore {
  private metrics: PerformanceMetrics[] = [];
  private maxSize: number = 10000;
  
  constructor(maxSize: number = 10000) {
    this.maxSize = maxSize;
  }
  
  async store(metric: PerformanceMetrics): Promise<void> {
    metric.id = this.generateId();
    this.metrics.push(metric);
    
    // 保持存储大小限制
    if (this.metrics.length > this.maxSize) {
      this.metrics = this.metrics.slice(-this.maxSize);
    }
  }
  
  async find(query: MetricsQuery): Promise<PerformanceMetrics[]> {
    let results = [...this.metrics];
    
    // 按时间范围过滤
    if (query.startTime) {
      results = results.filter(m => m.timestamp >= query.startTime!);
    }
    if (query.endTime) {
      results = results.filter(m => m.timestamp <= query.endTime!);
    }
    
    // 按来源过滤
    if (query.source) {
      results = results.filter(m => m.source === query.source);
    }
    
    // 按类型过滤
    if (query.type) {
      results = results.filter(m => m.type === query.type);
    }
    
    // 按标签过滤
    if (query.tags) {
      results = results.filter(m => {
        if (!m.tags) return false;
        return Object.entries(query.tags!).every(([key, value]) => m.tags![key] === value);
      });
    }
    
    // 限制结果数量
    if (query.limit) {
      results = results.slice(0, query.limit);
    }
    
    return results;
  }
  
  async delete(query: MetricsQuery): Promise<number> {
    const toDelete = await this.find(query);
    const deleteIds = new Set(toDelete.map(m => m.id));
    
    const originalLength = this.metrics.length;
    this.metrics = this.metrics.filter(m => !deleteIds.has(m.id));
    
    return originalLength - this.metrics.length;
  }
  
  private generateId(): string {
    return `metric_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
  }
}

16.4 查询优化器

// 查询优化器接口
interface QueryOptimizer {
  optimize(query: any): Promise<OptimizedQuery>;
  analyzeQuery(query: any): Promise<QueryAnalysis>;
  suggestIndexes(query: any): Promise<IndexSuggestion[]>;
}

// 查询分析
interface QueryAnalysis {
  complexity: QueryComplexity;
  estimatedCost: number;
  bottlenecks: QueryBottleneck[];
  suggestions: OptimizationSuggestion[];
}

// 查询复杂度
enum QueryComplexity {
  LOW = 'low',
  MEDIUM = 'medium',
  HIGH = 'high',
  VERY_HIGH = 'very_high'
}

// 查询瓶颈
interface QueryBottleneck {
  type: BottleneckType;
  description: string;
  impact: string;
}

// 瓶颈类型
enum BottleneckType {
  FULL_TABLE_SCAN = 'full_table_scan',
  MISSING_INDEX = 'missing_index',
  INEFFICIENT_JOIN = 'inefficient_join',
  LARGE_RESULT_SET = 'large_result_set',
  COMPLEX_SUBQUERY = 'complex_subquery'
}

// 优化建议
interface OptimizationSuggestion {
  type: OptimizationType;
  description: string;
  expectedImprovement: number;
  implementation: string;
}

// 索引建议
interface IndexSuggestion {
  table: string;
  columns: string[];
  type: IndexType;
  reason: string;
  estimatedImprovement: number;
}

// 索引类型
enum IndexType {
  BTREE = 'btree',
  HASH = 'hash',
  COMPOSITE = 'composite',
  PARTIAL = 'partial'
}

// 查询优化器实现
class LowCodeQueryOptimizer implements QueryOptimizer {
  private indexAnalyzer: IndexAnalyzer;
  private queryRewriter: QueryRewriter;
  private costEstimator: CostEstimator;
  
  constructor() {
    this.indexAnalyzer = new IndexAnalyzer();
    this.queryRewriter = new QueryRewriter();
    this.costEstimator = new CostEstimator();
  }
  
  async optimize(query: any): Promise<OptimizedQuery> {
    const analysis = await this.analyzeQuery(query);
    const optimizations: QueryOptimization[] = [];
    let optimizedQuery = { ...query };
    
    // 应用各种优化策略
    if (analysis.bottlenecks.some(b => b.type === BottleneckType.MISSING_INDEX)) {
      const indexOptimization = await this.optimizeWithIndexes(optimizedQuery);
      optimizations.push(indexOptimization);
      optimizedQuery = indexOptimization.optimizedQuery;
    }
    
    if (analysis.bottlenecks.some(b => b.type === BottleneckType.LARGE_RESULT_SET)) {
      const paginationOptimization = await this.addPagination(optimizedQuery);
      optimizations.push(paginationOptimization);
      optimizedQuery = paginationOptimization.optimizedQuery;
    }
    
    if (analysis.bottlenecks.some(b => b.type === BottleneckType.INEFFICIENT_JOIN)) {
      const joinOptimization = await this.optimizeJoins(optimizedQuery);
      optimizations.push(joinOptimization);
      optimizedQuery = joinOptimization.optimizedQuery;
    }
    
    // 计算预期改进
    const estimatedImprovement = optimizations.reduce(
      (total, opt) => total + (opt.estimatedImprovement || 0), 0
    );
    
    return {
      originalQuery: query,
      optimizedQuery,
      optimizations,
      estimatedImprovement
    };
  }
  
  async analyzeQuery(query: any): Promise<QueryAnalysis> {
    const complexity = this.assessComplexity(query);
    const estimatedCost = await this.costEstimator.estimate(query);
    const bottlenecks = await this.identifyBottlenecks(query);
    const suggestions = await this.generateSuggestions(query, bottlenecks);
    
    return {
      complexity,
      estimatedCost,
      bottlenecks,
      suggestions
    };
  }
  
  async suggestIndexes(query: any): Promise<IndexSuggestion[]> {
    return await this.indexAnalyzer.analyze(query);
  }
  
  private assessComplexity(query: any): QueryComplexity {
    let score = 0;
    
    // 评估查询复杂度
    if (query.joins && query.joins.length > 0) {
      score += query.joins.length * 2;
    }
    
    if (query.subqueries && query.subqueries.length > 0) {
      score += query.subqueries.length * 3;
    }
    
    if (query.aggregations && query.aggregations.length > 0) {
      score += query.aggregations.length;
    }
    
    if (query.orderBy && query.orderBy.length > 0) {
      score += query.orderBy.length;
    }
    
    if (score <= 2) return QueryComplexity.LOW;
    if (score <= 5) return QueryComplexity.MEDIUM;
    if (score <= 10) return QueryComplexity.HIGH;
    return QueryComplexity.VERY_HIGH;
  }
  
  private async identifyBottlenecks(query: any): Promise<QueryBottleneck[]> {
    const bottlenecks: QueryBottleneck[] = [];
    
    // 检查是否缺少索引
    if (!query.indexes || query.indexes.length === 0) {
      bottlenecks.push({
        type: BottleneckType.MISSING_INDEX,
        description: 'Query may benefit from additional indexes',
        impact: 'Slow query execution due to full table scans'
      });
    }
    
    // 检查大结果集
    if (!query.limit || query.limit > 1000) {
      bottlenecks.push({
        type: BottleneckType.LARGE_RESULT_SET,
        description: 'Query returns large result set without pagination',
        impact: 'High memory usage and slow response times'
      });
    }
    
    // 检查低效连接
    if (query.joins && query.joins.some((j: any) => !j.indexed)) {
      bottlenecks.push({
        type: BottleneckType.INEFFICIENT_JOIN,
        description: 'Joins without proper indexes detected',
        impact: 'Exponential increase in query execution time'
      });
    }
    
    return bottlenecks;
  }
  
  private async generateSuggestions(query: any, bottlenecks: QueryBottleneck[]): Promise<OptimizationSuggestion[]> {
    const suggestions: OptimizationSuggestion[] = [];
    
    for (const bottleneck of bottlenecks) {
      switch (bottleneck.type) {
        case BottleneckType.MISSING_INDEX:
          suggestions.push({
            type: OptimizationType.INDEX,
            description: 'Add indexes on frequently queried columns',
            expectedImprovement: 70,
            implementation: 'CREATE INDEX idx_column ON table(column)'
          });
          break;
          
        case BottleneckType.LARGE_RESULT_SET:
          suggestions.push({
            type: OptimizationType.PAGINATION,
            description: 'Implement pagination to limit result set size',
            expectedImprovement: 50,
            implementation: 'Add LIMIT and OFFSET clauses'
          });
          break;
          
        case BottleneckType.INEFFICIENT_JOIN:
          suggestions.push({
            type: OptimizationType.QUERY_REWRITE,
            description: 'Optimize join conditions and add indexes',
            expectedImprovement: 60,
            implementation: 'Rewrite joins with proper indexing strategy'
          });
          break;
      }
    }
    
    return suggestions;
  }
  
  private async optimizeWithIndexes(query: any): Promise<QueryOptimization> {
    // 实现索引优化逻辑
    return {
      type: OptimizationType.INDEX,
      description: 'Added recommended indexes for query optimization',
      impact: 'Reduced query execution time by utilizing indexes',
      optimizedQuery: { ...query, useIndexes: true },
      estimatedImprovement: 70
    };
  }
  
  private async addPagination(query: any): Promise<QueryOptimization> {
    // 实现分页优化逻辑
    return {
      type: OptimizationType.PAGINATION,
      description: 'Added pagination to limit result set size',
      impact: 'Reduced memory usage and improved response time',
      optimizedQuery: { ...query, limit: 100, offset: 0 },
      estimatedImprovement: 50
    };
  }
  
  private async optimizeJoins(query: any): Promise<QueryOptimization> {
    // 实现连接优化逻辑
    return {
      type: OptimizationType.QUERY_REWRITE,
      description: 'Optimized join conditions and order',
      impact: 'Improved join performance through better execution plan',
      optimizedQuery: { ...query, optimizedJoins: true },
      estimatedImprovement: 60
    };
  }
}

// 索引分析器
class IndexAnalyzer {
  async analyze(query: any): Promise<IndexSuggestion[]> {
    const suggestions: IndexSuggestion[] = [];
    
    // 分析WHERE条件中的列
    if (query.where) {
      for (const condition of query.where) {
        suggestions.push({
          table: condition.table,
          columns: [condition.column],
          type: IndexType.BTREE,
          reason: 'Frequently used in WHERE conditions',
          estimatedImprovement: 60
        });
      }
    }
    
    // 分析JOIN条件中的列
    if (query.joins) {
      for (const join of query.joins) {
        suggestions.push({
          table: join.table,
          columns: [join.column],
          type: IndexType.BTREE,
          reason: 'Used in JOIN conditions',
          estimatedImprovement: 70
        });
      }
    }
    
    // 分析ORDER BY中的列
    if (query.orderBy) {
      suggestions.push({
        table: query.table,
        columns: query.orderBy.map((o: any) => o.column),
        type: IndexType.COMPOSITE,
        reason: 'Used in ORDER BY clause',
        estimatedImprovement: 40
      });
    }
    
    return suggestions;
  }
}

// 查询重写器
class QueryRewriter {
  rewrite(query: any): any {
    let rewritten = { ...query };
    
    // 重写子查询为JOIN
    rewritten = this.rewriteSubqueriesToJoins(rewritten);
    
    // 优化WHERE条件顺序
    rewritten = this.optimizeWhereConditions(rewritten);
    
    // 添加查询提示
    rewritten = this.addQueryHints(rewritten);
    
    return rewritten;
  }
  
  private rewriteSubqueriesToJoins(query: any): any {
    // 实现子查询到JOIN的重写逻辑
    return query;
  }
  
  private optimizeWhereConditions(query: any): any {
    // 实现WHERE条件优化逻辑
    if (query.where) {
      // 将选择性高的条件放在前面
      query.where.sort((a: any, b: any) => {
        return this.getSelectivity(b) - this.getSelectivity(a);
      });
    }
    return query;
  }
  
  private addQueryHints(query: any): any {
    // 添加查询优化提示
    query.hints = query.hints || [];
    query.hints.push('USE_INDEX');
    return query;
  }
  
  private getSelectivity(condition: any): number {
    // 估算条件的选择性
    switch (condition.operator) {
      case '=':
        return 0.1;
      case 'IN':
        return 0.3;
      case 'LIKE':
        return 0.5;
      default:
        return 0.7;
    }
  }
}

// 成本估算器
class CostEstimator {
  async estimate(query: any): Promise<number> {
    let cost = 0;
    
    // 基础查询成本
    cost += 10;
    
    // JOIN成本
    if (query.joins) {
      cost += query.joins.length * 50;
    }
    
    // 子查询成本
    if (query.subqueries) {
      cost += query.subqueries.length * 100;
    }
    
    // 聚合成本
    if (query.aggregations) {
      cost += query.aggregations.length * 30;
    }
    
    // 排序成本
    if (query.orderBy) {
      cost += query.orderBy.length * 20;
    }
    
    // 结果集大小成本
    if (query.limit) {
      cost += Math.log(query.limit) * 5;
    } else {
      cost += 200; // 无限制的查询成本很高
    }
    
    return cost;
  }
}

16.5 缓存管理器

// 缓存管理器接口
interface CacheManager {
  get(key: string): Promise<any>;
  set(key: string, value: any, ttl?: number): Promise<void>;
  delete(key: string): Promise<boolean>;
  clear(): Promise<void>;
  optimize(config: CacheConfig): Promise<CacheOptimization>;
  getStats(): Promise<CacheStats>;
}

// 缓存统计
interface CacheStats {
  hitCount: number;
  missCount: number;
  hitRate: number;
  size: number;
  maxSize: number;
  memoryUsage: number;
  evictionCount: number;
}

// 缓存管理器实现
class LowCodeCacheManager implements CacheManager {
  private cache: Map<string, CacheEntry> = new Map();
  private config: CacheConfig;
  private stats: CacheStats;
  private cleanupInterval: NodeJS.Timeout | null = null;
  
  constructor(config: CacheConfig) {
    this.config = config;
    this.stats = {
      hitCount: 0,
      missCount: 0,
      hitRate: 0,
      size: 0,
      maxSize: config.maxSize,
      memoryUsage: 0,
      evictionCount: 0
    };
    
    this.startCleanup();
  }
  
  async get(key: string): Promise<any> {
    const entry = this.cache.get(key);
    
    if (!entry) {
      this.stats.missCount++;
      this.updateHitRate();
      return null;
    }
    
    // 检查是否过期
    if (this.isExpired(entry)) {
      this.cache.delete(key);
      this.stats.missCount++;
      this.updateHitRate();
      return null;
    }
    
    // 更新访问信息
    entry.lastAccessed = Date.now();
    entry.accessCount++;
    
    this.stats.hitCount++;
    this.updateHitRate();
    
    return entry.value;
  }
  
  async set(key: string, value: any, ttl?: number): Promise<void> {
    const now = Date.now();
    const entry: CacheEntry = {
      key,
      value,
      createdAt: now,
      lastAccessed: now,
      accessCount: 0,
      ttl: ttl || this.config.ttl,
      size: this.calculateSize(value)
    };
    
    // 检查是否需要驱逐
    if (this.cache.size >= this.config.maxSize) {
      await this.evict();
    }
    
    this.cache.set(key, entry);
    this.updateStats();
  }
  
  async delete(key: string): Promise<boolean> {
    const deleted = this.cache.delete(key);
    if (deleted) {
      this.updateStats();
    }
    return deleted;
  }
  
  async clear(): Promise<void> {
    this.cache.clear();
    this.updateStats();
  }
  
  async optimize(config: CacheConfig): Promise<CacheOptimization> {
    const currentStats = await this.getStats();
    
    // 分析当前性能
    const analysis = this.analyzeCachePerformance(currentStats);
    
    // 生成优化建议
    const recommendedConfig = this.generateOptimalConfig(analysis);
    
    // 计算预期改进
    const expectedImprovement = this.calculateImprovement(this.config, recommendedConfig);
    
    return {
      currentConfig: this.config,
      recommendedConfig,
      expectedImprovement
    };
  }
  
  async getStats(): Promise<CacheStats> {
    this.updateStats();
    return { ...this.stats };
  }
  
  private isExpired(entry: CacheEntry): boolean {
    return Date.now() - entry.createdAt > entry.ttl;
  }
  
  private async evict(): Promise<void> {
    let keyToEvict: string | null = null;
    
    switch (this.config.strategy) {
      case CacheStrategy.LRU:
        keyToEvict = this.findLRUKey();
        break;
      case CacheStrategy.LFU:
        keyToEvict = this.findLFUKey();
        break;
      case CacheStrategy.FIFO:
        keyToEvict = this.findFIFOKey();
        break;
      case CacheStrategy.RANDOM:
        keyToEvict = this.findRandomKey();
        break;
    }
    
    if (keyToEvict) {
      this.cache.delete(keyToEvict);
      this.stats.evictionCount++;
    }
  }
  
  private findLRUKey(): string | null {
    let oldestKey: string | null = null;
    let oldestTime = Date.now();
    
    for (const [key, entry] of this.cache.entries()) {
      if (entry.lastAccessed < oldestTime) {
        oldestTime = entry.lastAccessed;
        oldestKey = key;
      }
    }
    
    return oldestKey;
  }
  
  private findLFUKey(): string | null {
    let leastUsedKey: string | null = null;
    let leastCount = Infinity;
    
    for (const [key, entry] of this.cache.entries()) {
      if (entry.accessCount < leastCount) {
        leastCount = entry.accessCount;
        leastUsedKey = key;
      }
    }
    
    return leastUsedKey;
  }
  
  private findFIFOKey(): string | null {
    let oldestKey: string | null = null;
    let oldestTime = Date.now();
    
    for (const [key, entry] of this.cache.entries()) {
      if (entry.createdAt < oldestTime) {
        oldestTime = entry.createdAt;
        oldestKey = key;
      }
    }
    
    return oldestKey;
  }
  
  private findRandomKey(): string | null {
    const keys = Array.from(this.cache.keys());
    return keys.length > 0 ? keys[Math.floor(Math.random() * keys.length)] : null;
  }
  
  private calculateSize(value: any): number {
    // 简单的大小计算
    return JSON.stringify(value).length;
  }
  
  private updateStats(): void {
    this.stats.size = this.cache.size;
    this.stats.memoryUsage = Array.from(this.cache.values())
      .reduce((total, entry) => total + entry.size, 0);
  }
  
  private updateHitRate(): void {
    const total = this.stats.hitCount + this.stats.missCount;
    this.stats.hitRate = total > 0 ? (this.stats.hitCount / total) * 100 : 0;
  }
  
  private startCleanup(): void {
    this.cleanupInterval = setInterval(() => {
      this.cleanupExpired();
    }, 60000); // 每分钟清理一次过期项
  }
  
  private cleanupExpired(): void {
    const now = Date.now();
    for (const [key, entry] of this.cache.entries()) {
      if (now - entry.createdAt > entry.ttl) {
        this.cache.delete(key);
      }
    }
    this.updateStats();
  }
  
  private analyzeCachePerformance(stats: CacheStats): CacheAnalysis {
    return {
      hitRateGrade: this.gradeHitRate(stats.hitRate),
      memoryEfficiency: this.calculateMemoryEfficiency(stats),
      evictionRate: this.calculateEvictionRate(stats),
      recommendations: this.generateCacheRecommendations(stats)
    };
  }
  
  private gradeHitRate(hitRate: number): 'excellent' | 'good' | 'fair' | 'poor' {
    if (hitRate >= 90) return 'excellent';
    if (hitRate >= 75) return 'good';
    if (hitRate >= 50) return 'fair';
    return 'poor';
  }
  
  private calculateMemoryEfficiency(stats: CacheStats): number {
    return stats.maxSize > 0 ? (stats.memoryUsage / stats.maxSize) * 100 : 0;
  }
  
  private calculateEvictionRate(stats: CacheStats): number {
    const total = stats.hitCount + stats.missCount;
    return total > 0 ? (stats.evictionCount / total) * 100 : 0;
  }
  
  private generateCacheRecommendations(stats: CacheStats): string[] {
    const recommendations: string[] = [];
    
    if (stats.hitRate < 50) {
      recommendations.push('Consider increasing cache size or TTL');
    }
    
    if (stats.evictionCount > stats.hitCount * 0.1) {
      recommendations.push('High eviction rate detected, consider increasing cache size');
    }
    
    if (stats.memoryUsage / stats.maxSize > 0.9) {
      recommendations.push('Cache is near capacity, consider optimization');
    }
    
    return recommendations;
  }
  
  private generateOptimalConfig(analysis: CacheAnalysis): CacheConfig {
    const config = { ...this.config };
    
    // 根据分析结果调整配置
    if (analysis.hitRateGrade === 'poor') {
      config.maxSize = Math.floor(config.maxSize * 1.5);
      config.ttl = Math.floor(config.ttl * 1.2);
    }
    
    if (analysis.evictionRate > 10) {
      config.maxSize = Math.floor(config.maxSize * 1.3);
    }
    
    return config;
  }
  
  private calculateImprovement(current: CacheConfig, recommended: CacheConfig): CacheImprovement {
    return {
      hitRateIncrease: recommended.maxSize > current.maxSize ? 15 : 0,
      responseTimeReduction: recommended.ttl > current.ttl ? 10 : 0,
      memoryUsageChange: (recommended.maxSize - current.maxSize) / current.maxSize * 100
    };
  }
}

// 缓存条目
interface CacheEntry {
  key: string;
  value: any;
  createdAt: number;
  lastAccessed: number;
  accessCount: number;
  ttl: number;
  size: number;
}

// 缓存分析
interface CacheAnalysis {
  hitRateGrade: 'excellent' | 'good' | 'fair' | 'poor';
  memoryEfficiency: number;
  evictionRate: number;
  recommendations: string[];
}

16.6 内存管理器

// 内存管理器接口
interface MemoryManager {
  getUsage(): Promise<MemoryUsage>;
  optimize(): Promise<MemoryOptimization>;
  forceGC(): Promise<void>;
  monitorLeaks(): Promise<MemoryLeak[]>;
  setThresholds(thresholds: MemoryThresholds): void;
}

// 内存阈值
interface MemoryThresholds {
  warning: number; // 警告阈值（百分比）
  critical: number; // 严重阈值（百分比）
  maxHeapSize: number; // 最大堆大小（字节）
}

// 内存泄漏
interface MemoryLeak {
  type: LeakType;
  description: string;
  severity: 'low' | 'medium' | 'high' | 'critical';
  location?: string;
  size: number;
}

// 泄漏类型
enum LeakType {
  EVENT_LISTENER = 'event_listener',
  TIMER = 'timer',
  CLOSURE = 'closure',
  DOM_REFERENCE = 'dom_reference',
  CACHE_OVERFLOW = 'cache_overflow'
}

// 内存管理器实现
class LowCodeMemoryManager implements MemoryManager {
  private thresholds: MemoryThresholds;
  private monitoringInterval: NodeJS.Timeout | null = null;
  private leakDetectors: Map<LeakType, LeakDetector> = new Map();
  
  constructor(thresholds?: MemoryThresholds) {
    this.thresholds = thresholds || {
      warning: 70,
      critical: 90,
      maxHeapSize: 1024 * 1024 * 1024 // 1GB
    };
    
    this.initializeLeakDetectors();
    this.startMonitoring();
  }
  
  async getUsage(): Promise<MemoryUsage> {
    const memUsage = process.memoryUsage();
    const totalMem = require('os').totalmem();
    const freeMem = require('os').freemem();
    
    return {
      total: totalMem,
      used: totalMem - freeMem,
      free: freeMem,
      cached: 0, // 在Node.js中难以准确获取
      buffers: 0 // 在Node.js中难以准确获取
    };
  }
  
  async optimize(): Promise<MemoryOptimization> {
    const currentUsage = await this.getUsage();
    const optimizations: MemoryOptimizationAction[] = [];
    let expectedSavings = 0;
    
    // 检查是否需要垃圾回收
    if (this.shouldForceGC(currentUsage)) {
      optimizations.push({
        type: MemoryOptimizationType.GARBAGE_COLLECTION,
        description: 'Force garbage collection to free unused memory',
        estimatedSavings: currentUsage.used * 0.1 // 估计可释放10%
      });
      expectedSavings += currentUsage.used * 0.1;
    }
    
    // 检查缓存清理
    const cacheOptimization = await this.optimizeCache();
    if (cacheOptimization) {
      optimizations.push(cacheOptimization);
      expectedSavings += cacheOptimization.estimatedSavings;
    }
    
    // 检查内存泄漏
    const leaks = await this.monitorLeaks();
    if (leaks.length > 0) {
      optimizations.push({
        type: MemoryOptimizationType.MEMORY_LEAK_FIX,
        description: `Fix ${leaks.length} detected memory leaks`,
        estimatedSavings: leaks.reduce((total, leak) => total + leak.size, 0)
      });
      expectedSavings += leaks.reduce((total, leak) => total + leak.size, 0);
    }
    
    // 执行优化
    for (const optimization of optimizations) {
      await this.executeOptimization(optimization);
    }
    
    return {
      currentUsage,
      optimizations,
      expectedSavings
    };
  }
  
  async forceGC(): Promise<void> {
    if (global.gc) {
      global.gc();
      console.log('Forced garbage collection completed');
    } else {
      console.warn('Garbage collection not available. Run with --expose-gc flag.');
    }
  }
  
  async monitorLeaks(): Promise<MemoryLeak[]> {
    const leaks: MemoryLeak[] = [];
    
    for (const [type, detector] of this.leakDetectors.entries()) {
      const detectedLeaks = await detector.detect();
      leaks.push(...detectedLeaks);
    }
    
    return leaks;
  }
  
  setThresholds(thresholds: MemoryThresholds): void {
    this.thresholds = thresholds;
  }
  
  private initializeLeakDetectors(): void {
    this.leakDetectors.set(LeakType.EVENT_LISTENER, new EventListenerLeakDetector());
    this.leakDetectors.set(LeakType.TIMER, new TimerLeakDetector());
    this.leakDetectors.set(LeakType.CLOSURE, new ClosureLeakDetector());
    this.leakDetectors.set(LeakType.CACHE_OVERFLOW, new CacheOverflowDetector());
  }
  
  private startMonitoring(): void {
    this.monitoringInterval = setInterval(async () => {
      const usage = await this.getUsage();
      const usagePercent = (usage.used / usage.total) * 100;
      
      if (usagePercent >= this.thresholds.critical) {
        console.error(`Critical memory usage: ${usagePercent.toFixed(2)}%`);
        await this.optimize();
      } else if (usagePercent >= this.thresholds.warning) {
        console.warn(`High memory usage: ${usagePercent.toFixed(2)}%`);
      }
    }, 30000); // 每30秒检查一次
  }
  
  private shouldForceGC(usage: MemoryUsage): boolean {
    const usagePercent = (usage.used / usage.total) * 100;
    return usagePercent > this.thresholds.warning;
  }
  
  private async optimizeCache(): Promise<MemoryOptimizationAction | null> {
    // 检查是否有缓存可以清理
    // 这里需要与缓存管理器集成
    return {
      type: MemoryOptimizationType.CACHE_CLEANUP,
      description: 'Clear expired cache entries',
      estimatedSavings: 1024 * 1024 * 10 // 估计10MB
    };
  }
  
  private async executeOptimization(optimization: MemoryOptimizationAction): Promise<void> {
    switch (optimization.type) {
      case MemoryOptimizationType.GARBAGE_COLLECTION:
        await this.forceGC();
        break;
        
      case MemoryOptimizationType.CACHE_CLEANUP:
        // 执行缓存清理
        console.log('Executing cache cleanup');
        break;
        
      case MemoryOptimizationType.MEMORY_LEAK_FIX:
        // 修复内存泄漏
        console.log('Fixing memory leaks');
        break;
        
      case MemoryOptimizationType.OBJECT_POOLING:
        // 实现对象池
        console.log('Implementing object pooling');
        break;
    }
  }
}

// 泄漏检测器基类
abstract class LeakDetector {
  abstract detect(): Promise<MemoryLeak[]>;
}

// 事件监听器泄漏检测器
class EventListenerLeakDetector extends LeakDetector {
  async detect(): Promise<MemoryLeak[]> {
    const leaks: MemoryLeak[] = [];
    
    // 检测未移除的事件监听器
    // 这是一个简化的实现
    const listenerCount = process.listenerCount('uncaughtException');
    if (listenerCount > 10) {
      leaks.push({
        type: LeakType.EVENT_LISTENER,
        description: `Too many uncaughtException listeners: ${listenerCount}`,
        severity: 'medium',
        size: listenerCount * 1024 // 估计每个监听器1KB
      });
    }
    
    return leaks;
  }
}

// 定时器泄漏检测器
class TimerLeakDetector extends LeakDetector {
  private activeTimers: Set<NodeJS.Timeout> = new Set();
  
  async detect(): Promise<MemoryLeak[]> {
    const leaks: MemoryLeak[] = [];
    
    // 检测长时间运行的定时器
    if (this.activeTimers.size > 100) {
      leaks.push({
        type: LeakType.TIMER,
        description: `Too many active timers: ${this.activeTimers.size}`,
        severity: 'high',
        size: this.activeTimers.size * 512 // 估计每个定时器512字节
      });
    }
    
    return leaks;
  }
  
  trackTimer(timer: NodeJS.Timeout): void {
    this.activeTimers.add(timer);
  }
  
  untrackTimer(timer: NodeJS.Timeout): void {
    this.activeTimers.delete(timer);
  }
}

// 闭包泄漏检测器
class ClosureLeakDetector extends LeakDetector {
  async detect(): Promise<MemoryLeak[]> {
    const leaks: MemoryLeak[] = [];
    
    // 检测可能的闭包泄漏
    // 这需要更复杂的分析，这里只是示例
    const memUsage = process.memoryUsage();
    if (memUsage.heapUsed > memUsage.heapTotal * 0.8) {
      leaks.push({
        type: LeakType.CLOSURE,
        description: 'Potential closure memory leak detected',
        severity: 'medium',
        size: memUsage.heapUsed * 0.1
      });
    }
    
    return leaks;
  }
}

// 缓存溢出检测器
class CacheOverflowDetector extends LeakDetector {
  async detect(): Promise<MemoryLeak[]> {
    const leaks: MemoryLeak[] = [];
    
    // 检测缓存是否过大
    // 这需要与缓存管理器集成
    const estimatedCacheSize = 1024 * 1024 * 50; // 假设50MB
    if (estimatedCacheSize > 1024 * 1024 * 100) { // 超过100MB
      leaks.push({
        type: LeakType.CACHE_OVERFLOW,
        description: 'Cache size exceeds recommended limits',
        severity: 'high',
        size: estimatedCacheSize - 1024 * 1024 * 100
      });
    }
    
    return leaks;
  }
}

16.7 告警管理器

// 告警管理器接口
interface AlertManager {
  start(): Promise<void>;
  stop(): Promise<void>;
  createAlert(alert: CreateAlertRequest): Promise<PerformanceAlert>;
  getAlerts(query: AlertQuery): Promise<PerformanceAlert[]>;
  updateAlert(alertId: string, update: UpdateAlertRequest): Promise<PerformanceAlert>;
  deleteAlert(alertId: string): Promise<void>;
  checkAlerts(): Promise<void>;
}

// 告警管理器实现
class LowCodeAlertManager implements AlertManager {
  private alerts: Map<string, PerformanceAlert> = new Map();
  private metricsCollector: MetricsCollector;
  private notificationService: NotificationService;
  private checkInterval: NodeJS.Timeout | null = null;
  private isRunning: boolean = false;
  
  constructor(metricsCollector: MetricsCollector, notificationService: NotificationService) {
    this.metricsCollector = metricsCollector;
    this.notificationService = notificationService;
  }
  
  async start(): Promise<void> {
    if (this.isRunning) {
      throw new Error('Alert manager is already running');
    }
    
    this.isRunning = true;
    
    // 定期检查告警条件
    this.checkInterval = setInterval(async () => {
      await this.checkAlerts();
    }, 60000); // 每分钟检查一次
    
    console.log('Alert manager started');
  }
  
  async stop(): Promise<void> {
    if (!this.isRunning) {
      throw new Error('Alert manager is not running');
    }
    
    this.isRunning = false;
    
    if (this.checkInterval) {
      clearInterval(this.checkInterval);
      this.checkInterval = null;
    }
    
    console.log('Alert manager stopped');
  }
  
  async createAlert(alert: CreateAlertRequest): Promise<PerformanceAlert> {
    const id = this.generateAlertId();
    const now = new Date();
    
    const performanceAlert: PerformanceAlert = {
      id,
      name: alert.name,
      description: alert.description,
      condition: alert.condition,
      severity: alert.severity,
      status: AlertStatus.ACTIVE,
      createdAt: now,
      updatedAt: now
    };
    
    this.alerts.set(id, performanceAlert);
    
    console.log(`Alert created: ${alert.name}`);
    return performanceAlert;
  }
  
  async getAlerts(query: AlertQuery): Promise<PerformanceAlert[]> {
    let results = Array.from(this.alerts.values());
    
    // 按状态过滤
    if (query.status) {
      results = results.filter(alert => alert.status === query.status);
    }
    
    // 按严重性过滤
    if (query.severity) {
      results = results.filter(alert => alert.severity === query.severity);
    }
    
    // 按时间范围过滤
    if (query.startTime) {
      results = results.filter(alert => alert.createdAt >= query.startTime!);
    }
    if (query.endTime) {
      results = results.filter(alert => alert.createdAt <= query.endTime!);
    }
    
    // 限制结果数量
    if (query.limit) {
      results = results.slice(0, query.limit);
    }
    
    return results;
  }
  
  async updateAlert(alertId: string, update: UpdateAlertRequest): Promise<PerformanceAlert> {
    const alert = this.alerts.get(alertId);
    if (!alert) {
      throw new Error(`Alert not found: ${alertId}`);
    }
    
    // 更新告警属性
    if (update.name !== undefined) alert.name = update.name;
    if (update.description !== undefined) alert.description = update.description;
    if (update.condition !== undefined) alert.condition = update.condition;
    if (update.severity !== undefined) alert.severity = update.severity;
    if (update.status !== undefined) alert.status = update.status;
    
    alert.updatedAt = new Date();
    
    console.log(`Alert updated: ${alert.name}`);
    return alert;
  }
  
  async deleteAlert(alertId: string): Promise<void> {
    const deleted = this.alerts.delete(alertId);
    if (!deleted) {
      throw new Error(`Alert not found: ${alertId}`);
    }
    
    console.log(`Alert deleted: ${alertId}`);
  }
  
  async checkAlerts(): Promise<void> {
    try {
      for (const alert of this.alerts.values()) {
        if (alert.status === AlertStatus.ACTIVE) {
          const isTriggered = await this.evaluateAlertCondition(alert);
          
          if (isTriggered && alert.status !== AlertStatus.TRIGGERED) {
            await this.triggerAlert(alert);
          } else if (!isTriggered && alert.status === AlertStatus.TRIGGERED) {
            await this.resolveAlert(alert);
          }
        }
      }
    } catch (error) {
      console.error('Error checking alerts:', error);
    }
  }
  
  private async evaluateAlertCondition(alert: PerformanceAlert): Promise<boolean> {
    const condition = alert.condition;
    
    // 获取最近的指标数据
    const endTime = new Date();
    const startTime = new Date(endTime.getTime() - condition.duration);
    
    const metrics = await this.metricsCollector.getMetrics({
      startTime,
      endTime,
      limit: 100
    });
    
    if (metrics.length === 0) {
      return false;
    }
    
    // 提取指标值
    const values = this.extractMetricValues(metrics, condition.metric);
    if (values.length === 0) {
      return false;
    }
    
    // 计算平均值
    const average = values.reduce((sum, val) => sum + val, 0) / values.length;
    
    // 评估条件
    return this.evaluateCondition(average, condition.operator, condition.threshold);
  }
  
  private extractMetricValues(metrics: PerformanceMetrics[], metricName: string): number[] {
    const values: number[] = [];
    
    for (const metric of metrics) {
      let value: number | undefined;
      
      switch (metricName) {
        case 'cpu_usage':
          value = metric.cpuUsage;
          break;
        case 'memory_usage':
          value = metric.memoryUsage;
          break;
        case 'response_time':
          value = metric.responseTime;
          break;
        case 'error_rate':
          value = metric.errorCount && metric.requestCount 
            ? (metric.errorCount / metric.requestCount) * 100 
            : undefined;
          break;
        default:
          value = metric.customMetrics?.[metricName];
      }
      
      if (value !== undefined) {
        values.push(value);
      }
    }
    
    return values;
  }
  
  private evaluateCondition(value: number, operator: ComparisonOperator, threshold: number): boolean {
    switch (operator) {
      case ComparisonOperator.GREATER_THAN:
        return value > threshold;
      case ComparisonOperator.LESS_THAN:
        return value < threshold;
      case ComparisonOperator.EQUAL:
        return value === threshold;
      case ComparisonOperator.NOT_EQUAL:
        return value !== threshold;
      case ComparisonOperator.GREATER_EQUAL:
        return value >= threshold;
      case ComparisonOperator.LESS_EQUAL:
        return value <= threshold;
      default:
        return false;
    }
  }
  
  private async triggerAlert(alert: PerformanceAlert): Promise<void> {
    alert.status = AlertStatus.TRIGGERED;
    alert.triggeredAt = new Date();
    alert.updatedAt = new Date();
    
    // 发送通知
    await this.notificationService.sendAlert(alert);
    
    console.log(`Alert triggered: ${alert.name}`);
  }
  
  private async resolveAlert(alert: PerformanceAlert): Promise<void> {
    alert.status = AlertStatus.RESOLVED;
    alert.resolvedAt = new Date();
    alert.updatedAt = new Date();
    
    // 发送解决通知
    await this.notificationService.sendResolution(alert);
    
    console.log(`Alert resolved: ${alert.name}`);
  }
  
  private generateAlertId(): string {
    return `alert_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
  }
}

// 通知服务接口
interface NotificationService {
  sendAlert(alert: PerformanceAlert): Promise<void>;
  sendResolution(alert: PerformanceAlert): Promise<void>;
}

// 通知服务实现
class EmailNotificationService implements NotificationService {
  private emailService: EmailService;
  
  constructor(emailService: EmailService) {
    this.emailService = emailService;
  }
  
  async sendAlert(alert: PerformanceAlert): Promise<void> {
    const subject = `[${alert.severity.toUpperCase()}] Alert Triggered: ${alert.name}`;
    const body = `
      Alert: ${alert.name}
      Description: ${alert.description}
      Severity: ${alert.severity}
      Triggered At: ${alert.triggeredAt}
      
      Condition: ${alert.condition.metric} ${alert.condition.operator} ${alert.condition.threshold}
    `;
    
    await this.emailService.send({
      subject,
      body,
      recipients: ['admin@example.com'] // 配置收件人
    });
  }
  
  async sendResolution(alert: PerformanceAlert): Promise<void> {
    const subject = `Alert Resolved: ${alert.name}`;
    const body = `
      Alert: ${alert.name}
      Description: ${alert.description}
      Resolved At: ${alert.resolvedAt}
    `;
    
    await this.emailService.send({
      subject,
      body,
      recipients: ['admin@example.com']
    });
  }
}

// 邮件服务接口
interface EmailService {
  send(email: EmailMessage): Promise<void>;
}

// 邮件消息
interface EmailMessage {
  subject: string;
  body: string;
  recipients: string[];
}

16.8 报告生成器

// 报告生成器接口
interface ReportGenerator {
  generate(config: ReportConfig): Promise<PerformanceReport>;
  generateHTML(report: PerformanceReport): Promise<string>;
  generatePDF(report: PerformanceReport): Promise<Buffer>;
  generateCSV(report: PerformanceReport): Promise<string>;
}

// 报告生成器实现
class LowCodeReportGenerator implements ReportGenerator {
  private metricsCollector: MetricsCollector;
  private templateEngine: TemplateEngine;
  
  constructor(metricsCollector: MetricsCollector, templateEngine: TemplateEngine) {
    this.metricsCollector = metricsCollector;
    this.templateEngine = templateEngine;
  }
  
  async generate(config: ReportConfig): Promise<PerformanceReport> {
    const reportId = this.generateReportId();
    const sections: ReportSection[] = [];
    
    // 生成各个部分
    for (const sectionConfig of config.sections) {
      const section = await this.generateSection(sectionConfig, config.timeRange);
      sections.push(section);
    }
    
    const report: PerformanceReport = {
      id: reportId,
      title: config.title,
      timeRange: config.timeRange,
      sections,
      generatedAt: new Date(),
      format: config.format
    };
    
    // 发送给收件人（如果配置了）
    if (config.recipients && config.recipients.length > 0) {
      await this.sendReport(report, config.recipients);
    }
    
    return report;
  }
  
  async generateHTML(report: PerformanceReport): Promise<string> {
    const template = `
      <!DOCTYPE html>
      <html>
      <head>
        <title>{{title}}</title>
        <style>
          body { font-family: Arial, sans-serif; margin: 20px; }
          .header { border-bottom: 2px solid #333; padding-bottom: 10px; }
          .section { margin: 20px 0; }
          .chart { width: 100%; height: 400px; border: 1px solid #ddd; }
          table { width: 100%; border-collapse: collapse; }
          th, td { border: 1px solid #ddd; padding: 8px; text-align: left; }
          th { background-color: #f2f2f2; }
        </style>
      </head>
      <body>
        <div class="header">
          <h1>{{title}}</h1>
          <p>Generated: {{generatedAt}}</p>
          <p>Time Range: {{timeRange.start}} - {{timeRange.end}}</p>
        </div>
        
        {{#sections}}
        <div class="section">
          <h2>{{title}}</h2>
          {{#if isChart}}
            <div class="chart">Chart: {{content.chartType}}</div>
          {{/if}}
          {{#if isTable}}
            <table>
              <thead>
                <tr>
                  {{#content.headers}}
                  <th>{{this}}</th>
                  {{/content.headers}}
                </tr>
              </thead>
              <tbody>
                {{#content.rows}}
                <tr>
                  {{#this}}
                  <td>{{this}}</td>
                  {{/this}}
                </tr>
                {{/content.rows}}
              </tbody>
            </table>
          {{/if}}
          {{#if isText}}
            <p>{{content}}</p>
          {{/if}}
        </div>
        {{/sections}}
      </body>
      </html>
    `;
    
    return this.templateEngine.render(template, report);
  }
  
  async generatePDF(report: PerformanceReport): Promise<Buffer> {
    const html = await this.generateHTML(report);
    // 这里需要使用PDF生成库，如puppeteer或类似工具
    // 简化实现，返回空Buffer
    return Buffer.from(html, 'utf-8');
  }
  
  async generateCSV(report: PerformanceReport): Promise<string> {
    const csvLines: string[] = [];
    
    // 添加报告头信息
    csvLines.push(`Report,${report.title}`);
    csvLines.push(`Generated,${report.generatedAt.toISOString()}`);
    csvLines.push(`Time Range,${report.timeRange.start.toISOString()} - ${report.timeRange.end.toISOString()}`);
    csvLines.push(''); // 空行
    
    // 添加各个部分的数据
    for (const section of report.sections) {
      csvLines.push(`Section,${section.title}`);
      
      if (section.type === SectionType.TABLE && section.content.headers && section.content.rows) {
        // 添加表格数据
        csvLines.push(section.content.headers.join(','));
        for (const row of section.content.rows) {
          csvLines.push(row.join(','));
        }
      } else if (section.type === SectionType.SUMMARY) {
        // 添加摘要数据
        for (const [key, value] of Object.entries(section.content)) {
          csvLines.push(`${key},${value}`);
        }
      }
      
      csvLines.push(''); // 空行
    }
    
    return csvLines.join('\n');
  }
  
  private async generateSection(config: SectionConfig, timeRange: TimeRange): Promise<ReportSection> {
    const metrics = await this.metricsCollector.getMetrics({
      startTime: timeRange.start,
      endTime: timeRange.end
    });
    
    let content: any;
    
    switch (config.type) {
      case SectionType.SUMMARY:
        content = this.generateSummaryContent(metrics, config.metrics);
        break;
        
      case SectionType.CHART:
        content = this.generateChartContent(metrics, config.metrics, config.chartType);
        break;
        
      case SectionType.TABLE:
        content = this.generateTableContent(metrics, config.metrics);
        break;
        
      case SectionType.TEXT:
        content = this.generateTextContent(metrics, config.metrics);
        break;
        
      default:
        content = {};
    }
    
    return {
      title: config.title,
      type: config.type,
      content
    };
  }
  
  private generateSummaryContent(metrics: PerformanceMetrics[], metricNames: string[]): any {
    const summary: any = {};
    
    for (const metricName of metricNames) {
      const values = this.extractMetricValues(metrics, metricName);
      if (values.length > 0) {
        summary[metricName] = {
          average: values.reduce((sum, val) => sum + val, 0) / values.length,
          min: Math.min(...values),
          max: Math.max(...values),
          count: values.length
        };
      }
    }
    
    return summary;
  }
  
  private generateChartContent(metrics: PerformanceMetrics[], metricNames: string[], chartType?: ChartType): any {
    const chartData: any = {
      chartType: chartType || ChartType.LINE,
      datasets: []
    };
    
    for (const metricName of metricNames) {
      const values = this.extractMetricValues(metrics, metricName);
      const timestamps = metrics.map(m => m.timestamp);
      
      chartData.datasets.push({
        label: metricName,
        data: values,
        timestamps
      });
    }
    
    return chartData;
  }
  
  private generateTableContent(metrics: PerformanceMetrics[], metricNames: string[]): any {
    const headers = ['Timestamp', ...metricNames];
    const rows: any[][] = [];
    
    for (const metric of metrics) {
      const row = [metric.timestamp.toISOString()];
      
      for (const metricName of metricNames) {
        const values = this.extractMetricValues([metric], metricName);
        row.push(values.length > 0 ? values[0] : 'N/A');
      }
      
      rows.push(row);
    }
    
    return { headers, rows };
  }
  
  private generateTextContent(metrics: PerformanceMetrics[], metricNames: string[]): string {
    const analysis: string[] = [];
    
    analysis.push(`Performance analysis for ${metrics.length} data points:`);
    
    for (const metricName of metricNames) {
      const values = this.extractMetricValues(metrics, metricName);
      if (values.length > 0) {
        const avg = values.reduce((sum, val) => sum + val, 0) / values.length;
        analysis.push(`${metricName}: Average ${avg.toFixed(2)}`);
      }
    }
    
    return analysis.join('\n');
  }
  
  private extractMetricValues(metrics: PerformanceMetrics[], metricName: string): number[] {
    const values: number[] = [];
    
    for (const metric of metrics) {
      let value: number | undefined;
      
      switch (metricName) {
        case 'cpu_usage':
          value = metric.cpuUsage;
          break;
        case 'memory_usage':
          value = metric.memoryUsage;
          break;
        case 'response_time':
          value = metric.responseTime;
          break;
        case 'request_count':
          value = metric.requestCount;
          break;
        case 'error_count':
          value = metric.errorCount;
          break;
        default:
          value = metric.customMetrics?.[metricName];
      }
      
      if (value !== undefined) {
        values.push(value);
      }
    }
    
    return values;
  }
  
  private async sendReport(report: PerformanceReport, recipients: string[]): Promise<void> {
    // 实现报告发送逻辑
    console.log(`Sending report "${report.title}" to ${recipients.join(', ')}`);
  }
  
  private generateReportId(): string {
    return `report_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
  }
}

// 模板引擎接口
interface TemplateEngine {
  render(template: string, data: any): string;
}

// 简单模板引擎实现
class SimpleTemplateEngine implements TemplateEngine {
  render(template: string, data: any): string {
    let result = template;
    
    // 简单的模板替换实现
    result = result.replace(/{{(\w+)}}/g, (match, key) => {
      return data[key] || match;
    });
    
    // 处理嵌套属性
    result = result.replace(/{{(\w+)\.(\w+)}}/g, (match, obj, key) => {
      return data[obj] && data[obj][key] || match;
    });
    
    return result;
  }
}

”`