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/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)
+	}
+}