refactor: standardize logging keys across the codebase

internal/api/server.go

@@ -11,6 +11,7 @@ import (
 	"time"
 
 	"github.com/RedBoardDev/gh-runners-tool/v2/internal/health"
+	"github.com/RedBoardDev/gh-runners-tool/v2/internal/logging"
 	"github.com/RedBoardDev/gh-runners-tool/v2/internal/model"
 	"github.com/RedBoardDev/gh-runners-tool/v2/internal/state"
 )
@@ -68,7 +69,7 @@ func (s *Server) Run(ctx context.Context) error {
 
 	defer func() {
 		if cleanupErr := os.Remove(s.socketPath); cleanupErr != nil && !os.IsNotExist(cleanupErr) {
-			s.logger.Warn("failed to remove socket file", "path", s.socketPath, "error", cleanupErr)
+			s.logger.Warn("failed to remove socket file", logging.KeyPath, s.socketPath, logging.KeyError, cleanupErr)
 		}
 	}()
 

internal/cli/daemon.go

@@ -49,7 +49,7 @@ func buildDaemon(cfg *config.Config, creds *auth.Credentials, githubURL string)
 	}
 
 	if err := logMgr.CleanupOldLogs(); err != nil {
-		logger.Warn("log cleanup failed", "error", err)
+		logger.Warn("log cleanup failed", logging.KeyError, err)
 	}
 
 	ghClient, err := github.NewClient(creds, githubURL)
@@ -62,7 +62,7 @@ func buildDaemon(cfg *config.Config, creds *auth.Credentials, githubURL string)
 	processMgr := runner.NewProcessManager(cfg.Runner.WorkdirBase, logger)
 
 	if err := processMgr.CleanupStale(context.Background()); err != nil {
-		logger.Warn("stale runner cleanup failed", "error", err)
+		logger.Warn("stale runner cleanup failed", logging.KeyError, err)
 	}
 	processMgr.KillOrphanRunners(context.Background())
 

internal/controller/controller.go

@@ -105,7 +105,7 @@ func (c *GroupController) Shutdown(ctx context.Context) {
 	c.mu.Unlock()
 
 	for name, s := range scalers {
-		c.logger.InfoContext(ctx, "shutting down scaler", "group", name)
+		c.logger.InfoContext(ctx, "shutting down scaler", logging.KeyGroup, name)
 		s.Shutdown(ctx)
 	}
 }

internal/controller/group.go

@@ -10,6 +10,7 @@ import (
 	"time"
 
 	"github.com/RedBoardDev/gh-runners-tool/v2/internal/config"
+	"github.com/RedBoardDev/gh-runners-tool/v2/internal/logging"
 	"github.com/actions/scaleset"
 )
 
@@ -44,8 +45,8 @@ func (c *GroupController) runGroup(ctx context.Context, group *config.GroupConfi
 		}
 
 		groupLogger.ErrorContext(ctx, "group listener failed, retrying",
-			"group", group.Name,
-			"error", err,
+			logging.KeyGroup, group.Name,
+			logging.KeyError, err,
 			"backoff", backoff,
 		)
 
@@ -84,8 +85,8 @@ func (c *GroupController) runGroupOnce(
 		closeCtx := context.WithoutCancel(ctx)
 		if closeErr := session.Close(closeCtx); closeErr != nil {
 			groupLogger.DebugContext(ctx, "session close",
-				"group", group.Name,
-				"error", closeErr,
+				logging.KeyGroup, group.Name,
+				logging.KeyError, closeErr,
 			)
 		}
 	}()
@@ -104,7 +105,7 @@ func (c *GroupController) runGroupOnce(
 	}
 
 	groupLogger.InfoContext(ctx, "group listener started",
-		"group", group.Name,
+		logging.KeyGroup, group.Name,
 		"scale_set_id", ss.ID,
 	)
 
@@ -118,9 +119,9 @@ func (c *GroupController) runGroupOnce(
 		deleteErr := c.client.DeleteScaleSet(cleanupCtx, ss.ID)
 		if deleteErr != nil {
 			groupLogger.WarnContext(ctx, "failed to delete scale set on shutdown",
-				"group", group.Name,
+				logging.KeyGroup, group.Name,
 				"scale_set_id", ss.ID,
-				"error", deleteErr,
+				logging.KeyError, deleteErr,
 			)
 		}
 		return context.Canceled
@@ -134,7 +135,7 @@ func (c *GroupController) resolveScaleSet(ctx context.Context, name string, labe
 	if err == nil && ss != nil {
 		if labelsChanged(ss.Labels, labels) {
 			c.logger.WarnContext(ctx, "scale set label mismatch detected, delete and recreate to update",
-				"group", name,
+				logging.KeyGroup, name,
 				"scale_set_id", ss.ID,
 			)
 		}

internal/controller/scaler.go

@@ -80,8 +80,8 @@ func (s *MacOSScaler) HandleDesiredRunnerCount(ctx context.Context, count int) (
 	for i := 0; i < target-current; i++ {
 		if err := s.startRunner(ctx); err != nil {
 			s.logger.ErrorContext(ctx, "failed to start runner",
-				"group", s.groupName,
-				"error", err,
+				logging.KeyGroup, s.groupName,
+				logging.KeyError, err,
 			)
 		}
 	}
@@ -96,8 +96,8 @@ func (s *MacOSScaler) HandleJobStarted(ctx context.Context, jobInfo *scaleset.Jo
 	proc, ok := s.idle[jobInfo.RunnerName]
 	if !ok {
 		s.logger.WarnContext(ctx, "job started for unknown runner",
-			"runner", jobInfo.RunnerName,
-			"group", s.groupName,
+			logging.KeyRunner, jobInfo.RunnerName,
+			logging.KeyGroup, s.groupName,
 		)
 		return nil
 	}
@@ -106,8 +106,8 @@ func (s *MacOSScaler) HandleJobStarted(ctx context.Context, jobInfo *scaleset.Jo
 	s.busy[jobInfo.RunnerName] = proc
 
 	s.logger.InfoContext(ctx, "job started",
-		"runner", jobInfo.RunnerName,
-		"group", s.groupName,
+		logging.KeyRunner, jobInfo.RunnerName,
+		logging.KeyGroup, s.groupName,
 		"job", jobInfo.JobDisplayName,
 	)
 
@@ -137,27 +137,27 @@ func (s *MacOSScaler) HandleJobCompleted(ctx context.Context, jobInfo *scaleset.
 		stopErr := s.process.Stop(ctx, proc)
 		if stopErr != nil {
 			s.logger.WarnContext(ctx, "failed to stop runner",
-				"runner", jobInfo.RunnerName,
-				"error", stopErr,
+				logging.KeyRunner, jobInfo.RunnerName,
+				logging.KeyError, stopErr,
 			)
 		}
 		cleanupErr := s.process.Cleanup(proc)
 		if cleanupErr != nil {
 			s.logger.WarnContext(ctx, "failed to cleanup runner",
-				"runner", jobInfo.RunnerName,
-				"error", cleanupErr,
+				logging.KeyRunner, jobInfo.RunnerName,
+				logging.KeyError, cleanupErr,
 			)
 		}
 		if logsErr := s.logMgr.RemoveRunnerLogs(s.groupName, jobInfo.RunnerName); logsErr != nil {
 			s.logger.WarnContext(ctx, "failed to remove runner log dir",
-				"runner", jobInfo.RunnerName,
-				"error", logsErr,
+				logging.KeyRunner, jobInfo.RunnerName,
+				logging.KeyError, logsErr,
 			)
 		}
 	} else {
 		s.logger.WarnContext(ctx, "job completed for unknown runner",
-			"runner", jobInfo.RunnerName,
-			"group", s.groupName,
+			logging.KeyRunner, jobInfo.RunnerName,
+			logging.KeyGroup, s.groupName,
 		)
 	}
 
@@ -167,8 +167,8 @@ func (s *MacOSScaler) HandleJobCompleted(ctx context.Context, jobInfo *scaleset.
 	}
 
 	logArgs := []any{
-		"runner", jobInfo.RunnerName,
-		"group", s.groupName,
+		logging.KeyRunner, jobInfo.RunnerName,
+		logging.KeyGroup, s.groupName,
 		"result", jobInfo.Result,
 	}
 	if !jobInfo.FinishTime.IsZero() && !jobInfo.RunnerAssignTime.IsZero() {

internal/controller/scaler_ops.go

@@ -6,6 +6,7 @@ import (
 	"encoding/hex"
 	"fmt"
 
+	"github.com/RedBoardDev/gh-runners-tool/v2/internal/logging"
 	"github.com/RedBoardDev/gh-runners-tool/v2/internal/model"
 	"github.com/RedBoardDev/gh-runners-tool/v2/internal/runner"
 )
@@ -45,9 +46,9 @@ func (s *MacOSScaler) startRunner(ctx context.Context) error {
 	s.idle[name] = proc
 
 	s.logger.InfoContext(ctx, "runner provisioned",
-		"runner", name,
-		"group", s.groupName,
-		"pid", proc.PID,
+		logging.KeyRunner, name,
+		logging.KeyGroup, s.groupName,
+		logging.KeyPID, proc.PID,
 	)
 
 	return nil
@@ -70,8 +71,8 @@ func (s *MacOSScaler) killRunner(ctx context.Context, runnerName string) error {
 	stopErr := s.process.Stop(ctx, proc)
 	if stopErr != nil {
 		s.logger.WarnContext(ctx, "failed to stop runner during kill",
-			"runner", runnerName,
-			"error", stopErr,
+			logging.KeyRunner, runnerName,
+			logging.KeyError, stopErr,
 		)
 	}
 
@@ -82,12 +83,12 @@ func (s *MacOSScaler) killRunner(ctx context.Context, runnerName string) error {
 
 	if logsErr := s.logMgr.RemoveRunnerLogs(s.groupName, runnerName); logsErr != nil {
 		s.logger.WarnContext(ctx, "failed to remove runner log dir",
-			"runner", runnerName,
-			"error", logsErr,
+			logging.KeyRunner, runnerName,
+			logging.KeyError, logsErr,
 		)
 	}
 
-	s.logger.InfoContext(ctx, "killed runner", "runner", runnerName, "group", s.groupName)
+	s.logger.InfoContext(ctx, "killed runner", logging.KeyRunner, runnerName, logging.KeyGroup, s.groupName)
 	return nil
 }
 
@@ -108,21 +109,21 @@ func (s *MacOSScaler) Shutdown(ctx context.Context) {
 		stopErr := s.process.Stop(ctx, proc)
 		if stopErr != nil {
 			s.logger.WarnContext(ctx, "failed to stop runner during shutdown",
-				"runner", proc.Name,
-				"error", stopErr,
+				logging.KeyRunner, proc.Name,
+				logging.KeyError, stopErr,
 			)
 		}
 		cleanupErr := s.process.Cleanup(proc)
 		if cleanupErr != nil {
 			s.logger.WarnContext(ctx, "failed to cleanup runner during shutdown",
-				"runner", proc.Name,
-				"error", cleanupErr,
+				logging.KeyRunner, proc.Name,
+				logging.KeyError, cleanupErr,
 			)
 		}
 		if logsErr := s.logMgr.RemoveRunnerLogs(s.groupName, proc.Name); logsErr != nil {
 			s.logger.WarnContext(ctx, "failed to remove runner log dir during shutdown",
-				"runner", proc.Name,
-				"error", logsErr,
+				logging.KeyRunner, proc.Name,
+				logging.KeyError, logsErr,
 			)
 		}
 	}

internal/health/checks.go

@@ -6,6 +6,7 @@ import (
 	"syscall"
 	"time"
 
+	"github.com/RedBoardDev/gh-runners-tool/v2/internal/logging"
 	"github.com/RedBoardDev/gh-runners-tool/v2/internal/model"
 )
 
@@ -105,7 +106,7 @@ func (m *Monitor) checkRunnerLiveness(ctx context.Context, group string, snapsho
 			})
 			if m.killer != nil {
 				if killErr := m.killer.KillRunner(ctx, group, snap.Name); killErr != nil {
-					m.logger.ErrorContext(ctx, "failed to kill zombie runner", "group", group, "runner", snap.Name, "error", killErr)
+					m.logger.ErrorContext(ctx, "failed to kill zombie runner", logging.KeyGroup, group, logging.KeyRunner, snap.Name, logging.KeyError, killErr)
 				}
 			}
 		}
@@ -138,7 +139,7 @@ func (m *Monitor) checkRunnerTimeouts(ctx context.Context, group string, snapsho
 		})
 		if m.killer != nil {
 			if killErr := m.killer.KillRunner(ctx, group, snap.Name); killErr != nil {
-				m.logger.ErrorContext(ctx, "failed to kill timed-out runner", "group", group, "runner", snap.Name, "error", killErr)
+				m.logger.ErrorContext(ctx, "failed to kill timed-out runner", logging.KeyGroup, group, logging.KeyRunner, snap.Name, logging.KeyError, killErr)
 			}
 		}
 	}
@@ -187,7 +188,7 @@ func (m *Monitor) checkIdleTimeouts(ctx context.Context, group string, snapshots
 		})
 		if m.killer != nil {
 			if killErr := m.killer.KillRunner(ctx, group, snap.Name); killErr != nil {
-				m.logger.ErrorContext(ctx, "failed to kill idle runner", "group", group, "runner", snap.Name, "error", killErr)
+				m.logger.ErrorContext(ctx, "failed to kill idle runner", logging.KeyGroup, group, logging.KeyRunner, snap.Name, logging.KeyError, killErr)
 			}
 		}
 		killable--

internal/health/checks_disk.go

@@ -5,6 +5,7 @@ import (
 	"syscall"
 	"time"
 
+	"github.com/RedBoardDev/gh-runners-tool/v2/internal/logging"
 	"github.com/RedBoardDev/gh-runners-tool/v2/internal/model"
 )
 
@@ -15,7 +16,7 @@ func (m *Monitor) checkDiskSpace() {
 
 	var stat syscall.Statfs_t
 	if err := syscall.Statfs("/", &stat); err != nil {
-		m.logger.Warn("failed to check disk space", "error", err)
+		m.logger.Warn("failed to check disk space", logging.KeyError, err)
 		return
 	}
 

internal/logging/keys.go

@@ -0,0 +1,18 @@
+package logging
+
+const (
+	KeyComponent = "component"
+	KeyGroup     = "group"
+	KeyRunner    = "runner"
+	KeyError     = "error"
+	KeyPID       = "pid"
+	KeyVersion   = "version"
+	KeyPath      = "path"
+	KeyDir       = "dir"
+)
+
+const (
+	ComponentDaemon = "daemon"
+	ComponentGroup  = "group"
+	ComponentRunner = "runner"
+)

internal/logging/manager.go

@@ -87,7 +87,7 @@ func (m *LogManager) DaemonLogger() (*slog.Logger, error) {
 		return nil, fmt.Errorf("logging: daemon file handler: %w", err)
 	}
 	multi := NewMultiHandler(daemonFileH, m.consoleHandler())
-	return slog.New(multi).With("component", "daemon"), nil
+	return slog.New(multi).With(KeyComponent, ComponentDaemon), nil
 }
 
 func (m *LogManager) GroupLogger(group string) (*slog.Logger, error) {
@@ -103,7 +103,7 @@ func (m *LogManager) GroupLogger(group string) (*slog.Logger, error) {
 	}
 
 	multi := NewMultiHandler(groupFileH, daemonFileH, m.consoleHandler())
-	return slog.New(multi).With("component", "group", "group", group), nil
+	return slog.New(multi).With(KeyComponent, ComponentGroup, KeyGroup, group), nil
 }
 
 func (m *LogManager) RunnerLogger(group, runner string) (*slog.Logger, error) {
@@ -125,7 +125,7 @@ func (m *LogManager) RunnerLogger(group, runner string) (*slog.Logger, error) {
 	}
 
 	multi := NewMultiHandler(runnerFileH, groupFileH, daemonFileH, m.consoleHandler())
-	return slog.New(multi).With("component", "runner", "group", group, "runner", runner), nil
+	return slog.New(multi).With(KeyComponent, ComponentRunner, KeyGroup, group, KeyRunner, runner), nil
 }
 
 func (m *LogManager) RunnerOutputFile(group, runner string) (io.WriteCloser, error) {

internal/monitoring/uptimekuma.go

@@ -8,6 +8,8 @@ import (
 	"net/url"
 	"strings"
 	"time"
+
+	"github.com/RedBoardDev/gh-runners-tool/v2/internal/logging"
 )
 
 type UptimeKumaConfig struct {
@@ -44,7 +46,7 @@ func (u *UptimeKuma) ReportDaemonHealth(ctx context.Context, groups, totalActual
 
 	pushErr := u.push(ctx, u.cfg.DaemonToken, "up", msg, ping)
 	if pushErr != nil {
-		u.logger.Warn("uptime-kuma daemon push failed", "error", pushErr)
+		u.logger.Warn("uptime-kuma daemon push failed", logging.KeyError, pushErr)
 	}
 }
 
@@ -62,7 +64,7 @@ func (u *UptimeKuma) ReportGroupHealth(ctx context.Context, group string, actual
 
 	pushErr := u.push(ctx, token, status, msg, ping)
 	if pushErr != nil {
-		u.logger.Warn("uptime-kuma group push failed", "group", group, "error", pushErr)
+		u.logger.Warn("uptime-kuma group push failed", logging.KeyGroup, group, logging.KeyError, pushErr)
 	}
 }