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

cmd/server/main.go

@@ -2,23 +2,22 @@ package main
 
 import (
 	"context"
+	"log/slog"
 	"net/http"
 	"os"
 	"os/signal"
-	"strings"
 	"syscall"
 	"time"
 
 	_ "github.com/ez-api/ez-api/docs"
 	"github.com/ez-api/ez-api/internal/api"
 	"github.com/ez-api/ez-api/internal/config"
+	"github.com/ez-api/ez-api/internal/logging"
 	"github.com/ez-api/ez-api/internal/middleware"
 	"github.com/ez-api/ez-api/internal/model"
 	"github.com/ez-api/ez-api/internal/service"
 	"github.com/gin-gonic/gin"
 	"github.com/redis/go-redis/v9"
-	"github.com/rs/zerolog"
-	"github.com/rs/zerolog/log"
 	swaggerFiles "github.com/swaggo/files"
 	ginSwagger "github.com/swaggo/gin-swagger"
 	"gorm.io/driver/postgres"
@@ -48,13 +47,18 @@ import (
 // @in header
 // @name Authorization
 
+func fatal(logger *slog.Logger, msg string, args ...any) {
+	logger.Error(msg, args...)
+	os.Exit(1)
+}
+
 func main() {
-	logger := setupLogger()
+	logger, _ := logging.New(logging.Options{Service: "ez-api"})
 
 	// 1. Load Configuration
 	cfg, err := config.Load()
 	if err != nil {
-		logger.Fatal().Err(err).Msg("Failed to load config")
+		fatal(logger, "failed to load config", "err", err)
 	}
 
 	// 2. Initialize Redis Client
@@ -68,28 +72,28 @@ func main() {
 	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
 	defer cancel()
 	if err := rdb.Ping(ctx).Err(); err != nil {
-		logger.Fatal().Err(err).Msg("Failed to connect to Redis")
+		fatal(logger, "failed to connect to redis", "err", err)
 	}
-	logger.Info().Msg("Connected to Redis successfully")
+	logger.Info("connected to redis successfully")
 
 	// 3. Initialize GORM (PostgreSQL)
 	db, err := gorm.Open(postgres.Open(cfg.Postgres.DSN), &gorm.Config{})
 	if err != nil {
-		logger.Fatal().Err(err).Msg("Failed to connect to PostgreSQL")
+		fatal(logger, "failed to connect to postgresql", "err", err)
 	}
 	sqlDB, err := db.DB()
 	if err != nil {
-		logger.Fatal().Err(err).Msg("Failed to get generic database object")
+		fatal(logger, "failed to get generic database object", "err", err)
 	}
 	// Verify DB connection
 	if err := sqlDB.Ping(); err != nil {
-		logger.Fatal().Err(err).Msg("Failed to ping PostgreSQL")
+		fatal(logger, "failed to ping postgresql", "err", err)
 	}
-	logger.Info().Msg("Connected to PostgreSQL successfully")
+	logger.Info("connected to postgresql successfully")
 
 	// Auto Migrate
 	if err := db.AutoMigrate(&model.Master{}, &model.Key{}, &model.Provider{}, &model.Model{}, &model.LogRecord{}); err != nil {
-		logger.Fatal().Err(err).Msg("Failed to auto migrate")
+		fatal(logger, "failed to auto migrate", "err", err)
 	}
 
 	// 4. Setup Services and Handlers
@@ -101,7 +105,7 @@ func main() {
 
 	adminService, err := service.NewAdminService()
 	if err != nil {
-		logger.Fatal().Err(err).Msg("Failed to create admin service")
+		fatal(logger, "failed to create admin service", "err", err)
 	}
 	masterService := service.NewMasterService(db)
 	healthService := service.NewHealthCheckService(db, rdb)
@@ -112,7 +116,7 @@ func main() {
 
 	// 4.1 Prime Redis snapshots so DP can start with data
 	if err := syncService.SyncAll(db); err != nil {
-		logger.Warn().Err(err).Msg("Initial sync warning")
+		logger.Warn("initial sync warning", "err", err)
 	}
 
 	// 5. Setup Gin Router
@@ -176,9 +180,9 @@ func main() {
 
 	// 6. Start Server with Graceful Shutdown
 	go func() {
-		logger.Info().Str("port", cfg.Server.Port).Msg("Starting ez-api")
+		logger.Info("starting ez-api", "port", cfg.Server.Port)
 		if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
-			logger.Fatal().Err(err).Msg("Server failed")
+			fatal(logger, "server failed", "err", err)
 		}
 	}()
 
@@ -186,36 +190,14 @@ func main() {
 	quit := make(chan os.Signal, 1)
 	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
 	<-quit
-	logger.Info().Msg("Shutting down server...")
+	logger.Info("shutting down server...")
 
 	// Shutdown with timeout
 	ctx, cancel = context.WithTimeout(context.Background(), 5*time.Second)
 	defer cancel()
 	if err := srv.Shutdown(ctx); err != nil {
-		logger.Fatal().Err(err).Msg("Server forced to shutdown")
+		fatal(logger, "server forced to shutdown", "err", err)
 	}
 
-	logger.Info().Msg("Server exited properly")
-}
-
-func setupLogger() zerolog.Logger {
-	level := zerolog.InfoLevel
-	if raw := strings.TrimSpace(os.Getenv("EZ_LOG_LEVEL")); raw != "" {
-		if parsed, err := zerolog.ParseLevel(strings.ToLower(raw)); err == nil {
-			level = parsed
-		}
-	}
-
-	zerolog.SetGlobalLevel(level)
-	output := zerolog.ConsoleWriter{
-		Out:        os.Stdout,
-		TimeFormat: time.RFC3339,
-	}
-
-	logger := zerolog.New(output).Level(level).With().
-		Timestamp().
-		Str("service", "ez-api").
-		Logger()
-	log.Logger = logger
-	return logger
+	logger.Info("server exited properly")
 }