全栈工程师的第 90 天：AI 上线三个月后，哪些东西会静默坏掉

层级

现象

常规监控可见吗

谁先发现

崩溃层

进程死、超时、 5xx

可见，秒级告警

值班工程师

错误层

返回了格式错误的输出、工具调用失败

多数可见（前提是你校验了输出）

监控或用户

漂移层

一切正常，但输出悄悄变了

不可见

用户，通常在几天到几周后

一句话记住：第一层和第二层故障在跟你说话，第三层故障在跟你装死。运维的第一原则是：给你不拥有的东西装上传感器。

TypeScript

import { generateText } from 'ai';

import { MockLanguageModelV4 } from 'ai/test';

​

const REQUESTED = 'gpt-x';

const ACTUALLY_SERVED = 'gpt-x-2026-09-01';

​

const model = new MockLanguageModelV4({

  provider: 'acme-gateway',

  modelId: REQUESTED,

  doGenerate: [

    {

      content: [{ type: 'text', text: 'ok' }],

      finishReason: { unified: 'stop', raw: 'stop' },

      usage: { inputTokens: { total: 100, noCache: 100, cacheRead: 0, cacheWrite: 0 },

               outputTokens: { total: 10, text: 10, reasoning: 0 } },

      modelId: ACTUALLY_SERVED,

      response: { id: 'resp_1', timestamp: new Date('2026-09-30T02:00:00Z'), modelId: ACTUALLY_SERVED },

      providerMetadata: { 'acme-gateway': { servedModel: ACTUALLY_SERVED } },

    },

  ],

});

​

const r = await generateText({ model, prompt: 'hello' });

console.log(r.response.modelId);

示例文本

你请求的 = gpt-x

实际服务的 = gpt-x-2026-09-01

​

result.response.modelId = "gpt-x-2026-09-01"

   → 是否等于服务端真相？ 是（可用作漂移检测）

​

result.providerMetadata = {"acme-gateway":{"servedModel":"gpt-x-2026-09-01"}}

   → 能否读到服务端真相？ 能

示例文本

你请求的 = gpt-x | 服务端实际（假设已被换成 gpt-x-2026-09-01，但上游没说）

result.response.modelId = "gpt-x"

   → 是 undefined 还是回显了你请求的名字？ 回显了你请求的名字（危险：看起来一切正常）

result.providerMetadata = undefined

TypeScript

// result.response 的完整形状

{

  id: 'resp_abc', // 上游给的响应 ID

  timestamp: Date, // 上游给的时间戳

  modelId: '…', // 可能是真相，也可能是回声

  headers: { … }, // 原始 HTTP 响应头

  body: '…', // 原始响应体

  messages: […], // 消息记录

}

JavaScript

// @ai-sdk/openai dist/index.js（节选）

async doGenerate(options) {

  const { responseHeaders, value: response, rawValue: rawResponse } =

    await postJsonToApi({

      url: this.config.url({ path: '/chat/completions', modelId: this.modelId }),

      headers: combineHeaders(this.config.headers?.(), options.headers),

      body,

    });

​

  return {

    // …

    response: {

      …getResponseMetadata(response), // 从响应体取 id / model / created

      headers: responseHeaders, // 完整响应头（含 x-request-id 之类）

      body: rawResponse, // 原始响应体文本

    },

  };

}

TypeScript

type DriftRecord = {

  requested: string;

  served: string | null;

  drifted: boolean;

  requestId: string | null;

};

​

function collectDrift(params: {

  requested: string;

  response: { modelId?: string; headers?: Record<string, string>; body?: string };

}): DriftRecord {

  const { requested, response } = params;

​

  // 优先从原始响应体里取真相，取不到再退回 SDK 的 modelId

  let served: string | null = null;

  if (response.body) {

    try {

      const parsed = JSON.parse(response.body) as { model?: string };

      served = parsed.model ?? null;

    } catch {

      served = null; // 响应体不是 JSON，放弃

    }

  }

  served = served ?? response.modelId ?? null;

​

  const requestId =

    response.headers?.['x-request-id'] ??

    response.headers?.['request-id'] ??

    response.headers?.['x-amzn-requestid'] ??

    null;

​

  return {

    requested,

    served,

    // 关键：只有在明确拿到 served 且与请求不一致时才算 drift

    // 拿不到 served 不能当作"没漂移"，要单独计数

    drifted: served !== null && served !== requested,

    requestId,

  };

}

TypeScript

// models.ts —— 全代码库唯一的模型标识来源

export const MODELS = {

  chat: {

    id: 'gpt-x-2026-09-01', // 生产：钉死快照，禁止浮动别名

    pinnedOn: '2026-09-28',

    verifiedAgainstGoldenSet: true, // 换这个值之前必须跑过金标集

    fallback: 'claude-y-20260514', // 备胎现在就选好，不要等出事再选

    sunsetWatch: 'https://provider.example/deprecations',

  },

} as const;

TypeScript

import { generateText, APICallError, RetryError } from 'ai';

​

async function run(label: string, statusCode: number, isRetryable: boolean, maxRetriesArg?: number) {

  let calls = 0;

  const model = new MockLanguageModelV4({

    provider: 'acme',

    modelId: 'm',

    doGenerate: async () => {

      calls++;

      throw new APICallError({

        message: `HTTP ${statusCode} from upstream`,

        url: 'https://api.example/v1/chat/completions',

        requestBodyValues: { model: 'gpt-x' },

        statusCode,

        responseHeaders: {},

        responseBody: '{"error":"boom"}',

        isRetryable,

        data: { raw: 'boom' },

      });

    },

  });

​

  const t0 = Date.now();

  const opts: Record<string, unknown> = { model, prompt: 'x' };

  if (maxRetriesArg !== undefined) opts.maxRetries = maxRetriesArg;

​

  try {

    await generateText(opts as never);

    return { calls, err: '未抛错', ms: Date.now() – t0 };

  } catch (e) {

    const isRetry = RetryError.isInstance(e);

    return {

      calls,

      err: e.constructor.name,

      reason: isRetry ? e.reason : '-',

      ms: Date.now() – t0,

    };

  }

}

示例文本

场景 | 调用次数 | 错误类 | 原因 | 内部错误数 | 耗时

——————————————————————————————————–

429 可重试（默认 maxRetries） | 实际调用次数=3 | 错误类=RetryError | reason=maxRetriesExceeded | errors.length=3 | 耗时=2041ms

500 可重试（默认 maxRetries） | 实际调用次数=3 | 错误类=RetryError | reason=maxRetriesExceeded | errors.length=3 | 耗时=2005ms

400 不可重试 | 实际调用次数=1 | 错误类=APICallError | reason=- | errors.length=- | 耗时=1ms

429 但 maxRetries=0 | 实际调用次数=1 | 错误类=APICallError | reason=- | errors.length=- | 耗时=1ms

429 但 maxRetries=5（观察上限） | 实际调用次数=6 | 错误类=RetryError | reason=maxRetriesExceeded | errors.length=6 | 耗时=5005ms

示例文本

C1 无 retry-after，500，默认重试 | 调用=3 次 | 总耗时=6041ms → 纯退避开销

C2 retry-after: 2，429，默认重试 | 调用=3 次 | 总耗时=4005ms → 尊重 retry-after（被拖长）

TypeScript

// 1) 幂等键：让重复执行变成无害操作

await sendSms({

  templateId: 'order_shipped',

  to: order.phone,

  idempotencyKey: `order_shipped:${order.id}`, // 同一订单只发一条

});

​

// 2) 明确重试预算：不要让 SDK 的默认值替你决定

const r = await generateText({

  model,

  prompt,

  tools,

  maxRetries: 1, // 有副作用的链路，重试次数要压到最低

  timeout: { totalMs: 8000 }, // 并且给它一个上限

});

TypeScript

// 用户主动取消

const ac = new AbortController();

setTimeout(() => ac.abort(), 300);

await generateText({ model, prompt: 'x', abortSignal: ac.signal });

​

// 整体超时

await generateText({ model, prompt: 'x', timeout: { totalMs: 400 } });

​

// 单步超时

await generateText({ model, prompt: 'x', timeout: { stepMs: 400 } });

示例文本

用户主动取消(abortSignal):

  构造器=DOMException | name="AbortError" | message="Delay was aborted"

  是 RetryError? false | 是 APICallError? false

超时中断(timeout.totalMs):

  构造器=DOMException | name="AbortError" | message="Delay was aborted"

  是 RetryError? false | 是 APICallError? false

单步超时(timeout.stepMs):

  构造器=DOMException | name="AbortError" | message="Delay was aborted"

TypeScript

type AbortReason = 'user' | 'total-timeout' | 'step-timeout';

​

// 用一个映射把 AbortSignal 和"为什么中断"关联起来

const abortReasons = new WeakMap<AbortSignal, AbortReason>();

​

function withReason(reason: AbortReason) {

  const ac = new AbortController();

  abortReasons.set(ac.signal, reason);

  return ac;

}

​

function classifyAbort(err: unknown, signal?: AbortSignal): AbortReason | null {

  if (!(err instanceof DOMException) || err.name !== 'AbortError') return null;

  if (signal && abortReasons.has(signal)) return abortReasons.get(signal)!;

  return null; // 拿不到标记：归入 unknown，单独计数

}

​

// 使用

const ac = withReason('user');

const timer = setTimeout(() => ac.abort(), 30_000);

​

try {

  await generateText({ model, prompt, abortSignal: ac.signal });

} catch (err) {

  const why = classifyAbort(err, ac.signal);

  metrics.increment('llm.aborted', { reason: why ?? 'unknown' });

  // 只有非用户原因才告警

  if (why && why !== 'user') {

    logger.error('llm.abort.anomaly', { reason: why });

  }

  throw err;

} finally {

  clearTimeout(timer);

}

上游信号

含义

你该做什么

429 + retry-after: 5

明确让你 5 秒后再来

尊重它，不要退避得比它还久

429 无 retry-after

没说等多久

用指数退避 + 抖动，别用固定间隔

403 / 401

凭据或权限问题

别重试，直接告警（这是配置事故）

400

请求本身不合法

别重试，去看请求构造代码

500 / 502 / 503

上游自己出问题了

重试 + 考虑切备用供应商

TypeScript

// 租户级配额闸门：宁可让大租户排队，也不能让它挤死所有人

type QuotaState = { tokensUsed: number; resetAt: number };

​

class TenantQuotaGate {

  private readonly states = new Map<string, QuotaState>();

  constructor(

    private readonly perTenantLimit: number,

    private readonly windowMs: number,

  ) {}

​

  tryConsume(tenantId: string, tokens: number): { ok: true } | { ok: false; retryAfterMs: number } {

    const now = Date.now();

    let s = this.states.get(tenantId);

    if (!s || now >= s.resetAt) {

      s = { tokensUsed: 0, resetAt: now + this.windowMs };

      this.states.set(tenantId, s);

    }

    if (s.tokensUsed + tokens > this.perTenantLimit) {

      return { ok: false, retryAfterMs: s.resetAt – now }; // 让调用方去排队，而不是去打上游

    }

    s.tokensUsed += tokens;

    return { ok: true };

  }

}

层级

手段

用户体验

什么时候用

L1 模型降级

换更小 / 更快的模型

质量下降，但功能完整

主模型限流或延迟飙升

L2 供应商降级

切到备用供应商

风格略有差异

主供应商故障或额度耗尽

L3 功能降级

关掉 AI 特性，回到确定性逻辑

功能缺失，但可用

所有 AI 通道都不可用

L4 人工兜底

转人工队列

慢，但正确

降级会导致严重后果的场景

TypeScript

type Route = {

  name: string;

  model: string;

  provider: 'primary' | 'secondary';

  acceptable: (m: { goldenSetPassRate: number; p95Ms: number }) => boolean;

};

​

// 备用路线的准入标准：不是"能跑"，而是"跑得够好"

const ROUTES: Route[] = [

  {

    name: 'primary',

    model: 'gpt-x-2026-09-01',

    provider: 'primary',

    acceptable: () => true,

  },

  {

    name: 'secondary',

    model: 'claude-y-20260514',

    provider: 'secondary',

    // 关键：备用路线必须用金标集验证过，且差距在业务可接受范围内

    acceptable: (m) => m.goldenSetPassRate >= 0.9 && m.p95Ms <= 4000,

  },

];

​

function pickRoute(metrics: Record<string, { goldenSetPassRate: number; p95Ms: number }>): Route {

  const primary = ROUTES[0];

  if (primary.acceptable(metrics.primary)) return primary;

  const secondary = ROUTES[1];

  return secondary.acceptable(metrics.secondary) ? secondary : { …secondary, name: 'degraded' };

}

业务切片

线上模型

候选模型

差异

退款类工单

94%

96%

+2

物流类工单

92%

95%

+3

账号安全类工单

98%

89%

-9

其他咨询

88%

91%

+3

总体

93.0%

92.8%

-0.2

TypeScript

type Slice = {

  id: string;

  weight: number; // 业务后果权重，不是样本占比

  cases: EvalCase[];

};

​

type SliceResult = { id: string; currentPass: number; candidatePass: number; weight: number };

​

function gateOnSlices(results: SliceResult[]): { ship: boolean; blockers: string[] } {

  const blockers: string[] = [];

​

  // 规则一：任何高权重切片的绝对退步都不能超过 2 个百分点

  for (const r of results.filter((x) => x.weight >= 2)) {

    const delta = r.candidatePass – r.currentPass;

    if (delta < -0.02) blockers.push(`${r.id} 退步 ${(delta * 100).toFixed(1)}pt（高权重切片）`);

  }

​

  // 规则二：总体加权分不能下降

  const wSum = results.reduce((a, r) => a + r.weight, 0);

  const cur = results.reduce((a, r) => a + r.currentPass * r.weight, 0) / wSum;

  const cand = results.reduce((a, r) => a + r.candidatePass * r.weight, 0) / wSum;

  if (cand < cur) blockers.push(`加权总分下降 ${((cand – cur) * 100).toFixed(2)}pt`);

​

  return { ship: blockers.length === 0, blockers };

}

TypeScript

type Daily = { date: string; passRate: number };

​

function detectDrift(baseline: number[], recent: Daily[]) {

  const mean = baseline.reduce((a, b) => a + b, 0) / baseline.length;

  const sd = Math.sqrt(

    baseline.reduce((a, b) => a + (b – mean) ** 2, 0) / baseline.length,

  );

  const threshold = mean – 2 * sd;

​

  // 连续 3 天低于基线 2 个标准差，才认为是系统性变化而不是抖动

  const streak = recent.slice(-3).filter((d) => d.passRate < threshold).length;

​

  return {

    drifting: streak >= 3,

    detail: `基线 ${(mean * 100).toFixed(1)}% ±${(sd * 100).toFixed(1)}%，`

          + `阈值 ${(threshold * 100).toFixed(1)}%，近 3 天低于阈值 ${streak} 天`,

  };

}

​

// 输出指纹集合的重叠度：不依赖上游，自己就能算

function fingerprintOverlap(previous: Set<string>, current: Set<string>): number {

  let hit = 0;

  for (const h of current) if (previous.has(h)) hit++;

  return current.size === 0 ? 0 : hit / current.size;

  // 接近 1 → 行为稳定；接近 0 → 输出分布整体换了，强漂移信号

}

示例文本

第一问：代码变了吗？

  → 看最近一次部署时间、模型标识的 git diff

  → 没变？进第二问（这一步就排掉了 80% 的直觉错误方向）

​

第二问：上游变了吗？

  → 查 response.headers 里的 request-id，抽 3 条最近的成功调用

  → 从 response.body 里读服务端声明的 model 字段，跟你的期望值比对

  → 拿到漂移记录？确认是别名重指向还是静默点发布

​

第三问：是"变差"还是"变慢"？

  → p95/p99 延迟环比

  → 注意：可能是上游换了更慢的模型，而不是你的代码变慢

​

第四问：影响面多大？

  → 按业务切片看，不要只看总体

  → 找出受影响最贵的那个切片

​

第五问：要不要降级？

  → 走 L1 → L2 → L3 的决策树，按预案执行，不要在事故中现场设计

TypeScript

type CallRecord = {

  requestId: string | null; // 关联键：能凭它去问上游

  requested: string; // 你请求的模型标识

  served: string | null; // 服务端声明的模型（可能为 null）

  drifted: boolean; // requested !== served

  promptHash: string; // 输入指纹，方便回溯"同一个输入变了吗"

  outputHash: string; // 输出指纹，用于检测同类输入输出漂移

  inputTokens: number;

  cacheReadTokens: number; // 缓存命中情况（下一节详述）

  latencyMs: number;

  finishReason: string;

  abortReason: string | null; // 自己打的标记：user / total-timeout / step-timeout

  errorClass: string | null; // RetryError 还是 APICallError，决定"是否重试过"

};

​

// 一个最小的落地点：把关键字段写进结构化日志

function recordCall(r: { response: { id?: string; modelId?: string }; usage: { inputTokens: number; inputTokenDetails?: { cacheReadTokens?: number } } }, extra: Partial<CallRecord>) {

  logger.info('llm.call', {

    requestId: extra.requestId ?? null,

    requested: extra.requested,

    served: extra.served ?? null,

    drifted: extra.drifted ?? false,

    promptHash: extra.promptHash,

    outputHash: extra.outputHash,

    inputTokens: r.usage.inputTokens,

    cacheReadTokens: r.usage.inputTokenDetails?.cacheReadTokens ?? 0,

    latencyMs: extra.latencyMs,

    errorClass: extra.errorClass ?? null,

  });

}

TypeScript

inputTokens: { total: number; noCache: number; cacheRead: number; cacheWrite: number }

示例文本

— result.usage —

  键 = inputTokens, inputTokenDetails, outputTokens, outputTokenDetails, totalTokens

  JSON = {"inputTokens":10000,"inputTokenDetails":{"noCacheTokens":2000,"cacheReadTokens":7000,"cacheWriteTokens":1000},"outputTokens":300,"outputTokenDetails":{"textTokens":300,"reasoningTokens":0},"totalTokens":10300}

TypeScript

function cacheHitRate(usage: {

  inputTokens: number;

  inputTokenDetails?: { cacheReadTokens?: number; cacheWriteTokens?: number };

}): { rate: number | null; caveat: string | null } {

  const read = usage.inputTokenDetails?.cacheReadTokens ?? 0;

  const write = usage.inputTokenDetails?.cacheWriteTokens ?? 0;

​

  if (!usage.inputTokens || usage.inputTokens <= 0) {

    return { rate: null, caveat: '无输入 token，无法计算' };

  }

  if (read === 0 && write === 0) {

    // 关键：0 命中率有两种可能，必须区分

    return { rate: 0, caveat: '无缓存明细：可能是上游不上报，也可能是真的没命中' };

  }

  return { rate: read / usage.inputTokens, caveat: null };

}

现象组合

可能原因

动作

命中率下降 + 成本上升

前缀缓存失效（ prompt 结构被改动）

检查 prompt 前缀是否稳定

命中率下降 + 成本上升 + 延迟变化

上游换了路由或模型

查漂移记录

命中率不变 + 成本上升

上游调价，或输 token 变多

对账单价，检查输出长度分布

命中率显示为 0 且恒定不动

可能压根拿不到缓存字段

换供应商或改用其它口径