errcode

internal/api/group/group.go

@@ -996,15 +996,15 @@ func MuteGroupMember(c *gin.Context) {
 // @Failure 400 {object} api.Swagger400Resp "errCode为400 一般为参数输入错误, token未带上等"
 // @Router /group/cancel_mute_group_member [post]
 func CancelMuteGroupMember(c *gin.Context) {
-	nCtx := trace_log.NewCtx(c, utils.GetSelfFuncName())
+	nCtx := tracelog.NewCtx(c, utils.GetSelfFuncName())
 	defer log.ShowLog(c)
 
 	params := api.CancelMuteGroupMemberReq{}
 	if err := c.BindJSON(&params); err != nil {
-		trace_log.WriteErrorResponse(nCtx, "BindJSON", err)
+		tracelog.WriteErrorResponse(nCtx, "BindJSON", err)
 		return
 	}
-	trace_log.SetCtxInfo(nCtx, "BindJSON", nil, "params", params)
+	tracelog.SetCtxInfo(nCtx, "BindJSON", nil, "params", params)
 	req := &rpc.CancelMuteGroupMemberReq{}
 	utils.CopyStructFields(req, &params)
 
@@ -1013,18 +1013,18 @@ func CancelMuteGroupMember(c *gin.Context) {
 	//	trace_log.WriteErrorResponse(nCtx, "ParseUserIDFromToken", err)
 	//	return
 	//}
-	trace_log.SetCtxInfo(nCtx, "ParseUserIDFromToken", nil, "token", c.Request.Header.Get("token"), "OpUserID", req.OpUserID)
+	tracelog.SetCtxInfo(nCtx, "ParseUserIDFromToken", nil, "token", c.Request.Header.Get("token"), "OpUserID", req.OpUserID)
 
 	etcdConn := getcdv3.GetDefaultConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","), config.Config.RpcRegisterName.OpenImGroupName, req.OperationID)
 
 	client := rpc.NewGroupClient(etcdConn)
 	reply, err := client.CancelMuteGroupMember(nCtx, req)
 	if err != nil {
-		trace_log.WriteErrorResponse(nCtx, "CancelMuteGroupMember", err)
+		tracelog.WriteErrorResponse(nCtx, "CancelMuteGroupMember", err)
 		return
 	}
 
-	trace_log.SetCtxInfo(nCtx, "CancelMuteGroupMember", nil, "req", req.String(), "resp", reply.String())
+	tracelog.SetCtxInfo(nCtx, "CancelMuteGroupMember", nil, "req", req.String(), "resp", reply.String())
 	resp := api.CancelMuteGroupMemberResp{CommResp: api.CommResp{ErrCode: reply.CommonResp.ErrCode, ErrMsg: reply.CommonResp.ErrMsg}}
 	c.JSON(http.StatusOK, resp)
 }

internal/api_to_rpc/api.go

@@ -16,16 +16,16 @@ func ApiToRpc(c *gin.Context, apiReq, apiResp interface{}, rpcName string, rpcCl
 		rpcName = utils2.GetFuncName(1)
 	}
 	logFuncName := fmt.Sprintf("[ApiToRpc: %s]%s", utils2.GetFuncName(1), rpcFuncName)
-	ctx := trace_log.NewCtx1(c, rpcFuncName)
+	ctx := tracelog.NewCtx1(c, rpcFuncName)
 	defer log.ShowLog(ctx)
 	if err := c.BindJSON(apiReq); err != nil {
-		trace_log.WriteErrorResponse(ctx, "BindJSON", err)
+		tracelog.WriteErrorResponse(ctx, "BindJSON", err)
 		return
 	}
-	trace_log.SetCtxInfo(ctx, logFuncName, nil, "apiReq", apiReq)
+	tracelog.SetCtxInfo(ctx, logFuncName, nil, "apiReq", apiReq)
 	etcdConn, err := getcdv3.GetConn(ctx, rpcName)
 	if err != nil {
-		trace_log.WriteErrorResponse(ctx, "GetConn", err)
+		tracelog.WriteErrorResponse(ctx, "GetConn", err)
 		return
 	}
 	rpcClient := reflect.ValueOf(rpcClientFunc).Call([]reflect.Value{
@@ -33,22 +33,22 @@ func ApiToRpc(c *gin.Context, apiReq, apiResp interface{}, rpcName string, rpcCl
 	})[0].MethodByName(rpcFuncName) // rpcClient func
 	rpcReqPtr := reflect.New(rpcClient.Type().In(1).Elem()) // *req
 	CopyAny(apiReq, rpcReqPtr.Interface())
-	trace_log.SetCtxInfo(ctx, logFuncName, nil, "opUserID", c.GetString("opUserID"), "callRpcReq", rpcString(rpcReqPtr.Elem().Interface()))
+	tracelog.SetCtxInfo(ctx, logFuncName, nil, "opUserID", c.GetString("opUserID"), "callRpcReq", rpcString(rpcReqPtr.Elem().Interface()))
 	respArr := rpcClient.Call([]reflect.Value{
 		reflect.ValueOf(context.Context(c)), // context.Context (ctx operationID. opUserID)
 		rpcReqPtr,                           // rpcClient apiReq
 	}) // respArr => (apiResp, error)
 	if !respArr[1].IsNil() { // rpcClient err != nil
 		err := respArr[1].Interface().(error)
-		trace_log.WriteErrorResponse(ctx, rpcFuncName, err, "callRpcResp", "error")
+		tracelog.WriteErrorResponse(ctx, rpcFuncName, err, "callRpcResp", "error")
 		return
 	}
 	rpcResp := respArr[0].Elem()
-	trace_log.SetCtxInfo(ctx, rpcFuncName, nil, "callRpcResp", rpcString(rpcResp.Interface()))
+	tracelog.SetCtxInfo(ctx, rpcFuncName, nil, "callRpcResp", rpcString(rpcResp.Interface()))
 	if apiResp != nil {
 		CopyAny(rpcResp.Interface(), apiResp)
 	}
-	trace_log.SetSuccess(ctx, rpcFuncName, apiResp)
+	tracelog.SetSuccess(ctx, rpcFuncName, apiResp)
 }
 
 func rpcString(v interface{}) string {

internal/cron_task/cron_task.go

@@ -18,7 +18,7 @@ const cronTaskOperationID = "cronTaskOperationID-"
 func StartCronTask(userID, workingGroupID string) {
 	log.NewPrivateLog("cron")
 	log.NewInfo(utils.OperationIDGenerator(), "start cron task", "cron config", config.Config.Mongo.ChatRecordsClearTime)
-	fmt.Println("cron config", config.Config.Mongo.ChatRecordsClearTime)
+	fmt.Println("cron task start, config", config.Config.Mongo.ChatRecordsClearTime)
 	if userID != "" {
 		operationID := getCronTaskOperationID()
 		StartClearMsg(operationID, []string{userID})

internal/cron_task/test/main.go

@@ -1,6 +0,0 @@
-package main
-
-//
-//func main() {
-//	db.DB.BatchInsertChat()
-//}

internal/rpc/admin_cms/admin_cms.go

@@ -3,9 +3,11 @@ package admin_cms
 import (
 	"Open_IM/pkg/common/config"
 	"Open_IM/pkg/common/constant"
+	"Open_IM/pkg/common/db/controller"
 	"Open_IM/pkg/common/log"
 	promePkg "Open_IM/pkg/common/prometheus"
 	"Open_IM/pkg/common/token_verify"
+	"Open_IM/pkg/common/tracelog"
 	"Open_IM/pkg/getcdv3"
 	pbAdminCMS "Open_IM/pkg/proto/admin_cms"
 	server_api_params "Open_IM/pkg/proto/sdk_ws"
@@ -26,10 +28,13 @@ import (
 )
 
 type adminCMSServer struct {
-	rpcPort         int
+	rpcPort           int
-	rpcRegisterName string
+	rpcRegisterName   string
-	etcdSchema      string
+	etcdSchema        string
-	etcdAddr        []string
+	etcdAddr          []string
+	adminCMSInterface controller.AdminCMSInterface
+	groupInterface    controller.GroupInterface
+	userInterface     controller.UserInterface
 }
 
 func NewAdminCMSServer(port int) *adminCMSServer {
@@ -82,7 +87,7 @@ func (s *adminCMSServer) Run() {
 		}
 	}
 	log.NewInfo("", "rpcRegisterIP ", rpcRegisterIP)
-	err = getcdv3.RegisterEtcd(s.etcdSchema, strings.Join(s.etcdAddr, ","), rpcRegisterIP, s.rpcPort, s.rpcRegisterName, 10)
+	err = getcdv3.RegisterEtcd(s.etcdSchema, strings.Join(s.etcdAddr, ","), rpcRegisterIP, s.rpcPort, s.rpcRegisterName, 10, "")
 	if err != nil {
 		log.NewError("0", "RegisterEtcd failed ", err.Error())
 		panic(utils.Wrap(err, "register admin module  rpc to etcd err"))
@@ -95,35 +100,27 @@ func (s *adminCMSServer) Run() {
 	log.NewInfo("0", "message cms rpc success")
 }
 
-func (s *adminCMSServer) AdminLogin(_ context.Context, req *pbAdminCMS.AdminLoginReq) (*pbAdminCMS.AdminLoginResp, error) {
+func (s *adminCMSServer) AdminLogin(ctx context.Context, req *pbAdminCMS.AdminLoginReq) (*pbAdminCMS.AdminLoginResp, error) {
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
+	resp := &pbAdminCMS.AdminLoginResp{}
-	resp := &pbAdminCMS.AdminLoginResp{CommonResp: &pbAdminCMS.CommonResp{}}
 	for i, adminID := range config.Config.Manager.AppManagerUid {
 		if adminID == req.AdminID && config.Config.Manager.Secrets[i] == req.Secret {
-			token, expTime, err := token_verify.CreateToken(adminID, constant.SingleChatType)
+			token, expTime, err := token_verify.CreateToken(adminID, constant.LinuxPlatformID)
 			if err != nil {
-				log.NewError(req.OperationID, utils.GetSelfFuncName(), "generate token failed", "adminID: ", adminID, err.Error())
+				log.NewError(tracelog.GetOperationID(ctx), utils.GetSelfFuncName(), "generate token failed", "adminID: ", adminID, err.Error())
-				resp.CommonResp.ErrCode = constant.ErrTokenUnknown.ErrCode
+				return nil, err
-				resp.CommonResp.ErrMsg = err.Error()
-				return resp, nil
 			}
-			log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "generate token success", "token: ", token, "expTime:", expTime)
+			log.NewInfo(tracelog.GetOperationID(ctx), utils.GetSelfFuncName(), "generate token success", "token: ", token, "expTime:", expTime)
 			resp.Token = token
 			break
 		}
 	}
 	if resp.Token == "" {
 		log.NewError(req.OperationID, utils.GetSelfFuncName(), "failed")
-		resp.CommonResp.ErrCode = constant.ErrTokenUnknown.ErrCode
+		return nil, constant.ErrInternalServer
-		resp.CommonResp.ErrMsg = constant.ErrTokenMalformed.ErrMsg
-		return resp, nil
 	}
-	admin, err := imdb.GetUserByUserID(req.AdminID)
+	admin, err := s.userInterface.Take(ctx, req.AdminID)
 	if err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), "failed", req.AdminID, err.Error())
+		return nil, err
-		resp.CommonResp.ErrCode = constant.ErrTokenUnknown.ErrCode
-		resp.CommonResp.ErrMsg = err.Error()
-		return resp, nil
 	}
 	resp.UserName = admin.Nickname
 	resp.FaceURL = admin.FaceURL
@@ -149,67 +146,6 @@ func (s *adminCMSServer) GetUserToken(_ context.Context, req *pbAdminCMS.GetUser
 	return resp, nil
 }
 
-func (s *adminCMSServer) AddUserRegisterAddFriendIDList(_ context.Context, req *pbAdminCMS.AddUserRegisterAddFriendIDListReq) (*pbAdminCMS.AddUserRegisterAddFriendIDListResp, error) {
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
-	resp := &pbAdminCMS.AddUserRegisterAddFriendIDListResp{CommonResp: &pbAdminCMS.CommonResp{}}
-	if err := imdb.AddUserRegisterAddFriendIDList(req.UserIDList...); err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), req.UserIDList)
-		resp.CommonResp.ErrCode = constant.ErrDB.ErrCode
-		resp.CommonResp.ErrMsg = err.Error()
-		return resp, nil
-	}
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", req.String())
-	return resp, nil
-}
-
-func (s *adminCMSServer) ReduceUserRegisterAddFriendIDList(_ context.Context, req *pbAdminCMS.ReduceUserRegisterAddFriendIDListReq) (*pbAdminCMS.ReduceUserRegisterAddFriendIDListResp, error) {
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
-	resp := &pbAdminCMS.ReduceUserRegisterAddFriendIDListResp{CommonResp: &pbAdminCMS.CommonResp{}}
-	if req.Operation == 0 {
-		if err := imdb.ReduceUserRegisterAddFriendIDList(req.UserIDList...); err != nil {
-			log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), req.UserIDList)
-			resp.CommonResp.ErrCode = constant.ErrDB.ErrCode
-			resp.CommonResp.ErrMsg = err.Error()
-			return resp, nil
-		}
-	} else {
-		if err := imdb.DeleteAllRegisterAddFriendIDList(); err != nil {
-			log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error(), req.UserIDList)
-			resp.CommonResp.ErrCode = constant.ErrDB.ErrCode
-			resp.CommonResp.ErrMsg = err.Error()
-			return resp, nil
-		}
-	}
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", req.String())
-	return resp, nil
-}
-
-func (s *adminCMSServer) GetUserRegisterAddFriendIDList(_ context.Context, req *pbAdminCMS.GetUserRegisterAddFriendIDListReq) (*pbAdminCMS.GetUserRegisterAddFriendIDListResp, error) {
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", req.String())
-	resp := &pbAdminCMS.GetUserRegisterAddFriendIDListResp{CommonResp: &pbAdminCMS.CommonResp{}}
-	userIDList, err := imdb.GetRegisterAddFriendList(req.Pagination.ShowNumber, req.Pagination.PageNumber)
-	if err != nil {
-		log.NewError(req.OperationID, utils.GetSelfFuncName(), err.Error())
-		resp.CommonResp.ErrCode = constant.ErrDB.ErrCode
-		resp.CommonResp.ErrMsg = err.Error()
-		return resp, nil
-	}
-	userList, err := imdb.GetUsersByUserIDList(userIDList)
-	if err != nil {
-		resp.CommonResp.ErrCode = constant.ErrDB.ErrCode
-		resp.CommonResp.ErrMsg = err.Error()
-		return resp, nil
-	}
-	log.NewDebug(req.OperationID, utils.GetSelfFuncName(), userList, userIDList)
-	resp.Pagination = &server_api_params.ResponsePagination{
-		CurrentPage: req.Pagination.PageNumber,
-		ShowNumber:  req.Pagination.ShowNumber,
-	}
-	utils.CopyStructFields(&resp.UserInfoList, userList)
-	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", req.String())
-	return resp, nil
-}
-
 func (s *adminCMSServer) GetChatLogs(_ context.Context, req *pbAdminCMS.GetChatLogsReq) (*pbAdminCMS.GetChatLogsResp, error) {
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "GetChatLogs", req.String())
 	resp := &pbAdminCMS.GetChatLogsResp{CommonResp: &pbAdminCMS.CommonResp{}, Pagination: &server_api_params.ResponsePagination{}}
@@ -302,17 +238,17 @@ func (s *adminCMSServer) GetActiveGroup(_ context.Context, req *pbAdminCMS.GetAc
 	resp := &pbAdminCMS.GetActiveGroupResp{}
 	fromTime, toTime, err := ParseTimeFromTo(req.StatisticsReq.From, req.StatisticsReq.To)
 	if err != nil {
-		return resp, err
+		return nil, err
 	}
-	activeGroups, err := imdb.GetActiveGroups(fromTime, toTime, 12)
+	activeGroups, err := s.adminCMSInterface.GetActiveGroups(fromTime, toTime, 12)
 	if err != nil {
-		return resp, err
+		return nil, err
 	}
 	for _, activeGroup := range activeGroups {
 		resp.Groups = append(resp.Groups,
 			&pbAdminCMS.GroupResp{
 				GroupName:  activeGroup.Name,
-				GroupID:    activeGroup.Id,
+				GroupID:    activeGroup.ID,
 				MessageNum: int32(activeGroup.MessageNum),
 			})
 	}
@@ -684,43 +620,3 @@ func (s *adminCMSServer) GetUserIDByEmailAndPhoneNumber(_ context.Context, req *
 	log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "resp: ", resp.String())
 	return resp, nil
 }
-
-func (s *adminCMSServer) GenerateInvitationCode(_ context.Context, req *pbAdminCMS.GenerateInvitationCodeReq) (*pbAdminCMS.GenerateInvitationCodeResp, error) {
-	return nil, nil
-}
-
-func (s *adminCMSServer) GetInvitationCodes(_ context.Context, req *pbAdminCMS.GetInvitationCodesReq) (*pbAdminCMS.GetInvitationCodesResp, error) {
-	return nil, nil
-}
-
-func (s *adminCMSServer) QueryIPRegister(_ context.Context, req *pbAdminCMS.QueryIPRegisterReq) (*pbAdminCMS.QueryIPRegisterResp, error) {
-	return nil, nil
-}
-
-func (s *adminCMSServer) AddIPLimit(_ context.Context, req *pbAdminCMS.AddIPLimitReq) (*pbAdminCMS.AddIPLimitResp, error) {
-	return nil, nil
-}
-
-func (s *adminCMSServer) RemoveIPLimit(_ context.Context, req *pbAdminCMS.RemoveIPLimitReq) (*pbAdminCMS.RemoveIPLimitResp, error) {
-	return nil, nil
-}
-
-func (s *adminCMSServer) QueryUserIDIPLimitLogin(_ context.Context, req *pbAdminCMS.QueryUserIDIPLimitLoginReq) (*pbAdminCMS.QueryUserIDIPLimitLoginResp, error) {
-	return nil, nil
-}
-
-func (s *adminCMSServer) AddUserIPLimitLogin(_ context.Context, req *pbAdminCMS.AddUserIPLimitLoginReq) (*pbAdminCMS.AddUserIPLimitLoginResp, error) {
-	return nil, nil
-}
-
-func (s *adminCMSServer) RemoveUserIPLimit(_ context.Context, req *pbAdminCMS.RemoveUserIPLimitReq) (*pbAdminCMS.RemoveUserIPLimitResp, error) {
-	return nil, nil
-}
-
-func (s *adminCMSServer) GetClientInitConfig(_ context.Context, req *pbAdminCMS.GetClientInitConfigReq) (*pbAdminCMS.GetClientInitConfigResp, error) {
-	return nil, nil
-}
-
-func (s *adminCMSServer) SetClientInitConfig(_ context.Context, req *pbAdminCMS.SetClientInitConfigReq) (*pbAdminCMS.SetClientInitConfigResp, error) {
-	return nil, nil
-}

internal/rpc/friend/friend.go

@@ -247,7 +247,7 @@ func (s *friendServer) AddFriendResponse(ctx context.Context, req *pbFriend.AddF
 	} else if req.HandleResult == constant.FriendResponseRefuse {
 		chat.FriendApplicationRejectedNotification(req)
 	} else {
-		trace_log.SetCtxInfo(ctx, utils.GetSelfFuncName(), nil, "handleResult", req.HandleResult)
+		tracelog.SetCtxInfo(ctx, utils.GetSelfFuncName(), nil, "handleResult", req.HandleResult)
 	}
 	return resp, nil
 }

internal/rpc/group/callback.go

@@ -16,7 +16,7 @@ import (
 
 func callbackBeforeCreateGroup(ctx context.Context, req *pbGroup.CreateGroupReq) (err error) {
 	defer func() {
-		trace_log.SetCtxInfo(ctx, utils.GetFuncName(1), err, "req", req)
+		tracelog.SetCtxInfo(ctx, utils.GetFuncName(1), err, "req", req)
 	}()
 	if !config.Config.Callback.CallbackBeforeCreateGroup.Enable {
 		return nil
@@ -79,7 +79,7 @@ func callbackBeforeCreateGroup(ctx context.Context, req *pbGroup.CreateGroupReq)
 
 func CallbackBeforeMemberJoinGroup(ctx context.Context, operationID string, groupMember *relation.GroupMember, groupEx string) (err error) {
 	defer func() {
-		trace_log.SetCtxInfo(ctx, utils.GetFuncName(1), err, "groupMember", *groupMember, "groupEx", groupEx)
+		tracelog.SetCtxInfo(ctx, utils.GetFuncName(1), err, "groupMember", *groupMember, "groupEx", groupEx)
 	}()
 	callbackResp := cbApi.CommonCallbackResp{OperationID: operationID}
 	if !config.Config.Callback.CallbackBeforeMemberJoinGroup.Enable {
@@ -121,7 +121,7 @@ func CallbackBeforeMemberJoinGroup(ctx context.Context, operationID string, grou
 
 func CallbackBeforeSetGroupMemberInfo(ctx context.Context, req *pbGroup.SetGroupMemberInfoReq) (err error) {
 	defer func() {
-		trace_log.SetCtxInfo(ctx, utils.GetFuncName(1), err, "req", *req)
+		tracelog.SetCtxInfo(ctx, utils.GetFuncName(1), err, "req", *req)
 	}()
 	callbackResp := cbApi.CommonCallbackResp{OperationID: req.OperationID}
 	if !config.Config.Callback.CallbackBeforeSetGroupMemberInfo.Enable {

internal/rpc/group/group.go

@@ -15,6 +15,7 @@ import (
 	"Open_IM/pkg/common/token_verify"
 	"Open_IM/pkg/common/tools"
 	"Open_IM/pkg/common/trace_log"
+	"Open_IM/pkg/common/tracelog"
 
 	cp "Open_IM/internal/utils"
 	"Open_IM/pkg/getcdv3"
@@ -319,14 +320,14 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
 			resultNode.Result = 0
 			toUserInfo, err := relation.GetUserByUserID(v)
 			if err != nil {
-				trace_log.SetCtxInfo(ctx, "GetUserByUserID", err, "userID", v)
+				tracelog.SetCtxInfo(ctx, "GetUserByUserID", err, "userID", v)
 				resultNode.Result = -1
 				resp.Id2ResultList = append(resp.Id2ResultList, &resultNode)
 				continue
 			}
 
 			if relation.IsExistGroupMember(req.GroupID, v) {
-				trace_log.SetCtxInfo(ctx, "IsExistGroupMember", err, "groupID", req.GroupID, "userID", v)
+				tracelog.SetCtxInfo(ctx, "IsExistGroupMember", err, "groupID", req.GroupID, "userID", v)
 				resultNode.Result = -1
 				resp.Id2ResultList = append(resp.Id2ResultList, &resultNode)
 				continue
@@ -343,7 +344,7 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
 			}
 			err = relation.InsertIntoGroupMember(toInsertInfo)
 			if err != nil {
-				trace_log.SetCtxInfo(ctx, "InsertIntoGroupMember", err, "args", toInsertInfo)
+				tracelog.SetCtxInfo(ctx, "InsertIntoGroupMember", err, "args", toInsertInfo)
 				resultNode.Result = -1
 				resp.Id2ResultList = append(resp.Id2ResultList, &resultNode)
 				continue
@@ -351,7 +352,7 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
 			okUserIDList = append(okUserIDList, v)
 			err = db.DB.AddGroupMember(req.GroupID, toUserInfo.UserID)
 			if err != nil {
-				trace_log.SetCtxInfo(ctx, "AddGroupMember", err, "groupID", req.GroupID, "userID", toUserInfo.UserID)
+				tracelog.SetCtxInfo(ctx, "AddGroupMember", err, "groupID", req.GroupID, "userID", toUserInfo.UserID)
 			}
 			resp.Id2ResultList = append(resp.Id2ResultList, &resultNode)
 		}
@@ -367,7 +368,7 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
 	} else {
 		for _, userID := range req.InvitedUserIDList {
 			if err := rocksCache.DelJoinedSuperGroupIDListFromCache(ctx, userID); err != nil {
-				trace_log.SetCtxInfo(ctx, "DelJoinedSuperGroupIDListFromCache", err, "userID", userID)
+				tracelog.SetCtxInfo(ctx, "DelJoinedSuperGroupIDListFromCache", err, "userID", userID)
 			}
 		}
 		for _, v := range req.InvitedUserIDList {
@@ -480,23 +481,23 @@ func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGrou
 			kickedInfo, err := rocksCache.GetGroupMemberInfoFromCache(ctx, req.GroupID, v)
 			if err != nil {
 				resp.Id2ResultList = append(resp.Id2ResultList, &pbGroup.Id2Result{UserID: v, Result: -1})
-				trace_log.SetCtxInfo(ctx, "GetGroupMemberInfoFromCache", err, "groupID", req.GroupID, "userID", v)
+				tracelog.SetCtxInfo(ctx, "GetGroupMemberInfoFromCache", err, "groupID", req.GroupID, "userID", v)
 				continue
 			}
 
 			if kickedInfo.RoleLevel == constant.GroupAdmin && opFlag == 3 {
 				resp.Id2ResultList = append(resp.Id2ResultList, &pbGroup.Id2Result{UserID: v, Result: -1})
-				trace_log.SetCtxInfo(ctx, "", nil, "msg", "is constant.GroupAdmin, can't kicked", "groupID", req.GroupID, "userID", v)
+				tracelog.SetCtxInfo(ctx, "", nil, "msg", "is constant.GroupAdmin, can't kicked", "groupID", req.GroupID, "userID", v)
 				continue
 			}
 			if kickedInfo.RoleLevel == constant.GroupOwner && opFlag != 1 {
 				resp.Id2ResultList = append(resp.Id2ResultList, &pbGroup.Id2Result{UserID: v, Result: -1})
-				trace_log.SetCtxInfo(ctx, "", nil, "msg", "is constant.GroupOwner, can't kicked", "groupID", req.GroupID, "userID", v)
+				tracelog.SetCtxInfo(ctx, "", nil, "msg", "is constant.GroupOwner, can't kicked", "groupID", req.GroupID, "userID", v)
 				continue
 			}
 
 			err = relation.DeleteGroupMemberByGroupIDAndUserID(req.GroupID, v)
-			trace_log.SetCtxInfo(ctx, "RemoveGroupMember", err, "groupID", req.GroupID, "userID", v)
+			tracelog.SetCtxInfo(ctx, "RemoveGroupMember", err, "groupID", req.GroupID, "userID", v)
 			if err != nil {
 				log.NewError(tools.OperationID(ctx), "RemoveGroupMember failed ", err.Error(), req.GroupID, v)
 				resp.Id2ResultList = append(resp.Id2ResultList, &pbGroup.Id2Result{UserID: v, Result: -1})
@@ -521,7 +522,7 @@ func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGrou
 			}
 			client := pbUser.NewUserClient(etcdConn)
 			respPb, err := client.SetConversation(context.Background(), &reqPb)
-			trace_log.SetCtxInfo(ctx, "SetConversation", err, "req", &reqPb, "resp", respPb)
+			tracelog.SetCtxInfo(ctx, "SetConversation", err, "req", &reqPb, "resp", respPb)
 		}
 	} else {
 		okUserIDList = req.KickedUserIDList
@@ -533,14 +534,14 @@ func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGrou
 	if groupInfo.GroupType != constant.SuperGroup {
 		for _, userID := range okUserIDList {
 			if err := rocksCache.DelGroupMemberInfoFromCache(ctx, req.GroupID, userID); err != nil {
-				trace_log.SetCtxInfo(ctx, "DelGroupMemberInfoFromCache", err, "groupID", req.GroupID, "userID", userID)
+				tracelog.SetCtxInfo(ctx, "DelGroupMemberInfoFromCache", err, "groupID", req.GroupID, "userID", userID)
 			}
 		}
 		chat.MemberKickedNotification(req, okUserIDList)
 	} else {
 		for _, userID := range okUserIDList {
 			if err = rocksCache.DelJoinedSuperGroupIDListFromCache(ctx, userID); err != nil {
-				trace_log.SetCtxInfo(ctx, "DelGroupMemberInfoFromCache", err, "userID", userID)
+				tracelog.SetCtxInfo(ctx, "DelGroupMemberInfoFromCache", err, "userID", userID)
 			}
 		}
 		go func() {
@@ -599,7 +600,7 @@ func (s *groupServer) GetGroupApplicationList(ctx context.Context, req *pbGroup.
 		return nil, err
 	}
 	var errResult error
-	trace_log.SetCtxInfo(ctx, "GetRecvGroupApplicationList", nil, " FromUserID: ", req.FromUserID, "GroupApplicationList: ", reply)
+	tracelog.SetCtxInfo(ctx, "GetRecvGroupApplicationList", nil, " FromUserID: ", req.FromUserID, "GroupApplicationList: ", reply)
 	for _, v := range reply {
 		node := open_im_sdk.GroupRequest{UserInfo: &open_im_sdk.PublicUserInfo{}, GroupInfo: &open_im_sdk.GroupInfo{}}
 		err := FillGroupInfoByGroupID(tools.OperationID(ctx), v.GroupID, node.GroupInfo)
@@ -609,7 +610,7 @@ func (s *groupServer) GetGroupApplicationList(ctx context.Context, req *pbGroup.
 			}
 			continue
 		}
-		trace_log.SetCtxInfo(ctx, "FillGroupInfoByGroupID ", nil, " groupID: ", v.GroupID, " groupInfo: ", node.GroupInfo)
+		tracelog.SetCtxInfo(ctx, "FillGroupInfoByGroupID ", nil, " groupID: ", v.GroupID, " groupInfo: ", node.GroupInfo)
 		err = FillPublicUserInfoByUserID(tools.OperationID(ctx), v.UserID, node.UserInfo)
 		if err != nil {
 			errResult = err
@@ -621,7 +622,7 @@ func (s *groupServer) GetGroupApplicationList(ctx context.Context, req *pbGroup.
 	if errResult != nil && len(resp.GroupRequestList) == 0 {
 		return nil, err
 	}
-	trace_log.SetRpcRespInfo(ctx, utils.GetSelfFuncName(), resp.String())
+	tracelog.SetRpcRespInfo(ctx, utils.GetSelfFuncName(), resp.String())
 	return resp, nil
 }
 
@@ -644,7 +645,7 @@ func (s *groupServer) GetGroupsInfo(ctx context.Context, req *pbGroup.GetGroupsI
 
 func CheckPermission(ctx context.Context, groupID string, userID string) (err error) {
 	defer func() {
-		trace_log.SetCtxInfo(ctx, utils.GetSelfFuncName(), err, "groupID", groupID, "userID", userID)
+		tracelog.SetCtxInfo(ctx, utils.GetSelfFuncName(), err, "groupID", groupID, "userID", userID)
 	}()
 	if !token_verify.IsManagerUserID(userID) && !relation.IsGroupOwnerAdmin(groupID, userID) {
 		return utils.Wrap(constant.ErrNoPermission, utils.GetSelfFuncName())
@@ -764,7 +765,7 @@ func (s *groupServer) JoinGroup(ctx context.Context, req *pbGroup.JoinGroupReq)
 			}
 			client := pbUser.NewUserClient(etcdConn)
 			respPb, err := client.SetConversation(context.Background(), &reqPb)
-			trace_log.SetCtxInfo(ctx, "SetConversation", err, "req", reqPb, "resp", respPb)
+			tracelog.SetCtxInfo(ctx, "SetConversation", err, "req", reqPb, "resp", respPb)
 			chat.MemberEnterDirectlyNotification(req.GroupID, tools.OpUserID(ctx), tools.OperationID(ctx))
 			return resp, nil
 		} else {
@@ -932,7 +933,7 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInf
 		}
 		nClient := pbConversation.NewConversationClient(nEtcdConn)
 		conversationReply, err := nClient.ModifyConversationField(context.Background(), &conversationReq)
-		trace_log.SetCtxInfo(ctx, "ModifyConversationField", err, "req", &conversationReq, "resp", conversationReply)
+		tracelog.SetCtxInfo(ctx, "ModifyConversationField", err, "req", &conversationReq, "resp", conversationReply)
 	}
 	return resp, nil
 }
@@ -1005,14 +1006,14 @@ func (s *groupServer) GetGroups(ctx context.Context, req *pbGroup.GetGroupsReq)
 	} else {
 		groups, count, err := relation.GetGroupsByName(req.GroupName, req.Pagination.PageNumber, req.Pagination.ShowNumber)
 		if err != nil {
-			trace_log.SetCtxInfo(ctx, "GetGroupsByName", err, "GroupName", req.GroupName, "PageNumber", req.Pagination.PageNumber, "ShowNumber", req.Pagination.ShowNumber)
+			tracelog.SetCtxInfo(ctx, "GetGroupsByName", err, "GroupName", req.GroupName, "PageNumber", req.Pagination.PageNumber, "ShowNumber", req.Pagination.ShowNumber)
 		}
 		for _, v := range groups {
 			group := &pbGroup.CMSGroup{GroupInfo: &open_im_sdk.GroupInfo{}}
 			utils.CopyStructFields(group.GroupInfo, v)
 			groupMember, err := relation.GetGroupOwnerInfoByGroupID(v.GroupID)
 			if err != nil {
-				trace_log.SetCtxInfo(ctx, "GetGroupOwnerInfoByGroupID", err, "GroupID", v.GroupID)
+				tracelog.SetCtxInfo(ctx, "GetGroupOwnerInfoByGroupID", err, "GroupID", v.GroupID)
 				continue
 			}
 			group.GroupInfo.CreateTime = uint32(v.CreateTime.Unix())
@@ -1061,12 +1062,12 @@ func (s *groupServer) GetUserReqApplicationList(ctx context.Context, req *pbGrou
 		node := open_im_sdk.GroupRequest{UserInfo: &open_im_sdk.PublicUserInfo{}, GroupInfo: &open_im_sdk.GroupInfo{}}
 		group, err := relation.GetGroupInfoByGroupID(groupReq.GroupID)
 		if err != nil {
-			trace_log.SetCtxInfo(ctx, "GetGroupInfoByGroupID", err, "GroupID", groupReq.GroupID)
+			tracelog.SetCtxInfo(ctx, "GetGroupInfoByGroupID", err, "GroupID", groupReq.GroupID)
 			continue
 		}
 		user, err := relation.GetUserByUserID(groupReq.UserID)
 		if err != nil {
-			trace_log.SetCtxInfo(ctx, "GetUserByUserID", err, "UserID", groupReq.UserID)
+			tracelog.SetCtxInfo(ctx, "GetUserByUserID", err, "UserID", groupReq.UserID)
 			continue
 		}
 		cp.GroupRequestDBCopyOpenIM(&node, &groupReq)
@@ -1102,7 +1103,7 @@ func (s *groupServer) DismissGroup(ctx context.Context, req *pbGroup.DismissGrou
 	if groupInfo.GroupType != constant.SuperGroup {
 		memberList, err := relation.GetGroupMemberListByGroupID(req.GroupID)
 		if err != nil {
-			trace_log.SetCtxInfo(ctx, "GetGroupMemberListByGroupID", err, "groupID", req.GroupID)
+			tracelog.SetCtxInfo(ctx, "GetGroupMemberListByGroupID", err, "groupID", req.GroupID)
 		}
 		//modify quitter conversation info
 		var reqPb pbUser.SetConversationReq
@@ -1118,7 +1119,7 @@ func (s *groupServer) DismissGroup(ctx context.Context, req *pbGroup.DismissGrou
 			etcdConn, err := getcdv3.GetConn(ctx, config.Config.RpcRegisterName.OpenImUserName)
 			client := pbUser.NewUserClient(etcdConn)
 			respPb, err := client.SetConversation(context.Background(), &reqPb)
-			trace_log.SetCtxInfo(ctx, "SetConversation", err, "req", &reqPb, "resp", respPb)
+			tracelog.SetCtxInfo(ctx, "SetConversation", err, "req", &reqPb, "resp", respPb)
 		}
 		err = relation.DeleteGroupMemberByGroupID(req.GroupID)
 		if err != nil {
@@ -1381,7 +1382,7 @@ func (s *groupServer) GetGroupAbstractInfo(ctx context.Context, req *pbGroup.Get
 }
 
 func (s *groupServer) DelGroupAndUserCache(ctx context.Context, groupID string, userIDList []string) error {
-	operationID := trace_log.GetOperationID(ctx)
+	operationID := tracelog.GetOperationID(ctx)
 	if groupID != "" {
 		etcdConn, err := getcdv3.GetConn(ctx, config.Config.RpcRegisterName.OpenImCacheName)
 		if err != nil {

internal/utils/callback.go

@@ -1 +0,0 @@
-package utils

pkg/common/db/cache/group.go

@@ -56,7 +56,7 @@ func (g *GroupCache) GetGroupInfo(ctx context.Context, groupID string) (group *r
 	}
 	group = &relation.Group{}
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "group", *group)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "group", *group)
 	}()
 	groupStr, err := g.rcClient.Fetch(g.getGroupInfoCacheKey(groupID), g.expireTime, getGroup)
 	if err != nil {
@@ -68,7 +68,7 @@ func (g *GroupCache) GetGroupInfo(ctx context.Context, groupID string) (group *r
 
 func (g *GroupCache) DelGroupInfo(ctx context.Context, groupID string) (err error) {
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID)
 	}()
 	return g.rcClient.TagAsDeleted(g.getGroupInfoCacheKey(groupID))
 }
@@ -96,7 +96,7 @@ func (g *GroupCache) DelJoinedSuperGroupIDs(ctx context.Context, userIDs []strin
 
 func (g *GroupCache) DelJoinedSuperGroupID(ctx context.Context, userID string) (err error) {
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID)
 	}()
 	return g.rcClient.TagAsDeleted(joinedSuperGroupListCache + userID)
 }

pkg/common/db/cache/rockscache.go

@@ -85,7 +85,7 @@ func (rc *Client) GetFriendIDListFromCache(ctx context.Context, userID string) (
 		return string(bytes), nil
 	}
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID, "friendIDList", friendIDList)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID, "friendIDList", friendIDList)
 	}()
 	friendIDListStr, err := db.DB.Rc.Fetch(friendRelationCache+userID, time.Second*30*60, getFriendIDList)
 	if err != nil {
@@ -97,7 +97,7 @@ func (rc *Client) GetFriendIDListFromCache(ctx context.Context, userID string) (
 
 func DelFriendIDListFromCache(ctx context.Context, userID string) (err error) {
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID)
 	}()
 	return db.DB.Rc.TagAsDeleted(friendRelationCache + userID)
 }
@@ -115,7 +115,7 @@ func GetBlackListFromCache(ctx context.Context, userID string) (blackIDs []strin
 		return string(bytes), nil
 	}
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID, "blackIDList", blackIDs)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID, "blackIDList", blackIDs)
 	}()
 	blackIDListStr, err := db.DB.Rc.Fetch(blackListCache+userID, time.Second*30*60, getBlackIDList)
 	if err != nil {
@@ -127,7 +127,7 @@ func GetBlackListFromCache(ctx context.Context, userID string) (blackIDs []strin
 
 func DelBlackIDListFromCache(ctx context.Context, userID string) (err error) {
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "ctx", ctx)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "ctx", ctx)
 	}()
 	return db.DB.Rc.TagAsDeleted(blackListCache + userID)
 }
@@ -145,7 +145,7 @@ func GetJoinedGroupIDListFromCache(ctx context.Context, userID string) (joinedGr
 		return string(bytes), nil
 	}
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID, "joinedGroupList", joinedGroupList)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID, "joinedGroupList", joinedGroupList)
 	}()
 	joinedGroupIDListStr, err := db.DB.Rc.Fetch(joinedGroupListCache+userID, time.Second*30*60, getJoinedGroupIDList)
 	if err != nil {
@@ -157,7 +157,7 @@ func GetJoinedGroupIDListFromCache(ctx context.Context, userID string) (joinedGr
 
 func DelJoinedGroupIDListFromCache(ctx context.Context, userID string) (err error) {
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID)
 	}()
 	return db.DB.Rc.TagAsDeleted(joinedGroupListCache + userID)
 }
@@ -188,7 +188,7 @@ func GetGroupMemberIDListFromCache(ctx context.Context, groupID string) (groupMe
 		return string(bytes), nil
 	}
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "groupMemberIDList", groupMemberIDList)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "groupMemberIDList", groupMemberIDList)
 	}()
 	groupIDListStr, err := db.DB.Rc.Fetch(groupCache+groupID, time.Second*30*60, f)
 	if err != nil {
@@ -200,7 +200,7 @@ func GetGroupMemberIDListFromCache(ctx context.Context, groupID string) (groupMe
 
 func DelGroupMemberIDListFromCache(ctx context.Context, groupID string) (err error) {
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID)
 	}()
 	return db.DB.Rc.TagAsDeleted(groupCache + groupID)
 }
@@ -218,7 +218,7 @@ func GetUserInfoFromCache(ctx context.Context, userID string) (userInfo *relatio
 		return string(bytes), nil
 	}
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID, "userInfo", *userInfo)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID, "userInfo", *userInfo)
 	}()
 	userInfoStr, err := db.DB.Rc.Fetch(userInfoCache+userID, time.Second*30*60, getUserInfo)
 	if err != nil {
@@ -243,7 +243,7 @@ func GetUserInfoFromCacheBatch(ctx context.Context, userIDs []string) ([]*relati
 
 func DelUserInfoFromCache(ctx context.Context, userID string) (err error) {
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID)
 	}()
 	return db.DB.Rc.TagAsDeleted(userInfoCache + userID)
 }
@@ -261,7 +261,7 @@ func GetGroupMemberInfoFromCache(ctx context.Context, groupID, userID string) (g
 		return string(bytes), nil
 	}
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "userID", userID, "groupMember", *groupMember)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "userID", userID, "groupMember", *groupMember)
 	}()
 	groupMemberInfoStr, err := db.DB.Rc.Fetch(groupMemberInfoCache+groupID+"-"+userID, time.Second*30*60, getGroupMemberInfo)
 	if err != nil {
@@ -274,14 +274,14 @@ func GetGroupMemberInfoFromCache(ctx context.Context, groupID, userID string) (g
 
 func DelGroupMemberInfoFromCache(ctx context.Context, groupID, userID string) (err error) {
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "userID", userID)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "userID", userID)
 	}()
 	return db.DB.Rc.TagAsDeleted(groupMemberInfoCache + groupID + "-" + userID)
 }
 
 func GetGroupMembersInfoFromCache(ctx context.Context, count, offset int32, groupID string) (groupMembers []*relation.GroupMember, err error) {
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "count", count, "offset", offset, "groupID", groupID, "groupMember", groupMembers)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "count", count, "offset", offset, "groupID", groupID, "groupMember", groupMembers)
 	}()
 	groupMemberIDList, err := GetGroupMemberIDListFromCache(ctx, groupID)
 	if err != nil {
@@ -328,7 +328,7 @@ func GetGroupMembersInfoFromCache(ctx context.Context, count, offset int32, grou
 
 func GetAllGroupMembersInfoFromCache(ctx context.Context, groupID string) (groupMembers []*relation.GroupMember, err error) {
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "groupMembers", groupMembers)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "groupMembers", groupMembers)
 	}()
 	getGroupMemberInfo := func() (string, error) {
 		groupMembers, err := relation.GetGroupMemberListByGroupID(groupID)
@@ -351,7 +351,7 @@ func GetAllGroupMembersInfoFromCache(ctx context.Context, groupID string) (group
 
 func DelAllGroupMembersInfoFromCache(ctx context.Context, groupID string) (err error) {
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID)
 	}()
 	return db.DB.Rc.TagAsDeleted(groupAllMemberInfoCache + groupID)
 }
@@ -400,7 +400,7 @@ func GetAllFriendsInfoFromCache(ctx context.Context, userID string) (friends []*
 		return string(bytes), nil
 	}
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID, "friends", friends)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID, "friends", friends)
 	}()
 	allFriendInfoStr, err := db.DB.Rc.Fetch(allFriendInfoCache+userID, time.Second*30*60, getAllFriendInfo)
 	if err != nil {
@@ -412,7 +412,7 @@ func GetAllFriendsInfoFromCache(ctx context.Context, userID string) (friends []*
 
 func DelAllFriendsInfoFromCache(ctx context.Context, userID string) (err error) {
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID)
 	}()
 	return db.DB.Rc.TagAsDeleted(allFriendInfoCache + userID)
 }
@@ -430,7 +430,7 @@ func GetJoinedSuperGroupListFromCache(ctx context.Context, userID string) (joine
 		return string(bytes), nil
 	}
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID, "joinedSuperGroupIDs", joinedSuperGroupIDs)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID, "joinedSuperGroupIDs", joinedSuperGroupIDs)
 	}()
 	joinedSuperGroupListStr, err := db.DB.Rc.Fetch(joinedSuperGroupListCache+userID, time.Second*30*60, getJoinedSuperGroupIDList)
 	if err != nil {
@@ -442,7 +442,7 @@ func GetJoinedSuperGroupListFromCache(ctx context.Context, userID string) (joine
 
 func DelJoinedSuperGroupIDListFromCache(ctx context.Context, userID string) (err error) {
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID)
 	}()
 	return db.DB.Rc.TagAsDeleted(joinedSuperGroupListCache + userID)
 }
@@ -470,7 +470,7 @@ func GetGroupMemberListHashFromCache(ctx context.Context, groupID string) (hashC
 		return strconv.Itoa(int(bi.Uint64())), nil
 	}
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "hashCodeUint64", hashCodeUint64)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "hashCodeUint64", hashCodeUint64)
 	}()
 	hashCodeStr, err := db.DB.Rc.Fetch(groupMemberListHashCache+groupID, time.Second*30*60, generateHash)
 	if err != nil {
@@ -482,7 +482,7 @@ func GetGroupMemberListHashFromCache(ctx context.Context, groupID string) (hashC
 
 func DelGroupMemberListHashFromCache(ctx context.Context, groupID string) (err error) {
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID)
 	}()
 	return db.DB.Rc.TagAsDeleted(groupMemberListHashCache + groupID)
 }
@@ -496,7 +496,7 @@ func GetGroupMemberNumFromCache(ctx context.Context, groupID string) (num int, e
 		return strconv.Itoa(int(num)), nil
 	}
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "num", num)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "num", num)
 	}()
 	groupMember, err := db.DB.Rc.Fetch(groupMemberNumCache+groupID, time.Second*30*60, getGroupMemberNum)
 	if err != nil {
@@ -507,7 +507,7 @@ func GetGroupMemberNumFromCache(ctx context.Context, groupID string) (num int, e
 
 func DelGroupMemberNumFromCache(ctx context.Context, groupID string) (err error) {
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID)
 	}()
 	return db.DB.Rc.TagAsDeleted(groupMemberNumCache + groupID)
 }
@@ -526,7 +526,7 @@ func GetUserConversationIDListFromCache(ctx context.Context, userID string) (con
 		return string(bytes), nil
 	}
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID, "conversationIDs", conversationIDs)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID, "conversationIDs", conversationIDs)
 	}()
 	conversationIDListStr, err := db.DB.Rc.Fetch(conversationIDListCache+userID, time.Second*30*60, getConversationIDList)
 	err = json.Unmarshal([]byte(conversationIDListStr), &conversationIDs)
@@ -538,7 +538,7 @@ func GetUserConversationIDListFromCache(ctx context.Context, userID string) (con
 
 func DelUserConversationIDListFromCache(ctx context.Context, userID string) (err error) {
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID)
 	}()
 	return utils.Wrap(db.DB.Rc.TagAsDeleted(conversationIDListCache+userID), "DelUserConversationIDListFromCache err")
 }
@@ -556,7 +556,7 @@ func GetConversationFromCache(ctx context.Context, ownerUserID, conversationID s
 		return string(bytes), nil
 	}
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "ownerUserID", ownerUserID, "conversationID", conversationID, "conversation", *conversation)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "ownerUserID", ownerUserID, "conversationID", conversationID, "conversation", *conversation)
 	}()
 	conversationStr, err := db.DB.Rc.Fetch(conversationCache+ownerUserID+":"+conversationID, time.Second*30*60, getConversation)
 	if err != nil {
@@ -569,7 +569,7 @@ func GetConversationFromCache(ctx context.Context, ownerUserID, conversationID s
 
 func GetConversationsFromCache(ctx context.Context, ownerUserID string, conversationIDs []string) (conversations []relation.Conversation, err error) {
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "ownerUserID", ownerUserID, "conversationIDs", conversationIDs, "conversations", conversations)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "ownerUserID", ownerUserID, "conversationIDs", conversationIDs, "conversations", conversations)
 	}()
 	for _, conversationID := range conversationIDs {
 		conversation, err := GetConversationFromCache(ctx, ownerUserID, conversationID)
@@ -583,7 +583,7 @@ func GetConversationsFromCache(ctx context.Context, ownerUserID string, conversa
 
 func GetUserAllConversationList(ctx context.Context, ownerUserID string) (conversations []relation.Conversation, err error) {
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "ownerUserID", ownerUserID, "conversations", conversations)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "ownerUserID", ownerUserID, "conversations", conversations)
 	}()
 	IDList, err := GetUserConversationIDListFromCache(ctx, ownerUserID)
 	if err != nil {
@@ -603,7 +603,7 @@ func GetUserAllConversationList(ctx context.Context, ownerUserID string) (conver
 
 func DelConversationFromCache(ctx context.Context, ownerUserID, conversationID string) (err error) {
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "ownerUserID", ownerUserID, "conversationID", conversationID)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "ownerUserID", ownerUserID, "conversationID", conversationID)
 	}()
 	return utils.Wrap(db.DB.Rc.TagAsDeleted(conversationCache+ownerUserID+":"+conversationID), "DelConversationFromCache err")
 }
@@ -621,7 +621,7 @@ func GetExtendMsg(ctx context.Context, sourceID string, sessionType int32, clien
 		return string(bytes), nil
 	}
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "sourceID", sourceID, "sessionType",
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "sourceID", sourceID, "sessionType",
 			sessionType, "clientMsgID", clientMsgID, "firstModifyTime", firstModifyTime, "extendMsg", extendMsg)
 	}()
 	extendMsgStr, err := db.DB.Rc.Fetch(extendMsgCache+clientMsgID, time.Second*30*60, getExtendMsg)
@@ -635,7 +635,7 @@ func GetExtendMsg(ctx context.Context, sourceID string, sessionType int32, clien
 
 func DelExtendMsg(ctx context.Context, clientMsgID string) (err error) {
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "clientMsgID", clientMsgID)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "clientMsgID", clientMsgID)
 	}()
 	return utils.Wrap(db.DB.Rc.TagAsDeleted(extendMsgCache+clientMsgID), "DelExtendMsg err")
 }

pkg/common/db/relation/black.go

@@ -26,35 +26,35 @@ func NewBlack(db *gorm.DB) *Black {
 
 func (b *Black) Create(ctx context.Context, blacks []*Black) (err error) {
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "blacks", blacks)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "blacks", blacks)
 	}()
 	return utils.Wrap(b.DB.Create(&blacks).Error, "")
 }
 
 func (b *Black) Delete(ctx context.Context, blacks []*Black) (err error) {
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "blacks", blacks)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "blacks", blacks)
 	}()
 	return utils.Wrap(GroupMemberDB.Delete(blacks).Error, "")
 }
 
 func (b *Black) UpdateByMap(ctx context.Context, ownerUserID, blockUserID string, args map[string]interface{}) (err error) {
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "ownerUserID", ownerUserID, "blockUserID", blockUserID, "args", args)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "ownerUserID", ownerUserID, "blockUserID", blockUserID, "args", args)
 	}()
 	return utils.Wrap(b.DB.Where("block_user_id = ? and block_user_id = ?", ownerUserID, blockUserID).Updates(args).Error, "")
 }
 
 func (b *Black) Update(ctx context.Context, blacks []*Black) (err error) {
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "blacks", blacks)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "blacks", blacks)
 	}()
 	return utils.Wrap(b.DB.Updates(&blacks).Error, "")
 }
 
 func (b *Black) Find(ctx context.Context, blacks []*Black) (blackList []*Black, err error) {
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "blacks", blacks, "blackList", blackList)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "blacks", blacks, "blackList", blackList)
 	}()
 	var where [][]interface{}
 	for _, black := range blacks {
@@ -66,20 +66,20 @@ func (b *Black) Find(ctx context.Context, blacks []*Black) (blackList []*Black,
 func (b *Black) Take(ctx context.Context, ownerUserID, blockUserID string) (black *Black, err error) {
 	black = &Black{}
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "ownerUserID", ownerUserID, "blockUserID", blockUserID, "black", *black)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "ownerUserID", ownerUserID, "blockUserID", blockUserID, "black", *black)
 	}()
 	return black, utils.Wrap(b.DB.Where("owner_user_id = ? and block_user_id = ?", ownerUserID, blockUserID).Take(black).Error, "")
 }
 
 func (b *Black) FindByOwnerUserID(ctx context.Context, ownerUserID string) (blackList []*Black, err error) {
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "ownerUserID", ownerUserID, "blackList", blackList)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "ownerUserID", ownerUserID, "blackList", blackList)
 	}()
 	return blackList, utils.Wrap(GroupMemberDB.Where("owner_user_id = ?", ownerUserID).Find(&blackList).Error, "")
 }
 
 func InsertInToUserBlackList(ctx context.Context, black Black) (err error) {
-	defer trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "black", black)
+	defer tracelog.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "black", black)
 	black.CreateTime = time.Now()
 	err = BlackDB.Create(black).Error
 	return err

pkg/common/db/relation/friend_model_k.go

@@ -27,14 +27,14 @@ func NewFriend(db *gorm.DB) *Friend {
 
 func (f *Friend) Create(ctx context.Context, friends []*Friend) (err error) {
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "friends", friends)
+		tracelog.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "friends", friends)
 	}()
 	return utils.Wrap(f.DB.Create(&friends).Error, "")
 }
 
 func (f *Friend) Delete(ctx context.Context, ownerUserID string, friendUserIDs string) (err error) {
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "friendUserIDs", friendUserIDs)
+		tracelog.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "friendUserIDs", friendUserIDs)
 	}()
 	err = utils.Wrap(f.DB.Where("owner_user_id = ? and friend_user_id = ?", ownerUserID, friendUserIDs).Delete(&Friend{}).Error, "")
 	return err
@@ -42,48 +42,48 @@ func (f *Friend) Delete(ctx context.Context, ownerUserID string, friendUserIDs s
 
 func (f *Friend) UpdateByMap(ctx context.Context, ownerUserID string, args map[string]interface{}) (err error) {
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "args", args)
+		tracelog.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "args", args)
 	}()
 	return utils.Wrap(f.DB.Where("owner_user_id = ?", ownerUserID).Updates(args).Error, "")
 }
 
 func (f *Friend) Update(ctx context.Context, friends []*Friend) (err error) {
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "friends", friends)
+		tracelog.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "friends", friends)
 	}()
 	return utils.Wrap(f.DB.Updates(&friends).Error, "")
 }
 
 func (f *Friend) UpdateRemark(ctx context.Context, ownerUserID, friendUserID, remark string) (err error) {
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "friendUserID", friendUserID, "remark", remark)
+		tracelog.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "friendUserID", friendUserID, "remark", remark)
 	}()
 	return utils.Wrap(f.DB.Model(f).Where("owner_user_id = ? and friend_user_id = ?", ownerUserID, friendUserID).Update("remark", remark).Error, "")
 }
 
 func (f *Friend) FindOwnerUserID(ctx context.Context, ownerUserID string) (friends []*Friend, err error) {
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "friends", friends)
+		tracelog.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "friends", friends)
 	}()
 	return friends, utils.Wrap(f.DB.Where("owner_user_id = ?", ownerUserID).Find(&friends).Error, "")
 }
 
 func (f *Friend) FindFriendUserID(ctx context.Context, friendUserID string) (friends []*Friend, err error) {
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "friendUserID", friendUserID, "friends", friends)
+		tracelog.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "friendUserID", friendUserID, "friends", friends)
 	}()
 	return friends, utils.Wrap(f.DB.Where("friend_user_id = ?", friendUserID).Find(&friends).Error, "")
 }
 
 func (f *Friend) Take(ctx context.Context, ownerUserID, friendUserID string) (friend *Friend, err error) {
 	friend = &Friend{}
-	defer trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "friendUserID", friendUserID, "friend", friend)
+	defer tracelog.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "friendUserID", friendUserID, "friend", friend)
 	return friend, utils.Wrap(f.DB.Where("owner_user_id = ? and friend_user_id", ownerUserID, friendUserID).Take(friend).Error, "")
 }
 
 func (f *Friend) FindUserState(ctx context.Context, userID1, userID2 string) (friends []*Friend, err error) {
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "userID1", userID1, "userID2", userID2)
+		tracelog.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "userID1", userID1, "userID2", userID2)
 	}()
 	return friends, utils.Wrap(f.DB.Where("(owner_user_id = ? and friend_user_id = ?) or (owner_user_id = ? and friend_user_id = ?)", userID1, userID2, userID2, userID1).Find(&friends).Error, "")
 }

pkg/common/db/relation/friend_request_model.go

@@ -31,55 +31,55 @@ func NewFriendRequest(db *gorm.DB) *FriendRequest {
 
 func (f *FriendRequest) Create(ctx context.Context, friends []*FriendRequest) (err error) {
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "friends", friends)
+		tracelog.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "friends", friends)
 	}()
 	return utils.Wrap(f.DB.Create(&friends).Error, "")
 }
 
 func (f *FriendRequest) Delete(ctx context.Context, fromUserID, toUserID string) (err error) {
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "fromUserID", fromUserID, "toUserID", toUserID)
+		tracelog.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "fromUserID", fromUserID, "toUserID", toUserID)
 	}()
 	return utils.Wrap(f.DB.Where("from_user_id = ? and to_user_id = ?", fromUserID, toUserID).Delete(&FriendRequest{}).Error, "")
 }
 
 func (f *FriendRequest) UpdateByMap(ctx context.Context, ownerUserID string, args map[string]interface{}) (err error) {
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "args", args)
+		tracelog.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "args", args)
 	}()
 	return utils.Wrap(f.DB.Where("owner_user_id = ?", ownerUserID).Updates(args).Error, "")
 }
 
 func (f *FriendRequest) Update(ctx context.Context, friends []*FriendRequest) (err error) {
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "friends", friends)
+		tracelog.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "friends", friends)
 	}()
 	return utils.Wrap(f.DB.Updates(&friends).Error, "")
 }
 
 func (f *FriendRequest) Find(ctx context.Context, ownerUserID string) (friends []*FriendRequest, err error) {
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "friends", friends)
+		tracelog.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "friends", friends)
 	}()
 	return friends, utils.Wrap(f.DB.Where("owner_user_id = ?", ownerUserID).Find(&friends).Error, "")
 }
 
 func (f *FriendRequest) Take(ctx context.Context, fromUserID, toUserID string) (friend *FriendRequest, err error) {
 	friend = &FriendRequest{}
-	defer trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "fromUserID", fromUserID, "toUserID", toUserID, "friend", friend)
+	defer tracelog.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "fromUserID", fromUserID, "toUserID", toUserID, "friend", friend)
 	return friend, utils.Wrap(f.DB.Where("from_user_id = ? and to_user_id", fromUserID, toUserID).Take(friend).Error, "")
 }
 
 func (f *FriendRequest) FindToUserID(ctx context.Context, toUserID string) (friends []*FriendRequest, err error) {
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "toUserID", toUserID, "friends", friends)
+		tracelog.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "toUserID", toUserID, "friends", friends)
 	}()
 	return friends, utils.Wrap(f.DB.Where("to_user_id = ?", toUserID).Find(&friends).Error, "")
 }
 
 func (f *FriendRequest) FindFromUserID(ctx context.Context, fromUserID string) (friends []*FriendRequest, err error) {
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "fromUserID", fromUserID, "friends", friends)
+		tracelog.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "fromUserID", fromUserID, "friends", friends)
 	}()
 	return friends, utils.Wrap(f.DB.Where("from_user_id = ?", fromUserID).Find(&friends).Error, "")
 }

pkg/common/db/relation/group_member_model_k.go

@@ -3,6 +3,7 @@ package relation
 import (
 	"Open_IM/pkg/common/constant"
 	"Open_IM/pkg/common/trace_log"
+	"Open_IM/pkg/common/tracelog"
 	"Open_IM/pkg/utils"
 	"context"
 	"fmt"
@@ -33,33 +34,33 @@ func NewGroupMemberDB(db *gorm.DB) *GroupMember {
 
 func (g *GroupMember) Create(ctx context.Context, groupMemberList []*GroupMember, tx ...*gorm.DB) (err error) {
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupMemberList", groupMemberList)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupMemberList", groupMemberList)
 	}()
 	return utils.Wrap(getDBConn(g.DB, tx).Create(&groupMemberList).Error, "")
 }
 
 func (g *GroupMember) Delete(ctx context.Context, groupMembers []*GroupMember, tx ...*gorm.DB) (err error) {
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupMembers", groupMembers)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupMembers", groupMembers)
 	}()
 	return utils.Wrap(getDBConn(g.DB, tx).Delete(groupMembers).Error, "")
 }
 
 func (g *GroupMember) UpdateByMap(ctx context.Context, groupID string, userID string, args map[string]interface{}, tx ...*gorm.DB) (err error) {
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "userID", userID, "args", args)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "userID", userID, "args", args)
 	}()
 	return utils.Wrap(getDBConn(g.DB, tx).Model(&GroupMember{}).Where("group_id = ? and user_id = ?", groupID, userID).Updates(args).Error, "")
 }
 
 func (g *GroupMember) Update(ctx context.Context, groupMembers []*GroupMember, tx ...*gorm.DB) (err error) {
-	defer func() { trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupMembers", groupMembers) }()
+	defer func() { tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupMembers", groupMembers) }()
 	return utils.Wrap(getDBConn(g.DB, tx).Updates(&groupMembers).Error, "")
 }
 
 func (g *GroupMember) Find(ctx context.Context, groupMembers []*GroupMember, tx ...*gorm.DB) (groupList []*GroupMember, err error) {
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupMembers", groupMembers, "groupList", groupList)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupMembers", groupMembers, "groupList", groupList)
 	}()
 	var where [][]interface{}
 	for _, groupMember := range groupMembers {
@@ -70,7 +71,7 @@ func (g *GroupMember) Find(ctx context.Context, groupMembers []*GroupMember, tx
 
 func (g *GroupMember) Take(ctx context.Context, groupID string, userID string, tx ...*gorm.DB) (groupMember *GroupMember, err error) {
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "userID", userID, "groupMember", *groupMember)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "userID", userID, "groupMember", *groupMember)
 	}()
 	groupMember = &GroupMember{}
 	return groupMember, utils.Wrap(getDBConn(g.DB, tx).Where("group_id = ? and user_id = ?", groupID, userID).Take(groupMember).Error, "")
@@ -78,7 +79,7 @@ func (g *GroupMember) Take(ctx context.Context, groupID string, userID string, t
 
 func (g *GroupMember) TakeOwnerInfo(ctx context.Context, groupID string, tx ...*gorm.DB) (groupMember *GroupMember, err error) {
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "groupMember", *groupMember)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "groupMember", *groupMember)
 	}()
 	groupMember = &GroupMember{}
 	return groupMember, utils.Wrap(getDBConn(g.DB, tx).Where("group_id = ? and role_level = ?", groupID, constant.GroupOwner).Take(groupMember).Error, "")

pkg/common/db/relation/group_model_k.go

@@ -1,7 +1,7 @@
 package relation
 
 import (
-	"Open_IM/pkg/common/trace_log"
+	"Open_IM/pkg/common/tracelog"
 	"Open_IM/pkg/utils"
 	"context"
 	"gorm.io/gorm"
@@ -35,35 +35,35 @@ func NewGroupDB(db *gorm.DB) *Group {
 
 func (g *Group) Create(ctx context.Context, groups []*Group, tx ...*gorm.DB) (err error) {
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groups", groups)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groups", groups)
 	}()
 	return utils.Wrap(getDBConn(g.DB, tx).Create(&groups).Error, "")
 }
 
 func (g *Group) Delete(ctx context.Context, groupIDs []string, tx ...*gorm.DB) (err error) {
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupIDs", groupIDs)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupIDs", groupIDs)
 	}()
 	return utils.Wrap(getDBConn(g.DB, tx).Where("group_id in (?)", groupIDs).Delete(&Group{}).Error, "")
 }
 
 func (g *Group) UpdateByMap(ctx context.Context, groupID string, args map[string]interface{}, tx ...*gorm.DB) (err error) {
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "args", args)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "args", args)
 	}()
 	return utils.Wrap(getDBConn(g.DB, tx).Where("group_id = ?", groupID).Model(g).Updates(args).Error, "")
 }
 
 func (g *Group) Update(ctx context.Context, groups []*Group, tx ...*gorm.DB) (err error) {
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groups", groups)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groups", groups)
 	}()
 	return utils.Wrap(getDBConn(g.DB, tx).Updates(&groups).Error, "")
 }
 
 func (g *Group) Find(ctx context.Context, groupIDs []string, tx ...*gorm.DB) (groups []*Group, err error) {
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupIDs", groupIDs, "groups", groups)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupIDs", groupIDs, "groups", groups)
 	}()
 	return groups, utils.Wrap(getDBConn(g.DB, tx).Where("group_id in (?)", groupIDs).Find(&groups).Error, "")
 }
@@ -71,11 +71,7 @@ func (g *Group) Find(ctx context.Context, groupIDs []string, tx ...*gorm.DB) (gr
 func (g *Group) Take(ctx context.Context, groupID string, tx ...*gorm.DB) (group *Group, err error) {
 	group = &Group{}
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "group", *group)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "group", *group)
 	}()
 	return group, utils.Wrap(getDBConn(g.DB, tx).Where("group_id = ?", groupID).Take(group).Error, "")
 }
-
-//func (g *Group) DeleteTx(ctx context.Context, groupIDs []string) error {
-//	return nil
-//}

pkg/common/db/relation/group_request_model_k.go

@@ -37,35 +37,35 @@ func (GroupRequest) TableName() string {
 
 func (*GroupRequest) Create(ctx context.Context, groupRequests []*GroupRequest) (err error) {
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupRequests", groupRequests)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupRequests", groupRequests)
 	}()
 	return utils.Wrap(GroupRequestDB.Create(&groupRequests).Error, utils.GetSelfFuncName())
 }
 
 func (*GroupRequest) Delete(ctx context.Context, groupRequests []*GroupRequest) (err error) {
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupRequests", groupRequests)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupRequests", groupRequests)
 	}()
 	return utils.Wrap(GroupRequestDB.Delete(&groupRequests).Error, utils.GetSelfFuncName())
 }
 
 func (*GroupRequest) UpdateByMap(ctx context.Context, groupID string, userID string, args map[string]interface{}) (err error) {
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "userID", userID, "args", args)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "userID", userID, "args", args)
 	}()
 	return utils.Wrap(GroupRequestDB.Where("group_id = ? and user_id = ? ", groupID, userID).Updates(args).Error, utils.GetSelfFuncName())
 }
 
 func (*GroupRequest) Update(ctx context.Context, groupRequests []*GroupRequest) (err error) {
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupRequests", groupRequests)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupRequests", groupRequests)
 	}()
 	return utils.Wrap(GroupRequestDB.Updates(&groupRequests).Error, utils.GetSelfFuncName())
 }
 
 func (*GroupRequest) Find(ctx context.Context, groupRequests []*GroupRequest) (resultGroupRequests []*GroupRequest, err error) {
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupRequests", groupRequests, "resultGroupRequests", resultGroupRequests)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupRequests", groupRequests, "resultGroupRequests", resultGroupRequests)
 	}()
 	var where [][]interface{}
 	for _, groupMember := range groupRequests {
@@ -77,7 +77,7 @@ func (*GroupRequest) Find(ctx context.Context, groupRequests []*GroupRequest) (r
 func (*GroupRequest) Take(ctx context.Context, groupID string, userID string) (groupRequest *GroupRequest, err error) {
 	groupRequest = &GroupRequest{}
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "userID", userID, "groupRequest", *groupRequest)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "userID", userID, "groupRequest", *groupRequest)
 	}()
 	return groupRequest, utils.Wrap(GroupRequestDB.Where("group_id = ? and user_id = ? ", groupID, userID).Take(groupRequest).Error, utils.GetSelfFuncName())
 }

pkg/common/db/relation/user_model_k.go

@@ -34,7 +34,7 @@ func NewUserDB(db *gorm.DB) *User {
 
 func (u *User) Create(ctx context.Context, users []*User) (err error) {
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "users", users)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "users", users)
 	}()
 	err = utils.Wrap(u.DB.Create(&users).Error, "")
 	return err
@@ -42,21 +42,21 @@ func (u *User) Create(ctx context.Context, users []*User) (err error) {
 
 func (u *User) UpdateByMap(ctx context.Context, userID string, args map[string]interface{}) (err error) {
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID, "args", args)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID, "args", args)
 	}()
 	return utils.Wrap(u.DB.Where("user_id = ?", userID).Updates(args).Error, "")
 }
 
 func (u *User) Update(ctx context.Context, users []*User) (err error) {
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "users", users)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "users", users)
 	}()
 	return utils.Wrap(u.DB.Updates(&users).Error, "")
 }
 
 func (u *User) Find(ctx context.Context, userIDs []string) (users []*User, err error) {
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userIDs", userIDs, "users", users)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userIDs", userIDs, "users", users)
 	}()
 	err = utils.Wrap(u.DB.Where("user_id in (?)", userIDs).Find(&users).Error, "")
 	return users, err
@@ -65,7 +65,7 @@ func (u *User) Find(ctx context.Context, userIDs []string) (users []*User, err e
 func (u *User) Take(ctx context.Context, userID string) (user *User, err error) {
 	user = &User{}
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID, "user", *user)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID, "user", *user)
 	}()
 	err = utils.Wrap(u.DB.Where("user_id = ?", userID).Take(&user).Error, "")
 	return user, err
@@ -73,7 +73,7 @@ func (u *User) Take(ctx context.Context, userID string) (user *User, err error)
 
 func (u *User) GetByName(ctx context.Context, userName string, showNumber, pageNumber int32) (users []*User, err error) {
 	defer func() {
-		trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userName", userName, "showNumber", showNumber, "pageNumber", pageNumber, "users", users)
+		tracelog.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userName", userName, "showNumber", showNumber, "pageNumber", pageNumber, "users", users)
 	}()
 	err = u.DB.Where(" name like ?", fmt.Sprintf("%%%s%%", userName)).Limit(int(showNumber)).Offset(int(showNumber * (pageNumber - 1))).Find(&users).Error
 	return users, utils.Wrap(err, "")

pkg/common/log/logrus.go

@@ -237,8 +237,8 @@ func NewWarn(OperationID string, args ...interface{}) {
 }
 
 func ShowLog(ctx context.Context) {
-	t := ctx.Value(trace_log.TraceLogKey).(*trace_log.ApiInfo)
+	t := ctx.Value(tracelog.TraceLogKey).(*tracelog.ApiInfo)
-	OperationID := trace_log.GetOperationID(ctx)
+	OperationID := tracelog.GetOperationID(ctx)
 	//if ctx.Value(trace_log.TraceLogKey).(*trace_log.ApiInfo).GinCtx != nil {
 	//	ctxLogger.WithFields(logrus.Fields{
 	//		"OperationID": OperationID,
@@ -284,8 +284,8 @@ func ShowLog(ctx context.Context) {
 }
 
 func InfoWithCtx(ctx context.Context, args ...interface{}) {
-	t := ctx.Value(trace_log.TraceLogKey).(*trace_log.ApiInfo)
+	t := ctx.Value(tracelog.TraceLogKey).(*tracelog.ApiInfo)
-	OperationID := trace_log.GetOperationID(ctx)
+	OperationID := tracelog.GetOperationID(ctx)
 	for _, v := range *t.Funcs {
 		logger.WithFields(logrus.Fields{
 			"OperationID": OperationID,
@@ -295,8 +295,8 @@ func InfoWithCtx(ctx context.Context, args ...interface{}) {
 }
 
 func DebugWithCtx(ctx context.Context, args ...interface{}) {
-	t := ctx.Value(trace_log.TraceLogKey).(*trace_log.ApiInfo)
+	t := ctx.Value(tracelog.TraceLogKey).(*tracelog.ApiInfo)
-	OperationID := trace_log.GetOperationID(ctx)
+	OperationID := tracelog.GetOperationID(ctx)
 	for _, v := range *t.Funcs {
 		logger.WithFields(logrus.Fields{
 			"OperationID": OperationID,
@@ -306,8 +306,8 @@ func DebugWithCtx(ctx context.Context, args ...interface{}) {
 }
 
 func ErrorWithCtx(ctx context.Context, args ...interface{}) {
-	t := ctx.Value(trace_log.TraceLogKey).(*trace_log.ApiInfo)
+	t := ctx.Value(tracelog.TraceLogKey).(*tracelog.ApiInfo)
-	OperationID := trace_log.GetOperationID(ctx)
+	OperationID := tracelog.GetOperationID(ctx)
 	for _, v := range *t.Funcs {
 		if v.Err != nil {
 			logger.WithFields(logrus.Fields{
@@ -319,8 +319,8 @@ func ErrorWithCtx(ctx context.Context, args ...interface{}) {
 }
 
 func WarnWithCtx(ctx context.Context, args ...interface{}) {
-	t := ctx.Value(trace_log.TraceLogKey).(*trace_log.ApiInfo)
+	t := ctx.Value(tracelog.TraceLogKey).(*tracelog.ApiInfo)
-	OperationID := trace_log.GetOperationID(ctx)
+	OperationID := tracelog.GetOperationID(ctx)
 	for _, v := range *t.Funcs {
 		logger.WithFields(logrus.Fields{
 			"OperationID": OperationID,

pkg/common/middleware/rpc.go

@@ -37,12 +37,12 @@ func RpcServerInterceptor(ctx context.Context, req interface{}, info *grpc.Unary
 	if opts := md.Get("opUserID"); len(opts) == 1 {
 		opUserID = opts[0]
 	}
-	ctx = trace_log.NewRpcCtx(ctx, funcName, operationID)
+	ctx = tracelog.NewRpcCtx(ctx, funcName, operationID)
 	defer log.ShowLog(ctx)
-	trace_log.SetCtxInfo(ctx, funcName, err, "opUserID", opUserID, "rpcReq", rpcString(req))
+	tracelog.SetCtxInfo(ctx, funcName, err, "opUserID", opUserID, "rpcReq", rpcString(req))
 	resp, err = handler(ctx, req)
 	if err != nil {
-		trace_log.SetCtxInfo(ctx, funcName, err)
+		tracelog.SetCtxInfo(ctx, funcName, err)
 		errInfo := constant.ToAPIErrWithErr(err)
 		var code codes.Code
 		if errInfo.ErrCode == 0 {
@@ -56,7 +56,7 @@ func RpcServerInterceptor(ctx context.Context, req interface{}, info *grpc.Unary
 		}
 		return nil, sta.Err()
 	}
-	trace_log.SetCtxInfo(ctx, funcName, nil, "rpcResp", rpcString(resp))
+	tracelog.SetCtxInfo(ctx, funcName, nil, "rpcResp", rpcString(resp))
 	return
 }
 

pkg/common/token_verify/jwt_token.go

@@ -162,7 +162,7 @@ func CheckAccess(ctx context.Context, OpUserID string, OwnerUserID string) bool
 func CheckAccessV3(ctx context.Context, ownerUserID string) (err error) {
 	opUserID := tools.OpUserID(ctx)
 	defer func() {
-		trace_log.SetCtxInfo(ctx, utils.GetFuncName(1), err, "OpUserID", opUserID, "ownerUserID", ownerUserID)
+		tracelog.SetCtxInfo(ctx, utils.GetFuncName(1), err, "OpUserID", opUserID, "ownerUserID", ownerUserID)
 	}()
 	if utils.IsContain(opUserID, config.Config.Manager.AppManagerUid) {
 		return nil

pkg/common/tracelog/ctx.go

@@ -1,4 +1,4 @@
-package trace_log
+package tracelog
 
 import (
 	"Open_IM/pkg/common/constant"

pkg/getcdv3/temp.go

@@ -4,6 +4,7 @@ import (
 	"Open_IM/pkg/common/config"
 	"Open_IM/pkg/common/constant"
 	"Open_IM/pkg/common/trace_log"
+	"Open_IM/pkg/common/tracelog"
 	"context"
 	"github.com/OpenIMSDK/getcdv3"
 	"google.golang.org/grpc"
@@ -16,10 +17,10 @@ func GetDefaultConn(arg1, arg2, arg3, arg4 string) *grpc.ClientConn {
 
 func GetConn(ctx context.Context, serviceName string) (conn *grpc.ClientConn, err error) {
 	defer func() {
-		trace_log.SetCtxInfo(ctx, "GetConn", err, "serviceName", serviceName)
+		tracelog.SetCtxInfo(ctx, "GetConn", err, "serviceName", serviceName)
 	}()
 	conn = getcdv3.GetConn(config.Config.Etcd.EtcdSchema, strings.Join(config.Config.Etcd.EtcdAddr, ","),
-		serviceName, trace_log.GetOperationID(ctx), config.Config.Etcd.UserName, config.Config.Etcd.Password)
+		serviceName, tracelog.GetOperationID(ctx), config.Config.Etcd.UserName, config.Config.Etcd.Password)
 	if conn == nil {
 		return nil, constant.ErrInternalServer
 	}