diff --git a/internal/api/server.go b/internal/api/server.go index 0b082ce..629fd64 100644 --- a/internal/api/server.go +++ b/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) } }() diff --git a/internal/cli/daemon.go b/internal/cli/daemon.go index 01e3f22..bb78ea8 100644 --- a/internal/cli/daemon.go +++ b/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()) diff --git a/internal/controller/controller.go b/internal/controller/controller.go index 0624341..22da71a 100644 --- a/internal/controller/controller.go +++ b/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) } } diff --git a/internal/controller/group.go b/internal/controller/group.go index 9934e10..919d752 100644 --- a/internal/controller/group.go +++ b/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, ) } diff --git a/internal/controller/scaler.go b/internal/controller/scaler.go index 00d4acf..4a88759 100644 --- a/internal/controller/scaler.go +++ b/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() { diff --git a/internal/controller/scaler_ops.go b/internal/controller/scaler_ops.go index 26f790a..f10430c 100644 --- a/internal/controller/scaler_ops.go +++ b/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, ) } } diff --git a/internal/health/checks.go b/internal/health/checks.go index ecbc685..d3d6bd5 100644 --- a/internal/health/checks.go +++ b/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-- diff --git a/internal/health/checks_disk.go b/internal/health/checks_disk.go index 68665d2..a022b54 100644 --- a/internal/health/checks_disk.go +++ b/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 } diff --git a/internal/logging/keys.go b/internal/logging/keys.go new file mode 100644 index 0000000..42d6830 --- /dev/null +++ b/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" +) diff --git a/internal/logging/manager.go b/internal/logging/manager.go index 5b4ccb2..d7ffeca 100644 --- a/internal/logging/manager.go +++ b/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) { diff --git a/internal/monitoring/uptimekuma.go b/internal/monitoring/uptimekuma.go index 1803037..c7acff2 100644 --- a/internal/monitoring/uptimekuma.go +++ b/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) } } diff --git a/internal/notification/service.go b/internal/notification/service.go index 40e4f33..ee4544a 100644 --- a/internal/notification/service.go +++ b/internal/notification/service.go @@ -4,6 +4,7 @@ import ( "context" "log/slog" + "github.com/RedBoardDev/gh-runners-tool/v2/internal/logging" "github.com/RedBoardDev/gh-runners-tool/v2/internal/model" ) @@ -47,7 +48,7 @@ func (s *Service) Notify(ctx context.Context, event *model.Event) { s.logger.Warn("notification send failed", "provider", entry.provider.Name(), "event", event.Type, - "error", err, + logging.KeyError, err, ) } } diff --git a/internal/runner/binary.go b/internal/runner/binary.go index efdd7b3..05b469c 100644 --- a/internal/runner/binary.go +++ b/internal/runner/binary.go @@ -13,6 +13,8 @@ import ( "strings" "sync" "time" + + "github.com/RedBoardDev/gh-runners-tool/v2/internal/logging" ) type BinaryManager struct { @@ -40,7 +42,7 @@ func (m *BinaryManager) EnsureBits(ctx context.Context, version string) (string, return "", fmt.Errorf("resolve latest runner version: %w", err) } resolved = v - m.logger.InfoContext(ctx, "resolved latest runner version", "version", resolved) + m.logger.InfoContext(ctx, "resolved latest runner version", logging.KeyVersion, resolved) } mu := m.lockFor(resolved) @@ -51,18 +53,18 @@ func (m *BinaryManager) EnsureBits(ctx context.Context, version string) (string, marker := filepath.Join(destDir, ".complete") if _, err := os.Stat(marker); err == nil { - m.logger.DebugContext(ctx, "runner binary cached", "version", resolved, "path", destDir) + m.logger.DebugContext(ctx, "runner binary cached", logging.KeyVersion, resolved, logging.KeyPath, destDir) return destDir, nil } if _, err := os.Stat(destDir); err == nil { - m.logger.WarnContext(ctx, "removing incomplete runner cache", "version", resolved, "path", destDir) + m.logger.WarnContext(ctx, "removing incomplete runner cache", logging.KeyVersion, resolved, logging.KeyPath, destDir) if rmErr := os.RemoveAll(destDir); rmErr != nil { return "", fmt.Errorf("clean stale cache %s: %w", destDir, rmErr) } } - m.logger.InfoContext(ctx, "downloading runner binary", "version", resolved) + m.logger.InfoContext(ctx, "downloading runner binary", logging.KeyVersion, resolved) if err := os.MkdirAll(destDir, 0o755); err != nil { return "", fmt.Errorf("create cache dir %s: %w", destDir, err) @@ -70,22 +72,22 @@ func (m *BinaryManager) EnsureBits(ctx context.Context, version string) (string, if err := downloadAndExtract(ctx, m.httpClient, resolved, destDir); err != nil { if rmErr := os.RemoveAll(destDir); rmErr != nil { - m.logger.WarnContext(ctx, "failed to clean partial download", "path", destDir, "error", rmErr) + m.logger.WarnContext(ctx, "failed to clean partial download", logging.KeyPath, destDir, logging.KeyError, rmErr) } return "", fmt.Errorf("download runner %s: %w", resolved, err) } if err := os.WriteFile(marker, nil, 0o644); err != nil { if rmErr := os.RemoveAll(destDir); rmErr != nil { - m.logger.WarnContext(ctx, "failed to clean cache after marker write", "path", destDir, "error", rmErr) + m.logger.WarnContext(ctx, "failed to clean cache after marker write", logging.KeyPath, destDir, logging.KeyError, rmErr) } return "", fmt.Errorf("write completion marker %s: %w", marker, err) } - m.logger.InfoContext(ctx, "runner binary ready", "version", resolved, "path", destDir) + m.logger.InfoContext(ctx, "runner binary ready", logging.KeyVersion, resolved, logging.KeyPath, destDir) if err := m.gcOldVersions(ctx, resolved); err != nil { - m.logger.WarnContext(ctx, "cache GC failed", "error", err) + m.logger.WarnContext(ctx, "cache GC failed", logging.KeyError, err) } return destDir, nil @@ -128,10 +130,10 @@ func (m *BinaryManager) gcOldVersions(ctx context.Context, keep string) error { for _, victim := range completed[cacheKeepVersions-1:] { path := filepath.Join(m.cacheDir, victim.name) if rmErr := os.RemoveAll(path); rmErr != nil { - m.logger.WarnContext(ctx, "failed to remove old runner cache", "path", path, "error", rmErr) + m.logger.WarnContext(ctx, "failed to remove old runner cache", logging.KeyPath, path, logging.KeyError, rmErr) continue } - m.logger.InfoContext(ctx, "removed old runner cache", "version", victim.name) + m.logger.InfoContext(ctx, "removed old runner cache", logging.KeyVersion, victim.name) } return nil } diff --git a/internal/runner/cleanup.go b/internal/runner/cleanup.go index a4944b9..0554a7d 100644 --- a/internal/runner/cleanup.go +++ b/internal/runner/cleanup.go @@ -9,6 +9,8 @@ import ( "strconv" "strings" "syscall" + + "github.com/RedBoardDev/gh-runners-tool/v2/internal/logging" ) func (m *ProcessManager) CleanupStale(ctx context.Context) error { @@ -25,7 +27,7 @@ func (m *ProcessManager) CleanupStale(ctx context.Context) error { continue } if err := m.cleanupStaleGroup(ctx, groupEntry.Name()); err != nil { - m.logger.WarnContext(ctx, "failed to cleanup stale group", "group", groupEntry.Name(), "error", err) + m.logger.WarnContext(ctx, "failed to cleanup stale group", logging.KeyGroup, groupEntry.Name(), logging.KeyError, err) } } @@ -55,33 +57,33 @@ func (m *ProcessManager) cleanupStaleRunner(ctx context.Context, group, runner s pidBytes, err := os.ReadFile(pidFile) if err != nil { - m.logger.DebugContext(ctx, "no PID file found, removing stale workdir", "dir", runnerDir) + m.logger.DebugContext(ctx, "no PID file found, removing stale workdir", logging.KeyDir, runnerDir) m.removeStaleDir(ctx, runnerDir) return } pid, err := strconv.Atoi(strings.TrimSpace(string(pidBytes))) if err != nil { - m.logger.WarnContext(ctx, "invalid PID file content, removing workdir", "dir", runnerDir, "error", err) + m.logger.WarnContext(ctx, "invalid PID file content, removing workdir", logging.KeyDir, runnerDir, logging.KeyError, err) m.removeStaleDir(ctx, runnerDir) return } if isProcessAlive(pid) { - m.logger.WarnContext(ctx, "killing stale runner process", "pid", pid, "runner", runner, "group", group) + m.logger.WarnContext(ctx, "killing stale runner process", logging.KeyPID, pid, logging.KeyRunner, runner, logging.KeyGroup, group) if killErr := syscall.Kill(pid, syscall.SIGKILL); killErr != nil { - m.logger.WarnContext(ctx, "failed to kill stale process", "pid", pid, "error", killErr) + m.logger.WarnContext(ctx, "failed to kill stale process", logging.KeyPID, pid, logging.KeyError, killErr) } } if m.removeStaleDir(ctx, runnerDir) { - m.logger.InfoContext(ctx, "cleaned up stale runner", "runner", runner, "group", group, "pid", pid) + m.logger.InfoContext(ctx, "cleaned up stale runner", logging.KeyRunner, runner, logging.KeyGroup, group, logging.KeyPID, pid) } } func (m *ProcessManager) removeStaleDir(ctx context.Context, dir string) bool { if err := os.RemoveAll(dir); err != nil { - m.logger.WarnContext(ctx, "failed to remove stale workdir", "dir", dir, "error", err) + m.logger.WarnContext(ctx, "failed to remove stale workdir", logging.KeyDir, dir, logging.KeyError, err) return false } return true @@ -98,12 +100,12 @@ func (m *ProcessManager) KillOrphanRunners(ctx context.Context) { continue } if !m.processBelongsToGhr(ctx, pid) { - m.logger.DebugContext(ctx, "ignoring pgrep match not owned by ghr", "pid", pid) + m.logger.DebugContext(ctx, "ignoring pgrep match not owned by ghr", logging.KeyPID, pid) continue } - m.logger.WarnContext(ctx, "killing orphan runner process", "pid", pid) + m.logger.WarnContext(ctx, "killing orphan runner process", logging.KeyPID, pid) if killErr := syscall.Kill(pid, syscall.SIGKILL); killErr != nil { - m.logger.WarnContext(ctx, "failed to kill orphan runner", "pid", pid, "error", killErr) + m.logger.WarnContext(ctx, "failed to kill orphan runner", logging.KeyPID, pid, logging.KeyError, killErr) } } } diff --git a/internal/runner/process.go b/internal/runner/process.go index 2e6372b..e34d5cc 100644 --- a/internal/runner/process.go +++ b/internal/runner/process.go @@ -13,6 +13,7 @@ import ( "syscall" "time" + "github.com/RedBoardDev/gh-runners-tool/v2/internal/logging" "github.com/RedBoardDev/gh-runners-tool/v2/internal/model" ) @@ -52,7 +53,7 @@ func (m *ProcessManager) Prepare(ctx context.Context, instance *model.RunnerInst return "", fmt.Errorf("copy runner bits to %s: %w", workdir, err) } - m.logger.DebugContext(ctx, "prepared runner workdir", "workdir", workdir, "runner", instance.Name) + m.logger.DebugContext(ctx, "prepared runner workdir", "workdir", workdir, logging.KeyRunner, instance.Name) return workdir, nil } @@ -71,10 +72,10 @@ func (m *ProcessManager) Start(ctx context.Context, instance *model.RunnerInstan pid := int32(cmd.Process.Pid) pidFile := filepath.Join(workdir, ".ghr-pid") if err := os.WriteFile(pidFile, []byte(strconv.FormatInt(int64(pid), 10)), 0o644); err != nil { - m.logger.WarnContext(ctx, "failed to write PID file", "path", pidFile, "error", err) + m.logger.WarnContext(ctx, "failed to write PID file", logging.KeyPath, pidFile, logging.KeyError, err) } - m.logger.InfoContext(ctx, "runner started", "runner", instance.Name, "pid", pid) + m.logger.InfoContext(ctx, "runner started", logging.KeyRunner, instance.Name, logging.KeyPID, pid) return &Process{ Name: instance.Name, @@ -91,7 +92,7 @@ func (m *ProcessManager) Stop(ctx context.Context, proc *Process) error { return nil } - m.logger.InfoContext(ctx, "stopping runner", "runner", proc.Name, "pid", proc.PID) + m.logger.InfoContext(ctx, "stopping runner", logging.KeyRunner, proc.Name, logging.KeyPID, proc.PID) if err := proc.cmd.Process.Signal(syscall.SIGTERM); err != nil { if isProcessFinished(err) { @@ -112,7 +113,7 @@ func (m *ProcessManager) Stop(ctx context.Context, proc *Process) error { } return err case <-time.After(stopGracePeriod): - m.logger.WarnContext(ctx, "runner did not exit after SIGTERM, sending SIGKILL", "runner", proc.Name, "pid", proc.PID) + m.logger.WarnContext(ctx, "runner did not exit after SIGTERM, sending SIGKILL", logging.KeyRunner, proc.Name, logging.KeyPID, proc.PID) if err := proc.cmd.Process.Kill(); err != nil { return fmt.Errorf("kill runner %s (pid %d): %w", proc.Name, proc.PID, err) }