合成监控：主动保障用户体验

┌──────────────────────────────────────────────────────┐
│                合成监控工作流程                         │
│                                                      │
│  ┌──────────────┐                                   │
│  │ 探测节点集群   │  ← 全球分布的探测节点               │
│  │ (Beijing/    │                                   │
│  │  Shanghai/   │                                   │
│  │  Overseas)   │                                   │
│  └──────┬───────┘                                   │
│         │                                            │
│         │ 定时执行探测脚本                              │
│         ▼                                            │
│  ┌──────────────┐    ┌──────────────┐              │
│  │  模拟用户行为  │ ──→ │  目标系统     │              │
│  │  • 打开页面   │    │  (Web/API)   │              │
│  │  • 点击按钮   │    └──────┬───────┘              │
│  │  • 填写表单   │           │                      │
│  │  • 调用 API   │           │                      │
│  └──────┬───────┘           │                      │
│         │                    │                      │
│         ▼                    │                      │
│  ┌──────────────┐           │                      │
│  │  记录结果     │ ←─────────┘                      │
│  │  • 状态码     │                                  │
│  │  • 响应时间   │                                  │
│  │  • 页面内容   │                                  │
│  │  • 截图       │                                  │
│  │  • Trace     │                                  │
│  └──────┬───────┘                                  │
│         │                                            │
│         ▼                                            │
│  ┌──────────────┐                                   │
│  │  告警 + 仪表盘│                                   │
│  └──────────────┘                                   │
└──────────────────────────────────────────────────────┘

被动监控和合成监控互补：

被动监控：
  → 回答"系统现在的状态是什么？"
  → CPU 80%、QPS 1000、错误率 0.1%
  → 发现已有问题的症状

合成监控：
  → 回答"用户能否正常使用？"
  → 首页可访问？登录功能正常？支付流程通畅？
  → 在用户之前发现问题

两者结合 = 完整的可用性保障

电商网站关键路径：

1. 首页访问 → 页面加载 < 3s
2. 商品搜索 → 搜索结果 < 2s
3. 商品详情 → 页面渲染 < 2s
4. 加入购物车 → API 响应 < 1s
5. 结算流程 → 全流程 < 10s
6. 支付完成 → 支付回调 < 5s

每一步都是关键路径，任何一步出问题都会影响转化率。

# API 合成监控（Checkly / Grafana Synthetics）
steps:
  - name: "用户登录"
    request:
      url: https://api.example.com/auth/login
      method: POST
      headers:
        Content-Type: application/json
      body:
        email: synthetic@test.com
        password: ${SECRET_PASSWORD}
    assertions:
      - status_code == 200
      - response_time < 2000
      - body.token != null

  - name: "获取用户信息"
    request:
      url: https://api.example.com/user/profile
      method: GET
      headers:
        Authorization: Bearer {{steps[0].body.token}}
    assertions:
      - status_code == 200
      - response_time < 1000

  - name: "搜索商品"
    request:
      url: https://api.example.com/products/search?q=phone
      method: GET
      headers:
        Authorization: Bearer {{steps[0].body.token}}
    assertions:
      - status_code == 200
      - response_time < 2000
      - body.products.length > 0

// Playwright 脚本 — 模拟用户购物流程
const { chromium } = require('playwright');

async function syntheticTest() {
    const browser = await chromium.launch();
    const page = await browser.newPage();

    try {
        // 步骤 1：访问首页
        await page.goto('https://www.example.com', { timeout: 10000 });
        await page.waitForLoadState('networkidle');
        const pageTitle = await page.title();
        assert(pageTitle.includes('商城'), '首页标题正确');

        // 步骤 2：搜索商品
        await page.fill('#search-box', '手机');
        await page.click('#search-button');
        await page.waitForSelector('.product-list .product-item', { timeout: 5000 });

        const productCount = await page.locator('.product-item').count();
        assert(productCount > 0, '搜索结果不为空');

        // 步骤 3：点击商品详情
        await page.click('.product-item:first-child');
        await page.waitForSelector('.product-detail', { timeout: 5000 });

        // 步骤 4：加入购物车
        await page.click('#add-to-cart');
        await page.waitForSelector('.cart-success', { timeout: 3000 });

        // 步骤 5：进入结算
        await page.click('#checkout');
        await page.waitForURL('**/checkout/**', { timeout: 5000 });

        console.log('✓ 合成监控通过：购物流程正常');
        await page.screenshot({ path: 'success.png' });

    } catch (error) {
        console.error('✗ 合成监控失败:', error.message);
        await page.screenshot({ path: 'failure.png' });
        throw error;
    } finally {
        await browser.close();
    }
}

module.exports = syntheticTest;

┌─────────────────────────────────────────────────────┐
│                   监控分层模型                        │
│                                                     │
│  Layer 4: 合成监控 (主动)                            │
│  → 模拟用户行为，发现"用户能否使用"                    │
│  → 在用户之前发现问题                                 │
│                                                     │
│  Layer 3: 被动监控 (Metrics)                        │
│  → 采集系统指标，发现"系统是否健康"                    │
│  → 实时反映系统状态                                   │
│                                                     │
│  Layer 2: 日志监控 (Logs)                           │
│  → 搜索日志内容，发现"出了什么问题"                    │
│  → 提供排障证据                                      │
│                                                     │
│  Layer 1: 链路追踪 (Traces)                         │
│  → 追踪请求路径，发现"问题在哪里"                      │
│  → 精确定位故障点                                    │
└─────────────────────────────────────────────────────┘

合成监控发现首页响应慢（> 5s）
    │
    ▼
查看合成监控的 Trace 信息
    │
    ├── DNS 解析 0.5s (正常)
    ├── TCP 连接 0.2s (正常)
    ├── TLS 握手 0.3s (正常)
    ├── 服务端处理 3.5s (异常！)
    └── 页面渲染 0.5s (正常)
    │
    ▼
跳转到链路追踪（通过 TraceID 关联）
    │
    ├── API Gateway: 0.1s
    ├── User Service: 0.2s
    ├── Product Service: 2.8s ← 瓶颈！
    │   └── Database Query: 2.5s ← 根因！
    └── Cart Service: 0.3s
    │
    ▼
查看 Product Service 日志
    │
    └── 发现慢查询: SELECT * FROM products WHERE ...
    │
    ▼
修复：添加索引 / 优化 SQL

单地域探测的盲区：

探测节点在北京
  → 北京访问正常 ✓
  → 上海用户可能无法访问 ✗（看不到）
  → 广州用户可能访问慢 ✗（看不到）
  → 海外用户可能 DNS 解析错误 ✗（看不到）

多地域探测：

探测节点在北京、上海、广州、海外
  → 北京访问正常 ✓
  → 上海访问正常 ✓
  → 广州发现延迟 > 3s ⚠️
  → 海外发现 DNS 解析失败 🔴
  → 每个地域的用户体验都被覆盖

┌─── 北京探测节点 ──────────┐
│  API 测试 + 浏览器测试      │
│  → 探测全国入口             │
└──────────────────────────┘

┌─── 上海探测节点 ──────────┐
│  API 测试 + 浏览器测试      │
│  → 探测华东入口             │
└──────────────────────────┘

┌─── 广州探测节点 ──────────┐
│  API 测试 + 浏览器测试      │
│  → 探测华南入口             │
└──────────────────────────┘

┌─── 海外探测节点 ──────────┐
│  API 测试 + 浏览器测试      │
│  → 探测海外入口             │
└──────────────────────────┘

         │
         ▼
  ┌──────────────┐
  │  集中存储     │
  │  (Prometheus)│
  └──────┬───────┘
         │
         ▼
  ┌──────────────┐
  │   Grafana    │
  │  多地域对比   │
  └──────────────┘

groups:
  - name: synthetic-multi-region
    rules:
      # 所有地域都失败 → critical
      - alert: SyntheticAllRegionsDown
        expr: |
          count by(target) (synthetic_probe_success == 0) >= 4          
        for: 2m
        labels:
          severity: critical
        annotations:
          summary: "所有地域探测失败: {{ $labels.target }}"
          description: "4 个地域同时探测失败，服务可能完全不可用"

      # 多数地域失败 → critical
      - alert: SyntheticMostRegionsDown
        expr: |
          count by(target) (synthetic_probe_success == 0) >= 3          
        for: 3m
        labels:
          severity: critical
        annotations:
          summary: "多数地域探测失败: {{ $labels.target }}"

      # 单地域失败 → warning
      - alert: SyntheticSingleRegionDown
        expr: |
          synthetic_probe_success == 0
          and on(target)
          count by(target) (synthetic_probe_success == 0) < 3          
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "单地域探测失败: {{ $labels.target }} ({{ $labels.region }})"
          description: "仅 {{ $labels.region }} 探测失败，可能是区域网络问题"

      # 地域间延迟差异过大
      - alert: SyntheticLatencyVariance
        expr: |
          (max by(target) (synthetic_probe_duration_seconds) -
           min by(target) (synthetic_probe_duration_seconds)) > 3          
        for: 10m
        labels:
          severity: warning
        annotations:
          summary: "地域间延迟差异过大: {{ $labels.target }}"
          description: "最快与最慢地域延迟差异超过 3 秒"

# GitHub Actions 集成合成监控
name: Synthetic Monitoring

on:
  schedule:
    - cron: '*/5 * * * *'  # 每 5 分钟执行
  workflow_dispatch:        # 手动触发

jobs:
  synthetic-test:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        region: [beijing, shanghai, guangzhou]
    steps:
      - uses: actions/checkout@v4

      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'

      - name: Install dependencies
        run: npm install playwright @playwright/test

      - name: Run synthetic test
        env:
          REGION: ${{ matrix.region }}
          BASE_URL: ${{ vars[format('BASE_URL_{0}', matrix.region)] }}
        run: node synthetic-tests/critical-path.js

      - name: Upload screenshots on failure
        if: failure()
        uses: actions/upload-artifact@v4
        with:
          name: failure-screenshots-${{ matrix.region }}
          path: screenshots/

// synthetic-tests/critical-path.js
const { chromium } = require('playwright');
const { PrometheusPushgateway } = require('prom-client');

const pg = new PrometheusPushgateway('http://pushgateway:9091');

async function runSyntheticTest() {
    const startTime = Date.now();
    const browser = await chromium.launch({
        args: ['--no-sandbox']
    });

    let success = 1;
    let errorMessage = '';

    try {
        const page = await browser.newPage();

        // 注入性能监控
        await page.route('**/*', async (route) => {
            const response = await route.fetch();
            const timing = Date.now() - startTime;
            console.log(`${route.request().url()}: ${response.status()} (${timing}ms)`);
            route.fulfill({ response });
        });

        // 步骤 1：访问首页
        const homeStart = Date.now();
        await page.goto(process.env.BASE_URL, { timeout: 15000 });
        await page.waitForLoadState('networkidle');
        const homeDuration = (Date.now() - homeStart) / 1000;

        if (homeDuration > 3) {
            throw new Error(`首页加载过慢: ${homeDuration}s`);
        }

        // 步骤 2：验证关键元素
        const heroSection = await page.$('.hero-section');
        if (!heroSection) {
            throw new Error('首页关键元素缺失');
        }

        // 步骤 3：测试搜索功能
        const searchStart = Date.now();
        await page.fill('#search-input', 'test product');
        await page.click('#search-submit');
        await page.waitForSelector('.search-results', { timeout: 5000 });
        const searchDuration = (Date.now() - searchStart) / 1000;

        if (searchDuration > 2) {
            throw new Error(`搜索响应过慢: ${searchDuration}s`);
        }

        console.log('✓ 合成监控全部通过');

    } catch (error) {
        success = 0;
        errorMessage = error.message;
        console.error('✗ 合成监控失败:', errorMessage);

        // 截图保存
        const page = await browser.newPage();
        await page.goto(process.env.BASE_URL);
        await page.screenshot({ path: `screenshots/failure-${Date.now()}.png` });
    } finally {
        await browser.close();
    }

    // 推送指标到 Prometheus
    const duration = (Date.now() - startTime) / 1000;
    await pg.pushAdd({
        synthetic_probe_success: {
            value: success,
            labels: {
                target: process.env.BASE_URL,
                region: process.env.REGION
            }
        },
        synthetic_probe_duration_seconds: {
            value: duration,
            labels: {
                target: process.env.BASE_URL,
                region: process.env.REGION
            }
        }
    });

    if (success === 0) {
        process.exit(1);
    }
}

runSyntheticTest();

# Grafana Synthetic Monitoring 配置
probes:
  - id: probe-us-east
    region: us-east-1
  - id: probe-eu-west
    region: eu-west-1
  - id: probe-ap-south
    region: ap-south-1

checks:
  - name: "Homepage HTTP"
    type: HTTP
    config:
      url: https://www.example.com
      method: GET
      headers:
        User-Agent: "Grafana-Synthetic"
    assertions:
      - status_code == 200
      - response_time < 3000
    frequency: 60s
    probes: [probe-us-east, probe-eu-west, probe-ap-south]

  - name: "Login API"
    type: HTTP
    config:
      url: https://api.example.com/auth/login
      method: POST
      body: '{"email":"test@example.com","password":"***"}'
    assertions:
      - status_code == 200
      - response_time < 2000
    frequency: 300s
    probes: [probe-us-east, probe-eu-west]

  - name: "Checkout Flow"
    type: Browser
    config:
      script: |
        await page.goto('https://www.example.com');
        await page.fill('#search', 'phone');
        await page.click('#search-btn');
        await page.waitForSelector('.product-item');
        await page.click('.product-item:first-child #add-to-cart');
        await page.waitForSelector('.cart-success');        
    frequency: 600s
    probes: [probe-us-east]

# Prometheus 配置 — Blackbox 作为合成监控
scrape_configs:
  - job_name: 'synthetic-api'
    metrics_path: /probe
    params:
      module: [http_2xx]
    static_configs:
      - targets:
          - https://www.example.com              # 首页
          - https://api.example.com/health        # API 健康检查
          - https://api.example.com/v1/products   # 商品 API
        labels:
          synthetic: 'true'
          type: 'api'
    relabel_configs:
      - source_labels: [__address__]
        target_label: __param_target
      - source_labels: [__param_target]
        target_label: instance
      - target_label: __address__
        replacement: blackbox:9115

你的合成监控需求是什么？

只需要 API/TCP 拨测？
  ├── 是 → Blackbox Exporter（免费，够用）
  └── 否 → 需要浏览器测试？

需要浏览器测试？
  ├── 是 → 已有 Grafana 生态？
  │         ├── 是 → Grafana Synthetic Monitoring
  │         └── 否 → Checkly（专注，性价比好）
  └── 否 → 只需要 API 拨测 + 全球节点？
            ├── 是 → Pingdom（简单可靠）
            └── 否 → 已有 Datadog/New Relic？
                      ├── 是 → 用平台自带 Synthetics
                      └── 否 → Grafana Synthetic Monitoring

# 可用性 SLO（30 天窗口）
avg_over_time(synthetic_probe_success[30d]) * 100

# 按目标和地域
avg by(target, region) (avg_over_time(synthetic_probe_success[30d])) * 100

# 响应时间 SLO
histogram_quantile(0.95,
  sum by(le, target) (rate(synthetic_probe_duration_seconds_bucket[5m]))
)

# 成功率趋势
avg_over_time(synthetic_probe_success[1h]) * 100

groups:
  - name: synthetic-slo
    rules:
      # 可用性 SLO 违约（30 天 < 99.9%）
      - alert: SyntheticAvailabilitySLOBreach
        expr: |
          avg by(target) (avg_over_time(synthetic_probe_success[30d])) < 0.999          
        for: 5m
        labels:
          severity: warning
          slo: availability-999
        annotations:
          summary: "合成监控可用性 SLO 违约: {{ $labels.target }}"
          description: "近 30 天可用性低于 99.9%"

      # 响应时间 SLO 违约（P95 > 3s）
      - alert: SyntheticLatencySLOBreach
        expr: |
          histogram_quantile(0.95,
            sum by(le, target) (rate(synthetic_probe_duration_seconds_bucket[5m]))
          ) > 3          
        for: 10m
        labels:
          severity: warning
        annotations:
          summary: "合成监控延迟 SLO 违约: {{ $labels.target }}"
          description: "P95 响应时间超过 3 秒"

synthetic-tests/
├── api/
│   ├── health-check.js        # API 健康检查
│   ├── auth-flow.js           # 登录流程
│   ├── product-search.js      # 商品搜索
│   └── checkout-flow.js       # 结算流程
├── browser/
│   ├── homepage.js            # 首页加载
│   ├── search-and-buy.js     # 搜索到购买全流程
│   └── mobile-responsive.js   # 移动端适配
├── config/
│   ├── environments.json      # 环境配置
│   └── thresholds.json        # 阈值配置
└── lib/
    ├── prometheus.js          # 指标推送
    └── alerting.js            # 告警逻辑

# 在应用中识别合成监控流量
# 方式 1：特殊 User-Agent
headers:
  User-Agent: "Synthetic-Monitor/1.0"

# 方式 2：特殊 Header
headers:
  X-Synthetic-Monitor: "true"
  X-Synthetic-Test-ID: "checkout-flow-001"

# 方式 3：专用测试账号
auth:
  email: synthetic-monitor@example.com
  password: ${SYNTHETIC_PASSWORD}

// 排除合成监控流量
if (request.getHeader("X-Synthetic-Monitor") != null) {
    // 不计入业务指标
    // 不写入业务日志
    // 不触发 A/B 测试
}

┌─────────────────────────────────────────────────────────┐
│              合成监控仪表盘                                │
│                                                         │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐             │
│  │ 总探测数  │  │ 成功率    │  │ 平均延迟  │             │
│  │   8,640  │  │  99.5%   │  │  1.2s    │             │
│  └──────────┘  └──────────┘  └──────────┘             │
│                                                         │
│  ┌─────────────────────────────────────────────┐       │
│  │  各路径成功率（30 天趋势）                    │       │
│  │  首页     ━━━━━━━━━━━━━━━━━━ 100%           │       │
│  │  搜索     ━━━━━━━━━━━━━━━━━━ 99.8%          │       │
│  │  登录     ━━━━━━━━━━━━━━━━━━ 99.5%          │       │
│  │  结算     ━━━━━━━━━━━━━━━━━━ 98.2% ⚠️       │       │
│  │  支付     ━━━━━━━━━━━━━━━━━━ 99.9%          │       │
│  └─────────────────────────────────────────────┘       │
│                                                         │
│  ┌─────────────────────────────────────────────┐       │
│  │  多地域延迟对比                                │       │
│  │  北京  ━━━━━━━━━━━━ 0.8s                    │       │
│  │  上海  ━━━━━━━━━━━━━━ 1.0s                  │       │
│  │  广州  ━━━━━━━━━━━━━━━━━━ 1.5s              │       │
│  │  海外  ━━━━━━━━━━━━━━━━━━━━━━━━ 2.5s ⚠️   │       │
│  └─────────────────────────────────────────────┘       │
│                                                         │
│  ┌──────────────────────┐ ┌──────────────────────┐    │
│  │ 最近失败的探测         │ │ SSL 证书到期           │    │
│  │ Target | Time | Error│ │ 域名 | 剩余天数        │    │
│  └──────────────────────┘ └──────────────────────┘    │
└─────────────────────────────────────────────────────────┘

# 分级告警
- alert: SyntheticAPIFailure
  expr: synthetic_probe_success{type="api"} == 0
  for: 1m
  labels:
    severity: critical
  annotations:
    summary: "API 探测失败: {{ $labels.target }}"

- alert: SyntheticBrowserFailure
  expr: synthetic_probe_success{type="browser"} == 0
  for: 3m   # 浏览器测试允许更多重试时间
  labels:
    severity: warning
  annotations:
    summary: "浏览器探测失败: {{ $labels.target }}"

- alert: SyntheticLatencyDegradation
  expr: |
    avg_over_time(synthetic_probe_duration_seconds[1h]) >
    2 * avg_over_time(synthetic_probe_duration_seconds[7d])    
  for: 15m
  labels:
    severity: warning
  annotations:
    summary: "响应时间退化: {{ $labels.target }}"
    description: "当前延迟是过去 7 天平均值的 2 倍以上"