diff --git a/config/config.go b/config/config.go
index a212b34..efadfd8 100644
--- a/config/config.go
+++ b/config/config.go
@@ -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
 	})
diff --git a/game/builtin/room.go b/game/builtin/room.go
index 546db04..457d5b0 100644
--- a/game/builtin/room.go
+++ b/game/builtin/room.go
@@ -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)
 }
diff --git a/game/builtin/world.go b/game/builtin/world.go
index 34d69c9..463b76d 100644
--- a/game/builtin/world.go
+++ b/game/builtin/world.go
@@ -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
diff --git a/notify/manager.go b/notify/manager.go
index a235d98..4c4829e 100644
--- a/notify/manager.go
+++ b/notify/manager.go
@@ -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
 }
 
diff --git a/planner/configexport/configexport.go b/planner/configexport/configexport.go
index abffe9c..8db87d5 100644
--- a/planner/configexport/configexport.go
+++ b/planner/configexport/configexport.go
@@ -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
 			}
diff --git a/planner/configexport/example/config.go b/planner/configexport/example/config.go
index 7fedfdc..5d33937 100644
--- a/planner/configexport/example/config.go
+++ b/planner/configexport/example/config.go
@@ -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))
 	}
 
 }
diff --git a/planner/configexport/internal/template.go b/planner/configexport/internal/template.go
index a332fff..f4a98e9 100644
--- a/planner/configexport/internal/template.go
+++ b/planner/configexport/internal/template.go
@@ -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}}
diff --git a/server/cross/nats.go b/server/cross/nats.go
index 43b2f78..8b13d21 100644
--- a/server/cross/nats.go
+++ b/server/cross/nats.go
@@ -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)
diff --git a/server/event.go b/server/event.go
index 537d472..c906c2d 100644
--- a/server/event.go
+++ b/server/event.go
@@ -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"))
 	}
 
 }
diff --git a/server/gnet.go b/server/gnet.go
index 73f9d57..06877eb 100644
--- a/server/gnet.go
+++ b/server/gnet.go
@@ -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))
 	}
 }
 
diff --git a/server/multiple.go b/server/multiple.go
index e3ddad2..06a96f9 100644
--- a/server/multiple.go
+++ b/server/multiple.go
@@ -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)
diff --git a/server/options.go b/server/options.go
index 610d35b..3039366 100644
--- a/server/options.go
+++ b/server/options.go
@@ -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()))
 		}
 	}
 }
diff --git a/server/server.go b/server/server.go
index 344f66e..e89b0c2 100644
--- a/server/server.go
+++ b/server/server.go
@@ -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()))
 	}
 }
diff --git a/utils/log/field.go b/utils/log/field.go
index 5919e66..80ef71e 100644
--- a/utils/log/field.go
+++ b/utils/log/field.go
@@ -156,4 +156,7 @@ var (
 	// Any 接受一个键和一个任意值，并选择将它们表示为字段的最佳方式，仅在必要时才回退到基于反射的方法。
 	// 由于 byteuint8 和 runeint32 是别名，Any 无法区分它们。为了尽量减少意外情况，[]byte 值被视为二进制 blob，字节值被视为 uint8，而 runes 始终被视为整数
 	Any = zap.Any
+
+	// Err 是常见习语 NamedError("error", err) 的简写
+	Err = zap.Error
 )
diff --git a/utils/synchronization/pool.go b/utils/synchronization/pool.go
index e8a9da4..9b2ed24 100644
--- a/utils/synchronization/pool.go
+++ b/utils/synchronization/pool.go
@@ -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()