# 建议使用LTS版本
node --version   # v18.x 或 v20.x
npm --version

mkdir signaling-server && cd signaling-server
npm init -y
npm install ws uuid           # 核心依赖
npm install -D typescript @types/node @types/ws ts-node-dev  # 开发工具链（可选）

signaling-server/
├── src/
│   ├── index.ts          # 入口文件
│   ├── rooms.ts          # 房间与用户状态管理
│   ├── message.ts        # 消息类型定义与校验
│   └── utils.ts          # 工具函数
├── package.json
└── tsconfig.json

// src/message.ts
export enum SignalType {
  JOIN = 'join',           // 加入房间
  LEAVE = 'leave',         // 离开房间
  OFFER = 'offer',         // SDP Offer
  ANSWER = 'answer',       // SDP Answer
  CANDIDATE = 'candidate', // ICE Candidate
  USER_LIST = 'user_list', // 房间成员列表（服务端下发）
  PEER_JOINED = 'peer_joined', // 新成员通知
  PEER_LEFT = 'peer_left',     // 成员离开通知
  ERROR = 'error'          // 错误提示
}

export interface BaseMessage {
  type: SignalType;
  roomId: string;
  from: string;            // 发送者socketId
  to?: string;             // 目标socketId，广播时可省略
  payload?: any;           // 业务载荷
  timestamp: number;
}

// 类型守卫，运行时校验
export function isValidMessage(data: any): data is BaseMessage {
  return data &&
         typeof data.type === 'string' &&
         Object.values(SignalType).includes(data.type) &&
         typeof data.roomId === 'string' &&
         typeof data.from === 'string' &&
         typeof data.timestamp === 'number';
}

// src/rooms.ts
import { WebSocket } from 'ws';

export interface PeerInfo {
  socketId: string;
  ws: WebSocket;
  metadata?: Record<string, any>; // 昵称、设备信息等
  joinedAt: number;
}

export class RoomManager {
  private rooms: Map<string, Map<string, PeerInfo>> = new Map();

  // 加入房间
  join(roomId: string, peer: PeerInfo): PeerInfo[] {
    if (!this.rooms.has(roomId)) this.rooms.set(roomId, new Map());
    const room = this.rooms.get(roomId)!;
    room.set(peer.socketId, peer);
    return Array.from(room.values()).filter(p => p.socketId !== peer.socketId);
  }

  // 离开房间
  leave(roomId: string, socketId: string): boolean {
    const room = this.rooms.get(roomId);
    if (!room) return false;
    room.delete(socketId);
    if (room.size === 0) this.rooms.delete(roomId);
    return true;
  }

  // 获取房间其他成员
  getPeers(roomId: string, excludeId?: string): PeerInfo[] {
    const room = this.rooms.get(roomId);
    if (!room) return [];
    return Array.from(room.values()).filter(p => p.socketId !== excludeId);
  }

  // 广播消息（除发送者外）
  broadcast(roomId: string, message: string, excludeId?: string): void {
    const peers = this.getPeers(roomId, excludeId);
    peers.forEach(p => p.ws.readyState === WebSocket.OPEN && p.ws.send(message));
  }
}

// src/index.ts
import { WebSocketServer, WebSocket } from 'ws';
import { v4 as uuidv4 } from 'uuid';
import { RoomManager } from './rooms';
import { BaseMessage, SignalType, isValidMessage } from './message';

const PORT = process.env.PORT || 3000;
const wss = new WebSocketServer({ port: PORT });
const roomManager = new RoomManager();

console.log(`[${new Date().toISOString()}] Signaling server started on port ${PORT}`);

wss.on('connection', (ws: WebSocket, req) => {
  const socketId = uuidv4();
  let currentRoomId: string | null = null;

  console.log(`[${new Date().toISOString()}] New connection: ${socketId}`);

  // 心跳检测
  ws.isAlive = true;
  ws.on('pong', () => { ws.isAlive = true; });

  ws.on('message', (rawData: Buffer) => {
    try {
      const msg: BaseMessage = JSON.parse(rawData.toString());
      if (!isValidMessage(msg)) {
        return sendError(ws, 'INVALID_MESSAGE_FORMAT', '消息格式不合法');
      }
      handleMessage(ws, socketId, msg);
    } catch (e) {
      sendError(ws, 'PARSE_ERROR', 'JSON解析失败');
    }
  });

  ws.on('close', () => {
    if (currentRoomId) {
      roomManager.leave(currentRoomId, socketId);
      broadcastPeerLeft(currentRoomId, socketId);
      currentRoomId = null;
    }
    console.log(`[${new Date().toISOString()}] Connection closed: ${socketId}`);
  });

  ws.on('error', (err) => {
    console.error(`[${socketId}] WebSocket error:`, err.message);
  });

  // 核心消息分发
  function handleMessage(ws: WebSocket, socketId: string, msg: BaseMessage) {
    switch (msg.type) {
      case SignalType.JOIN:
        currentRoomId = msg.roomId;
        const peers = roomManager.join(msg.roomId, {
          socketId, ws, joinedAt: Date.now(), metadata: msg.payload
        });
        // 回复当前房间成员列表
        ws.send(JSON.stringify({
          type: SignalType.USER_LIST,
          roomId: msg.roomId,
          from: 'server',
          payload: peers.map(p => ({ id: p.socketId, metadata: p.metadata })),
          timestamp: Date.now()
        }));
        // 通知房间内其他人
        roomManager.broadcast(msg.roomId, JSON.stringify({
          type: SignalType.PEER_JOINED,
          roomId: msg.roomId,
          from: 'server',
          payload: { id: socketId, metadata: msg.payload },
          timestamp: Date.now()
        }), socketId);
        break;

      case SignalType.OFFER:
      case SignalType.ANSWER:
      case SignalType.CANDIDATE:
        // 透传给目标用户
        if (!msg.to) return sendError(ws, 'MISSING_TARGET', '缺少目标用户ID');
        const target = roomManager.getPeers(msg.roomId).find(p => p.socketId === msg.to);
        if (target?.ws.readyState === WebSocket.OPEN) {
          target.ws.send(JSON.stringify({ ...msg, from: socketId }));
        } else {
          sendError(ws, 'TARGET_OFFLINE', '目标用户不在线');
        }
        break;

      case SignalType.LEAVE:
        if (currentRoomId) {
          roomManager.leave(currentRoomId, socketId);
          broadcastPeerLeft(currentRoomId, socketId);
          currentRoomId = null;
        }
        break;

      default:
        sendError(ws, 'UNKNOWN_TYPE', `未知消息类型: ${msg.type}`);
    }
  }

  function broadcastPeerLeft(roomId: string, leftId: string) {
    roomManager.broadcast(roomId, JSON.stringify({
      type: SignalType.PEER_LEFT,
      roomId,
      from: 'server',
      payload: { id: leftId },
      timestamp: Date.now()
    }));
  }

  function sendError(ws: WebSocket, code: string, detail: string) {
    if (ws.readyState === WebSocket.OPEN) {
      ws.send(JSON.stringify({
        type: SignalType.ERROR,
        roomId: '',
        from: 'server',
        payload: { code, detail },
        timestamp: Date.now()
      }));
    }
  }
});

// 定时心跳清理僵尸连接
setInterval(() => {
  wss.clients.forEach((ws: WebSocket) => {
    if (ws.isAlive === false) return ws.terminate();
    ws.isAlive = false;
    ws.ping();
  });
}, 30000);

# 使用PM2管理进程，利用多核CPU
npm install -g pm2
pm2 start src/index.ts --name signaling --interpreter ts-node -- -r tsconfig-paths/register
pm2 save && pm2 startup

// 生产环境必须启用WSS
import fs from 'fs';
import https from 'https';
import { WebSocketServer } from 'ws';

const server = https.createServer({
  cert: fs.readFileSync('/etc/letsencrypt/live/yourdomain.com/fullchain.pem'),
  key: fs.readFileSync('/etc/letsencrypt/live/yourdomain.com/privkey.pem')
});
const wss = new WebSocketServer({ server });
server.listen(443);

wss.on('connection', (ws, req) => {
  const url = new URL(req.url!, `https://${req.headers.host}`);
  const token = url.searchParams.get('token');
  if (!verifyJWT(token)) {  // 自行实现JWT校验
    ws.close(4001, 'Unauthorized');
    return;
  }
  // ...后续逻辑
});

// 简易客户端封装
class SignalingClient {
  constructor(url, roomId, token) {
    this.ws = new WebSocket(`${url}?token=${token}`);
    this.roomId = roomId;
    this.handlers = new Map();
    this.ws.onmessage = (e) => this.onMessage(JSON.parse(e.data));
    this.ws.onopen = () => this.send({ type: 'join', roomId, payload: { name: 'User' } });
  }

  onMessage(msg) {
    const handlers = this.handlers.get(msg.type) || [];
    handlers.forEach(fn => fn(msg.payload));
  }

  on(type, handler) {
    if (!this.handlers.has(type)) this.handlers.set(type, []);
    this.handlers.get(type).push(handler);
  }

  send(msg) {
    this.ws.send(JSON.stringify({ ...msg, roomId: this.roomId, from: 'me', timestamp: Date.now() }));
  }

  // 业务封装
  sendOffer(to, sdp) { this.send({ type: 'offer', to, payload: sdp }); }
  sendAnswer(to, sdp) { this.send({ type: 'answer', to, payload: sdp }); }
  sendCandidate(to, candidate) { this.send({ type: 'candidate', to, payload: candidate }); }
}

# 1. 房间成员集合（有序集合，Score=JoinTimestamp，支持分页/按序广播）
KEY: room:members:{roomId}
TYPE: ZSET
MEMBER: {peerId}  ->  VALUE: {json: {socketId, gatewayNodeId, metadata, joinedAt}}
TTL: 86400 (24h无活动自动过期)

# 2. 连接路由表（String，极速查找目标网关节点）
KEY: route:peer:{peerId}
VALUE: {gatewayNodeId}  # 标识该连接挂载在哪个Gateway实例
TTL: 3600 (心跳刷新)

# 3. 网关节点心跳（Hash，服务发现/健康检查）
KEY: cluster:gateways
FIELD: {gatewayNodeId} -> VALUE: {json: {ip, pid, wsPort, cpu, mem, connCount, updatedAt}}
TTL: 10 (10s无心跳判定下线)

# 4. 幂等去重窗口（防重放攻击/客户端重发）
KEY: idempotency:{msgId}
TTL: 60 (SET NX EX 60 成功即通过)

sequenceDiagram
    participant ClientA
    participant Gateway-1
    participant Redis Pub/Sub
    participant Gateway-2
    participant ClientB

    ClientA->>Gateway-1: WS: {type:offer, to:B, payload:sdp}
    Gateway-1->>Redis: GET route:peer:B  --> 返回 Gateway-2
    alt 目标在本地
        Gateway-1->>ClientB: 直接投递
    else 目标在远端
        Gateway-1->>Redis Pub/Sub: PUBLISH channel:gateway-2 {msg, targetPeerId:B}
        Redis Pub/Sub->>Gateway-2: 推送消息
        Gateway-2->>ClientB: 本地WS投递
    end

// worker/messageRouter.ts
import { createClient } from 'redis';
const redis = createClient({ url: process.env.REDIS_URL });
const subscriber = redis.duplicate();
const publisher = redis.duplicate();

await subscriber.connect();
await publisher.connect();

// 订阅本实例专属频道
await subscriber.subscribe(`gateway:${NODE_ID}`, (msg) => {
  const { targetPeerId, payload } = JSON.parse(msg);
  const ws = localConnections.get(targetPeerId); // 进程内Map<peerId, WebSocket>
  if (ws?.readyState === WebSocket.OPEN) ws.send(JSON.stringify(payload));
});

// 发送信令通用入口
export async function routeSignal(msg: SignalMessage) {
  // 1. 幂等校验
  const idemKey = `idempotency:${msg.id}`;
  if (!(await redis.set(idemKey, '1', { NX: true, EX: 60 }))) return; // 重复丢弃

  // 2. 目标路由查找
  const targetGateway = await redis.get(`route:peer:${msg.to}`);
  
  if (targetGateway === NODE_ID) {
    // 本地投递
    localDeliver(msg.to, msg);
  } else if (targetGateway) {
    // 跨节点投递
    await publisher.publish(`gateway:${targetGateway}`, JSON.stringify({
      targetPeerId: msg.to,
      payload: msg
    }));
  } else {
    // 目标离线/不存在 -> 回调发送方 ERROR
    sendError(msg.from, 'TARGET_OFFLINE');
  }
}

# Dockerfile 片段：集成 Certbot 自动续期
FROM node:20-alpine AS builder
# ... 构建步骤 ...

FROM nginx:alpine AS runtime
# 1. 复制编译产物
COPY --from=builder /app/dist /usr/share/nginx/html
# 2. Nginx 终结 TLS，反代至 Node.js (localhost:3000)
COPY nginx.conf /etc/nginx/nginx.conf
# 3. Certbot 定时任务
RUN apk add --no-cache certbot certbot-nginx dcron
COPY certbot-renew.sh /etc/periodic/daily/certbot-renew
RUN chmod +x /etc/periodic/daily/certbot-renew
CMD ["sh", "-c", "crond -f & nginx -g 'daemon off;'"]

// auth/tokenValidator.ts
import { verify, JwtPayload } from 'jsonwebtoken';
import { createHash } from 'crypto';

interface SignalTokenPayload extends JwtPayload {
  uid: string;           // 业务用户ID
  roomId: string;        // 目标房间（限制跨房间访问）
  role: 'host' | 'guest' | 'audience'; // 角色权限控制
  fp: string;            // 设备指纹哈希 (UA + Canvas + IP前缀)
  iat: number;
  exp: number;           // 建议 15-30 分钟短效
}

// 校验中间件（握手阶段执行）
export function validateHandshake(req: IncomingMessage): SignalTokenPayload | null {
  const url = new URL(req.url!, `https://${req.headers.host}`);
  const token = url.searchParams.get('token');
  if (!token) return null;

  try {
    const decoded = verify(token, process.env.JWT_PUBLIC_KEY!, { algorithms: ['RS256'] }) as SignalTokenPayload;
    
    // 设备指纹二次校验（防Token劫持）
    const clientFp = generateFingerprint(req.headers['user-agent'], req.socket.remoteAddress);
    if (decoded.fp !== clientFp) {
      logger.warn(`Fingerprint mismatch: uid=${decoded.uid}, ip=${req.socket.remoteAddress}`);
      return null; // 拒绝连接
    }
    return decoded;
  } catch (e) {
    return null; // 过期/签名错误/篡改
  }
}

// 结构化审计日志样例 (输出至 Kafka/ELK)
{
  "timestamp": "2024-05-20T10:30:00.123Z",
  "level": "AUDIT",
  "traceId": "a1b2c3d4",          // 全链路追踪ID
  "event": "SIGNAL_ROUTE",
  "actor": { "uid": "user_123", "ip": "112.x.x.x", "role": "host" },
  "action": "SEND_OFFER",
  "target": { "uid": "user_456", "roomId": "room_789" },
  "payloadHash": "sha256:...",    // 敏感数据仅存哈希
  "result": "SUCCESS",
  "gatewayNode": "gw-pod-7b9c"
}

# 启动命令优化 (package.json scripts)
"start:prod": "node --max-old-space-size=4096 
  --optimize-for-size 
  --gc-interval=100 
  --enable-source-maps 
  dist/index.js"

// 使用快速序列化库 (如 fast-json-stringify / msgpackr)
import { MessagePack } from 'msgpackr'; // 二进制协议，体积减少 30-50%

// 编码
const buffer = MessagePack.encode(msg);
ws.send(buffer, { binary: true });

// 解码 (ws.on('message', ...))
const msg = MessagePack.decode(new Uint8Array(data));

// 高频对象复用 (如 Candidate 对象)
class CandidatePool {
  private pool: RTCIceCandidateInit[] = [];
  acquire(): RTCIceCandidateInit { return this.pool.pop() || {}; }
  release(obj: RTCIceCandidateInit) { 
    Object.keys(obj).forEach(k => delete obj[k]); 
    this.pool.push(obj); 
  }
}
const candidatePool = new CandidatePool();
// 处理消息时
const cand = candidatePool.acquire();
// ... 填充数据 ...
// 处理完毕
candidatePool.release(cand);

// monitor/eventloop.ts
setInterval(() => {
  const start = process.hrtime.bigint();
  setImmediate(() => {
    const lag = Number(process.hrtime.bigint() - start) / 1e6; // ms
    if (lag > 100) logger.warn({ lag }, 'EventLoop blocked!'); // 告警阈值 100ms
    metrics.gauge('eventloop.lag.ms', lag);
  });
}, 1000);

# /etc/sysctl.d/99-websocket.conf
# 连接队列
net.core.somaxconn = 65535
net.ipv4.tcp_max_syn_backlog = 65535

# TIME_WAIT 复用 (高并发短连接场景有效，长连接场景慎用)
net.ipv4.tcp_tw_reuse = 1
# net.ipv4.tcp_tw_recycle = 0  # 内核 4.12+ 已移除，勿开启

# 文件描述符
fs.nr_open = 2000000
fs.file-max = 2000000

# 内存缓冲区 (根据带宽延迟积 BDP 设置)
net.core.rmem_max = 16777216
net.core.wmem_max = 16777216
net.ipv4.tcp_rmem = 4096 87380 16777216
net.ipv4.tcp_wmem = 4096 65536 16777216

# 启用 BBR 拥塞控制 (需内核 4.9+)
net.core.default_qdisc = fq
net.ipv4.tcp_congestion_control = bbr

# k6 压测脚本 (load-test/signaling.js)
import ws from 'k6/ws';
import { check, sleep } from 'k6';

export const options = {
  stages: [
    { duration: '2m', target: 1000 },   // 预热
    { duration: '5m', target: 50000 },  // 阶梯加压
    { duration: '10m', target: 100000 }, // 峰值保持
    { duration: '2m', target: 0 },      // 卸载
  ],
  thresholds: {
    'ws_connecting': ['rate<0.01'],       // 连接失败率 < 1%
    'ws_messages_received': ['rate>1000'], // 吞吐基线
    'checks': ['rate>0.99'],
  },
};

export default function () {
  const url = `wss://${__ENV.TARGET_HOST}/?token=${getToken()}`;
  const res = ws.connect(url, {}, function (socket) {
    socket.on('open', () => {
      socket.send(JSON.stringify({type:'join', roomId:'stress_test', payload:{}}));
    });
    socket.on('message', (msg) => {
      check(msg, { 'received ack': (m) => JSON.parse(m).type === 'user_list' });
    });
    socket.setTimeout(() => socket.close(), 60000);
  });
  check(res, { 'status 101': (r) => r && r.status === 101 });
}

# chaos-mesh/experiment/gateway-pod-kill.yaml
apiVersion: chaos-mesh.org/v1alpha1
kind: PodChaos
metadata:
  name: kill-gateway-random
spec:
  action: pod-failure
  mode: one
  duration: '30s'
  selector:
    namespaces: ['signaling-prod']
    labelSelectors:
      'app': 'signaling-gateway'
  scheduler:
    cron: '@every 1h'  # 每小时随机杀一个 Pod
---
# 验证指标 (Grafana Alert Rule)
# - 连接迁移成功率 > 99.9%
# - 信令丢包率 = 0
# - 平均恢复时间 (MTTR) < 5s

// tests/contract/message.schema.ts
import { Type } from '@sinclair/typebox';

export const SignalMessageSchema = Type.Object({
  type: Type.Union([Type.Literal('offer'), Type.Literal('answer'), ...]),
  roomId: Type.String({ format: 'uuid' }),
  from: Type.String(),
  to: Type.Optional(Type.String()),
  payload: Type.Optional(Type.Any()), // 允许扩展
  timestamp: Type.Integer({ minimum: 1000000000000 }),
  // 版本字段：客户端声明支持版本，服务端按版本序列化
  v: Type.Optional(Type.Integer({ default: 1 })) 
});

// 服务端响应校验中间件
export function validateOutgoing(msg: unknown) {
  const result = SignalMessageSchema.safeParse(msg);
  if (!result.success) {
    logger.error({ errors: result.error.format() }, 'Contract violation: Outgoing message');
    // 生产环境建议降级处理而非抛异常，避免单条脏数据炸进程
    return fallbackSerialize(msg); 
  }
  return result.data;
}

# Dockerfile (生产级多阶段构建)
# ---- Stage 1: Build ----
FROM node:20-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci --omit=dev --ignore-scripts  # 仅安装生产依赖，跳过 prepare 脚本
COPY . .
RUN npm run build  # tsc 编译

# ---- Stage 2: Runtime (Distroless - 无 Shell、无包管理器、攻击面极小) ----
FROM gcr.io/distroless/nodejs20-debian12:nonroot
WORKDIR /app
COPY --from=builder /app/node_modules ./node_modules
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/package.json ./

# 非 root 用户 (distroless 默认 nonroot:nonroot 65532:65532)
USER nonroot

# 环境变量默认值
ENV NODE_ENV=production 
    PORT=3000 
    LOG_LEVEL=info

EXPOSE 3000
ENTRYPOINT ["node", "dist/index.js"]

# k8s/deployment.yaml 关键片段
apiVersion: apps/v1
kind: Deployment
metadata:
  name: signaling-gateway
spec:
  replicas: 6  # HPA 管理实际副本数
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 25%
      maxUnavailable: 0  # 关键：滚动更新不减少可用副本，保障长连接不断
  template:
    spec:
      terminationGracePeriodSeconds: 60  # 关键：给足时间 drain 连接
      containers:
      - name: gateway
        image: registry.example.com/signaling-gateway:v1.2.3
        ports:
        - containerPort: 3000
          name: ws
        resources:
          requests:
            cpu: "500m"
            memory: "1Gi"
          limits:
            cpu: "2000m"
            memory: "4Gi"
        readinessProbe:
          httpGet:
            path: /healthz
            port: 3000
          initialDelaySeconds: 5
          periodSeconds: 5
          failureThreshold: 3
        lifecycle:
          preStop:
            exec:
              command: ["/bin/sh", "-c", "sleep 10 && kill -SIGTERM 1"] # 优雅下线脚本
        env:
        - name: NODE_ID
          valueFrom:
            fieldRef:
              fieldPath: metadata.name
        - name: POD_IP
          valueFrom:
            fieldRef:
              fieldPath: status.podIP
---
# HPA 自动扩缩容 (基于自定义指标: 连接数/CPU)
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: signaling-gateway-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: signaling-gateway
  minReplicas: 3
  maxReplicas: 50
  metrics:
  - type: Pods
    pods:
      metric:
        name: websocket_connections_active
      target:
        type: AverageValue
        averageValue: "15000"  # 单 Pod 目标连接数
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70
  behavior:
    scaleDown:
      stabilizationWindowSeconds: 300  # 缩容冷却 5 分钟，防抖
      policies:
      - type: Percent
        value: 10
        periodSeconds: 60

// tracing/instrumentation.ts
import { trace, context, SpanStatusCode } from '@opentelemetry/api';
import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node';
import { Resource } from '@opentelemetry/resources';
import { SemanticResourceAttributes } from '@opentelemetry/semantic-conventions';
import { JaegerExporter } from '@opentelemetry/exporter-jaeger';

// 初始化
const provider = new NodeTracerProvider({
  resource: new Resource({
    [SemanticResourceAttributes.SERVICE_NAME]: 'signaling-gateway',
    [SemanticResourceAttributes.DEPLOYMENT_ENVIRONMENT]: process.env.NODE_ENV,
  }),
});
provider.addSpanProcessor(new BatchSpanProcessor(new JaegerExporter()));
provider.register();

// 关键路径埋点
export async function traceRouteSignal(msg: SignalMessage) {
  return tracer.startActiveSpan('route_signal', { attributes: {
    'signal.type': msg.type,
    'signal.room_id': msg.roomId,
    'signal.from': msg.from,
    'signal.to': msg.to,
    'peer.local': targetGateway === NODE_ID,
  }}, async (span) => {
    try {
      await routeSignal(msg);
      span.setStatus({ code: SpanStatusCode.OK });
    } catch (err) {
      span.recordException(err);
      span.setStatus({ code: SpanStatusCode.ERROR, message: err.message });
      throw err;
    } finally {
      span.end();
    }
  });
}

// 统一 JSON 日志格式 (stdout -> Filebeat/Fluent Bit -> ES/Loki)
{
  "ts": "2024-05-20T10:30:00.123Z",
  "level": "info",
  "logger": "signaling.gateway",
  "trace_id": "a1b2c3d4e5f6",      // W3C TraceContext 标准
  "span_id": "1a2b3c4d",
  "msg": "Signal routed",
  "signal_type": "offer",
  "room_id": "room_789",
  "from_uid": "user_123",
  "to_uid": "user_456",
  "target_gateway": "gw-pod-7b9c",
  "latency_ms": 2.4,
  "result": "success"
}