Merge branch 'errcode' of github.com:OpenIMSDK/Open-IM-Server into errcode

2026-05-20 16:59:01 +08:00 · 2023-03-23 19:05:20 +08:00
parent 132e1b987c a0d61769b2
commit 2baf208c02
70 changed files with 1040 additions and 535 deletions
@@ -0,0 +1,23 @@
+package api
+
+import (
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
+	"github.com/go-playground/validator/v10"
+)
+
+func RequiredIf(fl validator.FieldLevel) bool {
+	sessionType := fl.Parent().FieldByName("SessionType").Int()
+	switch sessionType {
+	case constant.SingleChatType, constant.NotificationChatType:
+		if fl.FieldName() == "RecvID" {
+			return fl.Field().String() != ""
+		}
+	case constant.GroupChatType, constant.SuperGroupChatType:
+		if fl.FieldName() == "GroupID" {
+			return fl.Field().String() != ""
+		}
+	default:
+		return true
+	}
+	return true
+}
@@ -2,14 +2,13 @@ package api

 import (
 	"context"
-	"errors"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/a2r"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/apiresp"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/apistruct"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/config"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/log"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/tracelog"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/mcontext"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/errs"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/msg"
@@ -23,23 +22,23 @@ import (

 var _ context.Context // 解决goland编辑器bug

-func NewMsg(c discoveryregistry.SvcDiscoveryRegistry) *Msg {
-	return &Msg{c: c, validate: validator.New()}
+func NewMsg(c discoveryregistry.SvcDiscoveryRegistry) *Message {
+	return &Message{c: c, validate: validator.New()}
 }

-type Msg struct {
+type Message struct {
 	c        discoveryregistry.SvcDiscoveryRegistry
 	validate *validator.Validate
 }

-func (Msg) SetOptions(options map[string]bool, value bool) {
+func (Message) SetOptions(options map[string]bool, value bool) {
 	utils.SetSwitchFromOptions(options, constant.IsHistory, value)
 	utils.SetSwitchFromOptions(options, constant.IsPersistent, value)
 	utils.SetSwitchFromOptions(options, constant.IsSenderSync, value)
 	utils.SetSwitchFromOptions(options, constant.IsConversationUpdate, value)
 }

-func (m Msg) newUserSendMsgReq(c *gin.Context, params *apistruct.ManagementSendMsgReq) *msg.SendMsgReq {
+func (m Message) newUserSendMsgReq(c *gin.Context, params *apistruct.ManagementSendMsgReq) *msg.SendMsgReq {
 	var newContent string
 	var err error
 	switch params.ContentType {
@@ -100,13 +99,13 @@ func (m Msg) newUserSendMsgReq(c *gin.Context, params *apistruct.ManagementSendM
 		tips.JsonDetail = utils.StructToJsonString(params.Content)
 		pbData.MsgData.Content, err = proto.Marshal(&tips)
 		if err != nil {
-			log.Error(tracelog.GetOperationID(c), "Marshal failed ", err.Error(), tips.String())
+			log.Error(mcontext.GetOperationID(c), "Marshal failed ", err.Error(), tips.String())
 		}
 	}
 	return &pbData
 }

-func (m *Msg) client() (msg.MsgClient, error) {
+func (m *Message) client() (msg.MsgClient, error) {
 	conn, err := m.c.GetConn(config.Config.RpcRegisterName.OpenImMsgName)
 	if err != nil {
 		return nil, err
@@ -114,48 +113,49 @@ func (m *Msg) client() (msg.MsgClient, error) {
 	return msg.NewMsgClient(conn), nil
 }

-func (m *Msg) GetSeq(c *gin.Context) {
+func (m *Message) GetSeq(c *gin.Context) {
 	a2r.Call(msg.MsgClient.GetMaxAndMinSeq, m.client, c)
 }

-func (m *Msg) PullMsgBySeqs(c *gin.Context) {
+func (m *Message) PullMsgBySeqs(c *gin.Context) {
 	a2r.Call(msg.MsgClient.PullMessageBySeqs, m.client, c)
 }

-func (m *Msg) DelMsg(c *gin.Context) {
+func (m *Message) DelMsg(c *gin.Context) {
 	a2r.Call(msg.MsgClient.DelMsgs, m.client, c)
 }

-func (m *Msg) DelSuperGroupMsg(c *gin.Context) {
+func (m *Message) DelSuperGroupMsg(c *gin.Context) {
 	a2r.Call(msg.MsgClient.DelSuperGroupMsg, m.client, c)
 }

-func (m *Msg) ClearMsg(c *gin.Context) {
+func (m *Message) ClearMsg(c *gin.Context) {
 	a2r.Call(msg.MsgClient.ClearMsg, m.client, c)
 }

-func (m *Msg) SetMessageReactionExtensions(c *gin.Context) {
+func (m *Message) SetMessageReactionExtensions(c *gin.Context) {
 	a2r.Call(msg.MsgClient.SetMessageReactionExtensions, m.client, c)
 }

-func (m *Msg) GetMessageListReactionExtensions(c *gin.Context) {
+func (m *Message) GetMessageListReactionExtensions(c *gin.Context) {
 	a2r.Call(msg.MsgClient.GetMessagesReactionExtensions, m.client, c)
 }

-func (m *Msg) AddMessageReactionExtensions(c *gin.Context) {
+func (m *Message) AddMessageReactionExtensions(c *gin.Context) {
 	a2r.Call(msg.MsgClient.AddMessageReactionExtensions, m.client, c)
 }

-func (m *Msg) DeleteMessageReactionExtensions(c *gin.Context) {
+func (m *Message) DeleteMessageReactionExtensions(c *gin.Context) {
 	a2r.Call(msg.MsgClient.DeleteMessageReactionExtensions, m.client, c)
 }

-func (m *Msg) SendMsg(c *gin.Context) {
+func (m *Message) SendMessage(c *gin.Context) {
 	params := apistruct.ManagementSendMsgReq{}
 	if err := c.BindJSON(&params); err != nil {
-		apiresp.GinError(c, err)
+		apiresp.GinError(c, errs.ErrArgs.WithDetail(err.Error()).Wrap())
 		return
 	}
+
 	var data interface{}
 	switch params.ContentType {
 	case constant.Text:
@@ -181,32 +181,17 @@ func (m *Msg) SendMsg(c *gin.Context) {
 		data = apistruct.CustomElem{}
 	case constant.CustomOnlineOnly:
 		data = apistruct.CustomElem{}
-	//case constant.HasReadReceipt:
-	//case constant.Typing:
-	//case constant.Quote:
 	default:
-		apiresp.GinError(c, errors.New("wrong contentType"))
+		apiresp.GinError(c, errs.ErrArgs.WithDetail("not support err contentType").Wrap())
 		return
 	}
 	if err := mapstructure.WeakDecode(params.Content, &data); err != nil {
-		apiresp.GinError(c, errs.ErrData)
+		apiresp.GinError(c, errs.ErrArgs.Wrap(err.Error()))
 		return
 	} else if err := m.validate.Struct(data); err != nil {
-		apiresp.GinError(c, errs.ErrData)
+		apiresp.GinError(c, errs.ErrArgs.Wrap(err.Error()))
 		return
 	}
-	switch params.SessionType {
-	case constant.SingleChatType:
-		if len(params.RecvID) == 0 {
-			apiresp.GinError(c, errs.ErrData)
-			return
-		}
-	case constant.GroupChatType, constant.SuperGroupChatType:
-		if len(params.GroupID) == 0 {
-			apiresp.GinError(c, errs.ErrData)
-			return
-		}
-	}
 	pbReq := m.newUserSendMsgReq(c, &params)
 	conn, err := m.c.GetConn(config.Config.RpcRegisterName.OpenImMsgName)
 	if err != nil {
@@ -226,24 +211,24 @@ func (m *Msg) SendMsg(c *gin.Context) {
 		Status: int32(status),
 	})
 	if err != nil {
-		log.NewError(tracelog.GetOperationID(c), "SetSendMsgStatus failed")
+		log.NewError(mcontext.GetOperationID(c), "SetSendMsgStatus failed")
 	}
-	resp := apistruct.ManagementSendMsgResp{ResultList: sdkws.UserSendMsgResp{ServerMsgID: respPb.ServerMsgID, ClientMsgID: respPb.ClientMsgID, SendTime: respPb.SendTime}}
-	apiresp.GinSuccess(c, resp)
+	//resp := apistruct.ManagementSendMsgResp{ResultList: sdkws.UserSendMsgResp{ServerMsgID: respPb.ServerMsgID, ClientMsgID: respPb.ClientMsgID, SendTime: respPb.SendTime}}
+	apiresp.GinSuccess(c, respPb)
 }

-func (m *Msg) ManagementBatchSendMsg(c *gin.Context) {
+func (m *Message) ManagementBatchSendMsg(c *gin.Context) {
 	a2r.Call(msg.MsgClient.SendMsg, m.client, c)
 }

-func (m *Msg) CheckMsgIsSendSuccess(c *gin.Context) {
+func (m *Message) CheckMsgIsSendSuccess(c *gin.Context) {
 	a2r.Call(msg.MsgClient.GetSendMsgStatus, m.client, c)
 }

-func (m *Msg) GetUsersOnlineStatus(c *gin.Context) {
+func (m *Message) GetUsersOnlineStatus(c *gin.Context) {
 	a2r.Call(msg.MsgClient.GetSendMsgStatus, m.client, c)
 }

-func (m *Msg) AccountCheck(c *gin.Context) {
+func (m *Message) AccountCheck(c *gin.Context) {
 	a2r.Call(msg.MsgClient.GetSendMsgStatus, m.client, c)
 }
@@ -7,6 +7,8 @@ import (
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/prome"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
 	"github.com/gin-gonic/gin"
+	"github.com/gin-gonic/gin/binding"
+	"github.com/go-playground/validator/v10"
 	"github.com/go-redis/redis/v8"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/credentials/insecure"
@@ -19,6 +21,9 @@ func NewGinRouter(zk discoveryregistry.SvcDiscoveryRegistry, rdb redis.Universal
 	//gin.DefaultWriter = io.MultiWriter(f)
 	//gin.SetMode(gin.DebugMode)
 	r := gin.New()
+	if v, ok := binding.Validator.Engine().(*validator.Validate); ok {
+		_ = v.RegisterValidation("required_if", RequiredIf)
+	}
 	log.Info("load config: ", config.Config)
 	r.Use(gin.Recovery(), mw.CorsHandler(), mw.GinParseOperationID())
 	if config.Config.Prometheus.Enable {
@@ -126,7 +131,7 @@ func NewGinRouter(zk discoveryregistry.SvcDiscoveryRegistry, rdb redis.Universal
 		m := NewMsg(zk)
 		msgGroup.Use(mw.GinParseToken(rdb))
 		msgGroup.POST("/newest_seq", m.GetSeq)
-		msgGroup.POST("/send_msg", m.SendMsg)
+		msgGroup.POST("/send_msg", m.SendMessage)
 		msgGroup.POST("/pull_msg_by_seq", m.PullMsgBySeqs)
 		msgGroup.POST("/del_msg", m.DelMsg)
 		msgGroup.POST("/del_super_group_msg", m.DelSuperGroupMsg)
@@ -6,7 +6,7 @@ import (
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/config"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/http"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/tracelog"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/mcontext"
 	"time"
 )

@@ -22,7 +22,7 @@ func CallbackUserOnline(ctx context.Context, userID string, platformID int, isAp
 		UserStatusCallbackReq: cbapi.UserStatusCallbackReq{
 			UserStatusBaseCallback: cbapi.UserStatusBaseCallback{
 				CallbackCommand: constant.CallbackUserOnlineCommand,
-				OperationID:     tracelog.GetOperationID(ctx),
+				OperationID:     mcontext.GetOperationID(ctx),
 				PlatformID:      platformID,
 				Platform:        constant.PlatformIDToName(platformID),
 			},
@@ -44,7 +44,7 @@ func CallbackUserOffline(ctx context.Context, userID string, platformID int, con
 		UserStatusCallbackReq: cbapi.UserStatusCallbackReq{
 			UserStatusBaseCallback: cbapi.UserStatusBaseCallback{
 				CallbackCommand: constant.CallbackUserOfflineCommand,
-				OperationID:     tracelog.GetOperationID(ctx),
+				OperationID:     mcontext.GetOperationID(ctx),
 				PlatformID:      platformID,
 				Platform:        constant.PlatformIDToName(platformID),
 			},
@@ -65,7 +65,7 @@ func CallbackUserKickOff(ctx context.Context, userID string, platformID int) err
 		UserStatusCallbackReq: cbapi.UserStatusCallbackReq{
 			UserStatusBaseCallback: cbapi.UserStatusBaseCallback{
 				CallbackCommand: constant.CallbackUserKickOffCommand,
-				OperationID:     tracelog.GetOperationID(ctx),
+				OperationID:     mcontext.GetOperationID(ctx),
 				PlatformID:      platformID,
 				Platform:        constant.PlatformIDToName(platformID),
 			},
@@ -4,6 +4,9 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/log"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/mcontext"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/sdkws"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
 	"runtime/debug"
@@ -36,7 +39,7 @@ type Client struct {
 	isCompress     bool
 	userID         string
 	isBackground   bool
-	connID         string
+	ctx            *UserConnContext
 	onlineAt       int64 // 上线时间戳（毫秒）
 	longConnServer LongConnServer
 	closed         bool
@@ -49,7 +52,7 @@ func newClient(ctx *UserConnContext, conn LongConn, isCompress bool) *Client {
 		platformID: utils.StringToInt(ctx.GetPlatformID()),
 		isCompress: isCompress,
 		userID:     ctx.GetUserID(),
-		connID:     ctx.GetConnID(),
+		ctx:        ctx,
 		onlineAt:   utils.GetCurrentTimestampByMill(),
 	}
 }
@@ -59,7 +62,7 @@ func (c *Client) ResetClient(ctx *UserConnContext, conn LongConn, isCompress boo
 	c.platformID = utils.StringToInt(ctx.GetPlatformID())
 	c.isCompress = isCompress
 	c.userID = ctx.GetUserID()
-	c.connID = ctx.GetConnID()
+	c.ctx = ctx
 	c.onlineAt = utils.GetCurrentTimestampByMill()
 	c.longConnServer = longConnServer
 }
@@ -68,7 +71,7 @@ func (c *Client) readMessage() {
 		if r := recover(); r != nil {
 			fmt.Println("socket have panic err:", r, string(debug.Stack()))
 		}
-		//c.close()
+		c.close()
 	}()
 	//var returnErr error
 	for {
@@ -91,6 +94,7 @@ func (c *Client) readMessage() {
 			}
 			returnErr = c.handleMessage(message)
 			if returnErr != nil {
+				log.ZError(context.Background(), "WSGetNewestSeq", returnErr)
 				break
 			}

@@ -117,16 +121,14 @@ func (c *Client) handleMessage(message []byte) error {
 	if binaryReq.SendID != c.userID {
 		return errors.New("exception conn userID not same to req userID")
 	}
-	ctx := context.Background()
-	ctx = context.WithValue(ctx, ConnID, c.connID)
-	ctx = context.WithValue(ctx, OperationID, binaryReq.OperationID)
-	ctx = context.WithValue(ctx, CommonUserID, binaryReq.SendID)
-	ctx = context.WithValue(ctx, PlatformID, c.platformID)
+	ctx := mcontext.WithMustInfoCtx([]string{binaryReq.OperationID, binaryReq.SendID, constant.PlatformIDToName(c.platformID), c.ctx.GetConnID()})
 	var messageErr error
 	var resp []byte
 	switch binaryReq.ReqIdentifier {
 	case WSGetNewestSeq:
 		resp, messageErr = c.longConnServer.GetSeq(ctx, binaryReq)
+		log.ZError(ctx, "WSGetNewestSeq", messageErr, "resp", resp)
+
 	case WSSendMsg:
 		resp, messageErr = c.longConnServer.SendMessage(ctx, binaryReq)
 	case WSSendSignalMsg:
@@ -1,9 +1,11 @@
 package msggateway

 import (
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
 	"net/http"
 	"strconv"
+	"time"
 )

 type UserConnContext struct {
@@ -12,6 +14,36 @@ type UserConnContext struct {
 	Path       string
 	Method     string
 	RemoteAddr string
+	ConnID     string
+}
+
+func (c *UserConnContext) Deadline() (deadline time.Time, ok bool) {
+	return
+}
+
+func (c *UserConnContext) Done() <-chan struct{} {
+	return nil
+}
+
+func (c *UserConnContext) Err() error {
+	return nil
+}
+
+func (c *UserConnContext) Value(key any) any {
+	switch key {
+	case constant.OpUserID:
+		return c.GetUserID()
+	case constant.OperationID:
+		return c.GetOperationID()
+	case constant.ConnID:
+		return c.GetConnID()
+	case constant.OpUserPlatform:
+		return constant.PlatformIDToName(utils.StringToInt(c.GetPlatformID()))
+	case constant.RemoteAddr:
+		return c.RemoteAddr
+	default:
+		return ""
+	}
 }

 func newContext(respWriter http.ResponseWriter, req *http.Request) *UserConnContext {
@@ -21,6 +53,7 @@ func newContext(respWriter http.ResponseWriter, req *http.Request) *UserConnCont
 		Path:       req.URL.Path,
 		Method:     req.Method,
 		RemoteAddr: req.RemoteAddr,
+		ConnID:     utils.Md5(req.RemoteAddr + "_" + strconv.Itoa(int(utils.GetCurrentTimestampByMill()))),
 	}
 }
 func (c *UserConnContext) Query(key string) (string, bool) {
@@ -44,7 +77,7 @@ func (c *UserConnContext) ErrReturn(error string, code int) {
 	http.Error(c.RespWriter, error, code)
 }
 func (c *UserConnContext) GetConnID() string {
-	return utils.Md5(c.RemoteAddr + "_" + strconv.Itoa(int(utils.GetCurrentTimestampByMill())))
+	return c.ConnID
 }
 func (c *UserConnContext) GetUserID() string {
 	return c.Req.URL.Query().Get(WsUserID)
@@ -52,3 +85,6 @@ func (c *UserConnContext) GetUserID() string {
 func (c *UserConnContext) GetPlatformID() string {
 	return c.Req.URL.Query().Get(PlatformID)
 }
+func (c *UserConnContext) GetOperationID() string {
+	return c.Req.URL.Query().Get(OperationID)
+}
@@ -9,21 +9,24 @@ import (
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/errs"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/msggateway"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/rpcclient/notification"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/startrpc"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
 	"google.golang.org/grpc"
 )

-func Start(client discoveryregistry.SvcDiscoveryRegistry, server *grpc.Server) error {
-	msggateway.RegisterMsgGatewayServer(server, &Server{})
+func (s *Server) InitServer(client discoveryregistry.SvcDiscoveryRegistry, server *grpc.Server) error {
+	s.LongConnServer.SetMessageHandler(notification.NewCheck(client))
+	msggateway.RegisterMsgGatewayServer(server, s)
 	return nil
 }

 func (s *Server) Start() error {
-	return startrpc.Start(s.rpcPort, config.Config.RpcRegisterName.OpenImMessageGatewayName, s.prometheusPort, Start)
+	return startrpc.Start(s.rpcPort, config.Config.RpcRegisterName.OpenImMessageGatewayName, s.prometheusPort, s.InitServer)
 }

 type Server struct {
+	notification   *notification.Check
 	rpcPort        int
 	prometheusPort int
 	LongConnServer LongConnServer
@@ -31,6 +34,14 @@ type Server struct {
 	//rpcServer      *RpcServer
 }

+func (s *Server) SetLongConnServer(LongConnServer LongConnServer) {
+	s.LongConnServer = LongConnServer
+}
+
+func (s *Server) Notification() *notification.Check {
+	return s.notification
+}
+
 func NewServer(rpcPort int, longConnServer LongConnServer) *Server {
 	return &Server{rpcPort: rpcPort, LongConnServer: longConnServer, pushTerminal: []int{constant.IOSPlatformID, constant.AndroidPlatformID}}
 }
@@ -56,7 +67,7 @@ func (s *Server) GetUsersOnlineStatus(ctx context.Context, req *msggateway.GetUs
 				ps := new(msggateway.GetUsersOnlineStatusResp_SuccessDetail)
 				ps.Platform = constant.PlatformIDToName(client.platformID)
 				ps.Status = constant.OnlineStatus
-				ps.ConnID = client.connID
+				ps.ConnID = client.ctx.GetConnID()
 				ps.IsBackground = client.isBackground
 				temp.Status = constant.OnlineStatus
 				temp.DetailPlatformStatus = append(temp.DetailPlatformStatus, ps)
@@ -5,13 +5,10 @@ import (
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/config"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/log"
-	"sync"
 	"time"
 )

 func RunWsAndServer(rpcPort, wsPort, prometheusPort int) error {
-	var wg sync.WaitGroup
-	wg.Add(1)
 	log.NewPrivateLog(constant.LogFileName)
 	fmt.Println("start rpc/msg_gateway server, port: ", rpcPort, wsPort, prometheusPort, ", OpenIM version: ", config.Version)
 	longServer, err := NewWsServer(
@@ -24,7 +21,6 @@ func RunWsAndServer(rpcPort, wsPort, prometheusPort int) error {
 	}
 	hubServer := NewServer(rpcPort, longServer)
 	go hubServer.Start()
-	go hubServer.LongConnServer.Run()
-	wg.Wait()
+	hubServer.LongConnServer.Run()
 	return nil
 }
@@ -2,6 +2,7 @@ package msggateway

 import (
 	"context"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/log"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/msg"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/sdkws"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/rpcclient/notification"
@@ -53,6 +54,7 @@ func (g GrpcHandler) GetSeq(context context.Context, data Req) ([]byte, error) {
 	if err := g.validate.Struct(req); err != nil {
 		return nil, err
 	}
+	log.ZDebug(context, "msggateway GetSeq", "notification", g.notification, "msg", g.notification.Msg)
 	resp, err := g.notification.Msg.GetMaxAndMinSeq(context, &req)
 	if err != nil {
 		return nil, err
@@ -2,9 +2,10 @@ package msggateway

 import (
 	"errors"
-	"fmt"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/log"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/tokenverify"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/errs"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/rpcclient/notification"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
 	"github.com/go-playground/validator/v10"
 	"net/http"
@@ -19,6 +20,7 @@ type LongConnServer interface {
 	GetUserAllCons(userID string) ([]*Client, bool)
 	GetUserPlatformCons(userID string, platform int) ([]*Client, bool, bool)
 	Validate(s interface{}) error
+	SetMessageHandler(rpcClient *notification.Check)
 	UnRegister(c *Client)
 	Compressor
 	Encoder
@@ -42,12 +44,17 @@ type WsServer struct {
 	onlineUserConnNum               int64
 	handshakeTimeout                time.Duration
 	readBufferSize, WriteBufferSize int
+	hubServer                       *Server
 	validate                        *validator.Validate
 	Compressor
 	Encoder
 	MessageHandler
 }

+func (ws *WsServer) SetMessageHandler(rpcClient *notification.Check) {
+	ws.MessageHandler = NewGrpcHandler(ws.validate, rpcClient)
+}
+
 func (ws *WsServer) UnRegister(c *Client) {
 	ws.unregisterChan <- c
 }
@@ -90,8 +97,6 @@ func NewWsServer(opts ...Option) (*WsServer, error) {
 		clients:        newUserMap(),
 		Compressor:     NewGzipCompressor(),
 		Encoder:        NewGobEncoder(),
-		MessageHandler: NewGrpcHandler(v, nil),
-		//handler:  NewGrpcHandler(validate),
 	}, nil
 }
 func (ws *WsServer) Run() error {
@@ -121,8 +126,7 @@ func (ws *WsServer) registerClient(client *Client) {
 		ws.clients.Set(client.userID, client)
 		atomic.AddInt64(&ws.onlineUserNum, 1)
 		atomic.AddInt64(&ws.onlineUserConnNum, 1)
-		fmt.Println("R在线用户数量:", ws.onlineUserNum)
-		fmt.Println("R在线用户连接数量:", ws.onlineUserConnNum)
+
 	} else {
 		if clientOK { //已经有同平台的连接存在
 			ws.clients.Set(client.userID, client)
@@ -130,11 +134,9 @@ func (ws *WsServer) registerClient(client *Client) {
 		} else {
 			ws.clients.Set(client.userID, client)
 			atomic.AddInt64(&ws.onlineUserConnNum, 1)
-			fmt.Println("R在线用户数量:", ws.onlineUserNum)
-			fmt.Println("R在线用户连接数量:", ws.onlineUserConnNum)
 		}
 	}
-
+	log.ZInfo(client.ctx, "user online", "online user Num", ws.onlineUserNum, "online user conn Num", ws.onlineUserConnNum)
 }

 func (ws *WsServer) multiTerminalLoginChecker(client []*Client) {
@@ -147,8 +149,7 @@ func (ws *WsServer) unregisterClient(client *Client) {
 		atomic.AddInt64(&ws.onlineUserNum, -1)
 	}
 	atomic.AddInt64(&ws.onlineUserConnNum, -1)
-	fmt.Println("R在线用户数量:", ws.onlineUserNum)
-	fmt.Println("R在线用户连接数量:", ws.onlineUserConnNum)
+	log.ZInfo(client.ctx, "user offline", "online user Num", ws.onlineUserNum, "online user conn Num", ws.onlineUserConnNum)
 }

 func (ws *WsServer) wsHandler(w http.ResponseWriter, r *http.Request) {
@@ -10,7 +10,7 @@ import (
 	unRelationTb "github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/table/unrelation"
 	kfk "github.com/OpenIMSDK/Open-IM-Server/pkg/common/kafka"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/log"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/tracelog"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/mcontext"
 	pbMsg "github.com/OpenIMSDK/Open-IM-Server/pkg/proto/msg"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
 	"github.com/Shopify/sarama"
@@ -41,7 +41,7 @@ func (mmc *ModifyMsgConsumerHandler) ConsumeClaim(sess sarama.ConsumerGroupSessi
 	for msg := range claim.Messages() {
 		log.NewDebug("", "kafka get info to mysql", "ModifyMsgConsumerHandler", msg.Topic, "msgPartition", msg.Partition, "msg", string(msg.Value), "key", string(msg.Key))
 		if len(msg.Value) != 0 {
-			ctx := mmc.modifyMsgConsumerGroup.GetContextFromMsg(msg, "modify consumer")
+			ctx := mmc.modifyMsgConsumerGroup.GetContextFromMsg(msg)
 			mmc.ModifyMsg(ctx, msg, string(msg.Key), sess)
 		} else {
 			log.Error("", "msg get from kafka but is nil", msg.Key)
@@ -54,7 +54,7 @@ func (mmc *ModifyMsgConsumerHandler) ConsumeClaim(sess sarama.ConsumerGroupSessi
 func (mmc *ModifyMsgConsumerHandler) ModifyMsg(ctx context.Context, cMsg *sarama.ConsumerMessage, msgKey string, _ sarama.ConsumerGroupSession) {
 	log.NewInfo("msg come here ModifyMsg!!!", "", "msg", string(cMsg.Value), msgKey)
 	msgFromMQ := pbMsg.MsgDataToModifyByMQ{}
-	operationID := tracelog.GetOperationID(ctx)
+	operationID := mcontext.GetOperationID(ctx)
 	err := proto.Unmarshal(cMsg.Value, &msgFromMQ)
 	if err != nil {
 		log.NewError(msgFromMQ.TriggerID, "msg_transfer Unmarshal msg err", "msg", string(cMsg.Value), "err", err.Error())
@@ -66,7 +66,7 @@ func (mmc *ModifyMsgConsumerHandler) ModifyMsg(ctx context.Context, cMsg *sarama
 		if !isReactionFromCache {
 			continue
 		}
-		tracelog.SetOperationID(ctx, operationID)
+		ctx = mcontext.SetOperationID(ctx, operationID)
 		if msgDataToMQ.MsgData.ContentType == constant.ReactionMessageModifier {
 			notification := &apistruct.ReactionMessageModifierNotification{}
 			if err := json.Unmarshal(msgDataToMQ.MsgData.Content, notification); err != nil {
@@ -1,12 +1,13 @@
 package msgtransfer

 import (
+	"context"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/config"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/controller"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/kafka"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/log"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/tracelog"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/mcontext"
 	pbMsg "github.com/OpenIMSDK/Open-IM-Server/pkg/proto/msg"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
 	"github.com/Shopify/sarama"
@@ -22,20 +23,24 @@ const ChannelNum = 100

 type MsgChannelValue struct {
 	aggregationID string //maybe userID or super groupID
-	triggerID     string
-	msgList       []*pbMsg.MsgDataToMQ
+	ctx           context.Context
+	ctxMsgList    []*ContextMsg
 	lastSeq       uint64
 }

 type TriggerChannelValue struct {
-	triggerID string
-	cMsgList  []*sarama.ConsumerMessage
+	ctx      context.Context
+	cMsgList []*sarama.ConsumerMessage
 }

 type Cmd2Value struct {
 	Cmd   int
 	Value interface{}
 }
+type ContextMsg struct {
+	message *pbMsg.MsgDataToMQ
+	ctx     context.Context
+}

 type OnlineHistoryRedisConsumerHandler struct {
 	historyConsumerGroup *kafka.MConsumerGroup
@@ -80,38 +85,39 @@ func (och *OnlineHistoryRedisConsumerHandler) Run(channelID int) {
 			switch cmd.Cmd {
 			case AggregationMessages:
 				msgChannelValue := cmd.Value.(MsgChannelValue)
-				msgList := msgChannelValue.msgList
-				triggerID := msgChannelValue.triggerID
+				ctxMsgList := msgChannelValue.ctxMsgList
+				ctx := msgChannelValue.ctx
 				storageMsgList := make([]*pbMsg.MsgDataToMQ, 0, 80)
-				notStoragePushMsgList := make([]*pbMsg.MsgDataToMQ, 0, 80)
-				log.Debug(triggerID, "msg arrived channel", "channel id", channelID, msgList, msgChannelValue.aggregationID, len(msgList))
+				storagePushMsgList := make([]*ContextMsg, 0, 80)
+				notStoragePushMsgList := make([]*ContextMsg, 0, 80)
+				log.ZDebug(ctx, "msg arrived channel", "channel id", channelID, "msgList length", len(ctxMsgList), "aggregationID", msgChannelValue.aggregationID)
 				var modifyMsgList []*pbMsg.MsgDataToMQ
-				ctx := tracelog.NewCtx("redis consumer")
-				tracelog.SetOperationID(ctx, triggerID)
-				for _, v := range msgList {
-					log.Debug(triggerID, "msg come to storage center", v.String())
-					isHistory := utils.GetSwitchFromOptions(v.MsgData.Options, constant.IsHistory)
-					isSenderSync := utils.GetSwitchFromOptions(v.MsgData.Options, constant.IsSenderSync)
+				//ctx := mcontext.NewCtx("redis consumer")
+				//mcontext.SetOperationID(ctx, triggerID)
+				for _, v := range ctxMsgList {
+					log.ZDebug(ctx, "msg come to storage center", "message", v.message.String())
+					isHistory := utils.GetSwitchFromOptions(v.message.MsgData.Options, constant.IsHistory)
+					isSenderSync := utils.GetSwitchFromOptions(v.message.MsgData.Options, constant.IsSenderSync)
 					if isHistory {
-						storageMsgList = append(storageMsgList, v)
-						//log.NewWarn(triggerID, "storageMsgList to mongodb  client msgID: ", v.MsgData.ClientMsgID)
+						storageMsgList = append(storageMsgList, v.message)
+						storagePushMsgList = append(storagePushMsgList, v)
 					} else {
-						if !(!isSenderSync && msgChannelValue.aggregationID == v.MsgData.SendID) {
+						if !(!isSenderSync && msgChannelValue.aggregationID == v.message.MsgData.SendID) {
 							notStoragePushMsgList = append(notStoragePushMsgList, v)
 						}
 					}
-					if v.MsgData.ContentType == constant.ReactionMessageModifier || v.MsgData.ContentType == constant.ReactionMessageDeleter {
-						modifyMsgList = append(modifyMsgList, v)
+					if v.message.MsgData.ContentType == constant.ReactionMessageModifier || v.message.MsgData.ContentType == constant.ReactionMessageDeleter {
+						modifyMsgList = append(modifyMsgList, v.message)
 					}
 				}
 				if len(modifyMsgList) > 0 {
-					och.msgDatabase.MsgToModifyMQ(ctx, msgChannelValue.aggregationID, triggerID, modifyMsgList)
+					och.msgDatabase.MsgToModifyMQ(ctx, msgChannelValue.aggregationID, "", modifyMsgList)
 				}
-				log.Debug(triggerID, "msg storage length", len(storageMsgList), "push length", len(notStoragePushMsgList))
+				log.ZDebug(ctx, "msg storage length", "storageMsgList", len(storageMsgList), "push length", len(notStoragePushMsgList))
 				if len(storageMsgList) > 0 {
 					lastSeq, err := och.msgDatabase.BatchInsertChat2Cache(ctx, msgChannelValue.aggregationID, storageMsgList)
 					if err != nil {
-						log.NewError(triggerID, "single data insert to redis err", err.Error(), storageMsgList)
+						log.ZError(ctx, "batch data insert to redis err", err, "storageMsgList", storageMsgList)
 						och.singleMsgFailedCountMutex.Lock()
 						och.singleMsgFailedCount += uint64(len(storageMsgList))
 						och.singleMsgFailedCountMutex.Unlock()
@@ -119,18 +125,20 @@ func (och *OnlineHistoryRedisConsumerHandler) Run(channelID int) {
 						och.singleMsgSuccessCountMutex.Lock()
 						och.singleMsgSuccessCount += uint64(len(storageMsgList))
 						och.singleMsgSuccessCountMutex.Unlock()
-						och.msgDatabase.MsgToMongoMQ(ctx, msgChannelValue.aggregationID, triggerID, storageMsgList, lastSeq)
-						for _, v := range storageMsgList {
-							och.msgDatabase.MsgToPushMQ(ctx, msgChannelValue.aggregationID, v)
+						och.msgDatabase.MsgToMongoMQ(ctx, msgChannelValue.aggregationID, "", storageMsgList, lastSeq)
+						for _, v := range storagePushMsgList {
+							och.msgDatabase.MsgToPushMQ(v.ctx, msgChannelValue.aggregationID, v.message)
 						}
 						for _, v := range notStoragePushMsgList {
-							och.msgDatabase.MsgToPushMQ(ctx, msgChannelValue.aggregationID, v)
+							och.msgDatabase.MsgToPushMQ(v.ctx, msgChannelValue.aggregationID, v.message)
 						}
 					}
 				} else {
 					for _, v := range notStoragePushMsgList {
-						och.msgDatabase.MsgToPushMQ(ctx, msgChannelValue.aggregationID, v)
-
+						p, o, err := och.msgDatabase.MsgToPushMQ(v.ctx, msgChannelValue.aggregationID, v.message)
+						if err != nil {
+							log.ZError(v.ctx, "kafka send failed", err, "msg", v.message.String(), "pid", p, "offset", o)
+						}
 					}
 				}
 			}
@@ -140,40 +148,43 @@ func (och *OnlineHistoryRedisConsumerHandler) Run(channelID int) {

 func (och *OnlineHistoryRedisConsumerHandler) MessagesDistributionHandle() {
 	for {
-		aggregationMsgs := make(map[string][]*pbMsg.MsgDataToMQ, ChannelNum)
+		aggregationMsgs := make(map[string][]*ContextMsg, ChannelNum)
 		select {
 		case cmd := <-och.msgDistributionCh:
 			switch cmd.Cmd {
 			case ConsumerMsgs:
 				triggerChannelValue := cmd.Value.(TriggerChannelValue)
-				triggerID := triggerChannelValue.triggerID
+				ctx := triggerChannelValue.ctx
 				consumerMessages := triggerChannelValue.cMsgList
 				//Aggregation map[userid]message list
-				log.Debug(triggerID, "batch messages come to distribution center", len(consumerMessages))
+				log.ZDebug(ctx, "batch messages come to distribution center", "length", len(consumerMessages))
 				for i := 0; i < len(consumerMessages); i++ {
+					ctxMsg := &ContextMsg{}
 					msgFromMQ := pbMsg.MsgDataToMQ{}
 					err := proto.Unmarshal(consumerMessages[i].Value, &msgFromMQ)
 					if err != nil {
-						log.Error(triggerID, "msg_transfer Unmarshal msg err", "msg", string(consumerMessages[i].Value), "err", err.Error())
+						log.ZError(ctx, "msg_transfer Unmarshal msg err", err, string(consumerMessages[i].Value))
 						return
 					}
-					log.Debug(triggerID, "single msg come to distribution center", msgFromMQ.String(), string(consumerMessages[i].Key))
+					ctxMsg.ctx = kafka.GetContextWithMQHeader(consumerMessages[i].Headers)
+					ctxMsg.message = &msgFromMQ
+					log.ZDebug(ctx, "single msg come to distribution center", msgFromMQ.String(), string(consumerMessages[i].Key))
 					if oldM, ok := aggregationMsgs[string(consumerMessages[i].Key)]; ok {
-						oldM = append(oldM, &msgFromMQ)
+						oldM = append(oldM, ctxMsg)
 						aggregationMsgs[string(consumerMessages[i].Key)] = oldM
 					} else {
-						m := make([]*pbMsg.MsgDataToMQ, 0, 100)
-						m = append(m, &msgFromMQ)
+						m := make([]*ContextMsg, 0, 100)
+						m = append(m, ctxMsg)
 						aggregationMsgs[string(consumerMessages[i].Key)] = m
 					}
 				}
-				log.Debug(triggerID, "generate map list users len", len(aggregationMsgs))
+				log.ZDebug(ctx, "generate map list users len", "length", len(aggregationMsgs))
 				for aggregationID, v := range aggregationMsgs {
 					if len(v) >= 0 {
 						hashCode := utils.GetHashCode(aggregationID)
 						channelID := hashCode % ChannelNum
-						log.Debug(triggerID, "generate channelID", hashCode, channelID, aggregationID)
-						och.chArrays[channelID] <- Cmd2Value{Cmd: AggregationMessages, Value: MsgChannelValue{aggregationID: aggregationID, msgList: v, triggerID: triggerID}}
+						log.ZDebug(ctx, "generate channelID", "hashCode", hashCode, "channelID", channelID, "aggregationID", aggregationID)
+						och.chArrays[channelID] <- Cmd2Value{Cmd: AggregationMessages, Value: MsgChannelValue{aggregationID: aggregationID, ctxMsgList: v, ctx: ctx}}
 					}
 				}
 			}
@@ -181,8 +192,10 @@ func (och *OnlineHistoryRedisConsumerHandler) MessagesDistributionHandle() {
 	}
 }

-func (OnlineHistoryRedisConsumerHandler) Setup(_ sarama.ConsumerGroupSession) error   { return nil }
-func (OnlineHistoryRedisConsumerHandler) Cleanup(_ sarama.ConsumerGroupSession) error { return nil }
+func (och *OnlineHistoryRedisConsumerHandler) Setup(_ sarama.ConsumerGroupSession) error { return nil }
+func (och *OnlineHistoryRedisConsumerHandler) Cleanup(_ sarama.ConsumerGroupSession) error {
+	return nil
+}

 func (och *OnlineHistoryRedisConsumerHandler) ConsumeClaim(sess sarama.ConsumerGroupSession, claim sarama.ConsumerGroupClaim) error { // a instance in the consumer group
 	for {
@@ -194,10 +207,10 @@ func (och *OnlineHistoryRedisConsumerHandler) ConsumeClaim(sess sarama.ConsumerG
 		}
 	}
 	rwLock := new(sync.RWMutex)
-	log.NewDebug("", "online new session msg come", claim.HighWaterMarkOffset(), claim.Topic(), claim.Partition())
+	log.ZDebug(context.Background(), "online new session msg come", "highWaterMarkOffset",
+		claim.HighWaterMarkOffset(), "topic", claim.Topic(), "partition", claim.Partition())
 	cMsg := make([]*sarama.ConsumerMessage, 0, 1000)
 	t := time.NewTicker(time.Duration(100) * time.Millisecond)
-	var triggerID string
 	go func() {
 		for {
 			select {
@@ -211,18 +224,18 @@ func (och *OnlineHistoryRedisConsumerHandler) ConsumeClaim(sess sarama.ConsumerG
 					cMsg = make([]*sarama.ConsumerMessage, 0, 1000)
 					rwLock.Unlock()
 					split := 1000
-					triggerID = utils.OperationIDGenerator()
-					log.Debug(triggerID, "timer trigger msg consumer start", len(ccMsg))
+					ctx := mcontext.WithTriggerIDContext(context.Background(), utils.OperationIDGenerator())
+					log.ZDebug(ctx, "timer trigger msg consumer start", "length", len(ccMsg))
 					for i := 0; i < len(ccMsg)/split; i++ {
 						//log.Debug()
 						och.msgDistributionCh <- Cmd2Value{Cmd: ConsumerMsgs, Value: TriggerChannelValue{
-							triggerID: triggerID, cMsgList: ccMsg[i*split : (i+1)*split]}}
+							ctx: ctx, cMsgList: ccMsg[i*split : (i+1)*split]}}
 					}
 					if (len(ccMsg) % split) > 0 {
 						och.msgDistributionCh <- Cmd2Value{Cmd: ConsumerMsgs, Value: TriggerChannelValue{
-							triggerID: triggerID, cMsgList: ccMsg[split*(len(ccMsg)/split):]}}
+							ctx: ctx, cMsgList: ccMsg[split*(len(ccMsg)/split):]}}
 					}
-					log.Debug(triggerID, "timer trigger msg consumer end", len(cMsg))
+					log.ZDebug(ctx, "timer trigger msg consumer end", "length", len(ccMsg))
 				}
 			}
 		}
@@ -7,7 +7,7 @@ import (
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/controller"
 	kfk "github.com/OpenIMSDK/Open-IM-Server/pkg/common/kafka"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/log"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/tracelog"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/mcontext"
 	pbMsg "github.com/OpenIMSDK/Open-IM-Server/pkg/proto/msg"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/sdkws"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
@@ -33,7 +33,7 @@ func NewOnlineHistoryMongoConsumerHandler(database controller.MsgDatabase) *Onli
 func (mc *OnlineHistoryMongoConsumerHandler) handleChatWs2Mongo(ctx context.Context, cMsg *sarama.ConsumerMessage, msgKey string, session sarama.ConsumerGroupSession) {
 	msg := cMsg.Value
 	msgFromMQ := pbMsg.MsgDataToMongoByMQ{}
-	operationID := tracelog.GetOperationID(ctx)
+	operationID := mcontext.GetOperationID(ctx)
 	err := proto.Unmarshal(msg, &msgFromMQ)
 	if err != nil {
 		log.Error("msg_transfer Unmarshal msg err", "", "msg", string(msg), "err", err.Error())
@@ -78,7 +78,7 @@ func (mc *OnlineHistoryMongoConsumerHandler) ConsumeClaim(sess sarama.ConsumerGr
 	for msg := range claim.Messages() {
 		log.NewDebug("", "kafka get info to mongo", "msgTopic", msg.Topic, "msgPartition", msg.Partition, "msg", string(msg.Value), "key", string(msg.Key))
 		if len(msg.Value) != 0 {
-			ctx := mc.historyConsumerGroup.GetContextFromMsg(msg, "mongoDB consumer")
+			ctx := mc.historyConsumerGroup.GetContextFromMsg(msg)
 			mc.handleChatWs2Mongo(ctx, msg, string(msg.Key), sess)
 		} else {
 			log.Error("", "mongo msg get from kafka but is nil", msg.Key)
@@ -14,7 +14,7 @@ import (
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/controller"
 	kfk "github.com/OpenIMSDK/Open-IM-Server/pkg/common/kafka"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/log"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/tracelog"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/mcontext"
 	pbMsg "github.com/OpenIMSDK/Open-IM-Server/pkg/proto/msg"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"

@@ -38,7 +38,7 @@ func NewPersistentConsumerHandler(database controller.ChatLogDatabase) *Persiste

 func (pc *PersistentConsumerHandler) handleChatWs2Mysql(ctx context.Context, cMsg *sarama.ConsumerMessage, msgKey string, _ sarama.ConsumerGroupSession) {
 	msg := cMsg.Value
-	operationID := tracelog.GetOperationID(ctx)
+	operationID := mcontext.GetOperationID(ctx)
 	log.NewInfo("msg come here mysql!!!", "", "msg", string(msg), msgKey)
 	var tag bool
 	msgFromMQ := pbMsg.MsgDataToMQ{}
@@ -79,7 +79,7 @@ func (pc *PersistentConsumerHandler) ConsumeClaim(sess sarama.ConsumerGroupSessi
 	for msg := range claim.Messages() {
 		log.NewDebug("", "kafka get info to mysql", "msgTopic", msg.Topic, "msgPartition", msg.Partition, "msg", string(msg.Value), "key", string(msg.Key))
 		if len(msg.Value) != 0 {
-			ctx := pc.persistentConsumerGroup.GetContextFromMsg(msg, "mysql consumer")
+			ctx := pc.persistentConsumerGroup.GetContextFromMsg(msg)
 			pc.handleChatWs2Mysql(ctx, msg, string(msg.Key), sess)
 		} else {
 			log.Error("", "msg get from kafka but is nil", msg.Key)
@@ -6,7 +6,7 @@ import (
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/config"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/http"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/tracelog"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/mcontext"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/sdkws"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
 )
@@ -23,7 +23,7 @@ func callbackOfflinePush(ctx context.Context, userIDs []string, msg *sdkws.MsgDa
 		UserStatusBatchCallbackReq: callbackstruct.UserStatusBatchCallbackReq{
 			UserStatusBaseCallback: callbackstruct.UserStatusBaseCallback{
 				CallbackCommand: constant.CallbackOfflinePushCommand,
-				OperationID:     tracelog.GetOperationID(ctx),
+				OperationID:     mcontext.GetOperationID(ctx),
 				PlatformID:      int(msg.SenderPlatformID),
 				Platform:        constant.PlatformIDToName(int(msg.SenderPlatformID)),
 			},
@@ -60,7 +60,7 @@ func callbackOnlinePush(ctx context.Context, userIDs []string, msg *sdkws.MsgDat
 		UserStatusBatchCallbackReq: callbackstruct.UserStatusBatchCallbackReq{
 			UserStatusBaseCallback: callbackstruct.UserStatusBaseCallback{
 				CallbackCommand: constant.CallbackOnlinePushCommand,
-				OperationID:     tracelog.GetOperationID(ctx),
+				OperationID:     mcontext.GetOperationID(ctx),
 				PlatformID:      int(msg.SenderPlatformID),
 				Platform:        constant.PlatformIDToName(int(msg.SenderPlatformID)),
 			},
@@ -85,7 +85,7 @@ func callbackBeforeSuperGroupOnlinePush(ctx context.Context, groupID string, msg
 	req := callbackstruct.CallbackBeforeSuperGroupOnlinePushReq{
 		UserStatusBaseCallback: callbackstruct.UserStatusBaseCallback{
 			CallbackCommand: constant.CallbackSuperGroupOnlinePushCommand,
-			OperationID:     tracelog.GetOperationID(ctx),
+			OperationID:     mcontext.GetOperationID(ctx),
 			PlatformID:      int(msg.SenderPlatformID),
 			Platform:        constant.PlatformIDToName(int(msg.SenderPlatformID)),
 		},
@@ -1,17 +1,7 @@
-/*
-** description("").
-** copyright('open-im,www.open-im.io').
-** author("fg,Gordon@open-im.io").
-** time(2021/3/22 15:33).
- */
 package push

 import (
-	"fmt"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/config"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/prome"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/statistics"
 )

 type Consumer struct {
@@ -31,6 +21,6 @@ func (c *Consumer) initPrometheus() {
 }

 func (c *Consumer) Start() {
-	statistics.NewStatistics(&c.successCount, config.Config.ModuleName.PushName, fmt.Sprintf("%d second push to msg_gateway count", constant.StatisticsTimeInterval), constant.StatisticsTimeInterval)
+	//statistics.NewStatistics(&c.successCount, config.Config.ModuleName.PushName, fmt.Sprintf("%d second push to msg_gateway count", constant.StatisticsTimeInterval), constant.StatisticsTimeInterval)
 	go c.pushCh.pushConsumerGroup.RegisterHandleAndConsumer(&c.pushCh)
 }
@@ -6,7 +6,7 @@ import (
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/cache"
 	http2 "github.com/OpenIMSDK/Open-IM-Server/pkg/common/http"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/log"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/tracelog"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/mcontext"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils/splitter"
 	"github.com/go-redis/redis/v8"
 	"sync"
@@ -71,7 +71,7 @@ func (g *Client) Push(ctx context.Context, userIDs []string, title, content stri
 				go func(index int, userIDs []string) {
 					defer wg.Done()
 					if err2 := g.batchPush(ctx, token, userIDs, pushReq); err2 != nil {
-						log.NewError(tracelog.GetOperationID(ctx), "batchPush failed", i, token, pushReq)
+						log.NewError(mcontext.GetOperationID(ctx), "batchPush failed", i, token, pushReq)
 						err = err2
 					}
 				}(i, v.Item)
@@ -132,7 +132,7 @@ func (g *Client) batchPush(ctx context.Context, token string, userIDs []string,
 }

 func (g *Client) singlePush(ctx context.Context, token, userID string, pushReq PushReq) error {
-	operationID := tracelog.GetOperationID(ctx)
+	operationID := mcontext.GetOperationID(ctx)
 	pushReq.RequestID = &operationID
 	pushReq.Audience = &Audience{Alias: []string{userID}}
 	return g.request(ctx, pushURL, pushReq, token, nil)
@@ -1,9 +1,3 @@
-/*
-** description("").
-** copyright('OpenIM,www.OpenIM.io').
-** author("fg,Gordon@tuoyun.net").
-** time(2021/5/13 10:33).
- */
 package push

 import (
@@ -13,7 +7,6 @@ import (
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
 	kfk "github.com/OpenIMSDK/Open-IM-Server/pkg/common/kafka"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/log"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/tracelog"
 	pbChat "github.com/OpenIMSDK/Open-IM-Server/pkg/proto/msg"
 	pbPush "github.com/OpenIMSDK/Open-IM-Server/pkg/proto/push"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
@@ -36,10 +29,9 @@ func NewConsumerHandler(pusher *Pusher) *ConsumerHandler {
 }

 func (c *ConsumerHandler) handleMs2PsChat(ctx context.Context, msg []byte) {
-	log.NewDebug("", "msg come from kafka  And push!!!", "msg", string(msg))
 	msgFromMQ := pbChat.PushMsgDataToMQ{}
 	if err := proto.Unmarshal(msg, &msgFromMQ); err != nil {
-		log.Error("", "push Unmarshal msg err", "msg", string(msg), "err", err.Error())
+		log.ZError(ctx, "push Unmarshal msg err", err, "msg", string(msg))
 		return
 	}
 	pbData := &pbPush.PushMsgReq{
@@ -51,7 +43,6 @@ func (c *ConsumerHandler) handleMs2PsChat(ctx context.Context, msg []byte) {
 	if nowSec-sec > 10 {
 		return
 	}
-	tracelog.SetOperationID(ctx, "")
 	var err error
 	switch msgFromMQ.MsgData.SessionType {
 	case constant.SuperGroupChatType:
@@ -60,7 +51,7 @@ func (c *ConsumerHandler) handleMs2PsChat(ctx context.Context, msg []byte) {
 		err = c.pusher.MsgToUser(ctx, pbData.SourceID, pbData.MsgData)
 	}
 	if err != nil {
-		log.NewError("", "push failed", pbData)
+		log.ZError(ctx, "push failed", err, "msg", pbData.String())
 	}
 }
 func (ConsumerHandler) Setup(_ sarama.ConsumerGroupSession) error   { return nil }
@@ -68,8 +59,7 @@ func (ConsumerHandler) Cleanup(_ sarama.ConsumerGroupSession) error { return nil
 func (c *ConsumerHandler) ConsumeClaim(sess sarama.ConsumerGroupSession,
 	claim sarama.ConsumerGroupClaim) error {
 	for msg := range claim.Messages() {
-		log.NewDebug("", "kafka get info to mysql", "msgTopic", msg.Topic, "msgPartition", msg.Partition, "msg", string(msg.Value))
-		ctx := c.pushConsumerGroup.GetContextFromMsg(msg, "push consumer")
+		ctx := c.pushConsumerGroup.GetContextFromMsg(msg)
 		c.handleMs2PsChat(ctx, msg.Value)
 		sess.MarkMessage(msg, "")
 	}
@@ -22,7 +22,6 @@ func Start(client discoveryregistry.SvcDiscoveryRegistry, server *grpc.Server) e
 		return err
 	}
 	cacheModel := cache.NewCacheModel(rdb)
-
 	offlinePusher := NewOfflinePusher(cacheModel)
 	database := controller.NewPushDatabase(cacheModel)
 	pusher := NewPusher(client, offlinePusher, database, localcache.NewGroupLocalCache(client), localcache.NewConversationLocalCache(client))
@@ -1,9 +1,3 @@
-/*
-** description("").
-** copyright('open-im,www.open-im.io').
-** author("fg,Gordon@open-im.io").
-** time(2021/3/5 14:31).
- */
 package push

 import (
@@ -19,8 +13,8 @@ import (
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/controller"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/localcache"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/log"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/mcontext"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/prome"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/tracelog"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/errs"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/msggateway"
@@ -64,9 +58,8 @@ func NewOfflinePusher(cache cache.Model) offlinepush.OfflinePusher {
 }

 func (p *Pusher) MsgToUser(ctx context.Context, userID string, msg *sdkws.MsgData) error {
-	operationID := tracelog.GetOperationID(ctx)
 	var userIDs = []string{userID}
-	log.Debug(operationID, "Get msg from msg_transfer And push msg", msg.String(), userID)
+	log.ZDebug(ctx, "Get msg from msg_transfer And push msg", "userID", userID, "msg", msg.String())
 	// callback
 	if err := callbackOnlinePush(ctx, userIDs, msg); err != nil && err != errs.ErrCallbackContinue {
 		return err
@@ -77,7 +70,8 @@ func (p *Pusher) MsgToUser(ctx context.Context, userID string, msg *sdkws.MsgDat
 		return err
 	}
 	isOfflinePush := utils.GetSwitchFromOptions(msg.Options, constant.IsOfflinePush)
-	log.NewInfo(operationID, "push_result", wsResults, "sendData", msg, "isOfflinePush", isOfflinePush)
+	//log.NewInfo(operationID, "push_result", wsResults, "sendData", msg, "isOfflinePush", isOfflinePush)
+	log.ZDebug(ctx, "push_result", "ws push result", wsResults, "sendData", msg, "isOfflinePush", isOfflinePush, "push_to_userID", userID)
 	p.successCount++
 	if isOfflinePush && userID != msg.SendID {
 		// save invitation info for offline push
@@ -107,7 +101,7 @@ func (p *Pusher) MsgToUser(ctx context.Context, userID string, msg *sdkws.MsgDat
 }

 func (p *Pusher) MsgToSuperGroupUser(ctx context.Context, groupID string, msg *sdkws.MsgData) (err error) {
-	operationID := tracelog.GetOperationID(ctx)
+	operationID := mcontext.GetOperationID(ctx)
 	log.Debug(operationID, "Get super group msg from msg_transfer And push msg", msg.String(), groupID)
 	var pushToUserIDs []string
 	if err := callbackBeforeSuperGroupOnlinePush(ctx, groupID, msg, &pushToUserIDs); err != nil && err != errs.ErrCallbackContinue {
@@ -183,6 +177,7 @@ func (p *Pusher) MsgToSuperGroupUser(ctx context.Context, groupID string, msg *s

 func (p *Pusher) GetConnsAndOnlinePush(ctx context.Context, msg *sdkws.MsgData, pushToUserIDs []string) (wsResults []*msggateway.SingleMsgToUserResults, err error) {
 	conns, err := p.client.GetConns(config.Config.RpcRegisterName.OpenImMessageGatewayName)
+	log.ZDebug(ctx, "get gateway conn", "conn length", len(conns))
 	if err != nil {
 		return nil, err
 	}
@@ -191,7 +186,6 @@ func (p *Pusher) GetConnsAndOnlinePush(ctx context.Context, msg *sdkws.MsgData,
 		msgClient := msggateway.NewMsgGatewayClient(v)
 		reply, err := msgClient.SuperGroupOnlineBatchPushOneMsg(ctx, &msggateway.OnlineBatchPushOneMsgReq{MsgData: msg, PushToUserIDs: pushToUserIDs})
 		if err != nil {
-			log.NewError(tracelog.GetOperationID(ctx), msg, len(pushToUserIDs), "err", err)
 			continue
 		}
 		if reply != nil && reply.SinglePushResult != nil {
@@ -6,8 +6,8 @@ import (
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/cache"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/controller"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/mcontext"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/tokenverify"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/tracelog"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/errs"
 	pbAuth "github.com/OpenIMSDK/Open-IM-Server/pkg/proto/auth"
@@ -92,7 +92,7 @@ func (s *authServer) ForceLogout(ctx context.Context, req *pbAuth.ForceLogoutReq
 	if err := tokenverify.CheckAdmin(ctx); err != nil {
 		return nil, err
 	}
-	if err := s.forceKickOff(ctx, req.UserID, req.PlatformID, tracelog.GetOperationID(ctx)); err != nil {
+	if err := s.forceKickOff(ctx, req.UserID, req.PlatformID, mcontext.GetOperationID(ctx)); err != nil {
 		return nil, err
 	}
 	return &resp, nil
@@ -5,8 +5,8 @@ import (
 	"time"

 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/table/relation"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/mcontext"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/tokenverify"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/tracelog"
 	pbFriend "github.com/OpenIMSDK/Open-IM-Server/pkg/proto/friend"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/rpcclient/convert"
 )
@@ -63,7 +63,7 @@ func (s *friendServer) AddBlack(ctx context.Context, req *pbFriend.AddBlackReq)
 	if err != nil {
 		return nil, err
 	}
-	black := relation.BlackModel{OwnerUserID: req.OwnerUserID, BlockUserID: req.BlackUserID, OperatorUserID: tracelog.GetOpUserID(ctx), CreateTime: time.Now()}
+	black := relation.BlackModel{OwnerUserID: req.OwnerUserID, BlockUserID: req.BlackUserID, OperatorUserID: mcontext.GetOpUserID(ctx), CreateTime: time.Now()}
 	if err := s.BlackDatabase.Create(ctx, []*relation.BlackModel{&black}); err != nil {
 		return nil, err
 	}
@@ -6,7 +6,7 @@ import (
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/config"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/http"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/tracelog"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/mcontext"
 	pbfriend "github.com/OpenIMSDK/Open-IM-Server/pkg/proto/friend"
 )

@@ -19,7 +19,7 @@ func CallbackBeforeAddFriend(ctx context.Context, req *pbfriend.ApplyToAddFriend
 		FromUserID:      req.FromUserID,
 		ToUserID:        req.ToUserID,
 		ReqMsg:          req.ReqMsg,
-		OperationID:     tracelog.GetOperationID(ctx),
+		OperationID:     mcontext.GetOperationID(ctx),
 	}
 	resp := &cbapi.CallbackBeforeAddFriendResp{}
 	return http.CallBackPostReturn(config.Config.Callback.CallbackUrl, cbReq, resp, config.Config.Callback.CallbackBeforeAddFriend)
@@ -8,7 +8,7 @@ import (
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/table/relation"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/http"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/tracelog"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/mcontext"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/group"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/wrapperspb"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
@@ -21,7 +21,7 @@ func CallbackBeforeCreateGroup(ctx context.Context, req *group.CreateGroupReq) (
 	}
 	cbReq := &callbackstruct.CallbackBeforeCreateGroupReq{
 		CallbackCommand: constant.CallbackBeforeCreateGroupCommand,
-		OperationID:     tracelog.GetOperationID(ctx),
+		OperationID:     mcontext.GetOperationID(ctx),
 		GroupInfo:       *req.GroupInfo,
 	}
 	cbReq.InitMemberList = append(cbReq.InitMemberList, &apistruct.GroupAddMemberInfo{
@@ -66,7 +66,7 @@ func CallbackBeforeMemberJoinGroup(ctx context.Context, groupMember *relation.Gr
 	}
 	callbackReq := &callbackstruct.CallbackBeforeMemberJoinGroupReq{
 		CallbackCommand: constant.CallbackBeforeMemberJoinGroupCommand,
-		OperationID:     tracelog.GetOperationID(ctx),
+		OperationID:     mcontext.GetOperationID(ctx),
 		GroupID:         groupMember.GroupID,
 		UserID:          groupMember.UserID,
 		Ex:              groupMember.Ex,
@@ -93,7 +93,7 @@ func CallbackBeforeSetGroupMemberInfo(ctx context.Context, req *group.SetGroupMe
 	}
 	callbackReq := callbackstruct.CallbackBeforeSetGroupMemberInfoReq{
 		CallbackCommand: constant.CallbackBeforeSetGroupMemberInfoCommand,
-		OperationID:     tracelog.GetOperationID(ctx),
+		OperationID:     mcontext.GetOperationID(ctx),
 		GroupID:         req.GroupID,
 		UserID:          req.UserID,
 	}
@@ -16,8 +16,8 @@ import (
 	relationTb "github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/table/relation"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/unrelation"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/log"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/mcontext"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/tokenverify"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/tracelog"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/errs"
 	pbConversation "github.com/OpenIMSDK/Open-IM-Server/pkg/proto/conversation"
@@ -63,7 +63,7 @@ type groupServer struct {

 func (s *groupServer) CheckGroupAdmin(ctx context.Context, groupID string) error {
 	if !tokenverify.IsAppManagerUid(ctx) {
-		groupMember, err := s.GroupDatabase.TakeGroupMember(ctx, groupID, tracelog.GetOpUserID(ctx))
+		groupMember, err := s.GroupDatabase.TakeGroupMember(ctx, groupID, mcontext.GetOpUserID(ctx))
 		if err != nil {
 			return err
 		}
@@ -103,7 +103,7 @@ func (s *groupServer) GenGroupID(ctx context.Context, groupID *string) error {
 		}
 	}
 	for i := 0; i < 10; i++ {
-		id := utils.Md5(strings.Join([]string{tracelog.GetOperationID(ctx), strconv.FormatInt(time.Now().UnixNano(), 10), strconv.Itoa(rand.Int())}, ",;,"))
+		id := utils.Md5(strings.Join([]string{mcontext.GetOperationID(ctx), strconv.FormatInt(time.Now().UnixNano(), 10), strconv.Itoa(rand.Int())}, ",;,"))
 		bi := big.NewInt(0)
 		bi.SetString(id[0:8], 16)
 		id = bi.String()
@@ -148,9 +148,9 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
 		groupMember.Nickname = ""
 		groupMember.GroupID = group.GroupID
 		groupMember.RoleLevel = roleLevel
-		groupMember.OperatorUserID = tracelog.GetOpUserID(ctx)
+		groupMember.OperatorUserID = mcontext.GetOpUserID(ctx)
 		groupMember.JoinSource = constant.JoinByInvitation
-		groupMember.InviterUserID = tracelog.GetOpUserID(ctx)
+		groupMember.InviterUserID = mcontext.GetOpUserID(ctx)
 		groupMember.JoinTime = time.Now()
 		if err := CallbackBeforeMemberJoinGroup(ctx, groupMember, group.Ex); err != nil && err != errs.ErrCallbackContinue {
 			return err
@@ -265,7 +265,7 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
 	}
 	if group.NeedVerification == constant.AllNeedVerification {
 		if !tokenverify.IsAppManagerUid(ctx) {
-			opUserID := tracelog.GetOpUserID(ctx)
+			opUserID := mcontext.GetOpUserID(ctx)
 			member, ok := memberMap[opUserID]
 			if !ok {
 				return nil, errs.ErrNoPermission.Wrap("not in group")
@@ -303,7 +303,7 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
 			s.Notification.SuperGroupNotification(ctx, userID, userID)
 		}
 	} else {
-		opUserID := tracelog.GetOpUserID(ctx)
+		opUserID := mcontext.GetOpUserID(ctx)
 		var groupMembers []*relationTb.GroupMemberModel
 		for _, userID := range req.InvitedUserIDs {
 			member := PbToDbGroupMember(userMap[userID])
@@ -388,7 +388,7 @@ func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGrou
 	if utils.IsDuplicateStringSlice(req.KickedUserIDs) {
 		return nil, errs.ErrArgs.Wrap("KickedUserIDs duplicate")
 	}
-	opUserID := tracelog.GetOpUserID(ctx)
+	opUserID := mcontext.GetOpUserID(ctx)
 	if utils.IsContain(opUserID, req.KickedUserIDs) {
 		return nil, errs.ErrArgs.Wrap("opUserID in KickedUserIDs")
 	}
@@ -593,7 +593,7 @@ func (s *groupServer) GroupApplicationResponse(ctx context.Context, req *pbGroup
 			JoinTime:       time.Now(),
 			JoinSource:     groupRequest.JoinSource,
 			InviterUserID:  groupRequest.InviterUserID,
-			OperatorUserID: tracelog.GetOpUserID(ctx),
+			OperatorUserID: mcontext.GetOpUserID(ctx),
 			Ex:             groupRequest.Ex,
 		}
 		if err = CallbackBeforeMemberJoinGroup(ctx, member, group.Ex); err != nil && err != errs.ErrCallbackContinue {
@@ -616,7 +616,7 @@ func (s *groupServer) GroupApplicationResponse(ctx context.Context, req *pbGroup

 func (s *groupServer) JoinGroup(ctx context.Context, req *pbGroup.JoinGroupReq) (*pbGroup.JoinGroupResp, error) {
 	resp := &pbGroup.JoinGroupResp{}
-	if _, err := s.UserCheck.GetPublicUserInfo(ctx, tracelog.GetOpUserID(ctx)); err != nil {
+	if _, err := s.UserCheck.GetPublicUserInfo(ctx, mcontext.GetOpUserID(ctx)); err != nil {
 		return nil, err
 	}
 	group, err := s.GroupDatabase.TakeGroup(ctx, req.GroupID)
@@ -630,27 +630,27 @@ func (s *groupServer) JoinGroup(ctx context.Context, req *pbGroup.JoinGroupReq)
 		if group.GroupType == constant.SuperGroup {
 			return nil, errs.ErrGroupTypeNotSupport.Wrap()
 		}
-		user, err := s.UserCheck.GetUserInfo(ctx, tracelog.GetOpUserID(ctx))
+		user, err := s.UserCheck.GetUserInfo(ctx, mcontext.GetOpUserID(ctx))
 		if err != nil {
 			return nil, err
 		}
 		groupMember := PbToDbGroupMember(user)
 		groupMember.GroupID = group.GroupID
 		groupMember.RoleLevel = constant.GroupOrdinaryUsers
-		groupMember.OperatorUserID = tracelog.GetOpUserID(ctx)
+		groupMember.OperatorUserID = mcontext.GetOpUserID(ctx)
 		groupMember.JoinSource = constant.JoinByInvitation
-		groupMember.InviterUserID = tracelog.GetOpUserID(ctx)
+		groupMember.InviterUserID = mcontext.GetOpUserID(ctx)
 		if err := CallbackBeforeMemberJoinGroup(ctx, groupMember, group.Ex); err != nil && err != errs.ErrCallbackContinue {
 			return nil, err
 		}
 		if err := s.GroupDatabase.CreateGroup(ctx, nil, []*relationTb.GroupMemberModel{groupMember}); err != nil {
 			return nil, err
 		}
-		s.Notification.MemberEnterDirectlyNotification(ctx, req.GroupID, tracelog.GetOpUserID(ctx), tracelog.GetOperationID(ctx))
+		s.Notification.MemberEnterDirectlyNotification(ctx, req.GroupID, mcontext.GetOpUserID(ctx), mcontext.GetOperationID(ctx))
 		return resp, nil
 	}
 	groupRequest := relationTb.GroupRequestModel{
-		UserID:     tracelog.GetOpUserID(ctx),
+		UserID:     mcontext.GetOpUserID(ctx),
 		ReqMsg:     req.ReqMessage,
 		GroupID:    req.GroupID,
 		JoinSource: req.JoinSource,
@@ -670,12 +670,12 @@ func (s *groupServer) QuitGroup(ctx context.Context, req *pbGroup.QuitGroupReq)
 		return nil, err
 	}
 	if group.GroupType == constant.SuperGroup {
-		if err := s.GroupDatabase.DeleteSuperGroupMember(ctx, req.GroupID, []string{tracelog.GetOpUserID(ctx)}); err != nil {
+		if err := s.GroupDatabase.DeleteSuperGroupMember(ctx, req.GroupID, []string{mcontext.GetOpUserID(ctx)}); err != nil {
 			return nil, err
 		}
-		s.Notification.SuperGroupNotification(ctx, tracelog.GetOpUserID(ctx), tracelog.GetOpUserID(ctx))
+		s.Notification.SuperGroupNotification(ctx, mcontext.GetOpUserID(ctx), mcontext.GetOpUserID(ctx))
 	} else {
-		_, err := s.GroupDatabase.TakeGroupMember(ctx, req.GroupID, tracelog.GetOpUserID(ctx))
+		_, err := s.GroupDatabase.TakeGroupMember(ctx, req.GroupID, mcontext.GetOpUserID(ctx))
 		if err != nil {
 			return nil, err
 		}
@@ -687,7 +687,7 @@ func (s *groupServer) QuitGroup(ctx context.Context, req *pbGroup.QuitGroupReq)
 func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInfoReq) (*pbGroup.SetGroupInfoResp, error) {
 	resp := &pbGroup.SetGroupInfoResp{}
 	if !tokenverify.IsAppManagerUid(ctx) {
-		groupMember, err := s.GroupDatabase.TakeGroupMember(ctx, req.GroupInfoForSet.GroupID, tracelog.GetOpUserID(ctx))
+		groupMember, err := s.GroupDatabase.TakeGroupMember(ctx, req.GroupInfoForSet.GroupID, mcontext.GetOpUserID(ctx))
 		if err != nil {
 			return nil, err
 		}
@@ -721,7 +721,7 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInf
 	if req.GroupInfoForSet.Notification != "" {
 		args := pbConversation.ModifyConversationFieldReq{
 			Conversation: &pbConversation.Conversation{
-				OwnerUserID:      tracelog.GetOpUserID(ctx),
+				OwnerUserID:      mcontext.GetOpUserID(ctx),
 				ConversationID:   utils.GetConversationIDBySessionType(group.GroupID, constant.GroupChatType),
 				ConversationType: constant.GroupChatType,
 				GroupID:          group.GroupID,
@@ -772,8 +772,8 @@ func (s *groupServer) TransferGroupOwner(ctx context.Context, req *pbGroup.Trans
 		if oldOwner == nil {
 			return nil, errs.ErrArgs.Wrap("OldOwnerUser not in group " + req.NewOwnerUserID)
 		}
-		if oldOwner.GroupID != tracelog.GetOpUserID(ctx) {
-			return nil, errs.ErrNoPermission.Wrap(fmt.Sprintf("user %s no permission transfer group owner", tracelog.GetOpUserID(ctx)))
+		if oldOwner.GroupID != mcontext.GetOpUserID(ctx) {
+			return nil, errs.ErrNoPermission.Wrap(fmt.Sprintf("user %s no permission transfer group owner", mcontext.GetOpUserID(ctx)))
 		}
 	}
 	if err := s.GroupDatabase.TransferGroupOwner(ctx, req.GroupID, req.OldOwnerUserID, req.NewOwnerUserID, newOwner.RoleLevel); err != nil {
@@ -922,7 +922,7 @@ func (s *groupServer) MuteGroupMember(ctx context.Context, req *pbGroup.MuteGrou
 	if err != nil {
 		return nil, err
 	}
-	if !(tracelog.GetOpUserID(ctx) == req.UserID || tokenverify.IsAppManagerUid(ctx)) {
+	if !(mcontext.GetOpUserID(ctx) == req.UserID || tokenverify.IsAppManagerUid(ctx)) {
 		opMember, err := s.GroupDatabase.TakeGroupMember(ctx, req.GroupID, req.UserID)
 		if err != nil {
 			return nil, err
@@ -945,8 +945,8 @@ func (s *groupServer) CancelMuteGroupMember(ctx context.Context, req *pbGroup.Ca
 	if err != nil {
 		return nil, err
 	}
-	if !(tracelog.GetOpUserID(ctx) == req.UserID || tokenverify.IsAppManagerUid(ctx)) {
-		opMember, err := s.GroupDatabase.TakeGroupMember(ctx, req.GroupID, tracelog.GetOpUserID(ctx))
+	if !(mcontext.GetOpUserID(ctx) == req.UserID || tokenverify.IsAppManagerUid(ctx)) {
+		opMember, err := s.GroupDatabase.TakeGroupMember(ctx, req.GroupID, mcontext.GetOpUserID(ctx))
 		if err != nil {
 			return nil, err
 		}
@@ -1005,7 +1005,7 @@ func (s *groupServer) SetGroupMemberInfo(ctx context.Context, req *pbGroup.SetGr
 	}
 	groupIDs := utils.Keys(groupIDMap)
 	userIDs := utils.Keys(userIDMap)
-	members, err := s.GroupDatabase.FindGroupMember(ctx, groupIDs, append(userIDs, tracelog.GetOpUserID(ctx)), nil)
+	members, err := s.GroupDatabase.FindGroupMember(ctx, groupIDs, append(userIDs, mcontext.GetOpUserID(ctx)), nil)
 	if err != nil {
 		return nil, err
 	}
@@ -1021,7 +1021,7 @@ func (s *groupServer) SetGroupMemberInfo(ctx context.Context, req *pbGroup.SetGr
 		return [...]string{e.GroupID, e.UserID}
 	})
 	if !tokenverify.IsAppManagerUid(ctx) {
-		opUserID := tracelog.GetOpUserID(ctx)
+		opUserID := mcontext.GetOpUserID(ctx)
 		for _, member := range members {
 			if member.UserID == opUserID {
 				continue
@@ -6,7 +6,7 @@ import (
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/config"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/http"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/tracelog"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/mcontext"
 	pbChat "github.com/OpenIMSDK/Open-IM-Server/pkg/proto/msg"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
 )
@@ -21,7 +21,7 @@ func toCommonCallback(ctx context.Context, msg *pbChat.SendMsgReq, command strin
 		ServerMsgID:      msg.MsgData.ServerMsgID,
 		CallbackCommand:  command,
 		ClientMsgID:      msg.MsgData.ClientMsgID,
-		OperationID:      tracelog.GetOperationID(ctx),
+		OperationID:      mcontext.GetOperationID(ctx),
 		SenderPlatformID: msg.MsgData.SenderPlatformID,
 		SenderNickname:   msg.MsgData.SenderNickname,
 		SessionType:      msg.MsgData.SessionType,
@@ -6,7 +6,7 @@ import (
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/config"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/http"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/tracelog"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/mcontext"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/msg"
 )

@@ -15,10 +15,10 @@ func CallbackSetMessageReactionExtensions(ctx context.Context, setReq *msg.SetMe
 		return nil
 	}
 	req := &cbapi.CallbackBeforeSetMessageReactionExtReq{
-		OperationID:           tracelog.GetOperationID(ctx),
+		OperationID:           mcontext.GetOperationID(ctx),
 		CallbackCommand:       constant.CallbackBeforeSetMessageReactionExtensionCommand,
 		SourceID:              setReq.SourceID,
-		OpUserID:              tracelog.GetOpUserID(ctx),
+		OpUserID:              mcontext.GetOpUserID(ctx),
 		SessionType:           setReq.SessionType,
 		ReactionExtensionList: setReq.ReactionExtensions,
 		ClientMsgID:           setReq.ClientMsgID,
@@ -58,10 +58,10 @@ func CallbackGetMessageListReactionExtensions(ctx context.Context, getReq *msg.G
 		return nil
 	}
 	req := &cbapi.CallbackGetMessageListReactionExtReq{
-		OperationID:     tracelog.GetOperationID(ctx),
+		OperationID:     mcontext.GetOperationID(ctx),
 		CallbackCommand: constant.CallbackGetMessageListReactionExtensionsCommand,
 		SourceID:        getReq.SourceID,
-		OpUserID:        tracelog.GetOperationID(ctx),
+		OpUserID:        mcontext.GetOperationID(ctx),
 		SessionType:     getReq.SessionType,
 		TypeKeyList:     getReq.TypeKeys,
 	}
@@ -71,10 +71,10 @@ func CallbackGetMessageListReactionExtensions(ctx context.Context, getReq *msg.G

 func CallbackAddMessageReactionExtensions(ctx context.Context, setReq *msg.ModifyMessageReactionExtensionsReq) error {
 	req := &cbapi.CallbackAddMessageReactionExtReq{
-		OperationID:           tracelog.GetOperationID(ctx),
+		OperationID:           mcontext.GetOperationID(ctx),
 		CallbackCommand:       constant.CallbackAddMessageListReactionExtensionsCommand,
 		SourceID:              setReq.SourceID,
-		OpUserID:              tracelog.GetOperationID(ctx),
+		OpUserID:              mcontext.GetOperationID(ctx),
 		SessionType:           setReq.SessionType,
 		ReactionExtensionList: setReq.ReactionExtensions,
 		ClientMsgID:           setReq.ClientMsgID,
@@ -0,0 +1,61 @@
+package msg
+
+import (
+	"context"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/config"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/log"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/errs"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/msg"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/sdkws"
+)
+
+type MessageInterceptorFunc func(ctx context.Context, req *msg.SendMsgReq) (*sdkws.MsgData, error)
+
+func MessageHasReadEnabled(_ context.Context, req *msg.SendMsgReq) (*sdkws.MsgData, error) {
+	switch req.MsgData.ContentType {
+	case constant.HasReadReceipt:
+		if config.Config.SingleMessageHasReadReceiptEnable {
+			return req.MsgData, nil
+		} else {
+			return nil, errs.ErrMessageHasReadDisable.Wrap()
+		}
+	case constant.GroupHasReadReceipt:
+		if config.Config.GroupMessageHasReadReceiptEnable {
+			return req.MsgData, nil
+		} else {
+			return nil, errs.ErrMessageHasReadDisable.Wrap()
+		}
+	}
+	return req.MsgData, nil
+}
+func MessageModifyCallback(ctx context.Context, req *msg.SendMsgReq) (*sdkws.MsgData, error) {
+	if err := CallbackMsgModify(ctx, req); err != nil && err != errs.ErrCallbackContinue {
+		log.ZWarn(ctx, "CallbackMsgModify failed", err, "req", req.String())
+		return nil, err
+	}
+	return req.MsgData, nil
+}
+func MessageBeforeSendCallback(ctx context.Context, req *msg.SendMsgReq) (*sdkws.MsgData, error) {
+	switch req.MsgData.SessionType {
+	case constant.SingleChatType:
+		if err := CallbackBeforeSendSingleMsg(ctx, req); err != nil && err != errs.ErrCallbackContinue {
+			log.ZWarn(ctx, "CallbackBeforeSendSingleMsg failed", err, "req", req.String())
+			return nil, err
+		}
+	case constant.GroupChatType:
+		if err := CallbackBeforeSendGroupMsg(ctx, req); err != nil && err != errs.ErrCallbackContinue {
+			log.ZWarn(ctx, "CallbackBeforeSendGroupMsg failed", err, "req", req.String())
+			return nil, err
+		}
+	case constant.NotificationChatType:
+	case constant.SuperGroupChatType:
+		if err := CallbackBeforeSendGroupMsg(ctx, req); err != nil && err != errs.ErrCallbackContinue {
+			log.ZWarn(ctx, "CallbackBeforeSendGroupMsg failed", err, "req", req.String())
+			return nil, err
+		}
+	default:
+		return nil, errs.ErrArgs.Wrap("unknown sessionType")
+	}
+	return req.MsgData, nil
+}
@@ -3,13 +3,13 @@ package msg
 import (
 	"context"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/tracelog"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/mcontext"
 	pbMsg "github.com/OpenIMSDK/Open-IM-Server/pkg/proto/msg"
 )

 func (m *msgServer) SetSendMsgStatus(ctx context.Context, req *pbMsg.SetSendMsgStatusReq) (*pbMsg.SetSendMsgStatusResp, error) {
 	resp := &pbMsg.SetSendMsgStatusResp{}
-	if err := m.MsgDatabase.SetSendMsgStatus(ctx, tracelog.GetOperationID(ctx), req.Status); err != nil {
+	if err := m.MsgDatabase.SetSendMsgStatus(ctx, mcontext.GetOperationID(ctx), req.Status); err != nil {
 		return nil, err
 	}
 	return resp, nil
@@ -17,7 +17,7 @@ func (m *msgServer) SetSendMsgStatus(ctx context.Context, req *pbMsg.SetSendMsgS

 func (m *msgServer) GetSendMsgStatus(ctx context.Context, req *pbMsg.GetSendMsgStatusReq) (*pbMsg.GetSendMsgStatusResp, error) {
 	resp := &pbMsg.GetSendMsgStatusResp{}
-	status, err := m.MsgDatabase.GetSendMsgStatus(ctx, tracelog.GetOperationID(ctx))
+	status, err := m.MsgDatabase.GetSendMsgStatus(ctx, mcontext.GetOperationID(ctx))
 	if IsNotFound(err) {
 		resp.Status = constant.MsgStatusNotExist
 		return resp, nil
@@ -270,9 +270,10 @@ func (m *msgServer) modifyMessageByUserMessageReceiveOpt(ctx context.Context, us
 	}
 	conversationID := utils.GetConversationIDBySessionType(sourceID, sessionType)
 	singleOpt, err := m.Conversation.GetSingleConversationRecvMsgOpt(ctx, userID, conversationID)
-	if err != nil {
-		return false, err
-	}
+	//if err != nil {
+	//	return false, err
+	//}
+	return true, nil
 	switch singleOpt {
 	case constant.ReceiveMessage:
 		return true, nil
@@ -16,11 +16,6 @@ import (
 func (m *msgServer) sendMsgSuperGroupChat(ctx context.Context, req *msg.SendMsgReq) (resp *msg.SendMsgResp, err error) {
 	resp = &msg.SendMsgResp{}
 	promePkg.Inc(promePkg.WorkSuperGroupChatMsgRecvSuccessCounter)
-	// callback
-	if err = CallbackBeforeSendGroupMsg(ctx, req); err != nil && err != errs.ErrCallbackContinue {
-		return nil, err
-	}
-
 	if _, err = m.messageVerification(ctx, req); err != nil {
 		promePkg.Inc(promePkg.WorkSuperGroupChatMsgProcessFailedCounter)
 		return nil, err
@@ -63,9 +58,6 @@ func (m *msgServer) sendMsgNotification(ctx context.Context, req *msg.SendMsgReq

 func (m *msgServer) sendMsgSingleChat(ctx context.Context, req *msg.SendMsgReq) (resp *msg.SendMsgResp, err error) {
 	promePkg.Inc(promePkg.SingleChatMsgRecvSuccessCounter)
-	if err = CallbackBeforeSendSingleMsg(ctx, req); err != nil && err != errs.ErrCallbackContinue {
-		return nil, err
-	}
 	_, err = m.messageVerification(ctx, req)
 	if err != nil {
 		return nil, err
@@ -103,10 +95,6 @@ func (m *msgServer) sendMsgSingleChat(ctx context.Context, req *msg.SendMsgReq)
 func (m *msgServer) sendMsgGroupChat(ctx context.Context, req *msg.SendMsgReq) (resp *msg.SendMsgResp, err error) {
 	// callback
 	promePkg.Inc(promePkg.GroupChatMsgRecvSuccessCounter)
-	err = CallbackBeforeSendGroupMsg(ctx, req)
-	if err != nil && err != errs.ErrCallbackContinue {
-		return nil, err
-	}

 	var memberUserIDList []string
 	if memberUserIDList, err = m.messageVerification(ctx, req); err != nil {
@@ -231,79 +219,3 @@ func (m *msgServer) sendMsgGroupChat(ctx context.Context, req *msg.SendMsgReq) (
 	resp.ClientMsgID = msgToMQSingle.MsgData.ClientMsgID
 	return resp, nil
 }
-
-func (m *msgServer) SendMsg(ctx context.Context, req *msg.SendMsgReq) (resp *msg.SendMsgResp, error error) {
-	resp = &msg.SendMsgResp{}
-	flag := isMessageHasReadEnabled(req.MsgData)
-	if !flag {
-		return nil, errs.ErrMessageHasReadDisable.Wrap()
-	}
-	m.encapsulateMsgData(req.MsgData)
-	if err := CallbackMsgModify(ctx, req); err != nil && err != errs.ErrCallbackContinue {
-		return nil, err
-	}
-	switch req.MsgData.SessionType {
-	case constant.SingleChatType:
-		return m.sendMsgSingleChat(ctx, req)
-	case constant.GroupChatType:
-		return m.sendMsgGroupChat(ctx, req)
-	case constant.NotificationChatType:
-		return m.sendMsgNotification(ctx, req)
-	case constant.SuperGroupChatType:
-		return m.sendMsgSuperGroupChat(ctx, req)
-	default:
-		return nil, errs.ErrArgs.Wrap("unknown sessionType")
-	}
-}
-
-func (m *msgServer) GetMaxAndMinSeq(ctx context.Context, req *sdkws.GetMaxAndMinSeqReq) (*sdkws.GetMaxAndMinSeqResp, error) {
-	resp := new(sdkws.GetMaxAndMinSeqResp)
-	m2 := make(map[string]*sdkws.MaxAndMinSeq)
-	maxSeq, err := m.MsgDatabase.GetUserMaxSeq(ctx, req.UserID)
-	if err != nil {
-		return nil, err
-	}
-	minSeq, err := m.MsgDatabase.GetUserMinSeq(ctx, req.UserID)
-	if err != nil {
-		return nil, err
-	}
-	resp.MaxSeq = maxSeq
-	resp.MinSeq = minSeq
-	if len(req.GroupIDs) > 0 {
-		resp.GroupMaxAndMinSeq = make(map[string]*sdkws.MaxAndMinSeq)
-		for _, groupID := range req.GroupIDs {
-			maxSeq, err := m.MsgDatabase.GetGroupMaxSeq(ctx, groupID)
-			if err != nil {
-				return nil, err
-			}
-			minSeq, err := m.MsgDatabase.GetGroupMinSeq(ctx, groupID)
-			if err != nil {
-				return nil, err
-			}
-			m2[groupID] = &sdkws.MaxAndMinSeq{
-				MaxSeq: maxSeq,
-				MinSeq: minSeq,
-			}
-		}
-	}
-	return resp, nil
-}
-
-func (m *msgServer) PullMessageBySeqs(ctx context.Context, req *sdkws.PullMessageBySeqsReq) (*sdkws.PullMessageBySeqsResp, error) {
-	resp := &sdkws.PullMessageBySeqsResp{GroupMsgDataList: make(map[string]*sdkws.MsgDataList)}
-	msgs, err := m.MsgDatabase.GetMsgBySeqs(ctx, req.UserID, req.Seqs)
-	if err != nil {
-		return nil, err
-	}
-	resp.List = msgs
-	for groupID, list := range req.GroupSeqs {
-		msgs, err := m.MsgDatabase.GetSuperGroupMsgBySeqs(ctx, groupID, list.Seqs)
-		if err != nil {
-			return nil, err
-		}
-		resp.GroupMsgDataList[groupID] = &sdkws.MsgDataList{
-			MsgDataList: msgs,
-		}
-	}
-	return resp, nil
-}
@@ -1,18 +1,25 @@
 package msg

 import (
+	"context"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/cache"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/controller"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/localcache"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/tx"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/unrelation"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/prome"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/tokenverify"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/errs"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/msg"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/sdkws"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/rpcclient/check"
+	"github.com/go-redis/redis/v8"
 	"google.golang.org/grpc"
 )

+type MessageInterceptorChain []MessageInterceptorFunc
 type msgServer struct {
 	RegisterCenter    discoveryregistry.SvcDiscoveryRegistry
 	MsgDatabase       controller.MsgDatabase
@@ -24,8 +31,22 @@ type msgServer struct {
 	*localcache.GroupLocalCache
 	black         *check.BlackChecker
 	MessageLocker MessageLocker
+	Handlers      MessageInterceptorChain
 }

+func (m *msgServer) addInterceptorHandler(interceptorFunc ...MessageInterceptorFunc) {
+	m.Handlers = append(m.Handlers, interceptorFunc...)
+}
+func (m *msgServer) execInterceptorHandler(ctx context.Context, req *msg.SendMsgReq) error {
+	for _, handler := range m.Handlers {
+		msgData, err := handler(ctx, req)
+		if err != nil {
+			return err
+		}
+		req.MsgData = msgData
+	}
+	return nil
+}
 func Start(client discoveryregistry.SvcDiscoveryRegistry, server *grpc.Server) error {
 	rdb, err := cache.NewRedis()
 	if err != nil {
@@ -35,7 +56,6 @@ func Start(client discoveryregistry.SvcDiscoveryRegistry, server *grpc.Server) e
 	if err != nil {
 		return err
 	}
-
 	cacheModel := cache.NewCacheModel(rdb)
 	msgDocModel := unrelation.NewMsgMongoDriver(mongo.GetDatabase())
 	extendMsgModel := unrelation.NewExtendMsgSetMongoDriver(mongo.GetDatabase())
@@ -55,6 +75,7 @@ func Start(client discoveryregistry.SvcDiscoveryRegistry, server *grpc.Server) e
 		friend:            check.NewFriendChecker(client),
 		MessageLocker:     NewLockerMessage(cacheModel),
 	}
+	s.addInterceptorHandler(MessageHasReadEnabled, MessageModifyCallback)
 	s.initPrometheus()
 	msg.RegisterMsgServer(server, s)
 	return nil
@@ -75,3 +96,81 @@ func (m *msgServer) initPrometheus() {
 	prome.NewWorkSuperGroupChatMsgProcessSuccessCounter()
 	prome.NewWorkSuperGroupChatMsgProcessFailedCounter()
 }
+func (m *msgServer) SendMsg(ctx context.Context, req *msg.SendMsgReq) (resp *msg.SendMsgResp, error error) {
+	resp = &msg.SendMsgResp{}
+	flag := isMessageHasReadEnabled(req.MsgData)
+	if !flag {
+		return nil, errs.ErrMessageHasReadDisable.Wrap()
+	}
+	m.encapsulateMsgData(req.MsgData)
+	if err := CallbackMsgModify(ctx, req); err != nil && err != errs.ErrCallbackContinue {
+		return nil, err
+	}
+	switch req.MsgData.SessionType {
+	case constant.SingleChatType:
+		return m.sendMsgSingleChat(ctx, req)
+	case constant.GroupChatType:
+		return m.sendMsgGroupChat(ctx, req)
+	case constant.NotificationChatType:
+		return m.sendMsgNotification(ctx, req)
+	case constant.SuperGroupChatType:
+		return m.sendMsgSuperGroupChat(ctx, req)
+	default:
+		return nil, errs.ErrArgs.Wrap("unknown sessionType")
+	}
+}
+
+func (m *msgServer) GetMaxAndMinSeq(ctx context.Context, req *sdkws.GetMaxAndMinSeqReq) (*sdkws.GetMaxAndMinSeqResp, error) {
+	if err := tokenverify.CheckAccessV3(ctx, req.UserID); err != nil {
+		return nil, err
+	}
+	resp := new(sdkws.GetMaxAndMinSeqResp)
+	m2 := make(map[string]*sdkws.MaxAndMinSeq)
+	maxSeq, err := m.MsgDatabase.GetUserMaxSeq(ctx, req.UserID)
+	if err != nil && errs.Unwrap(err) != redis.Nil {
+		return nil, err
+	}
+	minSeq, err := m.MsgDatabase.GetUserMinSeq(ctx, req.UserID)
+	if err != nil && errs.Unwrap(err) != redis.Nil {
+		return nil, err
+	}
+	resp.MaxSeq = maxSeq
+	resp.MinSeq = minSeq
+	if len(req.GroupIDs) > 0 {
+		for _, groupID := range req.GroupIDs {
+			maxSeq, err := m.MsgDatabase.GetGroupMaxSeq(ctx, groupID)
+			if err != nil && errs.Unwrap(err) != redis.Nil {
+				return nil, err
+			}
+			minSeq, err := m.MsgDatabase.GetGroupMinSeq(ctx, groupID)
+			if err != nil && errs.Unwrap(err) != redis.Nil {
+				return nil, err
+			}
+			m2[groupID] = &sdkws.MaxAndMinSeq{
+				MaxSeq: maxSeq,
+				MinSeq: minSeq,
+			}
+		}
+	}
+	resp.GroupMaxAndMinSeq = m2
+	return resp, nil
+}
+
+func (m *msgServer) PullMessageBySeqs(ctx context.Context, req *sdkws.PullMessageBySeqsReq) (*sdkws.PullMessageBySeqsResp, error) {
+	resp := &sdkws.PullMessageBySeqsResp{GroupMsgDataList: make(map[string]*sdkws.MsgDataList)}
+	msgs, err := m.MsgDatabase.GetMsgBySeqs(ctx, req.UserID, req.Seqs)
+	if err != nil {
+		return nil, err
+	}
+	resp.List = msgs
+	for groupID, list := range req.GroupSeqs {
+		msgs, err := m.MsgDatabase.GetSuperGroupMsgBySeqs(ctx, groupID, list.Seqs)
+		if err != nil {
+			return nil, err
+		}
+		resp.GroupMsgDataList[groupID] = &sdkws.MsgDataList{
+			MsgDataList: msgs,
+		}
+	}
+	return resp, nil
+}
@@ -8,8 +8,8 @@ import (
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/controller"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/relation"
 	tablerelation "github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/table/relation"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/mcontext"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/tokenverify"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/tracelog"
 	registry "github.com/OpenIMSDK/Open-IM-Server/pkg/discoveryregistry"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/errs"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/sdkws"
@@ -92,10 +92,10 @@ func (s *userServer) UpdateUserInfo(ctx context.Context, req *pbuser.UpdateUserI
 	}
 	go func() {
 		for _, v := range friends {
-			s.notification.FriendInfoUpdatedNotification(ctx, req.UserInfo.UserID, v, tracelog.GetOpUserID(ctx))
+			s.notification.FriendInfoUpdatedNotification(ctx, req.UserInfo.UserID, v, mcontext.GetOpUserID(ctx))
 		}
 	}()
-	s.notification.UserInfoUpdatedNotification(ctx, tracelog.GetOpUserID(ctx), req.UserInfo.UserID)
+	s.notification.UserInfoUpdatedNotification(ctx, mcontext.GetOpUserID(ctx), req.UserInfo.UserID)
 	return resp, nil
 }

@@ -11,7 +11,7 @@ import (
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/relation"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/unrelation"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/log"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/tracelog"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/mcontext"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
 	"github.com/go-redis/redis/v8"
 	"math"
@@ -59,7 +59,7 @@ func (c *MsgTool) getCronTaskOperationID() string {

 func (c *MsgTool) AllUserClearMsgAndFixSeq() {
 	operationID := "AllUserAndGroupClearMsgAndFixSeq"
-	ctx := tracelog.NewCtx(utils.GetSelfFuncName())
+	ctx := mcontext.NewCtx(utils.GetSelfFuncName())
 	log.NewInfo(operationID, "============================ start del cron task ============================")
 	var err error
 	userIDList, err := c.userDatabase.GetAllUserID(ctx)
@@ -81,7 +81,7 @@ func (c *MsgTool) AllUserClearMsgAndFixSeq() {
 func (c *MsgTool) ClearUsersMsg(ctx context.Context, userIDs []string) {
 	for _, userID := range userIDs {
 		if err := c.msgDatabase.DeleteUserMsgsAndSetMinSeq(ctx, userID, int64(config.Config.Mongo.DBRetainChatRecords*24*60*60)); err != nil {
-			log.NewError(tracelog.GetOperationID(ctx), utils.GetSelfFuncName(), err.Error(), userID)
+			log.NewError(mcontext.GetOperationID(ctx), utils.GetSelfFuncName(), err.Error(), userID)
 		}
 		maxSeqCache, maxSeqMongo, err := c.GetAndFixUserSeqs(ctx, userID)
 		if err != nil {
@@ -95,14 +95,14 @@ func (c *MsgTool) ClearSuperGroupMsg(ctx context.Context, superGroupIDs []string
 	for _, groupID := range superGroupIDs {
 		userIDs, err := c.groupDatabase.FindGroupMemberUserID(ctx, groupID)
 		if err != nil {
-			log.NewError(tracelog.GetOperationID(ctx), utils.GetSelfFuncName(), "FindGroupMemberUserID", err.Error(), groupID)
+			log.NewError(mcontext.GetOperationID(ctx), utils.GetSelfFuncName(), "FindGroupMemberUserID", err.Error(), groupID)
 			continue
 		}
 		if err := c.msgDatabase.DeleteUserSuperGroupMsgsAndSetMinSeq(ctx, groupID, userIDs, int64(config.Config.Mongo.DBRetainChatRecords*24*60*60)); err != nil {
-			log.NewError(tracelog.GetOperationID(ctx), utils.GetSelfFuncName(), err.Error(), "DeleteUserSuperGroupMsgsAndSetMinSeq failed", groupID, userIDs, config.Config.Mongo.DBRetainChatRecords)
+			log.NewError(mcontext.GetOperationID(ctx), utils.GetSelfFuncName(), err.Error(), "DeleteUserSuperGroupMsgsAndSetMinSeq failed", groupID, userIDs, config.Config.Mongo.DBRetainChatRecords)
 		}
 		if err := c.fixGroupSeq(ctx, groupID, userIDs); err != nil {
-			log.NewError(tracelog.GetOperationID(ctx), utils.GetSelfFuncName(), err.Error(), groupID, userIDs)
+			log.NewError(mcontext.GetOperationID(ctx), utils.GetSelfFuncName(), err.Error(), groupID, userIDs)
 		}
 	}
 }
@@ -129,7 +129,7 @@ func (c *MsgTool) fixGroupSeq(ctx context.Context, groupID string, userIDs []str
 		}
 	}
 	if err := c.CheckMaxSeqWithMongo(ctx, groupID, maxSeqCache, maxSeqMongo, constant.WriteDiffusion); err != nil {
-		log.NewWarn(tracelog.GetOperationID(ctx), "cache max seq and mongo max seq is diff > 10", groupID, maxSeqCache, maxSeqMongo, constant.WriteDiffusion)
+		log.NewWarn(mcontext.GetOperationID(ctx), "cache max seq and mongo max seq is diff > 10", groupID, maxSeqCache, maxSeqMongo, constant.WriteDiffusion)
 	}
 	return nil
 }
@@ -138,16 +138,16 @@ func (c *MsgTool) GetAndFixUserSeqs(ctx context.Context, userID string) (maxSeqC
 	minSeqMongo, maxSeqMongo, minSeqCache, maxSeqCache, err := c.msgDatabase.GetUserMinMaxSeqInMongoAndCache(ctx, userID)
 	if err != nil {
 		if err != unrelation.ErrMsgNotFound {
-			log.NewError(tracelog.GetOperationID(ctx), utils.GetSelfFuncName(), err.Error(), "GetUserMinMaxSeqInMongoAndCache failed", userID)
+			log.NewError(mcontext.GetOperationID(ctx), utils.GetSelfFuncName(), err.Error(), "GetUserMinMaxSeqInMongoAndCache failed", userID)
 		}
 		return 0, 0, err
 	}
-	log.NewDebug(tracelog.GetOperationID(ctx), userID, minSeqMongo, maxSeqMongo, minSeqCache, maxSeqCache)
+	log.NewDebug(mcontext.GetOperationID(ctx), userID, minSeqMongo, maxSeqMongo, minSeqCache, maxSeqCache)
 	if minSeqCache > maxSeqCache {
 		if err := c.msgDatabase.SetUserMinSeq(ctx, userID, maxSeqCache); err != nil {
-			log.NewError(tracelog.GetOperationID(ctx), "SetUserMinSeq failed", userID, minSeqCache, maxSeqCache)
+			log.NewError(mcontext.GetOperationID(ctx), "SetUserMinSeq failed", userID, minSeqCache, maxSeqCache)
 		} else {
-			log.NewWarn(tracelog.GetOperationID(ctx), "SetUserMinSeq success", userID, minSeqCache, maxSeqCache)
+			log.NewWarn(mcontext.GetOperationID(ctx), "SetUserMinSeq success", userID, minSeqCache, maxSeqCache)
 		}
 	}
 	return maxSeqCache, maxSeqMongo, nil
@@ -156,14 +156,14 @@ func (c *MsgTool) GetAndFixUserSeqs(ctx context.Context, userID string) (maxSeqC
 func (c *MsgTool) GetAndFixGroupUserSeq(ctx context.Context, userID string, groupID string, maxSeqCache int64) (minSeqCache int64, err error) {
 	minSeqCache, err = c.msgDatabase.GetGroupUserMinSeq(ctx, groupID, userID)
 	if err != nil {
-		log.NewError(tracelog.GetOperationID(ctx), "GetGroupUserMinSeq failed", groupID, userID)
+		log.NewError(mcontext.GetOperationID(ctx), "GetGroupUserMinSeq failed", groupID, userID)
 		return 0, err
 	}
 	if minSeqCache > maxSeqCache {
 		if err := c.msgDatabase.SetGroupUserMinSeq(ctx, groupID, userID, maxSeqCache); err != nil {
-			log.NewError(tracelog.GetOperationID(ctx), "SetGroupUserMinSeq failed", userID, minSeqCache, maxSeqCache)
+			log.NewError(mcontext.GetOperationID(ctx), "SetGroupUserMinSeq failed", userID, minSeqCache, maxSeqCache)
 		} else {
-			log.NewWarn(tracelog.GetOperationID(ctx), "SetGroupUserMinSeq success", userID, minSeqCache, maxSeqCache)
+			log.NewWarn(mcontext.GetOperationID(ctx), "SetGroupUserMinSeq success", userID, minSeqCache, maxSeqCache)
 		}
 	}
 	return minSeqCache, nil
@@ -4,7 +4,7 @@ import (
 	"context"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/constant"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/db/cache"
-	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/tracelog"
+	"github.com/OpenIMSDK/Open-IM-Server/pkg/common/mcontext"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/proto/sdkws"
 	"github.com/OpenIMSDK/Open-IM-Server/pkg/utils"
 	"github.com/golang/protobuf/proto"
@@ -66,7 +66,7 @@ func TestDeleteMongoMsgAndResetRedisSeq(t *testing.T) {
 	mongoClient := mgo.GetDatabase().Collection(unRelationTb.MsgDocModel{}.TableName())

 	ctx := context.Background()
-	tracelog.SetOperationID(ctx, operationID)
+	ctx = mcontext.SetOperationID(ctx, operationID)
 	testUID1 := "test_del_id1"
 	_, err = mongoClient.DeleteOne(ctx, bson.M{"uid": testUID1 + ":" + strconv.Itoa(0)})
 	if err != nil {