Logging: structured slog messages throughout, and WithLogger options so callers choose the logger

Log messages are lower-case event names with their details as key/value
attributes ("error" for errors), in place of formatted strings.

Loggable package take a WithLogger option as part of their "New*" call,
defaulting to slog.Default(). Each tags its lines with its `component`.

Some debug loggers print directly rather than using slog when in
terminal logging mode.

internal/fetcher/fetcher.go

@@ -14,16 +14,60 @@ import (
 
 var ErrNoNewReleases = fmt.Errorf("%w: no new releases", util.ErrWorkerNoWork)
 
+// Option configures Run.
+type Option func(*options)
+
+// options holds the settings Options change.
+type options struct {
+	log *slog.Logger
+}
+
+// WithLogger makes Run, its workers and their clients log to logger instead
+// of slog.Default().
+func WithLogger(logger *slog.Logger) Option {
+	return func(opts *options) {
+		opts.log = logger
+	}
+}
+
+// logger returns the logger Run logs to: the given one, or slog.Default().
+// It isn't tagged here; each worker adds its source.
+func (opts options) logger() *slog.Logger {
+	if opts.log == nil {
+		return slog.Default()
+	}
+	return opts.log
+}
+
+// runFunc runs one source's worker until ctx is cancelled, logging to
+// logger.
+type runFunc func(
+	ctx context.Context,
+	logger *slog.Logger,
+	conf *config.JobSearchConfig,
+	since time.Time,
+) error
+
 // Run starts a worker for each enabled source and blocks until every worker
 // has stopped. Workers stop when ctx is cancelled, or when any worker stops
 // with an error, which starts a shutdown of all of them. The errors are
-// logged as they happen and returned joined; nil means a clean shutdown.
+// logged as they happen and returned joined; nil means a clean shutdown. It
+// logs to slog.Default() unless given WithLogger.
 func Run(
-	ctx context.Context, conf *config.JobSearchConfig, since time.Time,
+	ctx context.Context,
+	conf *config.JobSearchConfig,
+	since time.Time,
+	opts ...Option,
 ) error {
 	ctx, cancel := context.WithCancel(ctx)
 	defer cancel()
 
+	var settings options
+	for _, opt := range opts {
+		opt(&settings)
+	}
+	logger := settings.logger().With("component", "fetcher")
+
 	var (
 		wg   sync.WaitGroup
 		mu   sync.Mutex
@@ -32,13 +76,13 @@ func Run(
 
 	start := func(
 		name string,
-		run func(context.Context, *config.JobSearchConfig, time.Time) error,
+		run runFunc,
 	) {
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
-			if err := run(ctx, conf, since); err != nil {
-				slog.Error("source stopped, shutting down", "source", name, "err", err)
+			if err := run(ctx, logger, conf, since); err != nil {
+				logger.Error("source stopped, shutting down", "source", name, "error", err)
 				mu.Lock()
 				errs = append(errs, fmt.Errorf("%s: %w", name, err))
 				mu.Unlock()