querycheck: switch from zap to log/slog

cmd/querycheck/main.go

···
 	"context"
 	"fmt"
 	"log"
+	"log/slog"
 	"os"
 	"os/signal"
 	"sync"
···
 
 	"github.com/prometheus/client_golang/prometheus/promhttp"
 	"go.opentelemetry.io/otel/trace"
-	"go.uber.org/zap"
 
 	"github.com/carlmjohnson/versioninfo"
 	"github.com/urfave/cli/v2"
···
 	signals := make(chan os.Signal, 1)
 	signal.Notify(signals, syscall.SIGINT, syscall.SIGTERM)
 
-	rawlog, err := zap.NewDevelopment()
-	if err != nil {
-		log.Fatalf("failed to create logger: %+v\n", err)
-	}
+	logger := slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{
+		Level: slog.LevelInfo,
+	}))
 	defer func() {
-		log.Printf("main function teardown\n")
-		err := rawlog.Sync()
-		if err != nil {
-			log.Printf("failed to sync logger on teardown: %+v", err.Error())
-		}
+		logger.Info("main function teardown")
 	}()
 
-	log := rawlog.Sugar().With("source", "querycheck_main")
-
-	log.Info("starting querycheck")
+	logger = logger.With("source", "querycheck_main")
+	logger.Info("starting querycheck")
 
 	// Registers a tracer Provider globally if the exporter endpoint is set
 	if os.Getenv("OTEL_EXPORTER_OTLP_ENDPOINT") != "" {
-		log.Info("initializing tracer...")
+		logger.Info("initializing tracer")
 		shutdown, err := tracing.InstallExportPipeline(ctx, "Querycheck", 1)
 		if err != nil {
 			log.Fatal(err)
···
 	// Start the metrics server
 	wg.Add(1)
 	go func() {
-		log.Infof("starting metrics server on port %d", cctx.Int("port"))
+		logger.Info("starting metrics serverd", "port", cctx.Int("port"))
 		if err := e.Start(fmt.Sprintf(":%d", cctx.Int("port"))); err != nil {
-			log.Errorf("failed to start metrics server: %+v\n", err)
+			logger.Error("failed to start metrics server", "err", err)
 		}
 		wg.Done()
 	}()
···
 		fmt.Println("shutting down on context done")
 	}
 
-	log.Info("shutting down, waiting for workers to clean up...")
+	logger.Info("shutting down, waiting for workers to clean up")
 
 	if err := e.Shutdown(ctx); err != nil {
-		log.Errorf("failed to shut down metrics server: %+v\n", err)
+		logger.Error("failed to shut down metrics server", "err", err)
 		wg.Done()
 	}
 
 	querychecker.Stop()
 
 	wg.Wait()
-	log.Info("shut down successfully")
+	logger.Info("shut down successfully")
 
 	return nil
 }

querycheck/check.go

···
 
 import (
 	"context"
-	"log"
+	"fmt"
+	"log/slog"
 	"math"
+	"os"
 	"sync"
 	"time"
 
 	"github.com/jackc/pgx/v5"
 	"go.opentelemetry.io/otel"
 	"go.opentelemetry.io/otel/attribute"
-	"go.uber.org/zap"
 )
 
 var tracer = otel.Tracer("querycheck")
···
 // Querychecker is a query checker meta object
 type Querychecker struct {
 	Queries []*Query
-	Logger  *zap.SugaredLogger
+	Logger  *slog.Logger
 
 	connectionURL string
 	lk            sync.RWMutex
···
 
 // NewQuerychecker creates a new querychecker
 func NewQuerychecker(ctx context.Context, connectionURL string) (*Querychecker, error) {
-	logger, err := zap.NewDevelopment()
-	if err != nil {
-		return nil, err
-	}
-	l := logger.Sugar().With("source", "querychecker_manager")
+	logger := slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{
+		Level: slog.LevelInfo,
+	}))
+	logger = logger.With("source", "querychecker_manager")
 
 	return &Querychecker{
 		connectionURL: connectionURL,
-		Logger:        l,
+		Logger:        logger,
 		Queries:       []*Query{},
 	}, nil
 }
···
 
 	for _, qu := range q.Queries {
 		go func(query *Query) {
-			rawlog, err := zap.NewDevelopment()
-			if err != nil {
-				log.Fatalf("failed to create logger: %+v\n", err)
-			}
-			log := rawlog.Sugar().With("source", "query_checker_routine", "query", query.Name)
+			log := q.Logger.With("source", "query_checker_routine", "query", query.Name)
 
-			log.Infof("query checker routine started for query: %s\n", query.Name)
-			log.Infof("Query: \n%s\n", query.Query)
+			log.Info("query checker routine started for query", "query", query.Name)
+			log.Info(fmt.Sprintf("Query: \n%s\n", query.Query))
 
 			// Check the query plan every CheckEvery duration
 			ticker := time.NewTicker(query.CheckEvery)
 			defer ticker.Stop()
 
+			var err error
 			query.LatestPlan, err = q.CheckQueryPlan(ctx, query.Query)
 			if err != nil {
-				log.Errorf("failed to check query plan: %+v\n", err)
+				log.Error("failed to check query plan", "err", err)
 			}
 
 			if query.LatestPlan != nil {
-				log.Infof("Initial plan:\n%+v\n", query.LatestPlan.String())
+				log.Info(fmt.Sprintf("Initial plan:\n%+v\n", query.LatestPlan.String()))
 				query.RecordPlanMetrics(*query.LatestPlan)
 				query.LastChecked = time.Now()
 			}
···
 
 					if err != nil || qp == nil {
 						if qp == nil {
-							log.Errorf("query plan is nil")
+							log.Error("query plan is nil")
 						}
-						log.Errorf("failed to check query plan: %+v\n", err)
+						log.Error("failed to check query plan", "err", err)
 						errorCounter.WithLabelValues(query.Name).Inc()
 						continue
 					}
···
 							sign = "-"
 						}
 
-						log.Infof("query plan has changed (%s%.03fms): \n%+v\n", sign, diff, qp.String())
+						log.Info("query plan has changed", "diff", fmt.Sprintf("%s%.03fms", sign, diff), "query_plan", qp.String())
 
 						query.lk.Lock()
 						query.PreviousPlan = query.LatestPlan