166 lines
4.4 KiB
Go
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 send
|
|
|
|
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)
|
|
}
|
|
}
|
|
}
|