chenyh
/
vRp.CD2g_test
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

other: 日志字段调用由 zap.Field 更改为 log.Field

This commit is contained in:
kercylan98 2023-07-15 09:36:24 +08:00
parent 25ed712fc9
commit 8e2b4ebc89
15 changed files with 80 additions and 89 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
config/config.go
View File

@ -4,7 +4,6 @@ import (
jsonIter "github.com/json-iterator/go"
"github.com/kercylan98/minotaur/utils/log"
"github.com/kercylan98/minotaur/utils/timer"
"go.uber.org/zap"
"os"
"path/filepath"
"sync"
@ -51,7 +50,7 @@ func Load() {
return err
}
if err = json.Unmarshal(bytes, &config); err == nil && isInit {
log.Info("Config", zap.String("Name", filename), zap.Bool("LoadSuccess", true))
log.Info("Config", log.String("Name", filename), log.Bool("LoadSuccess", true))
}
return err
})

5
game/builtin/room.go
View File

@ -5,7 +5,6 @@ import (
"github.com/kercylan98/minotaur/utils/asynchronous"
"github.com/kercylan98/minotaur/utils/hash"
"github.com/kercylan98/minotaur/utils/log"
"go.uber.org/zap"
)
// NewRoom 创建一个默认的内置游戏房间 Room
@ -90,7 +89,7 @@ func (slf *Room[PlayerID, Player]) Join(player Player) error {
}
slf.players.Set(playerId, player)
if !exist {
log.Debug("Room.Join", zap.Any("guid", slf.GetGuid()), zap.Any("player", playerId))
log.Debug("Room.Join", log.Any("guid", slf.GetGuid()), log.Any("player", playerId))
if slf.players.Size() == 1 && !slf.noMaster {
slf.owner = playerId
}
@ -105,7 +104,7 @@ func (slf *Room[PlayerID, Player]) Leave(id PlayerID) {
if !exist {
return
}
log.Debug("Room.Leave", zap.Any("guid", slf.GetGuid()), zap.Any("player", id))
log.Debug("Room.Leave", log.Any("guid", slf.GetGuid()), log.Any("player", id))
slf.OnPlayerLeaveRoomEvent(player)
slf.players.Delete(id)
}

9
game/builtin/world.go
View File

@ -5,7 +5,6 @@ import (
"github.com/kercylan98/minotaur/utils/hash"
"github.com/kercylan98/minotaur/utils/log"
"github.com/kercylan98/minotaur/utils/synchronization"
"go.uber.org/zap"
"sync/atomic"
)
@ -103,7 +102,7 @@ func (slf *World[PlayerID, Player]) Join(player Player) error {
if slf.players.Size() >= slf.playerLimit && slf.playerLimit > 0 {
return ErrWorldPlayerLimit
}
log.Debug("World.Join", zap.Int64("guid", slf.GetGuid()), zap.Any("player", player.GetID()))
log.Debug("World.Join", log.Int64("guid", slf.GetGuid()), log.Any("player", player.GetID()))
slf.players.Set(player.GetID(), player)
if actors := slf.playerActors.Get(player.GetID()); actors == nil {
actors = synchronization.NewMap[int64, game.Actor]()
@ -118,7 +117,7 @@ func (slf *World[PlayerID, Player]) Leave(id PlayerID) {
if !exist {
return
}
log.Debug("World.Leave", zap.Int64("guid", slf.GetGuid()), zap.Any("player", player.GetID()))
log.Debug("World.Leave", log.Int64("guid", slf.GetGuid()), log.Any("player", player.GetID()))
slf.OnPlayerLeaveWorldEvent(player)
slf.playerActors.Get(player.GetID()).Range(func(guid int64, actor game.Actor) {
slf.OnActorAnnihilationEvent(actor)
@ -170,7 +169,7 @@ func (slf *World[PlayerID, Player]) RemoveActorOwner(guid int64) {
}
func (slf *World[PlayerID, Player]) Reset() {
log.Debug("World", zap.Int64("Reset", slf.guid))
log.Debug("World", log.Int64("Reset", slf.guid))
slf.players.Clear()
slf.playerActors.Range(func(id PlayerID, actors hash.Map[int64, game.Actor]) {
actors.Clear()
@ -184,7 +183,7 @@ func (slf *World[PlayerID, Player]) Reset() {
func (slf *World[PlayerID, Player]) Release() {
if !slf.released.Swap(true) {
log.Debug("World", zap.Int64("Release", slf.guid))
log.Debug("World", log.Int64("Release", slf.guid))
slf.OnWorldReleaseEvent()
slf.Reset()
slf.players = nil

7
notify/manager.go
View File

@ -2,7 +2,6 @@ package notify
import (
"github.com/kercylan98/minotaur/utils/log"
"go.uber.org/zap"
"reflect"
)
@ -20,19 +19,19 @@ func NewManager(senders ...Sender) *Manager {
case <-manager.closeChannel:
close(manager.closeChannel)
close(manager.notifyChannel)
log.Info("Manager", zap.String("state", "release"))
log.Info("Manager", log.String("state", "release"))
return
case notify := <-manager.notifyChannel:
for _, sender := range manager.senders {
if err := sender.Push(notify); err != nil {
log.Error("Manager", zap.String("sender", reflect.TypeOf(sender).String()), zap.Error(err))
log.Error("Manager", log.String("sender", reflect.TypeOf(sender).String()), log.Err(err))
}
}
}
}
}()
log.Info("Manager", zap.String("state", "running"))
log.Info("Manager", log.String("state", "running"))
return manager
}

31
planner/configexport/configexport.go
View File

@ -8,7 +8,6 @@ import (
"github.com/kercylan98/minotaur/utils/log"
"github.com/kercylan98/minotaur/utils/str"
"github.com/tealeg/xlsx"
"go.uber.org/zap"
"os/exec"
"path/filepath"
"runtime/debug"
@ -29,21 +28,21 @@ func New(xlsxPath string) *ConfigExport {
switch err {
case internal.ErrReadConfigFailedSame:
log.Warn("ConfigExport",
zap.String("File", xlsxPath),
zap.String("Sheet", sheet.Name),
zap.String("Info", "A configuration with the same name exists, skipped"),
log.String("File", xlsxPath),
log.String("Sheet", sheet.Name),
log.String("Info", "A configuration with the same name exists, skipped"),
)
case internal.ErrReadConfigFailedIgnore:
log.Info("ConfigExport",
zap.String("File", xlsxPath),
zap.String("Sheet", sheet.Name),
zap.String("Info", "Excluded non-configuration table files"),
log.String("File", xlsxPath),
log.String("Sheet", sheet.Name),
log.String("Info", "Excluded non-configuration table files"),
)
default:
log.Error("ConfigExport",
zap.String("File", xlsxPath),
zap.String("Sheet", sheet.Name),
zap.String("Info", "Excluded non-configuration table files"),
log.String("File", xlsxPath),
log.String("Sheet", sheet.Name),
log.String("Info", "Excluded non-configuration table files"),
)
debug.PrintStack()
}
@ -55,9 +54,9 @@ func New(xlsxPath string) *ConfigExport {
ce.exist[config.Name] = true
log.Info("ConfigExport",
zap.String("File", xlsxPath),
zap.String("Sheet", sheet.Name),
zap.String("Info", "Export successfully"),
log.String("File", xlsxPath),
log.String("Sheet", sheet.Name),
log.String("Info", "Export successfully"),
)
}
}
@ -84,9 +83,9 @@ func Merge(exports ...*ConfigExport) *ConfigExport {
for _, config := range ce.configs {
if _, ok := export.exist[config.Name]; ok {
log.Warn("ConfigExport",
zap.String("File", ce.xlsxPath),
zap.String("Sheet", config.Name),
zap.String("Info", "A configuration with the same name exists, skipped"),
log.String("File", ce.xlsxPath),
log.String("Sheet", config.Name),
log.String("Info", "A configuration with the same name exists, skipped"),
)
continue
}

4
planner/configexport/example/config.go
View File

@ -25,12 +25,12 @@ func LoadConfig(handle func(filename string, config any) error) {
var err error
_IndexConfig = make(map[int]map[string]*IndexConfigDefine)
if err = handle("IndexConfig.json", &_IndexConfig); err != nil {
log.Error("Config", zap.String("Name", "IndexConfig"), zap.Bool("Invalid", true), zap.Error(err))
log.Err("Config", log.String("Name", "IndexConfig"), log.Bool("Invalid", true), log.Err(err))
}
_EasyConfig = new(EasyConfigDefine)
if err = handle("EasyConfig.json", _EasyConfig); err != nil {
log.Error("Config", zap.String("Name", "EasyConfig"), zap.Bool("Invalid", true), zap.Error(err))
log.Err("Config", log.String("Name", "EasyConfig"), log.Bool("Invalid", true), log.Err(err))
}
}

4
planner/configexport/internal/template.go
View File

@ -59,11 +59,11 @@ func LoadConfig(handle func(filename string, config any) error) {
_{{$config.Name}} = {{$config.GetVariableGen}}
{{if eq $config.IndexCount 0}}
if err = handle("{{$config.Prefix}}{{$config.Name}}.json", _{{$config.Name}}); err != nil {
log.Error("Config", zap.String("Name", "{{$config.Name}}"), zap.Bool("Invalid", true), zap.Error(err))
log.Err("Config", log.String("Name", "{{$config.Name}}"), log.Bool("Invalid", true), log.Err(err))
}
{{else}}
if err = handle("{{$config.Prefix}}{{$config.Name}}.json", &_{{$config.Name}}); err != nil {
log.Error("Config", zap.String("Name", "{{$config.Name}}"), zap.Bool("Invalid", true), zap.Error(err))
log.Err("Config", log.String("Name", "{{$config.Name}}"), log.Bool("Invalid", true), log.Err(err))
}
{{end}}
{{end}}

7
server/cross/nats.go
View File

@ -7,7 +7,6 @@ import (
"github.com/kercylan98/minotaur/utils/log"
"github.com/kercylan98/minotaur/utils/synchronization"
"github.com/nats-io/nats.go"
"go.uber.org/zap"
"time"
)
@ -47,10 +46,10 @@ func (slf *Nats) Init(server *server.Server, packetHandle func(serverId int64, p
nats.ReconnectWait(time.Second*5),
nats.MaxReconnects(-1),
nats.DisconnectErrHandler(func(conn *nats.Conn, err error) {
log.Error(nasMark, zap.String("info", "disconnect"), zap.Error(err))
log.Error(nasMark, log.String("info", "disconnect"), log.Err(err))
}),
nats.ReconnectHandler(func(conn *nats.Conn) {
log.Info(nasMark, zap.String("info", "reconnect"))
log.Info(nasMark, log.String("info", "reconnect"))
}),
)
}
@ -63,7 +62,7 @@ func (slf *Nats) Init(server *server.Server, packetHandle func(serverId int64, p
message := slf.messagePool.Get()
defer slf.messagePool.Release(message)
if err := json.Unmarshal(msg.Data, &message); err != nil {
log.Error(nasMark, zap.Error(err))
log.Error(nasMark, log.Err(err))
return
}
packetHandle(message.ServerId, message.Packet)

31
server/event.go
View File

@ -4,7 +4,6 @@ import (
"fmt"
"github.com/kercylan98/minotaur/utils/log"
"github.com/kercylan98/minotaur/utils/runtimes"
"go.uber.org/zap"
"reflect"
"runtime/debug"
"sync"
@ -42,7 +41,7 @@ type event struct {
// RegStopEvent 服务器停止时将立即执行被注册的事件处理函数
func (slf *event) RegStopEvent(handle StopEventHandle) {
slf.stopEventHandles = append(slf.stopEventHandles, handle)
log.Info("Server", zap.String("RegEvent", runtimes.CurrentRunningFuncName()), zap.String("handle", reflect.TypeOf(handle).String()))
log.Info("Server", log.String("RegEvent", runtimes.CurrentRunningFuncName()), log.String("handle", reflect.TypeOf(handle).String()))
}
func (slf *event) OnStopEvent() {
@ -68,7 +67,7 @@ func (slf *event) RegConsoleCommandEvent(command string, handle ConsoleCommandEv
}()
})
slf.consoleCommandEventHandles[command] = append(slf.consoleCommandEventHandles[command], handle)
log.Info("Server", zap.String("RegEvent", runtimes.CurrentRunningFuncName()), zap.String("handle", reflect.TypeOf(handle).String()))
log.Info("Server", log.String("RegEvent", runtimes.CurrentRunningFuncName()), log.String("handle", reflect.TypeOf(handle).String()))
}
func (slf *event) OnConsoleCommandEvent(command string) {
@ -77,11 +76,11 @@ func (slf *event) OnConsoleCommandEvent(command string) {
if !exist {
switch command {
case "exit", "quit", "close", "shutdown", "EXIT", "QUIT", "CLOSE", "SHUTDOWN":
log.Info("Console", zap.String("Receive", command), zap.String("Action", "Shutdown"))
log.Info("Console", log.String("Receive", command), log.String("Action", "Shutdown"))
slf.Server.shutdown(nil)
return
}
log.Warn("Server", zap.String("Command", "unregistered"))
log.Warn("Server", log.String("Command", "unregistered"))
} else {
for _, handle := range handles {
handle(slf.Server)
@ -93,13 +92,13 @@ func (slf *event) OnConsoleCommandEvent(command string) {
// RegStartBeforeEvent 在服务器初始化完成启动前立刻执行被注册的事件处理函数
func (slf *event) RegStartBeforeEvent(handle StartBeforeEventHandle) {
slf.startBeforeEventHandles = append(slf.startBeforeEventHandles, handle)
log.Info("Server", zap.String("RegEvent", runtimes.CurrentRunningFuncName()), zap.String("handle", reflect.TypeOf(handle).String()))
log.Info("Server", log.String("RegEvent", runtimes.CurrentRunningFuncName()), log.String("handle", reflect.TypeOf(handle).String()))
}
func (slf *event) OnStartBeforeEvent() {
defer func() {
if err := recover(); err != nil {
log.Error("Server", zap.String("OnStartBeforeEvent", fmt.Sprintf("%v", err)))
log.Error("Server", log.String("OnStartBeforeEvent", fmt.Sprintf("%v", err)))
debug.PrintStack()
}
}()
@ -111,7 +110,7 @@ func (slf *event) OnStartBeforeEvent() {
// RegStartFinishEvent 在服务器启动完成时将立刻执行被注册的事件处理函数
func (slf *event) RegStartFinishEvent(handle StartFinishEventHandle) {
slf.startFinishEventHandles = append(slf.startFinishEventHandles, handle)
log.Info("Server", zap.String("RegEvent", runtimes.CurrentRunningFuncName()), zap.String("handle", reflect.TypeOf(handle).String()))
log.Info("Server", log.String("RegEvent", runtimes.CurrentRunningFuncName()), log.String("handle", reflect.TypeOf(handle).String()))
}
func (slf *event) OnStartFinishEvent() {
@ -128,7 +127,7 @@ func (slf *event) RegConnectionClosedEvent(handle ConnectionClosedEventHandle) {
panic(ErrNetworkIncompatibleHttp)
}
slf.connectionClosedEventHandles = append(slf.connectionClosedEventHandles, handle)
log.Info("Server", zap.String("RegEvent", runtimes.CurrentRunningFuncName()), zap.String("handle", reflect.TypeOf(handle).String()))
log.Info("Server", log.String("RegEvent", runtimes.CurrentRunningFuncName()), log.String("handle", reflect.TypeOf(handle).String()))
}
func (slf *event) OnConnectionClosedEvent(conn *Conn, err any) {
@ -147,7 +146,7 @@ func (slf *event) RegConnectionOpenedEvent(handle ConnectionOpenedEventHandle) {
panic(ErrNetworkIncompatibleHttp)
}
slf.connectionOpenedEventHandles = append(slf.connectionOpenedEventHandles, handle)
log.Info("Server", zap.String("RegEvent", runtimes.CurrentRunningFuncName()), zap.String("handle", reflect.TypeOf(handle).String()))
log.Info("Server", log.String("RegEvent", runtimes.CurrentRunningFuncName()), log.String("handle", reflect.TypeOf(handle).String()))
}
func (slf *event) OnConnectionOpenedEvent(conn *Conn) {
@ -165,7 +164,7 @@ func (slf *event) RegConnectionReceivePacketEvent(handle ConnectionReceivePacket
panic(ErrNetworkIncompatibleHttp)
}
slf.connectionReceivePacketEventHandles = append(slf.connectionReceivePacketEventHandles, handle)
log.Info("Server", zap.String("RegEvent", runtimes.CurrentRunningFuncName()), zap.String("handle", reflect.TypeOf(handle).String()))
log.Info("Server", log.String("RegEvent", runtimes.CurrentRunningFuncName()), log.String("handle", reflect.TypeOf(handle).String()))
}
func (slf *event) OnConnectionReceivePacketEvent(conn *Conn, packet Packet) {
@ -177,7 +176,7 @@ func (slf *event) OnConnectionReceivePacketEvent(conn *Conn, packet Packet) {
// RegReceiveCrossPacketEvent 在接收到跨服数据包时将立即执行被注册的事件处理函数
func (slf *event) RegReceiveCrossPacketEvent(handle ReceiveCrossPacketEventHandle) {
slf.receiveCrossPacketEventHandles = append(slf.receiveCrossPacketEventHandles, handle)
log.Info("Server", zap.String("RegEvent", runtimes.CurrentRunningFuncName()), zap.String("handle", reflect.TypeOf(handle).String()))
log.Info("Server", log.String("RegEvent", runtimes.CurrentRunningFuncName()), log.String("handle", reflect.TypeOf(handle).String()))
}
func (slf *event) OnReceiveCrossPacketEvent(serverId int64, packet []byte) {
@ -189,7 +188,7 @@ func (slf *event) OnReceiveCrossPacketEvent(serverId int64, packet []byte) {
// RegMessageErrorEvent 在处理消息发生错误时将立即执行被注册的事件处理函数
func (slf *event) RegMessageErrorEvent(handle MessageErrorEventHandle) {
slf.messageErrorEventHandles = append(slf.messageErrorEventHandles, handle)
log.Info("Server", zap.String("RegEvent", runtimes.CurrentRunningFuncName()), zap.String("handle", reflect.TypeOf(handle).String()))
log.Info("Server", log.String("RegEvent", runtimes.CurrentRunningFuncName()), log.String("handle", reflect.TypeOf(handle).String()))
}
func (slf *event) OnMessageErrorEvent(message *Message, err error) {
@ -203,7 +202,7 @@ func (slf *event) OnMessageErrorEvent(message *Message, err error) {
// RegMessageLowExecEvent 在处理消息缓慢时将立即执行被注册的事件处理函数
func (slf *event) RegMessageLowExecEvent(handle MessageLowExecEventHandle) {
slf.messageLowExecEventHandles = append(slf.messageLowExecEventHandles, handle)
log.Info("Server", zap.String("RegEvent", runtimes.CurrentRunningFuncName()), zap.String("handle", reflect.TypeOf(handle).String()))
log.Info("Server", log.String("RegEvent", runtimes.CurrentRunningFuncName()), log.String("handle", reflect.TypeOf(handle).String()))
}
func (slf *event) OnMessageLowExecEvent(message *Message, cost time.Duration) {
@ -219,12 +218,12 @@ func (slf *event) check() {
case NetworkHttp, NetworkGRPC:
default:
if len(slf.connectionReceivePacketEventHandles) == 0 {
log.Warn("Server", zap.String("ConnectionReceivePacketEvent", "invalid server, no packets processed"))
log.Warn("Server", log.String("ConnectionReceivePacketEvent", "invalid server, no packets processed"))
}
}
if len(slf.receiveCrossPacketEventHandles) > 0 && slf.cross == nil {
log.Warn("Server", zap.String("ReceiveCrossPacketEvent", "invalid server, not register cross server"))
log.Warn("Server", log.String("ReceiveCrossPacketEvent", "invalid server, not register cross server"))
}
}

3
server/gnet.go
View File

@ -6,7 +6,6 @@ import (
"fmt"
"github.com/kercylan98/minotaur/utils/log"
"github.com/panjf2000/gnet"
"go.uber.org/zap"
"time"
)
@ -23,7 +22,7 @@ func (slf *gNet) OnShutdown(server gnet.Server) {
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
defer cancel()
if err := gnet.Stop(ctx, fmt.Sprintf("%s://%s", slf.network, slf.addr)); err != nil {
log.Error("Server", zap.String("Minotaur GNet Server", "Shutdown"), zap.Error(err))
log.Error("Server", log.String("Minotaur GNet Server", "Shutdown"), log.Err(err))
}
}

11
server/multiple.go
View File

@ -2,7 +2,6 @@ package server
import (
"github.com/kercylan98/minotaur/utils/log"
"go.uber.org/zap"
"os"
"os/signal"
"sync"
@ -60,14 +59,14 @@ func (slf *MultipleServer) Run() {
}
wait.Wait()
log.Info("Server", zap.String(serverMultipleMark, "===================================================================="))
log.Info("Server", log.String(serverMultipleMark, "===================================================================="))
for _, server := range slf.servers {
log.Info("Server", zap.String(serverMultipleMark, "RunningInfo"),
zap.Any("network", server.network),
zap.String("listen", server.addr),
log.Info("Server", log.String(serverMultipleMark, "RunningInfo"),
log.Any("network", server.network),
log.String("listen", server.addr),
)
}
log.Info("Server", zap.String(serverMultipleMark, "===================================================================="))
log.Info("Server", log.String(serverMultipleMark, "===================================================================="))
systemSignal := make(chan os.Signal, 1)
signal.Notify(systemSignal, syscall.SIGHUP, syscall.SIGQUIT, syscall.SIGTERM, syscall.SIGINT)

7
server/options.go
View File

@ -4,7 +4,6 @@ import (
"github.com/gin-contrib/pprof"
"github.com/kercylan98/minotaur/utils/log"
"github.com/kercylan98/minotaur/utils/timer"
"go.uber.org/zap"
"google.golang.org/grpc"
"reflect"
"time"
@ -87,7 +86,7 @@ func WithDeadlockDetect(t time.Duration) Option {
return func(srv *Server) {
if t > 0 {
srv.deadlockDetect = t
log.Info("DeadlockDetect", zap.String("Time", t.String()))
log.Info("DeadlockDetect", log.String("Time", t.String()))
}
}
}
@ -153,11 +152,11 @@ func WithCross(crossName string, serverId int64, cross Cross) Option {
srv.pushMessage(msg)
})
if err != nil {
log.Info("Cross", zap.Int64("ServerID", serverId), zap.String("Cross", reflect.TypeOf(cross).String()), zap.String("State", "WaitNatsRun"))
log.Info("Cross", log.Int64("ServerID", serverId), log.String("Cross", reflect.TypeOf(cross).String()), log.String("State", "WaitNatsRun"))
time.Sleep(1 * time.Second)
goto start
}
log.Info("Cross", zap.Int64("ServerID", serverId), zap.String("Cross", reflect.TypeOf(cross).String()))
log.Info("Cross", log.Int64("ServerID", serverId), log.String("Cross", reflect.TypeOf(cross).String()))
}
}
}

41
server/server.go
View File

@ -14,7 +14,6 @@ import (
"github.com/panjf2000/gnet"
"github.com/panjf2000/gnet/pkg/logging"
"github.com/xtaci/kcp-go/v5"
"go.uber.org/zap"
"google.golang.org/grpc"
"net"
"net/http"
@ -318,12 +317,12 @@ func (slf *Server) Run(addr string) error {
close(messageInitFinish)
messageInitFinish = nil
if slf.multiple == nil {
log.Info("Server", zap.String(serverMark, "===================================================================="))
log.Info("Server", zap.String(serverMark, "RunningInfo"),
zap.Any("network", slf.network),
zap.String("listen", slf.addr),
log.Info("Server", log.String(serverMark, "===================================================================="))
log.Info("Server", log.String(serverMark, "RunningInfo"),
log.Any("network", slf.network),
log.String("listen", slf.addr),
)
log.Info("Server", zap.String(serverMark, "===================================================================="))
log.Info("Server", log.String(serverMark, "===================================================================="))
slf.OnStartFinishEvent()
signal.Notify(slf.systemSignal, syscall.SIGHUP, syscall.SIGQUIT, syscall.SIGTERM, syscall.SIGINT)
@ -422,15 +421,15 @@ func (slf *Server) shutdown(err error) {
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
defer cancel()
if shutdownErr := slf.httpServer.Shutdown(ctx); shutdownErr != nil {
log.Error("Server", zap.Error(shutdownErr))
log.Error("Server", log.Err(shutdownErr))
}
}
if err != nil {
if slf.multiple != nil {
slf.multiple.RegExitEvent(func() {
log.Panic("Server", zap.Any("network", slf.network), zap.String("listen", slf.addr),
zap.String("action", "shutdown"), zap.String("state", "exception"), zap.Error(err))
log.Panic("Server", log.Any("network", slf.network), log.String("listen", slf.addr),
log.String("action", "shutdown"), log.String("state", "exception"), log.Err(err))
})
for i, server := range slf.multiple.servers {
if server.addr == slf.addr {
@ -439,12 +438,12 @@ func (slf *Server) shutdown(err error) {
}
}
} else {
log.Panic("Server", zap.Any("network", slf.network), zap.String("listen", slf.addr),
zap.String("action", "shutdown"), zap.String("state", "exception"), zap.Error(err))
log.Panic("Server", log.Any("network", slf.network), log.String("listen", slf.addr),
log.String("action", "shutdown"), log.String("state", "exception"), log.Err(err))
}
} else {
log.Info("Server", zap.Any("network", slf.network), zap.String("listen", slf.addr),
zap.String("action", "shutdown"), zap.String("state", "normal"))
log.Info("Server", log.Any("network", slf.network), log.String("listen", slf.addr),
log.String("action", "shutdown"), log.String("state", "normal"))
}
if slf.gServer == nil {
slf.closeChannel <- struct{}{}
@ -479,7 +478,7 @@ func (slf *Server) pushMessage(message *Message) {
func (slf *Server) low(message *Message, present time.Time, expect time.Duration) {
cost := time.Since(present)
if cost > expect {
log.Warn("Server", zap.String("type", "low-message"), zap.String("cost", cost.String()), zap.String("message", message.String()), zap.Stack("stack"))
log.Warn("Server", log.String("type", "low-message"), log.String("cost", cost.String()), log.String("message", message.String()), log.Stack("stack"))
slf.OnMessageLowExecEvent(message, cost)
}
}
@ -496,7 +495,7 @@ func (slf *Server) dispatchMessage(msg *Message) {
select {
case <-ctx.Done():
if err := ctx.Err(); err == context.DeadlineExceeded {
log.Warn("Server", zap.String("MessageType", messageNames[msg.t]), zap.Any("SuspectedDeadlock", msg.attrs))
log.Warn("Server", log.String("MessageType", messageNames[msg.t]), log.Any("SuspectedDeadlock", msg.attrs))
}
}
}()
@ -506,7 +505,7 @@ func (slf *Server) dispatchMessage(msg *Message) {
defer func() {
if err := recover(); err != nil {
stack := string(debug.Stack())
log.Error("Server", zap.String("MessageType", messageNames[msg.t]), zap.Any("MessageAttrs", msg.attrs), zap.Any("error", err), zap.String("stack", stack))
log.Error("Server", log.String("MessageType", messageNames[msg.t]), log.Any("MessageAttrs", msg.attrs), log.Any("error", err), log.String("stack", stack))
fmt.Println(stack)
if e, ok := err.(error); ok {
slf.OnMessageErrorEvent(msg, e)
@ -535,11 +534,11 @@ func (slf *Server) dispatchMessage(msg *Message) {
err, action := attrs[0].(error), attrs[1].(MessageErrorAction)
switch action {
case MessageErrorActionNone:
log.Panic("Server", zap.Error(err))
log.Panic("Server", log.Err(err))
case MessageErrorActionShutdown:
slf.shutdown(err)
default:
log.Warn("Server", zap.String("not support message error action", action.String()))
log.Warn("Server", log.String("not support message error action", action.String()))
}
case MessageTypeCross:
slf.OnReceiveCrossPacketEvent(attrs[0].(int64), attrs[1].([]byte))
@ -552,7 +551,7 @@ func (slf *Server) dispatchMessage(msg *Message) {
defer func() {
if err := recover(); err != nil {
stack := string(debug.Stack())
log.Error("Server", zap.String("MessageType", messageNames[msg.t]), zap.Any("error", err), zap.String("stack", stack))
log.Error("Server", log.String("MessageType", messageNames[msg.t]), log.Any("error", err), log.String("stack", stack))
fmt.Println(stack)
if e, ok := err.(error); ok {
slf.OnMessageErrorEvent(msg, e)
@ -569,7 +568,7 @@ func (slf *Server) dispatchMessage(msg *Message) {
if cb {
callback(err)
} else {
log.Error("Server", zap.String("MessageType", messageNames[msg.t]), zap.Any("error", err), zap.String("stack", string(debug.Stack())))
log.Error("Server", log.String("MessageType", messageNames[msg.t]), log.Any("error", err), log.String("stack", string(debug.Stack())))
}
}); err != nil {
panic(err)
@ -577,6 +576,6 @@ func (slf *Server) dispatchMessage(msg *Message) {
case MessageTypeSystem:
attrs[0].(func())()
default:
log.Warn("Server", zap.String("not support message type", msg.t.String()))
log.Warn("Server", log.String("not support message type", msg.t.String()))
}
}

3
utils/log/field.go
View File

@ -156,4 +156,7 @@ var (
// Any 接受一个键和一个任意值，并选择将它们表示为字段的最佳方式，仅在必要时才回退到基于反射的方法。
// 由于 byteuint8 和 runeint32 是别名，Any 无法区分它们。为了尽量减少意外情况，[]byte 值被视为二进制 blob，字节值被视为 uint8，而 runes 始终被视为整数
Any = zap.Any
// Err 是常见习语 NamedError("error", err) 的简写
Err = zap.Error
)

3
utils/synchronization/pool.go
View File

@ -2,7 +2,6 @@ package synchronization
import (
"github.com/kercylan98/minotaur/utils/log"
"go.uber.org/zap"
"sync"
)
@ -42,7 +41,7 @@ func (slf *Pool[T]) Get() T {
slf.mutex.Unlock()
slf.warn++
if slf.warn >= 100 {
log.Warn("Pool", zap.String("Get", "the number of buffer members is insufficient, consider whether it is due to unreleased or inappropriate buffer size"))
log.Warn("Pool", log.String("Get", "the number of buffer members is insufficient, consider whether it is due to unreleased or inappropriate buffer size"))
slf.warn = 0
}
return slf.generator()