Files
go-sms-V2/internal/service/send/dispatch/backpressure.go
T

166 lines
4.4 KiB
Go

// backpressure.go Day 48(技术方案 10.4.4):背压三级水位。
//
// L1 lag>10 万 → 告警(日志+metrics);
// L2 lag>100 万 → 入口限流收紧(写 Redis 水位键,网关侧账号桶容量收至 Σ通道speed);
// L3 lag>500 万 → 暂停低优先级投放(消费组 Pause;恢复即 Resume)。
//
// 水位键由消费者进程写入(30s TTL,采样周期 10s),网关进程只读——跨进程解耦。
package dispatch
import (
"context"
"strconv"
"time"
"go-sms/internal/pkg/cache"
"go.uber.org/zap"
)
// BPLevel 背压水位(0 正常)。
type BPLevel int32
// 三级水位(阈值与开发计划 Day48 对齐)。
const (
BPNormal BPLevel = iota
BPAlert
BPTighten
BPPause
)
// 背压阈值(lag 条)与采样/键 TTL。
const (
BPThresholdL1 = 100_000
BPThresholdL2 = 1_000_000
BPThresholdL3 = 5_000_000
BPKeyTTL = 30 * time.Second
)
// BPLevelOf 水位判定(纯函数,单测口径)。
func BPLevelOf(lag int64) BPLevel {
switch {
case lag > BPThresholdL3:
return BPPause
case lag > BPThresholdL2:
return BPTighten
case lag > BPThresholdL1:
return BPAlert
default:
return BPNormal
}
}
// BPStore 水位存储(Redis 实现;测试可替身)。
type BPStore interface {
SetLevel(ctx context.Context, level BPLevel, capPerSec int64) error
}
// RedisBPStore 水位键实现:level 与 cap(收紧后的入口预算=Σ通道speed)。
type RedisBPStore struct {
rc *cache.Client
}
// NewRedisBPStore 构造(rc 可 nil:降级为不动作)。
func NewRedisBPStore(rc *cache.Client) *RedisBPStore { return &RedisBPStore{rc: rc} }
// BPLevelKey/BPCapKey 键名(网关侧 middleware 读取同款)。
const (
BPLevelKey = "go-sms:bp:level"
BPCapKey = "go-sms:bp:cap"
)
// SetLevel 写入水位与入口预算(30s TTL;cap<=0 不写)。
func (s *RedisBPStore) SetLevel(ctx context.Context, level BPLevel, capPerSec int64) error {
if s.rc == nil {
return nil
}
pipe := s.rc.TxPipeline()
pipe.Set(ctx, BPLevelKey, int32(level), BPKeyTTL)
if capPerSec > 0 {
pipe.Set(ctx, BPCapKey, capPerSec, BPKeyTTL)
}
_, err := pipe.Exec(ctx)
return err
}
// ReadBPLevel 读当前水位(网关侧收紧判定共用;键缺失/Redis 错=正常)。
func ReadBPLevel(ctx context.Context, rc *cache.Client) BPLevel {
if rc == nil {
return BPNormal
}
v, err := rc.Get(ctx, BPLevelKey).Result()
if err != nil {
return BPNormal // 键缺失(redis.Nil)/故障:可用性优先按正常
}
n, err := strconv.Atoi(v)
if err != nil {
return BPNormal
}
return BPLevel(n)
}
// Backpressure 背压控制器:采样 lag → 水位判定 → 动作。
// 恢复语义:水位回落时反向解除(L3→Resume;L2→写回正常水位键)。
type Backpressure struct {
store BPStore
log *zap.Logger
pause func() // L3:暂停投放(消费组 Pause;可 nil)
resume func() // 恢复
capFn func() int64 // Σ通道speed(入口收紧预算;可 nil=不收紧只告警)
last BPLevel // 上次水位(边缘触发动作,避免每拍重复)
}
// NewBackpressure 构造(pause/resume/capFn 可 nil 降级)。
func NewBackpressure(store BPStore, log *zap.Logger,
pause, resume func(), capFn func() int64) *Backpressure {
return &Backpressure{store: store, log: log, pause: pause, resume: resume, capFn: capFn}
}
// Check 单次采样处理:返回本次水位(边缘动作+持续状态键写入)。
func (b *Backpressure) Check(ctx context.Context, lag int64) BPLevel {
lv := BPLevelOf(lag)
if lv != b.last { // 边缘触发:升降沿各一次
b.log.Warn("backpressure_level_changed",
zap.Int64("lag", lag), zap.Int32("from", int32(b.last)), zap.Int32("to", int32(lv)))
switch {
case lv >= BPPause && b.last < BPPause:
if b.pause != nil {
b.pause()
}
case lv < BPPause && b.last >= BPPause:
if b.resume != nil {
b.resume()
}
}
b.last = lv
}
if b.store != nil { // 持续写入水位键(30s TTL;网关侧据此收紧)
var cap int64
if lv >= BPTighten && b.capFn != nil {
cap = b.capFn()
}
_ = b.store.SetLevel(ctx, lv, cap)
}
return lv
}
// Run 周期采样(sample 返回总 lag;err 时按 0 处理一拍)。
func (b *Backpressure) Run(ctx context.Context, interval time.Duration, sample func(context.Context) (int64, error)) {
tk := time.NewTicker(interval)
defer tk.Stop()
for {
select {
case <-ctx.Done():
return
case <-tk.C:
lag, err := sample(ctx)
if err != nil {
b.log.Warn("backpressure_sample_failed", zap.Error(err))
continue
}
b.Check(ctx, lag)
}
}
}