blackteay/open-im-server
1
0
Fork 0
mirror of https://github.com/openimsdk/open-im-server.git synced 2025-04-24 02:16:16 +08:00
Code Issues Packages Projects Releases Wiki Activity

log

Browse Source
This commit is contained in:
wangchuxiao 2023-01-12 15:55:44 +08:00
parent 47766a2c2c
commit 6205c67b70
17 changed files with 284 additions and 181 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
internal/api/group/group.go
View File

@ -997,14 +997,14 @@ func MuteGroupMember(c *gin.Context) {
// @Router /group/cancel_mute_group_member [post] // @Router /group/cancel_mute_group_member [post]
func CancelMuteGroupMember(c *gin.Context) { func CancelMuteGroupMember(c *gin.Context) {
nCtx := trace_log.NewCtx(c, utils.GetSelfFuncName()) nCtx := trace_log.NewCtx(c, utils.GetSelfFuncName())
defer trace_log.ShowLog(c) defer log.ShowLog(c)
params := api.CancelMuteGroupMemberReq{} params := api.CancelMuteGroupMemberReq{}
if err := c.BindJSON(&params); err != nil { if err := c.BindJSON(&params); err != nil {
trace_log.WriteErrorResponse(nCtx, "BindJSON", err) trace_log.WriteErrorResponse(nCtx, "BindJSON", err)
return return
} }
trace_log.SetContextInfo(nCtx, "BindJSON", nil, "params", params) trace_log.SetCtxInfo(nCtx, "BindJSON", nil, "params", params)
req := &rpc.CancelMuteGroupMemberReq{} req := &rpc.CancelMuteGroupMemberReq{}
utils.CopyStructFields(req, &params) utils.CopyStructFields(req, &params)
@ -1013,7 +1013,7 @@ func CancelMuteGroupMember(c *gin.Context) {
// trace_log.WriteErrorResponse(nCtx, "ParseUserIDFromToken", err) // trace_log.WriteErrorResponse(nCtx, "ParseUserIDFromToken", err)
// return // 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) 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 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}} resp := api.CancelMuteGroupMemberResp{CommResp: api.CommResp{ErrCode: reply.CommonResp.ErrCode, ErrMsg: reply.CommonResp.ErrMsg}}
c.JSON(http.StatusOK, resp) c.JSON(http.StatusOK, resp)
} }

15
internal/api_to_rpc/api.go
View File

@ -1,6 +1,7 @@
package common package common
import ( import (
"Open_IM/pkg/common/log"
"Open_IM/pkg/common/trace_log" "Open_IM/pkg/common/trace_log"
"Open_IM/pkg/getcdv3" "Open_IM/pkg/getcdv3"
utils2 "Open_IM/pkg/utils" 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) logFuncName := fmt.Sprintf("[ApiToRpc: %s]%s", utils2.GetFuncName(1), rpcFuncName)
operationID := c.GetHeader("operationID") operationID := c.GetHeader("operationID")
nCtx := trace_log.NewCtx1(c, rpcFuncName, operationID) nCtx := trace_log.NewCtx1(c, rpcFuncName, operationID)
defer trace_log.ShowLog(nCtx) defer log.ShowLog(nCtx)
if err := c.BindJSON(apiReq); err != nil { if err := c.BindJSON(apiReq); err != nil {
trace_log.WriteErrorResponse(nCtx, "BindJSON", err) trace_log.WriteErrorResponse(nCtx, "BindJSON", err)
return return
} }
trace_log.SetContextInfo(nCtx, logFuncName, nil, "apiReq", apiReq) trace_log.SetCtxInfo(nCtx, logFuncName, nil, "apiReq", apiReq)
etcdConn, err := getcdv3.GetConn(nCtx, rpcName) etcdConn, err := getcdv3.GetConn(nCtx, rpcName)
if err != nil { if err != nil {
trace_log.WriteErrorResponse(nCtx, "GetDefaultConn", err) 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) trace_log.WriteErrorResponse(nCtx, "CopyStructFields_RpcReq", err)
return 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) md := metadata.Pairs("operationID", operationID, "opUserID", opUserID)
respArr := rpc.Call([]reflect.Value{ respArr := rpc.Call([]reflect.Value{
reflect.ValueOf(metadata.NewOutgoingContext(c, md)), // context.Context reflect.ValueOf(metadata.NewOutgoingContext(c, md)), // context.Context
@ -55,10 +56,10 @@ func ApiToRpc(c *gin.Context, apiReq, apiResp interface{}, rpcName string, rpcCl
return return
} }
rpcResp := respArr[0].Elem() 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 apiResp != nil {
if err := utils.CopyStructFields(apiResp, rpcResp.Interface()); err != 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) trace_log.SetSuccess(nCtx, rpcFuncName, apiResp)
@ -81,7 +82,7 @@ func rpcString(v interface{}) string {
// reqValue := reflect.ValueOf(apiReq).Elem() // reqValue := reflect.ValueOf(apiReq).Elem()
// operationID := reqValue.FieldByName("OperationID").String() // operationID := reqValue.FieldByName("OperationID").String()
// trace_log.SetOperationID(nCtx, operationID) // 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) // etcdConn, err := utils2.GetConn(c, rpcName)
// if err != nil { // if err != nil {
// trace_log.WriteErrorResponse(nCtx, "GetDefaultConn", err) // trace_log.WriteErrorResponse(nCtx, "GetDefaultConn", err)
@ -124,7 +125,7 @@ func rpcString(v interface{}) string {
// return // return
// } // }
// rpcResp := respArr[0].Elem() // 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() // commonResp := rpcResp.FieldByName("CommonResp").Elem()
// errCodeVal := commonResp.FieldByName("ErrCode") // errCodeVal := commonResp.FieldByName("ErrCode")
// errMsgVal := commonResp.FieldByName("ErrMsg").Interface().(string) // errMsgVal := commonResp.FieldByName("ErrMsg").Interface().(string)

57
internal/rpc/cache/cache.go vendored
View File

@ -6,9 +6,7 @@ import (
rocksCache "Open_IM/pkg/common/db/rocks_cache" rocksCache "Open_IM/pkg/common/db/rocks_cache"
"Open_IM/pkg/common/log" "Open_IM/pkg/common/log"
promePkg "Open_IM/pkg/common/prometheus" promePkg "Open_IM/pkg/common/prometheus"
"Open_IM/pkg/common/trace_log"
pbCache "Open_IM/pkg/proto/cache" pbCache "Open_IM/pkg/proto/cache"
sdkws "Open_IM/pkg/proto/sdk_ws"
"Open_IM/pkg/utils" "Open_IM/pkg/utils"
"context" "context"
"github.com/OpenIMSDK/getcdv3" "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) { func (s *cacheServer) GetFriendIDListFromCache(ctx context.Context, req *pbCache.GetFriendIDListFromCacheReq) (resp *pbCache.GetFriendIDListFromCacheResp, err error) {
resp = &pbCache.GetFriendIDListFromCacheResp{CommonResp: &sdkws.CommonResp{}} resp = &pbCache.GetFriendIDListFromCacheResp{}
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)
}()
friendIDList, err := rocksCache.GetFriendIDListFromCache(ctx, req.UserID) friendIDList, err := rocksCache.GetFriendIDListFromCache(ctx, req.UserID)
if err != nil { if err != nil {
constant.SetErrorForResp(err, resp.CommonResp)
return return
} }
resp.UserIDList = friendIDList resp.UserIDList = friendIDList
@ -109,14 +101,8 @@ func (s *cacheServer) GetFriendIDListFromCache(ctx context.Context, req *pbCache
// this is for dtm call // this is for dtm call
func (s *cacheServer) DelFriendIDListFromCache(ctx context.Context, req *pbCache.DelFriendIDListFromCacheReq) (resp *pbCache.DelFriendIDListFromCacheResp, err error) { func (s *cacheServer) DelFriendIDListFromCache(ctx context.Context, req *pbCache.DelFriendIDListFromCacheReq) (resp *pbCache.DelFriendIDListFromCacheResp, err error) {
resp = &pbCache.DelFriendIDListFromCacheResp{CommonResp: &sdkws.CommonResp{}} resp = &pbCache.DelFriendIDListFromCacheResp{}
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)
}()
if err := rocksCache.DelFriendIDListFromCache(ctx, req.UserID); err != nil { if err := rocksCache.DelFriendIDListFromCache(ctx, req.UserID); err != nil {
constant.SetErrorForResp(err, resp.CommonResp)
return return
} }
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", resp.String()) 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) { func (s *cacheServer) GetBlackIDListFromCache(ctx context.Context, req *pbCache.GetBlackIDListFromCacheReq) (resp *pbCache.GetBlackIDListFromCacheResp, err error) {
resp = &pbCache.GetBlackIDListFromCacheResp{CommonResp: &sdkws.CommonResp{}} resp = &pbCache.GetBlackIDListFromCacheResp{}
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)
}()
blackUserIDList, err := rocksCache.GetBlackListFromCache(ctx, req.UserID) blackUserIDList, err := rocksCache.GetBlackListFromCache(ctx, req.UserID)
if err != nil { if err != nil {
constant.SetErrorForResp(err, resp.CommonResp)
return return
} }
resp.UserIDList = blackUserIDList 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) { func (s *cacheServer) DelBlackIDListFromCache(ctx context.Context, req *pbCache.DelBlackIDListFromCacheReq) (resp *pbCache.DelBlackIDListFromCacheResp, err error) {
resp = &pbCache.DelBlackIDListFromCacheResp{CommonResp: &sdkws.CommonResp{}} resp = &pbCache.DelBlackIDListFromCacheResp{}
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)
}()
if err := rocksCache.DelBlackIDListFromCache(ctx, req.UserID); err != nil { if err := rocksCache.DelBlackIDListFromCache(ctx, req.UserID); err != nil {
constant.SetErrorForResp(err, resp.CommonResp)
return return
} }
log.NewInfo(req.OperationID, utils.GetSelfFuncName(), "req: ", resp.String())
return resp, nil return resp, nil
} }
func (s *cacheServer) GetGroupMemberIDListFromCache(ctx context.Context, req *pbCache.GetGroupMemberIDListFromCacheReq) (resp *pbCache.GetGroupMemberIDListFromCacheResp, err error) { func (s *cacheServer) GetGroupMemberIDListFromCache(ctx context.Context, req *pbCache.GetGroupMemberIDListFromCacheReq) (resp *pbCache.GetGroupMemberIDListFromCacheResp, err error) {
resp = &pbCache.GetGroupMemberIDListFromCacheResp{ 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)
}()
userIDList, err := rocksCache.GetGroupMemberIDListFromCache(ctx, req.GroupID) userIDList, err := rocksCache.GetGroupMemberIDListFromCache(ctx, req.GroupID)
if err != nil { if err != nil {
constant.SetErrorForResp(err, resp.CommonResp) return
return resp, nil
} }
resp.UserIDList = userIDList resp.UserIDList = userIDList
return resp, nil return
} }
func (s *cacheServer) DelGroupMemberIDListFromCache(ctx context.Context, req *pbCache.DelGroupMemberIDListFromCacheReq) (resp *pbCache.DelGroupMemberIDListFromCacheResp, err error) { func (s *cacheServer) DelGroupMemberIDListFromCache(ctx context.Context, req *pbCache.DelGroupMemberIDListFromCacheReq) (resp *pbCache.DelGroupMemberIDListFromCacheResp, err error) {
resp = &pbCache.DelGroupMemberIDListFromCacheResp{CommonResp: &sdkws.CommonResp{}} resp = &pbCache.DelGroupMemberIDListFromCacheResp{}
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)
}()
if err := rocksCache.DelGroupMemberIDListFromCache(ctx, req.GroupID); err != nil { if err := rocksCache.DelGroupMemberIDListFromCache(ctx, req.GroupID); err != nil {
constant.SetErrorForResp(err, resp.CommonResp)
return resp, nil return resp, nil
} }
return resp, nil return resp, nil

6
internal/rpc/group/callback.go
View File

@ -16,7 +16,7 @@ import (
func callbackBeforeCreateGroup(ctx context.Context, req *pbGroup.CreateGroupReq) (err error) { func callbackBeforeCreateGroup(ctx context.Context, req *pbGroup.CreateGroupReq) (err error) {
defer func() { 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 { if !config.Config.Callback.CallbackBeforeCreateGroup.Enable {
return nil 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) { func CallbackBeforeMemberJoinGroup(ctx context.Context, operationID string, groupMember *im_mysql_model.GroupMember, groupEx string) (err error) {
defer func() { 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} callbackResp := cbApi.CommonCallbackResp{OperationID: operationID}
if !config.Config.Callback.CallbackBeforeMemberJoinGroup.Enable { 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) { func CallbackBeforeSetGroupMemberInfo(ctx context.Context, req *pbGroup.SetGroupMemberInfoReq) (err error) {
defer func() { 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} callbackResp := cbApi.CommonCallbackResp{OperationID: req.OperationID}
if !config.Config.Callback.CallbackBeforeSetGroupMemberInfo.Enable { if !config.Config.Callback.CallbackBeforeSetGroupMemberInfo.Enable {

50
internal/rpc/group/group.go
View File

@ -210,7 +210,7 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbGroup.CreateGroupR
} else { } else {
for _, userID := range userIDs { for _, userID := range userIDs {
if err := rocksCache.DelJoinedSuperGroupIDListFromCache(ctx, userID); err != nil { 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() { 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, err := (*imdb.GroupMember)(nil).TakeOwnerInfo(ctx, groupID)
//owner, err2 := imdb.GetGroupOwnerInfoByGroupID(groupID) //owner, err2 := imdb.GetGroupOwnerInfoByGroupID(groupID)
if err != nil { if err != nil {
trace_log.SetContextInfo(ctx, "TakeOwnerInfo", err, "groupID", groupID)
continue continue
} }
group, err := rocksCache.GetGroupInfoFromCache(ctx, groupID) group, err := rocksCache.GetGroupInfoFromCache(ctx, groupID)
@ -253,7 +252,6 @@ func (s *groupServer) GetJoinedGroupList(ctx context.Context, req *pbGroup.GetJo
continue continue
} }
if group.Status == constant.GroupStatusDismissed { if group.Status == constant.GroupStatusDismissed {
trace_log.SetContextInfo(ctx, "GetGroupInfoFromCache", err, "groupID", groupID)
continue continue
} }
utils.CopyStructFields(&groupNode, group) utils.CopyStructFields(&groupNode, group)
@ -327,14 +325,14 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
resultNode.Result = 0 resultNode.Result = 0
toUserInfo, err := imdb.GetUserByUserID(v) toUserInfo, err := imdb.GetUserByUserID(v)
if err != nil { if err != nil {
trace_log.SetContextInfo(ctx, "GetUserByUserID", err, "userID", v) trace_log.SetCtxInfo(ctx, "GetUserByUserID", err, "userID", v)
resultNode.Result = -1 resultNode.Result = -1
resp.Id2ResultList = append(resp.Id2ResultList, &resultNode) resp.Id2ResultList = append(resp.Id2ResultList, &resultNode)
continue continue
} }
if imdb.IsExistGroupMember(req.GroupID, v) { 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 resultNode.Result = -1
resp.Id2ResultList = append(resp.Id2ResultList, &resultNode) resp.Id2ResultList = append(resp.Id2ResultList, &resultNode)
continue continue
@ -351,7 +349,7 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
} }
err = imdb.InsertIntoGroupMember(toInsertInfo) err = imdb.InsertIntoGroupMember(toInsertInfo)
if err != nil { if err != nil {
trace_log.SetContextInfo(ctx, "InsertIntoGroupMember", err, "args", toInsertInfo) trace_log.SetCtxInfo(ctx, "InsertIntoGroupMember", err, "args", toInsertInfo)
resultNode.Result = -1 resultNode.Result = -1
resp.Id2ResultList = append(resp.Id2ResultList, &resultNode) resp.Id2ResultList = append(resp.Id2ResultList, &resultNode)
continue continue
@ -359,7 +357,7 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
okUserIDList = append(okUserIDList, v) okUserIDList = append(okUserIDList, v)
err = db.DB.AddGroupMember(req.GroupID, toUserInfo.UserID) err = db.DB.AddGroupMember(req.GroupID, toUserInfo.UserID)
if err != nil { 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) resp.Id2ResultList = append(resp.Id2ResultList, &resultNode)
} }
@ -375,7 +373,7 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbGroup.Invite
} else { } else {
for _, userID := range req.InvitedUserIDList { for _, userID := range req.InvitedUserIDList {
if err := rocksCache.DelJoinedSuperGroupIDListFromCache(ctx, userID); err != nil { 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 { 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) kickedInfo, err := rocksCache.GetGroupMemberInfoFromCache(ctx, req.GroupID, v)
if err != nil { if err != nil {
resp.Id2ResultList = append(resp.Id2ResultList, &pbGroup.Id2Result{UserID: v, Result: -1}) 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 continue
} }
if kickedInfo.RoleLevel == constant.GroupAdmin && opFlag == 3 { if kickedInfo.RoleLevel == constant.GroupAdmin && opFlag == 3 {
resp.Id2ResultList = append(resp.Id2ResultList, &pbGroup.Id2Result{UserID: v, Result: -1}) 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 continue
} }
if kickedInfo.RoleLevel == constant.GroupOwner && opFlag != 1 { if kickedInfo.RoleLevel == constant.GroupOwner && opFlag != 1 {
resp.Id2ResultList = append(resp.Id2ResultList, &pbGroup.Id2Result{UserID: v, Result: -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 continue
} }
err = imdb.DeleteGroupMemberByGroupIDAndUserID(req.GroupID, v) 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 { if err != nil {
log.NewError(req.OperationID, "RemoveGroupMember failed ", err.Error(), req.GroupID, v) log.NewError(req.OperationID, "RemoveGroupMember failed ", err.Error(), req.GroupID, v)
resp.Id2ResultList = append(resp.Id2ResultList, &pbGroup.Id2Result{UserID: v, Result: -1}) 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) client := pbUser.NewUserClient(etcdConn)
respPb, err := client.SetConversation(context.Background(), &reqPb) 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 { } else {
okUserIDList = req.KickedUserIDList okUserIDList = req.KickedUserIDList
@ -542,14 +540,14 @@ func (s *groupServer) KickGroupMember(ctx context.Context, req *pbGroup.KickGrou
if groupInfo.GroupType != constant.SuperGroup { if groupInfo.GroupType != constant.SuperGroup {
for _, userID := range okUserIDList { for _, userID := range okUserIDList {
if err := rocksCache.DelGroupMemberInfoFromCache(ctx, req.GroupID, userID); err != nil { 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) chat.MemberKickedNotification(req, okUserIDList)
} else { } else {
for _, userID := range okUserIDList { for _, userID := range okUserIDList {
if err = rocksCache.DelJoinedSuperGroupIDListFromCache(ctx, userID); err != nil { 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() { go func() {
@ -608,7 +606,7 @@ func (s *groupServer) GetGroupApplicationList(ctx context.Context, req *pbGroup.
return nil, err return nil, err
} }
var errResult error 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 { for _, v := range reply {
node := open_im_sdk.GroupRequest{UserInfo: &open_im_sdk.PublicUserInfo{}, GroupInfo: &open_im_sdk.GroupInfo{}} node := open_im_sdk.GroupRequest{UserInfo: &open_im_sdk.PublicUserInfo{}, GroupInfo: &open_im_sdk.GroupInfo{}}
err := FillGroupInfoByGroupID(req.OperationID, v.GroupID, node.GroupInfo) err := FillGroupInfoByGroupID(req.OperationID, v.GroupID, node.GroupInfo)
@ -618,7 +616,7 @@ func (s *groupServer) GetGroupApplicationList(ctx context.Context, req *pbGroup.
} }
continue 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) err = FillPublicUserInfoByUserID(req.OperationID, v.UserID, node.UserInfo)
if err != nil { if err != nil {
errResult = err 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) { func CheckPermission(ctx context.Context, groupID string, userID string) (err error) {
defer func() { 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) { if !token_verify.IsManagerUserID(userID) && !imdb.IsGroupOwnerAdmin(groupID, userID) {
return utils.Wrap(constant.ErrNoPermission, utils.GetSelfFuncName()) 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) client := pbUser.NewUserClient(etcdConn)
respPb, err := client.SetConversation(context.Background(), &reqPb) 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) chat.MemberEnterDirectlyNotification(req.GroupID, req.OpUserID, req.OperationID)
return resp, nil return resp, nil
} else { } else {
@ -976,7 +974,7 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbGroup.SetGroupInf
} }
nClient := pbConversation.NewConversationClient(nEtcdConn) nClient := pbConversation.NewConversationClient(nEtcdConn)
conversationReply, err := nClient.ModifyConversationField(context.Background(), &conversationReq) 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 return resp, nil
} }
@ -1049,14 +1047,14 @@ func (s *groupServer) GetGroups(ctx context.Context, req *pbGroup.GetGroupsReq)
} else { } else {
groups, count, err := imdb.GetGroupsByName(req.GroupName, req.Pagination.PageNumber, req.Pagination.ShowNumber) groups, count, err := imdb.GetGroupsByName(req.GroupName, req.Pagination.PageNumber, req.Pagination.ShowNumber)
if err != nil { 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 { for _, v := range groups {
group := &pbGroup.CMSGroup{GroupInfo: &open_im_sdk.GroupInfo{}} group := &pbGroup.CMSGroup{GroupInfo: &open_im_sdk.GroupInfo{}}
utils.CopyStructFields(group.GroupInfo, v) utils.CopyStructFields(group.GroupInfo, v)
groupMember, err := imdb.GetGroupOwnerInfoByGroupID(v.GroupID) groupMember, err := imdb.GetGroupOwnerInfoByGroupID(v.GroupID)
if err != nil { if err != nil {
trace_log.SetContextInfo(ctx, "GetGroupOwnerInfoByGroupID", err, "GroupID", v.GroupID) trace_log.SetCtxInfo(ctx, "GetGroupOwnerInfoByGroupID", err, "GroupID", v.GroupID)
continue continue
} }
group.GroupInfo.CreateTime = uint32(v.CreateTime.Unix()) 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{}} node := open_im_sdk.GroupRequest{UserInfo: &open_im_sdk.PublicUserInfo{}, GroupInfo: &open_im_sdk.GroupInfo{}}
group, err := imdb.GetGroupInfoByGroupID(groupReq.GroupID) group, err := imdb.GetGroupInfoByGroupID(groupReq.GroupID)
if err != nil { if err != nil {
trace_log.SetContextInfo(ctx, "GetGroupInfoByGroupID", err, "GroupID", groupReq.GroupID) trace_log.SetCtxInfo(ctx, "GetGroupInfoByGroupID", err, "GroupID", groupReq.GroupID)
continue continue
} }
user, err := imdb.GetUserByUserID(groupReq.UserID) user, err := imdb.GetUserByUserID(groupReq.UserID)
if err != nil { if err != nil {
trace_log.SetContextInfo(ctx, "GetUserByUserID", err, "UserID", groupReq.UserID) trace_log.SetCtxInfo(ctx, "GetUserByUserID", err, "UserID", groupReq.UserID)
continue continue
} }
cp.GroupRequestDBCopyOpenIM(&node, &groupReq) cp.GroupRequestDBCopyOpenIM(&node, &groupReq)
@ -1146,7 +1144,7 @@ func (s *groupServer) DismissGroup(ctx context.Context, req *pbGroup.DismissGrou
if groupInfo.GroupType != constant.SuperGroup { if groupInfo.GroupType != constant.SuperGroup {
memberList, err := imdb.GetGroupMemberListByGroupID(req.GroupID) memberList, err := imdb.GetGroupMemberListByGroupID(req.GroupID)
if err != nil { 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 //modify quitter conversation info
var reqPb pbUser.SetConversationReq 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) etcdConn, err := getcdv3.GetConn(ctx, config.Config.RpcRegisterName.OpenImUserName)
client := pbUser.NewUserClient(etcdConn) client := pbUser.NewUserClient(etcdConn)
respPb, err := client.SetConversation(context.Background(), &reqPb) 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) err = imdb.DeleteGroupMemberByGroupID(req.GroupID)
if err != nil { if err != nil {

12
pkg/common/db/mysql_model/im_mysql_model/friend_model_k.go
View File

@ -22,7 +22,7 @@ type Friend struct {
func (*Friend) Create(ctx context.Context, friends []*Friend) (err error) { func (*Friend) Create(ctx context.Context, friends []*Friend) (err error) {
defer func() { 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, "") err = utils.Wrap(FriendDB.Create(&friends).Error, "")
return err 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) { func (*Friend) Delete(ctx context.Context, ownerUserID string, friendUserIDs []string) (err error) {
defer func() { 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, "") err = utils.Wrap(FriendDB.Where("owner_user_id = ? and friend_user_id in (?)", ownerUserID, friendUserIDs).Delete(&Friend{}).Error, "")
return err 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) { func (*Friend) UpdateByMap(ctx context.Context, ownerUserID string, args map[string]interface{}) (err error) {
defer func() { 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, "") return utils.Wrap(FriendDB.Where("owner_user_id = ?", ownerUserID).Updates(args).Error, "")
} }
func (*Friend) Update(ctx context.Context, friends []*Friend) (err error) { func (*Friend) Update(ctx context.Context, friends []*Friend) (err error) {
defer func() { 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, "") return utils.Wrap(FriendDB.Updates(&friends).Error, "")
} }
func (*Friend) Find(ctx context.Context, ownerUserID string) (friends []*Friend, err error) { func (*Friend) Find(ctx context.Context, ownerUserID string) (friends []*Friend, err error) {
defer func() { 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, "") err = utils.Wrap(FriendDB.Where("owner_user_id = ?", ownerUserID).Find(&friends).Error, "")
return friends, err 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) { func (*Friend) Take(ctx context.Context, ownerUserID, friendUserID string) (group *Group, err error) {
group = &Group{} 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, "") err = utils.Wrap(FriendDB.Where("owner_user_id = ? and friend_user_id", ownerUserID, friendUserID).Take(group).Error, "")
return group, err return group, err
} }

14
pkg/common/db/mysql_model/im_mysql_model/group_member_model_k.go
View File

@ -29,33 +29,33 @@ type GroupMember struct {
func (g *GroupMember) Create(ctx context.Context, groupMemberList []*GroupMember) (err error) { func (g *GroupMember) Create(ctx context.Context, groupMemberList []*GroupMember) (err error) {
defer func() { 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, "") return utils.Wrap(GroupMemberDB.Create(&groupMemberList).Error, "")
} }
func (g *GroupMember) Delete(ctx context.Context, groupMembers []*GroupMember) (err error) { func (g *GroupMember) Delete(ctx context.Context, groupMembers []*GroupMember) (err error) {
defer func() { 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, "") return utils.Wrap(GroupMemberDB.Delete(groupMembers).Error, "")
} }
func (g *GroupMember) UpdateByMap(ctx context.Context, groupID string, userID string, args map[string]interface{}) (err error) { func (g *GroupMember) UpdateByMap(ctx context.Context, groupID string, userID string, args map[string]interface{}) (err error) {
defer func() { 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, "") 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) { 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, "") return utils.Wrap(GroupMemberDB.Updates(&groupMembers).Error, "")
} }
func (g *GroupMember) Find(ctx context.Context, groupMembers []*GroupMember) (groupList []*GroupMember, err error) { func (g *GroupMember) Find(ctx context.Context, groupMembers []*GroupMember) (groupList []*GroupMember, err error) {
defer func() { 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{} var where [][]interface{}
for _, groupMember := range groupMembers { 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) { func (g *GroupMember) Take(ctx context.Context, groupID string, userID string) (groupMember *GroupMember, err error) {
defer func() { 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{} groupMember = &GroupMember{}
return groupMember, utils.Wrap(GroupMemberDB.Where("group_id = ? and user_id = ?", groupID, userID).Take(groupMember).Error, "") 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) { func (g *GroupMember) TakeOwnerInfo(ctx context.Context, groupID string) (groupMember *GroupMember, err error) {
defer func() { 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{} groupMember = &GroupMember{}
err = GroupMemberDB.Where("group_id = ? and role_level = ?", groupID, constant.GroupOwner).Take(groupMember).Error err = GroupMemberDB.Where("group_id = ? and role_level = ?", groupID, constant.GroupOwner).Take(groupMember).Error

12
pkg/common/db/mysql_model/im_mysql_model/group_model_k.go
View File

@ -30,7 +30,7 @@ type Group struct {
func (*Group) Create(ctx context.Context, groups []*Group) (err error) { func (*Group) Create(ctx context.Context, groups []*Group) (err error) {
defer func() { 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, "") err = utils.Wrap(GroupDB.Create(&groups).Error, "")
return err 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) { func (*Group) Delete(ctx context.Context, groupIDs []string) (err error) {
defer func() { 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, "") 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) { func (*Group) UpdateByMap(ctx context.Context, groupID string, args map[string]interface{}) (err error) {
defer func() { 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, "") return utils.Wrap(GroupDB.Where("group_id = ?", groupID).Updates(args).Error, "")
} }
func (*Group) Update(ctx context.Context, groups []*Group) (err error) { func (*Group) Update(ctx context.Context, groups []*Group) (err error) {
defer func() { 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, "") return utils.Wrap(GroupDB.Updates(&groups).Error, "")
} }
func (*Group) Find(ctx context.Context, groupIDs []string) (groupList []*Group, err error) { func (*Group) Find(ctx context.Context, groupIDs []string) (groupList []*Group, err error) {
defer func() { 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, "") err = utils.Wrap(GroupDB.Where("group_id in (?)", groupIDs).Find(&groupList).Error, "")
return groupList, err 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) { func (*Group) Take(ctx context.Context, groupID string) (group *Group, err error) {
group = &Group{} group = &Group{}
defer func() { 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, "") err = utils.Wrap(GroupDB.Where("group_id = ?", groupID).Take(group).Error, "")
return group, err return group, err

12
pkg/common/db/mysql_model/im_mysql_model/group_request_model_k.go
View File

@ -27,35 +27,35 @@ type GroupRequest struct {
func (*GroupRequest) Create(ctx context.Context, groupRequests []*GroupRequest) (err error) { func (*GroupRequest) Create(ctx context.Context, groupRequests []*GroupRequest) (err error) {
defer func() { 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()) return utils.Wrap(GroupRequestDB.Create(&groupRequests).Error, utils.GetSelfFuncName())
} }
func (*GroupRequest) Delete(ctx context.Context, groupRequests []*GroupRequest) (err error) { func (*GroupRequest) Delete(ctx context.Context, groupRequests []*GroupRequest) (err error) {
defer func() { 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()) 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) { func (*GroupRequest) UpdateByMap(ctx context.Context, groupID string, userID string, args map[string]interface{}) (err error) {
defer func() { 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()) 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) { func (*GroupRequest) Update(ctx context.Context, groupRequests []*GroupRequest) (err error) {
defer func() { 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()) return utils.Wrap(GroupRequestDB.Updates(&groupRequests).Error, utils.GetSelfFuncName())
} }
func (*GroupRequest) Find(ctx context.Context, groupRequests []*GroupRequest) (resultGroupRequests []*GroupRequest, err error) { func (*GroupRequest) Find(ctx context.Context, groupRequests []*GroupRequest) (resultGroupRequests []*GroupRequest, err error) {
defer func() { 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{} var where [][]interface{}
for _, groupMember := range groupRequests { 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) { func (*GroupRequest) Take(ctx context.Context, groupID string, userID string) (groupRequest *GroupRequest, err error) {
groupRequest = &GroupRequest{} groupRequest = &GroupRequest{}
defer func() { 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()) return groupRequest, utils.Wrap(GroupRequestDB.Where("group_id = ? and user_id = ? ", groupID, userID).Take(groupRequest).Error, utils.GetSelfFuncName())
} }

2
pkg/common/db/mysql_model/im_mysql_model/user_black_list_model.go
View File

@ -20,7 +20,7 @@ type Black struct {
} }
func InsertInToUserBlackList(ctx context.Context, black Black) (err error) { 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() black.CreateTime = time.Now()
err = BlackDB.Create(black).Error err = BlackDB.Create(black).Error
return err return err

66
pkg/common/db/rocks_cache/rocks_cache.go
View File

@ -83,7 +83,7 @@ func GetFriendIDListFromCache(ctx context.Context, userID string) (friendIDList
return string(bytes), nil return string(bytes), nil
} }
defer func() { 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) friendIDListStr, err := db.DB.Rc.Fetch(friendRelationCache+userID, time.Second*30*60, getFriendIDList)
if err != nil { if err != nil {
@ -95,7 +95,7 @@ func GetFriendIDListFromCache(ctx context.Context, userID string) (friendIDList
func DelFriendIDListFromCache(ctx context.Context, userID string) (err error) { func DelFriendIDListFromCache(ctx context.Context, userID string) (err error) {
defer func() { 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) return db.DB.Rc.TagAsDeleted(friendRelationCache + userID)
} }
@ -113,7 +113,7 @@ func GetBlackListFromCache(ctx context.Context, userID string) (blackIDList []st
return string(bytes), nil return string(bytes), nil
} }
defer func() { 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) blackIDListStr, err := db.DB.Rc.Fetch(blackListCache+userID, time.Second*30*60, getBlackIDList)
if err != nil { 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) { func DelBlackIDListFromCache(ctx context.Context, userID string) (err error) {
defer func() { 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) return db.DB.Rc.TagAsDeleted(blackListCache + userID)
} }
@ -143,7 +143,7 @@ func GetJoinedGroupIDListFromCache(ctx context.Context, userID string) (joinedGr
return string(bytes), nil return string(bytes), nil
} }
defer func() { 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) joinedGroupIDListStr, err := db.DB.Rc.Fetch(joinedGroupListCache+userID, time.Second*30*60, getJoinedGroupIDList)
if err != nil { if err != nil {
@ -155,7 +155,7 @@ func GetJoinedGroupIDListFromCache(ctx context.Context, userID string) (joinedGr
func DelJoinedGroupIDListFromCache(ctx context.Context, userID string) (err error) { func DelJoinedGroupIDListFromCache(ctx context.Context, userID string) (err error) {
defer func() { 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) return db.DB.Rc.TagAsDeleted(joinedGroupListCache + userID)
} }
@ -186,7 +186,7 @@ func GetGroupMemberIDListFromCache(ctx context.Context, groupID string) (groupMe
return string(bytes), nil return string(bytes), nil
} }
defer func() { 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) groupIDListStr, err := db.DB.Rc.Fetch(groupCache+groupID, time.Second*30*60, f)
if err != nil { if err != nil {
@ -198,7 +198,7 @@ func GetGroupMemberIDListFromCache(ctx context.Context, groupID string) (groupMe
func DelGroupMemberIDListFromCache(ctx context.Context, groupID string) (err error) { func DelGroupMemberIDListFromCache(ctx context.Context, groupID string) (err error) {
defer func() { 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) 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 return string(bytes), nil
} }
defer func() { 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) userInfoStr, err := db.DB.Rc.Fetch(userInfoCache+userID, time.Second*30*60, getUserInfo)
if err != nil { 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) { func DelUserInfoFromCache(ctx context.Context, userID string) (err error) {
defer func() { 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) return db.DB.Rc.TagAsDeleted(userInfoCache + userID)
} }
@ -259,7 +259,7 @@ func GetGroupMemberInfoFromCache(ctx context.Context, groupID, userID string) (g
return string(bytes), nil return string(bytes), nil
} }
defer func() { 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) groupMemberInfoStr, err := db.DB.Rc.Fetch(groupMemberInfoCache+groupID+"-"+userID, time.Second*30*60, getGroupMemberInfo)
if err != nil { 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) { func DelGroupMemberInfoFromCache(ctx context.Context, groupID, userID string) (err error) {
defer func() { 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) return db.DB.Rc.TagAsDeleted(groupMemberInfoCache + groupID + "-" + userID)
} }
func GetGroupMembersInfoFromCache(ctx context.Context, count, offset int32, groupID string) (groupMembers []*imdb.GroupMember, err error) { func GetGroupMembersInfoFromCache(ctx context.Context, count, offset int32, groupID string) (groupMembers []*imdb.GroupMember, err error) {
defer func() { 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) groupMemberIDList, err := GetGroupMemberIDListFromCache(ctx, groupID)
if err != nil { 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) { func GetAllGroupMembersInfoFromCache(ctx context.Context, groupID string) (groupMembers []*imdb.GroupMember, err error) {
defer func() { 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) { getGroupMemberInfo := func() (string, error) {
groupMembers, err := imdb.GetGroupMemberListByGroupID(groupID) 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) { func DelAllGroupMembersInfoFromCache(ctx context.Context, groupID string) (err error) {
defer func() { 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) return db.DB.Rc.TagAsDeleted(groupAllMemberInfoCache + groupID)
} }
@ -368,7 +368,7 @@ func GetGroupInfoFromCache(ctx context.Context, groupID string) (groupInfo *imdb
} }
groupInfo = &imdb.Group{} groupInfo = &imdb.Group{}
defer func() { 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) groupInfoStr, err := db.DB.Rc.Fetch(groupInfoCache+groupID, time.Second*30*60, getGroupInfo)
if err != nil { 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) { func DelGroupInfoFromCache(ctx context.Context, groupID string) (err error) {
defer func() { 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) return db.DB.Rc.TagAsDeleted(groupInfoCache + groupID)
} }
@ -398,7 +398,7 @@ func GetAllFriendsInfoFromCache(ctx context.Context, userID string) (friends []*
return string(bytes), nil return string(bytes), nil
} }
defer func() { 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) allFriendInfoStr, err := db.DB.Rc.Fetch(allFriendInfoCache+userID, time.Second*30*60, getAllFriendInfo)
if err != nil { if err != nil {
@ -410,7 +410,7 @@ func GetAllFriendsInfoFromCache(ctx context.Context, userID string) (friends []*
func DelAllFriendsInfoFromCache(ctx context.Context, userID string) (err error) { func DelAllFriendsInfoFromCache(ctx context.Context, userID string) (err error) {
defer func() { 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) return db.DB.Rc.TagAsDeleted(allFriendInfoCache + userID)
} }
@ -478,7 +478,7 @@ func GetJoinedSuperGroupListFromCache(ctx context.Context, userID string) (joine
return string(bytes), nil return string(bytes), nil
} }
defer func() { 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) joinedSuperGroupListStr, err := db.DB.Rc.Fetch(joinedSuperGroupListCache+userID, time.Second*30*60, getJoinedSuperGroupIDList)
if err != nil { if err != nil {
@ -490,7 +490,7 @@ func GetJoinedSuperGroupListFromCache(ctx context.Context, userID string) (joine
func DelJoinedSuperGroupIDListFromCache(ctx context.Context, userID string) (err error) { func DelJoinedSuperGroupIDListFromCache(ctx context.Context, userID string) (err error) {
defer func() { 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) 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 return strconv.Itoa(int(bi.Uint64())), nil
} }
defer func() { 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) hashCodeStr, err := db.DB.Rc.Fetch(groupMemberListHashCache+groupID, time.Second*30*60, generateHash)
if err != nil { if err != nil {
@ -530,7 +530,7 @@ func GetGroupMemberListHashFromCache(ctx context.Context, groupID string) (hashC
func DelGroupMemberListHashFromCache(ctx context.Context, groupID string) (err error) { func DelGroupMemberListHashFromCache(ctx context.Context, groupID string) (err error) {
defer func() { 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) 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 return strconv.Itoa(int(num)), nil
} }
defer func() { 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) groupMember, err := db.DB.Rc.Fetch(groupMemberNumCache+groupID, time.Second*30*60, getGroupMemberNum)
if err != nil { 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) { func DelGroupMemberNumFromCache(ctx context.Context, groupID string) (err error) {
defer func() { 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) return db.DB.Rc.TagAsDeleted(groupMemberNumCache + groupID)
} }
@ -574,7 +574,7 @@ func GetUserConversationIDListFromCache(ctx context.Context, userID string) (con
return string(bytes), nil return string(bytes), nil
} }
defer func() { 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) conversationIDListStr, err := db.DB.Rc.Fetch(conversationIDListCache+userID, time.Second*30*60, getConversationIDList)
err = json.Unmarshal([]byte(conversationIDListStr), &conversationIDs) 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) { func DelUserConversationIDListFromCache(ctx context.Context, userID string) (err error) {
defer func() { 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") 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 return string(bytes), nil
} }
defer func() { 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) conversationStr, err := db.DB.Rc.Fetch(conversationCache+ownerUserID+":"+conversationID, time.Second*30*60, getConversation)
if err != nil { 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) { func GetConversationsFromCache(ctx context.Context, ownerUserID string, conversationIDs []string) (conversations []imdb.Conversation, err error) {
defer func() { 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 { for _, conversationID := range conversationIDs {
conversation, err := GetConversationFromCache(ctx, ownerUserID, conversationID) 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) { func GetUserAllConversationList(ctx context.Context, ownerUserID string) (conversations []imdb.Conversation, err error) {
defer func() { 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) IDList, err := GetUserConversationIDListFromCache(ctx, ownerUserID)
if err != nil { 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) { func DelConversationFromCache(ctx context.Context, ownerUserID, conversationID string) (err error) {
defer func() { 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") 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 return string(bytes), nil
} }
defer func() { 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) sessionType, "clientMsgID", clientMsgID, "firstModifyTime", firstModifyTime, "extendMsg", extendMsg)
}() }()
extendMsgStr, err := db.DB.Rc.Fetch(extendMsgCache+clientMsgID, time.Second*30*60, getExtendMsg) 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) { func DelExtendMsg(ctx context.Context, clientMsgID string) (err error) {
defer func() { 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") return utils.Wrap(db.DB.Rc.TagAsDeleted(extendMsgCache+clientMsgID), "DelExtendMsg err")
} }

122
pkg/common/log/logrus.go
View File

@ -2,7 +2,9 @@ package log
import ( import (
"Open_IM/pkg/common/config" "Open_IM/pkg/common/config"
"Open_IM/pkg/common/trace_log"
"bufio" "bufio"
"context"
//"bufio" //"bufio"
"fmt" "fmt"
@ -16,6 +18,7 @@ import (
) )
var logger *Logger var logger *Logger
var ctxLogger *Logger
type Logger struct { type Logger struct {
*logrus.Logger *logrus.Logger
@ -24,12 +27,35 @@ type Logger struct {
func init() { func init() {
logger = loggerInit("") logger = loggerInit("")
ctxLogger = ctxLoggerInit("")
} }
func NewPrivateLog(moduleName string) { func NewPrivateLog(moduleName string) {
logger = loggerInit(moduleName) 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 { func loggerInit(moduleName string) *Logger {
var logger = logrus.New() var logger = logrus.New()
//All logs will be printed //All logs will be printed
@ -44,11 +70,13 @@ func loggerInit(moduleName string) *Logger {
logger.SetOutput(writer) logger.SetOutput(writer)
// logger.SetOutput(os.Stdout) // logger.SetOutput(os.Stdout)
//Log Console Print Style Setting //Log Console Print Style Setting
logger.SetFormatter(&nested.Formatter{ logger.SetFormatter(&nested.Formatter{
TimestampFormat: "2006-01-02 15:04:05.000", TimestampFormat: "2006-01-02 15:04:05.000",
HideKeys: false, HideKeys: false,
FieldsOrder: []string{"PID", "FilePath", "OperationID"}, FieldsOrder: []string{"PID", "FilePath", "OperationID"},
}) })
//File name and line number display hook //File name and line number display hook
logger.AddHook(newFileHook()) logger.AddHook(newFileHook())
@ -200,3 +228,95 @@ func NewWarn(OperationID string, args ...interface{}) {
"PID": logger.Pid, "PID": logger.Pid,
}).Warnln(args) }).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)
}
}

8
pkg/common/middleware/rpc.go
View File

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

2
pkg/common/token_verify/jwt_token.go
View File

@ -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) { func CheckAccessV2(ctx context.Context, OpUserID string, OwnerUserID string) (err error) {
defer func() { 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) { if utils.IsContain(OpUserID, config.Config.Manager.AppManagerUid) {
return nil return nil

45
pkg/common/trace_log/ctx.go
View File

@ -3,8 +3,11 @@ package trace_log
import ( import (
"Open_IM/pkg/common/constant" "Open_IM/pkg/common/constant"
"Open_IM/pkg/common/log" "Open_IM/pkg/common/log"
"Open_IM/pkg/utils"
"context" "context"
"github.com/sirupsen/logrus"
"google.golang.org/grpc/status" "google.golang.org/grpc/status"
"runtime"
"strings" "strings"
//"errors" //"errors"
@ -47,18 +50,24 @@ func ShowLog(ctx context.Context) {
} else { } else {
log.Info(t.OperationID, "rpc: ", t.ApiName) log.Info(t.OperationID, "rpc: ", t.ApiName)
} }
for _, v := range *t.Funcs { for _, v := range *t.Funcs {
if v.Err != nil { if v.Err != nil {
log.Error(t.OperationID, "func: ", v.FuncName, " args: ", v.Args, v.Err.Error()) log.Error(t.OperationID, "func: ", v.FuncName, " args: ", v.Args, v.Err.Error())
} else { } else {
switch v.LogLevel {
case logrus.InfoLevel:
log.Info(t.OperationID, "func: ", v.FuncName, " args: ", v.Args) 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{}) { func WriteErrorResponse(ctx context.Context, funcName string, err error, args ...interface{}) {
SetContextInfo(ctx, funcName, err, args) SetCtxInfo(ctx, funcName, err, args)
e := Unwrap(err) e := Unwrap(err)
switch t := e.(type) { switch t := e.(type) {
case *constant.ErrInfo: 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{}) { //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) // e := new(constant.ErrInfo)
// switch { // switch {
// case errors.As(err, &e): // case errors.As(err, &e):
@ -119,6 +128,8 @@ type FuncInfo struct {
FuncName string FuncName string
Args Args Args Args
Err error Err error
LogLevel logrus.Level
File string
} }
type Args map[string]interface{} type Args map[string]interface{}
@ -139,13 +150,32 @@ func (a Args) String() string {
return s 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) t := ctx.Value(TraceLogKey).(*ApiInfo)
var funcInfo FuncInfo var funcInfo FuncInfo
funcInfo.Args = make(map[string]interface{}) funcInfo.Args = make(map[string]interface{})
argsHandle(args, funcInfo.Args) argsHandle(args, funcInfo.Args)
funcInfo.FuncName = funcName funcInfo.FuncName = funcName
funcInfo.Err = err 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) *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{}) { 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}) 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}
}

2
pkg/getcdv3/temp.go
View File

@ -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) { func GetConn(ctx context.Context, serviceName string) (conn *grpc.ClientConn, err error) {
defer func() { 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, ","), 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, trace_log.GetOperationID(ctx), config.Config.Etcd.UserName, config.Config.Etcd.Password)