diff --git a/internal/rpc/group/group.go b/internal/rpc/group/group.go
index 8f94b71b2..e8824899c 100644
--- a/internal/rpc/group/group.go
+++ b/internal/rpc/group/group.go
@@ -129,12 +129,12 @@ func (s *groupServer) NotificationUserInfoUpdate(ctx context.Context, req *pbgro
 		groupIDs = append(groupIDs, member.GroupID)
 	}
 	for _, groupID := range groupIDs {
-		if err := s.Notification.GroupMemberInfoSetNotification(ctx, groupID, req.UserID); err != nil {
-			log.ZError(ctx, "NotificationUserInfoUpdate setGroupMemberInfo notification failed", err, "groupID", groupID)
+		if err = s.Notification.GroupMemberInfoSetNotification(ctx, groupID, req.UserID); err != nil {
+			return nil, err
 		}
 	}
-	if err := s.db.DeleteGroupMemberHash(ctx, groupIDs); err != nil {
-		log.ZError(ctx, "NotificationUserInfoUpdate DeleteGroupMemberHash", err, "groupID", groupIDs)
+	if err = s.db.DeleteGroupMemberHash(ctx, groupIDs); err != nil {
+		return nil, err
 	}
 
 	return &pbgroup.NotificationUserInfoUpdateResp{}, nil
@@ -225,12 +225,12 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbgroup.CreateGroupR
 		return nil, errs.ErrUserIDNotFound.Wrap("user not found")
 	}
 	// Callback Before create Group
-	if err := CallbackBeforeCreateGroup(ctx, s.config, req); err != nil {
+	if err = CallbackBeforeCreateGroup(ctx, s.config, req); err != nil {
 		return nil, err
 	}
 	var groupMembers []*relationtb.GroupMemberModel
 	group := convert.Pb2DBGroupInfo(req.GroupInfo)
-	if err := s.GenGroupID(ctx, &group.GroupID); err != nil {
+	if err = s.GenGroupID(ctx, &group.GroupID); err != nil {
 		return nil, err
 	}
 	joinGroup := func(userID string, roleLevel int32) error {
@@ -244,26 +244,26 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbgroup.CreateGroupR
 			JoinTime:       time.Now(),
 			MuteEndTime:    time.UnixMilli(0),
 		}
-		if err := CallbackBeforeMemberJoinGroup(ctx, s.config, groupMember, group.Ex); err != nil {
+		if err = CallbackBeforeMemberJoinGroup(ctx, s.config, groupMember, group.Ex); err != nil {
 			return err
 		}
 		groupMembers = append(groupMembers, groupMember)
 		return nil
 	}
-	if err := joinGroup(req.OwnerUserID, constant.GroupOwner); err != nil {
+	if err = joinGroup(req.OwnerUserID, constant.GroupOwner); err != nil {
 		return nil, err
 	}
 	for _, userID := range req.AdminUserIDs {
-		if err := joinGroup(userID, constant.GroupAdmin); err != nil {
+		if err = joinGroup(userID, constant.GroupAdmin); err != nil {
 			return nil, err
 		}
 	}
 	for _, userID := range req.MemberUserIDs {
-		if err := joinGroup(userID, constant.GroupOrdinaryUsers); err != nil {
+		if err = joinGroup(userID, constant.GroupOrdinaryUsers); err != nil {
 			return nil, err
 		}
 	}
-	if err := s.db.CreateGroup(ctx, []*relationtb.GroupModel{group}, groupMembers); err != nil {
+	if err = s.db.CreateGroup(ctx, []*relationtb.GroupModel{group}, groupMembers); err != nil {
 		return nil, err
 	}
 	resp := &pbgroup.CreateGroupResp{GroupInfo: &sdkws.GroupInfo{}}
@@ -312,7 +312,7 @@ func (s *groupServer) CreateGroup(ctx context.Context, req *pbgroup.CreateGroupR
 		AdminUserIDs:  req.AdminUserIDs,
 	}
 
-	if err := CallbackAfterCreateGroup(ctx, s.config, reqCallBackAfter); err != nil {
+	if err = CallbackAfterCreateGroup(ctx, s.config, reqCallBackAfter); err != nil {
 		return nil, err
 	}
 
@@ -347,7 +347,7 @@ func (s *groupServer) GetJoinedGroupList(ctx context.Context, req *pbgroup.GetJo
 	if err != nil {
 		return nil, err
 	}
-	if err := s.PopulateGroupMember(ctx, members...); err != nil {
+	if err = s.PopulateGroupMember(ctx, members...); err != nil {
 		return nil, err
 	}
 	ownerMap := utils.SliceToMap(owners, func(e *relationtb.GroupMemberModel) string {
@@ -393,17 +393,17 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbgroup.Invite
 	var opUserID string
 	if !authverify.IsAppManagerUid(ctx, s.config) {
 		opUserID = mcontext.GetOpUserID(ctx)
-		var err error
+
 		groupMember, err = s.db.TakeGroupMember(ctx, req.GroupID, opUserID)
 		if err != nil {
 			return nil, err
 		}
-		if err := s.PopulateGroupMember(ctx, groupMember); err != nil {
+		if err = s.PopulateGroupMember(ctx, groupMember); err != nil {
 			return nil, err
 		}
 	}
 
-	if err := CallbackBeforeInviteUserToGroup(ctx, s.config, req); err != nil {
+	if err = CallbackBeforeInviteUserToGroup(ctx, s.config, req); err != nil {
 		return nil, err
 	}
 	if group.NeedVerification == constant.AllNeedVerification {
@@ -447,15 +447,15 @@ func (s *groupServer) InviteUserToGroup(ctx context.Context, req *pbgroup.Invite
 			JoinTime:       time.Now(),
 			MuteEndTime:    time.UnixMilli(0),
 		}
-		if err := CallbackBeforeMemberJoinGroup(ctx, s.config, member, group.Ex); err != nil {
+		if err = CallbackBeforeMemberJoinGroup(ctx, s.config, member, group.Ex); err != nil {
 			return nil, err
 		}
 		groupMembers = append(groupMembers, member)
 	}
-	if err := s.db.CreateGroup(ctx, nil, groupMembers); err != nil {
+	if err = s.db.CreateGroup(ctx, nil, groupMembers); err != nil {
 		return nil, err
 	}
-	if err := s.conversationRpcClient.GroupChatFirstCreateConversation(ctx, req.GroupID, req.InvitedUserIDs); err != nil {
+	if err = s.conversationRpcClient.GroupChatFirstCreateConversation(ctx, req.GroupID, req.InvitedUserIDs); err != nil {
 		return nil, err
 	}
 	s.Notification.MemberInvitedNotification(ctx, req.GroupID, req.Reason, req.InvitedUserIDs)
@@ -467,7 +467,7 @@ func (s *groupServer) GetGroupAllMember(ctx context.Context, req *pbgroup.GetGro
 	if err != nil {
 		return nil, err
 	}
-	if err := s.PopulateGroupMember(ctx, members...); err != nil {
+	if err = s.PopulateGroupMember(ctx, members...); err != nil {
 		return nil, err
 	}
 	resp := &pbgroup.GetGroupAllMemberResp{}
@@ -492,7 +492,7 @@ func (s *groupServer) GetGroupMemberList(ctx context.Context, req *pbgroup.GetGr
 	if err != nil {
 		return nil, err
 	}
-	if err := s.PopulateGroupMember(ctx, members...); err != nil {
+	if err = s.PopulateGroupMember(ctx, members...); err != nil {
 		return nil, err
 	}
 	if req.Keyword != "" {
@@ -583,7 +583,7 @@ func (s *groupServer) KickGroupMember(ctx context.Context, req *pbgroup.KickGrou
 	if len(ownerUserIDs) > 0 {
 		ownerUserID = ownerUserIDs[0]
 	}
-	if err := s.db.DeleteGroupMember(ctx, group.GroupID, req.KickedUserIDs); err != nil {
+	if err = s.db.DeleteGroupMember(ctx, group.GroupID, req.KickedUserIDs); err != nil {
 		return nil, err
 	}
 	tips := &sdkws.MemberKickedTips{
@@ -615,11 +615,11 @@ func (s *groupServer) KickGroupMember(ctx context.Context, req *pbgroup.KickGrou
 		tips.KickedUserList = append(tips.KickedUserList, convert.Db2PbGroupMember(memberMap[userID]))
 	}
 	s.Notification.MemberKickedNotification(ctx, tips)
-	if err := s.deleteMemberAndSetConversationSeq(ctx, req.GroupID, req.KickedUserIDs); err != nil {
+	if err = s.deleteMemberAndSetConversationSeq(ctx, req.GroupID, req.KickedUserIDs); err != nil {
 		return nil, err
 	}
 
-	if err := CallbackKillGroupMember(ctx, s.config, req); err != nil {
+	if err = CallbackKillGroupMember(ctx, s.config, req); err != nil {
 		return nil, err
 	}
 	return resp, nil
@@ -637,7 +637,7 @@ func (s *groupServer) GetGroupMembersInfo(ctx context.Context, req *pbgroup.GetG
 	if err != nil {
 		return nil, err
 	}
-	if err := s.PopulateGroupMember(ctx, members...); err != nil {
+	if err = s.PopulateGroupMember(ctx, members...); err != nil {
 		return nil, err
 	}
 	resp.Members = utils.Slice(members, func(e *relationtb.GroupMemberModel) *sdkws.GroupMemberFullInfo {
@@ -691,7 +691,7 @@ func (s *groupServer) GetGroupApplicationList(ctx context.Context, req *pbgroup.
 	if err != nil {
 		return nil, err
 	}
-	if err := s.PopulateGroupMember(ctx, owners...); err != nil {
+	if err = s.PopulateGroupMember(ctx, owners...); err != nil {
 		return nil, err
 	}
 	ownerMap := utils.SliceToMap(owners, func(e *relationtb.GroupMemberModel) string {
@@ -741,7 +741,6 @@ func (s *groupServer) GetGroupsInfo(ctx context.Context, req *pbgroup.GetGroupsI
 }
 
 func (s *groupServer) GroupApplicationResponse(ctx context.Context, req *pbgroup.GroupApplicationResponseReq) (*pbgroup.GroupApplicationResponseResp, error) {
-	defer log.ZInfo(ctx, utils.GetFuncName()+" Return")
 	if !utils.Contain(req.HandleResult, constant.GroupResponseAgree, constant.GroupResponseRefuse) {
 		return nil, errs.ErrArgs.Wrap("HandleResult unknown")
 	}
@@ -767,7 +766,7 @@ func (s *groupServer) GroupApplicationResponse(ctx context.Context, req *pbgroup
 	}
 	var inGroup bool
 	if _, takeErr := s.db.TakeGroupMember(ctx, req.GroupID, req.FromUserID); takeErr == nil {
-		inGroup = true // 已经在群里了
+		inGroup = true // It's already in the group.
 	} else if !s.IsNotFound(err) {
 		return nil, err
 	}
@@ -794,12 +793,12 @@ func (s *groupServer) GroupApplicationResponse(ctx context.Context, req *pbgroup
 		}
 	}
 	log.ZDebug(ctx, "GroupApplicationResponse", "inGroup", inGroup, "HandleResult", req.HandleResult, "member", member)
-	if err := s.db.HandlerGroupRequest(ctx, req.GroupID, req.FromUserID, req.HandledMsg, req.HandleResult, member); err != nil {
+	if err = s.db.HandlerGroupRequest(ctx, req.GroupID, req.FromUserID, req.HandledMsg, req.HandleResult, member); err != nil {
 		return nil, err
 	}
 	switch req.HandleResult {
 	case constant.GroupResponseAgree:
-		if err := s.conversationRpcClient.GroupChatFirstCreateConversation(ctx, req.GroupID, []string{req.FromUserID}); err != nil {
+		if err = s.conversationRpcClient.GroupChatFirstCreateConversation(ctx, req.GroupID, []string{req.FromUserID}); err != nil {
 			return nil, err
 		}
 		s.Notification.GroupApplicationAcceptedNotification(ctx, req)
@@ -816,7 +815,6 @@ func (s *groupServer) GroupApplicationResponse(ctx context.Context, req *pbgroup
 }
 
 func (s *groupServer) JoinGroup(ctx context.Context, req *pbgroup.JoinGroupReq) (resp *pbgroup.JoinGroupResp, err error) {
-	defer log.ZInfo(ctx, "JoinGroup.Return")
 	user, err := s.User.GetUserInfo(ctx, req.InviterUserID)
 	if err != nil {
 		return nil, err
@@ -914,12 +912,12 @@ func (s *groupServer) QuitGroup(ctx context.Context, req *pbgroup.QuitGroupReq)
 		return nil, err
 	}
 	_ = s.Notification.MemberQuitNotification(ctx, s.groupMemberDB2PB(member, 0))
-	if err := s.deleteMemberAndSetConversationSeq(ctx, req.GroupID, []string{req.UserID}); err != nil {
+	if err = s.deleteMemberAndSetConversationSeq(ctx, req.GroupID, []string{req.UserID}); err != nil {
 		return nil, err
 	}
 
 	// callback
-	if err := CallbackQuitGroup(ctx, s.config, req); err != nil {
+	if err = CallbackQuitGroup(ctx, s.config, req); err != nil {
 		return nil, err
 	}
 	return resp, nil
@@ -945,7 +943,7 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbgroup.SetGroupInf
 		if !(opMember.RoleLevel == constant.GroupOwner || opMember.RoleLevel == constant.GroupAdmin) {
 			return nil, errs.ErrNoPermission.Wrap("no group owner or admin")
 		}
-		if err := s.PopulateGroupMember(ctx, opMember); err != nil {
+		if err = s.PopulateGroupMember(ctx, opMember); err != nil {
 			return nil, err
 		}
 	}
@@ -1018,7 +1016,7 @@ func (s *groupServer) SetGroupInfo(ctx context.Context, req *pbgroup.SetGroupInf
 	if num > 0 {
 		_ = s.Notification.GroupInfoSetNotification(ctx, tips)
 	}
-	if err := CallbackAfterSetGroupInfo(ctx, s.config, req); err != nil {
+	if err = CallbackAfterSetGroupInfo(ctx, s.config, req); err != nil {
 		return nil, err
 	}
 	return resp, nil
@@ -1040,7 +1038,7 @@ func (s *groupServer) TransferGroupOwner(ctx context.Context, req *pbgroup.Trans
 	if err != nil {
 		return nil, err
 	}
-	if err := s.PopulateGroupMember(ctx, members...); err != nil {
+	if err = s.PopulateGroupMember(ctx, members...); err != nil {
 		return nil, err
 	}
 	memberMap := utils.SliceToMap(members, func(e *relationtb.GroupMemberModel) string { return e.UserID })
@@ -1060,11 +1058,11 @@ func (s *groupServer) TransferGroupOwner(ctx context.Context, req *pbgroup.Trans
 			return nil, errs.ErrNoPermission.Wrap("no permission transfer group owner")
 		}
 	}
-	if err := s.db.TransferGroupOwner(ctx, req.GroupID, req.OldOwnerUserID, req.NewOwnerUserID, newOwner.RoleLevel); err != nil {
+	if err = s.db.TransferGroupOwner(ctx, req.GroupID, req.OldOwnerUserID, req.NewOwnerUserID, newOwner.RoleLevel); err != nil {
 		return nil, err
 	}
 
-	if err := CallbackAfterTransferGroupOwner(ctx, s.config, req); err != nil {
+	if err = CallbackAfterTransferGroupOwner(ctx, s.config, req); err != nil {
 		return nil, err
 	}
 	s.Notification.GroupOwnerTransferredNotification(ctx, req)
@@ -1132,7 +1130,7 @@ func (s *groupServer) GetGroupMembersCMS(ctx context.Context, req *pbgroup.GetGr
 		return nil, err
 	}
 	resp.Total = uint32(total)
-	if err := s.PopulateGroupMember(ctx, members...); err != nil {
+	if err = s.PopulateGroupMember(ctx, members...); err != nil {
 		return nil, err
 	}
 	resp.Members = utils.Slice(members, func(e *relationtb.GroupMemberModel) *sdkws.GroupMemberFullInfo {
@@ -1190,7 +1188,6 @@ func (s *groupServer) GetUserReqApplicationList(ctx context.Context, req *pbgrou
 }
 
 func (s *groupServer) DismissGroup(ctx context.Context, req *pbgroup.DismissGroupReq) (*pbgroup.DismissGroupResp, error) {
-	defer log.ZInfo(ctx, "DismissGroup.return")
 	resp := &pbgroup.DismissGroupResp{}
 	owner, err := s.db.TakeGroupOwner(ctx, req.GroupID)
 	if err != nil {
@@ -1238,7 +1235,7 @@ func (s *groupServer) DismissGroup(ctx context.Context, req *pbgroup.DismissGrou
 		MembersID: membersID,
 		GroupType: string(group.GroupType),
 	}
-	if err := CallbackDismissGroup(ctx, s.config, reqCall); err != nil {
+	if err = CallbackDismissGroup(ctx, s.config, reqCall); err != nil {
 		return nil, err
 	}
 
@@ -1251,7 +1248,7 @@ func (s *groupServer) MuteGroupMember(ctx context.Context, req *pbgroup.MuteGrou
 	if err != nil {
 		return nil, err
 	}
-	if err := s.PopulateGroupMember(ctx, member); err != nil {
+	if err = s.PopulateGroupMember(ctx, member); err != nil {
 		return nil, err
 	}
 	if !authverify.IsAppManagerUid(ctx, s.config) {
@@ -1273,7 +1270,7 @@ func (s *groupServer) MuteGroupMember(ctx context.Context, req *pbgroup.MuteGrou
 		}
 	}
 	data := UpdateGroupMemberMutedTimeMap(time.Now().Add(time.Second * time.Duration(req.MutedSeconds)))
-	if err := s.db.UpdateGroupMember(ctx, member.GroupID, member.UserID, data); err != nil {
+	if err = s.db.UpdateGroupMember(ctx, member.GroupID, member.UserID, data); err != nil {
 		return nil, err
 	}
 	s.Notification.GroupMemberMutedNotification(ctx, req.GroupID, req.UserID, req.MutedSeconds)
@@ -1285,7 +1282,7 @@ func (s *groupServer) CancelMuteGroupMember(ctx context.Context, req *pbgroup.Ca
 	if err != nil {
 		return nil, err
 	}
-	if err := s.PopulateGroupMember(ctx, member); err != nil {
+	if err = s.PopulateGroupMember(ctx, member); err != nil {
 		return nil, err
 	}
 	if !authverify.IsAppManagerUid(ctx, s.config) {
@@ -1307,7 +1304,7 @@ func (s *groupServer) CancelMuteGroupMember(ctx context.Context, req *pbgroup.Ca
 		}
 	}
 	data := UpdateGroupMemberMutedTimeMap(time.Unix(0, 0))
-	if err := s.db.UpdateGroupMember(ctx, member.GroupID, member.UserID, data); err != nil {
+	if err = s.db.UpdateGroupMember(ctx, member.GroupID, member.UserID, data); err != nil {
 		return nil, err
 	}
 	s.Notification.GroupMemberCancelMutedNotification(ctx, req.GroupID, req.UserID)
@@ -1505,7 +1502,7 @@ func (s *groupServer) GetUserInGroupMembers(ctx context.Context, req *pbgroup.Ge
 	if err != nil {
 		return nil, err
 	}
-	if err := s.PopulateGroupMember(ctx, members...); err != nil {
+	if err = s.PopulateGroupMember(ctx, members...); err != nil {
 		return nil, err
 	}
 	resp.Members = utils.Slice(members, func(e *relationtb.GroupMemberModel) *sdkws.GroupMemberFullInfo {
@@ -1532,7 +1529,7 @@ func (s *groupServer) GetGroupMemberRoleLevel(ctx context.Context, req *pbgroup.
 	if err != nil {
 		return nil, err
 	}
-	if err := s.PopulateGroupMember(ctx, members...); err != nil {
+	if err = s.PopulateGroupMember(ctx, members...); err != nil {
 		return nil, err
 	}
 	resp.Members = utils.Slice(members, func(e *relationtb.GroupMemberModel) *sdkws.GroupMemberFullInfo {
diff --git a/internal/rpc/third/s3.go b/internal/rpc/third/s3.go
index 2e5bfebde..17e00f021 100644
--- a/internal/rpc/third/s3.go
+++ b/internal/rpc/third/s3.go
@@ -31,7 +31,6 @@ import (
 
 	"github.com/OpenIMSDK/protocol/third"
 	"github.com/OpenIMSDK/tools/errs"
-	"github.com/OpenIMSDK/tools/log"
 	"github.com/OpenIMSDK/tools/mcontext"
 	"github.com/OpenIMSDK/tools/utils"
 
@@ -111,7 +110,6 @@ func (t *thirdServer) InitiateMultipartUpload(ctx context.Context, req *third.In
 }
 
 func (t *thirdServer) AuthSign(ctx context.Context, req *third.AuthSignReq) (*third.AuthSignResp, error) {
-	defer log.ZDebug(ctx, "return")
 	partNumbers := utils.Slice(req.PartNumbers, func(partNumber int32) int { return int(partNumber) })
 	result, err := t.s3dataBase.AuthSign(ctx, req.UploadID, partNumbers)
 	if err != nil {
@@ -135,7 +133,6 @@ func (t *thirdServer) AuthSign(ctx context.Context, req *third.AuthSignReq) (*th
 }
 
 func (t *thirdServer) CompleteMultipartUpload(ctx context.Context, req *third.CompleteMultipartUploadReq) (*third.CompleteMultipartUploadResp, error) {
-	defer log.ZDebug(ctx, "return")
 	if err := checkUploadName(ctx, req.Name, t.config); err != nil {
 		return nil, err
 	}
@@ -153,7 +150,7 @@ func (t *thirdServer) CompleteMultipartUpload(ctx context.Context, req *third.Co
 		Group:       req.Cause,
 		CreateTime:  time.Now(),
 	}
-	if err := t.s3dataBase.SetObject(ctx, obj); err != nil {
+	if err = t.s3dataBase.SetObject(ctx, obj); err != nil {
 		return nil, err
 	}
 	return &third.CompleteMultipartUploadResp{
@@ -171,7 +168,6 @@ func (t *thirdServer) AccessURL(ctx context.Context, req *third.AccessURLReq) (*
 			opt.Image.Format = req.Query["format"]
 			opt.Image.Width, _ = strconv.Atoi(req.Query["width"])
 			opt.Image.Height, _ = strconv.Atoi(req.Query["height"])
-			log.ZDebug(ctx, "AccessURL image", "name", req.Name, "option", opt.Image)
 		default:
 			return nil, errs.ErrArgs.Wrap("invalid query type")
 		}
@@ -213,7 +209,7 @@ func (t *thirdServer) InitiateFormData(ctx context.Context, req *third.InitiateF
 	}
 	uid, err := uuid.NewRandom()
 	if err != nil {
-		return nil, err
+		return nil, errs.Wrap(err, "uuid NewRandom failed")
 	}
 	if key == "" {
 		date := time.Now().Format("20060102")
@@ -228,7 +224,7 @@ func (t *thirdServer) InitiateFormData(ctx context.Context, req *third.InitiateF
 	}
 	mateData, err := json.Marshal(&mate)
 	if err != nil {
-		return nil, err
+		return nil, errs.Wrap(err, "marshal failed")
 	}
 	resp, err := t.s3dataBase.FormData(ctx, key, req.Size, req.ContentType, duration)
 	if err != nil {
diff --git a/internal/rpc/third/third.go b/internal/rpc/third/third.go
index 76c6d9254..6ff891aff 100644
--- a/internal/rpc/third/third.go
+++ b/internal/rpc/third/third.go
@@ -17,7 +17,7 @@ package third
 import (
 	"context"
 	"fmt"
-	"github.com/OpenIMSDK/tools/log"
+	"github.com/OpenIMSDK/tools/errs"
 	"net/url"
 	"time"
 
@@ -41,8 +41,6 @@ import (
 )
 
 func Start(config *config.GlobalConfig, client discoveryregistry.SvcDiscoveryRegistry, server *grpc.Server) error {
-	log.ZDebug(context.Background(), "config19999999999999999999999999999999999", config, "javadfdas")
-
 	mongo, err := unrelation.NewMongo(config)
 	if err != nil {
 		return err
@@ -57,10 +55,10 @@ func Start(config *config.GlobalConfig, client discoveryregistry.SvcDiscoveryReg
 	}
 	apiURL := config.Object.ApiURL
 	if apiURL == "" {
-		return fmt.Errorf("api url is empty")
+		return errs.Wrap(fmt.Errorf("api url is empty"))
 	}
-	if _, parseErr := url.Parse(config.Object.ApiURL); parseErr != nil {
-		return err
+	if _, err = url.Parse(config.Object.ApiURL); err != nil {
+		return errs.Wrap(err, "parse url failed")
 	}
 	if apiURL[len(apiURL)-1] != '/' {
 		apiURL += "/"
@@ -70,7 +68,7 @@ func Start(config *config.GlobalConfig, client discoveryregistry.SvcDiscoveryReg
 	if err != nil {
 		return err
 	}
-	// 根据配置文件策略选择 oss 方式
+	// Select the oss method according to the profile policy
 	enable := config.Object.Enable
 	var o s3.Interface
 	switch config.Object.Enable {
diff --git a/internal/rpc/user/user.go b/internal/rpc/user/user.go
index ad7c1c646..9b2e6dbfe 100644
--- a/internal/rpc/user/user.go
+++ b/internal/rpc/user/user.go
@@ -16,7 +16,7 @@ package user
 
 import (
 	"context"
-	"errors"
+	"fmt"
 	"math/rand"
 	"strings"
 	"time"
@@ -32,8 +32,6 @@ import (
 	"github.com/OpenIMSDK/protocol/constant"
 	"github.com/OpenIMSDK/protocol/sdkws"
 	"github.com/OpenIMSDK/tools/errs"
-	"github.com/OpenIMSDK/tools/log"
-
 	"github.com/openimsdk/open-im-server/v3/pkg/authverify"
 	"github.com/openimsdk/open-im-server/v3/pkg/common/db/unrelation"
 
@@ -78,7 +76,7 @@ func Start(config *config.GlobalConfig, client registry.SvcDiscoveryRegistry, se
 	}
 	users := make([]*tablerelation.UserModel, 0)
 	if len(config.IMAdmin.UserID) != len(config.IMAdmin.Nickname) {
-		return errors.New("len(s.config.AppNotificationAdmin.AppManagerUid) != len(s.config.AppNotificationAdmin.Nickname)")
+		return errs.Wrap(fmt.Errorf("the count of ImAdmin.UserID is not equal to the count of ImAdmin.Nickname"))
 	}
 	for k, v := range config.IMAdmin.UserID {
 		users = append(users, &tablerelation.UserModel{UserID: v, Nickname: config.IMAdmin.Nickname[k], AppMangerLevel: constant.AppNotificationAdmin})
@@ -113,9 +111,6 @@ func (s *userServer) GetDesignateUsers(ctx context.Context, req *pbuser.GetDesig
 		return nil, err
 	}
 	resp.UsersInfo = convert.UsersDB2Pb(users)
-	if err != nil {
-		return nil, err
-	}
 	return resp, nil
 }
 
@@ -139,7 +134,7 @@ func (s *userServer) UpdateUserInfo(ctx context.Context, req *pbuser.UpdateUserI
 	}
 	if req.UserInfo.Nickname != "" || req.UserInfo.FaceURL != "" {
 		if err = s.groupRpcClient.NotificationUserInfoUpdate(ctx, req.UserInfo.UserID); err != nil {
-			log.ZError(ctx, "NotificationUserInfoUpdate", err)
+			return nil, errs.Wrap(err)
 		}
 	}
 	for _, friendID := range friends {
@@ -149,7 +144,7 @@ func (s *userServer) UpdateUserInfo(ctx context.Context, req *pbuser.UpdateUserI
 		return nil, err
 	}
 	if err = s.groupRpcClient.NotificationUserInfoUpdate(ctx, req.UserInfo.UserID); err != nil {
-		log.ZError(ctx, "NotificationUserInfoUpdate", err, "userID", req.UserInfo.UserID)
+		return nil, err
 	}
 	return resp, nil
 }
@@ -173,29 +168,29 @@ func (s *userServer) UpdateUserInfoEx(ctx context.Context, req *pbuser.UpdateUse
 		return nil, err
 	}
 	if req.UserInfo.Nickname != nil || req.UserInfo.FaceURL != nil {
-		if err := s.groupRpcClient.NotificationUserInfoUpdate(ctx, req.UserInfo.UserID); err != nil {
-			log.ZError(ctx, "NotificationUserInfoUpdate", err)
+		if err = s.groupRpcClient.NotificationUserInfoUpdate(ctx, req.UserInfo.UserID); err != nil {
+			return nil, err
 		}
 	}
 	for _, friendID := range friends {
 		s.friendNotificationSender.FriendInfoUpdatedNotification(ctx, req.UserInfo.UserID, friendID)
 	}
-	if err := CallbackAfterUpdateUserInfoEx(ctx, s.config, req); err != nil {
+	if err = CallbackAfterUpdateUserInfoEx(ctx, s.config, req); err != nil {
 		return nil, err
 	}
-	if err := s.groupRpcClient.NotificationUserInfoUpdate(ctx, req.UserInfo.UserID); err != nil {
-		log.ZError(ctx, "NotificationUserInfoUpdate", err, "userID", req.UserInfo.UserID)
+	if err = s.groupRpcClient.NotificationUserInfoUpdate(ctx, req.UserInfo.UserID); err != nil {
+		return nil, err
 	}
 	return resp, nil
 }
 func (s *userServer) SetGlobalRecvMessageOpt(ctx context.Context, req *pbuser.SetGlobalRecvMessageOptReq) (resp *pbuser.SetGlobalRecvMessageOptResp, err error) {
 	resp = &pbuser.SetGlobalRecvMessageOptResp{}
-	if _, err := s.FindWithError(ctx, []string{req.UserID}); err != nil {
+	if _, err = s.FindWithError(ctx, []string{req.UserID}); err != nil {
 		return nil, err
 	}
 	m := make(map[string]any, 1)
 	m["global_recv_msg_opt"] = req.GlobalRecvMsgOpt
-	if err := s.UpdateByMap(ctx, req.UserID, m); err != nil {
+	if err = s.UpdateByMap(ctx, req.UserID, m); err != nil {
 		return nil, err
 	}
 	s.friendNotificationSender.UserInfoUpdatedNotification(ctx, req.UserID)
@@ -244,7 +239,6 @@ func (s *userServer) GetPaginationUsers(ctx context.Context, req *pbuser.GetPagi
 			return nil, err
 		}
 		return &pbuser.GetPaginationUsersResp{Total: int32(total), Users: convert.UsersDB2Pb(users)}, err
-
 	}
 
 }
@@ -255,7 +249,6 @@ func (s *userServer) UserRegister(ctx context.Context, req *pbuser.UserRegisterR
 		return nil, errs.ErrArgs.Wrap("users is empty")
 	}
 	if req.Secret != s.config.Secret {
-		log.ZDebug(ctx, "UserRegister", s.config.Secret, req.Secret)
 		return nil, errs.ErrNoPermission.Wrap("secret invalid")
 	}
 	if utils.DuplicateAny(req.Users, func(e *sdkws.UserInfo) string { return e.UserID }) {
@@ -278,7 +271,7 @@ func (s *userServer) UserRegister(ctx context.Context, req *pbuser.UserRegisterR
 	if exist {
 		return nil, errs.ErrRegisteredAlready.Wrap("userID registered already")
 	}
-	if err := CallbackBeforeUserRegister(ctx, s.config, req); err != nil {
+	if err = CallbackBeforeUserRegister(ctx, s.config, req); err != nil {
 		return nil, err
 	}
 	now := time.Now()
@@ -294,11 +287,11 @@ func (s *userServer) UserRegister(ctx context.Context, req *pbuser.UserRegisterR
 			GlobalRecvMsgOpt: user.GlobalRecvMsgOpt,
 		})
 	}
-	if err := s.Create(ctx, users); err != nil {
+	if err = s.Create(ctx, users); err != nil {
 		return nil, err
 	}
 
-	if err := CallbackAfterUserRegister(ctx, s.config, req); err != nil {
+	if err = CallbackAfterUserRegister(ctx, s.config, req); err != nil {
 		return nil, err
 	}
 	return resp, nil
diff --git a/pkg/common/db/cache/msg.go b/pkg/common/db/cache/msg.go
index 207eb3983..1edde38b2 100644
--- a/pkg/common/db/cache/msg.go
+++ b/pkg/common/db/cache/msg.go
@@ -273,7 +273,7 @@ func (c *msgCache) GetHasReadSeqs(ctx context.Context, userID string, conversati
 func (c *msgCache) GetHasReadSeq(ctx context.Context, userID string, conversationID string) (int64, error) {
 	val, err := c.rdb.Get(ctx, c.getHasReadSeqKey(conversationID, userID)).Int64()
 	if err != nil {
-		return 0, err
+		return 0, errs.Wrap(err)
 	}
 	return val, nil
 }
@@ -477,7 +477,7 @@ func (c *msgCache) ParallelSetMessageToCache(ctx context.Context, conversationID
 
 	err := wg.Wait()
 	if err != nil {
-		return 0, err
+		return 0, errs.Wrap(err, "wg.Wait failed")
 	}
 
 	return len(msgs), nil
diff --git a/pkg/common/db/mgo/object.go b/pkg/common/db/mgo/object.go
index 88bfde213..eced0a183 100644
--- a/pkg/common/db/mgo/object.go
+++ b/pkg/common/db/mgo/object.go
@@ -16,6 +16,7 @@ package mgo
 
 import (
 	"context"
+	"github.com/OpenIMSDK/tools/errs"
 
 	"github.com/OpenIMSDK/tools/mgoutil"
 	"go.mongodb.org/mongo-driver/bson"
@@ -34,7 +35,7 @@ func NewS3Mongo(db *mongo.Database) (relation.ObjectInfoModelInterface, error) {
 		Options: options.Index().SetUnique(true),
 	})
 	if err != nil {
-		return nil, err
+		return nil, errs.Wrap(err)
 	}
 	return &S3Mongo{coll: coll}, nil
 }
diff --git a/pkg/common/db/mgo/user.go b/pkg/common/db/mgo/user.go
index 2797bc53f..9424b61ab 100644
--- a/pkg/common/db/mgo/user.go
+++ b/pkg/common/db/mgo/user.go
@@ -159,7 +159,7 @@ func (u *UserMgo) AddUserCommand(ctx context.Context, userID string, Type int32,
 	}
 
 	_, err := collection.InsertOne(ctx, doc)
-	return err
+	return errs.Wrap(err)
 }
 
 func (u *UserMgo) DeleteUserCommand(ctx context.Context, userID string, Type int32, UUID string) error {
@@ -186,7 +186,7 @@ func (u *UserMgo) UpdateUserCommand(ctx context.Context, userID string, Type int
 
 	result, err := collection.UpdateOne(ctx, filter, update)
 	if err != nil {
-		return err
+		return errs.Wrap(err)
 	}
 
 	if result.MatchedCount == 0 {
@@ -203,7 +203,7 @@ func (u *UserMgo) GetUserCommand(ctx context.Context, userID string, Type int32)
 
 	cursor, err := collection.Find(ctx, filter)
 	if err != nil {
-		return nil, err
+		return nil, errs.Wrap(err)
 	}
 	defer cursor.Close(ctx)
 
@@ -220,7 +220,7 @@ func (u *UserMgo) GetUserCommand(ctx context.Context, userID string, Type int32)
 		}
 
 		if err := cursor.Decode(&document); err != nil {
-			return nil, err
+			return nil, errs.Wrap(err)
 		}
 
 		commandInfo := &user.CommandInfoResp{
@@ -235,7 +235,7 @@ func (u *UserMgo) GetUserCommand(ctx context.Context, userID string, Type int32)
 	}
 
 	if err := cursor.Err(); err != nil {
-		return nil, err
+		return nil, errs.Wrap(err)
 	}
 
 	return commands, nil
@@ -246,7 +246,7 @@ func (u *UserMgo) GetAllUserCommand(ctx context.Context, userID string) ([]*user
 
 	cursor, err := collection.Find(ctx, filter)
 	if err != nil {
-		return nil, err
+		return nil, errs.Wrap(err)
 	}
 	defer cursor.Close(ctx)
 
@@ -263,7 +263,7 @@ func (u *UserMgo) GetAllUserCommand(ctx context.Context, userID string) ([]*user
 		}
 
 		if err := cursor.Decode(&document); err != nil {
-			return nil, err
+			return nil, errs.Wrap(err)
 		}
 
 		commandInfo := &user.AllCommandInfoResp{
@@ -278,7 +278,7 @@ func (u *UserMgo) GetAllUserCommand(ctx context.Context, userID string) ([]*user
 	}
 
 	if err := cursor.Err(); err != nil {
-		return nil, err
+		return nil, errs.Wrap(err)
 	}
 	return commands, nil
 }
diff --git a/pkg/common/db/table/relation/group.go b/pkg/common/db/table/relation/group.go
index 57d6b1d62..fca527e65 100644
--- a/pkg/common/db/table/relation/group.go
+++ b/pkg/common/db/table/relation/group.go
@@ -46,8 +46,6 @@ type GroupModelInterface interface {
 	Find(ctx context.Context, groupIDs []string) (groups []*GroupModel, err error)
 	Take(ctx context.Context, groupID string) (group *GroupModel, err error)
 	Search(ctx context.Context, keyword string, pagination pagination.Pagination) (total int64, groups []*GroupModel, err error)
-	// 获取群总数
 	CountTotal(ctx context.Context, before *time.Time) (count int64, err error)
-	// 获取范围内群增量
 	CountRangeEverydayTotal(ctx context.Context, start time.Time, end time.Time) (map[string]int64, error)
 }
diff --git a/pkg/common/discoveryregister/direct/directconn.go b/pkg/common/discoveryregister/direct/directconn.go
index 3493a86bf..1fa535192 100644
--- a/pkg/common/discoveryregister/direct/directconn.go
+++ b/pkg/common/discoveryregister/direct/directconn.go
@@ -101,13 +101,13 @@ func (cd *ConnDirect) GetConns(ctx context.Context,
 	for _, port := range ports {
 		conn, err := cd.dialServiceWithoutResolver(ctx, fmt.Sprintf(cd.config.Rpc.ListenIP+":%d", port), append(cd.additionalOpts, opts...)...)
 		if err != nil {
-			fmt.Printf("connect to port %d failed,serviceName %s, IP %s\n", port, serviceName, cd.config.Rpc.ListenIP)
+			return nil, err
 		}
 		connections = append(connections, conn)
 	}
 
 	if len(connections) == 0 {
-		return nil, fmt.Errorf("no connections found for service: %s", serviceName)
+		return nil, errs.Wrap(fmt.Errorf("no connections found for service: %s", serviceName))
 	}
 	return connections, nil
 }
@@ -130,7 +130,7 @@ func (cd *ConnDirect) GetConn(ctx context.Context, serviceName string, opts ...g
 	// Try to dial a new connection
 	conn, err := cd.dialService(ctx, result, append(cd.additionalOpts, opts...)...)
 	if err != nil {
-		return nil, errs.Wrap(err, "address", result)
+		return nil, err
 	}
 
 	// Store the new connection
@@ -157,7 +157,7 @@ func (cd *ConnDirect) dialService(ctx context.Context, address string, opts ...g
 	conn, err := grpc.DialContext(ctx, cd.resolverDirect.Scheme()+":///"+address, options...)
 
 	if err != nil {
-		return nil, err
+		return nil, errs.Wrap(err)
 	}
 	return conn, nil
 }
@@ -166,7 +166,7 @@ func (cd *ConnDirect) dialServiceWithoutResolver(ctx context.Context, address st
 	conn, err := grpc.DialContext(ctx, address, options...)
 
 	if err != nil {
-		return nil, err
+		return nil, errs.Wrap(err)
 	}
 	return conn, nil
 }
diff --git a/pkg/rpcclient/msg.go b/pkg/rpcclient/msg.go
index 6c3c46a2f..e2b6682d3 100644
--- a/pkg/rpcclient/msg.go
+++ b/pkg/rpcclient/msg.go
@@ -27,7 +27,6 @@ import (
 	"github.com/OpenIMSDK/protocol/msg"
 	"github.com/OpenIMSDK/protocol/sdkws"
 	"github.com/OpenIMSDK/tools/discoveryregistry"
-	"github.com/OpenIMSDK/tools/log"
 	"github.com/OpenIMSDK/tools/utils"
 
 	"github.com/openimsdk/open-im-server/v3/pkg/common/config"
@@ -161,7 +160,6 @@ func (m *MessageRpcClient) GetMaxSeq(ctx context.Context, req *sdkws.GetMaxSeqRe
 }
 
 func (m *MessageRpcClient) GetMaxSeqs(ctx context.Context, conversationIDs []string) (map[string]int64, error) {
-	log.ZDebug(ctx, "GetMaxSeqs", "conversationIDs", conversationIDs)
 	resp, err := m.Client.GetMaxSeqs(ctx, &msg.GetMaxSeqsReq{
 		ConversationIDs: conversationIDs,
 	})
@@ -261,8 +259,7 @@ func (s *NotificationSender) NotificationWithSesstionType(ctx context.Context, s
 	if notificationOpt.WithRpcGetUsername && s.getUserInfo != nil {
 		userInfo, err = s.getUserInfo(ctx, sendID)
 		if err != nil {
-			errInfo := fmt.Sprintf("getUserInfo failed, sendID:%s", sendID)
-			return errs.Wrap(err, errInfo)
+			return err
 		} else {
 			msg.SenderNickname = userInfo.Nickname
 			msg.SenderFaceURL = userInfo.FaceURL
@@ -295,8 +292,7 @@ func (s *NotificationSender) NotificationWithSesstionType(ctx context.Context, s
 	req.MsgData = &msg
 	_, err = s.sendMsg(ctx, &req)
 	if err != nil {
-		errInfo := fmt.Sprintf("MsgClient Notification SendMsg failed, req:%s", &req)
-		return errs.Wrap(err, errInfo)
+		return err
 	}
 	return err
 }
diff --git a/pkg/rpcclient/notification/friend.go b/pkg/rpcclient/notification/friend.go
index b40f2ba93..c8840c780 100644
--- a/pkg/rpcclient/notification/friend.go
+++ b/pkg/rpcclient/notification/friend.go
@@ -32,7 +32,7 @@ import (
 
 type FriendNotificationSender struct {
 	*rpcclient.NotificationSender
-	// 找不到报错
+	// Can't find error
 	getUsersInfo func(ctx context.Context, userIDs []string) ([]CommonUser, error)
 	// db controller
 	db controller.FriendDatabase
diff --git a/pkg/rpcclient/notification/group.go b/pkg/rpcclient/notification/group.go
index 70cc62473..15f4a22ef 100755
--- a/pkg/rpcclient/notification/group.go
+++ b/pkg/rpcclient/notification/group.go
@@ -150,7 +150,7 @@ func (g *GroupNotificationSender) getGroupMembers(ctx context.Context, groupID s
 	if err != nil {
 		return nil, err
 	}
-	if err := g.PopulateGroupMember(ctx, members...); err != nil {
+	if err = g.PopulateGroupMember(ctx, members...); err != nil {
 		return nil, err
 	}
 	log.ZDebug(ctx, "getGroupMembers", "members", members)
@@ -189,7 +189,7 @@ func (g *GroupNotificationSender) getGroupOwnerAndAdminUserID(ctx context.Contex
 	if err != nil {
 		return nil, err
 	}
-	if err := g.PopulateGroupMember(ctx, members...); err != nil {
+	if err = g.PopulateGroupMember(ctx, members...); err != nil {
 		return nil, err
 	}
 	fn := func(e *relation.GroupMemberModel) string { return e.UserID }
@@ -297,64 +297,34 @@ func (g *GroupNotificationSender) fillOpUser(ctx context.Context, opUser **sdkws
 }
 
 func (g *GroupNotificationSender) GroupCreatedNotification(ctx context.Context, tips *sdkws.GroupCreatedTips) (err error) {
-	defer log.ZDebug(ctx, "return")
-	defer func() {
-		if err != nil {
-			log.ZError(ctx, utils.GetFuncName(1)+" failed", err)
-		}
-	}()
-	if err := g.fillOpUser(ctx, &tips.OpUser, tips.Group.GroupID); err != nil {
+	if err = g.fillOpUser(ctx, &tips.OpUser, tips.Group.GroupID); err != nil {
 		return err
 	}
 	return g.Notification(ctx, mcontext.GetOpUserID(ctx), tips.Group.GroupID, constant.GroupCreatedNotification, tips)
 }
 
 func (g *GroupNotificationSender) GroupInfoSetNotification(ctx context.Context, tips *sdkws.GroupInfoSetTips) (err error) {
-	defer log.ZDebug(ctx, "return")
-	defer func() {
-		if err != nil {
-			log.ZError(ctx, utils.GetFuncName(1)+" failed", err)
-		}
-	}()
-	if err := g.fillOpUser(ctx, &tips.OpUser, tips.Group.GroupID); err != nil {
+	if err = g.fillOpUser(ctx, &tips.OpUser, tips.Group.GroupID); err != nil {
 		return err
 	}
 	return g.Notification(ctx, mcontext.GetOpUserID(ctx), tips.Group.GroupID, constant.GroupInfoSetNotification, tips, rpcclient.WithRpcGetUserName())
 }
 
 func (g *GroupNotificationSender) GroupInfoSetNameNotification(ctx context.Context, tips *sdkws.GroupInfoSetNameTips) (err error) {
-	defer log.ZDebug(ctx, "return")
-	defer func() {
-		if err != nil {
-			log.ZError(ctx, utils.GetFuncName(1)+" failed", err)
-		}
-	}()
-	if err := g.fillOpUser(ctx, &tips.OpUser, tips.Group.GroupID); err != nil {
+	if err = g.fillOpUser(ctx, &tips.OpUser, tips.Group.GroupID); err != nil {
 		return err
 	}
 	return g.Notification(ctx, mcontext.GetOpUserID(ctx), tips.Group.GroupID, constant.GroupInfoSetNameNotification, tips)
 }
 
 func (g *GroupNotificationSender) GroupInfoSetAnnouncementNotification(ctx context.Context, tips *sdkws.GroupInfoSetAnnouncementTips) (err error) {
-	defer log.ZDebug(ctx, "return")
-	defer func() {
-		if err != nil {
-			log.ZError(ctx, utils.GetFuncName(1)+" failed", err)
-		}
-	}()
-	if err := g.fillOpUser(ctx, &tips.OpUser, tips.Group.GroupID); err != nil {
+	if err = g.fillOpUser(ctx, &tips.OpUser, tips.Group.GroupID); err != nil {
 		return err
 	}
 	return g.Notification(ctx, mcontext.GetOpUserID(ctx), tips.Group.GroupID, constant.GroupInfoSetAnnouncementNotification, tips, rpcclient.WithRpcGetUserName())
 }
 
 func (g *GroupNotificationSender) JoinGroupApplicationNotification(ctx context.Context, req *pbgroup.JoinGroupReq) (err error) {
-	defer log.ZDebug(ctx, "return")
-	defer func() {
-		if err != nil {
-			log.ZError(ctx, utils.GetFuncName(1)+" failed", err)
-		}
-	}()
 	group, err := g.getGroupInfo(ctx, req.GroupID)
 	if err != nil {
 		return err
@@ -379,12 +349,6 @@ func (g *GroupNotificationSender) JoinGroupApplicationNotification(ctx context.C
 }
 
 func (g *GroupNotificationSender) MemberQuitNotification(ctx context.Context, member *sdkws.GroupMemberFullInfo) (err error) {
-	defer log.ZDebug(ctx, "return")
-	defer func() {
-		if err != nil {
-			log.ZError(ctx, utils.GetFuncName(1)+" failed", err)
-		}
-	}()
 	group, err := g.getGroupInfo(ctx, member.GroupID)
 	if err != nil {
 		return err
@@ -394,12 +358,6 @@ func (g *GroupNotificationSender) MemberQuitNotification(ctx context.Context, me
 }
 
 func (g *GroupNotificationSender) GroupApplicationAcceptedNotification(ctx context.Context, req *pbgroup.GroupApplicationResponseReq) (err error) {
-	defer log.ZDebug(ctx, "return")
-	defer func() {
-		if err != nil {
-			log.ZError(ctx, utils.GetFuncName(1)+" failed", err)
-		}
-	}()
 	group, err := g.getGroupInfo(ctx, req.GroupID)
 	if err != nil {
 		return err
@@ -427,12 +385,6 @@ func (g *GroupNotificationSender) GroupApplicationAcceptedNotification(ctx conte
 }
 
 func (g *GroupNotificationSender) GroupApplicationRejectedNotification(ctx context.Context, req *pbgroup.GroupApplicationResponseReq) (err error) {
-	defer log.ZDebug(ctx, "return")
-	defer func() {
-		if err != nil {
-			log.ZError(ctx, utils.GetFuncName(1)+" failed", err)
-		}
-	}()
 	group, err := g.getGroupInfo(ctx, req.GroupID)
 	if err != nil {
 		return err
@@ -460,12 +412,6 @@ func (g *GroupNotificationSender) GroupApplicationRejectedNotification(ctx conte
 }
 
 func (g *GroupNotificationSender) GroupOwnerTransferredNotification(ctx context.Context, req *pbgroup.TransferGroupOwnerReq) (err error) {
-	defer log.ZDebug(ctx, "return")
-	defer func() {
-		if err != nil {
-			log.ZError(ctx, utils.GetFuncName(1)+" failed", err)
-		}
-	}()
 	group, err := g.getGroupInfo(ctx, req.GroupID)
 	if err != nil {
 		return err
@@ -476,32 +422,20 @@ func (g *GroupNotificationSender) GroupOwnerTransferredNotification(ctx context.
 		return err
 	}
 	tips := &sdkws.GroupOwnerTransferredTips{Group: group, OpUser: member[opUserID], NewGroupOwner: member[req.NewOwnerUserID]}
-	if err := g.fillOpUser(ctx, &tips.OpUser, tips.Group.GroupID); err != nil {
+	if err = g.fillOpUser(ctx, &tips.OpUser, tips.Group.GroupID); err != nil {
 		return err
 	}
 	return g.Notification(ctx, mcontext.GetOpUserID(ctx), group.GroupID, constant.GroupOwnerTransferredNotification, tips)
 }
 
 func (g *GroupNotificationSender) MemberKickedNotification(ctx context.Context, tips *sdkws.MemberKickedTips) (err error) {
-	defer log.ZDebug(ctx, "return")
-	defer func() {
-		if err != nil {
-			log.ZError(ctx, utils.GetFuncName(1)+" failed", err)
-		}
-	}()
-	if err := g.fillOpUser(ctx, &tips.OpUser, tips.Group.GroupID); err != nil {
+	if err = g.fillOpUser(ctx, &tips.OpUser, tips.Group.GroupID); err != nil {
 		return err
 	}
 	return g.Notification(ctx, mcontext.GetOpUserID(ctx), tips.Group.GroupID, constant.MemberKickedNotification, tips)
 }
 
 func (g *GroupNotificationSender) MemberInvitedNotification(ctx context.Context, groupID, reason string, invitedUserIDList []string) (err error) {
-	defer log.ZDebug(ctx, "return")
-	defer func() {
-		if err != nil {
-			log.ZError(ctx, utils.GetFuncName(1)+" failed", err)
-		}
-	}()
 	group, err := g.getGroupInfo(ctx, groupID)
 	if err != nil {
 		return err
@@ -514,19 +448,13 @@ func (g *GroupNotificationSender) MemberInvitedNotification(ctx context.Context,
 		return err
 	}
 	tips := &sdkws.MemberInvitedTips{Group: group, InvitedUserList: users}
-	if err := g.fillOpUser(ctx, &tips.OpUser, tips.Group.GroupID); err != nil {
+	if err = g.fillOpUser(ctx, &tips.OpUser, tips.Group.GroupID); err != nil {
 		return err
 	}
 	return g.Notification(ctx, mcontext.GetOpUserID(ctx), group.GroupID, constant.MemberInvitedNotification, tips)
 }
 
 func (g *GroupNotificationSender) MemberEnterNotification(ctx context.Context, groupID string, entrantUserID string) (err error) {
-	defer log.ZDebug(ctx, "return")
-	defer func() {
-		if err != nil {
-			log.ZError(ctx, utils.GetFuncName(1)+" failed", err)
-		}
-	}()
 	group, err := g.getGroupInfo(ctx, groupID)
 	if err != nil {
 		return err
@@ -540,25 +468,13 @@ func (g *GroupNotificationSender) MemberEnterNotification(ctx context.Context, g
 }
 
 func (g *GroupNotificationSender) GroupDismissedNotification(ctx context.Context, tips *sdkws.GroupDismissedTips) (err error) {
-	defer log.ZDebug(ctx, "return")
-	defer func() {
-		if err != nil {
-			log.ZError(ctx, utils.GetFuncName(1)+" failed", err)
-		}
-	}()
-	if err := g.fillOpUser(ctx, &tips.OpUser, tips.Group.GroupID); err != nil {
+	if err = g.fillOpUser(ctx, &tips.OpUser, tips.Group.GroupID); err != nil {
 		return err
 	}
 	return g.Notification(ctx, mcontext.GetOpUserID(ctx), tips.Group.GroupID, constant.GroupDismissedNotification, tips)
 }
 
 func (g *GroupNotificationSender) GroupMemberMutedNotification(ctx context.Context, groupID, groupMemberUserID string, mutedSeconds uint32) (err error) {
-	defer log.ZDebug(ctx, "return")
-	defer func() {
-		if err != nil {
-			log.ZError(ctx, utils.GetFuncName(1)+" failed", err)
-		}
-	}()
 	group, err := g.getGroupInfo(ctx, groupID)
 	if err != nil {
 		return err
@@ -571,19 +487,13 @@ func (g *GroupNotificationSender) GroupMemberMutedNotification(ctx context.Conte
 		Group: group, MutedSeconds: mutedSeconds,
 		OpUser: user[mcontext.GetOpUserID(ctx)], MutedUser: user[groupMemberUserID],
 	}
-	if err := g.fillOpUser(ctx, &tips.OpUser, tips.Group.GroupID); err != nil {
+	if err = g.fillOpUser(ctx, &tips.OpUser, tips.Group.GroupID); err != nil {
 		return err
 	}
 	return g.Notification(ctx, mcontext.GetOpUserID(ctx), group.GroupID, constant.GroupMemberMutedNotification, tips)
 }
 
 func (g *GroupNotificationSender) GroupMemberCancelMutedNotification(ctx context.Context, groupID, groupMemberUserID string) (err error) {
-	defer log.ZDebug(ctx, "return")
-	defer func() {
-		if err != nil {
-			log.ZError(ctx, utils.GetFuncName(1)+" failed", err)
-		}
-	}()
 	group, err := g.getGroupInfo(ctx, groupID)
 	if err != nil {
 		return err
@@ -593,19 +503,13 @@ func (g *GroupNotificationSender) GroupMemberCancelMutedNotification(ctx context
 		return err
 	}
 	tips := &sdkws.GroupMemberCancelMutedTips{Group: group, OpUser: user[mcontext.GetOpUserID(ctx)], MutedUser: user[groupMemberUserID]}
-	if err := g.fillOpUser(ctx, &tips.OpUser, tips.Group.GroupID); err != nil {
+	if err = g.fillOpUser(ctx, &tips.OpUser, tips.Group.GroupID); err != nil {
 		return err
 	}
 	return g.Notification(ctx, mcontext.GetOpUserID(ctx), group.GroupID, constant.GroupMemberCancelMutedNotification, tips)
 }
 
 func (g *GroupNotificationSender) GroupMutedNotification(ctx context.Context, groupID string) (err error) {
-	defer log.ZDebug(ctx, "return")
-	defer func() {
-		if err != nil {
-			log.ZError(ctx, utils.GetFuncName(1)+" failed", err)
-		}
-	}()
 	group, err := g.getGroupInfo(ctx, groupID)
 	if err != nil {
 		return err
@@ -618,19 +522,13 @@ func (g *GroupNotificationSender) GroupMutedNotification(ctx context.Context, gr
 	if len(users) > 0 {
 		tips.OpUser = users[0]
 	}
-	if err := g.fillOpUser(ctx, &tips.OpUser, tips.Group.GroupID); err != nil {
+	if err = g.fillOpUser(ctx, &tips.OpUser, tips.Group.GroupID); err != nil {
 		return err
 	}
 	return g.Notification(ctx, mcontext.GetOpUserID(ctx), group.GroupID, constant.GroupMutedNotification, tips)
 }
 
 func (g *GroupNotificationSender) GroupCancelMutedNotification(ctx context.Context, groupID string) (err error) {
-	defer log.ZDebug(ctx, "return")
-	defer func() {
-		if err != nil {
-			log.ZError(ctx, utils.GetFuncName(1)+" failed", err)
-		}
-	}()
 	group, err := g.getGroupInfo(ctx, groupID)
 	if err != nil {
 		return err
@@ -643,7 +541,7 @@ func (g *GroupNotificationSender) GroupCancelMutedNotification(ctx context.Conte
 	if len(users) > 0 {
 		tips.OpUser = users[0]
 	}
-	if err := g.fillOpUser(ctx, &tips.OpUser, tips.Group.GroupID); err != nil {
+	if err = g.fillOpUser(ctx, &tips.OpUser, tips.Group.GroupID); err != nil {
 		return err
 	}
 	return g.Notification(ctx, mcontext.GetOpUserID(ctx), group.GroupID, constant.GroupCancelMutedNotification, tips)
@@ -659,7 +557,7 @@ func (g *GroupNotificationSender) GroupMemberInfoSetNotification(ctx context.Con
 		return err
 	}
 	tips := &sdkws.GroupMemberInfoSetTips{Group: group, OpUser: user[mcontext.GetOpUserID(ctx)], ChangedUser: user[groupMemberUserID]}
-	if err := g.fillOpUser(ctx, &tips.OpUser, tips.Group.GroupID); err != nil {
+	if err = g.fillOpUser(ctx, &tips.OpUser, tips.Group.GroupID); err != nil {
 		return err
 	}
 	return g.Notification(ctx, mcontext.GetOpUserID(ctx), group.GroupID, constant.GroupMemberInfoSetNotification, tips)
@@ -675,19 +573,13 @@ func (g *GroupNotificationSender) GroupMemberSetToAdminNotification(ctx context.
 		return err
 	}
 	tips := &sdkws.GroupMemberInfoSetTips{Group: group, OpUser: user[mcontext.GetOpUserID(ctx)], ChangedUser: user[groupMemberUserID]}
-	if err := g.fillOpUser(ctx, &tips.OpUser, tips.Group.GroupID); err != nil {
+	if err = g.fillOpUser(ctx, &tips.OpUser, tips.Group.GroupID); err != nil {
 		return err
 	}
 	return g.Notification(ctx, mcontext.GetOpUserID(ctx), group.GroupID, constant.GroupMemberSetToAdminNotification, tips)
 }
 
 func (g *GroupNotificationSender) GroupMemberSetToOrdinaryUserNotification(ctx context.Context, groupID, groupMemberUserID string) (err error) {
-	defer log.ZDebug(ctx, "return")
-	defer func() {
-		if err != nil {
-			log.ZError(ctx, utils.GetFuncName(1)+" failed", err)
-		}
-	}()
 	group, err := g.getGroupInfo(ctx, groupID)
 	if err != nil {
 		return err
@@ -697,19 +589,13 @@ func (g *GroupNotificationSender) GroupMemberSetToOrdinaryUserNotification(ctx c
 		return err
 	}
 	tips := &sdkws.GroupMemberInfoSetTips{Group: group, OpUser: user[mcontext.GetOpUserID(ctx)], ChangedUser: user[groupMemberUserID]}
-	if err := g.fillOpUser(ctx, &tips.OpUser, tips.Group.GroupID); err != nil {
+	if err = g.fillOpUser(ctx, &tips.OpUser, tips.Group.GroupID); err != nil {
 		return err
 	}
 	return g.Notification(ctx, mcontext.GetOpUserID(ctx), group.GroupID, constant.GroupMemberSetToOrdinaryUserNotification, tips)
 }
 
 func (g *GroupNotificationSender) SuperGroupNotification(ctx context.Context, sendID, recvID string) (err error) {
-	defer log.ZDebug(ctx, "return")
-	defer func() {
-		if err != nil {
-			log.ZError(ctx, utils.GetFuncName(1)+" failed", err)
-		}
-	}()
 	err = g.Notification(ctx, sendID, recvID, constant.SuperGroupUpdateNotification, nil)
 	return err
 }