refactor: introduce structured logging abstraction

Author: pixel365

cmd/pulse/main.go

@@ -2,13 +2,14 @@ package main
 
 import (
 	"context"
-	"log"
 	"os"
 	"os/signal"
 	"syscall"
 
 	"github.com/joho/godotenv"
 
+	"github.com/pixel365/pulse/internal/logger"
+
 	checkrepo "github.com/pixel365/pulse/internal/repository/check"
 	checksvc "github.com/pixel365/pulse/internal/services/check"
 
@@ -17,23 +18,22 @@ import (
 	"github.com/pixel365/pulse/internal/config"
 )
 
-func init() {
-	_ = godotenv.Load()
-}
-
 func main() {
 	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
 	defer stop()
 
-	cfg := config.MustLoad()
+	_ = godotenv.Load()
 
+	cfg := config.MustLoad()
+	log := logger.NewSlog()
 	repo := checkrepo.NewStateRepository()
 	stateSvc := checksvc.NewStateService(repo)
 	checkHandlerSvc := checksvc.NewHandlerService(stateSvc)
 
-	runner := app.NewApp(cfg, checkHandlerSvc)
+	runner := app.NewApp(cfg, log, checkHandlerSvc)
 	if err := runner.Run(ctx); err != nil {
 		stop()
-		log.Fatalf("app run error: %v", err)
+		log.Error(ctx, "failed to run app", "error", err)
+		os.Exit(1)
 	}
 }

internal/app/app.go

@@ -5,6 +5,8 @@ import (
 
 	"golang.org/x/sync/errgroup"
 
+	"github.com/pixel365/pulse/internal/logger"
+
 	checksvc "github.com/pixel365/pulse/internal/services/check"
 
 	"github.com/pixel365/pulse/internal"
@@ -22,52 +24,74 @@ var _ internal.Runner = (*App)(nil)
 type App struct {
 	cfg             *config.Config
 	checkHandlerSvc checksvc.CheckHandlerService
+	logger          logger.Logger
 }
 
-func NewApp(cfg *config.Config, checkSvc checksvc.CheckHandlerService) *App {
+func NewApp(cfg *config.Config, logger logger.Logger, checkSvc checksvc.CheckHandlerService) *App {
 	return &App{
 		cfg:             cfg,
 		checkHandlerSvc: checkSvc,
+		logger:          logger,
 	}
 }
 
 func (a *App) Run(ctx context.Context) error {
 	g, ctx := errgroup.WithContext(ctx)
 
 	for i := range a.cfg.HttpChecks {
-		executor := internal.NewCheckExecutor(a.checkHandlerSvc, a.cfg.HttpChecks[i].CheckFields)
+		executor := internal.NewCheckExecutor(
+			a.checkHandlerSvc,
+			a.cfg.HttpChecks[i].CheckFields,
+			a.logger,
+		)
 		checker := http.NewChecker(a.cfg.HttpChecks[i], executor)
 		g.Go(func() error {
 			return checker.Check(ctx)
 		})
 	}
 
 	for i := range a.cfg.TCPChecks {
-		executor := internal.NewCheckExecutor(a.checkHandlerSvc, a.cfg.TCPChecks[i].CheckFields)
+		executor := internal.NewCheckExecutor(
+			a.checkHandlerSvc,
+			a.cfg.TCPChecks[i].CheckFields,
+			a.logger,
+		)
 		checker := tcp.NewChecker(a.cfg.TCPChecks[i], executor)
 		g.Go(func() error {
 			return checker.Check(ctx)
 		})
 	}
 
 	for i := range a.cfg.GRPCChecks {
-		executor := internal.NewCheckExecutor(a.checkHandlerSvc, a.cfg.GRPCChecks[i].CheckFields)
+		executor := internal.NewCheckExecutor(
+			a.checkHandlerSvc,
+			a.cfg.GRPCChecks[i].CheckFields,
+			a.logger,
+		)
 		checker := grpc.NewChecker(a.cfg.GRPCChecks[i], executor)
 		g.Go(func() error {
 			return checker.Check(ctx)
 		})
 	}
 
 	for i := range a.cfg.DNSChecks {
-		executor := internal.NewCheckExecutor(a.checkHandlerSvc, a.cfg.DNSChecks[i].CheckFields)
+		executor := internal.NewCheckExecutor(
+			a.checkHandlerSvc,
+			a.cfg.DNSChecks[i].CheckFields,
+			a.logger,
+		)
 		checker := dns.NewChecker(a.cfg.DNSChecks[i], executor)
 		g.Go(func() error {
 			return checker.Check(ctx)
 		})
 	}
 
 	for i := range a.cfg.TLSChecks {
-		executor := internal.NewCheckExecutor(a.checkHandlerSvc, a.cfg.TLSChecks[i].CheckFields)
+		executor := internal.NewCheckExecutor(
+			a.checkHandlerSvc,
+			a.cfg.TLSChecks[i].CheckFields,
+			a.logger,
+		)
 		checker := tls.NewChecker(a.cfg.TLSChecks[i], executor)
 		g.Go(func() error {
 			return checker.Check(ctx)

internal/executor.go

@@ -7,6 +7,7 @@ import (
 
 	"github.com/pixel365/pulse/internal/config"
 	"github.com/pixel365/pulse/internal/e"
+	"github.com/pixel365/pulse/internal/logger"
 	"github.com/pixel365/pulse/internal/model"
 	"github.com/pixel365/pulse/internal/services/check"
 )
@@ -19,6 +20,7 @@ var _ CheckExecutor = (*CheckExec)(nil)
 
 type CheckExec struct {
 	handler check.CheckHandlerService
+	logger  logger.Logger
 	cfg     config.CheckFields
 }
 
@@ -47,9 +49,8 @@ func (c *CheckExec) Execute(
 				SuccessThreshold: c.cfg.SuccessThreshold,
 			}
 
-			//nolint:staticcheck
 			if err := c.handler.Handle(ctx, policy, result); err != nil {
-				//TODO: log
+				c.logger.Error(ctx, "failed to handle check result", "error", err)
 			}
 		}
 	}
@@ -104,9 +105,11 @@ func (c *CheckExec) execute(
 func NewCheckExecutor(
 	handler check.CheckHandlerService,
 	cfg config.CheckFields,
+	logger logger.Logger,
 ) *CheckExec {
 	return &CheckExec{
 		handler: handler,
 		cfg:     cfg,
+		logger:  logger,
 	}
 }

internal/logger/logger.go

@@ -0,0 +1,12 @@
+package logger
+
+import (
+	"context"
+)
+
+type Logger interface {
+	Debug(context.Context, string, ...any)
+	Info(context.Context, string, ...any)
+	Warn(context.Context, string, ...any)
+	Error(context.Context, string, ...any)
+}

internal/logger/slog.go

@@ -0,0 +1,55 @@
+package logger
+
+import (
+	"context"
+	"log/slog"
+	"os"
+	"strconv"
+)
+
+var _ Logger = (*Slog)(nil)
+
+type Slog struct {
+	logger *slog.Logger
+	debug  bool
+}
+
+func (l *Slog) Debug(ctx context.Context, msg string, args ...any) {
+	if l == nil || !l.debug {
+		return
+	}
+
+	l.logger.DebugContext(ctx, msg, args...)
+}
+
+func (l *Slog) Info(ctx context.Context, msg string, args ...any) {
+	if l == nil {
+		return
+	}
+
+	l.logger.InfoContext(ctx, msg, args...)
+}
+
+func (l *Slog) Warn(ctx context.Context, msg string, args ...any) {
+	if l == nil {
+		return
+	}
+
+	l.logger.WarnContext(ctx, msg, args...)
+}
+
+func (l *Slog) Error(ctx context.Context, msg string, args ...any) {
+	if l == nil {
+		return
+	}
+
+	l.logger.ErrorContext(ctx, msg, args...)
+}
+
+func NewSlog() *Slog {
+	debug, _ := strconv.ParseBool(os.Getenv("DEBUG"))
+	return &Slog{
+		logger: slog.New(slog.NewJSONHandler(os.Stdout, nil)),
+		debug:  debug,
+	}
+}