Refactor logging

cmd/server/main.go

@@ -4,18 +4,21 @@ import (
 	"context"
 	"flag"
 	"fmt"
-	"log"
 	"net"
 	"os"
 	"os/signal"
 	"syscall"
 	"time"
 
+	"github.com/grpc-ecosystem/go-grpc-middleware/v2/interceptors/logging"
 	"github.com/jackc/pgx/v5/pgxpool"
+	"github.com/rs/zerolog/log"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/reflection"
 
 	"github.com/metadata-agregator/internal/config"
+	applog "github.com/metadata-agregator/internal/logging"
+	"github.com/metadata-agregator/internal/metrics"
 	"github.com/metadata-agregator/internal/provider/musicbrainz"
 	"github.com/metadata-agregator/internal/repository/postgres"
 	"github.com/metadata-agregator/internal/server"
@@ -29,30 +32,54 @@ func main() {
 
 	cfg, err := config.Load(*configPath)
 	if err != nil {
-		log.Fatalf("failed to load config: %v", err)
+		fmt.Fprintf(os.Stderr, "failed to load config: %v\n", err)
+		os.Exit(1)
 	}
 
-	ctx := context.Background()
+	applog.Init(cfg.Logging)
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
 
 	services, cleanup := buildServices(ctx, cfg)
 	defer cleanup()
 
+	srvMetrics := metrics.NewServerMetrics()
+
 	addr := fmt.Sprintf(":%d", cfg.Server.Port)
 
 	lis, err := net.Listen("tcp", addr)
 	if err != nil {
-		log.Fatalf("failed to listen: %v", err)
+		log.Fatal().Err(err).Str("addr", addr).Msg("failed to listen")
 	}
 
-	grpcServer := grpc.NewServer()
+	grpcServer := grpc.NewServer(
+		grpc.ChainUnaryInterceptor(
+			applog.RequestIDInterceptor(),
+			applog.PeerInfoInterceptor(),
+			srvMetrics.UnaryServerInterceptor(),
+			logging.UnaryServerInterceptor(applog.InterceptorLogger(), applog.LoggingOpts()...),
+		),
+		grpc.ChainStreamInterceptor(
+			applog.StreamRequestIDInterceptor(),
+			srvMetrics.StreamServerInterceptor(),
+			logging.StreamServerInterceptor(applog.InterceptorLogger(), applog.LoggingOpts()...),
+		),
+	)
 	metadatav1.RegisterMetadataServiceServer(grpcServer, server.NewMetadataServer(services))
 	reflection.Register(grpcServer)
 
-	go gracefulShutdown(grpcServer)
+	srvMetrics.InitializeMetrics(grpcServer)
 
-	log.Printf("gRPC server listening on %s", addr)
+	if cfg.Metrics.Enabled {
+		go srvMetrics.StartHTTPServer(ctx, cfg.Metrics.Port)
+	}
+
+	go gracefulShutdown(grpcServer, cancel)
+
+	log.Info().Str("addr", addr).Msg("gRPC server listening")
 	if err := grpcServer.Serve(lis); err != nil {
-		log.Fatalf("failed to serve: %v", err)
+		log.Fatal().Err(err).Msg("failed to serve")
 	}
 }
 
@@ -66,7 +93,7 @@ func buildServices(ctx context.Context, cfg *config.Config) (map[metadatav1.Prov
 	}
 
 	if dbURL == "" {
-		log.Println("no database configured, running in provider-only mode")
+		log.Warn().Msg("no database configured, running in provider-only mode")
 		services[metadatav1.Provider_PROVIDER_MUSICBRAINZ] = service.NewMetadataService(
 			&noopArtistRepo{},
 			&noopAlbumRepo{},
@@ -78,7 +105,7 @@ func buildServices(ctx context.Context, cfg *config.Config) (map[metadatav1.Prov
 
 	pool, err := connectDB(ctx, dbURL)
 	if err != nil {
-		log.Fatalf("database connection failed: %v", err)
+		log.Fatal().Err(err).Msg("database connection failed")
 	}
 
 	artistRepo := postgres.NewArtistRepository(pool)
@@ -92,7 +119,7 @@ func buildServices(ctx context.Context, cfg *config.Config) (map[metadatav1.Prov
 		mb,
 	)
 
-	log.Println("database connected, caching enabled")
+	log.Info().Msg("database connected, caching enabled")
 	return services, func() { pool.Close() }
 }
 
@@ -100,15 +127,17 @@ func connectDB(ctx context.Context, dbURL string) (*pgxpool.Pool, error) {
 	ctx, cancel := context.WithTimeout(ctx, 10*time.Second)
 	defer cancel()
 
-	config, err := pgxpool.ParseConfig(dbURL)
+	pgxCfg, err := pgxpool.ParseConfig(dbURL)
 	if err != nil {
 		return nil, err
 	}
 
-	config.MaxConns = 10
-	config.MinConns = 2
+	pgxCfg.MaxConns = 10
+	pgxCfg.MinConns = 2
 
-	pool, err := pgxpool.NewWithConfig(ctx, config)
+	log.Debug().Msg("connecting to database")
+
+	pool, err := pgxpool.NewWithConfig(ctx, pgxCfg)
 	if err != nil {
 		return nil, err
 	}
@@ -121,10 +150,11 @@ func connectDB(ctx context.Context, dbURL string) (*pgxpool.Pool, error) {
 	return pool, nil
 }
 
-func gracefulShutdown(server *grpc.Server) {
+func gracefulShutdown(srv *grpc.Server, cancel context.CancelFunc) {
 	sigCh := make(chan os.Signal, 1)
 	signal.Notify(sigCh, syscall.SIGINT, syscall.SIGTERM)
-	<-sigCh
-	log.Println("shutting down...")
-	server.GracefulStop()
+	sig := <-sigCh
+	log.Info().Str("signal", sig.String()).Msg("shutting down")
+	cancel()
+	srv.GracefulStop()
 }