第一章：为什么你的Go推送服务凌晨崩溃？——基于37个线上事故日志的根因分析，今晚必须读完
凌晨2:17，警报刺耳响起：push-service CPU 98%、HTTP 5xx 突增400%，P99延迟飙升至12s。这不是孤例——我们从过去18个月37起生产事故日志中提取共性模式，发现86%的崩溃发生在01:00–04:00时段，且全部与未受控的 Goroutine 泄漏 + time.Timer 持久化引用强相关。
Goroutine 泄漏的静默杀手
37份日志中，32份 pprof/goroutine?debug=2 显示数万 goroutine 堆积在 net/http.(*conn).serve 或自定义 retryLoop() 中。典型诱因是：
- 使用
time.After()在长生命周期 goroutine 中轮询（如心跳检测） http.Client未设置Timeout，导致超时连接持续阻塞
修复示例（关键注释不可省略）：
// ❌ 危险：After() 创建的 Timer 不可回收，goroutine 隐式持有其引用
go func() {
for range time.After(30 * time.Second) { // 每30秒触发一次，但Timer永不释放！
doHeartbeat()
}
}()
// ✅ 安全：显式管理 Timer，复用并 Stop
ticker := time.NewTicker(30 * time.Second)
defer ticker.Stop() // 确保退出时清理
for range ticker.C {
doHeartbeat()
}内存压力下的 GC 雪崩
凌晨低峰期常触发“内存碎片+GC频率激增”组合拳。日志显示：gc 123 @123.456s 0%: ... 后紧接 runtime: out of memory。根本原因是：
- JSON 序列化大量小对象（如设备ID列表）未复用
bytes.Buffer sync.Pool未覆盖高频分配路径（如[]byte缓冲区）
验证命令（实时观测）：
# 连接生产Pod后执行，每2秒刷新一次堆统计
curl -s "http://localhost:6060/debug/pprof/heap?debug=1" | grep -E "(inuse_space|objects)"被忽视的信号处理缺陷
12起事故日志中出现 signal: killed，根源是容器 OOMKilled 前未优雅关闭 HTTP server。缺失的 os.Interrupt 处理导致连接队列积压：
| 场景 | 缺失操作 | 后果 |
|---|---|---|
| SIGTERM 到达 | 未调用 srv.Shutdown() |
新请求仍被接受 |
| Shutdown 超时未设 | context.WithTimeout 缺失 |
连接强制中断丢数据 |
务必在 main() 中加入：
srv := &http.Server{Addr: ":8080", Handler: mux}
go func() { http.ListenAndServe(":8080", mux) }()
// 捕获终止信号
sigChan := make(chan os.Signal, 1)
signal.Notify(sigChan, syscall.SIGTERM, syscall.SIGINT)
<-sigChan
log.Println("Shutting down server...")
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
srv.Shutdown(ctx) // 强制10秒内完成优雅退出第二章：Go推送服务高并发场景下的数据一致性陷阱
2.1 原子操作缺失导致的推送状态错乱（理论：CAS与内存模型；实践：atomic.Value在设备Token更新中的误用）
数据同步机制
设备Token频繁更新（如App重装、系统重置）时，若多goroutine并发写入*string或结构体字段而未加同步，将引发竞态——旧Token残留导致消息推送到已失效设备。
atomic.Value 的典型误用
var tokenStore atomic.Value // 存储 *string
// ❌ 错误：直接修改底层指针指向的值（非原子）
t := tokenStore.Load().(*string)
*t = "new_token_abc" // 竞态！多个goroutine可能同时改同一内存地址
atomic.Value仅保证整体替换（Store/Load）的原子性，不保护其承载对象内部状态。此处对*string解引用后赋值，绕过了原子边界，违反内存可见性约束。
正确姿势对比
| 方式 | 原子性保障 | 内存模型合规性 | 适用场景 |
|---|---|---|---|
atomic.Value.Store(&newToken) |
✅ 整体替换 | ✅ happens-before 链完整 | Token整值切换 |
unsafe.Pointer + CAS循环 |
✅ 细粒度控制 | ⚠️ 需手动维护acquire/release | 高频低开销更新 |
修复方案流程
graph TD
A[收到新Token] --> B{是否为首次设置？}
B -->|是| C[atomic.Value.Store(newToken)]
B -->|否| D[构造新字符串值]
D --> E[atomic.Value.Store(newStringPtr)]2.2 Channel阻塞未设超时引发goroutine泄漏（理论：Go内存模型与goroutine生命周期；实践：带context.WithTimeout的select+channel模式重构）
数据同步机制
当 goroutine 向无缓冲 channel 发送数据，而无协程接收时，该 goroutine 将永久阻塞——Go 运行时无法回收其栈空间与关联资源，形成不可达但存活的 goroutine。
经典泄漏场景
func leakyWorker(ch chan int) {
ch <- 42 // 若ch无人接收，此goroutine永驻
}ch <- 42在无接收者时触发永久调度阻塞；- runtime 不视其为“可终止”，GC 不释放其栈帧与 goroutine 结构体。
安全重构模式
func safeWorker(ctx context.Context, ch chan int) error {
select {
case ch <- 42:
return nil
case <-ctx.Done():
return ctx.Err() // 如 context.DeadlineExceeded
}
}select非阻塞分支 +context.WithTimeout构成超时守门人；ctx.Done()通道关闭即触发退出，保障 goroutine 可终结。
| 对比维度 | 无超时写法 | WithTimeout+select |
|---|---|---|
| 生命周期 | 永驻（泄漏） | 可预测终止 |
| 资源可见性 | GC 不可达但不回收 | runtime 可调度销毁 |
| 错误可观测性 | 无显式失败信号 | 返回 ctx.Err() |
graph TD
A[启动goroutine] --> B{向channel发送？}
B -->|无接收者| C[永久阻塞]
B -->|select+ctx| D[超时或成功]
D -->|成功| E[正常退出]
D -->|超时| F[返回ctx.Err并退出]2.3 Redis Pipeline批量写入与ACK语义不匹配（理论：分布式系统中at-least-once与exactly-once的边界；实践：结合Lua脚本+本地seq_id实现幂等确认）
数据同步机制的语义鸿沟
Redis Pipeline 提升吞吐，但不保证原子性 ACK：客户端发送 N 条命令后收到 OK，仅表示全部入队成功，而非全部执行成功。服务端崩溃或网络分区时，部分命令可能未执行——这天然导致 at-least-once 语义，而业务常需 exactly-once。
Lua 脚本 + seq_id 实现幂等确认
使用带版本号的 Lua 脚本校验并条件写入：
-- KEYS[1]: stream_key, ARGV[1]: seq_id, ARGV[2]: payload
local last_seq = redis.call('HGET', KEYS[1], 'last_seq')
if tonumber(last_seq) and tonumber(last_seq) >= tonumber(ARGV[1]) then
return 0 -- 已存在，幂等拒绝
end
redis.call('XADD', KEYS[1], '*', 'seq', ARGV[1], 'data', ARGV[2])
redis.call('HSET', KEYS[1], 'last_seq', ARGV[1])
return 1✅
last_seq存于 Hash 中，提供 O(1) 比较；
✅XADD与HSET在 Lua 原子上下文中执行；
✅ 客户端重试时携带单调递增seq_id，服务端可精确判重。
| 语义类型 | 是否由 Pipeline 保证 | 依赖条件 |
|---|---|---|
| at-least-once | 是（网络层重传） | TCP + 客户端重试逻辑 |
| exactly-once | 否 | 需 seq_id + Lua + 状态存储 |
graph TD
A[客户端发送Pipeline] --> B{Redis Server}
B --> C[命令入队成功]
B --> D[部分命令执行失败]
C --> E[返回OK]
D --> E
E --> F[客户端无法区分执行状态]
F --> G[必须引入seq_id+Lua做服务端幂等]2.4 JSON序列化竞态：struct tag动态修改引发panic（理论：反射与结构体布局稳定性；实践：预编译json.RawMessage缓存+字段校验中间件）
反射修改tag的危险性
Go 的 reflect.StructTag 是只读字符串，运行时强行覆盖 structField.Tag 会破坏 encoding/json 包对字段布局的缓存假设，触发 panic: reflect: reflect.Value.SetString using unaddressable value。
竞态复现代码
type User struct {
Name string `json:"name"`
}
u := User{Name: "Alice"}
v := reflect.ValueOf(&u).Elem()
// ❌ 危险：直接篡改tag（非法且不可预测）
// v.Type().Field(0).Tag = `json:"name,omitempty"` // 编译失败：不可寻址逻辑分析：
reflect.Type是只读元数据，其Field(i)返回副本；任何“修改”均无效。真实panic常源于第三方库（如某些ORM）在init()中用unsafe劫持tag，导致json.Marshal内部反射索引错位。
安全替代方案
- ✅ 预编译：
json.RawMessage缓存已序列化字节 - ✅ 中间件：在HTTP handler中注入字段合法性校验（如
jsonschema验证器）
| 方案 | 性能开销 | 安全性 | 适用场景 |
|---|---|---|---|
| 动态tag重写 | 极高（panic风险） | ⚠️ 低 | 禁止使用 |
json.RawMessage 缓存 |
O(1) | ✅ 高 | 高频读/不变结构 |
| 字段校验中间件 | O(n) | ✅ 高 | API入口防护 |
graph TD
A[HTTP Request] --> B{字段校验中间件}
B -->|通过| C[json.RawMessage 缓存]
B -->|失败| D[400 Bad Request]
C --> E[响应序列化]2.5 TLS握手超时被静默吞掉导致连接池枯竭（理论：Go net/http Transport底层连接复用机制；实践：自定义DialContext+Prometheus连接建立延迟直方图监控）
Go 的 net/http.Transport 在 TLS 握手失败（如超时）时，不返回错误而是直接丢弃连接，导致 idleConn 池未归还、新连接持续创建，最终耗尽 MaxIdleConnsPerHost。
连接生命周期关键断点
DialContext→ 建立 TCP 连接TLSHandshake→ 静默失败时不触发closeIdleConn- 失败连接既不复用也不归还，
idleConn计数失准
自定义 DialContext 监控示例
dialer := &net.Dialer{
Timeout: 5 * time.Second,
KeepAlive: 30 * time.Second,
}
transport := &http.Transport{
DialContext: func(ctx context.Context, network, addr string) (net.Conn, error) {
start := time.Now()
conn, err := dialer.DialContext(ctx, network, addr)
tlsDur := time.Since(start) // 包含 TLS 握手耗时
tlsHandshakeDuration.Observe(tlsDur.Seconds())
return conn, err
},
}此处
tlsDur实际涵盖 TCP + TLS 全链路，需配合http2.ConfigureTransport(transport)确保 HTTP/2 下仍可采集；Observe()将延迟上报至 Prometheushttp_tls_handshake_seconds直方图。
| 指标 | 说明 | 推荐分位 |
|---|---|---|
http_tls_handshake_seconds{quantile="0.99"} |
TLS 握手 P99 延迟 | >3s 触发告警 |
http_idle_conn_count |
当前空闲连接数 | 持续低于阈值预示泄漏 |
graph TD
A[HTTP Client] --> B[DialContext]
B --> C[TCP Connect]
C --> D[TLS Handshake]
D -- success --> E[Put to idleConn pool]
D -- timeout/fail --> F[Conn dropped silently]
F --> G[No pool return → leak]第三章：凌晨低峰期反而是故障高发期的底层机理
3.1 GC STW在大堆内存下的周期性毛刺放大效应（理论：Go 1.22 GC Pacer模型与触发阈值公式；实践：pprof trace定位STW峰值+GOGC动态调优策略）
当堆内存突破64GB量级，Go 1.22的Pacer模型中triggerRatio = (live / heapGoal) * 0.95导致GC触发频次陡增，STW毛刺呈非线性放大。
GC触发阈值关键公式
// Go 1.22 runtime/mgc.go 中 Pacer 的核心计算逻辑
heapGoal := live * (1 + GOGC/100) // 目标堆上限
trigger := heapGoal * 0.95 // 提前触发点（避免突增）trigger越接近当前live，GC越频繁；大堆下微小分配波动即引发连锁STW。
pprof trace定位STW峰值
- 运行
go tool trace -http=:8080 trace.out，聚焦GC STW时间轴； - 观察STW持续时间是否随堆增长呈指数上升（如从1ms→12ms @ 128GB堆）。
动态GOGC调优策略
| 场景 | GOGC建议 | 效果 |
|---|---|---|
| 高吞吐低延迟服务 | 50–80 | 减少GC频次，抑制毛刺放大 |
| 内存敏感批处理 | 150 | 平衡内存占用与STW周期 |
graph TD
A[Allocations] --> B{live > trigger?}
B -->|Yes| C[Start GC Cycle]
C --> D[Mark Phase STW]
D --> E[Sweep Phase STW]
E --> F[Heap Stabilization]
F --> A3.2 定时任务与系统cron守护进程的时区/夏令时错位（理论：Go time.LoadLocation与UTC偏移计算原理；实践：统一使用time.Now().UTC() + cronexpr解析器替换系统crontab）
问题根源：time.LoadLocation 的动态偏移陷阱
Go 的 time.LoadLocation("Asia/Shanghai") 返回的 *time.Location 在运行时缓存夏令时规则，但系统 crond 不感知 Go 运行时的时区状态，导致 0 0 * * * 在春秋季切换时可能漂移1小时。
关键事实对比
| 组件 | 时区依据 | 夏令时感知 | 可预测性 |
|---|---|---|---|
| 系统 crond | /etc/localtime + libc tzdata |
✅（依赖系统更新） | ❌（需重启crond） |
time.Now().In(loc) |
Go 内置 tzdata（编译时快照） | ✅（静态规则） | ⚠️（版本滞后风险） |
time.Now().UTC() |
恒定零偏移 | ❌（无夏令时概念） | ✅（绝对稳定） |
推荐实践：UTC+表达式双稳态模型
// 使用 cronexpr 替代系统 crontab，完全脱离系统时区
expr, _ := cronexpr.Parse("0 0 * * *") // 表示 UTC 每日0点
next := expr.Next(time.Now().UTC()) // 所有计算基于 UTC 时间戳逻辑分析：
expr.Next()接收time.Time实例并严格按 UTC 基准推算下一次触发时间；time.Now().UTC()强制剥离本地时区上下文，避免LoadLocation引入的夏令时跳变干扰。参数time.Now().UTC()确保输入为纯 UTC 时间点，使Next()输出具备跨时区、跨季节一致性。
流程保障
graph TD
A[应用启动] --> B[加载 cronexpr 规则]
B --> C[每秒调用 time.Now().UTC()]
C --> D{是否到达 Next() 时间？}
D -->|是| E[执行业务逻辑]
D -->|否| C3.3 日志轮转触发文件句柄泄漏（理论：os.File重定向与syscall.Dup2的资源继承行为；实践：logrus Hook级句柄回收+ulimit -n实时告警）
文件重定向中的句柄继承陷阱
当调用 syscall.Dup2(oldfd, newfd) 重定向 os.Stdout 到新日志文件时，子进程会继承所有未设置 FD_CLOEXEC 的打开句柄。若轮转后旧 *os.File 未显式 Close()，其底层 fd 仍被持有。
logrus Hook 级精准回收
type CloseHook struct{}
func (h CloseHook) Fire(entry *logrus.Entry) error {
if f, ok := entry.Logger.Out.(*os.File); ok {
_ = f.Close() // 主动释放，避免轮转残留
}
return nil
}
entry.Logger.Out指向当前输出目标；Close()触发syscall.Close()，真正归还 fd。注意：仅对*os.File类型生效，io.MultiWriter等需递归处理。
实时防护三件套
| 手段 | 命令/配置 | 作用 |
|---|---|---|
| 句柄监控 | watch -n 1 'lsof -p $PID \| wc -l' |
观察 fd 增长趋势 |
| 硬限制告警 | ulimit -n 1024 + grep "too many open files" /var/log/syslog |
内核级熔断 |
| 自动清理 | logrus.AddHook(CloseHook{}) |
应用层兜底 |
graph TD
A[轮转创建新文件] --> B[syscall.Dup2 stdout→newfd]
B --> C[旧*os.File未Close]
C --> D[fd泄漏累积]
D --> E[ulimit -n 触发EMFILE]
E --> F[Hook.Close()拦截并释放]第四章：37起事故中反复出现的Go推送数据层设计缺陷
4.1 设备离线状态缓存过期策略与真实心跳脱节（理论：CAP权衡下最终一致性的TTL设计缺陷；实践：基于滑动窗口心跳采样动态调整Redis EXPIRE）
数据同步机制
传统静态TTL（如 SET device:123 "online" EX 60）假设心跳周期恒定，但网络抖动、设备休眠或批量延迟上报会导致缓存过早驱逐，产生“假离线”。
滑动窗口动态TTL
# 基于最近3次心跳间隔的P95值动态设置过期时间
window = redis.lrange("hb:device:123", 0, 2) # [t1, t2, t3]
intervals = [int(b) - int(a) for a, b in zip(window, window[1:])]
p95_ttl = max(30, int(np.percentile(intervals, 95))) # 下限30s防过短
redis.setex("status:device:123", p95_ttl, "online") # 动态EXPIRE逻辑分析：取滑动窗口内心跳间隔的P95作为TTL基准，兼顾稳定性与灵敏度；max(30, ...) 避免因偶发超短间隔导致缓存瞬时失效。
CAP权衡映射
| 维度 | 静态TTL | 滑动窗口TTL |
|---|---|---|
| 一致性(C) | 弱（频繁误判） | 中（延迟容忍增强） |
| 可用性(A) | 高（无计算开销） | 高（本地采样） |
| 分区容错(P) | 强 | 强 |
graph TD
A[设备心跳上报] --> B{滑动窗口采集}
B --> C[计算P95间隔]
C --> D[更新Redis EXPIRE]
D --> E[状态查询返回最终一致结果]4.2 推送消息ID生成器单点瓶颈（理论：snowflake变种在单机时钟回拨下的ID重复风险；实践：go-zero内置xid库替代方案+分片worker ID注册中心）
时钟回拨引发的ID冲突本质
Snowflake 类算法依赖毫秒级时间戳 + worker ID + 序列号。当系统发生 NTP 校正或虚拟机休眠导致本地时钟回拨，同一毫秒内若序列号未重置，将生成重复 ID。
go-zero xid 的轻量替代设计
// xid 使用 32-bit 时间（秒级）+ 16-bit 机器ID + 16-bit 序列号
id := xid.New()
// 示例输出：0f5d7a3b1c2e4f6a8b9c0d1e2f3a4b5c（12字节，无符号大整数）逻辑分析：舍弃毫秒精度换稳定性；秒级时间戳天然规避微秒/毫秒级回拨冲突；16-bit 机器ID 支持最多 65536 节点，配合注册中心实现动态分片。
分片 Worker ID 注册中心机制
| 组件 | 职责 |
|---|---|
| etcd | 存储 /xid/workers/{host} TTL租约 |
| xid.Register | 启动时争抢唯一 worker ID |
| 心跳续约 | 每 15s 刷新租约，故障自动释放 |
graph TD
A[服务启动] --> B{向etcd注册worker ID}
B -->|成功| C[开始生成xid]
B -->|失败| D[等待并重试]
C --> E[每15s续租]
E -->|租约过期| F[自动释放ID，触发新选举]4.3 消息体Protobuf反序列化未做size limit导致OOM（理论：protobuf解码器缓冲区分配逻辑与整数溢出向量；实践：proto.UnmarshalOptions设置MaxDepth/MaxRecursion）
数据同步机制中的隐式风险
当服务接收外部不可信的 Protobuf 消息（如网关透传、跨域 RPC）时，若仅调用 proto.Unmarshal(data, msg)，解码器将依据 wire type 和 tag 动态分配缓冲区——对长度前缀字段（varint）不做校验，恶意构造的超大 size（如 0xffffffff）会触发整数溢出，导致 malloc(uint32(-1)) 实际分配极小内存，后续拷贝引发越界或 OOM。
安全反序列化实践
opts := proto.UnmarshalOptions{
MaxDepth: 100, // 防止嵌套过深（如递归结构）
MaxRecursion: 50, // 限制嵌套层级（v1.30+ 推荐用 MaxDepth）
DiscardUnknown: true, // 忽略未知字段，降低攻击面
}
err := opts.Unmarshal(data, msg)
MaxDepth控制解析树深度，避免栈溢出与内存爆炸；MaxRecursion已被标记为 deprecated，优先使用MaxDepth。二者共同约束嵌套与重复字段的资源消耗。
关键参数对比表
| 参数 | 作用 | 默认值 | 建议值 |
|---|---|---|---|
MaxDepth |
解析嵌套层级上限 | 1000 | 64–128 |
DiscardUnknown |
是否丢弃未知字段 | false | true |
graph TD
A[原始二进制数据] --> B{size prefix 解析}
B -->|合法 size| C[分配 buffer 并拷贝]
B -->|溢出/超大值| D[OOM 或 heap corruption]
C --> E[应用 MaxDepth 校验]
E -->|超限| F[立即返回 ErrInvalidUTF8/ErrInternal]4.4 MySQL写扩散：单条推送触发23张关联表更新（理论：领域事件驱动架构缺失导致的事务边界污染；实践：引入MessageBus解耦+异步物化视图同步）
数据同步机制
传统强一致性更新将用户推送行为硬编码为23张表的联立UPDATE，事务内嵌套多表写入，导致锁竞争加剧、RT飙升。
架构演进对比
| 维度 | 同步写模式 | MessageBus + 物化视图 |
|---|---|---|
| 事务粒度 | 跨域大事务（>500ms） | 领域事件单事务（ |
| 表依赖 | 硬编码JOIN/触发器 | 事件订阅解耦 |
| 一致性模型 | 强一致（失败即回滚） | 最终一致（幂等重试+版本戳） |
核心改造代码
-- 推送事件发布（MySQL Binlog → Kafka）
INSERT INTO push_events (id, user_id, content_id, ts)
VALUES (UUID(), 'u_8821', 'c_9a7f', NOW()); -- 仅写轻量事件表该语句剥离业务逻辑，push_events作为唯一事实源；后续由消费者按需构建用户动态流、通知中心、搜索索引等23个物化视图，避免事务污染。
事件流转示意
graph TD
A[MySQL push_events] -->|Binlog捕获| B[Kafka Topic]
B --> C{Consumer Group}
C --> D[UserFeed MV]
C --> E[Notification MV]
C --> F[Search Index Sync]第五章：今夜上线前必须执行的5项Go推送服务加固检查清单
验证JWT签名密钥轮转与失效时间硬限制
确保所有 /notify 接口使用的 JWT 令牌校验逻辑强制启用 time.Now().Before(claims.ExpiresAt.Time) 检查，且 ExpiresAt 不得大于 300 秒（5分钟）。在生产环境配置中，jwt.SigningKey 必须从 Vault 动态拉取，而非硬编码。以下为关键校验片段：
func validateToken(tokenString string) (*jwt.Token, error) {
keyFunc := func(t *jwt.Token) (interface{}, error) {
return getSigningKeyFromVault() // 实际调用 Vault API 的封装函数
}
token, err := jwt.Parse(tokenString, keyFunc)
if claims, ok := token.Claims.(jwt.MapClaims); ok && token.Valid {
if time.Now().After(claims["exp"].(float64)) {
return nil, errors.New("token expired")
}
if exp := int64(claims["exp"].(float64)); exp-time.Now().Unix() > 300 {
return nil, errors.New("token expiration too long (>300s)")
}
}
return token, err
}核查HTTP请求体大小与并发连接数限制
在 main.go 初始化阶段，必须显式设置 http.Server 的 MaxHeaderBytes（≤4096）、ReadTimeout（≤15s）、WriteTimeout（≤30s），并启用 net/http/pprof 的 /debug/pprof/ 路由仅限内网访问。同时，使用 golang.org/x/net/netutil 限制最大连接数：
listener := netutil.LimitListener(net.Listen("tcp", ":8080"), 1000)
server := &http.Server{
Handler: mux,
ReadTimeout: 15 * time.Second,
WriteTimeout: 30 * time.Second,
MaxHeaderBytes: 4096,
}确认消息队列重试策略与死信路由
推送服务对接 RabbitMQ 时，必须配置如下策略：
- 所有
push.task队列启用x-dead-letter-exchange: dlx.push - 设置
x-message-ttl: 600000（10分钟） - 消费端
ack前必须完成设备在线状态查询（调用 RedisEXISTS device:online:{id}） - 连续3次 nack 后自动入死信队列，并触发告警 webhook
| 组件 | 配置项 | 生产值 | 验证方式 |
|---|---|---|---|
| RabbitMQ | x-dead-letter-routing-key |
dlq.push.failed |
rabbitmqctl list_queues name arguments \| grep dlq |
| Go worker | maxRetries |
3 |
日志中搜索 "retry_count=3" |
审计敏感日志脱敏与结构化输出
所有包含 device_id、token、phone 字段的日志必须经 zap.String("device_id", redact(id)) 处理，redact() 函数实现为前4位保留、后缀替换为 ****。日志格式强制 JSON，字段含 level, ts, caller, trace_id, service="push-svc"。禁用 fmt.Printf 和 log.Println。
校验Prometheus指标暴露与健康探针
服务必须暴露 /healthz（返回 200 + {"status":"ok","uptime":12345}）和 /metrics（需含 push_service_http_requests_total{method="POST",code="200"} 等基础指标）。通过以下命令验证：
curl -s http://localhost:8080/healthz | jq -r '.status' # 应输出 ok
curl -s http://localhost:8080/metrics | grep 'http_requests_total' | head -1flowchart TD
A[启动服务] --> B{/healthz 返回200?}
B -->|否| C[立即终止进程]
B -->|是| D{/metrics 包含 push_service_.*_total?}
D -->|否| C
D -->|是| E[允许流量接入]