refactor(log): migrate from zerolog to structured slog with bridge

- Replace direct zerolog usage with standard library `log/slog` in business code
- Add `internal/logging` package with zerolog bridge handler for structured output
- Create `internal/jsoncodec` package to centralize JSON encoding/decoding using Sonic
- Update all services and main entry point to use new logging interface
- Maintain backward compatibility with existing zerolog console output
- Remove custom logger setup in favor of structured logging bridge

internal/jsoncodec/jsoncodec.go

@@ -0,0 +1,17 @@
+package jsoncodec
+
+import (
+	"io"
+
+	"github.com/bytedance/sonic"
+)
+
+func Marshal(v any) ([]byte, error) { return sonic.Marshal(v) }
+
+func Unmarshal(data []byte, v any) error { return sonic.Unmarshal(data, v) }
+
+func UnmarshalString(data string, v any) error { return sonic.UnmarshalString(data, v) }
+
+func NewEncoder(w io.Writer) sonic.Encoder { return sonic.ConfigDefault.NewEncoder(w) }
+
+func NewDecoder(r io.Reader) sonic.Decoder { return sonic.ConfigDefault.NewDecoder(r) }

internal/logging/logging.go

@@ -0,0 +1,63 @@
+package logging
+
+import (
+	"log/slog"
+	"os"
+	"strings"
+	"time"
+
+	"github.com/rs/zerolog"
+)
+
+type Options struct {
+	Service string
+}
+
+func New(opts Options) (*slog.Logger, zerolog.Logger) {
+	level := parseLevel(strings.TrimSpace(os.Getenv("EZ_LOG_LEVEL")))
+	zerolog.SetGlobalLevel(toZerologLevel(level))
+
+	output := zerolog.ConsoleWriter{
+		Out:        os.Stdout,
+		TimeFormat: time.RFC3339,
+	}
+
+	zl := zerolog.New(output).
+		Level(toZerologLevel(level)).
+		With().
+		Timestamp().
+		Str("service", strings.TrimSpace(opts.Service)).
+		Logger()
+
+	sl := slog.New(NewZerologHandler(zl, level))
+	slog.SetDefault(sl)
+	return sl, zl
+}
+
+func parseLevel(raw string) slog.Level {
+	switch strings.ToLower(raw) {
+	case "debug":
+		return slog.LevelDebug
+	case "warn", "warning":
+		return slog.LevelWarn
+	case "error":
+		return slog.LevelError
+	case "info", "":
+		return slog.LevelInfo
+	default:
+		return slog.LevelInfo
+	}
+}
+
+func toZerologLevel(level slog.Level) zerolog.Level {
+	switch {
+	case level <= slog.LevelDebug:
+		return zerolog.DebugLevel
+	case level <= slog.LevelInfo:
+		return zerolog.InfoLevel
+	case level <= slog.LevelWarn:
+		return zerolog.WarnLevel
+	default:
+		return zerolog.ErrorLevel
+	}
+}

internal/logging/zerolog_handler.go

@@ -0,0 +1,133 @@
+package logging
+
+import (
+	"context"
+	"fmt"
+	"log/slog"
+	"strings"
+
+	"github.com/rs/zerolog"
+)
+
+type ZerologHandler struct {
+	logger zerolog.Logger
+	level  slog.Level
+	attrs  []slog.Attr
+	groups []string
+}
+
+func NewZerologHandler(logger zerolog.Logger, level slog.Level) *ZerologHandler {
+	return &ZerologHandler{
+		logger: logger,
+		level:  level,
+	}
+}
+
+func (h *ZerologHandler) Enabled(_ context.Context, level slog.Level) bool {
+	return level >= h.level
+}
+
+func (h *ZerologHandler) Handle(_ context.Context, record slog.Record) error {
+	event := h.eventFor(record.Level)
+	if event == nil {
+		return nil
+	}
+
+	for _, attr := range h.attrs {
+		h.addAttr(event, h.key(attr.Key), attr.Value)
+	}
+	record.Attrs(func(attr slog.Attr) bool {
+		h.addAttr(event, h.key(attr.Key), attr.Value)
+		return true
+	})
+
+	event.Msg(record.Message)
+	return nil
+}
+
+func (h *ZerologHandler) WithAttrs(attrs []slog.Attr) slog.Handler {
+	cp := h.clone()
+	cp.attrs = append(cp.attrs, attrs...)
+	return cp
+}
+
+func (h *ZerologHandler) WithGroup(name string) slog.Handler {
+	if strings.TrimSpace(name) == "" {
+		return h
+	}
+	cp := h.clone()
+	cp.groups = append(cp.groups, name)
+	return cp
+}
+
+func (h *ZerologHandler) clone() *ZerologHandler {
+	cp := *h
+	cp.attrs = append([]slog.Attr(nil), h.attrs...)
+	cp.groups = append([]string(nil), h.groups...)
+	return &cp
+}
+
+func (h *ZerologHandler) key(k string) string {
+	k = strings.TrimSpace(k)
+	if k == "" {
+		return ""
+	}
+	if len(h.groups) == 0 {
+		return k
+	}
+	return strings.Join(h.groups, ".") + "." + k
+}
+
+func (h *ZerologHandler) eventFor(level slog.Level) *zerolog.Event {
+	switch {
+	case level >= slog.LevelError:
+		return h.logger.Error()
+	case level >= slog.LevelWarn:
+		return h.logger.Warn()
+	case level >= slog.LevelInfo:
+		return h.logger.Info()
+	default:
+		return h.logger.Debug()
+	}
+}
+
+func (h *ZerologHandler) addAttr(event *zerolog.Event, key string, value slog.Value) {
+	if event == nil || strings.TrimSpace(key) == "" {
+		return
+	}
+
+	value = value.Resolve()
+
+	switch value.Kind() {
+	case slog.KindGroup:
+		for _, groupAttr := range value.Group() {
+			groupKey := h.key(key + "." + groupAttr.Key)
+			h.addAttr(event, groupKey, groupAttr.Value.Resolve())
+		}
+	case slog.KindString:
+		event.Str(key, value.String())
+	case slog.KindBool:
+		event.Bool(key, value.Bool())
+	case slog.KindInt64:
+		event.Int64(key, value.Int64())
+	case slog.KindUint64:
+		event.Uint64(key, value.Uint64())
+	case slog.KindFloat64:
+		event.Float64(key, value.Float64())
+	case slog.KindDuration:
+		event.Dur(key, value.Duration())
+	case slog.KindTime:
+		event.Time(key, value.Time())
+	default:
+		anyValue := value.Any()
+		if err, ok := anyValue.(error); ok {
+			event.AnErr(key, err)
+			return
+		}
+		if stringer, ok := anyValue.(fmt.Stringer); ok {
+			event.Str(key, stringer.String())
+			return
+		}
+		event.Interface(key, anyValue)
+	}
+}

internal/service/logger.go

@@ -2,10 +2,10 @@ package service
 
 import (
 	"context"
+	"log/slog"
 	"time"
 
 	"github.com/ez-api/ez-api/internal/model"
-	"github.com/rs/zerolog/log"
 	"gorm.io/gorm"
 )
 
@@ -47,7 +47,7 @@ func (w *LogWriter) Start(ctx context.Context) {
 				return
 			}
 			if err := w.db.Create(&buf).Error; err != nil {
-				log.Error().Err(err).Msg("log batch insert failed")
+				slog.Default().Error("log batch insert failed", "err", err)
 			}
 			buf = buf[:0]
 		}

internal/service/sync.go

@@ -6,7 +6,7 @@ import (
 	"strings"
 	"time"
 
-	"github.com/bytedance/sonic"
+	"github.com/ez-api/ez-api/internal/jsoncodec"
 	"github.com/ez-api/ez-api/internal/model"
 	"github.com/ez-api/ez-api/internal/util"
 	"github.com/redis/go-redis/v9"
@@ -212,7 +212,7 @@ func (s *SyncService) SyncAll(db *gorm.DB) error {
 		if p.BanUntil != nil {
 			snap.BanUntil = p.BanUntil.UTC().Unix()
 		}
-		payload, err := sonic.Marshal(snap)
+		payload, err := jsoncodec.Marshal(snap)
 		if err != nil {
 			return fmt.Errorf("marshal provider %d: %w", p.ID, err)
 		}
@@ -271,7 +271,7 @@ func (s *SyncService) SyncAll(db *gorm.DB) error {
 			SupportsFIM:        m.SupportsFIM,
 			MaxOutputTokens:    m.MaxOutputTokens,
 		}
-		payload, err := sonic.Marshal(snap)
+		payload, err := jsoncodec.Marshal(snap)
 		if err != nil {
 			return fmt.Errorf("marshal model %s: %w", m.Name, err)
 		}
@@ -286,7 +286,7 @@ func (s *SyncService) SyncAll(db *gorm.DB) error {
 }
 
 func (s *SyncService) hsetJSON(ctx context.Context, key, field string, val interface{}) error {
-	payload, err := sonic.Marshal(val)
+	payload, err := jsoncodec.Marshal(val)
 	if err != nil {
 		return fmt.Errorf("marshal %s:%s: %w", key, field, err)
 	}