From 6205c67b70425e749ddb9d14285b4b87efd04e8a Mon Sep 17 00:00:00 2001 From: wangchuxiao Date: Thu, 12 Jan 2023 15:55:44 +0800 Subject: [PATCH] log --- internal/api/group/group.go | 8 +- internal/api_to_rpc/api.go | 15 ++- internal/rpc/cache/cache.go | 57 ++------ internal/rpc/group/callback.go | 6 +- internal/rpc/group/group.go | 50 ++++--- pkg/common/constant/constant.go | 30 ++--- .../im_mysql_model/friend_model_k.go | 12 +- .../im_mysql_model/group_member_model_k.go | 14 +- .../im_mysql_model/group_model_k.go | 12 +- .../im_mysql_model/group_request_model_k.go | 12 +- .../im_mysql_model/user_black_list_model.go | 2 +- pkg/common/db/rocks_cache/rocks_cache.go | 66 +++++----- pkg/common/log/logrus.go | 122 +++++++++++++++++- pkg/common/middleware/rpc.go | 8 +- pkg/common/token_verify/jwt_token.go | 2 +- pkg/common/trace_log/ctx.go | 47 +++++-- pkg/getcdv3/temp.go | 2 +- 17 files changed, 284 insertions(+), 181 deletions(-) diff --git a/internal/api/group/group.go b/internal/api/group/group.go index fa0552cf3..567b3986c 100644 --- a/internal/api/group/group.go +++ b/internal/api/group/group.go @@ -997,14 +997,14 @@ func MuteGroupMember(c *gin.Context) { // @Router /group/cancel_mute_group_member [post] func CancelMuteGroupMember(c *gin.Context) { nCtx := trace_log.NewCtx(c, utils.GetSelfFuncName()) - defer trace_log.ShowLog(c) + defer log.ShowLog(c) params := api.CancelMuteGroupMemberReq{} if err := c.BindJSON(¶ms); err != nil { trace_log.WriteErrorResponse(nCtx, "BindJSON", err) return } - trace_log.SetContextInfo(nCtx, "BindJSON", nil, "params", params) + trace_log.SetCtxInfo(nCtx, "BindJSON", nil, "params", params) req := &rpc.CancelMuteGroupMemberReq{} utils.CopyStructFields(req, ¶ms) @@ -1013,7 +1013,7 @@ func CancelMuteGroupMember(c *gin.Context) { // trace_log.WriteErrorResponse(nCtx, "ParseUserIDFromToken", err) // return //} - trace_log.SetContextInfo(nCtx, "ParseUserIDFromToken", nil, "token", c.Request.Header.Get("token"), "OpUserID", req.OpUserID) + trace_log.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) @@ -1024,7 +1024,7 @@ func CancelMuteGroupMember(c *gin.Context) { return } - trace_log.SetContextInfo(nCtx, "CancelMuteGroupMember", nil, "req", req.String(), "resp", reply.String()) + trace_log.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) } diff --git a/internal/api_to_rpc/api.go b/internal/api_to_rpc/api.go index 81037d2bb..d2df9e0a0 100644 --- a/internal/api_to_rpc/api.go +++ b/internal/api_to_rpc/api.go @@ -1,6 +1,7 @@ package common import ( + "Open_IM/pkg/common/log" "Open_IM/pkg/common/trace_log" "Open_IM/pkg/getcdv3" utils2 "Open_IM/pkg/utils" @@ -15,12 +16,12 @@ func ApiToRpc(c *gin.Context, apiReq, apiResp interface{}, rpcName string, rpcCl logFuncName := fmt.Sprintf("[ApiToRpc: %s]%s", utils2.GetFuncName(1), rpcFuncName) operationID := c.GetHeader("operationID") nCtx := trace_log.NewCtx1(c, rpcFuncName, operationID) - defer trace_log.ShowLog(nCtx) + defer log.ShowLog(nCtx) if err := c.BindJSON(apiReq); err != nil { trace_log.WriteErrorResponse(nCtx, "BindJSON", err) return } - trace_log.SetContextInfo(nCtx, logFuncName, nil, "apiReq", apiReq) + trace_log.SetCtxInfo(nCtx, logFuncName, nil, "apiReq", apiReq) etcdConn, err := getcdv3.GetConn(nCtx, rpcName) if err != nil { trace_log.WriteErrorResponse(nCtx, "GetDefaultConn", err) @@ -43,7 +44,7 @@ func ApiToRpc(c *gin.Context, apiReq, apiResp interface{}, rpcName string, rpcCl trace_log.WriteErrorResponse(nCtx, "CopyStructFields_RpcReq", err) return } - trace_log.SetContextInfo(nCtx, logFuncName, nil, "opUserID", opUserID, "callRpcReq", rpcString(rpcReqPtr.Elem().Interface())) + trace_log.SetCtxInfo(nCtx, logFuncName, nil, "opUserID", opUserID, "callRpcReq", rpcString(rpcReqPtr.Elem().Interface())) md := metadata.Pairs("operationID", operationID, "opUserID", opUserID) respArr := rpc.Call([]reflect.Value{ reflect.ValueOf(metadata.NewOutgoingContext(c, md)), // context.Context @@ -55,10 +56,10 @@ func ApiToRpc(c *gin.Context, apiReq, apiResp interface{}, rpcName string, rpcCl return } rpcResp := respArr[0].Elem() - trace_log.SetContextInfo(nCtx, rpcFuncName, nil, "callRpcResp", rpcString(rpcResp.Interface())) + trace_log.SetCtxInfo(nCtx, rpcFuncName, nil, "callRpcResp", rpcString(rpcResp.Interface())) if apiResp != nil { if err := utils.CopyStructFields(apiResp, rpcResp.Interface()); err != nil { - trace_log.SetContextInfo(nCtx, "CopyStructFields_RpcResp", err, "apiResp", fmt.Sprintf("%T", apiResp), "rpcResp", fmt.Sprintf("%T", rpcResp.Interface())) + trace_log.SetCtxInfo(nCtx, "CopyStructFields_RpcResp", err, "apiResp", fmt.Sprintf("%T", apiResp), "rpcResp", fmt.Sprintf("%T", rpcResp.Interface())) } } trace_log.SetSuccess(nCtx, rpcFuncName, apiResp) @@ -81,7 +82,7 @@ func rpcString(v interface{}) string { // reqValue := reflect.ValueOf(apiReq).Elem() // operationID := reqValue.FieldByName("OperationID").String() // trace_log.SetOperationID(nCtx, operationID) -// trace_log.SetContextInfo(nCtx, "BindJSON", nil, "params", apiReq) +// trace_log.SetCtxInfo(nCtx, "BindJSON", nil, "params", apiReq) // etcdConn, err := utils2.GetConn(c, rpcName) // if err != nil { // trace_log.WriteErrorResponse(nCtx, "GetDefaultConn", err) @@ -124,7 +125,7 @@ func rpcString(v interface{}) string { // return // } // rpcResp := respArr[0].Elem() -// trace_log.SetContextInfo(nCtx, rpcFuncName, nil, "rpc req", rpcReqPtr.Interface(), "resp", rpcResp.Interface()) +// trace_log.SetCtxInfo(nCtx, rpcFuncName, nil, "rpc req", rpcReqPtr.Interface(), "resp", rpcResp.Interface()) // commonResp := rpcResp.FieldByName("CommonResp").Elem() // errCodeVal := commonResp.FieldByName("ErrCode") // errMsgVal := commonResp.FieldByName("ErrMsg").Interface().(string) diff --git a/internal/rpc/cache/cache.go b/internal/rpc/cache/cache.go index dc2fb0d17..7c445f741 100644 --- a/internal/rpc/cache/cache.go +++ b/internal/rpc/cache/cache.go @@ -6,9 +6,7 @@ import ( rocksCache "Open_IM/pkg/common/db/rocks_cache" "Open_IM/pkg/common/log" promePkg "Open_IM/pkg/common/prometheus" - "Open_IM/pkg/common/trace_log" pbCache "Open_IM/pkg/proto/cache" - sdkws "Open_IM/pkg/proto/sdk_ws" "Open_IM/pkg/utils" "context" "github.com/OpenIMSDK/getcdv3" @@ -92,15 +90,9 @@ func (s *cacheServer) Run() { } func (s *cacheServer) GetFriendIDListFromCache(ctx context.Context, req *pbCache.GetFriendIDListFromCacheReq) (resp *pbCache.GetFriendIDListFromCacheResp, err error) { - resp = &pbCache.GetFriendIDListFromCacheResp{CommonResp: &sdkws.CommonResp{}} - ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID) - defer func() { - trace_log.SetContextInfo(ctx, utils.GetFuncName(1), nil, "req", req.String(), "resp", resp.String()) - trace_log.ShowLog(ctx) - }() + resp = &pbCache.GetFriendIDListFromCacheResp{} friendIDList, err := rocksCache.GetFriendIDListFromCache(ctx, req.UserID) if err != nil { - constant.SetErrorForResp(err, resp.CommonResp) return } resp.UserIDList = friendIDList @@ -109,14 +101,8 @@ func (s *cacheServer) GetFriendIDListFromCache(ctx context.Context, req *pbCache // this is for dtm call func (s *cacheServer) DelFriendIDListFromCache(ctx context.Context, req *pbCache.DelFriendIDListFromCacheReq) (resp *pbCache.DelFriendIDListFromCacheResp, err error) { - resp = &pbCache.DelFriendIDListFromCacheResp{CommonResp: &sdkws.CommonResp{}} - ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID) - defer func() { - trace_log.SetContextInfo(ctx, utils.GetFuncName(1), nil, "req", req.String(), "resp", resp.String()) - trace_log.ShowLog(ctx) - }() + resp = &pbCache.DelFriendIDListFromCacheResp{} if err := rocksCache.DelFriendIDListFromCache(ctx, req.UserID); err != nil { - constant.SetErrorForResp(err, resp.CommonResp) return } log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", resp.String()) @@ -124,15 +110,9 @@ func (s *cacheServer) DelFriendIDListFromCache(ctx context.Context, req *pbCache } func (s *cacheServer) GetBlackIDListFromCache(ctx context.Context, req *pbCache.GetBlackIDListFromCacheReq) (resp *pbCache.GetBlackIDListFromCacheResp, err error) { - resp = &pbCache.GetBlackIDListFromCacheResp{CommonResp: &sdkws.CommonResp{}} - ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID) - defer func() { - trace_log.SetContextInfo(ctx, utils.GetFuncName(1), nil, "req", req.String(), "resp", resp.String()) - trace_log.ShowLog(ctx) - }() + resp = &pbCache.GetBlackIDListFromCacheResp{} blackUserIDList, err := rocksCache.GetBlackListFromCache(ctx, req.UserID) if err != nil { - constant.SetErrorForResp(err, resp.CommonResp) return } resp.UserIDList = blackUserIDList @@ -140,47 +120,26 @@ func (s *cacheServer) GetBlackIDListFromCache(ctx context.Context, req *pbCache. } func (s *cacheServer) DelBlackIDListFromCache(ctx context.Context, req *pbCache.DelBlackIDListFromCacheReq) (resp *pbCache.DelBlackIDListFromCacheResp, err error) { - resp = &pbCache.DelBlackIDListFromCacheResp{CommonResp: &sdkws.CommonResp{}} - ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID) - defer func() { - trace_log.SetContextInfo(ctx, utils.GetFuncName(1), nil, "req", req.String(), "resp", resp.String()) - trace_log.ShowLog(ctx) - }() + resp = &pbCache.DelBlackIDListFromCacheResp{} if err := rocksCache.DelBlackIDListFromCache(ctx, req.UserID); err != nil { - constant.SetErrorForResp(err, resp.CommonResp) return } - log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", resp.String()) return resp, nil } func (s *cacheServer) GetGroupMemberIDListFromCache(ctx context.Context, req *pbCache.GetGroupMemberIDListFromCacheReq) (resp *pbCache.GetGroupMemberIDListFromCacheResp, err error) { - resp = &pbCache.GetGroupMemberIDListFromCacheResp{ - CommonResp: &sdkws.CommonResp{}, - } - ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID) - defer func() { - trace_log.SetContextInfo(ctx, utils.GetFuncName(1), nil, "req", req.String(), "resp", resp.String()) - trace_log.ShowLog(ctx) - }() + resp = &pbCache.GetGroupMemberIDListFromCacheResp{} userIDList, err := rocksCache.GetGroupMemberIDListFromCache(ctx, req.GroupID) if err != nil { - constant.SetErrorForResp(err, resp.CommonResp) - return resp, nil + return } resp.UserIDList = userIDList - return resp, nil + return } func (s *cacheServer) DelGroupMemberIDListFromCache(ctx context.Context, req *pbCache.DelGroupMemberIDListFromCacheReq) (resp *pbCache.DelGroupMemberIDListFromCacheResp, err error) { - resp = &pbCache.DelGroupMemberIDListFromCacheResp{CommonResp: &sdkws.CommonResp{}} - ctx = trace_log.NewRpcCtx(ctx, utils.GetSelfFuncName(), req.OperationID) - defer func() { - trace_log.SetContextInfo(ctx, utils.GetFuncName(1), nil, "req", req.String(), "resp", resp.String()) - trace_log.ShowLog(ctx) - }() + resp = &pbCache.DelGroupMemberIDListFromCacheResp{} if err := rocksCache.DelGroupMemberIDListFromCache(ctx, req.GroupID); err != nil { - constant.SetErrorForResp(err, resp.CommonResp) return resp, nil } return resp, nil diff --git a/internal/rpc/group/callback.go b/internal/rpc/group/callback.go index a5bd6dc78..4240bd2ab 100644 --- a/internal/rpc/group/callback.go +++ b/internal/rpc/group/callback.go @@ -16,7 +16,7 @@ import ( func callbackBeforeCreateGroup(ctx context.Context, req *pbGroup.CreateGroupReq) (err error) { defer func() { - trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "req", req) + trace_log.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 *im_mysql_model.GroupMember, groupEx string) (err error) { defer func() { - trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "groupMember", *groupMember, "groupEx", groupEx) + trace_log.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.SetContextInfo(ctx, utils.GetFuncName(1), err, "req", *req) + trace_log.SetCtxInfo(ctx, utils.GetFuncName(1), err, "req", *req) }() callbackResp := cbApi.CommonCallbackResp{OperationID: req.OperationID} if !config.Config.Callback.CallbackBeforeSetGroupMemberInfo.Enable { diff --git a/internal/rpc/group/group.go b/internal/rpc/group/group.go index 9dcb4d13c..347abe209 100644 --- a/internal/rpc/group/group.go +++ b/internal/rpc/group/group.go @@ -210,7 +210,7 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR } else { for _, userID := range userIDs { if err := rocksCache.DelJoinedSuperGroupIDListFromCache(ctx, userID); err != nil { - trace_log.SetContextInfo(ctx, "DelJoinedSuperGroupIDListFromCache", err, "userID", userID) + trace_log.SetCtxInfo(ctx, "DelJoinedSuperGroupIDListFromCache", err, "userID", userID) } } go func() { @@ -242,7 +242,6 @@ func (s *groupServer) GetJoinedGroupList(ctx context.Context, req *pbGroup.GetJo owner, err := (*imdb.GroupMember)(nil).TakeOwnerInfo(ctx, groupID) //owner, err2 := imdb.GetGroupOwnerInfoByGroupID(groupID) if err != nil { - trace_log.SetContextInfo(ctx, "TakeOwnerInfo", err, "groupID", groupID) continue } group, err := rocksCache.GetGroupInfoFromCache(ctx, groupID) @@ -253,7 +252,6 @@ func (s *groupServer) GetJoinedGroupList(ctx context.Context, req *pbGroup.GetJo continue } if group.Status == constant.GroupStatusDismissed { - trace_log.SetContextInfo(ctx, "GetGroupInfoFromCache", err, "groupID", groupID) continue } utils.CopyStructFields(&groupNode, group) @@ -327,14 +325,14 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite resultNode.Result = 0 toUserInfo, err := imdb.GetUserByUserID(v) if err != nil { - trace_log.SetContextInfo(ctx, "GetUserByUserID", err, "userID", v) + trace_log.SetCtxInfo(ctx, "GetUserByUserID", err, "userID", v) resultNode.Result = -1 resp.Id2ResultList = append(resp.Id2ResultList, &resultNode) continue } if imdb.IsExistGroupMember(req.GroupID, v) { - trace_log.SetContextInfo(ctx, "IsExistGroupMember", err, "groupID", req.GroupID, "userID", v) + trace_log.SetCtxInfo(ctx, "IsExistGroupMember", err, "groupID", req.GroupID, "userID", v) resultNode.Result = -1 resp.Id2ResultList = append(resp.Id2ResultList, &resultNode) continue @@ -351,7 +349,7 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite } err = imdb.InsertIntoGroupMember(toInsertInfo) if err != nil { - trace_log.SetContextInfo(ctx, "InsertIntoGroupMember", err, "args", toInsertInfo) + trace_log.SetCtxInfo(ctx, "InsertIntoGroupMember", err, "args", toInsertInfo) resultNode.Result = -1 resp.Id2ResultList = append(resp.Id2ResultList, &resultNode) continue @@ -359,7 +357,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.SetContextInfo(ctx, "AddGroupMember", err, "groupID", req.GroupID, "userID", toUserInfo.UserID) + trace_log.SetCtxInfo(ctx, "AddGroupMember", err, "groupID", req.GroupID, "userID", toUserInfo.UserID) } resp.Id2ResultList = append(resp.Id2ResultList, &resultNode) } @@ -375,7 +373,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.SetContextInfo(ctx, "DelJoinedSuperGroupIDListFromCache", err, "userID", userID) + trace_log.SetCtxInfo(ctx, "DelJoinedSuperGroupIDListFromCache", err, "userID", userID) } } for _, v := range req.InvitedUserIDList { @@ -489,23 +487,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.SetContextInfo(ctx, "GetGroupMemberInfoFromCache", err, "groupID", req.GroupID, "userID", v) + trace_log.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.SetContextInfo(ctx, "", nil, "msg", "is constant.GroupAdmin, can't kicked", "groupID", req.GroupID, "userID", v) + trace_log.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.SetContextInfo(ctx, "", nil, "msg", "is constant.GroupOwner, can't kicked", "groupID", req.GroupID, "userID", v) + trace_log.SetCtxInfo(ctx, "", nil, "msg", "is constant.GroupOwner, can't kicked", "groupID", req.GroupID, "userID", v) continue } err = imdb.DeleteGroupMemberByGroupIDAndUserID(req.GroupID, v) - trace_log.SetContextInfo(ctx, "RemoveGroupMember", err, "groupID", req.GroupID, "userID", v) + trace_log.SetCtxInfo(ctx, "RemoveGroupMember", err, "groupID", req.GroupID, "userID", v) if err != nil { log.NewError(req.OperationID, "RemoveGroupMember failed ", err.Error(), req.GroupID, v) resp.Id2ResultList = append(resp.Id2ResultList, &pbGroup.Id2Result{UserID: v, Result: -1}) @@ -530,7 +528,7 @@ func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGrou } client := pbUser.NewUserClient(etcdConn) respPb, err := client.SetConversation(context.Background(), &reqPb) - trace_log.SetContextInfo(ctx, "SetConversation", err, "req", &reqPb, "resp", respPb) + trace_log.SetCtxInfo(ctx, "SetConversation", err, "req", &reqPb, "resp", respPb) } } else { okUserIDList = req.KickedUserIDList @@ -542,14 +540,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.SetContextInfo(ctx, "DelGroupMemberInfoFromCache", err, "groupID", req.GroupID, "userID", userID) + trace_log.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.SetContextInfo(ctx, "DelGroupMemberInfoFromCache", err, "userID", userID) + trace_log.SetCtxInfo(ctx, "DelGroupMemberInfoFromCache", err, "userID", userID) } } go func() { @@ -608,7 +606,7 @@ func (s *groupServer) GetGroupApplicationList(ctx context.Context, req *pbGroup. return nil, err } var errResult error - trace_log.SetContextInfo(ctx, "GetRecvGroupApplicationList", nil, " FromUserID: ", req.FromUserID, "GroupApplicationList: ", reply) + trace_log.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(req.OperationID, v.GroupID, node.GroupInfo) @@ -618,7 +616,7 @@ func (s *groupServer) GetGroupApplicationList(ctx context.Context, req *pbGroup. } continue } - trace_log.SetContextInfo(ctx, "FillGroupInfoByGroupID ", nil, " groupID: ", v.GroupID, " groupInfo: ", node.GroupInfo) + trace_log.SetCtxInfo(ctx, "FillGroupInfoByGroupID ", nil, " groupID: ", v.GroupID, " groupInfo: ", node.GroupInfo) err = FillPublicUserInfoByUserID(req.OperationID, v.UserID, node.UserInfo) if err != nil { errResult = err @@ -654,7 +652,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.SetContextInfo(ctx, utils.GetSelfFuncName(), err, "groupID", groupID, "userID", userID) + trace_log.SetCtxInfo(ctx, utils.GetSelfFuncName(), err, "groupID", groupID, "userID", userID) }() if !token_verify.IsManagerUserID(userID) && !imdb.IsGroupOwnerAdmin(groupID, userID) { return utils.Wrap(constant.ErrNoPermission, utils.GetSelfFuncName()) @@ -793,7 +791,7 @@ func (s *groupServer) JoinGroup(ctx context.Context, req *pbGroup.JoinGroupReq) } client := pbUser.NewUserClient(etcdConn) respPb, err := client.SetConversation(context.Background(), &reqPb) - trace_log.SetContextInfo(ctx, "SetConversation", err, "req", reqPb, "resp", respPb) + trace_log.SetCtxInfo(ctx, "SetConversation", err, "req", reqPb, "resp", respPb) chat.MemberEnterDirectlyNotification(req.GroupID, req.OpUserID, req.OperationID) return resp, nil } else { @@ -976,7 +974,7 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInf } nClient := pbConversation.NewConversationClient(nEtcdConn) conversationReply, err := nClient.ModifyConversationField(context.Background(), &conversationReq) - trace_log.SetContextInfo(ctx, "ModifyConversationField", err, "req", &conversationReq, "resp", conversationReply) + trace_log.SetCtxInfo(ctx, "ModifyConversationField", err, "req", &conversationReq, "resp", conversationReply) } return resp, nil } @@ -1049,14 +1047,14 @@ func (s *groupServer) GetGroups(ctx context.Context, req *pbGroup.GetGroupsReq) } else { groups, count, err := imdb.GetGroupsByName(req.GroupName, req.Pagination.PageNumber, req.Pagination.ShowNumber) if err != nil { - trace_log.SetContextInfo(ctx, "GetGroupsByName", err, "GroupName", req.GroupName, "PageNumber", req.Pagination.PageNumber, "ShowNumber", req.Pagination.ShowNumber) + trace_log.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 := imdb.GetGroupOwnerInfoByGroupID(v.GroupID) if err != nil { - trace_log.SetContextInfo(ctx, "GetGroupOwnerInfoByGroupID", err, "GroupID", v.GroupID) + trace_log.SetCtxInfo(ctx, "GetGroupOwnerInfoByGroupID", err, "GroupID", v.GroupID) continue } group.GroupInfo.CreateTime = uint32(v.CreateTime.Unix()) @@ -1105,12 +1103,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 := imdb.GetGroupInfoByGroupID(groupReq.GroupID) if err != nil { - trace_log.SetContextInfo(ctx, "GetGroupInfoByGroupID", err, "GroupID", groupReq.GroupID) + trace_log.SetCtxInfo(ctx, "GetGroupInfoByGroupID", err, "GroupID", groupReq.GroupID) continue } user, err := imdb.GetUserByUserID(groupReq.UserID) if err != nil { - trace_log.SetContextInfo(ctx, "GetUserByUserID", err, "UserID", groupReq.UserID) + trace_log.SetCtxInfo(ctx, "GetUserByUserID", err, "UserID", groupReq.UserID) continue } cp.GroupRequestDBCopyOpenIM(&node, &groupReq) @@ -1146,7 +1144,7 @@ func (s *groupServer) DismissGroup(ctx context.Context, req *pbGroup.DismissGrou if groupInfo.GroupType != constant.SuperGroup { memberList, err := imdb.GetGroupMemberListByGroupID(req.GroupID) if err != nil { - trace_log.SetContextInfo(ctx, "GetGroupMemberListByGroupID", err, "groupID", req.GroupID) + trace_log.SetCtxInfo(ctx, "GetGroupMemberListByGroupID", err, "groupID", req.GroupID) } //modify quitter conversation info var reqPb pbUser.SetConversationReq @@ -1162,7 +1160,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.SetContextInfo(ctx, "SetConversation", err, "req", &reqPb, "resp", respPb) + trace_log.SetCtxInfo(ctx, "SetConversation", err, "req", &reqPb, "resp", respPb) } err = imdb.DeleteGroupMemberByGroupID(req.GroupID) if err != nil { diff --git a/pkg/common/constant/constant.go b/pkg/common/constant/constant.go index 12541e639..95c201b50 100644 --- a/pkg/common/constant/constant.go +++ b/pkg/common/constant/constant.go @@ -205,21 +205,21 @@ const ( VerificationCodeForResetSuffix = "_forReset" //callbackCommand - CallbackBeforeSendSingleMsgCommand = "callbackBeforeSendSingleMsgCommand" - CallbackAfterSendSingleMsgCommand = "callbackAfterSendSingleMsgCommand" - CallbackBeforeSendGroupMsgCommand = "callbackBeforeSendGroupMsgCommand" - CallbackAfterSendGroupMsgCommand = "callbackAfterSendGroupMsgCommand" - CallbackMsgModifyCommand = "callbackMsgModifyCommand" - CallbackUserOnlineCommand = "callbackUserOnlineCommand" - CallbackUserOfflineCommand = "callbackUserOfflineCommand" - CallbackUserKickOffCommand = "callbackUserKickOffCommand" - CallbackOfflinePushCommand = "callbackOfflinePushCommand" - CallbackOnlinePushCommand = "callbackOnlinePushCommand" - CallbackSuperGroupOnlinePushCommand = "callbackSuperGroupOnlinePushCommand" - CallbackBeforeAddFriendCommand = "callbackBeforeAddFriendCommand" - CallbackBeforeCreateGroupCommand = "callbackBeforeCreateGroupCommand" - CallbackBeforeMemberJoinGroupCommand = "callbackBeforeMemberJoinGroupCommand" - CallbackBeforeSetGroupMemberInfoCommand = "CallbackBeforeSetGroupMemberInfoCommand" + CallbackBeforeSendSingleMsgCommand = "callbackBeforeSendSingleMsgCommand" + CallbackAfterSendSingleMsgCommand = "callbackAfterSendSingleMsgCommand" + CallbackBeforeSendGroupMsgCommand = "callbackBeforeSendGroupMsgCommand" + CallbackAfterSendGroupMsgCommand = "callbackAfterSendGroupMsgCommand" + CallbackMsgModifyCommand = "callbackMsgModifyCommand" + CallbackUserOnlineCommand = "callbackUserOnlineCommand" + CallbackUserOfflineCommand = "callbackUserOfflineCommand" + CallbackUserKickOffCommand = "callbackUserKickOffCommand" + CallbackOfflinePushCommand = "callbackOfflinePushCommand" + CallbackOnlinePushCommand = "callbackOnlinePushCommand" + CallbackSuperGroupOnlinePushCommand = "callbackSuperGroupOnlinePushCommand" + CallbackBeforeAddFriendCommand = "callbackBeforeAddFriendCommand" + CallbackBeforeCreateGroupCommand = "callbackBeforeCreateGroupCommand" + CallbackBeforeMemberJoinGroupCommand = "callbackBeforeMemberJoinGroupCommand" + CallbackBeforeSetGroupMemberInfoCommand = "CallbackBeforeSetGroupMemberInfoCommand" CallbackBeforeSetMessageReactionExtensionCommand = "callbackBeforeSetMessageReactionExtensionCommand" CallbackBeforeDeleteMessageReactionExtensionsCommand = "callbackBeforeDeleteMessageReactionExtensionsCommand" diff --git a/pkg/common/db/mysql_model/im_mysql_model/friend_model_k.go b/pkg/common/db/mysql_model/im_mysql_model/friend_model_k.go index 19238336e..2f7433fcc 100644 --- a/pkg/common/db/mysql_model/im_mysql_model/friend_model_k.go +++ b/pkg/common/db/mysql_model/im_mysql_model/friend_model_k.go @@ -22,7 +22,7 @@ type Friend struct { func (*Friend) Create(ctx context.Context, friends []*Friend) (err error) { defer func() { - trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), err, "friends", friends) + trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "friends", friends) }() err = utils.Wrap(FriendDB.Create(&friends).Error, "") return err @@ -30,7 +30,7 @@ func (*Friend) Create(ctx context.Context, friends []*Friend) (err error) { func (*Friend) Delete(ctx context.Context, ownerUserID string, friendUserIDs []string) (err error) { defer func() { - trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "friendUserIDs", friendUserIDs) + trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "friendUserIDs", friendUserIDs) }() err = utils.Wrap(FriendDB.Where("owner_user_id = ? and friend_user_id in (?)", ownerUserID, friendUserIDs).Delete(&Friend{}).Error, "") return err @@ -38,21 +38,21 @@ func (*Friend) Delete(ctx context.Context, ownerUserID string, friendUserIDs []s func (*Friend) UpdateByMap(ctx context.Context, ownerUserID string, args map[string]interface{}) (err error) { defer func() { - trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "args", args) + trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "args", args) }() return utils.Wrap(FriendDB.Where("owner_user_id = ?", ownerUserID).Updates(args).Error, "") } func (*Friend) Update(ctx context.Context, friends []*Friend) (err error) { defer func() { - trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), err, "friends", friends) + trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "friends", friends) }() return utils.Wrap(FriendDB.Updates(&friends).Error, "") } func (*Friend) Find(ctx context.Context, ownerUserID string) (friends []*Friend, err error) { defer func() { - trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "friends", friends) + trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "friends", friends) }() err = utils.Wrap(FriendDB.Where("owner_user_id = ?", ownerUserID).Find(&friends).Error, "") return friends, err @@ -60,7 +60,7 @@ func (*Friend) Find(ctx context.Context, ownerUserID string) (friends []*Friend, func (*Friend) Take(ctx context.Context, ownerUserID, friendUserID string) (group *Group, err error) { group = &Group{} - defer trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "friendUserID", friendUserID, "group", *group) + defer trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "ownerUserID", ownerUserID, "friendUserID", friendUserID, "group", *group) err = utils.Wrap(FriendDB.Where("owner_user_id = ? and friend_user_id", ownerUserID, friendUserID).Take(group).Error, "") return group, err } diff --git a/pkg/common/db/mysql_model/im_mysql_model/group_member_model_k.go b/pkg/common/db/mysql_model/im_mysql_model/group_member_model_k.go index 762c7e80a..03ef2b741 100644 --- a/pkg/common/db/mysql_model/im_mysql_model/group_member_model_k.go +++ b/pkg/common/db/mysql_model/im_mysql_model/group_member_model_k.go @@ -29,33 +29,33 @@ type GroupMember struct { func (g *GroupMember) Create(ctx context.Context, groupMemberList []*GroupMember) (err error) { defer func() { - trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "groupMemberList", groupMemberList) + trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupMemberList", groupMemberList) }() return utils.Wrap(GroupMemberDB.Create(&groupMemberList).Error, "") } func (g *GroupMember) Delete(ctx context.Context, groupMembers []*GroupMember) (err error) { defer func() { - trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "groupMembers", groupMembers) + trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupMembers", groupMembers) }() return utils.Wrap(GroupMemberDB.Delete(groupMembers).Error, "") } func (g *GroupMember) UpdateByMap(ctx context.Context, groupID string, userID string, args map[string]interface{}) (err error) { defer func() { - trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "groupID", groupID, "userID", userID, "args", args) + trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "userID", userID, "args", args) }() return utils.Wrap(GroupMemberDB.Model(&GroupMember{}).Where("group_id = ? and user_id = ?", groupID, userID).Updates(args).Error, "") } func (g *GroupMember) Update(ctx context.Context, groupMembers []*GroupMember) (err error) { - defer func() { trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "groupMembers", groupMembers) }() + defer func() { trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupMembers", groupMembers) }() return utils.Wrap(GroupMemberDB.Updates(&groupMembers).Error, "") } func (g *GroupMember) Find(ctx context.Context, groupMembers []*GroupMember) (groupList []*GroupMember, err error) { defer func() { - trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "groupMembers", groupMembers, "groupList", groupList) + trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupMembers", groupMembers, "groupList", groupList) }() var where [][]interface{} for _, groupMember := range groupMembers { @@ -67,7 +67,7 @@ func (g *GroupMember) Find(ctx context.Context, groupMembers []*GroupMember) (gr func (g *GroupMember) Take(ctx context.Context, groupID string, userID string) (groupMember *GroupMember, err error) { defer func() { - trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "groupID", groupID, "userID", userID, "groupMember", *groupMember) + trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "userID", userID, "groupMember", *groupMember) }() groupMember = &GroupMember{} return groupMember, utils.Wrap(GroupMemberDB.Where("group_id = ? and user_id = ?", groupID, userID).Take(groupMember).Error, "") @@ -75,7 +75,7 @@ func (g *GroupMember) Take(ctx context.Context, groupID string, userID string) ( func (g *GroupMember) TakeOwnerInfo(ctx context.Context, groupID string) (groupMember *GroupMember, err error) { defer func() { - trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "groupID", groupID, "groupMember", *groupMember) + trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "groupMember", *groupMember) }() groupMember = &GroupMember{} err = GroupMemberDB.Where("group_id = ? and role_level = ?", groupID, constant.GroupOwner).Take(groupMember).Error diff --git a/pkg/common/db/mysql_model/im_mysql_model/group_model_k.go b/pkg/common/db/mysql_model/im_mysql_model/group_model_k.go index de4e28a78..60eab444e 100644 --- a/pkg/common/db/mysql_model/im_mysql_model/group_model_k.go +++ b/pkg/common/db/mysql_model/im_mysql_model/group_model_k.go @@ -30,7 +30,7 @@ type Group struct { func (*Group) Create(ctx context.Context, groups []*Group) (err error) { defer func() { - trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "groups", groups) + trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groups", groups) }() err = utils.Wrap(GroupDB.Create(&groups).Error, "") return err @@ -38,28 +38,28 @@ func (*Group) Create(ctx context.Context, groups []*Group) (err error) { func (*Group) Delete(ctx context.Context, groupIDs []string) (err error) { defer func() { - trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "groupIDs", groupIDs) + trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupIDs", groupIDs) }() return utils.Wrap(GroupDB.Where("group_id in (?)", groupIDs).Delete(&Group{}).Error, "") } func (*Group) UpdateByMap(ctx context.Context, groupID string, args map[string]interface{}) (err error) { defer func() { - trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "groupID", groupID, "args", args) + trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "args", args) }() return utils.Wrap(GroupDB.Where("group_id = ?", groupID).Updates(args).Error, "") } func (*Group) Update(ctx context.Context, groups []*Group) (err error) { defer func() { - trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "groups", groups) + trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groups", groups) }() return utils.Wrap(GroupDB.Updates(&groups).Error, "") } func (*Group) Find(ctx context.Context, groupIDs []string) (groupList []*Group, err error) { defer func() { - trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "groupIDList", groupIDs, "groupList", groupList) + trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupIDList", groupIDs, "groupList", groupList) }() err = utils.Wrap(GroupDB.Where("group_id in (?)", groupIDs).Find(&groupList).Error, "") return groupList, err @@ -68,7 +68,7 @@ func (*Group) Find(ctx context.Context, groupIDs []string) (groupList []*Group, func (*Group) Take(ctx context.Context, groupID string) (group *Group, err error) { group = &Group{} defer func() { - trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "groupID", groupID, "group", *group) + trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "group", *group) }() err = utils.Wrap(GroupDB.Where("group_id = ?", groupID).Take(group).Error, "") return group, err diff --git a/pkg/common/db/mysql_model/im_mysql_model/group_request_model_k.go b/pkg/common/db/mysql_model/im_mysql_model/group_request_model_k.go index 871578a6c..2cda93fee 100644 --- a/pkg/common/db/mysql_model/im_mysql_model/group_request_model_k.go +++ b/pkg/common/db/mysql_model/im_mysql_model/group_request_model_k.go @@ -27,35 +27,35 @@ type GroupRequest struct { func (*GroupRequest) Create(ctx context.Context, groupRequests []*GroupRequest) (err error) { defer func() { - trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), err, "groupRequests", groupRequests) + trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), 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.SetContextInfo(ctx, utils.GetSelfFuncName(), err, "groupRequests", groupRequests) + trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), 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.SetContextInfo(ctx, utils.GetSelfFuncName(), err, "groupID", groupID, "userID", userID, "args", args) + trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), 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.SetContextInfo(ctx, utils.GetSelfFuncName(), err, "groupRequests", groupRequests) + trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), 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.SetContextInfo(ctx, utils.GetSelfFuncName(), err, "groupRequests", groupRequests, "resultGroupRequests", resultGroupRequests) + trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "groupRequests", groupRequests, "resultGroupRequests", resultGroupRequests) }() var where [][]interface{} for _, groupMember := range groupRequests { @@ -67,7 +67,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.SetContextInfo(ctx, utils.GetSelfFuncName(), err, "groupID", groupID, "userID", userID, "groupRequest", *groupRequest) + trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), 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()) } diff --git a/pkg/common/db/mysql_model/im_mysql_model/user_black_list_model.go b/pkg/common/db/mysql_model/im_mysql_model/user_black_list_model.go index 3b676538d..9cd4dd586 100644 --- a/pkg/common/db/mysql_model/im_mysql_model/user_black_list_model.go +++ b/pkg/common/db/mysql_model/im_mysql_model/user_black_list_model.go @@ -20,7 +20,7 @@ type Black struct { } func InsertInToUserBlackList(ctx context.Context, black Black) (err error) { - defer trace_log.SetContextInfo(ctx, utils.GetSelfFuncName(), err, "black", black) + defer trace_log.SetCtxDebug(ctx, utils.GetSelfFuncName(), err, "black", black) black.CreateTime = time.Now() err = BlackDB.Create(black).Error return err diff --git a/pkg/common/db/rocks_cache/rocks_cache.go b/pkg/common/db/rocks_cache/rocks_cache.go index 8bfe2a2f8..639377562 100644 --- a/pkg/common/db/rocks_cache/rocks_cache.go +++ b/pkg/common/db/rocks_cache/rocks_cache.go @@ -83,7 +83,7 @@ func GetFriendIDListFromCache(ctx context.Context, userID string) (friendIDList return string(bytes), nil } defer func() { - trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "userID", userID, "friendIDList", friendIDList) + trace_log.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 { @@ -95,7 +95,7 @@ func GetFriendIDListFromCache(ctx context.Context, userID string) (friendIDList func DelFriendIDListFromCache(ctx context.Context, userID string) (err error) { defer func() { - trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "userID", userID) + trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID) }() return db.DB.Rc.TagAsDeleted(friendRelationCache + userID) } @@ -113,7 +113,7 @@ func GetBlackListFromCache(ctx context.Context, userID string) (blackIDList []st return string(bytes), nil } defer func() { - trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "userID", userID, "blackIDList", blackIDList) + trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID, "blackIDList", blackIDList) }() blackIDListStr, err := db.DB.Rc.Fetch(blackListCache+userID, time.Second*30*60, getBlackIDList) if err != nil { @@ -125,7 +125,7 @@ func GetBlackListFromCache(ctx context.Context, userID string) (blackIDList []st func DelBlackIDListFromCache(ctx context.Context, userID string) (err error) { defer func() { - trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "ctx", ctx) + trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "ctx", ctx) }() return db.DB.Rc.TagAsDeleted(blackListCache + userID) } @@ -143,7 +143,7 @@ func GetJoinedGroupIDListFromCache(ctx context.Context, userID string) (joinedGr return string(bytes), nil } defer func() { - trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "userID", userID, "joinedGroupList", joinedGroupList) + trace_log.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 { @@ -155,7 +155,7 @@ func GetJoinedGroupIDListFromCache(ctx context.Context, userID string) (joinedGr func DelJoinedGroupIDListFromCache(ctx context.Context, userID string) (err error) { defer func() { - trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "userID", userID) + trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID) }() return db.DB.Rc.TagAsDeleted(joinedGroupListCache + userID) } @@ -186,7 +186,7 @@ func GetGroupMemberIDListFromCache(ctx context.Context, groupID string) (groupMe return string(bytes), nil } defer func() { - trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "groupID", groupID, "groupMemberIDList", groupMemberIDList) + trace_log.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 { @@ -198,7 +198,7 @@ func GetGroupMemberIDListFromCache(ctx context.Context, groupID string) (groupMe func DelGroupMemberIDListFromCache(ctx context.Context, groupID string) (err error) { defer func() { - trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "groupID", groupID) + trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID) }() return db.DB.Rc.TagAsDeleted(groupCache + groupID) } @@ -216,7 +216,7 @@ func GetUserInfoFromCache(ctx context.Context, userID string) (userInfo *imdb.Us return string(bytes), nil } defer func() { - trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "userID", userID, "userInfo", *userInfo) + trace_log.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 { @@ -241,7 +241,7 @@ func GetUserInfoFromCacheBatch(ctx context.Context, userIDs []string) ([]*imdb.U func DelUserInfoFromCache(ctx context.Context, userID string) (err error) { defer func() { - trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "userID", userID) + trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID) }() return db.DB.Rc.TagAsDeleted(userInfoCache + userID) } @@ -259,7 +259,7 @@ func GetGroupMemberInfoFromCache(ctx context.Context, groupID, userID string) (g return string(bytes), nil } defer func() { - trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "groupID", groupID, "userID", userID, "groupMember", *groupMember) + trace_log.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 { @@ -272,14 +272,14 @@ func GetGroupMemberInfoFromCache(ctx context.Context, groupID, userID string) (g func DelGroupMemberInfoFromCache(ctx context.Context, groupID, userID string) (err error) { defer func() { - trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "groupID", groupID, "userID", userID) + trace_log.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 []*imdb.GroupMember, err error) { defer func() { - trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "count", count, "offset", offset, "groupID", groupID, "groupMember", groupMembers) + trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "count", count, "offset", offset, "groupID", groupID, "groupMember", groupMembers) }() groupMemberIDList, err := GetGroupMemberIDListFromCache(ctx, groupID) if err != nil { @@ -326,7 +326,7 @@ func GetGroupMembersInfoFromCache(ctx context.Context, count, offset int32, grou func GetAllGroupMembersInfoFromCache(ctx context.Context, groupID string) (groupMembers []*imdb.GroupMember, err error) { defer func() { - trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "groupID", groupID, "groupMembers", groupMembers) + trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "groupMembers", groupMembers) }() getGroupMemberInfo := func() (string, error) { groupMembers, err := imdb.GetGroupMemberListByGroupID(groupID) @@ -349,7 +349,7 @@ func GetAllGroupMembersInfoFromCache(ctx context.Context, groupID string) (group func DelAllGroupMembersInfoFromCache(ctx context.Context, groupID string) (err error) { defer func() { - trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "groupID", groupID) + trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID) }() return db.DB.Rc.TagAsDeleted(groupAllMemberInfoCache + groupID) } @@ -368,7 +368,7 @@ func GetGroupInfoFromCache(ctx context.Context, groupID string) (groupInfo *imdb } groupInfo = &imdb.Group{} defer func() { - trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "groupID", groupID, "groupInfo", groupInfo) + trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID, "groupInfo", groupInfo) }() groupInfoStr, err := db.DB.Rc.Fetch(groupInfoCache+groupID, time.Second*30*60, getGroupInfo) if err != nil { @@ -380,7 +380,7 @@ func GetGroupInfoFromCache(ctx context.Context, groupID string) (groupInfo *imdb func DelGroupInfoFromCache(ctx context.Context, groupID string) (err error) { defer func() { - trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "groupID", groupID) + trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID) }() return db.DB.Rc.TagAsDeleted(groupInfoCache + groupID) } @@ -398,7 +398,7 @@ func GetAllFriendsInfoFromCache(ctx context.Context, userID string) (friends []* return string(bytes), nil } defer func() { - trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "userID", userID, "friends", friends) + trace_log.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 { @@ -410,7 +410,7 @@ func GetAllFriendsInfoFromCache(ctx context.Context, userID string) (friends []* func DelAllFriendsInfoFromCache(ctx context.Context, userID string) (err error) { defer func() { - trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "userID", userID) + trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID) }() return db.DB.Rc.TagAsDeleted(allFriendInfoCache + userID) } @@ -478,7 +478,7 @@ func GetJoinedSuperGroupListFromCache(ctx context.Context, userID string) (joine return string(bytes), nil } defer func() { - trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "userID", userID, "joinedSuperGroupIDs", joinedSuperGroupIDs) + trace_log.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 { @@ -490,7 +490,7 @@ func GetJoinedSuperGroupListFromCache(ctx context.Context, userID string) (joine func DelJoinedSuperGroupIDListFromCache(ctx context.Context, userID string) (err error) { defer func() { - trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "userID", userID) + trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID) }() return db.DB.Rc.TagAsDeleted(joinedSuperGroupListCache + userID) } @@ -518,7 +518,7 @@ func GetGroupMemberListHashFromCache(ctx context.Context, groupID string) (hashC return strconv.Itoa(int(bi.Uint64())), nil } defer func() { - trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "groupID", groupID, "hashCodeUint64", hashCodeUint64) + trace_log.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 { @@ -530,7 +530,7 @@ func GetGroupMemberListHashFromCache(ctx context.Context, groupID string) (hashC func DelGroupMemberListHashFromCache(ctx context.Context, groupID string) (err error) { defer func() { - trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "groupID", groupID) + trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID) }() return db.DB.Rc.TagAsDeleted(groupMemberListHashCache + groupID) } @@ -544,7 +544,7 @@ func GetGroupMemberNumFromCache(ctx context.Context, groupID string) (num int, e return strconv.Itoa(int(num)), nil } defer func() { - trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "groupID", groupID, "num", num) + trace_log.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 { @@ -555,7 +555,7 @@ func GetGroupMemberNumFromCache(ctx context.Context, groupID string) (num int, e func DelGroupMemberNumFromCache(ctx context.Context, groupID string) (err error) { defer func() { - trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "groupID", groupID) + trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "groupID", groupID) }() return db.DB.Rc.TagAsDeleted(groupMemberNumCache + groupID) } @@ -574,7 +574,7 @@ func GetUserConversationIDListFromCache(ctx context.Context, userID string) (con return string(bytes), nil } defer func() { - trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "userID", userID, "conversationIDs", conversationIDs) + trace_log.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) @@ -586,7 +586,7 @@ func GetUserConversationIDListFromCache(ctx context.Context, userID string) (con func DelUserConversationIDListFromCache(ctx context.Context, userID string) (err error) { defer func() { - trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "userID", userID) + trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "userID", userID) }() return utils.Wrap(db.DB.Rc.TagAsDeleted(conversationIDListCache+userID), "DelUserConversationIDListFromCache err") } @@ -604,7 +604,7 @@ func GetConversationFromCache(ctx context.Context, ownerUserID, conversationID s return string(bytes), nil } defer func() { - trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "ownerUserID", ownerUserID, "conversationID", conversationID, "conversation", *conversation) + trace_log.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 { @@ -617,7 +617,7 @@ func GetConversationFromCache(ctx context.Context, ownerUserID, conversationID s func GetConversationsFromCache(ctx context.Context, ownerUserID string, conversationIDs []string) (conversations []imdb.Conversation, err error) { defer func() { - trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "ownerUserID", ownerUserID, "conversationIDs", conversationIDs, "conversations", conversations) + trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "ownerUserID", ownerUserID, "conversationIDs", conversationIDs, "conversations", conversations) }() for _, conversationID := range conversationIDs { conversation, err := GetConversationFromCache(ctx, ownerUserID, conversationID) @@ -631,7 +631,7 @@ func GetConversationsFromCache(ctx context.Context, ownerUserID string, conversa func GetUserAllConversationList(ctx context.Context, ownerUserID string) (conversations []imdb.Conversation, err error) { defer func() { - trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "ownerUserID", ownerUserID, "conversations", conversations) + trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "ownerUserID", ownerUserID, "conversations", conversations) }() IDList, err := GetUserConversationIDListFromCache(ctx, ownerUserID) if err != nil { @@ -651,7 +651,7 @@ func GetUserAllConversationList(ctx context.Context, ownerUserID string) (conver func DelConversationFromCache(ctx context.Context, ownerUserID, conversationID string) (err error) { defer func() { - trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "ownerUserID", ownerUserID, "conversationID", conversationID) + trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "ownerUserID", ownerUserID, "conversationID", conversationID) }() return utils.Wrap(db.DB.Rc.TagAsDeleted(conversationCache+ownerUserID+":"+conversationID), "DelConversationFromCache err") } @@ -669,7 +669,7 @@ func GetExtendMsg(ctx context.Context, sourceID string, sessionType int32, clien return string(bytes), nil } defer func() { - trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "sourceID", sourceID, "sessionType", + trace_log.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) @@ -683,7 +683,7 @@ func GetExtendMsg(ctx context.Context, sourceID string, sessionType int32, clien func DelExtendMsg(ctx context.Context, clientMsgID string) (err error) { defer func() { - trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "clientMsgID", clientMsgID) + trace_log.SetCtxDebug(ctx, utils.GetFuncName(1), err, "clientMsgID", clientMsgID) }() return utils.Wrap(db.DB.Rc.TagAsDeleted(extendMsgCache+clientMsgID), "DelExtendMsg err") } diff --git a/pkg/common/log/logrus.go b/pkg/common/log/logrus.go index 9d65719c7..2c3c56fa1 100644 --- a/pkg/common/log/logrus.go +++ b/pkg/common/log/logrus.go @@ -2,7 +2,9 @@ package log import ( "Open_IM/pkg/common/config" + "Open_IM/pkg/common/trace_log" "bufio" + "context" //"bufio" "fmt" @@ -16,6 +18,7 @@ import ( ) var logger *Logger +var ctxLogger *Logger type Logger struct { *logrus.Logger @@ -24,12 +27,35 @@ type Logger struct { func init() { logger = loggerInit("") - + ctxLogger = ctxLoggerInit("") } + func NewPrivateLog(moduleName string) { logger = loggerInit(moduleName) } +func ctxLoggerInit(moduleName string) *Logger { + var ctxLogger = logrus.New() + ctxLogger.SetLevel(logrus.Level(config.Config.Log.RemainLogLevel)) + src, err := os.OpenFile(os.DevNull, os.O_APPEND|os.O_WRONLY, os.ModeAppend) + if err != nil { + panic(err.Error()) + } + writer := bufio.NewWriter(src) + ctxLogger.SetOutput(writer) + ctxLogger.SetFormatter(&logrus.JSONFormatter{ + TimestampFormat: "2006-01-02 15:04:05.000", + DataKey: "args", + FieldMap: nil, + CallerPrettyfier: nil, + PrettyPrint: false, + }) + return &Logger{ + ctxLogger, + os.Getpid(), + } +} + func loggerInit(moduleName string) *Logger { var logger = logrus.New() //All logs will be printed @@ -44,11 +70,13 @@ func loggerInit(moduleName string) *Logger { logger.SetOutput(writer) // logger.SetOutput(os.Stdout) //Log Console Print Style Setting + logger.SetFormatter(&nested.Formatter{ TimestampFormat: "2006-01-02 15:04:05.000", HideKeys: false, FieldsOrder: []string{"PID", "FilePath", "OperationID"}, }) + //File name and line number display hook logger.AddHook(newFileHook()) @@ -200,3 +228,95 @@ func NewWarn(OperationID string, args ...interface{}) { "PID": logger.Pid, }).Warnln(args) } + +func ShowLog(ctx context.Context) { + t := ctx.Value(trace_log.TraceLogKey).(*trace_log.ApiInfo) + OperationID := trace_log.GetOperationID(ctx) + if ctx.Value(trace_log.TraceLogKey).(*trace_log.ApiInfo).GinCtx != nil { + ctxLogger.WithFields(logrus.Fields{ + "OperationID": OperationID, + "PID": ctxLogger.Pid, + }).Infoln("api: ", t.ApiName) + } else { + ctxLogger.WithFields(logrus.Fields{ + "OperationID": OperationID, + "PID": ctxLogger.Pid, + }).Infoln("rpc: ", t.ApiName) + } + for _, v := range *t.Funcs { + if v.Err != nil { + ctxLogger.WithFields(logrus.Fields{ + "OperationID": OperationID, + "PID": ctxLogger.Pid, + "FilePath": v.File, + }).Errorln("func: ", v.FuncName, " args: ", v.Args, v.Err.Error()) + } else { + switch v.LogLevel { + case logrus.InfoLevel: + ctxLogger.WithFields(logrus.Fields{ + "OperationID": OperationID, + "PID": ctxLogger.Pid, + "FilePath": v.File, + }).Infoln("func: ", v.FuncName, " args: ", v.Args) + case logrus.DebugLevel: + ctxLogger.WithFields(logrus.Fields{ + "OperationID": OperationID, + "PID": ctxLogger.Pid, + "FilePath": v.File, + }).Debugln("func: ", v.FuncName, " args: ", v.Args) + case logrus.WarnLevel: + ctxLogger.WithFields(logrus.Fields{ + "OperationID": OperationID, + "PID": ctxLogger.Pid, + "FilePath": v.File, + }).Warnln("func: ", v.FuncName, " args: ", v.Args) + } + } + } +} + +func InfoWithCtx(ctx context.Context, args ...interface{}) { + t := ctx.Value(trace_log.TraceLogKey).(*trace_log.ApiInfo) + OperationID := trace_log.GetOperationID(ctx) + for _, v := range *t.Funcs { + logger.WithFields(logrus.Fields{ + "OperationID": OperationID, + "PID": logger.Pid, + }).Infoln(v.Args, args) + } +} + +func DebugWithCtx(ctx context.Context, args ...interface{}) { + t := ctx.Value(trace_log.TraceLogKey).(*trace_log.ApiInfo) + OperationID := trace_log.GetOperationID(ctx) + for _, v := range *t.Funcs { + logger.WithFields(logrus.Fields{ + "OperationID": OperationID, + "PID": logger.Pid, + }).Debugln(v.Args, args) + } +} + +func ErrorWithCtx(ctx context.Context, args ...interface{}) { + t := ctx.Value(trace_log.TraceLogKey).(*trace_log.ApiInfo) + OperationID := trace_log.GetOperationID(ctx) + for _, v := range *t.Funcs { + if v.Err != nil { + logger.WithFields(logrus.Fields{ + "OperationID": OperationID, + "PID": logger.Pid, + }).Errorln(v.Err, v.Args, args) + } + } +} + +func WarnWithCtx(ctx context.Context, args ...interface{}) { + t := ctx.Value(trace_log.TraceLogKey).(*trace_log.ApiInfo) + OperationID := trace_log.GetOperationID(ctx) + for _, v := range *t.Funcs { + logger.WithFields(logrus.Fields{ + "OperationID": OperationID, + "PID": logger.Pid, + }).Warnln(v.Args, args) + } +} diff --git a/pkg/common/middleware/rpc.go b/pkg/common/middleware/rpc.go index de4f9a46d..a97e6c3a0 100644 --- a/pkg/common/middleware/rpc.go +++ b/pkg/common/middleware/rpc.go @@ -40,11 +40,11 @@ func RpcServerInterceptor(ctx context.Context, req interface{}, info *grpc.Unary opUserID = opts[0] } ctx = trace_log.NewRpcCtx(ctx, funcName, operationID) - defer trace_log.ShowLog(ctx) - trace_log.SetContextInfo(ctx, funcName, err, "opUserID", opUserID, "rpcReq", rpcString(req)) + defer log.ShowLog(ctx) + trace_log.SetCtxInfo(ctx, funcName, err, "opUserID", opUserID, "rpcReq", rpcString(req)) resp, err = handler(ctx, req) if err != nil { - trace_log.SetContextInfo(ctx, funcName, err) + trace_log.SetCtxInfo(ctx, funcName, err) errInfo := constant.ToAPIErrWithErr(err) var code codes.Code if errInfo.ErrCode == 0 { @@ -58,7 +58,7 @@ func RpcServerInterceptor(ctx context.Context, req interface{}, info *grpc.Unary } return nil, sta.Err() } - trace_log.SetContextInfo(ctx, funcName, nil, "rpcResp", rpcString(resp)) + trace_log.SetCtxInfo(ctx, funcName, nil, "rpcResp", rpcString(resp)) return } diff --git a/pkg/common/token_verify/jwt_token.go b/pkg/common/token_verify/jwt_token.go index 0b041f5a8..49acb8e90 100644 --- a/pkg/common/token_verify/jwt_token.go +++ b/pkg/common/token_verify/jwt_token.go @@ -154,7 +154,7 @@ func CheckAccess(ctx context.Context, OpUserID string, OwnerUserID string) bool func CheckAccessV2(ctx context.Context, OpUserID string, OwnerUserID string) (err error) { defer func() { - trace_log.SetContextInfo(ctx, utils.GetFuncName(1), err, "OpUserID", OpUserID, "OwnerUserID", OwnerUserID) + trace_log.SetCtxInfo(ctx, utils.GetFuncName(1), err, "OpUserID", OpUserID, "OwnerUserID", OwnerUserID) }() if utils.IsContain(OpUserID, config.Config.Manager.AppManagerUid) { return nil diff --git a/pkg/common/trace_log/ctx.go b/pkg/common/trace_log/ctx.go index db264491e..e515a1a7a 100644 --- a/pkg/common/trace_log/ctx.go +++ b/pkg/common/trace_log/ctx.go @@ -3,8 +3,11 @@ package trace_log import ( "Open_IM/pkg/common/constant" "Open_IM/pkg/common/log" + "Open_IM/pkg/utils" "context" + "github.com/sirupsen/logrus" "google.golang.org/grpc/status" + "runtime" "strings" //"errors" @@ -47,18 +50,24 @@ func ShowLog(ctx context.Context) { } else { log.Info(t.OperationID, "rpc: ", t.ApiName) } - for _, v := range *t.Funcs { if v.Err != nil { log.Error(t.OperationID, "func: ", v.FuncName, " args: ", v.Args, v.Err.Error()) } else { - log.Info(t.OperationID, "func: ", v.FuncName, " args: ", v.Args) + switch v.LogLevel { + case logrus.InfoLevel: + log.Info(t.OperationID, "func: ", v.FuncName, " args: ", v.Args) + case logrus.DebugLevel: + log.Debug(t.OperationID, "func: ", v.FuncName, " args: ", v.Args) + case logrus.WarnLevel: + log.Debug(t.OperationID, "func: ", v.FuncName, " args: ", v.Args) + } } } } func WriteErrorResponse(ctx context.Context, funcName string, err error, args ...interface{}) { - SetContextInfo(ctx, funcName, err, args) + SetCtxInfo(ctx, funcName, err, args) e := Unwrap(err) switch t := e.(type) { case *constant.ErrInfo: @@ -83,7 +92,7 @@ func WriteErrorResponse(ctx context.Context, funcName string, err error, args .. } //func WriteErrorResponse(ctx context.Context, funcName string, err error, args ...interface{}) { -// SetContextInfo(ctx, funcName, err, args) +// SetCtxInfo(ctx, funcName, err, args) // e := new(constant.ErrInfo) // switch { // case errors.As(err, &e): @@ -119,6 +128,8 @@ type FuncInfo struct { FuncName string Args Args Err error + LogLevel logrus.Level + File string } type Args map[string]interface{} @@ -139,13 +150,32 @@ func (a Args) String() string { return s } -func SetContextInfo(ctx context.Context, funcName string, err error, args ...interface{}) { +func SetCtxDebug(ctx context.Context, funcName string, err error, args ...interface{}) { + SetContextInfo(ctx, funcName, logrus.DebugLevel, err, args) +} + +func SetCtxInfo(ctx context.Context, funcName string, err error, args ...interface{}) { + SetContextInfo(ctx, funcName, logrus.InfoLevel, err, args) +} + +func SetCtxWarn(ctx context.Context, funcName string, err error, args ...interface{}) { + SetContextInfo(ctx, funcName, logrus.WarnLevel, err, args) +} + +func SetContextInfo(ctx context.Context, funcName string, logLevel logrus.Level, err error, args ...interface{}) { t := ctx.Value(TraceLogKey).(*ApiInfo) var funcInfo FuncInfo funcInfo.Args = make(map[string]interface{}) argsHandle(args, funcInfo.Args) funcInfo.FuncName = funcName funcInfo.Err = err + funcInfo.LogLevel = logLevel + _, file, line, _ := runtime.Caller(2) + i := strings.SplitAfter(file, "/") + if len(i) > 3 { + file = i[len(i)-3] + i[len(i)-2] + i[len(i)-1] + ":" + utils.IntToString(line) + } + funcInfo.File = file *t.Funcs = append(*t.Funcs, funcInfo) } @@ -172,7 +202,7 @@ func SetRpcRespInfo(ctx context.Context, funcName string, resp string) { } func SetSuccess(ctx context.Context, funcName string, data interface{}) { - SetContextInfo(ctx, funcName, nil, "data", data) + SetCtxInfo(ctx, funcName, nil, "data", data) ctx.Value(TraceLogKey).(*ApiInfo).GinCtx.JSON(http.StatusOK, gin.H{"errCode": 0, "errMsg": "", "errDtl": "", "data": data}) } @@ -185,8 +215,3 @@ func argsHandle(args []interface{}, fields map[string]interface{}) { } } } - -func GetApiErr(errCode int32, errMsg string) constant.ErrInfo { - - return constant.ErrInfo{ErrCode: errCode, ErrMsg: errMsg} -} diff --git a/pkg/getcdv3/temp.go b/pkg/getcdv3/temp.go index 373870985..3e680f023 100644 --- a/pkg/getcdv3/temp.go +++ b/pkg/getcdv3/temp.go @@ -16,7 +16,7 @@ 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.SetContextInfo(ctx, "GetConn", err, "serviceName", serviceName) + trace_log.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)