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 次后转投 .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...) }