// 示例：计算基于历史分位数的动态阈值（伪代码逻辑）
class DynamicThresholdCalculator {
  constructor(metricName, lookbackDays = 14, percentile = 95) {
    this.metricName = metricName;
    this.lookbackDays = lookbackDays;
    this.percentile = percentile; // 使用P95作为报警基线
  }

  async calculateThreshold(timestamp) {
    // 1. 获取历史数据：过去N天，同一小时段的数据点
    const historicalData = await this.fetchHistoricalData(timestamp);
    
    // 2. 计算百分位数作为阈值基线
    const baseline = this.calculatePercentile(historicalData, this.percentile);
    
    // 3. 可设置一个容忍系数，例如基线值的1.2倍作为硬报警线
    const toleranceFactor = 1.2;
    const hardThreshold = baseline * toleranceFactor;
    
    // 4. 同时计算标准差，用于设置“软”预警区间
    const stdDev = this.calculateStdDev(historicalData);
    const warningThreshold = baseline + (2 * stdDev); // 超过均值2个标准差预警
    
    return {
      baseline,
      hardThreshold,
      warningThreshold,
      historicalSampleSize: historicalData.length
    };
  }

  calculatePercentile(data, percentile) {
    const sorted = [...data].sort((a, b) => a - b);
    const index = Math.ceil((percentile / 100) * sorted.length) - 1;
    return sorted[Math.max(0, index)];
  }
}

// 使用示例：为“首页LCP”指标设定今天14:00-15:00时段的阈值
const calculator = new DynamicThresholdCalculator('homepage_lcp', 14, 95);
const thresholds = await calculator.calculateThreshold(new Date('2024-06-20T14:30:00Z'));
console.log(`动态阈值计算结果：
  基线(P95): ${thresholds.baseline.toFixed(2)}ms
  硬报警线: ${thresholds.hardThreshold.toFixed(2)}ms
  软预警线: ${thresholds.warningThreshold.toFixed(2)}ms`);

// 示例：多维度动态阈值规则配置
const thresholdRules = [
  {
    metric: 'LCP',
    dimensions: {
      page_group: 'checkout', // 结账流程页面组
      user_tier: 'premium' // 高级用户
    },
    // 更严格的阈值：基线P90，且绝对上限为2500ms
    calculation: {
      lookbackDays: 7,
      percentile: 90,
      absoluteMax: 2500 // 无论历史数据如何，超过此值必报警
    }
  },
  {
    metric: 'CLS',
    dimensions: {
      device_type: 'mobile',
      connection_type: '4g'
    },
    // 移动端4G下，CLS容忍度稍高
    calculation: {
      lookbackDays: 14,
      percentile: 98,
      absoluteMax: 0.25
    }
  },
  {
    metric: 'FID',
    dimensions: {
      path: '/product/*', // 产品详情页路径模式
      country: 'high_latency_region' // 高延迟地区
    },
    // 高延迟地区FID阈值放宽
    calculation: {
      lookbackDays: 30,
      percentile: 99,
      scalingFactor: 1.5 // 在计算出的基线上乘以1.5倍
    }
  }
];

// 阈值匹配函数
function findMatchingThreshold(metric, currentDimensions) {
  return thresholdRules.find(rule => {
    if (rule.metric !== metric) return false;
    // 匹配所有配置的维度键值对
    return Object.entries(rule.dimensions).every(([key, value]) => {
      const currentValue = currentDimensions[key];
      // 支持通配符匹配
      if (value.includes('*')) {
        const regex = new RegExp('^' + value.replace(/\*/g, '.*') + '$');
        return regex.test(currentValue);
      }
      return currentValue === value;
    });
  });
}

// 示例：使用简单移动平均与标准差进行异常检测
class AnomalyDetector {
  constructor(windowSize = 24, sigmaThreshold = 3) {
    this.windowSize = windowSize; // 滑动窗口大小（例如24小时）
    this.sigmaThreshold = sigmaThreshold; // 标准差倍数阈值
    this.dataWindow = [];
  }

  addDataPoint(value, timestamp) {
    this.dataWindow.push({ value, timestamp });
    // 保持窗口大小
    if (this.dataWindow.length > this.windowSize) {
      this.dataWindow.shift();
    }
  }

  isAnomaly(currentValue) {
    if (this.dataWindow.length < this.windowSize) {
      return false; // 数据不足，不进行检测
    }

    const values = this.dataWindow.map(d => d.value);
    const mean = values.reduce((s, v) => s + v, 0) / values.length;
    const variance = values.reduce((s, v) => s + Math.pow(v - mean, 2), 0) / values.length;
    const stdDev = Math.sqrt(variance);

    // 计算Z-score
    const zScore = Math.abs((currentValue - mean) / stdDev);
    
    return {
      isAnomaly: zScore > this.sigmaThreshold,
      zScore,
      mean,
      stdDev,
      currentValue,
      threshold: mean + (this.sigmaThreshold * stdDev)
    };
  }
}

// 使用示例：检测API响应时间异常
const detector = new AnomalyDetector(24, 2.5);

// 模拟添加历史数据
for (let i = 0; i < 24; i++) {
  detector.addDataPoint(150 + Math.random() * 50, Date.now() - (24 - i) * 3600000);
}

// 检查新数据点是否异常
const result = detector.isAnomaly(400); // 突然飙升至400ms
if (result.isAnomaly) {
  console.warn(`检测到异常！当前值: ${result.currentValue}ms, Z-score: ${result.zScore.toFixed(2)}`);
  console.warn(`基线均值: ${result.mean.toFixed(2)}ms, 标准差: ${result.stdDev.toFixed(2)}ms`);
}

# 示例：在监控系统中配置渐进式报警规则（YAML格式）
alert_rules:
  - name: "LCP_核心页面劣化"
    metric: "largest_contentful_paint"
    conditions:
      # 阶段1：检测异常
      - stage: "detection"
        query: |
          page_group in ("checkout", "product_detail")
          AND country in ("us", "eu")
        algorithm: "dynamic_percentile"
        params:
          lookback_hours: 168
          percentile: 95
          min_samples: 100
        # 当超过P95基线时，标记为“待观察”
        action: "tag_for_review"
        
      # 阶段2：确认持续劣化
      - stage: "confirmation"
        # 在过去10分钟内，有超过70%的样本超过阈值
        condition: "percent_over_threshold > 70 over 10m"
        action: "create_low_priority_alert"
        channels: ["team_slack"]
        
      # 阶段3：严重劣化或影响用户
      - stage: "escalation"
        # 同时满足：超过绝对上限 且 影响用户数>100
        condition: "value > 4000 AND affected_users > 100 over 5m"
        action: "create_high_priority_alert"
        channels: ["pagerduty_primary"]
        auto_escalate_after: "15m"
        
      # 阶段4：自动升级
      - stage: "auto_escalation"
        condition: "alert_unacknowledged for 15m"
        action: "escalate_alert"
        channels: ["pagerduty_manager", "team_lead_sms"]

// 示例：阈值校准报告生成器
class ThresholdCalibrationReport {
  constructor(alertLogs, incidentReports) {
    this.alertLogs = alertLogs; // 过去一段时间的报警记录
    this.incidentReports = incidentReports; // 已确认的线上事故报告
  }

  generateReport(timeRange) {
    const { falsePositives, truePositives } = this.categorizeAlerts(timeRange);
    const falseNegatives = this.identifyFalseNegatives(timeRange);
    
    // 计算关键指标
    const precision = truePositives.length / (truePositives.length + falsePositives.length);
    const recall = truePositives.length / (truePositives.length + falseNegatives.length);
    const f1Score = 2 * (precision * recall) / (precision + recall);
    
    // 分析误报原因
    const falsePositiveCauses = this.analyzeFalsePositiveCauses(falsePositives);
    
    // 生成校准建议
    const recommendations = this.generateRecommendations(
      falsePositiveCauses,
      falseNegatives
    );
    
    return {
      metrics: { precision, recall, f1Score },
      summary: {
        totalAlerts: this.alertLogs.length,
        falsePositives: falsePositives.length,
        truePositives: truePositives.length,
        falseNegatives: falseNegatives.length
      },
      falsePositiveAnalysis: falsePositiveCauses,
      recommendations
    };
  }
  
  analyzeFalsePositiveCauses(falsePositives) {
    const causes = {
      seasonal_variation: 0, // 季节性波动未考虑
      business_event: 0,     // 业务活动（如促销）
      algorithm_limitation: 0, // 算法本身限制
      data_issue: 0,         // 数据质量问题
      other: 0
    };
    
    falsePositives.forEach(alert => {
      if (alert.context?.is_holiday) causes.seasonal_variation++;
      else if (alert.context?.campaign_id) causes.business_event++;
      else if (alert.algorithm_type === 'static_threshold') causes.algorithm_limitation++;
      else causes.other++;
    });
    
    return causes;
  }
  
  generateRecommendations(falsePositiveCauses, falseNegatives) {
    const recs = [];
    
    // 基于误报原因的建议
    if (falsePositiveCauses.seasonal_variation > 0) {
      recs.push("为节假日添加特殊日期日历，调整季节性模型参数");
    }
    if (falsePositiveCauses.business_event > 0) {
      recs.push("集成营销活动日历，在已知活动期间自动放宽相关指标阈值");
    }
    
    // 基于漏报的建议
    if (falseNegatives.length > 0) {
      recs.push("审查漏报案例，考虑引入更敏感的异常检测算法（如变化点检测）");
      recs.push("为关键业务流添加合成监控，作为真实用户监控的补充");
    }
    
    return recs;
  }
}

# 示例：在GitLab CI中集成基于动态阈值的性能门禁
performance_gate:
  stage: performance
  image: node:18
  script:
    # 1. 运行性能测试套件（如使用Lighthouse CI）
    - npx lhci autorun
    
    # 2. 获取当前提交的性能指标
    - |
      PERFORMANCE_METRICS=$(cat .lighthouseci/links.json | jq '[.[] | {url, summary} ]')
      echo "$PERFORMANCE_METRICS" > current_metrics.json
    
    # 3. 从性能基准服务获取动态阈值
    - |
      # 调用内部API，获取基于最近N次成功构建的动态基线
      THRESHOLDS=$(curl -s "${PERF_BASELINE_API}/thresholds?branch=${CI_COMMIT_REF_NAME}")
      echo "$THRESHOLDS" > thresholds.json
    
    # 4. 对比与决策
    - node scripts/check-performance-gate.js
  artifacts:
    paths:
      - current_metrics.json
      - thresholds.json
    reports:
      performance: lhci_reports/**/*.json
  allow_failure: false # 性能门禁必须通过

// scripts/check-performance-gate.js
const currentMetrics = require('./current_metrics.json');
const thresholds = require('./thresholds.json');

function checkPerformanceGate() {
  let hasRegression = false;
  const regressions = [];
  
  currentMetrics.forEach(pageMetric => {
    const pageUrl = pageMetric.url;
    const metricSummary = pageMetric.summary;
    
    // 对每个核心Web Vital指标进行检查
    ['LCP', 'FID', 'CLS'].forEach(metricKey => {
      const currentValue = metricSummary[metricKey]?.percentile?.[95]; // 当前P95值
      const thresholdRule = thresholds.find(t => 
        t.page_pattern.test(pageUrl) && t.metric === metricKey
      );
      
      if (currentValue && thresholdRule) {
        // 动态阈值：基线值 + 容忍偏移量
        const allowedValue = thresholdRule.baseline * (1 + thresholdRule.tolerance);
        
        // 检查是否退化超过容忍度，且统计显著（样本量足够）
        if (currentValue > allowedValue && metricSummary.sample_size > 50) {
          hasRegression = true;
          regressions.push({