优化日志，避免一些变量的逃逸

2026-02-03 22:45:13 +08:00 · 2021-07-01 16:27:48 +08:00
parent 7392d90ef2
commit d9333e31c0
22 changed files with 157 additions and 141 deletions
--- a/rpc/client.go
+++ b/rpc/client.go
@@ -259,8 +259,7 @@ func (client *Client) Run(){
 		if r := recover(); r != nil {
 			buf := make([]byte, 4096)
 			l := runtime.Stack(buf, false)
-			err := fmt.Errorf("%v: %s\n", r, buf[:l])
-			log.Error("core dump info:%+v",err)
+			log.SError("core dump info:",r,":", string(buf[:l]))
 		}
 	}()

@@ -268,14 +267,14 @@ func (client *Client) Run(){
 	for {
 		bytes,err := client.conn.ReadMsg()
 		if err != nil {
-			log.Error("rpcClient %s ReadMsg error:%+v", client.Addr,err)
+			log.SError("rpcClient ",client.Addr," ReadMsg error:",err.Error())
 			return
 		}

 		processor := GetProcessor(uint8(bytes[0]))
 		if processor==nil {
 			client.conn.ReleaseReadMsg(bytes)
-			log.Error("rpcClient %s ReadMsg head error:%+v", client.Addr,err)
+			log.SError("rpcClient ",client.Addr," ReadMsg head error:",err.Error())
 			return
 		}

@@ -287,19 +286,19 @@ func (client *Client) Run(){
 		client.conn.ReleaseReadMsg(bytes)
 		if err != nil {
 			processor.ReleaseRpcResponse(response.RpcResponseData)
-			log.Error("rpcClient Unmarshal head error,error:%+v",err)
+			log.SError("rpcClient Unmarshal head error:",err.Error())
 			continue
 		}

 		v := client.RemovePending(response.RpcResponseData.GetSeq())
 		if v == nil {
-			log.Error("rpcClient cannot find seq %d in pending", response.RpcResponseData.GetSeq())
+			log.SError("rpcClient cannot find seq ",response.RpcResponseData.GetSeq()," in pending")
 		}else  {
 			v.Err = nil
 			if len(response.RpcResponseData.GetReply()) >0 {
 				err = processor.Unmarshal(response.RpcResponseData.GetReply(),v.Reply)
 				if err != nil {
-					log.Error("rpcClient Unmarshal body error,error:%+v",err)
+					log.SError("rpcClient Unmarshal body error:",err.Error())
 					v.Err = err
 				}
 			}
--- a/rpc/rpchandler.go
+++ b/rpc/rpchandler.go
@@ -6,6 +6,7 @@ import (
 	"github.com/duanhf2012/origin/log"
 	"reflect"
 	"runtime"
+	"strconv"
 	"strings"
 	"unicode"
 	"unicode/utf8"
@@ -218,8 +219,7 @@ func (handler *RpcHandler) HandlerRpcResponseCB(call *Call){
 		if r := recover(); r != nil {
 			buf := make([]byte, 4096)
 			l := runtime.Stack(buf, false)
-			err := fmt.Errorf("%v: %s\n", r, buf[:l])
-			log.Error("core dump info:%+v",err)
+			log.SError("core dump info:",r,":",string(buf[:l]))
 		}
 	}()

@@ -240,8 +240,7 @@ func (handler *RpcHandler) HandlerRpcRequest(request *RpcRequest) {
 		if r := recover(); r != nil {
 				buf := make([]byte, 4096)
 				l := runtime.Stack(buf, false)
-				err := fmt.Errorf("%v: %s", r, buf[:l])
-				log.Error("Handler Rpc %s Core dump info:%+v\n",request.RpcRequestData.GetServiceMethod(),err)
+				log.SError("Handler Rpc ",request.RpcRequestData.GetServiceMethod()," Core dump info:",r,":",string(buf[:l]))
 				rpcErr := RpcError("call error : core dumps")
 				if request.requestHandle!=nil {
 					request.requestHandle(nil,rpcErr)
@@ -256,8 +255,7 @@ func (handler *RpcHandler) HandlerRpcRequest(request *RpcRequest) {
 	if rawRpcId>0 {
 		v,ok := handler.mapRawFunctions[rawRpcId]
 		if ok == false {
-			err := fmt.Sprintf("RpcHandler cannot find request rpc id %d!",rawRpcId)
-			log.Error(err)
+			log.SError("RpcHandler cannot find request rpc id",rawRpcId)
 			return
 		}

@@ -269,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.Error(err)
+		log.SError(err)
 		if request.requestHandle!=nil {
 			request.requestHandle(nil,RpcError(err))
 		}
@@ -300,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.Error(rErr)
+		log.SError(rErr)
 		request.requestHandle(nil, RpcError(rErr))
 		return
 	}
@@ -319,9 +317,8 @@ func (handler *RpcHandler) CallMethod(ServiceMethod string,param interface{},rep
 	var err error
 	v,ok := handler.mapFunctions[ServiceMethod]
 	if ok == false {
-		err = fmt.Errorf("RpcHandler %s cannot find %s", handler.rpcHandler.GetName(),ServiceMethod)
-		log.Error("%s",err.Error())
-
+		err = errors.New("RpcHandler "+ handler.rpcHandler.GetName()+" cannot find"+ServiceMethod)
+		log.SError(err.Error())
 		return err
 	}

@@ -343,11 +340,11 @@ func (handler *RpcHandler) goRpc(processor IRpcProcessor,bCast bool,nodeId int,s
 	var pClientList [maxClusterNode]*Client
 	err,count := handler.funcRpcClient(nodeId,serviceMethod,pClientList[:])
 	if count==0||err != nil {
-		log.Error("Call %s is error:%+v!",serviceMethod,err)
+		log.SError("Call ",serviceMethod," is error:",err.Error())
 		return err
 	}
 	if count > 1 && bCast == false{
-		log.Error("Cannot call %s more then 1 node!",serviceMethod)
+		log.SError("Cannot call %s more then 1 node!",serviceMethod)
 		return fmt.Errorf("Cannot call more then 1 node!")
 	}

@@ -359,8 +356,8 @@ func (handler *RpcHandler) goRpc(processor IRpcProcessor,bCast bool,nodeId int,s
 			//判断是否是同一服务
 			findIndex := strings.Index(serviceMethod,".")
 			if findIndex==-1 {
-				sErr := fmt.Errorf("Call serviceMethod %s is error!",serviceMethod)
-				log.Error("%+v", sErr)
+				sErr := errors.New("Call serviceMethod "+serviceMethod+" is error!")
+				log.SError(sErr.Error())
 				if sErr != nil {
 					err = sErr
 				}
@@ -397,15 +394,15 @@ func (handler *RpcHandler) callRpc(nodeId int,serviceMethod string,args interfac
 	var pClientList [maxClusterNode]*Client
 	err,count := handler.funcRpcClient(nodeId,serviceMethod,pClientList[:])
 	if err != nil {
-		log.Error("Call serviceMethod is error:%+v!",err)
+		log.SError("Call serviceMethod is error:",err.Error())
 		return err
 	}else if count <=0 {
-		err  = fmt.Errorf("Call serviceMethod is error:cannot find %s",serviceMethod)
-		log.Error("%s",err.Error())
+		err  = errors.New("Call serviceMethod is error:cannot find "+serviceMethod)
+		log.SError(err.Error())
 		return err
 	}else if count > 1 {
-		log.Error("Cannot call more then 1 node!")
-		return fmt.Errorf("Cannot call more then 1 node!")
+		log.SError("Cannot call more then 1 node!")
+		return errors.New("Cannot call more then 1 node!")
 	}

 	//2.rpcclient调用
@@ -416,8 +413,8 @@ func (handler *RpcHandler) callRpc(nodeId int,serviceMethod string,args interfac
 		//判断是否是同一服务
 		findIndex := strings.Index(serviceMethod,".")
 		if findIndex==-1 {
-			err := fmt.Errorf("Call serviceMethod %s is error!",serviceMethod)
-			log.Error("%+v",err)
+			err := errors.New("Call serviceMethod "+serviceMethod+"is error!")
+			log.SError(err.Error())
 			return err
 		}
 		serviceName := serviceMethod[:findIndex]
@@ -449,20 +446,20 @@ func (handler *RpcHandler) callRpc(nodeId int,serviceMethod string,args interfac
 func (handler *RpcHandler) asyncCallRpc(nodeid int,serviceMethod string,args interface{},callback interface{}) error {
 	fVal := reflect.ValueOf(callback)
 	if fVal.Kind()!=reflect.Func{
-		err := fmt.Errorf("call %s input callback param is error!",serviceMethod)
-		log.Error("+v",err)
+		err := errors.New("call "+serviceMethod+" input callback param is error!")
+		log.SError(err.Error())
 		return err
 	}

    if fVal.Type().NumIn()!= 2 {
-    	err := fmt.Errorf("call %s callback param function is error!",serviceMethod)
-		log.Error("%+v",err)
+    	err := errors.New("call "+serviceMethod+" callback param function is error!")
+		log.SError(err.Error())
 		return err
 	}

 	if  fVal.Type().In(0).Kind() != reflect.Ptr || fVal.Type().In(1).String() != "error"{
-		err :=  fmt.Errorf("call %s callback  function param is error!",serviceMethod)
-		log.Error("%+v",err)
+		err := errors.New("call "+serviceMethod+" callback param function is error!")
+		log.SError(err.Error())
 		return err
 	}

@@ -470,18 +467,19 @@ func (handler *RpcHandler) asyncCallRpc(nodeid int,serviceMethod string,args int
 	var pClientList [maxClusterNode]*Client
 	err,count := handler.funcRpcClient(nodeid,serviceMethod,pClientList[:])
 	if count==0||err != nil {
+		strNodeId := strconv.Itoa(nodeid)
 		if err == nil {
-			err = fmt.Errorf("cannot find rpcclient from nodeid %d serviceMethod %s",nodeid,serviceMethod)
+			err = errors.New("cannot find rpcclient from nodeid "+strNodeId+" "+serviceMethod)
 		}
 		fVal.Call([]reflect.Value{reflect.ValueOf(reply),reflect.ValueOf(err)})
-		log.Error("Call serviceMethod is error:%+v!",err)
+		log.SError("Call serviceMethod is error:%+v!",err.Error())
 		return nil
 	}

 	if count > 1 {
-		err := fmt.Errorf("Cannot call more then 1 node!")
+		err := errors.New("Cannot call more then 1 node!")
 		fVal.Call([]reflect.Value{reflect.ValueOf(reply),reflect.ValueOf(err)})
-		log.Error("Cannot call more then 1 node!")
+		log.SError(err.Error())
 		return nil
 	}

@@ -493,9 +491,9 @@ func (handler *RpcHandler) asyncCallRpc(nodeid int,serviceMethod string,args int
 		//判断是否是同一服务
 		findIndex := strings.Index(serviceMethod,".")
 		if findIndex==-1 {
-			err := fmt.Errorf("Call serviceMethod %s is error!",serviceMethod)
+			err := errors.New("Call serviceMethod "+serviceMethod+" is error!")
 			fVal.Call([]reflect.Value{reflect.ValueOf(reply),reflect.ValueOf(err)})
-			log.Error("%+v",err)
+			log.SError(err.Error())
 			return nil
 		}
 		serviceName := serviceMethod[:findIndex]
@@ -567,13 +565,14 @@ func (handler *RpcHandler) RawGoNode(rpcProcessorType RpcProcessorType,nodeId in
 	err,count := handler.funcRpcClient(nodeId,serviceName,pClientList[:])
 	if count==0||err != nil {
 		//args.DoGc()
-		log.Error("Call serviceMethod is error:%+v!",err)
+		log.SError("Call serviceMethod is error:",err.Error())
 		return err
 	}
 	if count > 1 {
 		//args.DoGc()
-		log.Error("Cannot call more then 1 node!")
-		return fmt.Errorf("Cannot call more then 1 node!")
+		err := errors.New("Cannot call more then 1 node!")
+		log.SError(err.Error())
+		return err
 	}

 	//2.rpcclient调用
@@ -620,15 +619,17 @@ func (handler *RpcHandler) UnmarshalInParam(rpcProcessor IRpcProcessor,serviceMe
 	if rawRpcMethodId>0 {
 		v,ok := handler.mapRawFunctions[rawRpcMethodId]
 		if ok == false {
-			err := fmt.Errorf("RpcHandler cannot find request rpc id %d!",rawRpcMethodId)
-			log.Error(err.Error())
+			strRawRpcMethodId := strconv.FormatUint(uint64(rawRpcMethodId),10)
+			err := errors.New("RpcHandler cannot find request rpc id "+strRawRpcMethodId)
+			log.SError(err.Error())
 			return nil,err
 		}

 		msg,err := v.Unmarshal(inParam)
 		if err != nil {
-			err := fmt.Errorf("RpcHandler cannot Unmarshal rpc id %d!",rawRpcMethodId)
-			log.Error(err.Error())
+			strRawRpcMethodId := strconv.FormatUint(uint64(rawRpcMethodId),10)
+			err := errors.New("RpcHandler cannot Unmarshal rpc id "+strRawRpcMethodId)
+			log.SError(err.Error())
 			return nil,err
 		}

--- a/rpc/server.go
+++ b/rpc/server.go
@@ -1,6 +1,7 @@
 package rpc

 import (
+	"errors"
 	"fmt"
 	"github.com/duanhf2012/origin/log"
 	"github.com/duanhf2012/origin/network"
@@ -65,7 +66,7 @@ func (server *Server) Init(rpcHandleFinder RpcHandleFinder) {
 func (server *Server) Start(listenAddr string) {
 	 splitAddr := strings.Split(listenAddr,":")
 	 if len(splitAddr)!=2{
-	 	log.Fatal("listen addr is error :%s",listenAddr)
+	 	log.SFatal("listen addr is error :",listenAddr)
 	 }

 	server.rpcServer.Addr = ":"+splitAddr[1]
@@ -98,13 +99,13 @@ func (agent *RpcAgent) WriteResponse(processor IRpcProcessor,serviceMethod strin
 	defer processor.ReleaseRpcResponse(rpcResponse.RpcResponseData)

 	if errM != nil {
-		log.Error("service method %s %+v Marshal error:%+v!", serviceMethod,rpcResponse,errM)
+		log.SError("service method ",serviceMethod," Marshal error:",errM.Error())
 		return
 	}

 	errM = agent.conn.WriteMsg([]byte{uint8(processor.GetProcessorType())},bytes)
 	if errM != nil {
-		log.Error("Rpc %s return is error:%+v",serviceMethod,errM)
+		log.SError("Rpc ",serviceMethod," return is error:",errM.Error())
 	}
 }

@@ -112,7 +113,7 @@ func (agent *RpcAgent) Run() {
 	for {
 		data,err := agent.conn.ReadMsg()
 		if err != nil {
-			log.Error("remoteAddress:%s,read message: %v,",agent.conn.RemoteAddr().String(),err)
+			log.SError("remoteAddress:",agent.conn.RemoteAddr().String(),",read message: ",err.Error())
 			//will close tcpconn
 			break
 		}
@@ -120,7 +121,7 @@ func (agent *RpcAgent) Run() {
 		processor := GetProcessor(uint8(data[0]))
 		if processor==nil {
 			agent.conn.ReleaseReadMsg(data)
-			log.Error("remote rpc  %s data head error:%+v",agent.conn.RemoteAddr(),err)
+			log.SError("remote rpc  ",agent.conn.RemoteAddr()," data head error:",err.Error())
 			return
 		}

@@ -129,7 +130,7 @@ func (agent *RpcAgent) Run() {
 		err = processor.Unmarshal(data[1:],req.RpcRequestData)
 		agent.conn.ReleaseReadMsg(data)
 		if err != nil {
-			log.Error("rpc Unmarshal request is error: %v", err)
+			log.SError("rpc Unmarshal request is error:", err.Error())
 			if req.RpcRequestData.GetSeq()>0 {
 				rpcError := RpcError(err.Error())
 				if req.RpcRequestData.IsNoReply()==false {
@@ -152,7 +153,7 @@ func (agent *RpcAgent) Run() {
 				agent.WriteResponse(processor, req.RpcRequestData.GetServiceMethod(), req.RpcRequestData.GetSeq(), nil, rpcError)
 			}
 			ReleaseRpcRequest(req)
-			log.Debug("rpc request req.ServiceMethod is error")
+			log.SError("rpc request req.ServiceMethod is error")
 			continue
 		}

@@ -163,7 +164,7 @@ func (agent *RpcAgent) Run() {
 				agent.WriteResponse(processor,req.RpcRequestData.GetServiceMethod(),req.RpcRequestData.GetSeq(),nil,rpcError)
 			}

-			log.Error("service method %s not config!", req.RpcRequestData.GetServiceMethod())
+			log.SError("service method ",req.RpcRequestData.GetServiceMethod()," not config!")
 			ReleaseRpcRequest(req)
 			continue
 		}
@@ -181,7 +182,7 @@ func (agent *RpcAgent) Run() {
 			if req.requestHandle!=nil {
 				req.requestHandle(nil, RpcError(rErr))
 			}
-			log.Error(rErr)
+			log.SError(rErr)
 			ReleaseRpcRequest(req)
 			continue
 		}
@@ -230,8 +231,8 @@ func (server *Server) NewAgent(c *network.TCPConn) network.Agent {
 func (server *Server) myselfRpcHandlerGo(handlerName string,serviceMethod string, args interface{},reply interface{}) error {
 	rpcHandler := server.rpcHandleFinder.FindRpcHandler(handlerName)
 	if rpcHandler== nil {
-		err := fmt.Errorf("service method %s not config!", serviceMethod)
-		log.Error("%s",err.Error())
+		err := errors.New("service method "+serviceMethod+" not config!")
+		log.SError(err.Error())
 		return err
 	}

@@ -246,8 +247,8 @@ func (server *Server) selfNodeRpcHandlerGo(processor IRpcProcessor,client *Clien
 	rpcHandler := server.rpcHandleFinder.FindRpcHandler(handlerName)
 	if rpcHandler== nil {
 		pCall.Seq = 0
-		pCall.Err = fmt.Errorf("service method %s not config!", serviceMethod)
-		log.Error("%s",pCall.Err.Error())
+		pCall.Err = errors.New("service method "+serviceMethod+" not config!")
+		log.SError(pCall.Err.Error())
 		pCall.done <- pCall

 		return pCall
@@ -277,20 +278,20 @@ func (server *Server) selfNodeRpcHandlerGo(processor IRpcProcessor,client *Clien
 			if reply != nil && Returns != reply && Returns != nil {
 				byteReturns, err := req.rpcProcessor.Marshal(Returns)
 				if err != nil {
-					log.Error("returns data cannot be marshal",pCall.Seq)
+					log.SError("returns data cannot be marshal ",pCall.Seq)
 					ReleaseRpcRequest(req)
 				}

 				err = req.rpcProcessor.Unmarshal(byteReturns, reply)
 				if err != nil {
-					log.Error("returns data cannot be Unmarshal",pCall.Seq)
+					log.SError("returns data cannot be Unmarshal ",pCall.Seq)
 					ReleaseRpcRequest(req)
 				}
 			}

 			v := client.RemovePending(pCall.Seq)
 			if v == nil {
-				log.Error("rpcClient cannot find seq %d in pending",pCall.Seq)
+				log.SError("rpcClient cannot find seq ",pCall.Seq," in pending")
 				ReleaseRpcRequest(req)
 				return
 			}
@@ -317,8 +318,8 @@ func (server *Server) selfNodeRpcHandlerGo(processor IRpcProcessor,client *Clien
 func (server *Server) selfNodeRpcHandlerAsyncGo(client *Client,callerRpcHandler IRpcHandler,noReply bool,handlerName string,serviceMethod string,args interface{},reply interface{},callback reflect.Value) error {
 	rpcHandler := server.rpcHandleFinder.FindRpcHandler(handlerName)
 	if rpcHandler== nil {
-		err := fmt.Errorf("service method %s not config!", serviceMethod)
-		log.Error("%+v",err)
+		err := errors.New("service method "+serviceMethod+" not config!")
+		log.SError(err.Error())
 		return err
 	}

@@ -339,7 +340,7 @@ func (server *Server) selfNodeRpcHandlerAsyncGo(client *Client,callerRpcHandler
 		req.requestHandle = func(Returns interface{},Err RpcError){
 			v := client.RemovePending(callSeq)
 			if v == nil {
-				log.Error("rpcClient cannot find seq %d in pending",pCall.Seq)
+				log.SError("rpcClient cannot find seq ",pCall.Seq," in pending")
 				//ReleaseCall(pCall)
 				ReleaseRpcRequest(req)
 				return