```

feat(service): 优化地址解析逻辑以支持端口号直接解析

重构 parseTraditionalStyle 函数，简化 NetworkAddress 构造方式，
并引入 utils.IsNumber 判断纯端口号情况，提升地址解析的准确性与兼容性。
```

README.md

@@ -1,27 +1,59 @@
-# 私有仓库：core 设置
+# BSM-SDK Core
+
+BSM-SDK Core 是一个企业级后端开发工具包的核心模块，提供了加密解密、配置管理、缓存、数据库访问、中间件等基础功能。
+
+## 私有仓库设置
+
+```bash
+go env -w GOPRIVATE=git.apinb.com/*
+go env -w GONOPROXY=git.apinb.com/*
+go env -w GOINSECURE=git.apinb.com/*
+go env -w GONOSUMDB=git.apinb.com/*
 ```
-go env -w  GOPRIVATE=git.apinb.com/*
-go env -w  GONOPROXY=git.apinb.com/*
-go env -w  GOINSECURE=git.apinb.com/*
-go env -w  GONOSUMDB=git.apinb.com/*
+
+## 功能模块
+
+### 加密与解密 (crypto)
+
+#### GCM加密
+```go
+AESGCMEncrypt // GCM 加密
+AESGCMDecrypt // GCM 解密
 ```
-# crypto 加密与解密
-## GCM加密
+
+#### CBC加密
+```go
+Encrypt // CBC加密
+Decrypt // CBC解密
 ```
-AESGCMEncrypt GCM 加密
-AESGCMDecrypt GCM 解密
+
+#### ECB加密
+```go
+AesEncryptECB // ECB加密
+AesDecryptECB // ECB解密
 ```
-## CBC加密
-```
-Encrypt CBC加密
-Decrypt CBC解密
-```
-## ECB加密
-```
-AesEncryptECB ECB加密
-AesDecryptECB ECB解密
-```
-## 环境变量检测
-```
-AesKeyCheck 秘钥环境变量检测
+
+#### 环境变量检测
+```go
+AesKeyCheck // 秘钥环境变量检测
 ```
+
+### 缓存 (cache)
+
+支持 Redis 和内存缓存。
+
+### 数据库 (database)
+
+支持 MySQL 和 PostgreSQL 数据库连接和管理。
+
+### 中间件 (middleware)
+
+提供 CORS、JWT 认证、运行模式控制等中间件功能。
+
+### 消息队列 (queue)
+
+集成 NATS 消息队列。
+
+### 工具类 (utils)
+
+提供 JSON 处理、时间处理、随机数生成等通用工具函数。

crypto/encipher/encipher.go

@@ -104,31 +104,41 @@ func AesDecryptCBC(cryted string) (b []byte, err error) {
 	return orig, nil
 }
 
+// PKCS7Padding 使用PKCS7填充法对明文进行填充
 func PKCS7Padding(ciphertext []byte, blocksize int) []byte {
 	padding := blocksize - len(ciphertext)%blocksize
 	padtext := bytes.Repeat([]byte{byte(padding)}, padding)
 	return append(ciphertext, padtext...)
 }
 
-// 去码
+// PKCS7UnPadding 去除PKCS7填充
 // bug:runtime error: slice bounds out of range [:-22]
 func PKCS7UnPadding(origData []byte, blocksize int) []byte {
+	// 检查块大小是否有效
 	if blocksize <= 0 {
 		return nil
 	}
+
+	// 检查原始数据是否为空
 	if origData == nil || len(origData) == 0 {
 		return nil
 	}
+
+	// 检查数据长度是否为块大小的整数倍
 	if len(origData)%blocksize != 0 {
 		return nil
 	}
 
 	length := len(origData)
+	// 获取填充字节数
 	unpadding := int(origData[length-1])
 
+	// 检查去填充后数据长度是否有效
 	if length-unpadding <= 0 {
 		return nil
 	}
+
+	// 返回去除填充后的数据
 	return origData[:(length - unpadding)]
 }
 

database/new.go

@@ -1,3 +1,4 @@
+// Package database provides database connection and management functionality
 package database
 
 import (
@@ -12,9 +13,12 @@ import (
 )
 
 var (
+	// MigrateTables holds the tables that need to be auto-migrated on database initialization
 	MigrateTables []any
 )
 
+// NewDatabase creates a new database connection based on the provided driver type
+// It supports both MySQL and PostgreSQL databases
 func NewDatabase(driver string, dsn []string, options *types.SqlOptions) (db *gorm.DB, err error) {
 	driver = strings.ToLower(driver)
 	switch driver {
@@ -33,13 +37,13 @@ func NewDatabase(driver string, dsn []string, options *types.SqlOptions) (db *go
 	return db, nil
 }
 
-// NewMysql 创建MySQL数据库服务
+// NewMysql creates a MySQL database service
 func NewMysql(dsn []string, options *types.SqlOptions) (gormDb *gorm.DB, err error) {
 	//set connection default val.
 	if options == nil {
 		options = &types.SqlOptions{
 			MaxIdleConns:    vars.SqlOptionMaxIdleConns,
-			MaxOpenConns:    vars.SqlOptionMaxIdleConns,
+			MaxOpenConns:    vars.SqlOptionMaxOpenConns,
 			ConnMaxLifetime: vars.SqlOptionConnMaxLifetime,
 			LogStdout:       false,
 			Debug:           true,
@@ -58,7 +62,11 @@ func NewMysql(dsn []string, options *types.SqlOptions) (gormDb *gorm.DB, err err
 	}
 
 	// 获取通用数据库对象 sql.DB ，然后使用其提供的功能
-	sqlDB, _ := gormDb.DB()
+	sqlDB, err := gormDb.DB()
+	if err != nil {
+		return nil, err
+	}
+
 	// SetMaxIdleConns 用于设置连接池中空闲连接的最大数量。
 	sqlDB.SetMaxIdleConns(options.MaxIdleConns)
 	// SetMaxOpenConns 设置打开数据库连接的最大数量。
@@ -76,13 +84,13 @@ func NewMysql(dsn []string, options *types.SqlOptions) (gormDb *gorm.DB, err err
 	return gormDb, nil
 }
 
-// NewPostgres 创建PostgreSQL数据库服务
+// NewPostgres creates a PostgreSQL database service
 func NewPostgres(dsn []string, options *types.SqlOptions) (gormDb *gorm.DB, err error) {
 	//set connection default val.
 	if options == nil {
 		options = &types.SqlOptions{
 			MaxIdleConns:    vars.SqlOptionMaxIdleConns,
-			MaxOpenConns:    vars.SqlOptionMaxIdleConns,
+			MaxOpenConns:    vars.SqlOptionMaxOpenConns,
 			ConnMaxLifetime: vars.SqlOptionConnMaxLifetime,
 			LogStdout:       false,
 			Debug:           true,
@@ -98,6 +106,19 @@ func NewPostgres(dsn []string, options *types.SqlOptions) (gormDb *gorm.DB, err
 		gormDb = gormDb.Debug()
 	}
 
+	// 获取通用数据库对象 sql.DB ，然后使用其提供的功能
+	sqlDB, err := gormDb.DB()
+	if err != nil {
+		return nil, err
+	}
+
+	// SetMaxIdleConns 用于设置连接池中空闲连接的最大数量。
+	sqlDB.SetMaxIdleConns(options.MaxIdleConns)
+	// SetMaxOpenConns 设置打开数据库连接的最大数量。
+	sqlDB.SetMaxOpenConns(options.MaxOpenConns)
+	// SetConnMaxLifetime 设置了连接可复用的最大时间。
+	sqlDB.SetConnMaxLifetime(options.ConnMaxLifetime)
+
 	if len(MigrateTables) > 0 {
 		err = gormDb.AutoMigrate(MigrateTables...)
 		if err != nil {

database/sql/postgresql.go

@@ -12,7 +12,7 @@ func SetOptions(options *types.SqlOptions) *types.SqlOptions {
 	if options == nil {
 		options = &types.SqlOptions{
 			MaxIdleConns:    vars.SqlOptionMaxIdleConns,
-			MaxOpenConns:    vars.SqlOptionMaxIdleConns,
+			MaxOpenConns:    vars.SqlOptionMaxOpenConns,
 			ConnMaxLifetime: vars.SqlOptionConnMaxLifetime,
 			LogStdout:       false,
 			Debug:           false,
@@ -30,7 +30,7 @@ func NewPostgreSql(dsn string, options *types.SqlOptions) (*gorm.DB, error) {
 	if options == nil {
 		options = &types.SqlOptions{
 			MaxIdleConns:    vars.SqlOptionMaxIdleConns,
-			MaxOpenConns:    vars.SqlOptionMaxIdleConns,
+			MaxOpenConns:    vars.SqlOptionMaxOpenConns,
 			ConnMaxLifetime: vars.SqlOptionConnMaxLifetime,
 			LogStdout:       false,
 			Debug:           true,
@@ -56,7 +56,11 @@ func NewPostgreSql(dsn string, options *types.SqlOptions) (*gorm.DB, error) {
 	}
 
 	// 获取通用数据库对象 sql.DB ，然后使用其提供的功能
-	sqlDB, _ := gormDb.DB()
+	sqlDB, err := gormDb.DB()
+	if err != nil {
+		return nil, err
+	}
+	
 	// SetMaxIdleConns 用于设置连接池中空闲连接的最大数量。
 	sqlDB.SetMaxIdleConns(options.MaxIdleConns)
 	// SetMaxOpenConns 设置打开数据库连接的最大数量。
@@ -65,4 +69,4 @@ func NewPostgreSql(dsn string, options *types.SqlOptions) (*gorm.DB, error) {
 	sqlDB.SetConnMaxLifetime(options.ConnMaxLifetime)
 
 	return gormDb, nil
-}
+}

service/address.go

@@ -0,0 +1,204 @@
+package service
+
+import (
+	"fmt"
+	"net"
+	"net/url"
+	"strings"
+
+	"git.apinb.com/bsm-sdk/core/utils"
+)
+
+type NetworkAddress struct {
+	Protocol string // tcp, tcp4, tcp6, unix, unixpacket
+	Host     string // IP 地址或主机名
+	Port     string // 端口号
+	Path     string // Unix socket 路径
+	Raw      string // 原始字符串
+}
+
+// 解析网络地址字符串
+// "tcp://0.0.0.0:1212",
+//
+//	"tcp4://127.0.0.1:8080",
+//	"tcp6://[::1]:8080",
+//	"unix:///data/app/passport.sock",
+//	"unixpacket:///tmp/mysql.sock",
+//	":8080",                    // 传统格式
+//	"/tmp/server.sock",         // 传统Unix格式
+//	"invalid://address",        // 错误格式
+func ParseNetworkAddress(addr string) (*NetworkAddress, error) {
+	// 如果包含 ://，按 URL 解析
+	if strings.Contains(addr, "://") {
+		return parseURLStyle(addr)
+	}
+
+	// 否则按传统格式解析
+	return parseTraditionalStyle(addr)
+}
+
+// 解析 tcp://0.0.0.0:1212 或 unix:///path/to/socket 格式
+func parseURLStyle(addr string) (*NetworkAddress, error) {
+	u, err := url.Parse(addr)
+	if err != nil {
+		return nil, fmt.Errorf("解析URL失败: %w", err)
+	}
+
+	result := &NetworkAddress{
+		Protocol: u.Scheme,
+		Raw:      addr,
+	}
+
+	switch u.Scheme {
+	case "tcp", "tcp4", "tcp6":
+		return parseTCPURL(u, result)
+	case "unix", "unixpacket":
+		return parseUnixURL(u, result)
+	default:
+		return nil, fmt.Errorf("不支持的协议: %s", u.Scheme)
+	}
+}
+
+// 解析 TCP 类型的 URL
+func parseTCPURL(u *url.URL, result *NetworkAddress) (*NetworkAddress, error) {
+	host, port, err := net.SplitHostPort(u.Host)
+	if err != nil {
+		// 如果没有端口，尝试添加默认端口
+		if strings.Contains(err.Error(), "missing port") {
+			host = u.Host
+			port = "0" // 默认端口
+		} else {
+			return nil, fmt.Errorf("解析TCP地址失败: %w", err)
+		}
+	}
+
+	result.Host = host
+	result.Port = port
+
+	// 根据主机地址确定具体的协议类型
+	if result.Protocol == "tcp" {
+		result.Protocol = determineTCPProtocol(host)
+	}
+
+	return result, nil
+}
+
+// 解析 Unix socket 类型的 URL
+func parseUnixURL(u *url.URL, result *NetworkAddress) (*NetworkAddress, error) {
+	// Unix socket 路径在 URL 的 Path 字段
+	if u.Path == "" {
+		return nil, fmt.Errorf("Unix socket 路径不能为空")
+	}
+
+	result.Path = u.Path
+
+	// 如果协议是 unix，但路径表明需要数据包传输，可以自动升级
+	if result.Protocol == "unix" && strings.Contains(u.Path, "packet") {
+		result.Protocol = "unixpacket"
+	}
+
+	return result, nil
+}
+
+// 根据主机地址确定 TCP 协议类型
+func determineTCPProtocol(host string) string {
+	if host == "" {
+		return "tcp" // 默认
+	}
+
+	// 解析 IP 地址
+	ip := net.ParseIP(host)
+	if ip != nil {
+		if ip.To4() != nil {
+			return "tcp4"
+		}
+		return "tcp6"
+	}
+
+	// 如果是特殊地址
+	switch host {
+	case "0.0.0.0", "127.0.0.1", "localhost":
+		return "tcp4"
+	case "::", "::1":
+		return "tcp6"
+	default:
+		return "tcp" // 默认支持双栈
+	}
+}
+
+// 解析传统格式如 ":8080", "127.0.0.1:8080", "/tmp/socket"
+func parseTraditionalStyle(addr string) (*NetworkAddress, error) {
+	// 检查是否是 Unix socket（包含路径分隔符）
+	if strings.Contains(addr, "/") || strings.HasPrefix(addr, "@/") {
+		return &NetworkAddress{Protocol: "unix", Path: addr}, nil
+	}
+
+	// 否则按 TCP 地址解析
+	host, port, err := net.SplitHostPort(addr)
+	if err == nil {
+		return &NetworkAddress{Protocol: "tcp", Host: host, Port: port}, nil
+	}
+
+	// 检查是否是端口号
+	if ok := utils.IsNumber(addr); ok {
+		return &NetworkAddress{Protocol: "tcp", Host: "0.0.0.0", Port: addr}, nil
+	}
+
+	return nil, fmt.Errorf("解析地址失败: %w", err)
+
+}
+
+// 获取网络类型用于 net.Dial 或 net.Listen
+func (na *NetworkAddress) Network() string {
+	return na.Protocol
+}
+
+// 获取地址字符串用于 net.Dial 或 net.Listen
+func (na *NetworkAddress) Address() string {
+	switch na.Protocol {
+	case "tcp", "tcp4", "tcp6":
+		if na.Port == "" {
+			return na.Host
+		}
+		return net.JoinHostPort(na.Host, na.Port)
+	case "unix", "unixpacket":
+		return na.Path
+	default:
+		return na.Raw
+	}
+}
+
+// 格式化输出
+func (na *NetworkAddress) String() string {
+	switch na.Protocol {
+	case "tcp", "tcp4", "tcp6":
+		return fmt.Sprintf("%s://%s", na.Protocol, net.JoinHostPort(na.Host, na.Port))
+	case "unix", "unixpacket":
+		return fmt.Sprintf("%s://%s", na.Protocol, na.Path)
+	default:
+		return na.Raw
+	}
+}
+
+// 验证地址是否有效
+func (na *NetworkAddress) Validate() error {
+	switch na.Protocol {
+	case "tcp", "tcp4", "tcp6":
+		if na.Host == "" && na.Port == "" {
+			return fmt.Errorf("TCP地址需要主机和端口")
+		}
+		// 验证端口
+		if na.Port != "" {
+			if _, err := net.LookupPort("tcp", na.Port); err != nil {
+				return fmt.Errorf("无效的端口: %s", na.Port)
+			}
+		}
+	case "unix", "unixpacket":
+		if na.Path == "" {
+			return fmt.Errorf("Unix socket路径不能为空")
+		}
+	default:
+		return fmt.Errorf("不支持的协议: %s", na.Protocol)
+	}
+	return nil
+}

service/register.go

@@ -94,7 +94,11 @@ func (s *ServiceRegister) Close() error {
 
 func (s *ServiceRegister) SetAnonymous(key string, urls []string) {
 	// remove reppeat, clear service all anonymous uri.
-	anonymous, _ := s.cli.Get(context.Background(), key)
+	anonymous, err := s.cli.Get(context.Background(), key)
+	if err != nil {
+		print.Error("[BSM Register] Get Anonymous Fail: %v", err)
+		return
+	}
 
 	var as []string
 	if len(anonymous.Kvs) > 0 {
@@ -106,7 +110,7 @@ func (s *ServiceRegister) SetAnonymous(key string, urls []string) {
 	newAnonymous := strings.Join(as, ",")
 
 	// put anonymous to etcd
-	_, err := s.cli.Put(context.Background(), key, newAnonymous)
+	_, err = s.cli.Put(context.Background(), key, newAnonymous)
 
 	if err != nil {
 		print.Error("[BSM Register] Anonymous Fail.")

service/service.go

@@ -108,6 +108,14 @@ func (s *Service) Gateway(grpcAddr string, httpAddr string) {
 	http.ListenAndServe(httpAddr, s.Opts.GatewayMux)
 }
 
+func (s *Service) Use(initFunc func() error) {
+	err := (initFunc)()
+	if err != nil {
+		print.Error(err.Error())
+		panic(err)
+	}
+}
+
 func (s *Service) Stop() {
 	s.GrpcSrv.GracefulStop()
 }

utils/convert.go

@@ -6,36 +6,48 @@ import (
 	"strings"
 )
 
-// 字符串转Int
+// String2Int 字符串转Int
 //
 //	intStr：数字的字符串
 func String2Int(intStr string) (intNum int) {
-	intNum, _ = strconv.Atoi(intStr)
+	intNum, err := strconv.Atoi(intStr)
+	if err != nil {
+		return 0
+	}
 	return
 }
 
-// 字符串转Int64
+// String2Int64 字符串转Int64
 //
 //	intStr：数字的字符串
 func String2Int64(intStr string) (int64Num int64) {
-	intNum, _ := strconv.Atoi(intStr)
+	intNum, err := strconv.Atoi(intStr)
+	if err != nil {
+		return 0
+	}
 	int64Num = int64(intNum)
 	return
 }
 
-// 字符串转Float64
+// String2Float64 字符串转Float64
 //
 //	floatStr：小数点数字的字符串
 func String2Float64(floatStr string) (floatNum float64) {
-	floatNum, _ = strconv.ParseFloat(floatStr, 64)
+	floatNum, err := strconv.ParseFloat(floatStr, 64)
+	if err != nil {
+		return 0
+	}
 	return
 }
 
-// 字符串转Float32
+// String2Float32 字符串转Float32
 //
 //	floatStr：小数点数字的字符串
 func String2Float32(floatStr string) (floatNum float32) {
-	floatNum64, _ := strconv.ParseFloat(floatStr, 32)
+	floatNum64, err := strconv.ParseFloat(floatStr, 32)
+	if err != nil {
+		return 0
+	}
 	floatNum = float32(floatNum64)
 	return
 }

utils/dir.go

@@ -25,11 +25,17 @@ func CreateDir(dirName string) bool {
 }
 
 func GetRunPath() string {
-	path, _ := os.Executable()
+	path, err := os.Executable()
+	if err != nil {
+		return ""
+	}
 	return path
 }
 
 func GetCurrentPath() string {
-	path, _ := os.Getwd()
+	path, err := os.Getwd()
+	if err != nil {
+		return ""
+	}
 	return path
-}
+}

utils/validator.go

@@ -0,0 +1,129 @@
+package utils
+
+import (
+	"regexp"
+	"strings"
+	"unicode"
+)
+
+// IsEmail 验证是否是邮箱格式
+func IsEmail(email string) bool {
+	if strings.TrimSpace(email) == "" {
+		return false
+	}
+
+	// 邮箱正则表达式
+	pattern := `^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$`
+	matched, err := regexp.MatchString(pattern, email)
+	if err != nil {
+		return false
+	}
+	return matched
+}
+
+// IsMobile 验证是否是手机号（中国手机号格式）
+func IsMobile(mobile string) bool {
+	if strings.TrimSpace(mobile) == "" {
+		return false
+	}
+
+	// 中国手机号正则表达式：1开头，第二位3-9，后面9位数字
+	pattern := `^1[3-9]\d{9}$`
+	matched, err := regexp.MatchString(pattern, mobile)
+	if err != nil {
+		return false
+	}
+	return matched
+}
+
+// IsNumber 验证是否是纯数字
+func IsNumber(str string) bool {
+	if strings.TrimSpace(str) == "" {
+		return false
+	}
+
+	for _, char := range str {
+		if !unicode.IsDigit(char) {
+			return false
+		}
+	}
+	return true
+}
+
+// IsEnglish 验证是否是英文字符（不限大小写）
+func IsEnglish(str string) bool {
+	if strings.TrimSpace(str) == "" {
+		return false
+	}
+
+	for _, char := range str {
+		if !unicode.IsLetter(char) {
+			return false
+		}
+		if !isEnglishLetter(char) {
+			return false
+		}
+	}
+	return true
+}
+
+// IsEnglishWithSpace 验证是否是英文字符（允许空格）
+func IsEnglishWithSpace(str string) bool {
+	if strings.TrimSpace(str) == "" {
+		return false
+	}
+
+	for _, char := range str {
+		if unicode.IsSpace(char) {
+			continue
+		}
+		if !unicode.IsLetter(char) {
+			return false
+		}
+		if !isEnglishLetter(char) {
+			return false
+		}
+	}
+	return true
+}
+
+// IsAlphanumeric 验证是否是字母和数字组合
+func IsAlphanumeric(str string) bool {
+	if strings.TrimSpace(str) == "" {
+		return false
+	}
+
+	for _, char := range str {
+		if !unicode.IsLetter(char) && !unicode.IsDigit(char) {
+			return false
+		}
+	}
+	return true
+}
+
+// IsStrongPassword 验证强密码（至少8位，包含大小写字母和数字）
+func IsStrongPassword(password string) bool {
+	if len(password) < 8 {
+		return false
+	}
+
+	var hasUpper, hasLower, hasDigit bool
+
+	for _, char := range password {
+		switch {
+		case unicode.IsUpper(char):
+			hasUpper = true
+		case unicode.IsLower(char):
+			hasLower = true
+		case unicode.IsDigit(char):
+			hasDigit = true
+		}
+	}
+
+	return hasUpper && hasLower && hasDigit
+}
+
+// 辅助函数：判断是否是英文字母
+func isEnglishLetter(char rune) bool {
+	return (char >= 'a' && char <= 'z') || (char >= 'A' && char <= 'Z')
+}

with/etcd.go

@@ -13,7 +13,7 @@ import (
 
 func Etcd(cfg *conf.EtcdConf, cli *clientv3.Client) {
 	if cfg == nil || len(cfg.Endpoints) == 0 {
-		panic("Etcd endpoints is Empty!")
+		return
 	}
 
 	etcdCfg := clientv3.Config{

with/memory.go

@@ -2,7 +2,6 @@ package with
 
 import (
 	"context"
-	"encoding/json"
 	"time"
 
 	"git.apinb.com/bsm-sdk/core/print"
@@ -10,30 +9,27 @@ import (
 	"github.com/allegro/bigcache/v3"
 )
 
-func Memory(opts *bigcache.Config, cli *bigcache.BigCache) {
-	config := bigcache.Config{
-		Shards:             1024,
-		LifeWindow:         10 * time.Minute,
-		CleanWindow:        5 * time.Minute,
-		MaxEntriesInWindow: 1000 * 10 * 60,
-		MaxEntrySize:       500,
-		Verbose:            true,
-		HardMaxCacheSize:   8192,
-		OnRemove:           nil,
-		OnRemoveWithReason: nil,
-	}
-
-	if opts != nil {
-		config = *opts
+func Memory(cli *bigcache.BigCache, opts *bigcache.Config) {
+	if opts == nil {
+		opts = &bigcache.Config{
+			Shards:             1024,
+			LifeWindow:         10 * time.Minute,
+			CleanWindow:        5 * time.Minute,
+			MaxEntriesInWindow: 1000 * 10 * 60,
+			MaxEntrySize:       500,
+			Verbose:            true,
+			HardMaxCacheSize:   8192,
+			OnRemove:           nil,
+			OnRemoveWithReason: nil,
+		}
 	}
 
 	var err error
-	cli, err = bigcache.New(context.Background(), config)
+	cli, err = bigcache.New(context.Background(), *opts)
 	if err != nil {
 		print.Error("Memory Cache Fatal Error")
 		panic(err)
 	}
 
-	jsonBytes, _ := json.Marshal(config)
-	print.Success("[BSM - %s] Memory Cache: %s", vars.ServiceKey, jsonBytes)
+	print.Success("[BSM - %s] Memory Cache: Shards=%d, MaxEntrySize=%d", vars.ServiceKey, opts.Shards, opts.MaxEntrySize)
 }