200 lines
5.6 KiB
Go
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{}
|
|
}
|