From f4c304cfba62d5a180d63ac230d2312aa5d3acca Mon Sep 17 00:00:00 2001 From: Sam Catlow Date: Fri, 13 Nov 2026 03:56:12 +1100 Subject: [PATCH] refactor: log through the injected logger with context; NATS handlers root in the registering context (#1927) --- internal/app/archied/bootstrap.go | 46 ++++++++-------- internal/app/archied/main.go | 53 +++++++++---------- internal/app/archied/update.go | 6 +-- internal/app/archiegateway/chat_runtime.go | 10 ++-- internal/app/archiegateway/gateway_runtime.go | 2 +- internal/app/archiegateway/server.go | 2 +- internal/app/archiemessaging/supervise.go | 10 ++-- internal/app/archieui/compose.go | 14 ++--- internal/app/prbench/live.go | 7 +-- internal/app/prbench/prbench.go | 17 ++++-- internal/app/statestore/server.go | 14 ++--- internal/container/pool.go | 14 ++--- internal/domain/curator/runtime.go | 16 +++--- internal/domain/workflow/diff_rules.go | 8 +-- internal/forgerpc/forgerpc.go | 4 +- .../agenttransport/nats/transport.go | 12 ++--- .../infrastructure/forgeext/forgeext_test.go | 2 +- internal/infrastructure/issuerpc/issuerpc.go | 4 +- internal/infrastructure/logrpc/nats.go | 4 +- internal/infrastructure/taskactions/rpc.go | 4 +- internal/messagerpc/messagerpc.go | 4 +- internal/natsrpc/natsrpc.go | 11 ++-- internal/worktreerpc/worktreerpc.go | 4 +- 23 files changed, 139 insertions(+), 129 deletions(-) diff --git a/internal/app/archied/bootstrap.go b/internal/app/archied/bootstrap.go index 2e61ad7fe..58d4cd09c 100644 --- a/internal/app/archied/bootstrap.go +++ b/internal/app/archied/bootstrap.go @@ -339,14 +339,14 @@ func (b *boot) handleRequeue(ctx context.Context, requeue int64, once bool) (boo return !once, nil } -func (b *boot) seedSoul(cfgPath string) { +func (b *boot) seedSoul(ctx context.Context, cfgPath string) { result, err := configuration.SeedSoul(cfgPath, agent.ShippedSoul()) if err != nil { - b.log.Warn("soul: starter file unavailable", "err", err) + b.log.WarnContext(ctx, "soul: starter file unavailable", "err", err) return } if result.Action == configuration.SoulCreated { - b.log.Info("soul: starter file written", "path", result.Path, "action", result.Action) + b.log.InfoContext(ctx, "soul: starter file written", "path", result.Path, "action", result.Action) } } @@ -521,17 +521,17 @@ func (b *boot) buildWorktreeManager() { } } -func (b *boot) registerNATSRPC() error { +func (b *boot) registerNATSRPC(ctx context.Context) error { log := b.log if b.natsClient == nil { return nil } coreConn, err := b.natsClient.CoreConn() if err != nil { - log.Error("nats connection unavailable for task RPC", "err", err) + log.ErrorContext(ctx, "nats connection unavailable for task RPC", "err", err) return err } - unsubscribe, err := registerTaskRPCServers(coreConn, func(ctx context.Context, t *workflow.Task, op string) (daemon.RepositoryAccess, error) { + unsubscribe, err := registerTaskRPCServers(ctx, coreConn, func(ctx context.Context, t *workflow.Task, op string) (daemon.RepositoryAccess, error) { if b.d == nil { return daemon.RepositoryAccess{}, errors.New("repository connections starting") } @@ -543,40 +543,40 @@ func (b *boot) registerNATSRPC() error { return b.messaging.Deliver(ctx, org, channel, chatID, text) }, b.stateStoreGrants.Client, installedAuthorities{b.stateStoreGrants.Client}, log) if err != nil { - log.Error("task RPC server registration failed", "err", err) + log.ErrorContext(ctx, "task RPC server registration failed", "err", err) return err } b.addCleanup(unsubscribe) - stopLogs, err := logrpc.RegisterDaemon(coreConn, b.logFeed, log) + stopLogs, err := logrpc.RegisterDaemon(ctx, coreConn, b.logFeed, log) if err != nil { return fmt.Errorf("register daemon logs: %w", err) } b.addCleanup(stopLogs) - unsubscribeSystemLogs, err := subscribeSystemLogs(coreConn, b.taskLogs, log) + unsubscribeSystemLogs, err := subscribeSystemLogs(ctx, coreConn, b.taskLogs, log) if err != nil { - log.Error("system log subscribe failed", "err", err) + log.ErrorContext(ctx, "system log subscribe failed", "err", err) return err } b.addCleanup(unsubscribeSystemLogs) - unsubscribeAgentEvents, err := subscribeAgentEvents(coreConn, b.bus, log) + unsubscribeAgentEvents, err := subscribeAgentEvents(ctx, coreConn, b.bus, log) if err != nil { - log.Error("agent event subscribe failed", "err", err) + log.ErrorContext(ctx, "agent event subscribe failed", "err", err) return err } b.addCleanup(unsubscribeAgentEvents) - unsubscribeTaskActions, err := taskactions.Register(coreConn, b.taskActions(), log) + unsubscribeTaskActions, err := taskactions.Register(ctx, coreConn, b.taskActions(), log) if err != nil { - log.Error("gateway task action register failed", "err", err) + log.ErrorContext(ctx, "gateway task action register failed", "err", err) return err } b.addCleanup(unsubscribeTaskActions) - unsubscribeIssues, err := (&issuerpc.Server{Forge: b.issueForge, Log: log}).Register(coreConn) + unsubscribeIssues, err := (&issuerpc.Server{Forge: b.issueForge, Log: log}).Register(ctx, coreConn) if err != nil { - log.Error("issue RPC register failed", "err", err) + log.ErrorContext(ctx, "issue RPC register failed", "err", err) return err } b.addCleanup(unsubscribeIssues) @@ -588,13 +588,13 @@ func (b *boot) issueForge(ctx context.Context, owner, repo string) (forge.IssueF return b.repositoryForge(ctx, owner, repo) } -func (b *boot) buildDaemon() { +func (b *boot) buildDaemon(ctx context.Context) { log := b.log b.d = &daemon.Daemon{ ResolveRepository: b.repositoryAccess, Cfg: b.cfgHolder, ConnectedNATS: daemon.NATSEndpoint{URL: b.natsURL, Token: b.natsToken, Scoped: b.cfg.NATS.Mode != config.NATSModeExternal}, - ConnectedStateStore: daemon.StateStoreEndpoint{URL: strings.TrimSpace(b.cfg.Services.Get(config.ServiceNameState).Target), CA: b.stateStoreCA()}, + ConnectedStateStore: daemon.StateStoreEndpoint{URL: strings.TrimSpace(b.cfg.Services.Get(config.ServiceNameState).Target), CA: b.stateStoreCA(ctx)}, Store: b.stateStore, Bus: b.bus, Forge: b.forgeClient, @@ -653,14 +653,14 @@ func (b *boot) buildDaemon() { if denials, ok := b.stateStore.(access.DenialRecorder); ok { b.d.Denials = denials } - b.d.PlaybookLedger = playbookLedger(b.stateStore, b.log) + b.d.PlaybookLedger = playbookLedger(ctx, b.stateStore, b.log) } -func playbookLedger(source any, log *slog.Logger) storecontract.PlaybookDispatcher { +func playbookLedger(ctx context.Context, source any, log *slog.Logger) storecontract.PlaybookDispatcher { if pd, ok := source.(storecontract.PlaybookDispatcher); ok { return pd } - log.Warn("eda action playbooks will not run: no dispatch ledger is wired") + log.WarnContext(ctx, "eda action playbooks will not run: no dispatch ledger is wired") return nil } @@ -839,10 +839,10 @@ const playbookRefreshInterval = 30 * time.Second // stateStoreCA is the CA a task container verifies the State Store with; // nil without [tls]. -func (b *boot) stateStoreCA() []byte { +func (b *boot) stateStoreCA(ctx context.Context) []byte { id, err := servicekit.Identity(b.cfg.TLS, presence.Daemon) if err != nil { - b.log.Warn("state store CA for containers", "err", err) + b.log.WarnContext(ctx, "state store CA for containers", "err", err) return nil } return id.CAPEM() diff --git a/internal/app/archied/main.go b/internal/app/archied/main.go index f9d1439c1..30a250b0e 100644 --- a/internal/app/archied/main.go +++ b/internal/app/archied/main.go @@ -163,23 +163,23 @@ func Run() int { //nolint:cyclop,funlen // the composition root's setup sequence return 1 } if err := b.loadRuntimeConfig(ctx); err != nil { - b.log.Error("runtime settings unavailable", "err", err) + b.log.ErrorContext(ctx, "runtime settings unavailable", "err", err) return 1 } b.openForge(ctx) if err := b.startLiveSettings(ctx); err != nil { - b.log.Error("live settings unavailable", "err", err) + b.log.ErrorContext(ctx, "live settings unavailable", "err", err) return 1 } go b.applyStatus.Run(ctx) - go watchUpdateRecovery(ctx, args.cfgPath, 30*time.Second) + go watchUpdateRecovery(ctx, args.cfgPath, 30*time.Second, b.log) if exit, err := b.handleRequeue(ctx, args.requeue, args.once); err != nil { return 1 } else if exit { return 0 } b.loadCatalog(ctx) - b.seedSoul(args.cfgPath) + b.seedSoul(ctx, args.cfgPath) b.setupObservability(ctx) if err := b.setupBackends(ctx); err != nil { @@ -198,10 +198,10 @@ func Run() int { //nolint:cyclop,funlen // the composition root's setup sequence b.startModelCatalogRefresh(ctx) b.buildWorktreeManager() - if err := b.registerNATSRPC(); err != nil { + if err := b.registerNATSRPC(ctx); err != nil { return 1 } - b.buildDaemon() + b.buildDaemon(ctx) if err := b.setupScheduling(); err != nil { return 1 } @@ -259,33 +259,32 @@ func persistEvents(ctx context.Context, sink *events.Sub, st storecontract.TaskS // currently open there -- late, duplicate, or from an attempt this instance // never dispatched -- is expected and silently dropped rather than treated as // an error. -func subscribeSystemLogs(nc *natsio.Conn, taskLogs *logging.TaskRegistry, log *slog.Logger) (unsubscribe func(), err error) { +func subscribeSystemLogs(ctx context.Context, nc *natsio.Conn, taskLogs *logging.TaskRegistry, log *slog.Logger) (unsubscribe func(), err error) { sub, err := nc.Subscribe(agentexec.SubjectSystemWildcard, func(msg *natsio.Msg) { taskID, ok := agentexec.TaskIDFromSystemSubject(msg.Subject) if !ok { - log.Warn("system log message on unparseable subject", "subject", msg.Subject) + log.WarnContext(ctx, "system log message on unparseable subject", "subject", msg.Subject) return } var entry logging.Entry if err := json.Unmarshal(msg.Data, &entry); err != nil { - log.Warn("system log message undecodable", "task", taskID, "err", err) + log.WarnContext(ctx, "system log message undecodable", "task", taskID, "err", err) return } - // The NATS callback has no context of its own; the write is an append to - // an already-open sink, so there is nothing to cancel. + // The write is an append to an already-open sink, so it must outlive ctx. if entry.Fields == nil { entry.Fields = map[string]any{} } entry.Fields["service"] = presence.Agent entry.Fields["task_id"] = taskID - taskLogs.Write(context.Background(), taskID, entry) + taskLogs.Write(context.WithoutCancel(ctx), taskID, entry) }) if err != nil { return nil, err } return func() { if err := sub.Unsubscribe(); err != nil { - log.Warn("system log unsubscribe failed", "err", err) + log.WarnContext(ctx, "system log unsubscribe failed", "err", err) } }, nil } @@ -299,32 +298,32 @@ func subscribeSystemLogs(nc *natsio.Conn, taskLogs *logging.TaskRegistry, log *s // choke point that inserts into the events table and fans out over // SSE -- treats them exactly like every other daemon-observed event. Mirrors // subscribeSystemLogs's demux-by-taskID shape. -func subscribeAgentEvents(nc *natsio.Conn, bus *events.Bus, log *slog.Logger) (unsubscribe func(), err error) { +func subscribeAgentEvents(ctx context.Context, nc *natsio.Conn, bus *events.Bus, log *slog.Logger) (unsubscribe func(), err error) { sub, err := nc.Subscribe(agentexec.SubjectEventsWildcard, func(msg *natsio.Msg) { taskID, ok := agentexec.TaskIDFromEventsSubject(msg.Subject) if !ok { - log.Warn("task event message on unparseable subject", "subject", msg.Subject) + log.WarnContext(ctx, "task event message on unparseable subject", "subject", msg.Subject) return } var e events.Event if err := json.Unmarshal(msg.Data, &e); err != nil { - log.Warn("task event message undecodable", "task", taskID, "err", err) + log.WarnContext(ctx, "task event message undecodable", "task", taskID, "err", err) return } - bus.Publish(context.Background(), e) + bus.Publish(context.WithoutCancel(ctx), e) }) if err != nil { return nil, err } if err := nc.Flush(); err != nil { if cleanupErr := sub.Unsubscribe(); cleanupErr != nil { - log.Warn("task event subscription cleanup failed after flush failure", "err", cleanupErr) + log.WarnContext(ctx, "task event subscription cleanup failed after flush failure", "err", cleanupErr) } return nil, fmt.Errorf("flush task event subscription: %w", err) } return func() { if err := sub.Unsubscribe(); err != nil { - log.Warn("task event unsubscribe failed", "err", err) + log.WarnContext(ctx, "task event unsubscribe failed", "err", err) } }, nil } @@ -332,7 +331,7 @@ func subscribeAgentEvents(nc *natsio.Conn, bus *events.Bus, log *slog.Logger) (u // registerTaskRPCServers routes each request through the current task binding. // Wildcard subjects serve identities created after daemon startup; credentials // and repository bounds are checked before the connection is resolved. -func registerTaskRPCServers(nc *natsio.Conn, resolve func(context.Context, *workflow.Task, string) (daemon.RepositoryAccess, error), deliver func(ctx context.Context, org, channel, chatID, text string) error, runs worktreerpc.Runs, authorities forgerpc.Authorities, log *slog.Logger) (func(), error) { +func registerTaskRPCServers(ctx context.Context, nc *natsio.Conn, resolve func(context.Context, *workflow.Task, string) (daemon.RepositoryAccess, error), deliver func(ctx context.Context, org, channel, chatID, text string) error, runs worktreerpc.Runs, authorities forgerpc.Authorities, log *slog.Logger) (func(), error) { var unsubs []func() unsubscribe := func() { for _, stop := range unsubs { @@ -348,8 +347,8 @@ func registerTaskRPCServers(nc *natsio.Conn, resolve func(context.Context, *work return resolved.Trees, err }} messages := &messagerpc.Server{Runs: runs, Deliver: deliver, Log: log} - for _, register := range []func(*natsio.Conn, string) (func(), error){messages.RegisterFor, fg.RegisterFor, trees.RegisterFor} { - stop, err := register(nc, "*") + for _, register := range []func(context.Context, *natsio.Conn, string) (func(), error){messages.RegisterFor, fg.RegisterFor, trees.RegisterFor} { + stop, err := register(ctx, nc, "*") if err != nil { unsubscribe() return nil, err @@ -401,7 +400,7 @@ func startContainers( MaxConcurrency: cfg.Containers.MaxConcurrency, MaxUptime: cfg.Containers.MaxUptime.Std(), PullPolicy: cfg.Containers.PullPolicy, - RegistryAuth: resolveRegistryAuth(cfg.Containers.RegistryAuth, secrets, log), + RegistryAuth: resolveRegistryAuth(ctx, cfg.Containers.RegistryAuth, secrets, log), Network: cfg.Containers.Network, DockerClient: dockerCli, // The embedded broker binds the host gateway, and a loopback State @@ -456,21 +455,21 @@ func containerLiveSettings(cfgHolder *config.Holder) func() container.Config { // warning is what makes the 401 that a private registry will still answer // explicable after a typo or an unset secret. A ref that names only one half is // a config error caught by configuration.Validate, not a missing credential. -func resolveRegistryAuth(ref secret.SecretRef, secrets *secret.Registry, log *slog.Logger) string { +func resolveRegistryAuth(ctx context.Context, ref secret.SecretRef, secrets *secret.Registry, log *slog.Logger) string { if ref == (secret.SecretRef{}) { return "" } if secrets == nil { - log.Warn("registry credential unavailable; pulling without auth", "reason", "no secret registry", "engine", ref.Engine, "key", ref.Key) + log.WarnContext(ctx, "registry credential unavailable; pulling without auth", "reason", "no secret registry", "engine", ref.Engine, "key", ref.Key) return "" } value, err := secrets.Resolve(ref) if err != nil { - log.Warn("registry credential unavailable; pulling without auth", "err", err, "engine", ref.Engine, "key", ref.Key) + log.WarnContext(ctx, "registry credential unavailable; pulling without auth", "err", err, "engine", ref.Engine, "key", ref.Key) return "" } if strings.TrimSpace(value) == "" { - log.Warn("registry credential resolved empty; pulling without auth", "engine", ref.Engine, "key", ref.Key) + log.WarnContext(ctx, "registry credential resolved empty; pulling without auth", "engine", ref.Engine, "key", ref.Key) return "" } return value diff --git a/internal/app/archied/update.go b/internal/app/archied/update.go index fb82254ee..8bb6372b2 100644 --- a/internal/app/archied/update.go +++ b/internal/app/archied/update.go @@ -346,7 +346,7 @@ func spawnRecovery(ctx context.Context, configPath string) error { // watchUpdateRecovery recovers a transaction whose watchdog died while this // daemon kept running. An orphan must be seen on two consecutive checks so a // journal published just before its watchdog takes the lock is left alone. -func watchUpdateRecovery(ctx context.Context, configPath string, every time.Duration) { +func watchUpdateRecovery(ctx context.Context, configPath string, every time.Duration, log *slog.Logger) { ticker := time.NewTicker(every) defer ticker.Stop() seen := false @@ -358,12 +358,12 @@ func watchUpdateRecovery(ctx context.Context, configPath string, every time.Dura } orphaned, err := updateOrphaned() if err != nil { - slog.WarnContext(ctx, "check update recovery", "error", err) + log.WarnContext(ctx, "check update recovery", "error", err) continue } if orphaned && seen { if err := spawnRecovery(ctx, configPath); err != nil { - slog.WarnContext(ctx, "recover update", "error", err) + log.WarnContext(ctx, "recover update", "error", err) } } seen = orphaned diff --git a/internal/app/archiegateway/chat_runtime.go b/internal/app/archiegateway/chat_runtime.go index 5ae5042dd..b834d1af4 100644 --- a/internal/app/archiegateway/chat_runtime.go +++ b/internal/app/archiegateway/chat_runtime.go @@ -50,15 +50,15 @@ func (b *server) claimGatewayOwnership(ctx context.Context) error { return nil } -func (b *server) setupTranscriber(cfg config.Config, log *slog.Logger) { +func (b *server) setupTranscriber(ctx context.Context, cfg config.Config, log *slog.Logger) { client, ok := transcription.New(cfg.Models, cfg.Providers, transcription.Options{ ResolveSecret: b.secrets.Resolve, }) if ok { b.transcriber = client - log.Info("voice transcription enabled") + log.InfoContext(ctx, "voice transcription enabled") } else if _, err := config.ResolveModel(cfg.Models, "", config.PurposeTranscription); err == nil { - log.Warn("voice transcription configured but unavailable; capability disabled") + log.WarnContext(ctx, "voice transcription configured but unavailable; capability disabled") } } @@ -87,7 +87,7 @@ func (b *server) startRateLimiter(ctx context.Context, cfg config.RateLimitConfi // turn runner reads the runtime through server.chatLLM, so the swap reaches its // next turn without rebuilding the runner, and the model manager re-derives // the aliases it offers. -func (b *server) rebuildChatModelRuntime(cfg config.Config) { +func (b *server) rebuildChatModelRuntime(ctx context.Context, cfg config.Config) { if b.chatModels == nil { return // this process serves no chat turns } @@ -95,7 +95,7 @@ func (b *server) rebuildChatModelRuntime(cfg config.Config) { b.chatModels.SetConfigured(cfg.Models) catalog := b.catalogState() b.chatModels.SetModelCatalog(catalog) - b.log.Info("chat model runtime rebuilt", "providers", len(cfg.Providers), "models", len(cfg.Models)) + b.log.InfoContext(ctx, "chat model runtime rebuilt", "providers", len(cfg.Providers), "models", len(cfg.Models)) } // sessionKey builds a deterministic session identifier from a gateway diff --git a/internal/app/archiegateway/gateway_runtime.go b/internal/app/archiegateway/gateway_runtime.go index 90bc3971c..48c55b6b4 100644 --- a/internal/app/archiegateway/gateway_runtime.go +++ b/internal/app/archiegateway/gateway_runtime.go @@ -33,7 +33,7 @@ func (b *server) setupChatRuntime(ctx context.Context, cfg config.Config, actor // beside: it is built here, on the model-owning side, from this process's // own [models]/[providers]. The Messaging Service carries a voice note's // bytes to the Gateway and never holds the credential. - b.setupTranscriber(cfg, b.log) + b.setupTranscriber(ctx, cfg, b.log) b.toolReg = tools.NewRegistry() chatModels := newChatModelManager(cfg.Models) catalog := b.catalogState() diff --git a/internal/app/archiegateway/server.go b/internal/app/archiegateway/server.go index 2b06c6a44..5f5039259 100644 --- a/internal/app/archiegateway/server.go +++ b/internal/app/archiegateway/server.go @@ -374,7 +374,7 @@ func (b *server) relayer(ctx context.Context, base config.Config, kind string) e return err } b.cfgHolder.Set(cfg) - b.rebuildChatModelRuntime(cfg) + b.rebuildChatModelRuntime(ctx, cfg) var problems []error if kind == controlplanestore.ToolSettingsKind { if err := b.reconcileToolSettings(ctx, cfg); err != nil { diff --git a/internal/app/archiemessaging/supervise.go b/internal/app/archiemessaging/supervise.go index fa5f181f4..f0210a42f 100644 --- a/internal/app/archiemessaging/supervise.go +++ b/internal/app/archiemessaging/supervise.go @@ -62,7 +62,7 @@ func (s *Service) runChannel(ctx context.Context, c *channelInstance) { // idempotent tail for the paths that leave a listener behind. s.stopChannel(ctx, c.name, ch) - next, wait := s.afterChannelRun(c, err, shutdown, restart, attempts) + next, wait := s.afterChannelRun(ctx, c, err, shutdown, restart, attempts) if next == nextStop { return } @@ -93,7 +93,7 @@ const ( // afterChannelRun records the ended run's state and decides what the supervisor // does next. shutdown is the service stopping; restart is an explicit // replacement already waiting in the instance. -func (s *Service) afterChannelRun(c *channelInstance, err error, shutdown, restart bool, attempts int) (channelNext, time.Duration) { +func (s *Service) afterChannelRun(ctx context.Context, c *channelInstance, err error, shutdown, restart bool, attempts int) (channelNext, time.Duration) { switch { case shutdown: if err != nil && !errors.Is(err, context.Canceled) { @@ -108,17 +108,17 @@ func (s *Service) afterChannelRun(c *channelInstance, err error, shutdown, resta // The channel stopped itself. Hold it stopped rather than spending the // failure retry budget on a run that chose to end. s.status.MarkStopped(c.name, "") - s.log.Info("channel stopped", "name", c.name) + s.log.InfoContext(ctx, "channel stopped", "name", c.name) return nextPark, 0 case attempts >= s.retry.attempts: s.status.MarkFailed(c.name, err.Error()) - s.log.Error("channel failed repeatedly; parked until an explicit restart", + s.log.ErrorContext(ctx, "channel failed repeatedly; parked until an explicit restart", "name", c.name, "attempts", attempts, "err", err) return nextPark, 0 default: s.status.MarkFailed(c.name, err.Error()) wait := s.retry.backoffFor(attempts) - s.log.Warn("channel failed; restarting", "name", c.name, + s.log.WarnContext(ctx, "channel failed; restarting", "name", c.name, "attempt", attempts, "of", s.retry.attempts, "in", wait, "err", err) return nextRetry, wait } diff --git a/internal/app/archieui/compose.go b/internal/app/archieui/compose.go index 171dca2e2..b905cb3b7 100644 --- a/internal/app/archieui/compose.go +++ b/internal/app/archieui/compose.go @@ -124,8 +124,8 @@ func compose(ctx context.Context, d deps) *webui.Server { srv.Access = d.Access srv.Principals = d.Principals srv.Denials = d.Denials - wireTaskLogs(d, srv) - wireCaptureSurfaces(d, srv) + wireTaskLogs(ctx, d, srv) + wireCaptureSurfaces(ctx, d, srv) return srv } @@ -185,11 +185,11 @@ func wireCatalog(d deps, srv *webui.Server) { // contract, and logs the absence when it does not: a store without it leaves // the page reporting that this process cannot read logs, which is true, rather // than that the attempt has none, which it cannot know. -func wireTaskLogs(d deps, srv *webui.Server) { +func wireTaskLogs(ctx context.Context, d deps, srv *webui.Server) { logs, ok := d.Store.(storecontract.TaskLogStore) if !ok { if d.Store != nil { - d.Log.Warn("task logs unavailable: state store does not implement TaskLogStore") + d.Log.WarnContext(ctx, "task logs unavailable: state store does not implement TaskLogStore") } return } @@ -198,14 +198,14 @@ func wireTaskLogs(d deps, srv *webui.Server) { // wireCaptureSurfaces attaches capture listing, source editing and intake. A // store missing a contract degrades that part with a warning. -func wireCaptureSurfaces(d deps, srv *webui.Server) { +func wireCaptureSurfaces(ctx context.Context, d deps, srv *webui.Server) { if dispatches, ok := d.Store.(storecontract.DispatchLedger); ok { srv.Dispatches = dispatches } captures, hasCaptures := d.Store.(storecontract.CaptureStore) sources, hasSources := d.Store.(storecontract.SourceStore) if !hasCaptures { - d.Log.Warn("capture storage unavailable: state store does not implement CaptureStore") + d.Log.WarnContext(ctx, "capture storage unavailable: state store does not implement CaptureStore") return } var resolver captureintake.SourceResolver @@ -213,7 +213,7 @@ func wireCaptureSurfaces(d deps, srv *webui.Server) { srv.Sources = sources resolver = sources } else { - d.Log.Warn("source store unavailable: state store does not implement SourceStore; no capture will dispatch") + d.Log.WarnContext(ctx, "source store unavailable: state store does not implement SourceStore; no capture will dispatch") } capture := d.Options.Capture.withDefaults() diff --git a/internal/app/prbench/live.go b/internal/app/prbench/live.go index 8af63f56d..f5e0c6f50 100644 --- a/internal/app/prbench/live.go +++ b/internal/app/prbench/live.go @@ -27,6 +27,7 @@ type liveReviewer struct { cfg config.Config agent agentrun.Runner source workflow.PRSource + log *slog.Logger nextID atomic.Int64 } @@ -35,10 +36,10 @@ func (r *liveReviewer) Review(ctx context.Context, p bench.Problem) (bench.Revie if err != nil { return bench.Review{}, err } - slog.InfoContext(ctx, "benchmark review started", "problem", p.ID) + r.log.InfoContext(ctx, "benchmark review started", "problem", p.ID) tc := &workflow.TaskContext{ Task: &workflow.Task{ID: r.nextID.Add(1), Attempt: 1, Owner: owner, Repo: repo, PRNumber: number, Workflow: "pr-review", Inputs: map[string]any{"depth": "deep"}}, - Cfg: r.cfg, Agent: r.agent, PRSource: r.source, Log: slog.Default(), + Cfg: r.cfg, Agent: r.agent, PRSource: r.source, Log: r.log, } decision, err := workflow.ReviewPullRequest(ctx, tc) if err != nil { @@ -48,7 +49,7 @@ func (r *liveReviewer) Review(ctx context.Context, p bench.Problem) (bench.Revie if decision.Comments == nil { decision.Comments = []prreview.ScoredFinding{} } - slog.InfoContext(ctx, "benchmark review completed", "problem", p.ID, "comments", len(decision.Comments), "skipped_phases", decision.SkippedPhases) + r.log.InfoContext(ctx, "benchmark review completed", "problem", p.ID, "comments", len(decision.Comments), "skipped_phases", decision.SkippedPhases) return bench.Review{Comments: decision.Comments, SkippedPhases: decision.SkippedPhases}, nil } diff --git a/internal/app/prbench/prbench.go b/internal/app/prbench/prbench.go index 7dc42dd7c..aeadaa9ac 100644 --- a/internal/app/prbench/prbench.go +++ b/internal/app/prbench/prbench.go @@ -28,6 +28,7 @@ import ( "github.com/samcharles93/archie-core/internal/domain/workflow/prreview/bench" "github.com/samcharles93/archie-core/internal/infrastructure/configuration" "github.com/samcharles93/archie-core/internal/infrastructure/prsource" + "github.com/samcharles93/archie-core/internal/logging" ) // acceptanceRecall is the PRD's golden micro-recall bar for a full run. @@ -71,8 +72,8 @@ type Options struct { } // Run reviews and judges the selected problems, writes the report into -// Options.OutDir, and prints it to w. -func Run(ctx context.Context, opts Options, w io.Writer) (bench.Summary, error) { +// Options.OutDir, and prints it to w. log receives the run's progress. +func Run(ctx context.Context, log *slog.Logger, opts Options, w io.Writer) (bench.Summary, error) { problems, err := Problems(opts.Problems) if err != nil { return bench.Summary{}, err @@ -82,7 +83,7 @@ func Run(ctx context.Context, opts Options, w io.Writer) (bench.Summary, error) return bench.Summary{}, err } cfg := doc.Config - if err := servicekit.ResolveProviders(&cfg, slog.Default()); err != nil { + if err := servicekit.ResolveProviders(&cfg, log); err != nil { return bench.Summary{}, err } reviewRef, err := resolveRef(cfg.Models, opts.Model) @@ -99,7 +100,7 @@ func Run(ctx context.Context, opts Options, w io.Writer) (bench.Summary, error) } // The pipeline resolves its model through the default alias. cfg.Models = map[string]string{config.DefaultModelAlias: reviewRef} - reviewer := &liveReviewer{cfg: cfg, agent: modelloop.NewLoopRunner(rt, slog.Default()), source: prsource.New(newPublicGitHub())} + reviewer := &liveReviewer{cfg: cfg, agent: modelloop.NewLoopRunner(rt, log), source: prsource.New(newPublicGitHub()), log: log} judge := &modelJudge{runtime: rt, modelRef: judgeRef} results := bench.Run(ctx, problems, reviewer, judge, opts.Concurrency) @@ -138,9 +139,15 @@ func Main(args []string, stdout, stderr io.Writer) int { if problems != "" { opts.Problems = strings.Split(problems, ",") } + log, closer, err := logging.New(logging.Options{}) + if err != nil { + fmt.Fprintln(stderr, "archied prbench:", err) + return 1 + } + defer closer.Close() ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM) defer stop() - if _, err := Run(ctx, opts, stdout); err != nil { + if _, err := Run(ctx, log, opts, stdout); err != nil { fmt.Fprintln(stderr, "archied prbench:", err) return 1 } diff --git a/internal/app/statestore/server.go b/internal/app/statestore/server.go index 93dd12f1c..ee3a5d44e 100644 --- a/internal/app/statestore/server.go +++ b/internal/app/statestore/server.go @@ -107,7 +107,7 @@ func Run(ctx context.Context, options Options) error { //nolint:cyclop // the co if err != nil { return fmt.Errorf("import control-plane resources: %w", err) } - b.reportUnseededResources(skipped) + b.reportUnseededResources(ctx, skipped) grants, err := b.runCredentials(ctx) if err != nil { @@ -137,7 +137,7 @@ func Run(ctx context.Context, options Options) error { //nolint:cyclop // the co // accepting the moment it is called. b.announceReady() - deps := b.stateStoreDeps(grants) + deps := b.stateStoreDeps(ctx, grants) controlPlaneDeps(&deps, control) b.startSweeps(ctx, deps) return serveStateStore(ctx, listener, deps, opts) @@ -200,14 +200,14 @@ func (b *server) seedAndValidatePolicies(ctx context.Context) error { // It is a method rather than a loop in Run because the boot sequence // is at its complexity budget: the branch belongs to the report's own policy, // not to the sequence that triggers it. -func (b *server) reportUnseededResources(skipped []controlplanestore.SeedSkip) { +func (b *server) reportUnseededResources(ctx context.Context, skipped []controlplanestore.SeedSkip) { for _, skip := range skipped { if len(skip.Removed) > 0 { - b.log.Warn("removed stored entries that no longer validate; their earlier revision is in the resource history", + b.log.WarnContext(ctx, "removed stored entries that no longer validate; their earlier revision is in the resource history", "kind", skip.Kind, "removed", skip.Removed) continue } - b.log.Error("control-plane resource not seeded; the kind stays absent and the file's value is the one in effect", + b.log.ErrorContext(ctx, "control-plane resource not seeded; the kind stays absent and the file's value is the one in effect", "kind", skip.Kind, "err", skip.Err) } } @@ -263,7 +263,7 @@ func (b *server) openStateStore(ctx context.Context) error { // the capture/mapping/binding surfaces, so each is asserted here (the same // pattern the daemon's wireWebStoreSurfaces uses) and a store that lacks one // degrades that group rather than aborting boot. -func (b *server) stateStoreDeps(grants *staterpc.TaskGrants) staterpc.Deps { +func (b *server) stateStoreDeps(ctx context.Context, grants *staterpc.TaskGrants) staterpc.Deps { deps := staterpc.Deps{ LogFeed: b.logFeed, Tasks: b.st, Log: b.log, Grants: grants, @@ -279,7 +279,7 @@ func (b *server) stateStoreDeps(grants *staterpc.TaskGrants) staterpc.Deps { // and reports, rather than refusing to serve the task tables. projections, err := newPackageProjections(b.pg) if err != nil { - b.log.Error("build package projections", "err", err) + b.log.ErrorContext(ctx, "build package projections", "err", err) } else { packages.Projections = projections } diff --git a/internal/container/pool.go b/internal/container/pool.go index c2d1903ac..219411d49 100644 --- a/internal/container/pool.go +++ b/internal/container/pool.go @@ -593,15 +593,15 @@ func (p *Pool) Close() error { Filters: client.Filters{}.Add("label", daemonLabel+"="+p.cfg.Instance), }) if err != nil { - p.log.Warn("container list failed during close", "err", err) + p.log.WarnContext(ctx, "container list failed during close", "err", err) } else { for _, c := range list.Items { - p.log.Info("cleaning up container", "id", c.ID[:12]) + p.log.InfoContext(ctx, "cleaning up container", "id", c.ID[:12]) if _, err := p.cli.ContainerStop(ctx, c.ID, client.ContainerStopOptions{}); err != nil { - p.log.Warn("container stop during close", "id", c.ID[:12], "err", err) + p.log.WarnContext(ctx, "container stop during close", "id", c.ID[:12], "err", err) } if _, err := p.cli.ContainerRemove(ctx, c.ID, client.ContainerRemoveOptions{Force: true}); err != nil { - p.log.Warn("container remove during close", "id", c.ID[:12], "err", err) + p.log.WarnContext(ctx, "container remove during close", "id", c.ID[:12], "err", err) } } } @@ -657,7 +657,7 @@ func (p *Pool) pullImage(ctx context.Context, ref string) error { } p.log.InfoContext(ctx, "pulling image", "image", ref) - rc, err := p.cli.ImagePull(ctx, ref, client.ImagePullOptions{RegistryAuth: p.registryAuthHeader(cfg, ref)}) + rc, err := p.cli.ImagePull(ctx, ref, client.ImagePullOptions{RegistryAuth: p.registryAuthHeader(ctx, cfg, ref)}) if err != nil { return fmt.Errorf("pull %s: %w", ref, err) } @@ -675,13 +675,13 @@ func (p *Pool) pullImage(ctx context.Context, ref string) error { // registryAuthHeader returns the X-Registry-Auth value, or "". A credential // that cannot be rendered logs a warning and pulls anonymously. -func (p *Pool) registryAuthHeader(cfg Config, ref string) string { +func (p *Pool) registryAuthHeader(ctx context.Context, cfg Config, ref string) string { if cfg.RegistryAuth == "" { return "" } encoded, err := encodeRegistryAuth(cfg.RegistryAuth) if err != nil { - p.log.Warn("registry credential unusable; pulling without auth", "image", ref, "err", err) + p.log.WarnContext(ctx, "registry credential unusable; pulling without auth", "image", ref, "err", err) return "" } return encoded diff --git a/internal/domain/curator/runtime.go b/internal/domain/curator/runtime.go index 8dbb83ce4..f99759db1 100644 --- a/internal/domain/curator/runtime.go +++ b/internal/domain/curator/runtime.go @@ -284,7 +284,7 @@ func (rt *Runtime) runLoop(ctx context.Context, name string, c CuratorEngine, wa due, err := rt.safeCheck(ctx, c) if err != nil { - rt.fail(name, "check", err) + rt.fail(ctx, name, "check", err) next = clock.Now().Add(cooldown) continue } @@ -307,11 +307,11 @@ func (rt *Runtime) runLoop(ctx context.Context, name string, c CuratorEngine, wa now = clock.Now() lastPass = now if perr != nil { - rt.fail(name, "pass", perr) + rt.fail(ctx, name, "pass", perr) next = now.Add(cooldown) } else { next = scheduleNext(now, m, cooldown, result) - rt.emitRun(name, now, result) + rt.emitRun(ctx, name, now, result) } } } @@ -381,9 +381,9 @@ func (rt *Runtime) safePass(ctx context.Context, c CuratorEngine, in PassInput) // fail records a Check/Pass failure on the event stream. The event bus is // non-blocking by contract (bounded dropping buffers), so even a failing // curator cannot backpressure anything. -func (rt *Runtime) fail(name, phase string, err error) { +func (rt *Runtime) fail(ctx context.Context, name, phase string, err error) { if log := rt.registry.Host().Log; log != nil { - log.Error("curator failed", "curator", name, "phase", phase, "err", err) + log.ErrorContext(ctx, "curator failed", "curator", name, "phase", phase, "err", err) } if sink := rt.registry.Host().Events; sink != nil { sink.Emit(events.KindCuratorError, name, map[string]any{ @@ -396,14 +396,14 @@ func (rt *Runtime) fail(name, phase string, err error) { // emitRun publishes one run summary plus one event per action, so what ran, // when, what it changed, and why all stay attributable. -func (rt *Runtime) emitRun(name string, at time.Time, result PassResult) { +func (rt *Runtime) emitRun(ctx context.Context, name string, at time.Time, result PassResult) { rt.registry.RecordActivity(name, at, result.Actions) host := rt.registry.Host() if log := host.Log; log != nil { - log.Info("curator pass completed", "curator", name, "actions", len(result.Actions), "at", at) + log.InfoContext(ctx, "curator pass completed", "curator", name, "actions", len(result.Actions), "at", at) for _, a := range result.Actions { - log.Info("curator action", "curator", name, "type", a.Type, "detail", a.Detail, "reason", a.Reason, "at", a.At) + log.InfoContext(ctx, "curator action", "curator", name, "type", a.Type, "detail", a.Detail, "reason", a.Reason, "at", a.At) } } diff --git a/internal/domain/workflow/diff_rules.go b/internal/domain/workflow/diff_rules.go index e4041908a..ac7411fd0 100644 --- a/internal/domain/workflow/diff_rules.go +++ b/internal/domain/workflow/diff_rules.go @@ -119,7 +119,7 @@ func runDiffRules(ctx context.Context, tc *TaskContext, rules []compiledDiffRule var blocking []diffFinding for _, finding := range matchDiffRules(rules, added) { - logRuleFinding(tc, finding) + logRuleFinding(ctx, tc, finding) if finding.Blocking() { blocking = append(blocking, finding) } @@ -161,7 +161,7 @@ func refuseAChangeThatIsNotCommitted(ctx context.Context, tc *TaskContext) error // logRuleFinding logs a finding as a warning when it blocks and as info when // advisory, with the rule's declared level as rule_level. -func logRuleFinding(tc *TaskContext, finding diffFinding) { +func logRuleFinding(ctx context.Context, tc *TaskContext, finding diffFinding) { attributes := []any{ "rule_level", finding.Level, "rule", finding.Rule, @@ -170,10 +170,10 @@ func logRuleFinding(tc *TaskContext, finding diffFinding) { "message", finding.Message, } if finding.Blocking() { - tc.Log.Warn("diff rule finding", attributes...) + tc.Log.WarnContext(ctx, "diff rule finding", attributes...) return } - tc.Log.Info("diff rule finding", attributes...) + tc.Log.InfoContext(ctx, "diff rule finding", attributes...) } // renderDiffRuleFindings formats the blocking findings as a park reason: one diff --git a/internal/forgerpc/forgerpc.go b/internal/forgerpc/forgerpc.go index 13cc07315..86fd4b4c1 100644 --- a/internal/forgerpc/forgerpc.go +++ b/internal/forgerpc/forgerpc.go @@ -171,7 +171,7 @@ type Server struct { } // RegisterFor registers all handlers under the subjects scoped to identity. -func (s *Server) RegisterFor(nc *nats.Conn, identity string) (unsubscribe func(), err error) { +func (s *Server) RegisterFor(ctx context.Context, nc *nats.Conn, identity string) (unsubscribe func(), err error) { as := func(h func(context.Context, string, *nats.Msg)) func(context.Context, *nats.Msg) { return func(ctx context.Context, msg *nats.Msg) { scoped := identity @@ -181,7 +181,7 @@ func (s *Server) RegisterFor(nc *nats.Conn, identity string) (unsubscribe func() h(ctx, scoped, msg) } } - return natsrpc.RegisterAll(nc, []natsrpc.Registration{ + return natsrpc.RegisterAll(ctx, nc, []natsrpc.Registration{ {Subject: serverSubject(identity, SubjectComment), Handler: as(s.handleComment)}, {Subject: serverSubject(identity, SubjectCreateIssue), Handler: as(s.handleCreateIssue)}, {Subject: serverSubject(identity, SubjectCloseIssue), Handler: as(s.handleCloseIssue)}, diff --git a/internal/infrastructure/agenttransport/nats/transport.go b/internal/infrastructure/agenttransport/nats/transport.go index e1447826c..312a7fc3b 100644 --- a/internal/infrastructure/agenttransport/nats/transport.go +++ b/internal/infrastructure/agenttransport/nats/transport.go @@ -333,12 +333,12 @@ func (t *Transport) handleTask( var request taskrun.Request if err := json.Unmarshal(msg.Data, &request); err != nil { log.ErrorContext(ctx, "taskrun decode failed", "err", err) - t.respondTask(msg, nil, fmt.Errorf("decode taskrun request: %w", err), log) + t.respondTask(ctx, msg, nil, fmt.Errorf("decode taskrun request: %w", err), log) return } if err := validateTaskRequest(msg.Subject, request, bootTaskID); err != nil { log.ErrorContext(ctx, "taskrun validation failed", "subject", msg.Subject, "err", err) - t.respondTask(msg, nil, fmt.Errorf("validate taskrun request: %w", err), log) + t.respondTask(ctx, msg, nil, fmt.Errorf("validate taskrun request: %w", err), log) return } t.startTracing(ctx, request, log) @@ -346,7 +346,7 @@ func (t *Transport) handleTask( ctx, span := natsrpc.StartServer(ctx, msg) defer span.End() response, err := handler(ctx, request) - t.respondTask(msg, response, err, log) + t.respondTask(ctx, msg, response, err, log) } func validateTaskRequest(subject string, request taskrun.Request, bootTaskID int64) error { @@ -366,7 +366,7 @@ func validateTaskRequest(subject string, request taskrun.Request, bootTaskID int return nil } -func (*Transport) respondTask(msg *natsio.Msg, response *taskrun.Response, runErr error, log *slog.Logger) { +func (*Transport) respondTask(ctx context.Context, msg *natsio.Msg, response *taskrun.Response, runErr error, log *slog.Logger) { if response == nil { response = &taskrun.Response{} } @@ -375,10 +375,10 @@ func (*Transport) respondTask(msg *natsio.Msg, response *taskrun.Response, runEr } data, err := json.Marshal(response) if err != nil { - log.Error("taskrun encode response failed", "err", err) + log.ErrorContext(ctx, "taskrun encode response failed", "err", err) return } if err := msg.RespondMsg(&natsio.Msg{Data: data}); err != nil { - log.Error("taskrun respond failed", "err", err) + log.ErrorContext(ctx, "taskrun respond failed", "err", err) } } diff --git a/internal/infrastructure/forgeext/forgeext_test.go b/internal/infrastructure/forgeext/forgeext_test.go index 3e2431b7f..f5666e82f 100644 --- a/internal/infrastructure/forgeext/forgeext_test.go +++ b/internal/infrastructure/forgeext/forgeext_test.go @@ -112,7 +112,7 @@ func TestSetStateLabelFailureReachesTheCaller(t *testing.T) { }, Log: slog.New(slog.DiscardHandler), } - unsubscribe, err := fs.RegisterFor(nc, "bot") + unsubscribe, err := fs.RegisterFor(t.Context(), nc, "bot") if err != nil { t.Fatal(err) } diff --git a/internal/infrastructure/issuerpc/issuerpc.go b/internal/infrastructure/issuerpc/issuerpc.go index 453cd99c7..966d2dcbd 100644 --- a/internal/infrastructure/issuerpc/issuerpc.go +++ b/internal/infrastructure/issuerpc/issuerpc.go @@ -47,8 +47,8 @@ type Server struct { } // Register serves the issue subjects on nc. -func (s *Server) Register(nc *nats.Conn) (func(), error) { - return natsrpc.RegisterAll(nc, []natsrpc.Registration{ +func (s *Server) Register(ctx context.Context, nc *nats.Conn) (func(), error) { + return natsrpc.RegisterAll(ctx, nc, []natsrpc.Registration{ {Subject: listSubject, Handler: func(ctx context.Context, msg *nats.Msg) { var req request if err := json.Unmarshal(msg.Data, &req); err != nil { diff --git a/internal/infrastructure/logrpc/nats.go b/internal/infrastructure/logrpc/nats.go index 6a3ca048f..20eff3d2c 100644 --- a/internal/infrastructure/logrpc/nats.go +++ b/internal/infrastructure/logrpc/nats.go @@ -14,8 +14,8 @@ import ( const daemonSubject = "archie.logs.archied" -func RegisterDaemon(nc *nats.Conn, feed *logging.Feed, log *slog.Logger) (func(), error) { - return natsrpc.RegisterAll(nc, []natsrpc.Registration{{Subject: daemonSubject, Handler: func(_ context.Context, msg *nats.Msg) { +func RegisterDaemon(ctx context.Context, nc *nats.Conn, feed *logging.Feed, log *slog.Logger) (func(), error) { + return natsrpc.RegisterAll(ctx, nc, []natsrpc.Registration{{Subject: daemonSubject, Handler: func(_ context.Context, msg *nats.Msg) { var q logging.Query if err := json.Unmarshal(msg.Data, &q); err != nil { natsrpc.Respond(msg, log, "logs", reply{Error: "invalid log query"}) diff --git a/internal/infrastructure/taskactions/rpc.go b/internal/infrastructure/taskactions/rpc.go index fb67f545a..9a0847c86 100644 --- a/internal/infrastructure/taskactions/rpc.go +++ b/internal/infrastructure/taskactions/rpc.go @@ -109,8 +109,8 @@ func actionErrorFor(kind string, err error) error { } // Register serves identity-scoped task actions over NATS. -func Register(nc *nats.Conn, service taskactions.Service, log *slog.Logger) (func(), error) { - return natsrpc.RegisterAll(nc, []natsrpc.Registration{{ +func Register(ctx context.Context, nc *nats.Conn, service taskactions.Service, log *slog.Logger) (func(), error) { + return natsrpc.RegisterAll(ctx, nc, []natsrpc.Registration{{ Subject: actionSubject, Handler: func(ctx context.Context, msg *nats.Msg) { var req actionRequest diff --git a/internal/messagerpc/messagerpc.go b/internal/messagerpc/messagerpc.go index 81a8d2910..9ccc6b743 100644 --- a/internal/messagerpc/messagerpc.go +++ b/internal/messagerpc/messagerpc.go @@ -59,8 +59,8 @@ type Server struct { // RegisterFor registers the handler under the subject scoped to identity; // "*" answers every identity. -func (s *Server) RegisterFor(nc *nats.Conn, identity string) (func(), error) { - return natsrpc.RegisterAll(nc, []natsrpc.Registration{{ +func (s *Server) RegisterFor(ctx context.Context, nc *nats.Conn, identity string) (func(), error) { + return natsrpc.RegisterAll(ctx, nc, []natsrpc.Registration{{ Subject: serverSubject(identity), Handler: func(ctx context.Context, msg *nats.Msg) { scoped := identity diff --git a/internal/natsrpc/natsrpc.go b/internal/natsrpc/natsrpc.go index cfc617ccb..d77a7319f 100644 --- a/internal/natsrpc/natsrpc.go +++ b/internal/natsrpc/natsrpc.go @@ -130,7 +130,7 @@ type Registration struct { // RegisterAll subscribes every registration and flushes, unsubscribing all // of them on any failure. The returned func unsubscribes all. -func RegisterAll(nc *nats.Conn, regs []Registration) (unsubscribe func(), err error) { +func RegisterAll(ctx context.Context, nc *nats.Conn, regs []Registration) (unsubscribe func(), err error) { subs := make([]*nats.Subscription, 0, len(regs)) unsubscribeAll := func() { for _, s := range subs { @@ -139,7 +139,7 @@ func RegisterAll(nc *nats.Conn, regs []Registration) (unsubscribe func(), err er } for _, r := range regs { - sub, subErr := nc.Subscribe(r.Subject, serve(r.Handler)) + sub, subErr := nc.Subscribe(r.Subject, serve(ctx, r.Handler)) if subErr != nil { unsubscribeAll() return nil, fmt.Errorf("subscribe %s: %w", r.Subject, subErr) @@ -155,9 +155,12 @@ func RegisterAll(nc *nats.Conn, regs []Registration) (unsubscribe func(), err er return unsubscribeAll, nil } -func serve(h func(context.Context, *nats.Msg)) nats.MsgHandler { +// serve roots each request in base without its cancellation, so a handler +// keeps the registering service's values but outlives the call that registered it. +func serve(base context.Context, h func(context.Context, *nats.Msg)) nats.MsgHandler { + base = context.WithoutCancel(base) return func(msg *nats.Msg) { - ctx, span := StartServer(context.Background(), msg) + ctx, span := StartServer(base, msg) defer span.End() h(ctx, msg) } diff --git a/internal/worktreerpc/worktreerpc.go b/internal/worktreerpc/worktreerpc.go index 0680a709e..eb514dbaa 100644 --- a/internal/worktreerpc/worktreerpc.go +++ b/internal/worktreerpc/worktreerpc.go @@ -90,7 +90,7 @@ func (s *Server) handlerContext(parent context.Context) (context.Context, contex } // RegisterFor registers publication under the subject scoped to identity. -func (s *Server) RegisterFor(nc *nats.Conn, identity string) (unsubscribe func(), err error) { +func (s *Server) RegisterFor(ctx context.Context, nc *nats.Conn, identity string) (unsubscribe func(), err error) { subject, baseline := SubjectFor(identity, SubjectPush), SubjectFor(identity, SubjectBaseline) if identity == "*" { subject, baseline = "archie.worktree.*.push", "archie.worktree.*.baseline" @@ -101,7 +101,7 @@ func (s *Server) RegisterFor(nc *nats.Conn, identity string) (unsubscribe func() } return identity } - return natsrpc.RegisterAll(nc, []natsrpc.Registration{ + return natsrpc.RegisterAll(ctx, nc, []natsrpc.Registration{ {Subject: subject, Handler: func(ctx context.Context, msg *nats.Msg) { s.handlePush(ctx, scope(msg), msg) }}, {Subject: baseline, Handler: func(ctx context.Context, msg *nats.Msg) { s.handleBaseline(ctx, scope(msg), msg) }}, })