替换日志库为slog

rpc/client.go

@@ -81,14 +81,14 @@ func (bc *Client) checkRpcCallTimeout() {
 			pCall := bc.pending[callSeq]
 			if pCall == nil {
 				bc.pendingLock.Unlock()
-				log.SError("callSeq ",callSeq," is not find")
+				log.Error("call seq is not find",log.Uint64("seq", callSeq))
 				continue
 			}
 
 			delete(bc.pending,callSeq)
 			strTimeout := strconv.FormatInt(int64(pCall.TimeOut.Seconds()), 10)
 			pCall.Err = errors.New("RPC call takes more than " + strTimeout + " seconds,method is "+pCall.ServiceMethod)
-			log.SError(pCall.Err.Error())
+			log.Error("call timeout",log.String("error",pCall.Err.Error()))
 			bc.makeCallFail(pCall)
 			bc.pendingLock.Unlock()
 			continue
@@ -108,7 +108,7 @@ func (bc *Client) AddPending(call *Call) {
 
 	if call.Seq == 0 {
 		bc.pendingLock.Unlock()
-		log.SStack("call is error.")
+		log.Stack("call is error.")
 		return
 	}
 
@@ -160,7 +160,7 @@ func (bc *Client) cleanPending(){
 		}
 		pCall := bc.pending[callSeq]
 		if pCall == nil {
-			log.SError("callSeq ",callSeq," is not find")
+			log.Error("call Seq is not find",log.Uint64("seq",callSeq))
 			continue
 		}
 

rpc/lclient.go

@@ -43,7 +43,7 @@ func (lc *LClient) Go(timeout time.Duration,rpcHandler IRpcHandler,noReply bool,
 	findIndex := strings.Index(serviceMethod, ".")
 	if findIndex == -1 {
 		sErr := errors.New("Call serviceMethod " + serviceMethod + " is error!")
-		log.SError(sErr.Error())
+		log.Error("call rpc fail",log.String("error",sErr.Error()))
 		call := MakeCall()
 		call.DoError(sErr)
 
@@ -100,7 +100,7 @@ func (lc *LClient) AsyncCall(timeout time.Duration,rpcHandler IRpcHandler, servi
 	if findIndex == -1 {
 		err := errors.New("Call serviceMethod " + serviceMethod + " is error!")
 		callback.Call([]reflect.Value{reflect.ValueOf(reply), reflect.ValueOf(err)})
-		log.SError(err.Error())
+		log.Error("serviceMethod format is error",log.String("error",err.Error()))
 		return emptyCancelRpc,nil
 	}
 

rpc/rclient.go

@@ -46,7 +46,7 @@ func (rc *RClient) Go(timeout time.Duration,rpcHandler IRpcHandler,noReply bool,
 	_, processor := GetProcessorType(args)
 	InParam, err := processor.Marshal(args)
 	if err != nil {
-		log.SError(err.Error())
+		log.Error("Marshal is fail",log.ErrorAttr("error",err))
 		call := MakeCall()
 		call.DoError(err)
 		return call
@@ -68,7 +68,7 @@ func (rc *RClient) RawGo(timeout time.Duration,rpcHandler IRpcHandler,processor
 
 	if err != nil {
 		call.Seq = 0
-		log.SError(err.Error())
+		log.Error("marshal is fail",log.String("error",err.Error()))
 		call.DoError(err)
 		return call
 	}
@@ -77,7 +77,7 @@ func (rc *RClient) RawGo(timeout time.Duration,rpcHandler IRpcHandler,processor
 	if conn == nil || conn.IsConnected()==false {
 		call.Seq = 0
 		sErr := errors.New(serviceMethod + "  was called failed,rpc client is disconnect")
-		log.SError(sErr.Error())
+		log.Error("conn is disconnect",log.String("error",sErr.Error()))
 		call.DoError(sErr)
 		return call
 	}
@@ -89,7 +89,7 @@ func (rc *RClient) RawGo(timeout time.Duration,rpcHandler IRpcHandler,processor
 		compressBuff,cErr = compressor.CompressBlock(bytes)
 		if cErr != nil {
 			call.Seq = 0
-			log.SError(cErr.Error())
+			log.Error("compress fail",log.String("error",cErr.Error()))
 			call.DoError(cErr)
 			return call
 		}
@@ -109,9 +109,7 @@ func (rc *RClient) RawGo(timeout time.Duration,rpcHandler IRpcHandler,processor
 	}
 	if err != nil {
 		rc.selfClient.RemovePending(call.Seq)
-
-		log.SError(err.Error())
-
+		log.Error("WiteMsg is fail",log.ErrorAttr("error",err))
 		call.Seq = 0
 		call.DoError(err)
 	}
@@ -191,14 +189,13 @@ func (rc *RClient) asyncCall(timeout time.Duration,rpcHandler IRpcHandler, servi
 	return emptyCancelRpc,nil
 }
 
-
 func (rc *RClient) Run() {
 	defer func() {
 		if r := recover(); r != nil {
 			buf := make([]byte, 4096)
 			l := runtime.Stack(buf, false)
 			errString := fmt.Sprint(r)
-			log.SError("core dump info[", errString, "]\n", string(buf[:l]))
+			log.Dump(string(buf[:l]),log.String("error",errString))
 		}
 	}()
 
@@ -206,7 +203,7 @@ func (rc *RClient) Run() {
 	for {
 		bytes, err := rc.conn.ReadMsg()
 		if err != nil {
-			log.SError("rpcClient ", rc.Addr, " ReadMsg error:", err.Error())
+			log.Error("rclient read msg is failed",log.ErrorAttr("error",err))
 			return
 		}
 
@@ -214,7 +211,7 @@ func (rc *RClient) Run() {
 		processor := GetProcessor(bytes[0]&0x7f)
 		if processor == nil {
 			rc.conn.ReleaseReadMsg(bytes)
-			log.SError("rpcClient ", rc.Addr, " ReadMsg head error:", err.Error())
+			log.Error("cannot find process",log.Uint8("process type",bytes[0]&0x7f))
 			return
 		}
 
@@ -231,7 +228,7 @@ func (rc *RClient) Run() {
 			compressBuff,unCompressErr = compressor.UncompressBlock(byteData)
 			if unCompressErr!= nil {
 				rc.conn.ReleaseReadMsg(bytes)
-				log.SError("rpcClient ", rc.Addr, " ReadMsg head error:", unCompressErr.Error())
+				log.Error("uncompressBlock failed",log.ErrorAttr("error",unCompressErr))
 				return
 			}
 			byteData = compressBuff
@@ -245,19 +242,19 @@ func (rc *RClient) Run() {
 		rc.conn.ReleaseReadMsg(bytes)
 		if err != nil {
 			processor.ReleaseRpcResponse(response.RpcResponseData)
-			log.SError("rpcClient Unmarshal head error:", err.Error())
+			log.Error("rpcClient Unmarshal head error",log.ErrorAttr("error",err))
 			continue
 		}
 		
 		v := rc.selfClient.RemovePending(response.RpcResponseData.GetSeq())
 		if v == nil {
-			log.SError("rpcClient cannot find seq ", response.RpcResponseData.GetSeq(), " in pending")
+			log.Error("rpcClient cannot find seq",log.Uint64("seq",response.RpcResponseData.GetSeq()))
 		} else {
 			v.Err = nil
 			if len(response.RpcResponseData.GetReply()) > 0 {
 				err = processor.Unmarshal(response.RpcResponseData.GetReply(), v.Reply)
 				if err != nil {
-					log.SError("rpcClient Unmarshal body error:", err.Error())
+					log.Error("rpcClient Unmarshal body failed",log.ErrorAttr("error",err))
 					v.Err = err
 				}
 			}

rpc/rpchandler.go

@@ -215,7 +215,7 @@ func (handler *RpcHandler) HandlerRpcResponseCB(call *Call) {
 			buf := make([]byte, 4096)
 			l := runtime.Stack(buf, false)
 			errString := fmt.Sprint(r)
-			log.SError("core dump info[", errString, "]\n", string(buf[:l]))
+			log.Dump(string(buf[:l]),log.String("error",errString))
 		}
 	}()
 
@@ -237,7 +237,7 @@ func (handler *RpcHandler) HandlerRpcRequest(request *RpcRequest) {
 			buf := make([]byte, 4096)
 			l := runtime.Stack(buf, false)
 			errString := fmt.Sprint(r)
-			log.SError("Handler Rpc ", request.RpcRequestData.GetServiceMethod(), " Core dump info[", errString, "]\n", string(buf[:l]))
+			log.Dump(string(buf[:l]),log.String("error",errString))
 			rpcErr := RpcError("call error : core dumps")
 			if request.requestHandle != nil {
 				request.requestHandle(nil, rpcErr)
@@ -250,12 +250,12 @@ func (handler *RpcHandler) HandlerRpcRequest(request *RpcRequest) {
 	if rawRpcId > 0 {
 		v, ok := handler.mapRawFunctions[rawRpcId]
 		if ok == false {
-			log.SError("RpcHandler cannot find request rpc id", rawRpcId)
+			log.Error("RpcHandler cannot find request rpc id",log.Uint32("rawRpcId",rawRpcId))
 			return
 		}
 		rawData,ok := request.inParam.([]byte)
 		if ok == false {
-			log.SError("RpcHandler " + handler.rpcHandler.GetName()," cannot convert in param to []byte", rawRpcId)
+			log.Error("RpcHandler cannot  convert",log.String("RpcHandlerName",handler.rpcHandler.GetName()),log.Uint32("rawRpcId",rawRpcId))
 			return
 		}
 
@@ -267,7 +267,7 @@ func (handler *RpcHandler) HandlerRpcRequest(request *RpcRequest) {
 	v, ok := handler.mapFunctions[request.RpcRequestData.GetServiceMethod()]
 	if ok == false {
 		err := "RpcHandler " + handler.rpcHandler.GetName() + "cannot find " + request.RpcRequestData.GetServiceMethod()
-		log.SError(err)
+		log.Error("HandlerRpcRequest cannot find serviceMethod",log.String("RpcHandlerName",handler.rpcHandler.GetName()),log.String("serviceMethod",request.RpcRequestData.GetServiceMethod()))
 		if request.requestHandle != nil {
 			request.requestHandle(nil, RpcError(err))
 		}
@@ -298,7 +298,7 @@ func (handler *RpcHandler) HandlerRpcRequest(request *RpcRequest) {
 		paramList = append(paramList, oParam) //输出参数
 	} else if request.requestHandle != nil && v.hasResponder == false { //调用方有返回值，但被调用函数没有返回参数
 		rErr := "Call Rpc " + request.RpcRequestData.GetServiceMethod() + " without return parameter!"
-		log.SError(rErr)
+		log.Error("call serviceMethod without return parameter",log.String("serviceMethod",request.RpcRequestData.GetServiceMethod()))
 		request.requestHandle(nil, RpcError(rErr))
 		return
 	}
@@ -320,7 +320,7 @@ func (handler *RpcHandler) CallMethod(client *Client,ServiceMethod string, param
 	v, ok := handler.mapFunctions[ServiceMethod]
 	if ok == false {
 		err = errors.New("RpcHandler " + handler.rpcHandler.GetName() + " cannot find" + ServiceMethod)
-		log.SError(err.Error())
+		log.Error("CallMethod cannot find serviceMethod",log.String("rpcHandlerName",handler.rpcHandler.GetName()),log.String("serviceMethod",ServiceMethod))
 		return err
 	}
 
@@ -344,7 +344,7 @@ func (handler *RpcHandler) CallMethod(client *Client,ServiceMethod string, param
 			hander :=func(Returns interface{}, Err RpcError) {
 				rpcCall := client.RemovePending(callSeq)
 				if rpcCall == nil {
-					log.SError("cannot find call seq ",callSeq)
+					log.Error("cannot find call seq",log.Uint64("seq",callSeq))
 					return
 				}
 
@@ -431,15 +431,15 @@ func (handler *RpcHandler) goRpc(processor IRpcProcessor, bCast bool, nodeId int
 	err, count := handler.funcRpcClient(nodeId, serviceMethod, pClientList[:])
 	if count == 0 {
 		if err != nil {
-			log.SError("Call ", serviceMethod, " is error:", err.Error())
+			log.Error("call serviceMethod is failed",log.String("serviceMethod",serviceMethod),log.ErrorAttr("error",err))
 		} else {
-			log.SError("Can not find ", serviceMethod)
+			log.Error("cannot find serviceMethod",log.String("serviceMethod",serviceMethod))
 		}
 		return err
 	}
 
 	if count > 1 && bCast == false {
-		log.SError("Cannot call %s more then 1 node!", serviceMethod)
+		log.Error("cannot call serviceMethod more then 1 node",log.String("serviceMethod",serviceMethod))
 		return errors.New("cannot call more then 1 node")
 	}
 
@@ -460,14 +460,14 @@ func (handler *RpcHandler) callRpc(timeout time.Duration,nodeId int, serviceMeth
 	var pClientList [maxClusterNode]*Client
 	err, count := handler.funcRpcClient(nodeId, serviceMethod, pClientList[:])
 	if err != nil {
-		log.SError("Call serviceMethod is error:", err.Error())
+		log.Error("Call serviceMethod is failed",log.ErrorAttr("error",err))
 		return err
 	} else if count <= 0 {
 		err = errors.New("Call serviceMethod is error:cannot find " + serviceMethod)
-		log.SError(err.Error())
+		log.Error("cannot find serviceMethod",log.String("serviceMethod",serviceMethod))
 		return err
 	} else if count > 1 {
-		log.SError("Cannot call more then 1 node!")
+		log.Error("Cannot call more then 1 node!",log.String("serviceMethod",serviceMethod))
 		return errors.New("cannot call more then 1 node")
 	}
 
@@ -484,19 +484,19 @@ func (handler *RpcHandler) asyncCallRpc(timeout time.Duration,nodeId int, servic
 	fVal := reflect.ValueOf(callback)
 	if fVal.Kind() != reflect.Func {
 		err := errors.New("call " + serviceMethod + " input callback param is error!")
-		log.SError(err.Error())
+		log.Error("input callback param is error",log.String("serviceMethod",serviceMethod))
 		return emptyCancelRpc,err
 	}
 
 	if fVal.Type().NumIn() != 2 {
 		err := errors.New("call " + serviceMethod + " callback param function is error!")
-		log.SError(err.Error())
+		log.Error("callback param function is error",log.String("serviceMethod",serviceMethod))
 		return emptyCancelRpc,err
 	}
 
 	if fVal.Type().In(0).Kind() != reflect.Ptr || fVal.Type().In(1).String() != "error" {
 		err := errors.New("call " + serviceMethod + " callback param function is error!")
-		log.SError(err.Error())
+		log.Error("callback param function is error",log.String("serviceMethod",serviceMethod))
 		return emptyCancelRpc,err
 	}
 
@@ -512,14 +512,14 @@ func (handler *RpcHandler) asyncCallRpc(timeout time.Duration,nodeId int, servic
 			}
 		}
 		fVal.Call([]reflect.Value{reflect.ValueOf(reply), reflect.ValueOf(err)})
-		log.SError("Call serviceMethod is error:", err.Error())
+		log.Error("cannot find serviceMethod from node",log.String("serviceMethod",serviceMethod),log.Int("nodeId",nodeId))
 		return emptyCancelRpc,nil
 	}
 
 	if count > 1 {
 		err := errors.New("cannot call more then 1 node")
 		fVal.Call([]reflect.Value{reflect.ValueOf(reply), reflect.ValueOf(err)})
-		log.SError(err.Error())
+		log.Error("cannot call more then 1 node",log.String("serviceMethod",serviceMethod))
 		return emptyCancelRpc,nil
 	}
 
@@ -587,12 +587,12 @@ func (handler *RpcHandler) RawGoNode(rpcProcessorType RpcProcessorType, nodeId i
 	processor := GetProcessor(uint8(rpcProcessorType))
 	err, count := handler.funcRpcClient(nodeId, serviceName, handler.pClientList)
 	if count == 0 || err != nil {
-		log.SError("Call serviceMethod is error:", err.Error())
+		log.Error("call serviceMethod is failed",log.ErrorAttr("error",err))
 		return err
 	}
 	if count > 1 {
 		err := errors.New("cannot call more then 1 node")
-		log.SError(err.Error())
+		log.Error("cannot call more then 1 node",log.String("serviceName",serviceName))
 		return err
 	}
 

rpc/server.go

@@ -69,7 +69,7 @@ const Default_ReadWriteDeadline = 15*time.Second
 func (server *Server) Start(listenAddr string, maxRpcParamLen uint32,compressBytesLen int) {
 	splitAddr := strings.Split(listenAddr, ":")
 	if len(splitAddr) != 2 {
-		log.SFatal("listen addr is error :", listenAddr)
+		log.Fatal("listen addr is failed", log.String("listenAddr",listenAddr))
 	}
 
 	server.rpcServer.Addr = ":" + splitAddr[1]
@@ -111,7 +111,7 @@ func (agent *RpcAgent) WriteResponse(processor IRpcProcessor, serviceMethod stri
 	defer processor.ReleaseRpcResponse(rpcResponse.RpcResponseData)
 
 	if errM != nil {
-		log.SError("service method ", serviceMethod, " Marshal error:", errM.Error())
+		log.Error("mashal RpcResponseData failed",log.String("serviceMethod",serviceMethod),log.ErrorAttr("error",errM))
 		return
 	}
 
@@ -122,7 +122,7 @@ func (agent *RpcAgent) WriteResponse(processor IRpcProcessor, serviceMethod stri
 
 		compressBuff,cErr = compressor.CompressBlock(bytes)
 		if cErr != nil {
-			log.SError("service method ", serviceMethod, " CompressBlock error:", cErr.Error())
+			log.Error("CompressBlock failed",log.String("serviceMethod",serviceMethod),log.ErrorAttr("error",cErr))
 			return
 		}
 		if len(compressBuff) < len(bytes) {
@@ -136,7 +136,7 @@ func (agent *RpcAgent) WriteResponse(processor IRpcProcessor, serviceMethod stri
 		compressor.CompressBufferCollection(compressBuff)
 	}
 	if errM != nil {
-		log.SError("Rpc ", serviceMethod, " return is error:", errM.Error())
+		log.Error("WriteMsg error,Rpc return is fail",log.String("serviceMethod",serviceMethod),log.ErrorAttr("error",errM))
 	}
 }
 
@@ -144,7 +144,7 @@ func (agent *RpcAgent) Run() {
 	for {
 		data, err := agent.conn.ReadMsg()
 		if err != nil {
-			log.SError("remoteAddress:", agent.conn.RemoteAddr().String(), ",read message: ", err.Error())
+			log.Error("read message is error",log.String("remoteAddress",agent.conn.RemoteAddr().String()),log.ErrorAttr("error",err))
 			//will close tcpconn
 			break
 		}
@@ -153,7 +153,7 @@ func (agent *RpcAgent) Run() {
 		processor := GetProcessor(data[0]&0x7f)
 		if processor == nil {
 			agent.conn.ReleaseReadMsg(data)
-			log.SError("remote rpc  ", agent.conn.RemoteAddr().String(), " cannot find processor:", data[0])
+			log.Warning("cannot find processor",log.String("RemoteAddr",agent.conn.RemoteAddr().String()))
 			return
 		}
 
@@ -166,7 +166,7 @@ func (agent *RpcAgent) Run() {
 			compressBuff,unCompressErr = compressor.UncompressBlock(byteData)
 			if unCompressErr!= nil {
 				agent.conn.ReleaseReadMsg(data)
-				log.SError("rpcClient ", agent.conn.RemoteAddr().String(), " ReadMsg head error:", unCompressErr.Error())
+				log.Error("UncompressBlock failed",log.String("RemoteAddr",agent.conn.RemoteAddr().String()),log.ErrorAttr("error",unCompressErr))
 				return
 			}
 			byteData = compressBuff
@@ -179,7 +179,7 @@ func (agent *RpcAgent) Run() {
 		}
 		agent.conn.ReleaseReadMsg(data)
 		if err != nil {
-			log.SError("rpc Unmarshal request is error:", err.Error())
+			log.Error("Unmarshal failed",log.String("RemoteAddr",agent.conn.RemoteAddr().String()),log.ErrorAttr("error",err))
 			if req.RpcRequestData.GetSeq() > 0 {
 				rpcError := RpcError(err.Error())
 				if req.RpcRequestData.IsNoReply() == false {
@@ -201,7 +201,7 @@ func (agent *RpcAgent) Run() {
 				agent.WriteResponse(processor, req.RpcRequestData.GetServiceMethod(), req.RpcRequestData.GetSeq(), nil, rpcError)
 			}
 			ReleaseRpcRequest(req)
-			log.SError("rpc request req.ServiceMethod is error")
+			log.Error("rpc request req.ServiceMethod is error")
 			continue
 		}
 
@@ -211,8 +211,7 @@ func (agent *RpcAgent) Run() {
 			if req.RpcRequestData.IsNoReply() == false {
 				agent.WriteResponse(processor, req.RpcRequestData.GetServiceMethod(), req.RpcRequestData.GetSeq(), nil, rpcError)
 			}
-
-			log.SError("service method ", req.RpcRequestData.GetServiceMethod(), " not config!")
+			log.Error("serviceMethod not config",log.String("serviceMethod",req.RpcRequestData.GetServiceMethod()))
 			ReleaseRpcRequest(req)
 			continue
 		}
@@ -232,7 +231,7 @@ func (agent *RpcAgent) Run() {
 			} else {
 				ReleaseRpcRequest(req)
 			}
-			log.SError(rErr)
+			log.Error("call rpc param error",log.String("serviceMethod",req.RpcRequestData.GetServiceMethod()),log.ErrorAttr("error",err))
 			continue
 		}
 
@@ -281,7 +280,7 @@ func (server *Server) myselfRpcHandlerGo(client *Client,handlerName string, serv
 	rpcHandler := server.rpcHandleFinder.FindRpcHandler(handlerName)
 	if rpcHandler == nil {
 		err := errors.New("service method " + serviceMethod + " not config!")
-		log.SError(err.Error())
+		log.Error("service method not config",log.String("serviceMethod",serviceMethod))
 		return err
 	}
 	
@@ -297,7 +296,7 @@ func (server *Server) selfNodeRpcHandlerGo(timeout time.Duration,processor IRpcP
 	rpcHandler := server.rpcHandleFinder.FindRpcHandler(handlerName)
 	if rpcHandler == nil {
 		err := errors.New("service method " + serviceMethod + " not config!")
-		log.SError(err.Error())
+		log.Error("service method not config",log.String("serviceMethod",serviceMethod),log.ErrorAttr("error",err))
 		pCall.Seq = 0
 		pCall.DoError(err)
 
@@ -314,7 +313,7 @@ func (server *Server) selfNodeRpcHandlerGo(timeout time.Duration,processor IRpcP
 		iParam,err = processor.Clone(args)
 		if err != nil {
 			sErr := errors.New("RpcHandler " + handlerName + "."+serviceMethod+" deep copy inParam is error:" + err.Error())
-			log.SError(sErr.Error())
+			log.Error("deep copy inParam is failed",log.String("handlerName",handlerName),log.String("serviceMethod",serviceMethod))
 			pCall.Seq = 0
 			pCall.DoError(sErr)
 
@@ -329,7 +328,7 @@ func (server *Server) selfNodeRpcHandlerGo(timeout time.Duration,processor IRpcP
 		var err error
 		req.inParam, err = rpcHandler.UnmarshalInParam(processor, serviceMethod, rpcMethodId, rawArgs)
 		if err != nil {
-			log.SError(err.Error())
+			log.Error("unmarshalInParam is failed",log.String("serviceMethod",serviceMethod),log.Uint32("rpcMethodId",rpcMethodId),log.ErrorAttr("error",err))
 			pCall.Seq = 0
 			pCall.DoError(err)
 			ReleaseRpcRequest(req)
@@ -345,12 +344,12 @@ func (server *Server) selfNodeRpcHandlerGo(timeout time.Duration,processor IRpcP
 				byteReturns, err := req.rpcProcessor.Marshal(Returns)
 				if err != nil {
 					Err = ConvertError(err)
-					log.SError("returns data cannot be marshal,callSeq is ", callSeq," error is ",err.Error())
+					log.Error("returns data cannot be marshal",log.Uint64("seq",callSeq),log.ErrorAttr("error",err))
 				}else{
 					err = req.rpcProcessor.Unmarshal(byteReturns, reply)
 					if err != nil {
 						Err = ConvertError(err)
-						log.SError("returns data cannot be Unmarshal,callSeq is ", callSeq," error is ",err.Error())
+						log.Error("returns data cannot be Unmarshal",log.Uint64("seq",callSeq),log.ErrorAttr("error",err))
 					}
 				}
 			}
@@ -358,8 +357,7 @@ func (server *Server) selfNodeRpcHandlerGo(timeout time.Duration,processor IRpcP
 			ReleaseRpcRequest(req)
 			v := client.RemovePending(callSeq)
 			if v == nil {
-				log.SError("rpcClient cannot find seq ",callSeq, " in pending")
-
+				log.Error("rpcClient cannot find seq",log.Uint64("seq",callSeq))
 				return
 			}
 
@@ -367,7 +365,7 @@ func (server *Server) selfNodeRpcHandlerGo(timeout time.Duration,processor IRpcP
 				v.Err = nil
 				v.DoOK()
 			} else {
-				log.SError(Err.Error())
+				log.Error(Err.Error())
 				v.DoError(Err)
 			}
 		}
@@ -375,7 +373,7 @@ func (server *Server) selfNodeRpcHandlerGo(timeout time.Duration,processor IRpcP
 
 	err := rpcHandler.PushRpcRequest(req)
 	if err != nil {
-		log.SError(err.Error())
+		log.Error(err.Error())
 		pCall.DoError(err)
 		ReleaseRpcRequest(req)
 	}
@@ -387,7 +385,7 @@ func (server *Server) selfNodeRpcHandlerAsyncGo(timeout time.Duration,client *Cl
 	rpcHandler := server.rpcHandleFinder.FindRpcHandler(handlerName)
 	if rpcHandler == nil {
 		err := errors.New("service method " + serviceMethod + " not config!")
-		log.SError(err.Error())
+		log.Error(err.Error())
 		return emptyCancelRpc,err
 	}
 
@@ -395,7 +393,7 @@ func (server *Server) selfNodeRpcHandlerAsyncGo(timeout time.Duration,client *Cl
 	iParam,err := processor.Clone(args)
 	if err != nil {
 		errM := errors.New("RpcHandler " + handlerName + "."+serviceMethod+" deep copy inParam is error:" + err.Error())
-		log.SError(errM.Error())
+		log.Error(errM.Error())
 		return emptyCancelRpc,errM
 	}