refactor(logging): 迁移日志记录到 Zerolog 并优化错误处理

- 将日志记录库从 Logrus 替换为 Zerolog，提升性能和灵活性
- 更新各个模块的日志记录方式，确保一致性
- 优化错误处理逻辑，确保在发生错误时能够正确记录并传递错误信息
- 移除不再使用的错误处理字段，简化代码结构
- 更新相关文档以反映新的日志记录和错误处理机制

cache/cache.go

@@ -1,15 +1,14 @@
 package cache
 
 import (
-	"errors"
-
 	. "code.hoteas.com/golang/hotime/common"
+	"code.hoteas.com/golang/hotime/log"
 )
 
 // HoTimeCache 可配置memory，db，redis，默认启用memory，默认优先级为memory>redis>db,memory与数据库缓存设置项一致，
 // 缓存数据填充会自动反方向反哺，加入memory缓存过期将自动从redis更新，但memory永远不会更新redis，如果是集群建议不要开启memory，配置即启用
 type HoTimeCache struct {
-	*Error
+	Log         *log.Logger
 	dbCache     *CacheDb
 	redisCache  *CacheRedis
 	memoryCache *CacheMemory
@@ -383,16 +382,13 @@ func (that *HoTimeCache) CachesDelete(keys []string) {
 	}
 }
 
-func (that *HoTimeCache) Init(config Map, hotimeDb HoTimeDBInterface, err ...*Error) {
-	//防止空数据问题
+func (that *HoTimeCache) Init(config Map, hotimeDb HoTimeDBInterface, logger *log.Logger) {
 	if config == nil {
 		config = Map{}
 	}
-	if err[0] != nil {
-		that.Error = err[0]
-	}
+	that.Log = logger
 	that.Config = config
-	//memory配置初始化
+
 	memory := that.Config.GetMap("memory")
 	if memory == nil {
 		memory = Map{
@@ -401,71 +397,56 @@ func (that *HoTimeCache) Init(config Map, hotimeDb HoTimeDBInterface, err ...*Er
 			"sort":    0,
 			"timeout": 60 * 60 * 2,
 		}
-
 	}
 	if memory.Get("db") == nil {
 		memory["db"] = true
 	}
-
 	if memory.Get("session") == nil {
 		memory["session"] = true
 	}
-
 	if memory.Get("timeout") == nil {
 		memory["timeout"] = 60 * 60 * 2
 	}
 	that.Config["memory"] = memory
 	that.memoryCache = &CacheMemory{TimeOut: memory.GetCeilInt64("timeout"),
-		DbSet: memory.GetBool("db"), SessionSet: memory.GetBool("session")}
-	if err[0] != nil {
-		that.memoryCache.SetError(err[0])
-	}
+		DbSet: memory.GetBool("db"), SessionSet: memory.GetBool("session"),
+		Log: logger}
 
-	//db配置初始化
 	redis := that.Config.GetMap("redis")
 	if redis != nil {
 		if redis.GetString("host") == "" || redis.GetString("port") == "" {
-			if err[0] != nil {
-				err[0].SetError(errors.New("请检查redis配置host和port配置"))
+			if logger != nil {
+				logger.Error().Msg("请检查redis配置host和port配置")
 			}
 			return
 		}
 		if redis.Get("db") == nil {
 			redis["db"] = true
 		}
-
 		if redis.Get("session") == nil {
 			redis["session"] = true
 		}
-
 		if redis.Get("timeout") == nil {
 			redis["timeout"] = 60 * 60 * 24 * 15
 		}
 		that.Config["redis"] = redis
 		that.redisCache = &CacheRedis{TimeOut: redis.GetCeilInt64("timeout"),
 			DbSet: redis.GetBool("db"), SessionSet: redis.GetBool("session"), Host: redis.GetString("host"),
-			Pwd: redis.GetString("password"), Port: redis.GetCeilInt64("port")}
-
-		if err[0] != nil {
-			that.redisCache.SetError(err[0])
-		}
+			Pwd: redis.GetString("password"), Port: redis.GetCeilInt64("port"),
+			Log: logger}
 	}
 
-	//db配置初始化
 	db := that.Config.GetMap("db")
 	if db != nil {
-
 		if db.Get("db") == nil {
 			db["db"] = false
 		}
-
 		if db.Get("session") == nil {
 			db["session"] = true
 		}
 		if db.Get("timeout") == nil {
 			db["timeout"] = 60 * 60 * 24 * 30
 		}
-		// mode 默认为 "compatible"（兼容模式，便于老系统平滑升级）
 		if db.Get("mode") == nil {
 			db["mode"] = CacheModeCompatible
 		}
@@ -478,13 +459,9 @@ func (that *HoTimeCache) Init(config Map, hotimeDb HoTimeDBInterface, err ...*Er
 			HistorySet: db.GetBool("history"),
 			Mode:       db.GetString("mode"),
 			Db:         hotimeDb,
-		}
-
-		if err[0] != nil {
-			that.dbCache.SetError(err[0])
+			Log:        logger,
 		}
 	}
-
 }
 
 func (that *HoTimeCache) DisableDbCache() {

cache/cache_db.go

@@ -7,6 +7,7 @@ import (
 	"time"
 
 	. "code.hoteas.com/golang/hotime/common"
+	"code.hoteas.com/golang/hotime/log"
 )
 
 // 表名常量
@@ -22,7 +23,7 @@ const (
 type HoTimeDBInterface interface {
 	GetPrefix() string
 	Query(query string, args ...interface{}) []Map
-	Exec(query string, args ...interface{}) (sql.Result, *Error)
+	Exec(query string, args ...interface{}) (sql.Result, error)
 	Get(table string, qu ...interface{}) Map
 	Select(table string, qu ...interface{}) []Map
 	Delete(table string, data map[string]interface{}) int64
@@ -38,19 +39,11 @@ type CacheDb struct {
 	HistorySet bool   // 是否开启历史记录
 	Mode       string // 缓存模式："new"(默认，只用新表) 或 "compatible"(写新读老)
 	Db         HoTimeDBInterface
-	*Error
+	Log        *log.Logger
 	ContextBase
 	isInit bool
 }
 
-func (that *CacheDb) GetError() *Error {
-	return that.Error
-}
-
-func (that *CacheDb) SetError(err *Error) {
-	that.Error = err
-}
-
 // getTableName 获取带前缀的表名
 func (that *CacheDb) getTableName() string {
 	return that.Db.GetPrefix() + CacheTableName

cache/cache_memory.go

@@ -2,6 +2,7 @@ package cache
 
 import (
 	. "code.hoteas.com/golang/hotime/common"
+	"code.hoteas.com/golang/hotime/log"
 	"strings"
 	"sync"
 	"time"
@@ -12,24 +13,12 @@ type CacheMemory struct {
 	TimeOut    int64
 	DbSet      bool
 	SessionSet bool
-	*Error
-	cache sync.Map // 替代传统的 Map
-}
-
-func (that *CacheMemory) GetError() *Error {
-
-	return that.Error
-
-}
-
-func (that *CacheMemory) SetError(err *Error) {
-	that.Error = err
+	Log        *log.Logger
+	cache      sync.Map
 }
 func (c *CacheMemory) get(key string) (res *Obj) {
 
-	res = &Obj{
-		Error: *c.Error,
-	}
+	res = &Obj{}
 	value, ok := c.cache.Load(key)
 	if !ok {
 		return res // 缓存不存在

cache/cache_redis.go

@@ -2,6 +2,7 @@ package cache
 
 import (
 	. "code.hoteas.com/golang/hotime/common"
+	"code.hoteas.com/golang/hotime/log"
 	"github.com/garyburd/redigo/redis"
 	"strings"
 	"sync"
@@ -18,18 +19,14 @@ type CacheRedis struct {
 	pool       *redis.Pool
 	tag        int64
 	ContextBase
-	*Error
+	Log      *log.Logger
 	initOnce sync.Once
 }
 
-func (that *CacheRedis) GetError() *Error {
-
-	return that.Error
-
-}
-
-func (that *CacheRedis) SetError(err *Error) {
-	that.Error = err
+func (that *CacheRedis) logErr(err error) {
+	if err != nil && that.Log != nil {
+		that.Log.Error().Err(err).Msg("redis cache error")
+	}
 }
 
 // 唯一标志
@@ -97,7 +94,7 @@ func (that *CacheRedis) del(key string) {
 	if del != -1 {
 		val, err := redis.Strings(conn.Do("KEYS", key))
 		if err != nil {
-			that.Error.SetError(err)
+			that.logErr(err)
 			return
 		}
 		if len(val) == 0 {
@@ -109,12 +106,12 @@ func (that *CacheRedis) del(key string) {
 		}
 		_, err = conn.Do("EXEC")
 		if err != nil {
-			that.Error.SetError(err)
+			that.logErr(err)
 		}
 	} else {
 		_, err := conn.Do("DEL", key)
 		if err != nil {
-			that.Error.SetError(err)
+			that.logErr(err)
 		}
 	}
 }
@@ -129,7 +126,7 @@ func (that *CacheRedis) set(key string, value string, expireSeconds int64) {
 
 	_, err := conn.Do("SET", key, value, "EX", ObjToStr(expireSeconds))
 	if err != nil {
-		that.Error.SetError(err)
+		that.logErr(err)
 	}
 }
 
@@ -146,7 +143,7 @@ func (that *CacheRedis) get(key string) *Obj {
 	if err != nil {
 		reData.Data = nil
 		if !strings.Contains(err.Error(), "nil returned") {
-			that.Error.SetError(err)
+			that.logErr(err)
 		}
 	}
 	return reData
@@ -175,11 +172,10 @@ func (that *CacheRedis) Cache(key string, data ...interface{}) *Obj {
 		tim += that.TimeOut
 	}
 	if len(data) == 2 {
-		that.Error.SetError(nil)
-		tempt := ObjToInt64(data[1], that.Error)
+		tempt := ObjToInt64(data[1])
 		if tempt > tim {
 			tim = tempt
-		} else if that.GetError() == nil {
+		} else {
 			tim = tim + tempt
 		}
 	}
@@ -212,7 +208,7 @@ func (that *CacheRedis) CachesGet(keys []string) Map {
 	values, err := redis.Strings(conn.Do("MGET", args...))
 	if err != nil {
 		if !strings.Contains(err.Error(), "nil returned") {
-			that.Error.SetError(err)
+			that.logErr(err)
 		}
 		return result
 	}
@@ -257,7 +253,7 @@ func (that *CacheRedis) CachesSet(data Map, timeout ...int64) {
 	}
 	_, err := conn.Do("EXEC")
 	if err != nil {
-		that.Error.SetError(err)
+		that.logErr(err)
 	}
 }
 
@@ -281,6 +277,6 @@ func (that *CacheRedis) CachesDelete(keys []string) {
 
 	_, err := conn.Do("DEL", args...)
 	if err != nil {
-		that.Error.SetError(err)
+		that.logErr(err)
 	}
 }

cache/type.go

@@ -5,16 +5,10 @@ import (
 )
 
 type CacheIns interface {
-	//set(key string, value interface{}, time int64)
-	//get(key string) interface{}
-	//delete(key string)
-	GetError() *Error
-	SetError(err *Error)
 	Cache(key string, data ...interface{}) *Obj
-	// 批量操作
-	CachesGet(keys []string) Map               // 批量获取
-	CachesSet(data Map, timeout ...int64)      // 批量设置
-	CachesDelete(keys []string)                // 批量删除
+	CachesGet(keys []string) Map
+	CachesSet(data Map, timeout ...int64)
+	CachesDelete(keys []string)
 }
 
 // 单条缓存数据