高性能架构设计

// QPS = 总请求数 / 时间窗口（秒）
const qps = 6000 / 60; // 100 QPS

// TPS = 总事务数 / 时间窗口（秒）
const tps = 18000 / 3600; // 5 TPS

并发量 = QPS × 平均响应时间（秒）

const client = require('prom-client');

// 请求耗时直方图
const httpRequestDuration = new client.Histogram({
  name: 'http_request_duration_seconds',
  help: 'Duration of HTTP requests in seconds',
  labelNames: ['method', 'route', 'status_code'],
  buckets: [0.1, 0.5, 1, 1.5, 2, 5]
});

// 请求计数（用于计算 QPS）
const qpsCounter = new client.Counter({
  name: 'http_requests_total',
  help: 'Total number of HTTP requests',
  labelNames: ['method', 'route']
});

// Express 中间件
app.use((req, res, next) => {
  const start = Date.now();
  res.on('finish', () => {
    const duration = (Date.now() - start) / 1000;
    httpRequestDuration.labels(req.method, req.route?.path, res.statusCode).observe(duration);
    qpsCounter.labels(req.method, req.route?.path).inc();
  });
  next();
});

// 暴露 /metrics 端点供 Prometheus 抓取
app.get('/metrics', async (req, res) => {
  res.set('Content-Type', client.register.contentType);
  res.end(await client.register.metrics());
});

# prometheus.yml
global:
  scrape_interval: 15s

scrape_configs:
  - job_name: 'nodejs-app'
    static_configs:
      - targets: ['localhost:3000']

config:
  target: 'http://localhost:3000'
  phases:
    - duration: 60
      arrivalRate: 10
      name: "Warm up"
    - duration: 120
      arrivalRate: 10
      rampTo: 50
      name: "Ramp up"
    - duration: 300
      arrivalRate: 50
      name: "Sustained load"

scenarios:
  - name: "User browsing"
    flow:
      - get: { url: "/api/products" }
      - think: 2
      - get: { url: "/api/products/{{ $randomNumber(1, 100) }}" }

class CacheManager {
  constructor() {
    this.local = new Map();
    this.redis = new Redis();
  }

  async get(key) {
    // L1: 本地缓存
    if (this.local.has(key)) return this.local.get(key);
    // L2: Redis
    const cached = await this.redis.get(key);
    if (cached) { this.local.set(key, cached); return cached; }
    // L3: 数据库回源
    const data = await this.queryDB(key);
    if (data) {
      await this.redis.set(key, data, 'EX', 3600);
      this.local.set(key, data);
    }
    return data;
  }
}

// 订单创建 — 异步优化
async function createOrder(orderData) {
  const order = await Order.create(orderData); // 核心：同步

  // 非核心：投递消息队列
  MessageQueue.publish('order.created', {
    orderId: order.id,
    userId: order.userId
  });

  return order; // 立即返回
}

// 消费者异步处理
MessageQueue.subscribe('order.created', async ({ userId }) => {
  await Email.send(userId, '订单创建成功');
  await SMS.send(userId, '订单创建成功');
});

class DatabaseManager {
  constructor() {
    this.master = createConnection({ host: 'master.db' });
    this.slaves = [
      createConnection({ host: 'slave1.db' }),
      createConnection({ host: 'slave2.db' })
    ];
    this.idx = 0;
  }

  write(sql, params) { return this.master.query(sql, params); }

  read(sql, params) {
    const slave = this.slaves[this.idx % this.slaves.length];
    this.idx++;
    return slave.query(sql, params);
  }
}