diff --git a/cluster/cluster.go b/cluster/cluster.go index 763e564..c5b0517 100644 --- a/cluster/cluster.go +++ b/cluster/cluster.go @@ -114,7 +114,7 @@ func (cls *Cluster) DelNode(nodeId int, immediately bool) { //正在连接中不主动断开，只断开没有连接中的 if rpc.client.IsConnected() { nodeInfo.status = Discard - log.SRelease("Discard node ", nodeInfo.NodeId, " ", nodeInfo.ListenAddr) + log.Info("Discard node",log.Int("nodeId",nodeInfo.NodeId),log.String("ListenAddr", nodeInfo.ListenAddr)) return } @@ -131,7 +131,7 @@ func (cls *Cluster) DelNode(nodeId int, immediately bool) { rpc.client.Close(false) } - log.SRelease("remove node ", nodeInfo.NodeId, " ", nodeInfo.ListenAddr) + log.Info("remove node ",log.Int("NodeId", nodeInfo.NodeId),log.String("ListenAddr", nodeInfo.ListenAddr)) } func (cls *Cluster) serviceDiscoveryDelNode(nodeId int, immediately bool) { @@ -176,7 +176,7 @@ func (cls *Cluster) serviceDiscoverySetNodeInfo(nodeInfo *NodeInfo) { for _, serviceName := range nodeInfo.PublicServiceList { if _, ok := mapDuplicate[serviceName]; ok == true { //存在重复 - log.SError("Bad duplicate Service Cfg.") + log.Error("Bad duplicate Service Cfg.") continue } mapDuplicate[serviceName] = nil @@ -186,8 +186,7 @@ func (cls *Cluster) serviceDiscoverySetNodeInfo(nodeInfo *NodeInfo) { cls.mapServiceNode[serviceName][nodeInfo.NodeId] = struct{}{} } cls.mapIdNode[nodeInfo.NodeId] = *nodeInfo - - log.SRelease("Discovery nodeId: ", nodeInfo.NodeId, " services:", nodeInfo.PublicServiceList) + log.Info("Discovery nodeId",log.Int("NodeId", nodeInfo.NodeId),log.Any("services:", nodeInfo.PublicServiceList)) //已经存在连接，则不需要进行设置 if _, rpcInfoOK := cls.mapRpc[nodeInfo.NodeId]; rpcInfoOK == true { @@ -368,7 +367,7 @@ func (cls *Cluster) triggerRpcEvent(bConnect bool, clientId uint32, nodeId int) for serviceName, _ := range cls.mapServiceListenRpcEvent { ser := service.GetService(serviceName) if ser == nil { - log.SError("cannot find service name ", serviceName) + log.Error("cannot find service name "+serviceName) continue } @@ -386,7 +385,7 @@ func (cls *Cluster) TriggerDiscoveryEvent(bDiscovery bool, nodeId int, serviceNa for sName, _ := range cls.mapServiceListenDiscoveryEvent { ser := service.GetService(sName) if ser == nil { - log.SError("cannot find service name ", serviceName) + log.Error("cannot find service",log.Any("services",serviceName)) continue } diff --git a/cluster/dynamicdiscovery.go b/cluster/dynamicdiscovery.go index 4ecdcf9..dbe8f19 100644 --- a/cluster/dynamicdiscovery.go +++ b/cluster/dynamicdiscovery.go @@ -142,7 +142,7 @@ func (ds *DynamicDiscoveryMaster) RpcCastGo(serviceMethod string, args interface func (ds *DynamicDiscoveryMaster) RPC_RegServiceDiscover(req *rpc.ServiceDiscoverReq, res *rpc.Empty) error { if req.NodeInfo == nil { err := errors.New("RPC_RegServiceDiscover req is error.") - log.SError(err.Error()) + log.Error(err.Error()) return err } @@ -369,7 +369,7 @@ func (dc *DynamicDiscoveryClient) regServiceDiscover(nodeId int){ //向Master服务同步本Node服务信息 err := dc.AsyncCallNode(nodeId, RegServiceDiscover, &req, func(res *rpc.Empty, err error) { if err != nil { - log.SError("call ", RegServiceDiscover, " is fail :", err.Error()) + log.Error("call "+RegServiceDiscover+" is fail :"+ err.Error()) dc.AfterFunc(time.Second*3, func(timer *timer.Timer) { dc.regServiceDiscover(nodeId) }) @@ -378,7 +378,7 @@ func (dc *DynamicDiscoveryClient) regServiceDiscover(nodeId int){ } }) if err != nil { - log.SError("call ", RegServiceDiscover, " is fail :", err.Error()) + log.Error("call "+ RegServiceDiscover+" is fail :"+ err.Error()) } } diff --git a/cluster/parsecfg.go b/cluster/parsecfg.go index d16a093..7fd8e9e 100644 --- a/cluster/parsecfg.go +++ b/cluster/parsecfg.go @@ -58,7 +58,7 @@ func (cls *Cluster) readServiceConfig(filepath string) (interface{}, map[string] serviceCfg := v.(map[string]interface{}) nodeId, ok := serviceCfg["NodeId"] if ok == false { - log.SFatal("NodeService list not find nodeId field") + log.Fatal("NodeService list not find nodeId field") } mapNodeService[int(nodeId.(float64))] = serviceCfg } diff --git a/concurrent/concurrent.go b/concurrent/concurrent.go index 227089c..6b97059 100644 --- a/concurrent/concurrent.go +++ b/concurrent/concurrent.go @@ -50,7 +50,7 @@ func (c *Concurrent) AsyncDoByQueue(queueId int64, fn func() bool, cb func(err e } if fn == nil && cb == nil { - log.SStack("fn and cb is nil") + log.Stack("fn and cb is nil") return } @@ -66,7 +66,7 @@ func (c *Concurrent) AsyncDoByQueue(queueId int64, fn func() bool, cb func(err e select { case c.tasks <- task{queueId, fn, cb}: default: - log.SError("tasks channel is full") + log.Error("tasks channel is full") if cb != nil { c.pushAsyncDoCallbackEvent(func(err error) { cb(errors.New("tasks channel is full")) @@ -81,11 +81,11 @@ func (c *Concurrent) Close() { return } - log.SRelease("wait close concurrent") + log.Info("wait close concurrent") c.dispatch.close() - log.SRelease("concurrent has successfully exited") + log.Info("concurrent has successfully exited") } func (c *Concurrent) GetCallBackChannel() chan func(error) { diff --git a/concurrent/dispatch.go b/concurrent/dispatch.go index 0f29c18..0f3d13b 100644 --- a/concurrent/dispatch.go +++ b/concurrent/dispatch.go @@ -187,8 +187,7 @@ func (d *dispatch) DoCallback(cb func(err error)) { 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)) } }() diff --git a/concurrent/worker.go b/concurrent/worker.go index 80f0400..76f020c 100644 --- a/concurrent/worker.go +++ b/concurrent/worker.go @@ -40,7 +40,7 @@ func (w *worker) run(waitGroup *sync.WaitGroup, t task) { case tw := <-w.workerQueue: if tw.isExistTask() { //exit goroutine - log.SRelease("worker goroutine exit") + log.Info("worker goroutine exit") return } w.exec(&tw) @@ -59,9 +59,8 @@ func (w *worker) exec(t *task) { t.cb = func(err error) { cb(errors.New(errString)) } - + log.Dump(string(buf[:l]),log.String("error",errString)) w.endCallFun(true,t) - log.SError("core dump info[", errString, "]\n", string(buf[:l])) } }() diff --git a/console/command.go b/console/command.go index dad0332..e49aaf4 100644 --- a/console/command.go +++ b/console/command.go @@ -11,8 +11,9 @@ type CommandFunctionCB func(args interface{}) error var commandList []*command var programName string const( - boolType valueType = iota - stringType valueType = iota + boolType valueType = 0 + stringType valueType = 1 + intType valueType = 2 ) type command struct{ @@ -20,6 +21,7 @@ type command struct{ name string bValue bool strValue string + intValue int usage string fn CommandFunctionCB } @@ -29,6 +31,8 @@ func (cmd *command) execute() error{ return cmd.fn(cmd.bValue) }else if cmd.valType == stringType { return cmd.fn(cmd.strValue) + }else if cmd.valType == intType { + return cmd.fn(cmd.intValue) }else{ return fmt.Errorf("Unknow command type.") } @@ -72,6 +76,16 @@ func RegisterCommandBool(cmdName string, defaultValue bool, usage string,fn Comm commandList = append(commandList,&cmd) } +func RegisterCommandInt(cmdName string, defaultValue int, usage string,fn CommandFunctionCB){ + var cmd command + cmd.valType = intType + cmd.name = cmdName + cmd.fn = fn + cmd.usage = usage + flag.IntVar(&cmd.intValue, cmdName, defaultValue, usage) + commandList = append(commandList,&cmd) +} + func RegisterCommandString(cmdName string, defaultValue string, usage string,fn CommandFunctionCB){ var cmd command cmd.valType = stringType diff --git a/event/event.go b/event/event.go index 5cf5890..bd1c095 100644 --- a/event/event.go +++ b/event/event.go @@ -215,7 +215,7 @@ func (processor *EventProcessor) EventHandler(ev IEvent) { 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)) } }() @@ -230,13 +230,13 @@ func (processor *EventProcessor) EventHandler(ev IEvent) { func (processor *EventProcessor) castEvent(event IEvent){ if processor.mapListenerEvent == nil { - log.SError("mapListenerEvent not init!") + log.Error("mapListenerEvent not init!") return } eventProcessor,ok := processor.mapListenerEvent[event.GetEventType()] if ok == false || processor == nil{ - log.SDebug("event type ",event.GetEventType()," not listen.") + log.Debug("event is not listen",log.Int("event type",int(event.GetEventType()))) return } diff --git a/go.mod b/go.mod index 474b4c4..12b9768 100644 --- a/go.mod +++ b/go.mod @@ -1,6 +1,6 @@ module github.com/duanhf2012/origin -go 1.19 +go 1.21 require ( github.com/go-sql-driver/mysql v1.6.0 diff --git a/log/log.go b/log/log.go index 21f1188..c63246a 100644 --- a/log/log.go +++ b/log/log.go @@ -1,571 +1,209 @@ package log import ( - "errors" "fmt" jsoniter "github.com/json-iterator/go" "io" - "log" - syslog "log" "os" "path" - "runtime" - "runtime/debug" - "strings" - "sync" - "sync/atomic" "time" + "log/slog" + "context" + "sync/atomic" ) var json = jsoniter.ConfigCompatibleWithStandardLibrary var OpenConsole bool +var LogSize int64 +var gLogger, _ = NewTextLogger(LevelDebug, "", "",true) // levels const ( - debugLevel = 0 - releaseLevel = 1 - warningLevel = 2 - errorLevel = 3 - stackLevel = 4 - fatalLevel = 5 -) - -const ( - printDebugLevel = "[debug ] " - printReleaseLevel = "[release] " - printWarningLevel = "[warning] " - printErrorLevel = "[error ] " - printStackLevel = "[stack ] " - printFatalLevel = "[fatal ] " + LevelTrace = slog.Level(-8) + LevelDebug = slog.LevelDebug + LevelInfo = slog.LevelInfo + LevelWarning = slog.LevelWarn + LevelError = slog.LevelError + LevelStack = slog.Level(12) + LevelDump = slog.Level(16) + LevelFatal = slog.Level(20) ) type Logger struct { - filePath string - filepre string - - //logTime time.Time - fileDay int - level int - flag int - buf []Buffer + Slogger *slog.Logger + filePath string + fileprefix string + fileDay int + fileCreateTime int64 //second + ioWriter IoWriter - outFile io.Writer // destination for output - outConsole io.Writer //os.Stdout - - mu sync.Mutex // ensures atomic writes; protects the following fields - buffIndex uint32 - buffNum uint32 + sBuff Buffer } -func (logger *Logger) GenDayFile(now *time.Time) error { - if logger.fileDay == now.Day() { - return nil - } +type IoWriter struct { + outFile io.Writer // destination for output + outConsole io.Writer //os.Stdout + writeBytes int64 +} - filename := fmt.Sprintf("%d%02d%02d_%02d_%02d_%02d.log", - now.Year(), - now.Month(), - now.Day(), - now.Hour(), - now.Minute(), - now.Second()) - - if logger.filePath != "" { - var err error - logger.outFile,err = os.Create(path.Join(logger.filePath, logger.filepre+filename)) - if err != nil { - return err - } - logger.fileDay = now.Day() - if OpenConsole == true { - logger.outConsole = os.Stdout - } - }else{ - logger.outConsole = os.Stdout +func (iw *IoWriter) Close() error { + if iw.outFile!= nil { + return iw.outFile.(io.Closer).Close() } return nil } -func New(strLevel string, pathName string, filePre string, flag int,buffNum uint32) (*Logger, error) { - // level - var level int - switch strings.ToLower(strLevel) { - case "debug": - level = debugLevel - case "release": - level = releaseLevel - case "warning": - level = warningLevel - case "error": - level = errorLevel - case "stack": - level = stackLevel - case "fatal": - level = fatalLevel - default: - return nil, errors.New("unknown level: " + strLevel) +func (iw *IoWriter) writeFile(p []byte) (n int, err error){ + if iw.outFile != nil { + n,err = iw.outFile.Write(p) + if n > 0 { + atomic.AddInt64(&iw.writeBytes,int64(n)) + } } - // new111 - logger := new(Logger) - logger.level = level - logger.filePath = pathName - logger.filepre = filePre - logger.flag = flag - logger.buf = make([]Buffer,buffNum) - logger.buffNum = buffNum + return 0,nil +} - for i:=uint32(0);i= LogSize } -func (logger *Logger) nextBuff() *Buffer{ - return &logger.buf[atomic.AddUint32(&logger.buffIndex,1)%logger.buffNum] +func (logger *Logger) setIo() error{ + now := time.Now() + + if logger.fileCreateTime == now.Unix() { + return nil + } + + if logger.fileDay == now.Day() && logger.isFull() == false { + return nil + } + + if logger.Slogger != nil { + logger.Slogger.Handler().(IOriginHandler).Lock() + defer logger.Slogger.Handler().(IOriginHandler).UnLock() + } + + if logger.filePath != "" { + var err error + fileName := fmt.Sprintf("%s%d%02d%02d_%02d_%02d_%02d.log", + logger.fileprefix, + now.Year(), + now.Month(), + now.Day(), + now.Hour(), + now.Minute(), + now.Second()) + + filePath := path.Join(logger.filePath, fileName) + + logger.ioWriter.outFile,err = os.Create(filePath) + if err != nil { + return err + } + logger.fileDay = now.Day() + logger.fileCreateTime = now.Unix() + atomic.StoreInt64(&logger.ioWriter.writeBytes,0) + if OpenConsole == true { + logger.ioWriter.outConsole = os.Stdout + } + }else{ + logger.ioWriter.outConsole = os.Stdout + } + + return nil +} + +func NewTextLogger(level slog.Level,pathName string,filePrefix string,addSource bool) (*Logger,error){ + var logger Logger + logger.filePath = pathName + logger.fileprefix = filePrefix + + err := logger.setIo() + if err != nil { + return nil,err + } + logger.Slogger = slog.New(NewOriginTextHandler(level,&logger.ioWriter,addSource,defaultReplaceAttr)) + + return &logger,nil +} + +func NewJsonLogger(level slog.Level,pathName string,filePrefix string,addSource bool) (*Logger,error){ + var logger Logger + logger.filePath = pathName + logger.fileprefix = filePrefix + + err := logger.setIo() + if err != nil { + return nil,err + } + logger.Slogger = slog.New(NewOriginJsonHandler(level,&logger.ioWriter,true,defaultReplaceAttr)) + + return &logger,nil } // It's dangerous to call the method on logging func (logger *Logger) Close() { - if logger.outFile != nil { - logger.outFile.(io.Closer).Close() - logger.outFile = nil - } + logger.ioWriter.Close() } -func (logger *Logger) doPrintf(level int, printLevel string, format string, a ...interface{}) { - if level < logger.level { - return - } - now := time.Now() - - - buf := logger.nextBuff() - buf.Locker() - - buf.Reset() - logger.formatHeader(buf,3,&now) - buf.AppendString(printLevel) - buf.AppendString(fmt.Sprintf(format, a...)) - buf.AppendByte('\n') - - logger.mu.Lock() - logger.GenDayFile(&now) - - if logger.outFile!= nil { - logger.outFile.Write(buf.Bytes()) - } - if logger.outConsole!= nil { - logger.outConsole.Write(buf.Bytes()) - } - logger.mu.Unlock() - buf.UnLocker() - if level == fatalLevel { - os.Exit(1) - } +func (logger *Logger) Trace(msg string, args ...any) { + logger.setIo() + logger.Slogger.Log(context.Background(),LevelTrace,msg,args...) } - -func (logger *Logger) doSPrintf(level int, printLevel string, a []interface{}) { - if level < logger.level { - return - } - now := time.Now() - buf := logger.nextBuff() - buf.Locker() - buf.Reset() - logger.formatHeader(buf,3,&now) - buf.AppendString(printLevel) - for _,s := range a { - switch s.(type) { - //case error: - // logger.buf.AppendString(s.(error).Error()) - case []string: - strSlice := s.([]string) - buf.AppendByte('[') - for _,str := range strSlice { - buf.AppendString(str) - buf.AppendByte(',') - } - - lastIdx := buf.Len()-1 - if buf.Bytes()[lastIdx] == ',' { - buf.Bytes()[lastIdx] = ']' - }else{ - buf.AppendByte(']') - } - - case int: - buf.AppendInt(int64(s.(int))) - case []int: - intSlice := s.([]int) - buf.AppendByte('[') - for _,v := range intSlice { - buf.AppendInt(int64(v)) - buf.AppendByte(',') - } - - lastIdx := buf.Len()-1 - if buf.Bytes()[lastIdx] == ',' { - buf.Bytes()[lastIdx] = ']' - }else{ - buf.AppendByte(']') - } - case int8: - buf.AppendInt(int64(s.(int8))) - case []int8: - intSlice := s.([]int8) - buf.AppendByte('[') - for _,v := range intSlice { - buf.AppendInt(int64(v)) - buf.AppendByte(',') - } - - lastIdx := buf.Len()-1 - if buf.Bytes()[lastIdx] == ',' { - buf.Bytes()[lastIdx] = ']' - }else{ - buf.AppendByte(']') - } - case int16: - buf.AppendInt(int64(s.(int16))) - case []int16: - intSlice := s.([]int16) - buf.AppendByte('[') - for _,v := range intSlice { - buf.AppendInt(int64(v)) - buf.AppendByte(',') - } - - lastIdx := buf.Len()-1 - if buf.Bytes()[lastIdx] == ',' { - buf.Bytes()[lastIdx] = ']' - }else{ - buf.AppendByte(']') - } - case int32: - buf.AppendInt(int64(s.(int32))) - case []int32: - intSlice := s.([]int32) - buf.AppendByte('[') - for _,v := range intSlice { - buf.AppendInt(int64(v)) - buf.AppendByte(',') - } - - lastIdx := buf.Len()-1 - if buf.Bytes()[lastIdx] == ',' { - buf.Bytes()[lastIdx] = ']' - }else{ - buf.AppendByte(']') - } - case int64: - buf.AppendInt(s.(int64)) - case []int64: - intSlice := s.([]int64) - buf.AppendByte('[') - for _,v := range intSlice { - buf.AppendInt(v) - buf.AppendByte(',') - } - - lastIdx := buf.Len()-1 - if buf.Bytes()[lastIdx] == ',' { - buf.Bytes()[lastIdx] = ']' - }else{ - buf.AppendByte(']') - } - case uint: - buf.AppendUint(uint64(s.(uint))) - - case []uint: - intSlice := s.([]uint) - buf.AppendByte('[') - for _,v := range intSlice { - buf.AppendUint(uint64(v)) - buf.AppendByte(',') - } - - lastIdx := buf.Len()-1 - if buf.Bytes()[lastIdx] == ',' { - buf.Bytes()[lastIdx] = ']' - }else{ - buf.AppendByte(']') - } - - case uint8: - buf.AppendUint(uint64(s.(uint8))) - case []uint8: - intSlice := s.([]uint8) - buf.AppendByte('[') - for _,v := range intSlice { - buf.AppendUint(uint64(v)) - buf.AppendByte(',') - } - - lastIdx := buf.Len()-1 - if buf.Bytes()[lastIdx] == ',' { - buf.Bytes()[lastIdx] = ']' - }else{ - buf.AppendByte(']') - } - - case uint16: - buf.AppendUint(uint64(s.(uint16))) - case []uint16: - intSlice := s.([]uint16) - buf.AppendByte('[') - for _,v := range intSlice { - buf.AppendUint(uint64(v)) - buf.AppendByte(',') - } - - lastIdx := buf.Len()-1 - if buf.Bytes()[lastIdx] == ',' { - buf.Bytes()[lastIdx] = ']' - }else{ - buf.AppendByte(']') - } - case uint32: - buf.AppendUint(uint64(s.(uint32))) - case []uint32: - intSlice := s.([]uint32) - buf.AppendByte('[') - for _,v := range intSlice { - buf.AppendUint(uint64(v)) - buf.AppendByte(',') - } - - lastIdx := buf.Len()-1 - if buf.Bytes()[lastIdx] == ',' { - buf.Bytes()[lastIdx] = ']' - }else{ - buf.AppendByte(']') - } - case uint64: - buf.AppendUint(s.(uint64)) - case []uint64: - intSlice := s.([]uint64) - buf.AppendByte('[') - for _,v := range intSlice { - buf.AppendUint(v) - buf.AppendByte(',') - } - lastIdx := buf.Len()-1 - if buf.Bytes()[lastIdx] == ',' { - buf.Bytes()[lastIdx] = ']' - }else{ - buf.AppendByte(']') - } - case float32: - buf.AppendFloat(float64(s.(float32)),32) - case []float32: - intSlice := s.([]float32) - buf.AppendByte('[') - for _,v := range intSlice { - buf.AppendFloat(float64(v),32) - buf.AppendByte(',') - } - lastIdx := buf.Len()-1 - if buf.Bytes()[lastIdx] == ',' { - buf.Bytes()[lastIdx] = ']' - }else{ - buf.AppendByte(']') - } - case float64: - buf.AppendFloat(s.(float64),64) - case []float64: - intSlice := s.([]float64) - buf.AppendByte('[') - for _,v := range intSlice { - buf.AppendFloat(v,64) - buf.AppendByte(',') - } - lastIdx := buf.Len()-1 - if buf.Bytes()[lastIdx] == ',' { - buf.Bytes()[lastIdx] = ']' - }else{ - buf.AppendByte(']') - } - case bool: - buf.AppendBool(s.(bool)) - case []bool: - intSlice := s.([]bool) - buf.AppendByte('[') - for _,v := range intSlice { - buf.AppendBool(v) - buf.AppendByte(',') - } - lastIdx := buf.Len()-1 - if buf.Bytes()[lastIdx] == ',' { - buf.Bytes()[lastIdx] = ']' - }else{ - buf.AppendByte(']') - } - case string: - buf.AppendString(s.(string)) - case *int: - val := s.(*int) - if val != nil { - buf.AppendInt(int64(*val)) - }else{ - buf.AppendString("nil<*int>") - } - case *int8: - val := s.(*int8) - if val != nil { - buf.AppendInt(int64(*val)) - }else{ - buf.AppendString("nil<*int8>") - } - case *int16: - val := s.(*int16) - if val != nil { - buf.AppendInt(int64(*val)) - }else{ - buf.AppendString("nil<*int16>") - } - case *int32: - val := s.(*int32) - if val != nil { - buf.AppendInt(int64(*val)) - }else{ - buf.AppendString("nil<*int32>") - } - case *int64: - val := s.(*int64) - if val != nil { - buf.AppendInt(int64(*val)) - }else{ - buf.AppendString("nil<*int64>") - } - case *uint: - val := s.(*uint) - if val != nil { - buf.AppendUint(uint64(*val)) - }else{ - buf.AppendString("nil<*uint>") - } - case *uint8: - val := s.(*uint8) - if val != nil { - buf.AppendUint(uint64(*val)) - }else{ - buf.AppendString("nil<*uint8>") - } - case *uint16: - val := s.(*uint16) - if val != nil { - buf.AppendUint(uint64(*val)) - }else{ - buf.AppendString("nil<*uint16>") - } - case *uint32: - val := s.(*uint32) - if val != nil { - buf.AppendUint(uint64(*val)) - }else{ - buf.AppendString("nil<*uint32>") - } - case *uint64: - val := s.(*uint64) - if val != nil { - buf.AppendUint(uint64(*val)) - }else{ - buf.AppendString("nil<*uint64>") - } - case *float32: - val := s.(*float32) - if val != nil { - buf.AppendFloat(float64(*val),32) - }else{ - buf.AppendString("nil<*float32>") - } - case *float64: - val := s.(*float32) - if val != nil { - buf.AppendFloat(float64(*val),64) - }else{ - buf.AppendString("nil<*float64>") - } - case *bool: - val := s.(*bool) - if val != nil { - buf.AppendBool(*val) - }else{ - buf.AppendString("nil<*bool>") - } - case *string: - val := s.(*string) - if val != nil { - buf.AppendString(*val) - }else{ - buf.AppendString("nil<*string>") - } - //case []byte: - // logger.buf.AppendBytes(s.([]byte)) - default: - //b,err := json.MarshalToString(s) - //if err != nil { - buf.AppendString("") - //}else{ - //logger.buf.AppendBytes(b) - //} - } - } - buf.AppendByte('\n') - - logger.mu.Lock() - logger.GenDayFile(&now) - if logger.outFile!= nil { - logger.outFile.Write(buf.Bytes()) - } - if logger.outConsole!= nil { - logger.outConsole.Write(buf.Bytes()) - } - logger.mu.Unlock() - buf.UnLocker() - - if level == fatalLevel { - os.Exit(1) - } +func (logger *Logger) Debug(msg string, args ...any) { + logger.setIo() + logger.Slogger.Log(context.Background(),LevelDebug,msg,args...) } -func (logger *Logger) Debug(format string, a ...interface{}) { - logger.doPrintf(debugLevel, printDebugLevel, format, a...) +func (logger *Logger) Info(msg string, args ...any) { + logger.setIo() + logger.Slogger.Log(context.Background(),LevelInfo,msg,args...) } -func (logger *Logger) Release(format string, a ...interface{}) { - logger.doPrintf(releaseLevel, printReleaseLevel, format, a...) +func (logger *Logger) Warning(msg string, args ...any) { + logger.setIo() + logger.Slogger.Log(context.Background(),LevelWarning,msg,args...) } -func (logger *Logger) Warning(format string, a ...interface{}) { - logger.doPrintf(warningLevel, printWarningLevel, format, a...) +func (logger *Logger) Error(msg string, args ...any) { + logger.setIo() + logger.Slogger.Log(context.Background(),LevelError,msg,args...) } -func (logger *Logger) Error(format string, a ...interface{}) { - logger.doPrintf(errorLevel, printErrorLevel, format, a...) +func (logger *Logger) Stack(msg string, args ...any) { + logger.setIo() + logger.Slogger.Log(context.Background(),LevelStack,msg,args...) } -func (logger *Logger) Stack(format string, a ...interface{}) { - logger.doPrintf(stackLevel, printStackLevel, format, a...) +func (logger *Logger) Dump(msg string, args ...any) { + logger.setIo() + logger.Slogger.Log(context.Background(),LevelDump,msg,args...) } -func (logger *Logger) Fatal(format string, a ...interface{}) { - logger.doPrintf(fatalLevel, printFatalLevel, format, a...) +func (logger *Logger) Fatal(msg string, args ...any) { + logger.setIo() + logger.Slogger.Log(context.Background(),LevelFatal,msg,args...) + os.Exit(1) } -var gLogger, _ = New("debug", "", "", log.LstdFlags|log.Lshortfile,1) - // It's dangerous to call the method on logging func Export(logger *Logger) { if logger != nil { @@ -573,122 +211,494 @@ func Export(logger *Logger) { } } -func Debug(format string, a ...interface{}) { - gLogger.doPrintf(debugLevel, printDebugLevel, format, a...) +func Trace(msg string, args ...any){ + gLogger.Trace(msg, args...) } -func Release(format string, a ...interface{}) { - gLogger.doPrintf(releaseLevel, printReleaseLevel, format, a...) +func Debug(msg string, args ...any){ + gLogger.Debug(msg,args...) } -func Warning(format string, a ...interface{}) { - gLogger.doPrintf(warningLevel, printWarningLevel, format, a...) +func Info(msg string, args ...any){ + gLogger.Info(msg,args...) } -func Error(format string, a ...interface{}) { - gLogger.doPrintf(errorLevel, printErrorLevel, format, a...) +func Warning(msg string, args ...any){ + gLogger.Warning(msg,args...) } -func Stack(format string, a ...interface{}) { - s := string(debug.Stack()) - gLogger.doPrintf(stackLevel, printStackLevel, s+"\n"+format, a...) +func Error(msg string, args ...any){ + gLogger.Error(msg,args...) } -func Fatal(format string, a ...interface{}) { - gLogger.doPrintf(fatalLevel, printFatalLevel, format, a...) +func Stack(msg string, args ...any){ + gLogger.Stack(msg,args...) +} + +func Dump(dump string, args ...any){ + gLogger.Dump(dump,args...) +} + +func Fatal(msg string, args ...any){ + gLogger.Fatal(msg,args...) } func Close() { gLogger.Close() } -func SDebug(a ...interface{}) { - gLogger.doSPrintf(debugLevel, printDebugLevel, a) +func ErrorAttr(key string,value error) slog.Attr{ + return slog.Attr{key, slog.StringValue(value.Error())} } -func SRelease(a ...interface{}) { - gLogger.doSPrintf(releaseLevel, printReleaseLevel, a) +func String(key, value string) slog.Attr { + return slog.Attr{key, slog.StringValue(value)} +} + +func Int(key string, value int) slog.Attr { + return slog.Attr{key, slog.Int64Value(int64(value))} +} + +func Int64(key string, value int64) slog.Attr { + return slog.Attr{key, slog.Int64Value(value)} +} + +func Int32(key string, value int32) slog.Attr { + return slog.Attr{key, slog.Int64Value(int64(value))} +} + +func Int16(key string, value int16) slog.Attr { + return slog.Attr{key, slog.Int64Value(int64(value))} +} + +func Int8(key string, value int8) slog.Attr { + return slog.Attr{key, slog.Int64Value(int64(value))} +} + +func Uint(key string, value uint) slog.Attr { + return slog.Attr{key, slog.Uint64Value(uint64(value))} +} + +func Uint64(key string, v uint64) slog.Attr { + return slog.Attr{key, slog.Uint64Value(v)} +} + +func Uint32(key string, value uint32) slog.Attr { + return slog.Attr{key, slog.Uint64Value(uint64(value))} +} + +func Uint16(key string, value uint16) slog.Attr { + return slog.Attr{key, slog.Uint64Value(uint64(value))} +} + +func Uint8(key string, value uint8) slog.Attr { + return slog.Attr{key, slog.Uint64Value(uint64(value))} +} + +func Float64(key string, v float64) slog.Attr { + return slog.Attr{key, slog.Float64Value(v)} +} + +func Bool(key string, v bool) slog.Attr { + return slog.Attr{key, slog.BoolValue(v)} +} + +func Time(key string, v time.Time) slog.Attr { + return slog.Attr{key, slog.TimeValue(v)} +} + +func Duration(key string, v time.Duration) slog.Attr { + return slog.Attr{key, slog.DurationValue(v)} +} + +func Any(key string, value any) slog.Attr { + return slog.Attr{key, slog.AnyValue(value)} +} + +func Group(key string, args ...any) slog.Attr { + return slog.Group(key, args...) +} + +func (logger *Logger) doSPrintf(a []interface{}) string{ + logger.sBuff.Reset() + + for _,s := range a { + switch s.(type) { + case []string: + strSlice := s.([]string) + logger.sBuff.AppendByte('[') + for _,str := range strSlice { + logger.sBuff.AppendString(str) + logger.sBuff.AppendByte(',') + } + + lastIdx := logger.sBuff.Len()-1 + if logger.sBuff.Bytes()[lastIdx] == ',' { + logger.sBuff.Bytes()[lastIdx] = ']' + }else{ + logger.sBuff.AppendByte(']') + } + + case int: + logger.sBuff.AppendInt(int64(s.(int))) + case []int: + intSlice := s.([]int) + logger.sBuff.AppendByte('[') + for _,v := range intSlice { + logger.sBuff.AppendInt(int64(v)) + logger.sBuff.AppendByte(',') + } + + lastIdx := logger.sBuff.Len()-1 + if logger.sBuff.Bytes()[lastIdx] == ',' { + logger.sBuff.Bytes()[lastIdx] = ']' + }else{ + logger.sBuff.AppendByte(']') + } + case int8: + logger.sBuff.AppendInt(int64(s.(int8))) + case []int8: + intSlice := s.([]int8) + logger.sBuff.AppendByte('[') + for _,v := range intSlice { + logger.sBuff.AppendInt(int64(v)) + logger.sBuff.AppendByte(',') + } + + lastIdx := logger.sBuff.Len()-1 + if logger.sBuff.Bytes()[lastIdx] == ',' { + logger.sBuff.Bytes()[lastIdx] = ']' + }else{ + logger.sBuff.AppendByte(']') + } + case int16: + logger.sBuff.AppendInt(int64(s.(int16))) + case []int16: + intSlice := s.([]int16) + logger.sBuff.AppendByte('[') + for _,v := range intSlice { + logger.sBuff.AppendInt(int64(v)) + logger.sBuff.AppendByte(',') + } + + lastIdx := logger.sBuff.Len()-1 + if logger.sBuff.Bytes()[lastIdx] == ',' { + logger.sBuff.Bytes()[lastIdx] = ']' + }else{ + logger.sBuff.AppendByte(']') + } + case int32: + logger.sBuff.AppendInt(int64(s.(int32))) + case []int32: + intSlice := s.([]int32) + logger.sBuff.AppendByte('[') + for _,v := range intSlice { + logger.sBuff.AppendInt(int64(v)) + logger.sBuff.AppendByte(',') + } + + lastIdx := logger.sBuff.Len()-1 + if logger.sBuff.Bytes()[lastIdx] == ',' { + logger.sBuff.Bytes()[lastIdx] = ']' + }else{ + logger.sBuff.AppendByte(']') + } + case int64: + logger.sBuff.AppendInt(s.(int64)) + case []int64: + intSlice := s.([]int64) + logger.sBuff.AppendByte('[') + for _,v := range intSlice { + logger.sBuff.AppendInt(v) + logger.sBuff.AppendByte(',') + } + + lastIdx := logger.sBuff.Len()-1 + if logger.sBuff.Bytes()[lastIdx] == ',' { + logger.sBuff.Bytes()[lastIdx] = ']' + }else{ + logger.sBuff.AppendByte(']') + } + case uint: + logger.sBuff.AppendUint(uint64(s.(uint))) + + case []uint: + intSlice := s.([]uint) + logger.sBuff.AppendByte('[') + for _,v := range intSlice { + logger.sBuff.AppendUint(uint64(v)) + logger.sBuff.AppendByte(',') + } + + lastIdx := logger.sBuff.Len()-1 + if logger.sBuff.Bytes()[lastIdx] == ',' { + logger.sBuff.Bytes()[lastIdx] = ']' + }else{ + logger.sBuff.AppendByte(']') + } + + case uint8: + logger.sBuff.AppendUint(uint64(s.(uint8))) + case []uint8: + intSlice := s.([]uint8) + logger.sBuff.AppendByte('[') + for _,v := range intSlice { + logger.sBuff.AppendUint(uint64(v)) + logger.sBuff.AppendByte(',') + } + + lastIdx := logger.sBuff.Len()-1 + if logger.sBuff.Bytes()[lastIdx] == ',' { + logger.sBuff.Bytes()[lastIdx] = ']' + }else{ + logger.sBuff.AppendByte(']') + } + + case uint16: + logger.sBuff.AppendUint(uint64(s.(uint16))) + case []uint16: + intSlice := s.([]uint16) + logger.sBuff.AppendByte('[') + for _,v := range intSlice { + logger.sBuff.AppendUint(uint64(v)) + logger.sBuff.AppendByte(',') + } + + lastIdx := logger.sBuff.Len()-1 + if logger.sBuff.Bytes()[lastIdx] == ',' { + logger.sBuff.Bytes()[lastIdx] = ']' + }else{ + logger.sBuff.AppendByte(']') + } + case uint32: + logger.sBuff.AppendUint(uint64(s.(uint32))) + case []uint32: + intSlice := s.([]uint32) + logger.sBuff.AppendByte('[') + for _,v := range intSlice { + logger.sBuff.AppendUint(uint64(v)) + logger.sBuff.AppendByte(',') + } + + lastIdx := logger.sBuff.Len()-1 + if logger.sBuff.Bytes()[lastIdx] == ',' { + logger.sBuff.Bytes()[lastIdx] = ']' + }else{ + logger.sBuff.AppendByte(']') + } + case uint64: + logger.sBuff.AppendUint(s.(uint64)) + case []uint64: + intSlice := s.([]uint64) + logger.sBuff.AppendByte('[') + for _,v := range intSlice { + logger.sBuff.AppendUint(v) + logger.sBuff.AppendByte(',') + } + lastIdx := logger.sBuff.Len()-1 + if logger.sBuff.Bytes()[lastIdx] == ',' { + logger.sBuff.Bytes()[lastIdx] = ']' + }else{ + logger.sBuff.AppendByte(']') + } + case float32: + logger.sBuff.AppendFloat(float64(s.(float32)),32) + case []float32: + intSlice := s.([]float32) + logger.sBuff.AppendByte('[') + for _,v := range intSlice { + logger.sBuff.AppendFloat(float64(v),32) + logger.sBuff.AppendByte(',') + } + lastIdx := logger.sBuff.Len()-1 + if logger.sBuff.Bytes()[lastIdx] == ',' { + logger.sBuff.Bytes()[lastIdx] = ']' + }else{ + logger.sBuff.AppendByte(']') + } + case float64: + logger.sBuff.AppendFloat(s.(float64),64) + case []float64: + intSlice := s.([]float64) + logger.sBuff.AppendByte('[') + for _,v := range intSlice { + logger.sBuff.AppendFloat(v,64) + logger.sBuff.AppendByte(',') + } + lastIdx := logger.sBuff.Len()-1 + if logger.sBuff.Bytes()[lastIdx] == ',' { + logger.sBuff.Bytes()[lastIdx] = ']' + }else{ + logger.sBuff.AppendByte(']') + } + case bool: + logger.sBuff.AppendBool(s.(bool)) + case []bool: + intSlice := s.([]bool) + logger.sBuff.AppendByte('[') + for _,v := range intSlice { + logger.sBuff.AppendBool(v) + logger.sBuff.AppendByte(',') + } + lastIdx := logger.sBuff.Len()-1 + if logger.sBuff.Bytes()[lastIdx] == ',' { + logger.sBuff.Bytes()[lastIdx] = ']' + }else{ + logger.sBuff.AppendByte(']') + } + case string: + logger.sBuff.AppendString(s.(string)) + case *int: + val := s.(*int) + if val != nil { + logger.sBuff.AppendInt(int64(*val)) + }else{ + logger.sBuff.AppendString("nil<*int>") + } + case *int8: + val := s.(*int8) + if val != nil { + logger.sBuff.AppendInt(int64(*val)) + }else{ + logger.sBuff.AppendString("nil<*int8>") + } + case *int16: + val := s.(*int16) + if val != nil { + logger.sBuff.AppendInt(int64(*val)) + }else{ + logger.sBuff.AppendString("nil<*int16>") + } + case *int32: + val := s.(*int32) + if val != nil { + logger.sBuff.AppendInt(int64(*val)) + }else{ + logger.sBuff.AppendString("nil<*int32>") + } + case *int64: + val := s.(*int64) + if val != nil { + logger.sBuff.AppendInt(int64(*val)) + }else{ + logger.sBuff.AppendString("nil<*int64>") + } + case *uint: + val := s.(*uint) + if val != nil { + logger.sBuff.AppendUint(uint64(*val)) + }else{ + logger.sBuff.AppendString("nil<*uint>") + } + case *uint8: + val := s.(*uint8) + if val != nil { + logger.sBuff.AppendUint(uint64(*val)) + }else{ + logger.sBuff.AppendString("nil<*uint8>") + } + case *uint16: + val := s.(*uint16) + if val != nil { + logger.sBuff.AppendUint(uint64(*val)) + }else{ + logger.sBuff.AppendString("nil<*uint16>") + } + case *uint32: + val := s.(*uint32) + if val != nil { + logger.sBuff.AppendUint(uint64(*val)) + }else{ + logger.sBuff.AppendString("nil<*uint32>") + } + case *uint64: + val := s.(*uint64) + if val != nil { + logger.sBuff.AppendUint(uint64(*val)) + }else{ + logger.sBuff.AppendString("nil<*uint64>") + } + case *float32: + val := s.(*float32) + if val != nil { + logger.sBuff.AppendFloat(float64(*val),32) + }else{ + logger.sBuff.AppendString("nil<*float32>") + } + case *float64: + val := s.(*float32) + if val != nil { + logger.sBuff.AppendFloat(float64(*val),64) + }else{ + logger.sBuff.AppendString("nil<*float64>") + } + case *bool: + val := s.(*bool) + if val != nil { + logger.sBuff.AppendBool(*val) + }else{ + logger.sBuff.AppendString("nil<*bool>") + } + case *string: + val := s.(*string) + if val != nil { + logger.sBuff.AppendString(*val) + }else{ + logger.sBuff.AppendString("nil<*string>") + } + //case []byte: + // logger.buf.AppendBytes(s.([]byte)) + default: + //b,err := json.MarshalToString(s) + //if err != nil { + logger.sBuff.AppendString("") + //}else{ + //logger.buf.AppendBytes(b) + //} + } + } + + return logger.sBuff.String() +} + +func SDebug(a ...interface{}) { + gLogger.sBuff.Locker() + defer gLogger.sBuff.UnLocker() + + gLogger.Debug(gLogger.doSPrintf(a)) +} + +func SInfo(a ...interface{}) { + gLogger.sBuff.Locker() + defer gLogger.sBuff.UnLocker() + + gLogger.Info(gLogger.doSPrintf(a)) } func SWarning(a ...interface{}) { - gLogger.doSPrintf(warningLevel, printWarningLevel, a) + gLogger.sBuff.Locker() + defer gLogger.sBuff.UnLocker() + + gLogger.Warning(gLogger.doSPrintf(a)) } func SError(a ...interface{}) { - gLogger.doSPrintf(errorLevel, printErrorLevel, a) + gLogger.sBuff.Locker() + defer gLogger.sBuff.UnLocker() + + gLogger.Error(gLogger.doSPrintf(a)) } func SStack(a ...interface{}) { - gLogger.doSPrintf(stackLevel, printStackLevel, a) - gLogger.doSPrintf(stackLevel, printStackLevel, []interface{}{string(debug.Stack())}) + gLogger.sBuff.Locker() + defer gLogger.sBuff.UnLocker() + + gLogger.Stack(gLogger.doSPrintf(a)) } func SFatal(a ...interface{}) { - gLogger.doSPrintf(fatalLevel, printFatalLevel, a) -} - -const timeFlag = syslog.Ldate|syslog.Ltime|syslog.Lmicroseconds -func (logger *Logger) formatHeader(buf *Buffer,calldepth int,t *time.Time) { - var file string - var line int - if logger.flag&(syslog.Lshortfile|syslog.Llongfile) != 0 { - // Release lock while getting caller info - it's expensive. - var ok bool - _, file, line, ok = runtime.Caller(calldepth) - if !ok { - file = "???" - line = 0 - } - } - - if logger.flag&syslog.Lmsgprefix != 0 { - buf.AppendString(logger.filepre) - } - if logger.flag&timeFlag != 0 { - if logger.flag&syslog.Ldate != 0 { - year, month, day := t.Date() - buf.AppendInt(int64(year)) - buf.AppendByte('/') - buf.AppendInt(int64(month)) - buf.AppendByte('/') - buf.AppendInt(int64(day)) - buf.AppendByte(' ') - } - - if logger.flag&(syslog.Ltime|syslog.Lmicroseconds) != 0 { - hour, min, sec := t.Clock() - buf.AppendInt(int64(hour)) - buf.AppendByte(':') - buf.AppendInt(int64(min)) - buf.AppendByte(':') - - buf.AppendInt(int64(sec)) - - if logger.flag&syslog.Lmicroseconds != 0 { - buf.AppendByte('.') - buf.AppendInt(int64(t.Nanosecond()/1e3)) - } - buf.AppendByte(' ') - } - } - if logger.flag&(syslog.Lshortfile|syslog.Llongfile) != 0 { - if logger.flag&syslog.Lshortfile != 0 { - short := file - for i := len(file) - 1; i > 0; i-- { - if file[i] == '/' { - short = file[i+1:] - break - } - } - file = short - } - buf.AppendString(file) - buf.AppendByte(':') - buf.AppendInt(int64(line)) - buf.AppendString(": ") - } - - if logger.flag&syslog.Lmsgprefix != 0 { - buf.AppendString(logger.filepre) - } + gLogger.sBuff.Locker() + defer gLogger.sBuff.UnLocker() + + gLogger.Fatal(gLogger.doSPrintf(a)) } diff --git a/network/http_server.go b/network/http_server.go index f22b4af..e19652d 100644 --- a/network/http_server.go +++ b/network/http_server.go @@ -47,7 +47,7 @@ func (slf *HttpServer) startListen() error { for _, caFile := range slf.caFileList { cer, err := tls.LoadX509KeyPair(caFile.CertFile, caFile.Keyfile) if err != nil { - log.SFatal("Load CA [",caFile.CertFile,"]-[",caFile.Keyfile,"] file is fail:",err.Error()) + log.Fatal("Load CA file is fail",log.String("error",err.Error()),log.String("certFile",caFile.CertFile),log.String("keyFile",caFile.Keyfile)) return err } tlsCaList = append(tlsCaList, cer) @@ -74,7 +74,7 @@ func (slf *HttpServer) startListen() error { } if err != nil { - log.SFatal("Listen for address ",slf.listenAddr," failure:",err.Error()) + log.Fatal("Listen failure",log.String("error",err.Error()),log.String("addr:",slf.listenAddr)) return err } diff --git a/network/processor/jsonprocessor.go b/network/processor/jsonprocessor.go index 661a6ab..adfbcdd 100644 --- a/network/processor/jsonprocessor.go +++ b/network/processor/jsonprocessor.go @@ -106,7 +106,7 @@ func (jsonProcessor *JsonProcessor) MakeRawMsg(msgType uint16,msg []byte) *JsonP func (jsonProcessor *JsonProcessor) UnknownMsgRoute(clientId uint64,msg interface{}){ if jsonProcessor.unknownMessageHandler==nil { - log.SDebug("Unknown message received from ",clientId) + log.Debug("Unknown message",log.Uint64("clientId",clientId)) return } diff --git a/network/tcp_client.go b/network/tcp_client.go index 8760c32..228135e 100644 --- a/network/tcp_client.go +++ b/network/tcp_client.go @@ -40,29 +40,29 @@ func (client *TCPClient) init() { if client.ConnNum <= 0 { client.ConnNum = 1 - log.SRelease("invalid ConnNum, reset to ", client.ConnNum) + log.Info("invalid ConnNum",log.Int("reset", client.ConnNum)) } if client.ConnectInterval <= 0 { client.ConnectInterval = 3 * time.Second - log.SRelease("invalid ConnectInterval, reset to ", client.ConnectInterval) + log.Info("invalid ConnectInterval",log.Duration("reset", client.ConnectInterval)) } if client.PendingWriteNum <= 0 { client.PendingWriteNum = 1000 - log.SRelease("invalid PendingWriteNum, reset to ", client.PendingWriteNum) + log.Info("invalid PendingWriteNum",log.Int("reset",client.PendingWriteNum)) } if client.ReadDeadline == 0 { client.ReadDeadline = 15*time.Second - log.SRelease("invalid ReadDeadline, reset to ", int64(client.ReadDeadline.Seconds()),"s") + log.Info("invalid ReadDeadline",log.Int64("reset", int64(client.ReadDeadline.Seconds()))) } if client.WriteDeadline == 0 { client.WriteDeadline = 15*time.Second - log.SRelease("invalid WriteDeadline, reset to ", int64(client.WriteDeadline.Seconds()),"s") + log.Info("invalid WriteDeadline",log.Int64("reset", int64(client.WriteDeadline.Seconds()))) } if client.NewAgent == nil { - log.SFatal("NewAgent must not be nil") + log.Fatal("NewAgent must not be nil") } if client.cons != nil { - log.SFatal("client is running") + log.Fatal("client is running") } if client.MinMsgLen == 0 { @@ -77,7 +77,7 @@ func (client *TCPClient) init() { maxMsgLen := client.MsgParser.getMaxMsgLen(client.LenMsgLen) if client.MaxMsgLen > maxMsgLen { client.MaxMsgLen = maxMsgLen - log.SRelease("invalid MaxMsgLen, reset to ", maxMsgLen) + log.Info("invalid MaxMsgLen",log.Uint32("reset", maxMsgLen)) } client.cons = make(ConnSet) @@ -102,7 +102,7 @@ func (client *TCPClient) dial() net.Conn { return conn } - log.SWarning("connect to ",client.Addr," error:", err.Error()) + log.Warning("connect error ",log.String("error",err.Error()), log.String("Addr",client.Addr)) time.Sleep(client.ConnectInterval) continue } diff --git a/network/tcp_conn.go b/network/tcp_conn.go index b309b0d..094e472 100644 --- a/network/tcp_conn.go +++ b/network/tcp_conn.go @@ -92,7 +92,7 @@ func (tcpConn *TCPConn) GetRemoteIp() string { func (tcpConn *TCPConn) doWrite(b []byte) error{ if len(tcpConn.writeChan) == cap(tcpConn.writeChan) { tcpConn.ReleaseReadMsg(b) - log.SError("close conn: channel full") + log.Error("close conn: channel full") tcpConn.doDestroy() return errors.New("close conn: channel full") } diff --git a/network/tcp_server.go b/network/tcp_server.go index 3262c23..02c7d4f 100644 --- a/network/tcp_server.go +++ b/network/tcp_server.go @@ -43,52 +43,52 @@ func (server *TCPServer) Start() { func (server *TCPServer) init() { ln, err := net.Listen("tcp", server.Addr) if err != nil { - log.SFatal("Listen tcp error:", err.Error()) + log.Fatal("Listen tcp fail",log.String("error", err.Error())) } if server.MaxConnNum <= 0 { server.MaxConnNum = Default_MaxConnNum - log.SRelease("invalid MaxConnNum, reset to ", server.MaxConnNum) + log.Info("invalid MaxConnNum",log.Int("reset", server.MaxConnNum)) } if server.PendingWriteNum <= 0 { server.PendingWriteNum = Default_PendingWriteNum - log.SRelease("invalid PendingWriteNum, reset to ", server.PendingWriteNum) + log.Info("invalid PendingWriteNum",log.Int("reset", server.PendingWriteNum)) } if server.LenMsgLen <= 0 { server.LenMsgLen = Default_LenMsgLen - log.SRelease("invalid LenMsgLen, reset to ", server.LenMsgLen) + log.Info("invalid LenMsgLen", log.Int("reset", server.LenMsgLen)) } if server.MaxMsgLen <= 0 { server.MaxMsgLen = Default_MaxMsgLen - log.SRelease("invalid MaxMsgLen, reset to ", server.MaxMsgLen) + log.Info("invalid MaxMsgLen", log.Uint32("reset to", server.MaxMsgLen)) } maxMsgLen := server.MsgParser.getMaxMsgLen(server.LenMsgLen) if server.MaxMsgLen > maxMsgLen { server.MaxMsgLen = maxMsgLen - log.SRelease("invalid MaxMsgLen, reset to ", maxMsgLen) + log.Info("invalid MaxMsgLen",log.Uint32("reset", maxMsgLen)) } if server.MinMsgLen <= 0 { server.MinMsgLen = Default_MinMsgLen - log.SRelease("invalid MinMsgLen, reset to ", server.MinMsgLen) + log.Info("invalid MinMsgLen",log.Uint32("reset", server.MinMsgLen)) } if server.WriteDeadline == 0 { server.WriteDeadline = Default_WriteDeadline - log.SRelease("invalid WriteDeadline, reset to ", server.WriteDeadline.Seconds(),"s") + log.Info("invalid WriteDeadline",log.Int64("reset",int64(server.WriteDeadline.Seconds()))) } if server.ReadDeadline == 0 { server.ReadDeadline = Default_ReadDeadline - log.SRelease("invalid ReadDeadline, reset to ", server.ReadDeadline.Seconds(),"s") + log.Info("invalid ReadDeadline",log.Int64("reset", int64(server.ReadDeadline.Seconds()))) } if server.NewAgent == nil { - log.SFatal("NewAgent must not be nil") + log.Fatal("NewAgent must not be nil") } server.ln = ln @@ -121,7 +121,7 @@ func (server *TCPServer) run() { if max := 1 * time.Second; tempDelay > max { tempDelay = max } - log.SRelease("accept error:",err.Error(),"; retrying in ", tempDelay) + log.Info("accept fail",log.String("error",err.Error()),log.Duration("sleep time", tempDelay)) time.Sleep(tempDelay) continue } @@ -135,7 +135,7 @@ func (server *TCPServer) run() { if len(server.conns) >= server.MaxConnNum { server.mutexConns.Unlock() conn.Close() - log.SWarning("too many connections") + log.Warning("too many connections") continue } diff --git a/network/ws_client.go b/network/ws_client.go index 07a28e4..3c310d5 100644 --- a/network/ws_client.go +++ b/network/ws_client.go @@ -40,29 +40,29 @@ func (client *WSClient) init() { if client.ConnNum <= 0 { client.ConnNum = 1 - log.SRelease("invalid ConnNum, reset to ", client.ConnNum) + log.Info("invalid ConnNum",log.Int("reset", client.ConnNum)) } if client.ConnectInterval <= 0 { client.ConnectInterval = 3 * time.Second - log.SRelease("invalid ConnectInterval, reset to ", client.ConnectInterval) + log.Info("invalid ConnectInterval",log.Duration("reset", client.ConnectInterval)) } if client.PendingWriteNum <= 0 { client.PendingWriteNum = 100 - log.SRelease("invalid PendingWriteNum, reset to ", client.PendingWriteNum) + log.Info("invalid PendingWriteNum",log.Int("reset", client.PendingWriteNum)) } if client.MaxMsgLen <= 0 { client.MaxMsgLen = 4096 - log.SRelease("invalid MaxMsgLen, reset to ", client.MaxMsgLen) + log.Info("invalid MaxMsgLen",log.Uint32("reset", client.MaxMsgLen)) } if client.HandshakeTimeout <= 0 { client.HandshakeTimeout = 10 * time.Second - log.SRelease("invalid HandshakeTimeout, reset to ", client.HandshakeTimeout) + log.Info("invalid HandshakeTimeout",log.Duration("reset", client.HandshakeTimeout)) } if client.NewAgent == nil { - log.SFatal("NewAgent must not be nil") + log.Fatal("NewAgent must not be nil") } if client.cons != nil { - log.SFatal("client is running") + log.Fatal("client is running") } if client.MessageType == 0 { @@ -83,7 +83,7 @@ func (client *WSClient) dial() *websocket.Conn { return conn } - log.SRelease("connect to ", client.Addr," error: ", err.Error()) + log.Info("connect fail", log.String("error",err.Error()),log.String("addr",client.Addr)) time.Sleep(client.ConnectInterval) continue } diff --git a/network/ws_conn.go b/network/ws_conn.go index 2c4fc29..339531d 100644 --- a/network/ws_conn.go +++ b/network/ws_conn.go @@ -75,7 +75,7 @@ func (wsConn *WSConn) Close() { func (wsConn *WSConn) doWrite(b []byte) { if len(wsConn.writeChan) == cap(wsConn.writeChan) { - log.SDebug("close conn: channel full") + log.Debug("close conn: channel full") wsConn.doDestroy() return } diff --git a/network/ws_server.go b/network/ws_server.go index fa065f0..e5b3c88 100644 --- a/network/ws_server.go +++ b/network/ws_server.go @@ -47,7 +47,7 @@ func (handler *WSHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) { } conn, err := handler.upgrader.Upgrade(w, r, nil) if err != nil { - log.SError("upgrade error: ", err.Error()) + log.Error("upgrade fail",log.String("error",err.Error())) return } conn.SetReadLimit(int64(handler.maxMsgLen)) @@ -67,7 +67,7 @@ func (handler *WSHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(handler.conns) >= handler.maxConnNum { handler.mutexConns.Unlock() conn.Close() - log.SWarning("too many connections") + log.Warning("too many connections") return } handler.conns[conn] = struct{}{} @@ -95,27 +95,27 @@ func (server *WSServer) SetMessageType(messageType int) { func (server *WSServer) Start() { ln, err := net.Listen("tcp", server.Addr) if err != nil { - log.SFatal("WSServer Listen fail:", err.Error()) + log.Fatal("WSServer Listen fail",log.String("error", err.Error())) } if server.MaxConnNum <= 0 { server.MaxConnNum = 100 - log.SRelease("invalid MaxConnNum, reset to ", server.MaxConnNum) + log.Info("invalid MaxConnNum", log.Int("reset", server.MaxConnNum)) } if server.PendingWriteNum <= 0 { server.PendingWriteNum = 100 - log.SRelease("invalid PendingWriteNum, reset to ", server.PendingWriteNum) + log.Info("invalid PendingWriteNum", log.Int("reset", server.PendingWriteNum)) } if server.MaxMsgLen <= 0 { server.MaxMsgLen = 4096 - log.SRelease("invalid MaxMsgLen, reset to ", server.MaxMsgLen) + log.Info("invalid MaxMsgLen", log.Uint32("reset", server.MaxMsgLen)) } if server.HTTPTimeout <= 0 { server.HTTPTimeout = 10 * time.Second - log.SRelease("invalid HTTPTimeout, reset to ", server.HTTPTimeout) + log.Info("invalid HTTPTimeout", log.Duration("reset", server.HTTPTimeout)) } if server.NewAgent == nil { - log.SFatal("NewAgent must not be nil") + log.Fatal("NewAgent must not be nil") } if server.CertFile != "" || server.KeyFile != "" { @@ -126,7 +126,7 @@ func (server *WSServer) Start() { config.Certificates = make([]tls.Certificate, 1) config.Certificates[0], err = tls.LoadX509KeyPair(server.CertFile, server.KeyFile) if err != nil { - log.SFatal("LoadX509KeyPair fail:", err.Error()) + log.Fatal("LoadX509KeyPair fail",log.String("error", err.Error())) } ln = tls.NewListener(ln, config) diff --git a/node/node.go b/node/node.go index ebb1e36..21b7798 100644 --- a/node/node.go +++ b/node/node.go @@ -11,7 +11,6 @@ import ( "github.com/duanhf2012/origin/util/buildtime" "github.com/duanhf2012/origin/util/timer" "io" - slog "log" "net/http" _ "net/http/pprof" "os" @@ -20,6 +19,7 @@ import ( "strings" "syscall" "time" + "log/slog" ) var sig chan os.Signal @@ -28,7 +28,7 @@ var preSetupService []service.IService //预安装 var profilerInterval time.Duration var bValid bool var configDir = "./config/" -var logLevel string = "debug" +var logLevel slog.Level = log.LevelTrace var logPath string type BuildOSType = int8 @@ -50,6 +50,7 @@ func init() { console.RegisterCommandString("console", "", "<-console true|false> Turn on or off screen log output.", openConsole) console.RegisterCommandString("loglevel", "debug", "<-loglevel debug|release|warning|error|fatal> Set loglevel.", setLevel) console.RegisterCommandString("logpath", "", "<-logpath path> Set log file path.", setLogPath) + console.RegisterCommandInt("logsize", 0, "<-logsize size> Set log size(MB).", setLogSize) console.RegisterCommandString("pprof", "", "<-pprof ip:port> Open performance analysis.", setPprof) } @@ -144,7 +145,7 @@ func initNode(id int) { nodeId = id err := cluster.GetCluster().Init(GetNodeId(), Setup) if err != nil { - log.SFatal("read system config is error ", err.Error()) + log.Fatal("read system config is error ",log.ErrorAttr("error",err)) } err = initLog() @@ -168,7 +169,7 @@ func initNode(id int) { } if bSetup == false { - log.SFatal("Service name "+serviceName+" configuration error") + log.Fatal("Service name "+serviceName+" configuration error") } } @@ -183,7 +184,7 @@ func initLog() error { localnodeinfo := cluster.GetCluster().GetLocalNodeInfo() filepre := fmt.Sprintf("%s_%d_", localnodeinfo.NodeName, localnodeinfo.NodeId) - logger, err := log.New(logLevel, logPath, filepre, slog.LstdFlags|slog.Lshortfile, 10) + logger, err := log.NewTextLogger(logLevel,logPath,filepre,true) if err != nil { fmt.Printf("cannot create log file!\n") return err @@ -248,7 +249,7 @@ func startNode(args interface{}) error { } timer.StartTimer(10*time.Millisecond, 1000000) - log.SRelease("Start running server.") + log.Info("Start running server.") //2.初始化node initNode(nodeId) @@ -270,7 +271,7 @@ func startNode(args interface{}) error { for bRun { select { case <-sig: - log.SRelease("receipt stop signal.") + log.Info("receipt stop signal.") bRun = false case <-pProfilerTicker.C: profiler.Report() @@ -280,7 +281,7 @@ func startNode(args interface{}) error { //7.退出 service.StopAllService() - log.SRelease("Server is stop.") + log.Info("Server is stop.") return nil } @@ -304,10 +305,6 @@ func GetConfigDir() string { return configDir } -func SetSysLog(strLevel string, pathname string, flag int) { - logs, _ := log.New(strLevel, pathname, "", flag, 10) - log.Export(logs) -} func OpenProfilerReport(interval time.Duration) { profilerInterval = interval @@ -333,9 +330,24 @@ func setLevel(args interface{}) error { return nil } - logLevel = strings.TrimSpace(args.(string)) - if logLevel != "debug" && logLevel != "release" && logLevel != "warning" && logLevel != "error" && logLevel != "fatal" { - return errors.New("unknown level: " + logLevel) + strlogLevel := strings.TrimSpace(args.(string)) + switch strlogLevel { + case "trace": + logLevel = log.LevelTrace + case "debug": + logLevel = log.LevelDebug + case "info": + logLevel = log.LevelInfo + case "warning": + logLevel = log.LevelWarning + case "error": + logLevel = log.LevelError + case "stack": + logLevel = log.LevelStack + case "fatal": + logLevel = log.LevelFatal + default: + return errors.New("unknown level: " + strlogLevel) } return nil } @@ -359,3 +371,17 @@ func setLogPath(args interface{}) error { return nil } + +func setLogSize(args interface{}) error { + if args == "" { + return nil + } + logSize,ok := args.(int) + if ok == false{ + return errors.New("param logsize is error") + } + + log.LogSize = int64(logSize)*1024*1024 + + return nil +} diff --git a/profiler/profiler.go b/profiler/profiler.go index e110a8c..6ad99e2 100644 --- a/profiler/profiler.go +++ b/profiler/profiler.go @@ -167,7 +167,7 @@ func DefaultReportFunction(name string,callNum int,costTime time.Duration,record elem = elem.Next() } - log.SRelease(strReport) + log.Info("report",strReport) } func Report() { diff --git a/rpc/client.go b/rpc/client.go index 41768e5..25931e9 100644 --- a/rpc/client.go +++ b/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 } diff --git a/rpc/lclient.go b/rpc/lclient.go index b49c545..c88474d 100644 --- a/rpc/lclient.go +++ b/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 } diff --git a/rpc/rclient.go b/rpc/rclient.go index 990c727..33d6b13 100644 --- a/rpc/rclient.go +++ b/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 } } diff --git a/rpc/rpchandler.go b/rpc/rpchandler.go index d2622fc..459e5e5 100644 --- a/rpc/rpchandler.go +++ b/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 } diff --git a/rpc/server.go b/rpc/server.go index f2580df..efbf545 100644 --- a/rpc/server.go +++ b/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 } diff --git a/service/module.go b/service/module.go index bc4e502..d208484 100644 --- a/service/module.go +++ b/service/module.go @@ -117,7 +117,7 @@ func (m *Module) AddModule(module IModule) (uint32, error) { m.child[module.GetModuleId()] = module m.ancestor.getBaseModule().(*Module).descendants[module.GetModuleId()] = module - log.SDebug("Add module ", module.GetModuleName(), " completed") + log.Debug("Add module "+module.GetModuleName()+ " completed") return module.GetModuleId(), nil } @@ -131,7 +131,7 @@ func (m *Module) ReleaseModule(moduleId uint32) { pModule.self.OnRelease() pModule.GetEventHandler().Destroy() - log.SDebug("Release module ", pModule.GetModuleName()) + log.Debug("Release module "+ pModule.GetModuleName()) for pTimer := range pModule.mapActiveTimer { pTimer.Cancel() } @@ -278,18 +278,18 @@ func (m *Module) SafeNewTicker(tickerId *uint64, d time.Duration, AdditionData i func (m *Module) CancelTimerId(timerId *uint64) bool { if timerId==nil || *timerId == 0 { - log.SWarning("timerId is invalid") + log.Warning("timerId is invalid") return false } if m.mapActiveIdTimer == nil { - log.SError("mapActiveIdTimer is nil") + log.Error("mapActiveIdTimer is nil") return false } t, ok := m.mapActiveIdTimer[*timerId] if ok == false { - log.SStack("cannot find timer id ", timerId) + log.Stack("cannot find timer id ", log.Uint64("timerId",*timerId)) return false } diff --git a/service/service.go b/service/service.go index 9a9d28d..cd8da8f 100644 --- a/service/service.go +++ b/service/service.go @@ -93,7 +93,7 @@ func (s *Service) OnSetup(iService IService){ func (s *Service) OpenProfiler() { s.profiler = profiler.RegProfiler(s.GetName()) if s.profiler==nil { - log.SFatal("rofiler.RegProfiler ",s.GetName()," fail.") + log.Fatal("rofiler.RegProfiler "+s.GetName()+" fail.") } } @@ -128,7 +128,7 @@ func (s *Service) Start() { s.wg.Add(1) waitRun.Add(1) go func(){ - log.SRelease(s.GetName()," service is running",) + log.Info(s.GetName()+" service is running",) waitRun.Done() s.Run() }() @@ -158,12 +158,12 @@ func (s *Service) Run() { case event.ServiceRpcRequestEvent: cEvent,ok := ev.(*event.Event) if ok == false { - log.SError("Type event conversion error") + log.Error("Type event conversion error") break } rpcRequest,ok := cEvent.Data.(*rpc.RpcRequest) if ok == false { - log.SError("Type *rpc.RpcRequest conversion error") + log.Error("Type *rpc.RpcRequest conversion error") break } if s.profiler!=nil { @@ -179,12 +179,12 @@ func (s *Service) Run() { case event.ServiceRpcResponseEvent: cEvent,ok := ev.(*event.Event) if ok == false { - log.SError("Type event conversion error") + log.Error("Type event conversion error") break } rpcResponseCB,ok := cEvent.Data.(*rpc.Call) if ok == false { - log.SError("Type *rpc.Call conversion error") + log.Error("Type *rpc.Call conversion error") break } if s.profiler!=nil { @@ -242,7 +242,7 @@ func (s *Service) Release(){ 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)) } }() @@ -257,10 +257,10 @@ func (s *Service) OnInit() error { } func (s *Service) Stop(){ - log.SRelease("stop ",s.GetName()," service ") + log.Info("stop "+s.GetName()+" service ") close(s.closeSig) s.wg.Wait() - log.SRelease(s.GetName()," service has been stopped") + log.Info(s.GetName()+" service has been stopped") } func (s *Service) GetServiceCfg()interface{}{ @@ -353,7 +353,7 @@ func (s *Service) PushEvent(ev event.IEvent) error{ func (s *Service) pushEvent(ev event.IEvent) error{ if len(s.chanEvent) >= maxServiceEventChannelNum { err := errors.New("The event channel in the service is full") - log.SError(err.Error()) + log.Error(err.Error()) return err } @@ -380,7 +380,7 @@ func (s *Service) SetEventChannelNum(num int){ func (s *Service) SetGoRoutineNum(goroutineNum int32) bool { //已经开始状态不允许修改协程数量,打开性能分析器不允许开多线程 if s.startStatus == true || s.profiler!=nil { - log.SError("open profiler mode is not allowed to set Multi-coroutine.") + log.Error("open profiler mode is not allowed to set Multi-coroutine.") return false } diff --git a/sysservice/rankservice/MongodbPersist.go b/sysservice/rankservice/MongodbPersist.go index 8947c76..d07d03b 100644 --- a/sysservice/rankservice/MongodbPersist.go +++ b/sysservice/rankservice/MongodbPersist.go @@ -297,7 +297,7 @@ func (mp *MongoPersist) saveToDB(){ 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)) } }() diff --git a/sysservice/tcpservice/tcpservice.go b/sysservice/tcpservice/tcpservice.go index 46875ae..09945c4 100644 --- a/sysservice/tcpservice/tcpservice.go +++ b/sysservice/tcpservice/tcpservice.go @@ -170,7 +170,7 @@ func (slf *Client) Run() { 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)) } }() @@ -183,7 +183,7 @@ func (slf *Client) Run() { slf.tcpConn.SetReadDeadline(slf.tcpService.tcpServer.ReadDeadline) bytes,err := slf.tcpConn.ReadMsg() if err != nil { - log.SDebug("read client id ",slf.id," is error:",err.Error()) + log.Debug("read client failed",log.ErrorAttr("error",err),log.Uint64("clientId",slf.id)) break } data,err:=slf.tcpService.process.Unmarshal(slf.id,bytes) diff --git a/util/timer/timer.go b/util/timer/timer.go index 08ee52b..f531cb1 100644 --- a/util/timer/timer.go +++ b/util/timer/timer.go @@ -132,7 +132,7 @@ func (t *Timer) Do() { 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)) } }() @@ -218,7 +218,7 @@ func (c *Cron) Do() { 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)) } }() @@ -274,7 +274,7 @@ func (c *Ticker) Do() { 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)) } }()