《移动游戏产品的架构·网络、资源与热更新》7.1 一次会话的流量构成

// file: src/net/traffic-ledger.ts
// tier: L1
// verify: node --test test/net/traffic-ledger.test.ts

export const CHANNELS = ["biz", "heartbeat", "telemetry", "resync"] as const;

export type Channel = (typeof CHANNELS)[number];

export interface LedgerEntry {
  readonly channel: Channel;
  readonly payloadBytes: number;
  readonly frames: number;
}

export interface Ledger {
  readonly entries: readonly LedgerEntry[];
  readonly frameOverheadBytes: number;
}

export interface ChannelSlot {
  readonly channel: Channel;
  readonly payloadBytes: number;
  readonly wireBytes: number;
  readonly frames: number;
  readonly share: number;
}

export interface LedgerSummary {
  readonly slots: readonly ChannelSlot[];
  readonly totalPayloadBytes: number;
  readonly totalWireBytes: number;
  readonly totalFrames: number;
}

export function createLedger(frameOverheadBytes = 0): Ledger {
  if (!Number.isInteger(frameOverheadBytes) || frameOverheadBytes < 0) {
    throw new RangeError(`frame overhead must be a non-negative integer: ${frameOverheadBytes}`);
  }
  return { entries: [], frameOverheadBytes };
}

export function record(
  ledger: Ledger,
  channel: Channel,
  payloadBytes: number,
  frames = 1,
): Ledger {
  if (!Number.isInteger(payloadBytes) || payloadBytes < 0) {
    throw new RangeError(`payload bytes must be a non-negative integer: ${payloadBytes}`);
  }
  if (!Number.isInteger(frames) || frames <= 0) {
    throw new RangeError(`frames must be a positive integer: ${frames}`);
  }
  return {
    entries: [...ledger.entries, { channel, payloadBytes, frames }],
    frameOverheadBytes: ledger.frameOverheadBytes,
  };
}

export function summarize(ledger: Ledger): LedgerSummary {
  let totalPayloadBytes = 0;
  let totalWireBytes = 0;
  let totalFrames = 0;
  const slots: ChannelSlot[] = [];

  for (const channel of CHANNELS) {
    const entries = ledger.entries.filter((entry) => entry.channel === channel);
    const payloadBytes = entries.reduce((sum, entry) => sum + entry.payloadBytes, 0);
    const frames = entries.reduce((sum, entry) => sum + entry.frames, 0);
    const wireBytes = payloadBytes + frames * ledger.frameOverheadBytes;
    totalPayloadBytes += payloadBytes;
    totalWireBytes += wireBytes;
    totalFrames += frames;
    slots.push({ channel, payloadBytes, wireBytes, frames, share: 0 });
  }

  return {
    slots: slots.map((slot) => ({
      ...slot,
      share: totalWireBytes === 0 ? 0 : slot.wireBytes / totalWireBytes,
    })),
    totalPayloadBytes,
    totalWireBytes,
    totalFrames,
  };
}

export function estimateSessionBytes(
  perMessageBytes: number,
  messageCount: number,
  frameOverheadBytes = 0,
): number {
  if (!Number.isInteger(perMessageBytes) || perMessageBytes < 0) {
    throw new RangeError(`per-message bytes must be a non-negative integer: ${perMessageBytes}`);
  }
  if (!Number.isInteger(messageCount) || messageCount < 0) {
    throw new RangeError(`message count must be a non-negative integer: ${messageCount}`);
  }
  if (!Number.isInteger(frameOverheadBytes) || frameOverheadBytes < 0) {
    throw new RangeError(`frame overhead must be a non-negative integer: ${frameOverheadBytes}`);
  }
  return messageCount * (perMessageBytes + frameOverheadBytes);
}

export function projectMonthlyBytes(perDauDailyBytes: number, dau: number, days = 30): number {
  if (!Number.isFinite(perDauDailyBytes) || perDauDailyBytes < 0) {
    throw new RangeError(`per-DAU daily bytes must be non-negative: ${perDauDailyBytes}`);
  }
  if (!Number.isInteger(dau) || dau < 0) {
    throw new RangeError(`DAU must be a non-negative integer: ${dau}`);
  }
  if (!Number.isInteger(days) || days <= 0) {
    throw new RangeError(`days must be a positive integer: ${days}`);
  }
  return perDauDailyBytes * dau * days;
}

export function formatBytes(bytes: number): string {
  if (!Number.isFinite(bytes) || bytes < 0) {
    throw new RangeError(`bytes must be a non-negative finite number: ${bytes}`);
  }
  if (bytes < 1024) {
    return `${bytes} B`;
  }
  const units = ["KB", "MB", "GB", "TB"];
  let value = bytes / 1024;
  let unitIndex = 0;
  while (value >= 1024 && unitIndex < units.length - 1) {
    value /= 1024;
    unitIndex += 1;
  }
  return `${value.toFixed(1)} ${units[unitIndex]}`;
}

export function describeLedger(summary: LedgerSummary): string {
  const parts = summary.slots
    .filter((slot) => slot.frames > 0)
    .map((slot) => `${slot.channel} ${formatBytes(slot.wireBytes)}（${(slot.share * 100).toFixed(1)}%）`);
  const body = parts.length === 0 ? "无记录" : parts.join("，");
  return `会话流量 ${formatBytes(summary.totalWireBytes)}，共 ${summary.totalFrames} 帧：${body}`;
}