Files

200 lines
5.6 KiB
Go

// 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 非阻塞投递;后台协程处理回执,
// 失败自动重投,重试耗尽转投死信主题 <topic>.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{}
}