first push

This commit is contained in:
renzhiyuan 2025-02-21 11:07:33 +08:00
commit 2549804954
10 changed files with 963 additions and 0 deletions

76
README.md Normal file
View File

@ -0,0 +1,76 @@
# 事件总线
统一的事件总线低层使用RocketMQ进一步封装约束命名规范、权限验证、链路追踪等
## 发送
[参考:](/event/producer_test.go)
1. 生成发送实例
```go
producer, err := event.NewProducer("192.168.6.107:9876")
// 带有验证凭证的示例
producer, err := NewProducer("192.168.6.107:9876", producer.WithProducerCredentials("accessKey", "secretKey", "securityToken"))
```
生成时可选的配置项有:
* event.WithProducerCredentials 设置生产者的凭证
2. 在Data层中注入生成的实例
3. 在biz中声明event的interface
4. 在data层中实现biz声明的interface同repository类似
5. 使用的方法:
* SendSync 同步发送
* SendAsync 异步发送
* BatchSendSync 批量同步发送
* BatchSendAsync 批量异步发送
6. 默认支持链路追踪如要关闭请调用DisableTraceTelemetry方法
## 消费
[参考:](/event/producer_test.go)
### 一、随着Kratos服务一起启动
1. 在server中新增consumer.go
```go
// ConsumerServer 消费者Server
type ConsumerServer struct {
manager *event.ConsumerManager
}
// NewConsumerServer 工厂方法
func NewConsumerServer(
//注入一些依赖的对象包括biz同http、grpc的Sever类似
) *ConsumerServer {
manager := event.NewConsumerManager()
// 添加一些订阅方法,示例:
_ = manager.Subscribe(ctx, connConf, consumerConf, func(message *ConsumerMessage) error {
// mock 业务耗时
time.Sleep(10 * time.Second)
// 返回nil才会commit否则会重试
return nil
})
return &ConsumerServer{manager:manager}
}
func (c *ConsumerServer) Start(ctx context.Context) error {
return c.manager.Start()
}
func (c *ConsumerServer) Stop(ctx context.Context) error {
return c.manager.Stop()
}
```
2. 添加进provider_set.go
3. 打开main.go
```go
// 在newApp方法中注入ConsumerServer,并添加到
serverOption := kratos.Server(
//在这里面添加ConsumerServer的实例
)
```
### 二、使用cli模式启动
参考上面的启动方式顺序为subscribe -> start -> stop

32
consumer_config.go Normal file
View File

@ -0,0 +1,32 @@
package mq
import "github.com/apache/rocketmq-client-go/v2"
// ConsumerConfig 消费者配置
type ConsumerConfig struct {
TopicName string // 必填,主题名称
// GroupName 必填消费者分组名称填写消费的业务名称例如CreatePay-创建支付单
// 实际注册时会自动在前面加上TopicName
GroupName string
// ConsumerCnt消费者个数默认为1不能超过MQ的消费Queue个数
// 需要保证顺序消费的场景才推荐使用否则推荐配置PerCoroutineCnt参数来开启并发消费即可
ConsumerCnt int
// PerCoroutineCnt 每个consumer的协程个数默认为20它与ConsumerCnt都能实现并发消费区别在于此参数是一个消费者多个协程并发消费性能更高
// 由于是单消费者的并发处理,可能存在后拉取的比先拉取的先处理完,即无法保证严格的顺序消费要求(但大部分场景都没有顺序要求)
// SDK在收到消息时会启动一个新协程运行回调函数最大运行协程数不超过此配置
// 示例2则实际的并发数是4正常消费2个重试2个协程
PerCoroutineCnt int
// RetryCnt 消费最大重试次数间隔时间查看https://rocketmq.apache.org/zh/docs/featureBehavior/10consumerretrypolicy
// 我们默认为38次目的是给异常业务方保留最多48小时去修复超过之后进入死信队列3天后会被自动删除
RetryCnt *int
// 指定消费的tag为空则消费所有tag
Tags []string
//消费者实例
pushConsumers []rocketmq.PushConsumer
}

9
consumer_conn_config.go Normal file
View File

@ -0,0 +1,9 @@
package mq
// ConsumerConnConfig 消费者配置
type ConsumerConnConfig struct {
NameServers string // 必填,多个用,号隔开
AccessKey string // 连接rocketMQ的accessKey
SecretKey string // 连接rocketMQ的secretKey
SecurityToken string // 连接rocketMQ的securityToken
}

289
consumer_manager.go Normal file
View File

@ -0,0 +1,289 @@
package mq
import (
"context"
"fmt"
"github.com/apache/rocketmq-client-go/v2"
"github.com/apache/rocketmq-client-go/v2/consumer"
"github.com/apache/rocketmq-client-go/v2/primitive"
"github.com/pkg/errors"
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/codes"
"go.opentelemetry.io/otel/propagation"
semconv "go.opentelemetry.io/otel/semconv/v1.20.0"
"go.opentelemetry.io/otel/trace"
"os"
"strings"
"sync/atomic"
"time"
)
// ConsumerManager 消费者管理器
type ConsumerManager struct {
consumerConfigs []*ConsumerConfig
activeCnt atomic.Int32 //当前正在处理业务的个数,用于退出时业务平滑的退出
shutdownFlag atomic.Bool // 关闭标记
logger Logger
IsOpenTelemetry bool // 默认开启链路追踪,及时未配置上报地址也不影响业务,只是实际不会上报上去而已
}
// NewConsumerManager 创建一个消费者管理器
func NewConsumerManager(logger Logger) *ConsumerManager {
return &ConsumerManager{logger: logger, IsOpenTelemetry: true}
}
func (c *ConsumerManager) DisableOpenTelemetry() {
c.IsOpenTelemetry = false
}
// Subscribe 订阅一个主题
func (c *ConsumerManager) Subscribe(ctx context.Context, connConf *ConsumerConnConfig, consumerConf *ConsumerConfig, fn func(context.Context, *ConsumerMessage) error, opts ...consumer.Option) error {
// 检查参数规范
if !c.checkGroupName(consumerConf.TopicName, consumerConf.GroupName) {
return fmt.Errorf("groupName不符合规范前缀必须是\"${topicName}_\"开头如trade_recharge_dispatcher_pay")
}
if consumerConf.RetryCnt == nil || *consumerConf.RetryCnt < 0 {
retryCnt := 38
consumerConf.RetryCnt = &retryCnt
}
if consumerConf.ConsumerCnt <= 0 {
consumerConf.ConsumerCnt = 1
}
if consumerConf.PerCoroutineCnt <= 0 {
consumerConf.PerCoroutineCnt = 20
}
credentials := primitive.Credentials{
AccessKey: connConf.AccessKey,
SecretKey: connConf.SecretKey,
SecurityToken: connConf.SecurityToken,
}
//限制groupName名称必须与topic捆绑
nameServers := strings.Split(connConf.NameServers, ",")
opts = append(opts,
consumer.WithNameServer(nameServers),
consumer.WithCredentials(credentials),
consumer.WithConsumerModel(consumer.Clustering),
// 不要开启此参数开启顺序消费通过返回consumer.ConsumeRetryLater将会失效需要自己实现重试机制
//key.WithConsumerOrder(true),
consumer.WithGroupName(consumerConf.GroupName),
consumer.WithConsumeGoroutineNums(consumerConf.PerCoroutineCnt),
consumer.WithRetry(*consumerConf.RetryCnt),
// 不启用批消费,多个一起消费的特点是则其中一个失败则整体都会失败
consumer.WithConsumeMessageBatchMaxSize(1),
//key.WithPullThresholdForQueue(50),
)
// 启动指定个数的consumer
hostName, _ := os.Hostname()
now := time.Now().Unix()
for i := 0; i < consumerConf.ConsumerCnt; i++ {
currOpts := make([]consumer.Option, len(opts))
copy(currOpts, opts)
currOpts = append(currOpts, consumer.WithInstance(fmt.Sprintf("%s:%s:%d:%d", hostName, consumerConf.GroupName, now, i+1)))
pushConsumer, err := rocketmq.NewPushConsumer(currOpts...)
if err != nil {
return err
}
selector := consumer.MessageSelector{}
// 过滤tag
if len(consumerConf.Tags) > 0 {
selector.Type = consumer.TAG
selector.Expression = strings.Join(consumerConf.Tags, " || ")
}
err = pushConsumer.Subscribe(consumerConf.TopicName, selector, func(subCtx context.Context, ext ...*primitive.MessageExt) (consumer.ConsumeResult, error) {
return c.callbackForReceive(subCtx, consumerConf, fn, ext...)
})
if err != nil {
return err
}
consumerConf.pushConsumers = append(consumerConf.pushConsumers, pushConsumer)
}
c.consumerConfigs = append(c.consumerConfigs, consumerConf)
return nil
}
var consumerPropagator = propagation.TraceContext{}
// callbackForReceive 收到消息的回调
func (c *ConsumerManager) callbackForReceive(ctx context.Context, consumerConf *ConsumerConfig, fn func(context.Context, *ConsumerMessage) error, ext ...*primitive.MessageExt) (cr consumer.ConsumeResult, fnErr error) {
// 收到消息
if c.shutdownFlag.Load() {
cr = consumer.ConsumeRetryLater
fnErr = fmt.Errorf("正在退出中,延期处理:%s,%s", consumerConf.TopicName, consumerConf.GroupName)
// 卡住,不再继续消费,等待退出
// 测试发现在重试主题消费时返回retryLater有时会被commit掉导致消息丢失
time.Sleep(24 * time.Hour)
return
}
// 标记活跃状态
c.activeCnt.Add(1)
defer func() {
c.activeCnt.Add(-1)
if v := recover(); v != nil {
cr = consumer.ConsumeRetryLater
fnErr = errors.Errorf("处理消息panic, groupName=%s%+v", consumerConf.GroupName, v)
c.LogErrorf("%+v", fnErr)
return
}
}()
var tracer trace.Tracer
if c.IsOpenTelemetry {
tracer = otel.GetTracerProvider().Tracer("MQ")
}
// WithConsumeMessageBatchMaxSize 配置大于1时ext才会存在多个它的特点是要么全成功或全失败
cr = consumer.ConsumeSuccess
spanName := fmt.Sprintf("%s %s %s", consumerConf.TopicName, semconv.MessagingOperationProcess.Value.AsString(), consumerConf.GroupName)
for _, v := range ext {
func() {
message := &ConsumerMessage{
MsgId: v.MsgId,
Topic: v.Topic,
Body: v.Body,
ReconsumeTimes: v.ReconsumeTimes,
CompressedBody: v.CompressedBody,
Flag: v.Flag,
TransactionId: v.TransactionId,
Batch: v.Batch,
Compress: v.Compress,
Properties: v.GetProperties(),
}
// 链路追踪
var span trace.Span
if tracer != nil {
if traceParent, ok := message.Properties[openTelemetryPropertyName]; ok {
var mapCarrier propagation.MapCarrier = map[string]string{
openTelemetryPropertyName: traceParent,
}
ctx = consumerPropagator.Extract(ctx, mapCarrier)
}
ctx, span = tracer.Start(ctx, spanName, trace.WithSpanKind(trace.SpanKindConsumer))
span.SetAttributes(
semconv.MessagingSystem("RocketMQ"),
semconv.MessagingSourceName(consumerConf.TopicName),
semconv.MessagingRocketmqClientGroup(consumerConf.GroupName),
semconv.MessagingRocketmqMessageKeys(message.GetKeys()...),
semconv.MessagingRocketmqMessageTag(message.GetTags()),
semconv.MessagingRocketmqMessageDelayTimeLevel(message.GetDelayTimeLevel()),
semconv.MessageIDKey.String(message.MsgId),
)
defer func() {
// 记录追踪信息
spanErr := fnErr
var panicVal any
if panicVal = recover(); panicVal != nil {
spanErr = fmt.Errorf("%s消费者处理方法panic:%s", consumerConf.GroupName, panicVal)
}
if spanErr != nil {
span.RecordError(spanErr)
span.SetStatus(codes.Error, spanErr.Error())
}
span.End()
if panicVal != nil {
panic(panicVal)
}
}()
}
// 回调业务函数
currErr := fn(ctx, message)
if currErr != nil {
cr = consumer.ConsumeRetryLater
fnErr = currErr
c.LogErrorf("%s消费者处理方法返回失败,body=%s%+v", consumerConf.GroupName, string(message.Body), currErr)
}
}()
}
return
}
// Start 启动所有消费者
func (c *ConsumerManager) Start(_ context.Context) error {
for _, consumerConf := range c.consumerConfigs {
for _, pushConsumer := range consumerConf.pushConsumers {
err := pushConsumer.Start()
if err != nil {
return err
}
}
}
return nil
}
// Stop 停止所有消费者
func (c *ConsumerManager) Stop(_ context.Context) error {
fmt.Println("开始停止消费者")
c.shutdownFlag.Store(true)
for _, consumerConf := range c.consumerConfigs {
for _, pushConsumer := range consumerConf.pushConsumers {
pushConsumer.Suspend() // 似乎没起使用
}
}
fmt.Println("已suspend所有消费者")
//shutdown之间保证正在处理的消费先提交
_ = c.blockWaitFinish()
var err error = nil
for _, consumerConf := range c.consumerConfigs {
for _, pushConsumer := range consumerConf.pushConsumers {
if closeErr := pushConsumer.Shutdown(); closeErr != nil {
err = closeErr
fmt.Println("消费者shutdown失败", closeErr)
}
}
}
fmt.Println("已shutdown所有消费者")
return err
}
// blockWaitFinish 阻塞等待业务完成
func (c *ConsumerManager) blockWaitFinish() error {
// 每1s检查下业务是否都处理完成
for {
cnt := c.activeCnt.Load()
if cnt == 0 {
//无业务处理,正常退
break
} else {
fmt.Printf("等待消费者退出,%d 个正在运行\n", cnt)
}
time.Sleep(1 * time.Second)
}
//防止极端情况下commit未完成
// nolint
time.Sleep(1 * time.Second)
return nil
}
// LogErrorf 记录错误日志
func (c *ConsumerManager) LogErrorf(format string, args ...any) {
if c.logger != nil {
c.logger.Errorf(format, args...)
} else {
fmt.Printf(format+"\n", args...)
}
}
// checkGroupName 检查groupName是否符合规范
// 必须是以${topicName}_开头目的是
// 1. 防止相同相同groupName与多个topic的情况避免出现消费不符异常的情况
// 2. 在管理group时能更清晰地体现出对应的topic
func (c *ConsumerManager) checkGroupName(topicName string, groupName string) bool {
if groupName == "" {
return false
}
return strings.HasPrefix(groupName, topicName+"_")
}

64
consumer_message.go Normal file
View File

@ -0,0 +1,64 @@
package mq
import (
"github.com/apache/rocketmq-client-go/v2/primitive"
"strconv"
"strings"
)
// ConsumerMessage 消费者收到的消息
type ConsumerMessage struct {
MsgId string
Topic string
Body []byte
ReconsumeTimes int32
CompressedBody []byte
Flag int32
TransactionId string
Batch bool
Compress bool
Properties map[string]string
}
// GetKeys 获取消息的key
func (c *ConsumerMessage) GetKeys() []string {
if len(c.Properties) == 0 {
return nil
}
val, isOk := c.Properties[primitive.PropertyKeys]
if !isOk {
return nil
}
return strings.Split(val, primitive.PropertyKeySeparator)
}
// GetTags 获取消息的tag
func (c *ConsumerMessage) GetTags() string {
if len(c.Properties) == 0 {
return ""
}
// nolint
val, _ := c.Properties[primitive.PropertyTags]
return val
}
// GetShardingKey 获取消息的分区key
func (c *ConsumerMessage) GetShardingKey() string {
if len(c.Properties) == 0 {
return ""
}
// nolint
val, _ := c.Properties[primitive.PropertyShardingKey]
return val
}
// GetDelayTimeLevel 获取消息的延迟级别
func (c *ConsumerMessage) GetDelayTimeLevel() int {
if len(c.Properties) == 0 {
return 0
}
// nolint
val, _ := c.Properties[primitive.PropertyDelayTimeLevel]
level, _ := strconv.Atoi(val)
return level
}

62
consumer_test.go Normal file
View File

@ -0,0 +1,62 @@
package mq
import (
"context"
"fmt"
"sync/atomic"
"testing"
"time"
)
func TestConsumer_Start(t *testing.T) {
initTracer("http://192.168.6.194:14268/api/traces", 1, "go_unit_test_for_util_consumer")
manager := NewConsumerManager(nil)
ctx := context.Background()
consumerConf := &ConsumerConfig{
TopicName: "test_sdk_sync",
GroupName: "test_sdk_sync_myConsumer",
PerCoroutineCnt: 2,
}
connConf := &ConsumerConnConfig{
NameServers: "192.168.6.107:9876",
}
i := atomic.Int32{}
err := manager.Subscribe(ctx, connConf, consumerConf, func(ctx context.Context, message *ConsumerMessage) error {
cnt := i.Add(1)
fmt.Printf("%d开始消费%s body=%s \n", cnt, message.MsgId, message.Body)
fmt.Println(message.Properties)
// mock 业务耗时
time.Sleep(1 * time.Second)
fmt.Printf("%d已完成%s body=%s \n", cnt, message.MsgId, message.Body)
return nil
})
fmt.Println(err)
consumerConf = &ConsumerConfig{
TopicName: "test_sdk_async",
GroupName: "test_sdk_async_myConsumer",
PerCoroutineCnt: 2,
}
err = manager.Subscribe(ctx, connConf, consumerConf, func(ctx context.Context, message *ConsumerMessage) error {
cnt := i.Add(1)
fmt.Printf("%d开始消费%s body=%s \n", cnt, message.MsgId, message.Body)
fmt.Println(message.Properties)
// mock 业务耗时
time.Sleep(1 * time.Second)
fmt.Printf("%d已完成%s body=%s \n", cnt, message.MsgId, message.Body)
return nil
})
fmt.Println(err)
_ = manager.Start(context.Background())
time.Sleep(5 * time.Second)
// mock 退出
_ = manager.Stop(context.Background())
}

38
go.mod Normal file
View File

@ -0,0 +1,38 @@
module gitea.cdlsxd.cn/self-tools/l_rocketmq
go 1.23.6
require (
github.com/apache/rocketmq-client-go/v2 v2.1.2
github.com/pkg/errors v0.9.1
go.opentelemetry.io/otel v1.34.0
go.opentelemetry.io/otel/exporters/jaeger v1.17.0
go.opentelemetry.io/otel/sdk v1.34.0
go.opentelemetry.io/otel/trace v1.34.0
)
require (
github.com/emirpasic/gods v1.12.0 // indirect
github.com/go-logr/logr v1.4.2 // indirect
github.com/go-logr/stdr v1.2.2 // indirect
github.com/golang/mock v1.3.1 // indirect
github.com/google/uuid v1.6.0 // indirect
github.com/json-iterator/go v1.1.12 // indirect
github.com/konsorten/go-windows-terminal-sequences v1.0.1 // indirect
github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421 // indirect
github.com/modern-go/reflect2 v1.0.2 // indirect
github.com/patrickmn/go-cache v2.1.0+incompatible // indirect
github.com/sirupsen/logrus v1.4.0 // indirect
github.com/tidwall/gjson v1.13.0 // indirect
github.com/tidwall/match v1.1.1 // indirect
github.com/tidwall/pretty v1.2.0 // indirect
go.opentelemetry.io/auto/sdk v1.1.0 // indirect
go.opentelemetry.io/otel/metric v1.34.0 // indirect
go.uber.org/atomic v1.5.1 // indirect
golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9 // indirect
golang.org/x/lint v0.0.0-20190930215403-16217165b5de // indirect
golang.org/x/sys v0.29.0 // indirect
golang.org/x/tools v0.0.0-20201224043029-2b0845dc783e // indirect
gopkg.in/natefinch/lumberjack.v2 v2.0.0 // indirect
stathat.com/c/consistent v1.0.0 // indirect
)

266
producer.go Normal file
View File

@ -0,0 +1,266 @@
package mq
import (
"context"
"fmt"
"github.com/apache/rocketmq-client-go/v2"
"github.com/apache/rocketmq-client-go/v2/primitive"
"github.com/apache/rocketmq-client-go/v2/producer"
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/codes"
"go.opentelemetry.io/otel/propagation"
semconv "go.opentelemetry.io/otel/semconv/v1.20.0"
"go.opentelemetry.io/otel/trace"
"math/rand"
"strings"
"time"
)
type Producer struct {
ProducerClient rocketmq.Producer
IsOpenTelemetry bool // 默认开启链路追踪,及时未配置上报地址也不影响业务,只是实际不会上报上去而已
}
// WithProducerCredentials 设置生产者的凭证
func WithProducerCredentials(accessKey, secretKey, securityToken string) producer.Option {
return producer.WithCredentials(primitive.Credentials{
AccessKey: accessKey,
SecretKey: secretKey,
SecurityToken: securityToken,
})
}
// NewProducer 创建一个生产者
// nameServer: 连接地址,多个中间用,号隔开
// opts: 配置项
func NewProducer(nameServer string, opts ...producer.Option) (*Producer, error) {
//检查参数
if nameServer == "" {
return nil, fmt.Errorf("rocketMQ NameServer 不能为空")
}
//创建生产者
nameServers := strings.Split(nameServer, ",")
group := generateRandomString(10)
opts = append(opts, producer.WithNameServer(nameServers), producer.WithGroupName(group))
p, err := rocketmq.NewProducer(opts...)
if err != nil {
fmt.Println("创建 rocketMQ producer 失败: ", err)
return nil, err
}
//此时并没有发起连接,在使用时才会连接
return &Producer{ProducerClient: p, IsOpenTelemetry: true}, nil
}
func generateRandomString(length int) string {
// 定义字符集
const charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
var sb strings.Builder
rand.Seed(time.Now().UnixNano()) // 设置种子
// 生成随机字符串
for i := 0; i < length; i++ {
sb.WriteByte(charset[rand.Intn(len(charset))]) // 从字符集随机选取
}
return sb.String()
}
// DisableTelemetry 关闭链路追踪
func (p *Producer) DisableTelemetry() {
p.IsOpenTelemetry = false
}
// Start 启动生产者
func (p *Producer) Start() error {
return p.ProducerClient.Start()
}
// Shutdown 关闭生产者
func (p *Producer) Shutdown() error {
return p.ProducerClient.Shutdown()
}
// SendOption 发送消息选项
type SendOption func(*primitive.Message)
// WithSendKeysOption 设置消息的key
func WithSendKeysOption(keys []string) SendOption {
return func(msg *primitive.Message) {
msg.WithKeys(keys)
}
}
// WithSendShardingKeysOption 设置消息的key
func WithSendShardingKeysOption(key string) SendOption {
return func(msg *primitive.Message) {
msg.WithShardingKey(key)
}
}
// WithSendTagOption 设置消息的Tag
func WithSendTagOption(tag string) SendOption {
return func(msg *primitive.Message) {
msg.WithTag(tag)
}
}
// WithSendDelayLevelOption 设置消息的延迟级别
// reference delay level definition: 1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h
// delay level starts from 1. for example, if we set param level=1, then the delay time is 1s.
func WithSendDelayLevelOption(level int) SendOption {
return func(msg *primitive.Message) {
msg.WithDelayTimeLevel(level)
}
}
const openTelemetryPropertyName = "traceparent"
// WithOpenTelemetryOption 设置消息的链接追踪信息
func WithOpenTelemetryOption(value string) SendOption {
return func(msg *primitive.Message) {
msg.WithProperty(openTelemetryPropertyName, value)
}
}
// WithSendWithPropertyOption 设置消息的属性
func WithSendWithPropertyOption(key, value string) SendOption {
return func(msg *primitive.Message) {
msg.WithProperty(key, value)
}
}
// SendSync 同步发送消息
// topic: 主题
// sendOptions: 发送选项如WithSendTagOption
// bodyList: 支持发送多个
func (p *Producer) SendSync(ctx context.Context, topic string, body []byte, sendOptions ...SendOption) error {
return p.BatchSendSync(ctx, topic, sendOptions, body)
}
// SendAsync 异步发送消息
// topic: 主题
// sendOptions: 发送选项如WithSendTagOption
// callbackFn: 回调函数无论成功与否都会回调失败时err!=nil
// bodyList: 支持发送多个
func (p *Producer) SendAsync(ctx context.Context, topic string, body []byte, callbackFn func(error), sendOptions ...SendOption) error {
return p.BatchSendAsync(ctx, topic, callbackFn, sendOptions, body)
}
// BatchSendSync 同步发送消息
// topic: 主题
// sendOptions: 发送选项如WithSendTagOption
// bodyList: 支持发送多个
func (p *Producer) BatchSendSync(ctx context.Context, topic string, sendOptions []SendOption, bodyList ...[]byte) error {
if err := p.checkSend(topic); err != nil {
return err
}
msgList := make([]*primitive.Message, len(bodyList))
for i, body := range bodyList {
msgList[i] = &primitive.Message{
Topic: topic,
Body: body,
}
for _, option := range sendOptions {
option(msgList[i])
}
}
// 链路追踪
var err error
if p.IsOpenTelemetry {
_, span := p.generateTraceSpan(ctx, topic, msgList)
defer func() {
// 记录错误
if err != nil {
span.RecordError(err)
span.SetStatus(codes.Error, err.Error())
}
span.End()
}()
}
_, err = p.ProducerClient.SendSync(context.Background(), msgList...)
if err != nil {
return err
}
return nil
}
// generateTraceSpan 生成链路追踪的span
var produceTraceContext = propagation.TraceContext{}
func (p *Producer) generateTraceSpan(ctx context.Context, topic string, msgList []*primitive.Message) (context.Context, trace.Span) {
tracer := otel.GetTracerProvider().Tracer("MQ")
spanName := fmt.Sprintf("%s %s", topic, semconv.MessagingOperationPublish.Value.AsString())
spanCtx, span := tracer.Start(ctx, spanName, trace.WithSpanKind(trace.SpanKindProducer))
span.SetAttributes(
semconv.MessagingSystem("RocketMQ"),
semconv.MessagingDestinationName(topic),
semconv.MessagingBatchMessageCount(len(msgList)),
semconv.MessagingRocketmqMessageKeys(msgList[0].GetKeys()),
semconv.MessagingRocketmqMessageTag(msgList[0].GetTags()),
)
//将span的trace数据写入
carrier := propagation.MapCarrier{}
produceTraceContext.Inject(spanCtx, carrier)
traceParent := carrier[openTelemetryPropertyName]
for _, message := range msgList {
message.WithProperty(openTelemetryPropertyName, traceParent)
}
return spanCtx, span
}
// BatchSendAsync 异步发送消息
// topic: 主题
// callbackFn: 回调方法无论成功与否都会回调失败时err!=nil
// sendOptions: 发送选项如WithSendTagOption
// bodyList: 支持发送多个
func (p *Producer) BatchSendAsync(ctx context.Context, topic string, callbackFn func(error), sendOptions []SendOption, bodyList ...[]byte) error {
if err := p.checkSend(topic); err != nil {
return err
}
msgList := make([]*primitive.Message, len(bodyList))
for i, body := range bodyList {
msgList[i] = &primitive.Message{
Topic: topic,
Body: body,
}
for _, option := range sendOptions {
option(msgList[i])
}
}
var err error
var span trace.Span
if p.IsOpenTelemetry {
_, span = p.generateTraceSpan(ctx, topic, msgList)
}
err = p.ProducerClient.SendAsync(context.Background(), func(ctxErr context.Context, result *primitive.SendResult, err error) {
if err != nil {
span.RecordError(err)
span.SetStatus(codes.Error, err.Error())
}
span.End()
callbackFn(err)
}, msgList...)
return err
}
// checkTopicName 检查topicName是否符合规范
// 名字分三部分,由字母和.号组成:${模块名}_${业务名}_${事件}job-order-created
// 权限:
func (p *Producer) checkSend(topicName string) error {
arr := strings.Split(topicName, "_")
isOk := len(arr) == 3 && arr[0] != "" && arr[1] != "" && arr[2] != ""
if !isOk {
return fmt.Errorf("topic名称不符合规范")
}
// 检查权限:待完善
return nil
}

87
producer_test.go Normal file
View File

@ -0,0 +1,87 @@
package mq
import (
"context"
"fmt"
"go.opentelemetry.io/otel"
// nolint
"go.opentelemetry.io/otel/exporters/jaeger"
"go.opentelemetry.io/otel/sdk/resource"
"go.opentelemetry.io/otel/sdk/trace"
semconv "go.opentelemetry.io/otel/semconv/v1.21.0"
"os"
"testing"
"time"
)
func TestProducer_SendSync(t *testing.T) {
initTracer("http://192.168.6.194:14268/api/traces", 1, "go_unit_test_for_util_producer")
//http://192.168.6.107:9876/
p, err := NewProducer("192.168.6.107:9876")
//p, err := NewProducer("192.168.6.107:9876", WithProducerCredentials("", "", ""))
if err != nil {
t.Fatal(err)
}
err = p.Start()
if err != nil {
t.Fatal(err)
}
for i := 0; i < 10; i++ {
err = p.SendSync(
context.Background(),
"test_sdk_sync",
[]byte("hello world"+time.Now().Format(time.DateTime)+fmt.Sprintf("%d", i)),
WithSendKeysOption([]string{"ttt"}),
WithSendTagOption("TagA"),
WithSendWithPropertyOption("pk", "pv"),
)
if err != nil {
fmt.Println("同步发送失败:", err)
}
err = p.SendAsync(
context.Background(),
"test_sdk_async",
[]byte("hello world"+time.Now().Format(time.DateTime)+fmt.Sprintf("%d", i)),
func(err error) {
if err != nil {
//出错了
fmt.Println("异步回调错误", err)
} else {
fmt.Println("异步回调成功")
}
},
WithSendKeysOption([]string{"ttt"}),
WithSendTagOption("TagA"),
WithSendWithPropertyOption("pk", "pv"),
)
if err != nil {
fmt.Println("异步发起失败", err)
}
}
_ = p.Shutdown()
time.Sleep(1 * time.Second) // 防止测试时span未上报完成
}
func initTracer(url string, sampler float64, name string) {
exporter, err := jaeger.New(jaeger.WithCollectorEndpoint(jaeger.WithEndpoint(url)))
if err != nil {
panic(fmt.Errorf("failed to initialize jaeger exporter:%s", url))
}
hostName, _ := os.Hostname()
tp := trace.NewTracerProvider(
// 将基于父span的采样率设置为100%
trace.WithSampler(trace.ParentBased(trace.TraceIDRatioBased(sampler))),
// 单元测试使用同步发送
//trace.WithBatcher(exporter),
trace.WithSyncer(exporter),
// 在资源中记录有关此应用程序的信息
trace.WithResource(resource.NewSchemaless(
semconv.ServiceNameKey.String(name),
semconv.ServiceVersionKey.String("v1.0.0"),
semconv.ServiceInstanceIDKey.String(hostName),
semconv.GCPGceInstanceHostnameKey.String(hostName),
)),
)
otel.SetTracerProvider(tp)
}

40
recover.go Normal file
View File

@ -0,0 +1,40 @@
package mq
import (
"fmt"
"github.com/apache/rocketmq-client-go/v2/primitive"
)
type Logger interface {
// Debugf logs a formatted debugging message.
Debugf(format string, args ...interface{})
// Infof logs a formatted informational message.
Infof(format string, args ...interface{})
// Warnf logs a formatted warning message.
Warnf(format string, args ...interface{})
// Errorf logs a formatted error message.
Errorf(format string, args ...interface{})
}
func init() {
SetRecoverLogger(nil)
}
// SetRecoverLogger 设置RocketMQ的recover的处理函数日志不设置会导致协程panic后程序退出
func SetRecoverLogger(logger Logger) {
SetRecoverHandler(func(err any) {
if logger == nil {
fmt.Printf("rocketmq 发生 panic%+v\n", err)
return
}
logger.Errorf("rocketmq 发生 panic%+v", err)
})
}
// SetRecoverHandler 设置RocketMQ的recover的处理函数不设置会导致协程panic后程序退出
func SetRecoverHandler(fn func(any)) {
primitive.PanicHandler = fn
}