189 lines
5.3 KiB
Go
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...)
|
|
}
|