update

config/consul.go

@@ -50,7 +50,7 @@ func (x *ConsulConfFetcher) sync() *ConsulConfFetcher {
 		return x
 	}
 	if kv == nil || len(kv.Value) == 0 {
-		x.err = xerror.New("[consul]请先配置consul")
+		x.err = xerror.NewRuntimeError("[consul]请先配置consul")
 		return x
 	}
 	if hashutils.Md5(kv.Value) != hashutils.Md5(x.cfg.GetContent()) {

config/local.go

@@ -7,12 +7,13 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
-	"gitlab.wanzhuangkj.com/tush/xpkg/pkg/eventbus"
 	"os"
 	"path"
 	"path/filepath"
 	"strings"
 
+	"gitlab.wanzhuangkj.com/tush/xpkg/pkg/eventbus"
+
 	"gitlab.wanzhuangkj.com/tush/xpkg/pkg/xerrors/xerror"
 
 	"github.com/fsnotify/fsnotify"
@@ -41,13 +42,13 @@ func (x *localParser) parseLocal(configFile string, obj ICfg, reloads ...func())
 	viper.SetConfigName(filename)    // file name
 	viper.SetConfigType(ext)         // get the configuration type from the file name
 	if err = viper.ReadInConfig(); err != nil {
-		return xerror.New(err.Error())
+		return xerror.NewRuntimeError(err.Error())
 	}
 
 	obj.Lock()
 	if err = viper.Unmarshal(obj); err != nil {
 		obj.Unlock()
-		return xerror.New(err.Error())
+		return xerror.NewRuntimeError(err.Error())
 	}
 	obj.Unlock()
 

database/database.go

@@ -35,7 +35,7 @@ func InitDB() (err error) {
 			}
 			gdbs[db.Name] = gdb
 		default:
-			return xerror.New("InitDB error, please modify the correct 'database' configuration at yaml file. " +
+			return xerror.NewRuntimeError("InitDB error, please modify the correct 'database' configuration at yaml file. " +
 				"Refer to https://xmall/blob/main/configs/xmall.yml#L85")
 		}
 	}
@@ -60,7 +60,7 @@ func (x XDB) DB() *sgorm.DB {
 func DB(name string) *sgorm.DB {
 	conn, ok := gdbs[name]
 	if !ok {
-		err := xerror.Newf("database[%s] not initialized", name)
+		err := xerror.NewRuntimeErrorf("database[%s] not initialized", name)
 		panic(err)
 	}
 	return conn

gin/response/response.go

@@ -269,9 +269,11 @@ func Error(c *gin.Context, err error) {
 	msg := ""
 	if err != nil {
 		switch e := err.(type) {
-		case *xerror.BizError, *xerror.ParamError:
+		case *xerror.BizError, *xerror.ParamError: //无需打印日志，在[middleware][logging]里会打印
 			msg = e.Error()
-		case *xerror.DBError, *xerror.NetError:
+		case *xerror.DBError: // 无需打印日志，在gorm层会打印日志
+			msg = "网络开小差了,请稍后再试~"
+		case *xerror.NetError, *xerror.CacheError, *xerror.RuntimeError: // 需要打印日志
 			logger.Error(fmt.Sprintf("[response]%s", err.Error()), ctxutils.GinTraceIDField(c))
 			msg = "网络开小差了,请稍后再试~"
 		default:

pkg/cache/memory.go

@@ -41,14 +41,14 @@ const logPrefix = "[memory]"
 func (m *memoryCache) Set(ctx context.Context, key string, val any, expiration time.Duration) error {
 	buf, err := encoding.Marshal(m.encoding, val)
 	if err != nil {
-		return xerror.Errorf("encoding.Marshal error: %v, key=%s, val=%+v ", err, key, val)
+		return xerror.NewCacheErrorf("encoding.Marshal error: %v, key=%s, val=%+v ", err, key, val)
 	}
 	if len(buf) == 0 {
 		buf = NotFoundPlaceholderBytes
 	}
 	cacheKey, err := BuildCacheKey(m.KeyPrefix, key)
 	if err != nil {
-		return xerror.Errorf("BuildCacheKey error: %v, key=%s", err, key)
+		return xerror.NewCacheErrorf("BuildCacheKey error: %v, key=%s", err, key)
 	}
 	st := time.Now()
 	ok := m.client.SetWithTTL(cacheKey, buf, 0, expiration)
@@ -60,7 +60,7 @@ func (m *memoryCache) Set(ctx context.Context, key string, val any, expiration t
 		logger.Any("expiration", expiration.String()),
 		ctxUtil.CtxTraceIDField(ctx))
 	if !ok {
-		return xerror.New("SetWithTTL failed")
+		return xerror.NewCacheError("SetWithTTL failed")
 	}
 
 	return nil
@@ -76,7 +76,7 @@ func isSuccess(result bool) string {
 func (m *memoryCache) IncrBy(ctx context.Context, key string, val int64) (int64, error) {
 	cacheKey, err := BuildCacheKey(m.KeyPrefix, key)
 	if err != nil {
-		return 0, xerror.Errorf("BuildCacheKey error: %v, key=%s", err, key)
+		return 0, xerror.NewCacheErrorf("BuildCacheKey error: %v, key=%s", err, key)
 	}
 	v, ok := m.client.Get(cacheKey)
 	if !ok {
@@ -99,7 +99,7 @@ func (m *memoryCache) IncrBy(ctx context.Context, key string, val int64) (int64,
 func (m *memoryCache) Get(ctx context.Context, key string, val any) error {
 	cacheKey, err := BuildCacheKey(m.KeyPrefix, key)
 	if err != nil {
-		return xerror.Errorf("BuildCacheKey error: %v, key=%s", err, key)
+		return xerror.NewCacheErrorf("BuildCacheKey error: %v, key=%s", err, key)
 	}
 
 	st := time.Now()
@@ -115,7 +115,7 @@ func (m *memoryCache) Get(ctx context.Context, key string, val any) error {
 
 	dataBytes, ok := data.([]byte)
 	if !ok {
-		return xerror.Errorf("data type error, key=%s, type=%T", key, data)
+		return xerror.NewCacheErrorf("data type error, key=%s, type=%T", key, data)
 	}
 	if len(dataBytes) == 0 || bytes.Equal(dataBytes, NotFoundPlaceholderBytes) {
 		logger.Info(fmt.Sprintf("%s get", logPrefix),
@@ -129,7 +129,7 @@ func (m *memoryCache) Get(ctx context.Context, key string, val any) error {
 
 	err = encoding.Unmarshal(m.encoding, dataBytes, val)
 	if err != nil {
-		return xerror.Errorf("encoding.Unmarshal error: %v, key=%s, cacheKey=%s, type=%T, data=%s ",
+		return xerror.NewCacheErrorf("encoding.Unmarshal error: %v, key=%s, cacheKey=%s, type=%T, data=%s ",
 			err, key, cacheKey, val, dataBytes)
 	}
 	logger.Info(fmt.Sprintf("%s get", logPrefix),
@@ -150,7 +150,7 @@ func (m *memoryCache) Del(ctx context.Context, keys ...string) error {
 	for _, key := range keys {
 		cacheKey, err := BuildCacheKey(m.KeyPrefix, key)
 		if err != nil {
-			return xerror.Errorf("build cache key error, err=%v, key=%s", err, key)
+			return xerror.NewCacheErrorf("build cache key error, err=%v, key=%s", err, key)
 		}
 		st := time.Now()
 		m.client.Del(cacheKey)
@@ -208,12 +208,12 @@ func (m *memoryCache) MGet(ctx context.Context, keys []string) ([]any, error) {
 func (m *memoryCache) SetCacheWithNotFound(ctx context.Context, key string) error {
 	cacheKey, err := BuildCacheKey(m.KeyPrefix, key)
 	if err != nil {
-		return xerror.Errorf("BuildCacheKey error: %v, key=%s", err, key)
+		return xerror.NewCacheErrorf("BuildCacheKey error: %v, key=%s", err, key)
 	}
 	st := time.Now()
 	ok := m.client.SetWithTTL(cacheKey, []byte(NotFoundPlaceholder), 0, DefaultNotFoundExpireTime)
 	if !ok {
-		return xerror.New("SetWithTTL failed")
+		return xerror.NewCacheError("SetWithTTL failed")
 	}
 	logger.Info(fmt.Sprintf("%s set", logPrefix),
 		logger.Any("result", isSuccess(ok)),

pkg/cache/redis.go

@@ -39,11 +39,11 @@ func NewRedisCache(client *redis.Client, keyPrefix string, encode encoding.Encod
 func (c *redisCache) IncrBy(ctx context.Context, key string, val int64) (int64, error) {
 	cacheKey, err := BuildCacheKey(c.KeyPrefix, key)
 	if err != nil {
-		return 0, xerror.Errorf("BuildCacheKey error: %v, key=%s", err, key)
+		return 0, xerror.NewCacheErrorf("BuildCacheKey error: %v, key=%s", err, key)
 	}
 	cur, err := c.client.IncrBy(ctx, cacheKey, val).Result()
 	if err != nil {
-		return 0, xerror.Errorf("c.client.Set error: %v, cacheKey=%s", err, cacheKey)
+		return 0, xerror.NewCacheErrorf("c.client.Set error: %v, cacheKey=%s", err, cacheKey)
 	}
 	return cur, nil
 }
@@ -52,12 +52,12 @@ func (c *redisCache) IncrBy(ctx context.Context, key string, val int64) (int64,
 func (c *redisCache) Set(ctx context.Context, key string, val any, expiration time.Duration) error {
 	buf, err := encoding.Marshal(c.encoding, val)
 	if err != nil {
-		return xerror.Errorf("encoding.Marshal error: %v, key=%s, val=%+v ", err, key, val)
+		return xerror.NewCacheErrorf("encoding.Marshal error: %v, key=%s, val=%+v ", err, key, val)
 	}
 
 	cacheKey, err := BuildCacheKey(c.KeyPrefix, key)
 	if err != nil {
-		return xerror.Errorf("BuildCacheKey error: %v, key=%s", err, key)
+		return xerror.NewCacheErrorf("BuildCacheKey error: %v, key=%s", err, key)
 	}
 	//if expiration == 0 {
 	//	expiration = DefaultExpireTime
@@ -67,7 +67,7 @@ func (c *redisCache) Set(ctx context.Context, key string, val any, expiration ti
 	}
 	err = c.client.Set(ctx, cacheKey, buf, expiration).Err()
 	if err != nil {
-		return xerror.Errorf("c.client.Set error: %v, cacheKey=%s", err, cacheKey)
+		return xerror.NewCacheErrorf("c.client.Set error: %v, cacheKey=%s", err, cacheKey)
 	}
 	return nil
 }
@@ -76,7 +76,7 @@ func (c *redisCache) Set(ctx context.Context, key string, val any, expiration ti
 func (c *redisCache) Get(ctx context.Context, key string, val any) error {
 	cacheKey, err := BuildCacheKey(c.KeyPrefix, key)
 	if err != nil {
-		return xerror.Errorf("BuildCacheKey error: %v, key=%s", err, key)
+		return xerror.NewCacheErrorf("BuildCacheKey error: %v, key=%s", err, key)
 	}
 
 	dataBytes, err := c.client.Get(ctx, cacheKey).Bytes()
@@ -92,7 +92,7 @@ func (c *redisCache) Get(ctx context.Context, key string, val any) error {
 	}
 	err = encoding.Unmarshal(c.encoding, dataBytes, val)
 	if err != nil {
-		return xerror.Errorf("encoding.Unmarshal error: %v, key=%s, cacheKey=%s, type=%T, json=%s ",
+		return xerror.NewCacheErrorf("encoding.Unmarshal error: %v, key=%s, cacheKey=%s, type=%T, json=%s ",
 			err, key, cacheKey, val, dataBytes)
 	}
 	return nil
@@ -126,7 +126,7 @@ func (c *redisCache) MultiSet(ctx context.Context, valueMap map[string]any, expi
 	pipeline := c.client.Pipeline()
 	err := pipeline.MSet(ctx, paris...).Err()
 	if err != nil {
-		return xerror.Errorf("pipeline.MSet error: %v", err)
+		return xerror.NewCacheErrorf("pipeline.MSet error: %v", err)
 	}
 	for i := 0; i < len(paris); i = i + 2 {
 		switch paris[i].(type) {
@@ -138,7 +138,7 @@ func (c *redisCache) MultiSet(ctx context.Context, valueMap map[string]any, expi
 	}
 	_, err = pipeline.Exec(ctx)
 	if err != nil {
-		return xerror.Errorf("pipeline.Exec error: %v", err)
+		return xerror.NewCacheErrorf("pipeline.Exec error: %v", err)
 	}
 	return nil
 }
@@ -152,13 +152,13 @@ func (c *redisCache) MultiGet(ctx context.Context, keys []string, value any) err
 	for index, key := range keys {
 		cacheKey, err := BuildCacheKey(c.KeyPrefix, key)
 		if err != nil {
-			return xerror.Errorf("BuildCacheKey error: %v, key=%s", err, key)
+			return xerror.NewCacheErrorf("BuildCacheKey error: %v, key=%s", err, key)
 		}
 		cacheKeys[index] = cacheKey
 	}
 	values, err := c.client.MGet(ctx, cacheKeys...).Result()
 	if err != nil {
-		return xerror.Errorf("c.client.MGet error: %v, keys=%+v", err, cacheKeys)
+		return xerror.NewCacheErrorf("c.client.MGet error: %v, keys=%+v", err, cacheKeys)
 	}
 
 	// Injection into map via reflection
@@ -191,7 +191,7 @@ func (c *redisCache) MGet(ctx context.Context, keys []string) ([]any, error) {
 	for index, key := range keys {
 		cacheKey, err := BuildCacheKey(c.KeyPrefix, key)
 		if err != nil {
-			return nil, xerror.Errorf("BuildCacheKey error: %v, key=%s", err, key)
+			return nil, xerror.NewCacheErrorf("BuildCacheKey error: %v, key=%s", err, key)
 		}
 		cacheKeys[index] = cacheKey
 	}
@@ -214,7 +214,7 @@ func (c *redisCache) Del(ctx context.Context, keys ...string) error {
 	}
 	err := c.client.Del(ctx, cacheKeys...).Err()
 	if err != nil {
-		return xerror.Errorf("c.client.Del error: %v, keys=%+v", err, cacheKeys)
+		return xerror.NewCacheErrorf("c.client.Del error: %v, keys=%+v", err, cacheKeys)
 	}
 	return nil
 }
@@ -223,7 +223,7 @@ func (c *redisCache) Del(ctx context.Context, keys ...string) error {
 func (c *redisCache) SetCacheWithNotFound(ctx context.Context, key string) error {
 	cacheKey, err := BuildCacheKey(c.KeyPrefix, key)
 	if err != nil {
-		return xerror.Errorf("BuildCacheKey error: %v, key=%s", err, key)
+		return xerror.NewCacheErrorf("BuildCacheKey error: %v, key=%s", err, key)
 	}
 
 	return c.client.Set(ctx, cacheKey, NotFoundPlaceholder, DefaultNotFoundExpireTime).Err()
@@ -232,7 +232,7 @@ func (c *redisCache) SetCacheWithNotFound(ctx context.Context, key string) error
 // BuildCacheKey construct a cache key with a prefix
 func BuildCacheKey(keyPrefix string, key string) (string, error) {
 	if key == "" {
-		return "", xerror.New("[cache] key should not be empty")
+		return "", xerror.NewCacheError("[cache] key should not be empty")
 	}
 
 	cacheKey := key
@@ -268,12 +268,12 @@ func NewRedisClusterCache(client *redis.ClusterClient, keyPrefix string, encode
 func (c *redisClusterCache) Set(ctx context.Context, key string, val any, expiration time.Duration) error {
 	buf, err := encoding.Marshal(c.encoding, val)
 	if err != nil {
-		return xerror.Errorf("encoding.Marshal error: %v, key=%s, val=%+v ", err, key, val)
+		return xerror.NewCacheErrorf("encoding.Marshal error: %v, key=%s, val=%+v ", err, key, val)
 	}
 
 	cacheKey, err := BuildCacheKey(c.KeyPrefix, key)
 	if err != nil {
-		return xerror.Errorf("BuildCacheKey error: %v, key=%s", err, key)
+		return xerror.NewCacheErrorf("BuildCacheKey error: %v, key=%s", err, key)
 	}
 	//if expiration == 0 {
 	//	expiration = DefaultExpireTime
@@ -283,7 +283,7 @@ func (c *redisClusterCache) Set(ctx context.Context, key string, val any, expira
 	}
 	err = c.client.Set(ctx, cacheKey, buf, expiration).Err()
 	if err != nil {
-		return xerror.Errorf("c.client.Set error: %v, cacheKey=%s", err, cacheKey)
+		return xerror.NewCacheErrorf("c.client.Set error: %v, cacheKey=%s", err, cacheKey)
 	}
 	return nil
 }
@@ -291,11 +291,11 @@ func (c *redisClusterCache) Set(ctx context.Context, key string, val any, expira
 func (c *redisClusterCache) IncrBy(ctx context.Context, key string, val int64) (int64, error) {
 	cacheKey, err := BuildCacheKey(c.KeyPrefix, key)
 	if err != nil {
-		return 0, xerror.Errorf("BuildCacheKey error: %v, key=%s", err, key)
+		return 0, xerror.NewCacheErrorf("BuildCacheKey error: %v, key=%s", err, key)
 	}
 	cur, err := c.client.IncrBy(ctx, cacheKey, val).Result()
 	if err != nil {
-		return 0, xerror.Errorf("c.client.Set error: %v, cacheKey=%s", err, cacheKey)
+		return 0, xerror.NewCacheErrorf("c.client.Set error: %v, cacheKey=%s", err, cacheKey)
 	}
 	return cur, nil
 }
@@ -304,7 +304,7 @@ func (c *redisClusterCache) IncrBy(ctx context.Context, key string, val int64) (
 func (c *redisClusterCache) Get(ctx context.Context, key string, val any) error {
 	cacheKey, err := BuildCacheKey(c.KeyPrefix, key)
 	if err != nil {
-		return xerror.Errorf("BuildCacheKey error: %v, key=%s", err, key)
+		return xerror.NewCacheErrorf("BuildCacheKey error: %v, key=%s", err, key)
 	}
 
 	dataBytes, err := c.client.Get(ctx, cacheKey).Bytes()
@@ -320,7 +320,7 @@ func (c *redisClusterCache) Get(ctx context.Context, key string, val any) error
 	}
 	err = encoding.Unmarshal(c.encoding, dataBytes, val)
 	if err != nil {
-		return xerror.Errorf("encoding.Unmarshal error: %v, key=%s, cacheKey=%s, type=%T, json=%s ",
+		return xerror.NewCacheErrorf("encoding.Unmarshal error: %v, key=%s, cacheKey=%s, type=%T, json=%s ",
 			err, key, cacheKey, val, dataBytes)
 	}
 	return nil
@@ -350,7 +350,7 @@ func (c *redisClusterCache) MultiSet(ctx context.Context, valueMap map[string]an
 	pipeline := c.client.Pipeline()
 	err := pipeline.MSet(ctx, paris...).Err()
 	if err != nil {
-		return xerror.Errorf("pipeline.MSet error: %v", err)
+		return xerror.NewCacheErrorf("pipeline.MSet error: %v", err)
 	}
 	for i := 0; i < len(paris); i = i + 2 {
 		switch paris[i].(type) {
@@ -362,7 +362,7 @@ func (c *redisClusterCache) MultiSet(ctx context.Context, valueMap map[string]an
 	}
 	_, err = pipeline.Exec(ctx)
 	if err != nil {
-		return xerror.Errorf("pipeline.Exec error: %v", err)
+		return xerror.NewCacheErrorf("pipeline.Exec error: %v", err)
 	}
 	return nil
 }
@@ -376,13 +376,13 @@ func (c *redisClusterCache) MultiGet(ctx context.Context, keys []string, value a
 	for index, key := range keys {
 		cacheKey, err := BuildCacheKey(c.KeyPrefix, key)
 		if err != nil {
-			return xerror.Errorf("BuildCacheKey error: %v, key=%s", err, key)
+			return xerror.NewCacheErrorf("BuildCacheKey error: %v, key=%s", err, key)
 		}
 		cacheKeys[index] = cacheKey
 	}
 	values, err := c.client.MGet(ctx, cacheKeys...).Result()
 	if err != nil {
-		return xerror.Errorf("c.client.MGet error: %v, keys=%+v", err, cacheKeys)
+		return xerror.NewCacheErrorf("c.client.MGet error: %v, keys=%+v", err, cacheKeys)
 	}
 
 	// Injection into map via reflection
@@ -414,7 +414,7 @@ func (c *redisClusterCache) MGet(ctx context.Context, keys []string) ([]any, err
 	for index, key := range keys {
 		cacheKey, err := BuildCacheKey(c.KeyPrefix, key)
 		if err != nil {
-			return nil, xerror.Errorf("BuildCacheKey error: %v, key=%s", err, key)
+			return nil, xerror.NewCacheErrorf("BuildCacheKey error: %v, key=%s", err, key)
 		}
 		cacheKeys[index] = cacheKey
 	}
@@ -437,7 +437,7 @@ func (c *redisClusterCache) Del(ctx context.Context, keys ...string) error {
 	}
 	err := c.client.Del(ctx, cacheKeys...).Err()
 	if err != nil {
-		return xerror.Errorf("c.client.Del error: %v, keys=%+v", err, cacheKeys)
+		return xerror.NewCacheErrorf("c.client.Del error: %v, keys=%+v", err, cacheKeys)
 	}
 	return nil
 }
@@ -446,7 +446,7 @@ func (c *redisClusterCache) Del(ctx context.Context, keys ...string) error {
 func (c *redisClusterCache) SetCacheWithNotFound(ctx context.Context, key string) error {
 	cacheKey, err := BuildCacheKey(c.KeyPrefix, key)
 	if err != nil {
-		return xerror.Errorf("BuildCacheKey error: %v, key=%s", err, key)
+		return xerror.NewCacheErrorf("BuildCacheKey error: %v, key=%s", err, key)
 	}
 
 	return c.client.Set(ctx, cacheKey, NotFoundPlaceholder, DefaultNotFoundExpireTime).Err()

pkg/captcha/captcha.go

@@ -2,6 +2,7 @@ package captcha
 
 import (
 	"context"
+	"fmt"
 	"strings"
 	"time"
 
@@ -54,7 +55,7 @@ func (rs *RedisStore) Get(id string, clear bool) string {
 		if xerror.Is(err, redis.Nil) {
 			return ""
 		}
-		panic(xerror.New(err.Error()))
+		fmt.Println(xerror.NewNetError(err.Error()))
 	}
 	if clear {
 		go rs.client.Del(ctx, key)

pkg/email/email.go

@@ -114,7 +114,7 @@ func SendTLS(ctx context.Context, e *config.Email) error {
 	}
 	d.SSL = true
 	if err := d.DialAndSend(m); err != nil {
-		return xerror.New(err.Error())
+		return xerror.NewNetError(err.Error())
 	}
 	return nil
 }
@@ -232,7 +232,7 @@ func (x *oEmail) SendTLS(ctx context.Context, in *Params) (err error) {
 		}
 		return nil
 	}); err != nil {
-		return xerror.New(err.Error())
+		return xerror.NewNetError(err.Error())
 	}
 	return nil
 }

pkg/oss/oss.go

@@ -28,7 +28,7 @@ func NewClient(cfg *AliOssConfig) (bucket *oss.Bucket, err error) {
 	// client, err := oss.New(cfg.Endpoint, cfg.AccessKeyId, cfg.AccessKeySecret, oss.AuthVersion(oss.AuthV4), oss.Region(cfg.Region))
 	client, err := oss.New(cfg.Endpoint, cfg.AccessKeyId, cfg.AccessKeySecret)
 	if err != nil {
-		return nil, xerror.New(err.Error())
+		return nil, xerror.NewNetError(err.Error())
 	}
 	logger.Info("bucker name" + cfg.BucketName)
 	bucket, err = client.Bucket(cfg.BucketName)
@@ -52,7 +52,7 @@ func (*AliyunOSS) UploadFile(reader io.Reader, name string, cfg *AliOssConfig) (
 	fileTmpPath := cfg.BasePath + "/" + name
 	err = bucket.PutObject(fileTmpPath, reader)
 	if err != nil {
-		return "", "", xerror.New(err.Error())
+		return "", "", xerror.NewNetError(err.Error())
 	}
 	return cfg.BucketUrl + "/" + fileTmpPath, fileTmpPath, nil
 }
@@ -72,7 +72,7 @@ func (x Attachment) NewFromMultipartFileHeaders(files []*multipart.FileHeader) (
 	for i := range files {
 		reader, err := files[i].Open()
 		if err != nil {
-			return nil, xerror.New(err.Error())
+			return nil, xerror.NewNetError(err.Error())
 		}
 		attachment := &Attachment{
 			File: reader,
@@ -105,13 +105,13 @@ func (*AliyunOSS) UploadFiles(files *[]*Attachment, cfg *AliOssConfig) error {
 	}
 	bucket, err := NewClient(cfg)
 	if err != nil {
-		return xerror.New(err.Error())
+		return xerror.NewNetError(err.Error())
 	}
 	for i, file := range *files {
 		relativeUri := cfg.BasePath + "/" + file.Name
 		err = bucket.PutObject(relativeUri, file.File)
 		if err != nil {
-			return xerror.New(err.Error())
+			return xerror.NewNetError(err.Error())
 		}
 		(*files)[i].AbsUrl = cfg.BucketUrl + "/" + relativeUri
 		(*files)[i].RelativeUrl = relativeUri

pkg/sgorm/mysql/mysql.go

@@ -26,7 +26,7 @@ func Init(dsn string, opts ...Option) (*gorm.DB, error) {
 
 	sqlDB, err := sql.Open("mysql", dsn)
 	if err != nil {
-		return nil, xerror.New(err.Error())
+		return nil, xerror.NewRuntimeError(err.Error())
 	}
 	sqlDB.SetMaxIdleConns(o.maxIdleConns)       // set the maximum number of connections in the idle connection pool
 	sqlDB.SetMaxOpenConns(o.maxOpenConns)       // set the maximum number of open database connections
@@ -34,7 +34,7 @@ func Init(dsn string, opts ...Option) (*gorm.DB, error) {
 
 	db, err := gorm.Open(mysqlDriver.New(mysqlDriver.Config{Conn: sqlDB}), gormConfig(o))
 	if err != nil {
-		return nil, xerror.New(err.Error())
+		return nil, xerror.NewRuntimeError(err.Error())
 	}
 	db.Set("gorm:table_options", "CHARSET=utf8mb4") // automatic appending of table suffixes when creating tables
 
@@ -42,17 +42,17 @@ func Init(dsn string, opts ...Option) (*gorm.DB, error) {
 	if o.enableTrace {
 		err = db.Use(otelgorm.NewPlugin())
 		if err != nil {
-			return nil, xerror.Errorf("using gorm opentelemetry, err: %v", err)
+			return nil, xerror.NewRuntimeErrorf("using gorm opentelemetry, err: %v", err)
 		}
 	}
 	if err = sqlDB.Ping(); err != nil {
-		return nil, xerror.Errorf("ping db failed, err: %v", err)
+		return nil, xerror.NewRuntimeErrorf("ping db failed, err: %v", err)
 	}
 	// register read-write separation plugin
 	if len(o.slavesDsn) > 0 {
 		err = db.Use(rwSeparationPlugin(o))
 		if err != nil {
-			return nil, xerror.New(err.Error())
+			return nil, xerror.NewRuntimeError(err.Error())
 		}
 	}
 
@@ -60,7 +60,7 @@ func Init(dsn string, opts ...Option) (*gorm.DB, error) {
 	for _, plugin := range o.plugins {
 		err = db.Use(plugin)
 		if err != nil {
-			return nil, xerror.New(err.Error())
+			return nil, xerror.NewRuntimeError(err.Error())
 		}
 	}
 

pkg/sgorm/query/query_condition.go

@@ -136,10 +136,10 @@ type Column struct {
 
 func (c *Column) checkValid() error {
 	if c.Name == "" {
-		return xerror.New("field 'name' cannot be empty")
+		return xerror.NewRuntimeError("field 'name' cannot be empty")
 	}
 	if c.Value == nil {
-		return xerror.New("field 'value' cannot be nil")
+		return xerror.NewRuntimeError("field 'value' cannot be nil")
 	}
 	return nil
 }
@@ -157,7 +157,7 @@ func (c *Column) convert() error {
 		if c.Exp == " IN " {
 			val, ok := c.Value.(string)
 			if !ok {
-				return xerror.Newf("invalid value type '%s'", c.Value)
+				return xerror.NewRuntimeErrorf("invalid value type '%s'", c.Value)
 			}
 			iVal := []any{}
 			ss := strings.Split(val, ",")
@@ -167,7 +167,7 @@ func (c *Column) convert() error {
 			c.Value = iVal
 		}
 	} else {
-		return xerror.Newf("unknown exp type '%s'", c.Exp)
+		return xerror.NewRuntimeErrorf("unknown exp type '%s'", c.Exp)
 	}
 
 	if c.Logic == "" {
@@ -176,7 +176,7 @@ func (c *Column) convert() error {
 	if v, ok := logicMap[strings.ToLower(c.Logic)]; ok { //nolint
 		c.Logic = v
 	} else {
-		return xerror.Newf("unknown logic type '%s'", c.Logic)
+		return xerror.NewRuntimeErrorf("unknown logic type '%s'", c.Logic)
 	}
 
 	return nil
@@ -257,7 +257,7 @@ type Conditions struct {
 // CheckValid check valid
 func (c *Conditions) CheckValid() error {
 	if len(c.Columns) == 0 {
-		return xerror.New("field 'columns' cannot be empty")
+		return xerror.NewRuntimeError("field 'columns' cannot be empty")
 	}
 	for _, column := range c.Columns {
 		err := column.checkValid()
@@ -266,12 +266,12 @@ func (c *Conditions) CheckValid() error {
 		}
 		if column.Exp != "" {
 			if _, ok := expMap[column.Exp]; !ok {
-				return xerror.Newf("unknown exp type '%s'", column.Exp)
+				return xerror.NewRuntimeErrorf("unknown exp type '%s'", column.Exp)
 			}
 		}
 		if column.Logic != "" {
 			if _, ok := logicMap[column.Logic]; !ok {
-				return xerror.Newf("unknown logic type '%s'", column.Logic)
+				return xerror.NewRuntimeErrorf("unknown logic type '%s'", column.Logic)
 			}
 		}
 	}

pkg/ws/ws.go

@@ -94,10 +94,10 @@ func (m *WsConnManager) accept(c *gin.Context) error {
 	authorization := r.URL.Query().Get("auth")
 	if authorization == "" {
 		http.Error(w, "auth required", http.StatusUnauthorized)
-		return xerror.New("auth required")
+		return xerror.NewRuntimeError("auth required")
 	}
 	if len(authorization) <= 8 {
-		return xerror.New("auth required")
+		return xerror.NewRuntimeError("auth required")
 	}
 	token := authorization[7:] // remove Bearer prefix
 	claims, err := jwt.ParseToken(token)
@@ -153,7 +153,7 @@ func (m *WsConnManager) Send(ctx context.Context, receiverID xsf.ID, payload *Ws
 				h.OnConnNotFound(receiverID, payload)
 			}()
 		}
-		return xerror.Newf("user[id:%d] ws conn not found", receiverID)
+		return xerror.NewRuntimeErrorf("user[id:%d] ws conn not found", receiverID)
 	}
 	for _, h := range m.hooks {
 		go func() {

pkg/xerrors/xerror/xerror_api.go

@@ -3,17 +3,18 @@ package xerror
 import (
 	"fmt"
 
+	"gitlab.wanzhuangkj.com/tush/xpkg/pkg/errcode"
 	"gitlab.wanzhuangkj.com/tush/xpkg/pkg/xerrors/xcode"
 )
 
 // New 用于创建一个自定义文本错误信息的 error 对象，并包含堆栈信息。
-func New(text string) error {
-	return &Err{
-		stack: callers(),
-		text:  text,
-		code:  xcode.CodeDefault,
-	}
-}
+// func New(text string) error {
+// 	return &Err{
+// 		stack: callers(),
+// 		text:  text,
+// 		code:  xcode.CodeDefault,
+// 	}
+// }
 
 func NewNetError(text string) error {
 	e := NetError{}
@@ -23,6 +24,14 @@ func NewNetError(text string) error {
 	return &e
 }
 
+func NewNetErrorf(format string, args ...any) error {
+	e := NetError{}
+	e.stack = callers()
+	e.text = fmt.Sprintf(format, args...)
+	e.code = xcode.CodeDefault
+	return &e
+}
+
 func NewDBError(text string) error {
 	e := DBError{}
 	e.stack = callers()
@@ -31,10 +40,42 @@ func NewDBError(text string) error {
 	return &e
 }
 
+func NewDBErrorf(format string, args ...any) error {
+	e := DBError{}
+	e.stack = callers()
+	e.text = fmt.Sprintf(format, args...)
+	e.code = xcode.CodeDefault
+	return &e
+}
+
+func NewCacheError(text string) error {
+	e := CacheError{}
+	e.stack = callers()
+	e.text = text
+	e.code = xcode.CodeDefault
+	return &e
+}
+
+func NewCacheErrorf(format string, args ...any) error {
+	e := CacheError{}
+	e.stack = callers()
+	e.text = fmt.Sprintf(format, args...)
+	e.code = xcode.CodeDefault
+	return &e
+}
+
 func NewParamError(text string) error {
 	e := ParamError{}
 	e.stack = callers()
 	e.text = text
+	e.code = errcode.InvalidParams.Code()
+	return &e
+}
+
+func NewParamErrorf(format string, args ...any) error {
+	e := ParamError{}
+	e.stack = callers()
+	e.text = fmt.Sprintf(format, args...)
 	e.code = xcode.CodeDefault
 	return &e
 }
@@ -47,13 +88,45 @@ func NewBizError(text string) error {
 	return &e
 }
 
+func NewBizErrorC(code int, text string) error {
+	e := BizError{}
+	e.stack = callers()
+	e.text = text
+	e.code = code
+	return &e
+}
+
+func NewBizErrorf(format string, args ...any) error {
+	e := BizError{}
+	e.stack = callers()
+	e.text = fmt.Sprintf(format, args...)
+	e.code = xcode.CodeDefault
+	return &e
+}
+
+func NewRuntimeError(text string) error {
+	e := RuntimeError{}
+	e.stack = callers()
+	e.text = text
+	e.code = xcode.CodeDefault
+	return &e
+}
+
+func NewRuntimeErrorf(format string, args ...any) error {
+	e := RuntimeError{}
+	e.stack = callers()
+	e.text = fmt.Sprintf(format, args...)
+	e.code = xcode.CodeDefault
+	return &e
+}
+
 // NewC add code
 func NewC(code int, text string) error {
-	return &Err{
-		stack: callers(),
-		text:  text,
-		code:  code,
-	}
+	e := BizError{}
+	e.stack = callers()
+	e.text = text
+	e.code = code
+	return &e
 }
 
 func Join(errs ...error) error {

pkg/xerrors/xerror/xerror_error.go

@@ -24,6 +24,10 @@ type DBError struct {
 	Err
 }
 
+type CacheError struct {
+	Err
+}
+
 type ParamError struct {
 	Err
 }
@@ -32,6 +36,10 @@ type BizError struct {
 	Err
 }
 
+type RuntimeError struct {
+	Err
+}
+
 const (
 	// stackFilterKeyLocal 过滤当前错误模块路径的键。
 	stackFilterKeyLocal = "/xerrors/xerror"

pkg/xerrors/xerror/xerror_z_bench_test.go

@@ -15,7 +15,7 @@ var (
 
 func Benchmark_New(b *testing.B) {
 	for i := 0; i < b.N; i++ {
-		xerror.New("test")
+		xerror.NewRuntimeError("test")
 	}
 }
 

pkg/xerrors/xerror/xerror_z_example_test.go

@@ -53,7 +53,7 @@ func ExampleWrapCodef() {
 
 func ExampleEqual() {
 	err1 := errors.New("permission denied")
-	err2 := xerror.New("permission denied")
+	err2 := xerror.NewRuntimeError("permission denied")
 	err3 := xerror.NewCode(xcode.CodeNotAuthorized, "permission denied")
 	fmt.Println(xerror.Equal(err1, err2))
 	fmt.Println(xerror.Equal(err2, err3))

pkg/xerrors/xerror/xerror_z_unit_test.go

@@ -21,12 +21,12 @@ func nilError() error {
 }
 
 func Test_Nil(t *testing.T) {
-	assert.NotNil(t, xerror.New(""))
+	assert.NotNil(t, xerror.NewRuntimeError(""))
 	assert.Nil(t, xerror.Wrap(nilError(), "test"))
 }
 
 func Test_New(t *testing.T) {
-	err1 := xerror.New("1")
+	err1 := xerror.NewRuntimeError("1")
 	assert.NotNil(t, err1)
 	assert.Equal(t, err1.Error(), "1")
 
@@ -46,7 +46,7 @@ func Test_Wrap(t *testing.T) {
 	assert.NotNil(t, err1)
 	assert.Equal(t, err1.Error(), "3: 2: 1")
 
-	err2 := xerror.New("1")
+	err2 := xerror.NewRuntimeError("1")
 	err2 = xerror.Wrap(err2, "")
 	assert.NotNil(t, err2)
 	assert.Equal(t, err2.Error(), "1")
@@ -59,7 +59,7 @@ func Test_Wrapf(t *testing.T) {
 	assert.NotNil(t, err1)
 	assert.Equal(t, err1.Error(), "3: 2: 1")
 
-	err2 := xerror.New("1")
+	err2 := xerror.NewRuntimeError("1")
 	err2 = xerror.Wrapf(err2, "")
 	assert.NotNil(t, err2, nil)
 	assert.Equal(t, err2.Error(), "1")
@@ -72,7 +72,7 @@ func Test_WrapSkip(t *testing.T) {
 	assert.NotNil(t, err1, nil)
 	assert.Equal(t, err1.Error(), "3: 2: 1")
 
-	err2 := xerror.New("1")
+	err2 := xerror.NewRuntimeError("1")
 	err2 = xerror.WrapSkip(1, err2, "")
 	assert.NotNil(t, err2, nil)
 	assert.Equal(t, err2.Error(), "1")
@@ -85,7 +85,7 @@ func Test_WrapSkipf(t *testing.T) {
 	assert.NotNil(t, err1, nil)
 	assert.Equal(t, err1.Error(), "3: 2: 1")
 
-	err2 := xerror.New("1")
+	err2 := xerror.NewRuntimeError("1")
 	err2 = xerror.WrapSkipf(1, err2, "")
 	assert.NotNil(t, err2, nil)
 	assert.Equal(t, err2.Error(), "1")
@@ -100,10 +100,10 @@ func Test_Cause(t *testing.T) {
 	err1 = xerror.Wrap(err1, "3")
 	assert.Equal(t, xerror.Cause(err1).Error(), "1")
 
-	err2 := xerror.New("1")
+	err2 := xerror.NewRuntimeError("1")
 	assert.Equal(t, xerror.Cause(err2).Error(), "1")
 
-	err3 := xerror.New("1")
+	err3 := xerror.NewRuntimeError("1")
 	err3 = xerror.Wrap(err3, "2")
 	err3 = xerror.Wrap(err3, "3")
 	assert.Equal(t, xerror.Cause(err3).Error(), "1")
@@ -117,7 +117,7 @@ func Test_Format(t *testing.T) {
 	assert.Equal(t, fmt.Sprintf("%s", err1), "3: 2: 1")
 	assert.Equal(t, fmt.Sprintf("%v", err1), "3: 2: 1")
 
-	err2 := xerror.New("1")
+	err2 := xerror.NewRuntimeError("1")
 	err2 = xerror.Wrap(err2, "2")
 	err2 = xerror.Wrap(err2, "3")
 	assert.NotNil(t, err2, nil)
@@ -135,11 +135,11 @@ func Test_Stack(t *testing.T) {
 	assert.NotNil(t, err1, nil)
 	// fmt.Printf("%+v", err1)
 
-	err2 := xerror.New("1")
+	err2 := xerror.NewRuntimeError("1")
 	assert.NotNil(t, fmt.Sprintf("%+v", err2), "1")
 	// fmt.Printf("%+v", err2)
 
-	err3 := xerror.New("1")
+	err3 := xerror.NewRuntimeError("1")
 	err3 = xerror.Wrap(err3, "2")
 	err3 = xerror.Wrap(err3, "3")
 	assert.NotNil(t, err3, nil)
@@ -217,7 +217,7 @@ func Test_Code(t *testing.T) {
 }
 
 func Test_SetCode(t *testing.T) {
-	err := xerror.New("123")
+	err := xerror.NewRuntimeError("123")
 	assert.Equal(t, xerror.Code(err), -1)
 	assert.Equal(t, err.Error(), "123")
 
@@ -227,7 +227,7 @@ func Test_SetCode(t *testing.T) {
 }
 
 func Test_Json(t *testing.T) {
-	err := xerror.Wrap(xerror.New("1"), "2")
+	err := xerror.Wrap(xerror.NewRuntimeError("1"), "2")
 	b, e := json.Marshal(err)
 	assert.Equal(t, e, nil)
 	assert.Equal(t, string(b), `"2: 1"`)
@@ -235,7 +235,7 @@ func Test_Json(t *testing.T) {
 
 func Test_HasStack(t *testing.T) {
 	err1 := errors.New("1")
-	err2 := xerror.New("1")
+	err2 := xerror.NewRuntimeError("1")
 	assert.Equal(t, xerror.HasStack(err1), false)
 	assert.Equal(t, xerror.HasStack(err2), true)
 }
@@ -243,8 +243,8 @@ func Test_HasStack(t *testing.T) {
 func Test_Equal(t *testing.T) {
 	err1 := errors.New("1")
 	err2 := errors.New("1")
-	err3 := xerror.New("1")
-	err4 := xerror.New("4")
+	err3 := xerror.NewRuntimeError("1")
+	err4 := xerror.NewRuntimeError("4")
 	assert.Equal(t, xerror.Equal(err1, err2), false)
 	assert.Equal(t, xerror.Equal(err1, err3), true)
 	assert.Equal(t, xerror.Equal(err2, err3), true)
@@ -260,7 +260,7 @@ func Test_Is(t *testing.T) {
 	assert.Equal(t, xerror.Is(err2, err1), true)
 	err3 := xerror.Wrap(gorm.ErrRecordNotFound, "3")
 	assert.Equal(t, xerror.Is(err3, gorm.ErrRecordNotFound), true)
-	err4 := xerror.New(gorm.ErrRecordNotFound.Error())
+	err4 := xerror.NewRuntimeError(gorm.ErrRecordNotFound.Error())
 	assert.Equal(t, xerror.Is(err4, gorm.ErrRecordNotFound), true)
 	err5 := xerror.WrapCode(1, gorm.ErrRecordNotFound, "exes")
 	assert.Equal(t, xerror.Is(err5, gorm.ErrRecordNotFound), true)

xcommon/ocache/ocache.go

@@ -69,7 +69,7 @@ func (x *OCache[T]) Set(ctx context.Context, id xsf.ID, data *T, duration time.D
 	}
 	cacheKey := getCacheKey(x.KeyPrefix, id.Int64())
 	if err := x.Cache.Set(ctx, cacheKey, data, duration); err != nil {
-		return xerror.New(err.Error())
+		return xerror.NewCacheError(err.Error())
 	}
 	return nil
 }
@@ -81,7 +81,7 @@ func (x *OCache[T]) Get(ctx context.Context, id xsf.ID) (*T, error) {
 	var data *T
 	cacheKey := getCacheKey(x.KeyPrefix, id.Int64())
 	if err := x.Cache.Get(ctx, cacheKey, &data); err != nil {
-		return nil, xerror.New(err.Error())
+		return nil, xerror.NewCacheError(err.Error())
 	}
 	return data, nil
 }
@@ -97,7 +97,7 @@ func (x *OCache[T]) MultiSet(ctx context.Context, data []*T, duration time.Durat
 	}
 
 	if err := x.Cache.MultiSet(ctx, valMap, duration); err != nil {
-		return xerror.New(err.Error())
+		return xerror.NewCacheError(err.Error())
 	}
 
 	return nil
@@ -117,7 +117,7 @@ func (x *OCache[T]) MultiGet(ctx context.Context, ids []xsf.ID) (map[xsf.ID]int,
 	}
 	items, err := x.Cache.MGet(ctx, keys)
 	if err != nil {
-		return nil, nil, xerror.New(err.Error())
+		return nil, nil, xerror.NewCacheError(err.Error())
 	}
 	retMap := make(map[xsf.ID]*T)
 	hasMap := make(map[xsf.ID]int)
@@ -141,7 +141,7 @@ func (x *OCache[T]) MultiGet(ctx context.Context, ids []xsf.ID) (map[xsf.ID]int,
 func (x *OCache[T]) Del(ctx context.Context, id xsf.ID) error {
 	cacheKey := x.KeyPrefix + utils.Int64ToStr(id.Int64())
 	if err := x.Cache.Del(ctx, cacheKey); err != nil {
-		return xerror.New(err.Error())
+		return xerror.NewCacheError(err.Error())
 	}
 	return nil
 }
@@ -156,7 +156,7 @@ func (x *OCache[T]) Dels(ctx context.Context, ids []xsf.ID) error {
 		keys = append(keys, cacheKey)
 	}
 	if err := x.Cache.Del(ctx, keys...); err != nil {
-		return xerror.New(err.Error())
+		return xerror.NewCacheError(err.Error())
 	}
 	return nil
 }
@@ -164,7 +164,7 @@ func (x *OCache[T]) Dels(ctx context.Context, ids []xsf.ID) error {
 func (x *OCache[T]) SetPlaceholder(ctx context.Context, id xsf.ID) error {
 	cacheKey := x.KeyPrefix + utils.Int64ToStr(id.Int64())
 	if err := x.Cache.SetCacheWithNotFound(ctx, cacheKey); err != nil {
-		return xerror.New(err.Error())
+		return xerror.NewCacheError(err.Error())
 	}
 	return nil
 }

xcommon/odao/odao.go

@@ -356,7 +356,7 @@ func (x *ODao[T]) JList(ctx context.Context, where IListParams, result any, resu
 func (x *ODao[T]) GetPageByColumns(ctx context.Context, params *query.Params) (rs []*T, total int64, err error) {
 	queryStr, args, err := params.ConvertToGormConditions()
 	if err != nil {
-		return nil, 0, xerror.New("query params error: " + err.Error())
+		return nil, 0, xerror.NewDBError("query params error: " + err.Error())
 	}
 	if params.Sort != OrderIgnoreCount {
 		var tb T

xcron/dao/cron_job.go

@@ -93,7 +93,7 @@ func (x *cronJobDao) GetNotRunning(ctx context.Context, id xsf.ID) (*models.Cron
 		Where("state = ?", enums.CronJob_State_NOT_RUNNING).Where("id = ?", id).
 		Update("state", enums.CronJob_State_RUNNING)
 	if result.Error != nil {
-		return nil, xerror.New(result.Error.Error())
+		return nil, xerror.NewDBError(result.Error.Error())
 	}
 	if result.RowsAffected == 0 {
 		return nil, nil

xcron/service/cron_job.go

@@ -62,7 +62,7 @@ func (x *cronJobService) DeleteByID(ctx context.Context, id xsf.ID) error {
 		return err
 	}
 	if cronJob == nil {
-		return xerror.New(fmt.Sprintf("未查询到%s[id:%d]", models.CronJobTool.TableName(), id))
+		return xerror.NewBizError(fmt.Sprintf("未查询到%s[id:%d]", models.CronJobTool.TableName(), id))
 	}
 	return dao.CronJobDao.DeleteByID(ctx, id)
 }
@@ -107,7 +107,7 @@ func (x *cronJobService) UpdateByID(ctx context.Context, req *types.CronJobUpdat
 		return err
 	}
 	if cronJob == nil {
-		return xerror.New(fmt.Sprintf("未查询到%s[id:%d]", models.CronJobTool.TableName(), req.ID))
+		return xerror.NewBizError(fmt.Sprintf("未查询到%s[id:%d]", models.CronJobTool.TableName(), req.ID))
 	}
 	cronJobUpd := &models.CronJob{}
 	_ = copier.Copy(cronJobUpd, req)

xutils/goutils/go.go

@@ -45,7 +45,7 @@ func Do(ctx context.Context, fns ...FnCtx) error {
 		})
 	}
 	if err := eg.Wait(); err != nil {
-		return xerror.New(err.Error())
+		return xerror.NewRuntimeError(err.Error())
 	}
 	return nil
 }
@@ -63,7 +63,7 @@ func DoWithTimeout(timeout time.Duration, fns ...FnCtx) error {
 		})
 	}
 	if err := eg.Wait(); err != nil {
-		return xerror.New(err.Error())
+		return xerror.NewRuntimeError(err.Error())
 	}
 	return nil
 }

xutils/jsonutils/json.go

@@ -10,7 +10,7 @@ import (
 func Unmarshal(data []byte, v any) error {
 	err := json.Unmarshal(data, v)
 	if err != nil {
-		return xerror.New(err.Error())
+		return xerror.NewRuntimeError(err.Error())
 	}
 	return nil
 }

xutils/redsyncutils/red_sync_utils.go

@@ -31,13 +31,13 @@ func initialize(redisCli *redis.Client) {
 
 func Sync(ctx context.Context, key string, fn func(), options ...redsync.Option) error {
 	if key == "" {
-		return xerror.New("[redSync]key is empty, please check")
+		return xerror.NewRuntimeError("[redSync]key is empty, please check")
 	}
 	if fn == nil {
-		return xerror.New("[redSync]fn is nil, please check")
+		return xerror.NewRuntimeError("[redSync]fn is nil, please check")
 	}
 	if redSync == nil {
-		return xerror.New("[redSync]redSync is nil, please init first")
+		return xerror.NewRuntimeError("[redSync]redSync is nil, please init first")
 	}
 	mutex := redSync.NewMutex(key, options...)
 	if err := mutex.LockContext(ctx); err != nil {

xutils/sliceutils/xslice.go

@@ -245,14 +245,14 @@ func CompareSlice[ID xtype.Key, T IIDTable[ID], BizSlice ~[]*T](ids []ID, bizSli
 			if v, ok := errCode.(*errcode.Error); ok {
 				return xerror.NewC(v.Code(), v.Msg())
 			}
-			return xerror.New(errCode.Error())
+			return xerror.NewBizError(errCode.Error())
 		}
 		deltaIDs := SetDifference(ids, GetIDs[ID](bizSlice))
 		if len(deltaIDs) > 0 {
 			if v, ok := errCode.(*errcode.Error); ok {
 				return xerror.NewC(v.Code(), fmt.Sprintf("%s[ids:%s]", v.Msg(), Join(deltaIDs, ",")))
 			}
-			return xerror.New(errCode.Error())
+			return xerror.NewBizError(errCode.Error())
 		}
 	}
 	return nil

xutils/wg/wg.go

@@ -11,10 +11,10 @@ import (
 
 func Go(ctx context.Context, n int, fn func() error) error {
 	if n <= 0 {
-		return xerror.New("n cannot be less or equal then 0")
+		return xerror.NewRuntimeError("n cannot be less or equal then 0")
 	}
 	if fn == nil {
-		return xerror.New("fn cannot be nil")
+		return xerror.NewRuntimeError("fn cannot be nil")
 	}
 	wg := &sync.WaitGroup{}
 	wg.Add(n)

xutils/xsf/xsf.go

@@ -150,7 +150,7 @@ func ParseInt64(val int64) ID {
 func ParseString(val string) (ID, error) {
 	v, err := snowflake.ParseString(val)
 	if err != nil {
-		return 0, xerror.New(err.Error())
+		return 0, xerror.NewRuntimeError(err.Error())
 	}
 	return ID(v), nil
 }