// Package queue Kafka 消息队列封装(IBM/sarama,Day 7): // 异步生产者(自动重试 + 死信转投)与消费者组(处理成功才提交 offset)。 package queue import ( "errors" "sync" "time" "github.com/IBM/sarama" "go.uber.org/zap" ) // ErrProducerClosed 生产者已关闭,拒绝新消息。 var ErrProducerClosed = errors.New("queue: 生产者已关闭") // asyncProducer Sarama 异步生产者抽象(sarama.AsyncProducer 满足;单测可注入 mock)。 type asyncProducer interface { Input() chan<- *sarama.ProducerMessage Successes() <-chan *sarama.ProducerMessage Errors() <-chan *sarama.ProducerError Close() error } // ProducerConfig 生产者配置。 type ProducerConfig struct { Brokers []string MaxRetry int // 发送失败后的重投次数(默认 3;broker 级重试另由 sarama 内部处理) Logger *zap.Logger } // Producer 异步生产者:Send 非阻塞投递;后台协程处理回执, // 失败自动重投,重试耗尽转投死信主题 .dlq。 type Producer struct { inner asyncProducer maxRetry int log *zap.Logger done chan struct{} closeOnce sync.Once wg sync.WaitGroup } // NewProducer 连接 Kafka 并启动异步生产者。 func NewProducer(cfg ProducerConfig) (*Producer, error) { if len(cfg.Brokers) == 0 { return nil, errors.New("queue: kafka.brokers 不能为空") } sc := sarama.NewConfig() sc.Version = sarama.V2_8_0_0 sc.Producer.RequiredAcks = sarama.WaitForAll // 等待全部副本确认,防丢 sc.Producer.Idempotent = true // 幂等生产者,防重乱序 sc.Producer.Retry.Max = 5 // broker 级重试 sc.Producer.Return.Successes = true // 回传成功(需处理两通道) sc.Producer.Return.Errors = true sc.Net.MaxOpenRequests = 1 // 幂等模式要求串行请求 // P1 压测优化(09-27):sarama 默认零 linger——每条消息独立 request, // broker(同 HDD)随机写放大,洪峰下 Input chan 打满反向阻塞 SubmitFast // (fast_path p99 907ms 实测根因)。攒批 5ms/200 条+snappy 压缩后 // broker 请求数 ÷N,顺带提升单请求吞吐;ChannelBufferSize 拉平毛刺。 sc.Producer.Flush.Frequency = 5 * time.Millisecond sc.Producer.Flush.MaxMessages = 200 sc.Producer.Compression = sarama.CompressionSnappy sc.ChannelBufferSize = 1024 inner, err := sarama.NewAsyncProducer(cfg.Brokers, sc) if err != nil { return nil, err } return newProducer(inner, cfg), nil } // newProducer 装配(注入 mock 时使用)。 func newProducer(inner asyncProducer, cfg ProducerConfig) *Producer { if cfg.MaxRetry <= 0 { cfg.MaxRetry = 3 } if cfg.Logger == nil { cfg.Logger = zap.NewNop() } p := &Producer{ inner: inner, maxRetry: cfg.MaxRetry, log: cfg.Logger, done: make(chan struct{}), } p.wg.Add(1) go p.loop() return p } // Send 异步投递一条消息;返回 nil 仅代表已进入发送通道。 func (p *Producer) Send(topic string, key, value []byte) error { if topic == "" { return errors.New("queue: topic 不能为空") } if len(value) == 0 { return errors.New("queue: value 不能为空") } msg := &sarama.ProducerMessage{ Topic: topic, Key: sarama.ByteEncoder(key), Value: sarama.ByteEncoder(value), Metadata: retryMeta{}, } select { case p.inner.Input() <- msg: return nil case <-p.done: return ErrProducerClosed } } // Close 优雅关闭:拒绝新消息 → 排空内部通道 → 退出后台协程。 func (p *Producer) Close() error { var err error p.closeOnce.Do(func() { close(p.done) err = p.inner.Close() // 触发 Successes/Errors 关闭并排空 p.wg.Wait() }) return err } // loop 后台处理发送回执:成功记日志,失败重投,耗尽转死信。 func (p *Producer) loop() { defer p.wg.Done() succClosed, errClosed := false, false for { select { case <-p.done: return case m, ok := <-p.inner.Successes(): if !ok { succClosed = true if errClosed { return } continue } p.log.Debug("kafka_send_ok", zap.String("topic", m.Topic), zap.Any("offset", m.Offset)) case e, ok := <-p.inner.Errors(): if !ok { errClosed = true if succClosed { return } continue } p.handleError(e) } } } // handleError 失败处理:未超限则重投;超限转死信;死信再失败仅告警丢弃。 func (p *Producer) handleError(e *sarama.ProducerError) { meta := metaOf(e.Msg) switch { case meta.dlq: // 死信消息自身发送失败:最后防线,仅记录 p.log.Error("kafka_dlq_failed", zap.String("topic", e.Msg.Topic), zap.Error(e.Err)) case meta.retry < p.maxRetry: // 重投 meta.retry++ e.Msg.Metadata = meta select { case p.inner.Input() <- e.Msg: p.log.Warn("kafka_send_retry", zap.String("topic", e.Msg.Topic), zap.Int("retry", meta.retry), zap.Error(e.Err)) case <-p.done: } default: // 重试耗尽 → 死信 p.inner.Input() <- &sarama.ProducerMessage{ Topic: DLQTopic(e.Msg.Topic), Key: e.Msg.Key, Value: e.Msg.Value, Metadata: retryMeta{dlq: true}, } p.log.Error("kafka_send_to_dlq", zap.String("topic", e.Msg.Topic), zap.String("dlq_topic", DLQTopic(e.Msg.Topic)), zap.Int("retries", meta.retry), zap.Error(e.Err)) } } // DLQTopic 返回主题对应的死信主题名。 func DLQTopic(topic string) string { return topic + DLQSuffix } // retryMeta 消息重试元数据(挂载于 ProducerMessage.Metadata)。 type retryMeta struct { retry int dlq bool } // metaOf 安全取出消息的重试元数据。 func metaOf(m *sarama.ProducerMessage) retryMeta { if meta, ok := m.Metadata.(retryMeta); ok { return meta } return retryMeta{} }