Files

189 lines
5.3 KiB
Go

package queue
import (
"context"
"strconv"
"sync"
"sync/atomic"
"time"
"github.com/IBM/sarama"
"go.uber.org/zap"
"go-sms/internal/pkg/metrics"
)
// DefaultMaxConsumeRetry 消费失败重试上限(含首次,超过转死信)。
const DefaultMaxConsumeRetry = 3
// DLQSender 死信转投接口(生产为 *Producer;测试可注入 mock)。
type DLQSender interface {
Send(topic string, key, value []byte) error
}
// ConsumerGroupConfig 消费组配置(包装 Consumer/Producer 配置)。
type ConsumerGroupConfig struct {
Consumer ConsumerConfig
Producer ProducerConfig // 死信转投用(可为 nil:不转投仅丢弃计数)
MaxRetry int // 消费失败次数上限(默认 3,含首次)
}
// ConsumerGroup 优雅消费循环(Day 16):
// - 暂停/恢复:Pause 期间阻塞分区消息处理(心跳与 offset 不受影响);
// - 失败重试:Handler 返回错误不提交 offset(重平衡/重启后重投);
// - 死信转投:同一消息失败达 MaxRetry 次后转投 <topic>.dlq 并视为处理完成,
// 避免毒丸消息无限阻塞分区(重试计数为进程内存态,重启归零属预期)。
type ConsumerGroup struct {
cons *Consumer
dlq DLQSender
cfg ConsumerGroupConfig
log *zap.Logger
maxRetry int
mu sync.RWMutex
gate chan struct{} // 关闭=恢复(可消费);新建(未关闭)=暂停
paused bool
running atomic.Bool
}
// NewConsumerGroup 创建消费组(消费 + 死信转投一体)。
// MaxRetry<=0 取默认 3(Day48 修复:零值曾致重试循环不执行,死信分支
// 以 nil err 调 deadLetterValue panic——消费存量毒丸消息即触发)。
func NewConsumerGroup(cfg ConsumerGroupConfig) (*ConsumerGroup, error) {
if cfg.MaxRetry <= 0 {
cfg.MaxRetry = DefaultMaxConsumeRetry
}
cons, err := NewConsumer(cfg.Consumer)
if err != nil {
return nil, err
}
g := &ConsumerGroup{
cons: cons, cfg: cfg, log: cons.log,
maxRetry: cfg.MaxRetry,
gate: make(chan struct{}),
}
close(g.gate) // 初始为恢复态
if cfg.Producer.Brokers != nil {
p, err := NewProducer(cfg.Producer)
if err != nil {
_ = cons.Close()
return nil, err
}
g.dlq = p
}
return g, nil
}
// Run 阻塞消费直至 ctx 取消;handler 由 cfg.Consumer.Handler 提供,
// 内部经失败重试与死信包装。
func (g *ConsumerGroup) Run(ctx context.Context) error {
g.running.Store(true)
defer g.running.Store(false)
wrapped := g.wrap(g.cfg.Consumer.Handler)
inner := g.cons.cfg
inner.Handler = wrapped
g.cons.cfg = inner
return g.cons.Run(ctx)
}
// Pause 暂停消费:阻塞各分区的消息处理(已建立连接与心跳保持)。
func (g *ConsumerGroup) Pause() {
g.mu.Lock()
defer g.mu.Unlock()
if !g.paused {
g.paused = true
g.gate = make(chan struct{})
g.log.Info("consumer_group_paused")
}
}
// Resume 恢复消费。
func (g *ConsumerGroup) Resume() {
g.mu.Lock()
defer g.mu.Unlock()
if g.paused {
g.paused = false
close(g.gate)
g.log.Info("consumer_group_resumed")
}
}
// Paused 当前是否暂停。
func (g *ConsumerGroup) Paused() bool {
g.mu.RLock()
defer g.mu.RUnlock()
return g.paused
}
// Close 关闭消费者与死信生产者。
func (g *ConsumerGroup) Close() error {
if p, ok := g.dlq.(*Producer); ok && p != nil {
defer func() { _ = p.Close() }()
}
return g.cons.Close()
}
// waitGate 等待恢复信号;暂停期间阻塞(ctx 取消时返回错误以释放分区)。
func (g *ConsumerGroup) waitGate(ctx context.Context) error {
g.mu.RLock()
gate := g.gate
g.mu.RUnlock()
select {
case <-gate:
return nil
case <-ctx.Done():
return ctx.Err()
}
}
// wrap 包装业务 handler:暂停门 → 同步重试(指数退避)→ 死信转投。
func (g *ConsumerGroup) wrap(h Handler) Handler {
return func(ctx context.Context, msg *sarama.ConsumerMessage) error {
if err := g.waitGate(ctx); err != nil {
return err // 会话取消,交由上层退出
}
var err error
for attempt := 1; attempt <= g.maxRetry; attempt++ {
if attempt > 1 { // 退避:100ms * 2^(n-1),上限 1s
backoff := 100 * time.Millisecond << uint(attempt-2)
if backoff > time.Second {
backoff = time.Second
}
select {
case <-time.After(backoff):
case <-ctx.Done():
return ctx.Err()
}
}
if err = h(ctx, msg); err == nil {
return nil
}
if ctx.Err() != nil {
return err // 会话结束导致的失败不转死信
}
g.log.Warn("consume_attempt_failed",
zap.String("topic", msg.Topic), zap.Int32("partition", msg.Partition),
zap.Int64("offset", msg.Offset), zap.Int("attempt", attempt),
zap.Int("max", g.maxRetry), zap.Error(err))
}
// 重试耗尽:转投死信并视为完成(防毒丸阻塞分区)
dlqTopic := DLQTopic(msg.Topic)
g.log.Error("consume_dead_letter",
zap.String("topic", msg.Topic), zap.String("dlq_topic", dlqTopic),
zap.Int64("offset", msg.Offset), zap.Int("retries", g.maxRetry), zap.Error(err))
if g.dlq != nil {
_ = g.dlq.Send(dlqTopic, msg.Key, deadLetterValue(msg, err, g.maxRetry))
metrics.KafkaProducerMessages.WithLabelValues(dlqTopic, "dlq").Inc()
}
return nil
}
}
// deadLetterValue 死信载荷:原值 + 元信息头(简单前缀方案,阶段 5 解码消费)。
func deadLetterValue(m *sarama.ConsumerMessage, cause error, retries int) []byte {
meta := "dlq;retries=" + strconv.Itoa(retries) + ";cause=" + cause.Error() + ";payload="
return append([]byte(meta), m.Value...)
}