refactor: log through the injected logger with context; NATS handlers root in the registering context (#1927)

This commit is contained in:
sam committed 2026-11-13 03:56:12 +11:00
1 parent afaea346ee
commit f4c304cfba
23 files changed
+139 -129

No files matched your search

+23 -23
View File
@@ -339,14 +339,14 @@ func (b *boot) handleRequeue(ctx context.Context, requeue int64, once bool) (boo
return !once, nil 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()) result, err := configuration.SeedSoul(cfgPath, agent.ShippedSoul())
if err != nil { if err != nil {
b.log.Warn("soul: starter file unavailable", "err", err) b.log.WarnContext(ctx, "soul: starter file unavailable", "err", err)
return return
} }
if result.Action == configuration.SoulCreated { 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 log := b.log
if b.natsClient == nil { if b.natsClient == nil {
return nil return nil
} }
coreConn, err := b.natsClient.CoreConn() coreConn, err := b.natsClient.CoreConn()
if err != nil { 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 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 { if b.d == nil {
return daemon.RepositoryAccess{}, errors.New("repository connections starting") 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) return b.messaging.Deliver(ctx, org, channel, chatID, text)
}, b.stateStoreGrants.Client, installedAuthorities{b.stateStoreGrants.Client}, log) }, b.stateStoreGrants.Client, installedAuthorities{b.stateStoreGrants.Client}, log)
if err != nil { if err != nil {
log.Error("task RPC server registration failed", "err", err) log.ErrorContext(ctx, "task RPC server registration failed", "err", err)
return err return err
} }
b.addCleanup(unsubscribe) b.addCleanup(unsubscribe)
stopLogs, err := logrpc.RegisterDaemon(coreConn, b.logFeed, log) stopLogs, err := logrpc.RegisterDaemon(ctx, coreConn, b.logFeed, log)
if err != nil { if err != nil {
return fmt.Errorf("register daemon logs: %w", err) return fmt.Errorf("register daemon logs: %w", err)
} }
b.addCleanup(stopLogs) b.addCleanup(stopLogs)
unsubscribeSystemLogs, err := subscribeSystemLogs(coreConn, b.taskLogs, log) unsubscribeSystemLogs, err := subscribeSystemLogs(ctx, coreConn, b.taskLogs, log)
if err != nil { if err != nil {
log.Error("system log subscribe failed", "err", err) log.ErrorContext(ctx, "system log subscribe failed", "err", err)
return err return err
} }
b.addCleanup(unsubscribeSystemLogs) b.addCleanup(unsubscribeSystemLogs)
unsubscribeAgentEvents, err := subscribeAgentEvents(coreConn, b.bus, log) unsubscribeAgentEvents, err := subscribeAgentEvents(ctx, coreConn, b.bus, log)
if err != nil { if err != nil {
log.Error("agent event subscribe failed", "err", err) log.ErrorContext(ctx, "agent event subscribe failed", "err", err)
return err return err
} }
b.addCleanup(unsubscribeAgentEvents) b.addCleanup(unsubscribeAgentEvents)
unsubscribeTaskActions, err := taskactions.Register(coreConn, b.taskActions(), log) unsubscribeTaskActions, err := taskactions.Register(ctx, coreConn, b.taskActions(), log)
if err != nil { if err != nil {
log.Error("gateway task action register failed", "err", err) log.ErrorContext(ctx, "gateway task action register failed", "err", err)
return err return err
} }
b.addCleanup(unsubscribeTaskActions) 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 { if err != nil {
log.Error("issue RPC register failed", "err", err) log.ErrorContext(ctx, "issue RPC register failed", "err", err)
return err return err
} }
b.addCleanup(unsubscribeIssues) 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) return b.repositoryForge(ctx, owner, repo)
} }
func (b *boot) buildDaemon() { func (b *boot) buildDaemon(ctx context.Context) {
log := b.log log := b.log
b.d = &daemon.Daemon{ b.d = &daemon.Daemon{
ResolveRepository: b.repositoryAccess, ResolveRepository: b.repositoryAccess,
Cfg: b.cfgHolder, Cfg: b.cfgHolder,
ConnectedNATS: daemon.NATSEndpoint{URL: b.natsURL, Token: b.natsToken, Scoped: b.cfg.NATS.Mode != config.NATSModeExternal}, 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, Store: b.stateStore,
Bus: b.bus, Bus: b.bus,
Forge: b.forgeClient, Forge: b.forgeClient,
@@ -653,14 +653,14 @@ func (b *boot) buildDaemon() {
if denials, ok := b.stateStore.(access.DenialRecorder); ok { if denials, ok := b.stateStore.(access.DenialRecorder); ok {
b.d.Denials = denials 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 { if pd, ok := source.(storecontract.PlaybookDispatcher); ok {
return pd 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 return nil
} }
@@ -839,10 +839,10 @@ const playbookRefreshInterval = 30 * time.Second
// stateStoreCA is the CA a task container verifies the State Store with; // stateStoreCA is the CA a task container verifies the State Store with;
// nil without [tls]. // 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) id, err := servicekit.Identity(b.cfg.TLS, presence.Daemon)
if err != nil { 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 nil
} }
return id.CAPEM() return id.CAPEM()
+26 -27
View File
@@ -163,23 +163,23 @@ func Run() int { //nolint:cyclop,funlen // the composition root's setup sequence
return 1 return 1
} }
if err := b.loadRuntimeConfig(ctx); err != nil { 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 return 1
} }
b.openForge(ctx) b.openForge(ctx)
if err := b.startLiveSettings(ctx); err != nil { 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 return 1
} }
go b.applyStatus.Run(ctx) 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 { if exit, err := b.handleRequeue(ctx, args.requeue, args.once); err != nil {
return 1 return 1
} else if exit { } else if exit {
return 0 return 0
} }
b.loadCatalog(ctx) b.loadCatalog(ctx)
b.seedSoul(args.cfgPath) b.seedSoul(ctx, args.cfgPath)
b.setupObservability(ctx) b.setupObservability(ctx)
if err := b.setupBackends(ctx); err != nil { 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.startModelCatalogRefresh(ctx)
b.buildWorktreeManager() b.buildWorktreeManager()
if err := b.registerNATSRPC(); err != nil { if err := b.registerNATSRPC(ctx); err != nil {
return 1 return 1
} }
b.buildDaemon() b.buildDaemon(ctx)
if err := b.setupScheduling(); err != nil { if err := b.setupScheduling(); err != nil {
return 1 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 // currently open there -- late, duplicate, or from an attempt this instance
// never dispatched -- is expected and silently dropped rather than treated as // never dispatched -- is expected and silently dropped rather than treated as
// an error. // 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) { sub, err := nc.Subscribe(agentexec.SubjectSystemWildcard, func(msg *natsio.Msg) {
taskID, ok := agentexec.TaskIDFromSystemSubject(msg.Subject) taskID, ok := agentexec.TaskIDFromSystemSubject(msg.Subject)
if !ok { 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 return
} }
var entry logging.Entry var entry logging.Entry
if err := json.Unmarshal(msg.Data, &entry); err != nil { 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 return
} }
// The NATS callback has no context of its own; the write is an append to // The write is an append to an already-open sink, so it must outlive ctx.
// an already-open sink, so there is nothing to cancel.
if entry.Fields == nil { if entry.Fields == nil {
entry.Fields = map[string]any{} entry.Fields = map[string]any{}
} }
entry.Fields["service"] = presence.Agent entry.Fields["service"] = presence.Agent
entry.Fields["task_id"] = taskID entry.Fields["task_id"] = taskID
taskLogs.Write(context.Background(), taskID, entry) taskLogs.Write(context.WithoutCancel(ctx), taskID, entry)
}) })
if err != nil { if err != nil {
return nil, err return nil, err
} }
return func() { return func() {
if err := sub.Unsubscribe(); err != nil { if err := sub.Unsubscribe(); err != nil {
log.Warn("system log unsubscribe failed", "err", err) log.WarnContext(ctx, "system log unsubscribe failed", "err", err)
} }
}, nil }, 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 // choke point that inserts into the events table and fans out over
// SSE -- treats them exactly like every other daemon-observed event. Mirrors // SSE -- treats them exactly like every other daemon-observed event. Mirrors
// subscribeSystemLogs's demux-by-taskID shape. // 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) { sub, err := nc.Subscribe(agentexec.SubjectEventsWildcard, func(msg *natsio.Msg) {
taskID, ok := agentexec.TaskIDFromEventsSubject(msg.Subject) taskID, ok := agentexec.TaskIDFromEventsSubject(msg.Subject)
if !ok { 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 return
} }
var e events.Event var e events.Event
if err := json.Unmarshal(msg.Data, &e); err != nil { 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 return
} }
bus.Publish(context.Background(), e) bus.Publish(context.WithoutCancel(ctx), e)
}) })
if err != nil { if err != nil {
return nil, err return nil, err
} }
if err := nc.Flush(); err != nil { if err := nc.Flush(); err != nil {
if cleanupErr := sub.Unsubscribe(); cleanupErr != 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 nil, fmt.Errorf("flush task event subscription: %w", err)
} }
return func() { return func() {
if err := sub.Unsubscribe(); err != nil { if err := sub.Unsubscribe(); err != nil {
log.Warn("task event unsubscribe failed", "err", err) log.WarnContext(ctx, "task event unsubscribe failed", "err", err)
} }
}, nil }, 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. // registerTaskRPCServers routes each request through the current task binding.
// Wildcard subjects serve identities created after daemon startup; credentials // Wildcard subjects serve identities created after daemon startup; credentials
// and repository bounds are checked before the connection is resolved. // 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() var unsubs []func()
unsubscribe := func() { unsubscribe := func() {
for _, stop := range unsubs { for _, stop := range unsubs {
@@ -348,8 +347,8 @@ func registerTaskRPCServers(nc *natsio.Conn, resolve func(context.Context, *work
return resolved.Trees, err return resolved.Trees, err
}} }}
messages := &messagerpc.Server{Runs: runs, Deliver: deliver, Log: log} messages := &messagerpc.Server{Runs: runs, Deliver: deliver, Log: log}
for _, register := range []func(*natsio.Conn, string) (func(), error){messages.RegisterFor, fg.RegisterFor, trees.RegisterFor} { for _, register := range []func(context.Context, *natsio.Conn, string) (func(), error){messages.RegisterFor, fg.RegisterFor, trees.RegisterFor} {
stop, err := register(nc, "*") stop, err := register(ctx, nc, "*")
if err != nil { if err != nil {
unsubscribe() unsubscribe()
return nil, err return nil, err
@@ -401,7 +400,7 @@ func startContainers(
MaxConcurrency: cfg.Containers.MaxConcurrency, MaxConcurrency: cfg.Containers.MaxConcurrency,
MaxUptime: cfg.Containers.MaxUptime.Std(), MaxUptime: cfg.Containers.MaxUptime.Std(),
PullPolicy: cfg.Containers.PullPolicy, PullPolicy: cfg.Containers.PullPolicy,
RegistryAuth: resolveRegistryAuth(cfg.Containers.RegistryAuth, secrets, log), RegistryAuth: resolveRegistryAuth(ctx, cfg.Containers.RegistryAuth, secrets, log),
Network: cfg.Containers.Network, Network: cfg.Containers.Network,
DockerClient: dockerCli, DockerClient: dockerCli,
// The embedded broker binds the host gateway, and a loopback State // 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 // 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 // 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. // 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{}) { if ref == (secret.SecretRef{}) {
return "" return ""
} }
if secrets == nil { 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 "" return ""
} }
value, err := secrets.Resolve(ref) value, err := secrets.Resolve(ref)
if err != nil { 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 "" return ""
} }
if strings.TrimSpace(value) == "" { 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 ""
} }
return value return value
+3 -3
View File
@@ -346,7 +346,7 @@ func spawnRecovery(ctx context.Context, configPath string) error {
// watchUpdateRecovery recovers a transaction whose watchdog died while this // watchUpdateRecovery recovers a transaction whose watchdog died while this
// daemon kept running. An orphan must be seen on two consecutive checks so a // 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. // 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) ticker := time.NewTicker(every)
defer ticker.Stop() defer ticker.Stop()
seen := false seen := false
@@ -358,12 +358,12 @@ func watchUpdateRecovery(ctx context.Context, configPath string, every time.Dura
} }
orphaned, err := updateOrphaned() orphaned, err := updateOrphaned()
if err != nil { if err != nil {
slog.WarnContext(ctx, "check update recovery", "error", err) log.WarnContext(ctx, "check update recovery", "error", err)
continue continue
} }
if orphaned && seen { if orphaned && seen {
if err := spawnRecovery(ctx, configPath); err != nil { if err := spawnRecovery(ctx, configPath); err != nil {
slog.WarnContext(ctx, "recover update", "error", err) log.WarnContext(ctx, "recover update", "error", err)
} }
} }
seen = orphaned seen = orphaned
+5 -5
View File
@@ -50,15 +50,15 @@ func (b *server) claimGatewayOwnership(ctx context.Context) error {
return nil 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{ client, ok := transcription.New(cfg.Models, cfg.Providers, transcription.Options{
ResolveSecret: b.secrets.Resolve, ResolveSecret: b.secrets.Resolve,
}) })
if ok { if ok {
b.transcriber = client 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 { } 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 // 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 // next turn without rebuilding the runner, and the model manager re-derives
// the aliases it offers. // 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 { if b.chatModels == nil {
return // this process serves no chat turns return // this process serves no chat turns
} }
@@ -95,7 +95,7 @@ func (b *server) rebuildChatModelRuntime(cfg config.Config) {
b.chatModels.SetConfigured(cfg.Models) b.chatModels.SetConfigured(cfg.Models)
catalog := b.catalogState() catalog := b.catalogState()
b.chatModels.SetModelCatalog(catalog) 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 // sessionKey builds a deterministic session identifier from a gateway
@@ -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 // 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 // own [models]/[providers]. The Messaging Service carries a voice note's
// bytes to the Gateway and never holds the credential. // bytes to the Gateway and never holds the credential.
b.setupTranscriber(cfg, b.log) b.setupTranscriber(ctx, cfg, b.log)
b.toolReg = tools.NewRegistry() b.toolReg = tools.NewRegistry()
chatModels := newChatModelManager(cfg.Models) chatModels := newChatModelManager(cfg.Models)
catalog := b.catalogState() catalog := b.catalogState()
+1 -1
View File
@@ -374,7 +374,7 @@ func (b *server) relayer(ctx context.Context, base config.Config, kind string) e
return err return err
} }
b.cfgHolder.Set(cfg) b.cfgHolder.Set(cfg)
b.rebuildChatModelRuntime(cfg) b.rebuildChatModelRuntime(ctx, cfg)
var problems []error var problems []error
if kind == controlplanestore.ToolSettingsKind { if kind == controlplanestore.ToolSettingsKind {
if err := b.reconcileToolSettings(ctx, cfg); err != nil { if err := b.reconcileToolSettings(ctx, cfg); err != nil {
+5 -5
View File
@@ -62,7 +62,7 @@ func (s *Service) runChannel(ctx context.Context, c *channelInstance) {
// idempotent tail for the paths that leave a listener behind. // idempotent tail for the paths that leave a listener behind.
s.stopChannel(ctx, c.name, ch) 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 { if next == nextStop {
return return
} }
@@ -93,7 +93,7 @@ const (
// afterChannelRun records the ended run's state and decides what the supervisor // afterChannelRun records the ended run's state and decides what the supervisor
// does next. shutdown is the service stopping; restart is an explicit // does next. shutdown is the service stopping; restart is an explicit
// replacement already waiting in the instance. // 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 { switch {
case shutdown: case shutdown:
if err != nil && !errors.Is(err, context.Canceled) { 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 // The channel stopped itself. Hold it stopped rather than spending the
// failure retry budget on a run that chose to end. // failure retry budget on a run that chose to end.
s.status.MarkStopped(c.name, "") 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 return nextPark, 0
case attempts >= s.retry.attempts: case attempts >= s.retry.attempts:
s.status.MarkFailed(c.name, err.Error()) 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) "name", c.name, "attempts", attempts, "err", err)
return nextPark, 0 return nextPark, 0
default: default:
s.status.MarkFailed(c.name, err.Error()) s.status.MarkFailed(c.name, err.Error())
wait := s.retry.backoffFor(attempts) 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) "attempt", attempts, "of", s.retry.attempts, "in", wait, "err", err)
return nextRetry, wait return nextRetry, wait
} }
+7 -7
View File
@@ -124,8 +124,8 @@ func compose(ctx context.Context, d deps) *webui.Server {
srv.Access = d.Access srv.Access = d.Access
srv.Principals = d.Principals srv.Principals = d.Principals
srv.Denials = d.Denials srv.Denials = d.Denials
wireTaskLogs(d, srv) wireTaskLogs(ctx, d, srv)
wireCaptureSurfaces(d, srv) wireCaptureSurfaces(ctx, d, srv)
return 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 // 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 // the page reporting that this process cannot read logs, which is true, rather
// than that the attempt has none, which it cannot know. // 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) logs, ok := d.Store.(storecontract.TaskLogStore)
if !ok { if !ok {
if d.Store != nil { 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 return
} }
@@ -198,14 +198,14 @@ func wireTaskLogs(d deps, srv *webui.Server) {
// wireCaptureSurfaces attaches capture listing, source editing and intake. A // wireCaptureSurfaces attaches capture listing, source editing and intake. A
// store missing a contract degrades that part with a warning. // 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 { if dispatches, ok := d.Store.(storecontract.DispatchLedger); ok {
srv.Dispatches = dispatches srv.Dispatches = dispatches
} }
captures, hasCaptures := d.Store.(storecontract.CaptureStore) captures, hasCaptures := d.Store.(storecontract.CaptureStore)
sources, hasSources := d.Store.(storecontract.SourceStore) sources, hasSources := d.Store.(storecontract.SourceStore)
if !hasCaptures { 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 return
} }
var resolver captureintake.SourceResolver var resolver captureintake.SourceResolver
@@ -213,7 +213,7 @@ func wireCaptureSurfaces(d deps, srv *webui.Server) {
srv.Sources = sources srv.Sources = sources
resolver = sources resolver = sources
} else { } 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() capture := d.Options.Capture.withDefaults()
+4 -3
View File
@@ -27,6 +27,7 @@ type liveReviewer struct {
cfg config.Config cfg config.Config
agent agentrun.Runner agent agentrun.Runner
source workflow.PRSource source workflow.PRSource
log *slog.Logger
nextID atomic.Int64 nextID atomic.Int64
} }
@@ -35,10 +36,10 @@ func (r *liveReviewer) Review(ctx context.Context, p bench.Problem) (bench.Revie
if err != nil { if err != nil {
return bench.Review{}, err 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{ 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"}}, 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) decision, err := workflow.ReviewPullRequest(ctx, tc)
if err != nil { if err != nil {
@@ -48,7 +49,7 @@ func (r *liveReviewer) Review(ctx context.Context, p bench.Problem) (bench.Revie
if decision.Comments == nil { if decision.Comments == nil {
decision.Comments = []prreview.ScoredFinding{} 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 return bench.Review{Comments: decision.Comments, SkippedPhases: decision.SkippedPhases}, nil
} }
+12 -5
View File
@@ -28,6 +28,7 @@ import (
"github.com/samcharles93/archie-core/internal/domain/workflow/prreview/bench" "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/configuration"
"github.com/samcharles93/archie-core/internal/infrastructure/prsource" "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. // 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 // Run reviews and judges the selected problems, writes the report into
// Options.OutDir, and prints it to w. // Options.OutDir, and prints it to w. log receives the run's progress.
func Run(ctx context.Context, opts Options, w io.Writer) (bench.Summary, error) { func Run(ctx context.Context, log *slog.Logger, opts Options, w io.Writer) (bench.Summary, error) {
problems, err := Problems(opts.Problems) problems, err := Problems(opts.Problems)
if err != nil { if err != nil {
return bench.Summary{}, err 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 return bench.Summary{}, err
} }
cfg := doc.Config cfg := doc.Config
if err := servicekit.ResolveProviders(&cfg, slog.Default()); err != nil { if err := servicekit.ResolveProviders(&cfg, log); err != nil {
return bench.Summary{}, err return bench.Summary{}, err
} }
reviewRef, err := resolveRef(cfg.Models, opts.Model) 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. // The pipeline resolves its model through the default alias.
cfg.Models = map[string]string{config.DefaultModelAlias: reviewRef} 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} judge := &modelJudge{runtime: rt, modelRef: judgeRef}
results := bench.Run(ctx, problems, reviewer, judge, opts.Concurrency) results := bench.Run(ctx, problems, reviewer, judge, opts.Concurrency)
@@ -138,9 +139,15 @@ func Main(args []string, stdout, stderr io.Writer) int {
if problems != "" { if problems != "" {
opts.Problems = strings.Split(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) ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
defer stop() 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) fmt.Fprintln(stderr, "archied prbench:", err)
return 1 return 1
} }
+7 -7
View File
@@ -107,7 +107,7 @@ func Run(ctx context.Context, options Options) error { //nolint:cyclop // the co
if err != nil { if err != nil {
return fmt.Errorf("import control-plane resources: %w", err) return fmt.Errorf("import control-plane resources: %w", err)
} }
b.reportUnseededResources(skipped) b.reportUnseededResources(ctx, skipped)
grants, err := b.runCredentials(ctx) grants, err := b.runCredentials(ctx)
if err != nil { 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. // accepting the moment it is called.
b.announceReady() b.announceReady()
deps := b.stateStoreDeps(grants) deps := b.stateStoreDeps(ctx, grants)
controlPlaneDeps(&deps, control) controlPlaneDeps(&deps, control)
b.startSweeps(ctx, deps) b.startSweeps(ctx, deps)
return serveStateStore(ctx, listener, deps, opts) 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 // 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, // is at its complexity budget: the branch belongs to the report's own policy,
// not to the sequence that triggers it. // 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 { for _, skip := range skipped {
if len(skip.Removed) > 0 { 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) "kind", skip.Kind, "removed", skip.Removed)
continue 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) "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 // the capture/mapping/binding surfaces, so each is asserted here (the same
// pattern the daemon's wireWebStoreSurfaces uses) and a store that lacks one // pattern the daemon's wireWebStoreSurfaces uses) and a store that lacks one
// degrades that group rather than aborting boot. // 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{ deps := staterpc.Deps{
LogFeed: b.logFeed, LogFeed: b.logFeed,
Tasks: b.st, Log: b.log, Grants: grants, 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. // and reports, rather than refusing to serve the task tables.
projections, err := newPackageProjections(b.pg) projections, err := newPackageProjections(b.pg)
if err != nil { if err != nil {
b.log.Error("build package projections", "err", err) b.log.ErrorContext(ctx, "build package projections", "err", err)
} else { } else {
packages.Projections = projections packages.Projections = projections
} }
+7 -7
View File
@@ -593,15 +593,15 @@ func (p *Pool) Close() error {
Filters: client.Filters{}.Add("label", daemonLabel+"="+p.cfg.Instance), Filters: client.Filters{}.Add("label", daemonLabel+"="+p.cfg.Instance),
}) })
if err != nil { 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 { } else {
for _, c := range list.Items { 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 { 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 { 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) 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 { if err != nil {
return fmt.Errorf("pull %s: %w", ref, err) 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 // registryAuthHeader returns the X-Registry-Auth value, or "". A credential
// that cannot be rendered logs a warning and pulls anonymously. // 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 == "" { if cfg.RegistryAuth == "" {
return "" return ""
} }
encoded, err := encodeRegistryAuth(cfg.RegistryAuth) encoded, err := encodeRegistryAuth(cfg.RegistryAuth)
if err != nil { 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 ""
} }
return encoded return encoded
+8 -8
View File
@@ -284,7 +284,7 @@ func (rt *Runtime) runLoop(ctx context.Context, name string, c CuratorEngine, wa
due, err := rt.safeCheck(ctx, c) due, err := rt.safeCheck(ctx, c)
if err != nil { if err != nil {
rt.fail(name, "check", err) rt.fail(ctx, name, "check", err)
next = clock.Now().Add(cooldown) next = clock.Now().Add(cooldown)
continue continue
} }
@@ -307,11 +307,11 @@ func (rt *Runtime) runLoop(ctx context.Context, name string, c CuratorEngine, wa
now = clock.Now() now = clock.Now()
lastPass = now lastPass = now
if perr != nil { if perr != nil {
rt.fail(name, "pass", perr) rt.fail(ctx, name, "pass", perr)
next = now.Add(cooldown) next = now.Add(cooldown)
} else { } else {
next = scheduleNext(now, m, cooldown, result) 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 // 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 // non-blocking by contract (bounded dropping buffers), so even a failing
// curator cannot backpressure anything. // 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 { 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 { if sink := rt.registry.Host().Events; sink != nil {
sink.Emit(events.KindCuratorError, name, map[string]any{ 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, // emitRun publishes one run summary plus one event per action, so what ran,
// when, what it changed, and why all stay attributable. // 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) rt.registry.RecordActivity(name, at, result.Actions)
host := rt.registry.Host() host := rt.registry.Host()
if log := host.Log; log != nil { 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 { 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)
} }
} }
+4 -4
View File
@@ -119,7 +119,7 @@ func runDiffRules(ctx context.Context, tc *TaskContext, rules []compiledDiffRule
var blocking []diffFinding var blocking []diffFinding
for _, finding := range matchDiffRules(rules, added) { for _, finding := range matchDiffRules(rules, added) {
logRuleFinding(tc, finding) logRuleFinding(ctx, tc, finding)
if finding.Blocking() { if finding.Blocking() {
blocking = append(blocking, finding) 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 // logRuleFinding logs a finding as a warning when it blocks and as info when
// advisory, with the rule's declared level as rule_level. // 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{ attributes := []any{
"rule_level", finding.Level, "rule_level", finding.Level,
"rule", finding.Rule, "rule", finding.Rule,
@@ -170,10 +170,10 @@ func logRuleFinding(tc *TaskContext, finding diffFinding) {
"message", finding.Message, "message", finding.Message,
} }
if finding.Blocking() { if finding.Blocking() {
tc.Log.Warn("diff rule finding", attributes...) tc.Log.WarnContext(ctx, "diff rule finding", attributes...)
return 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 // renderDiffRuleFindings formats the blocking findings as a park reason: one
+2 -2
View File
@@ -171,7 +171,7 @@ type Server struct {
} }
// RegisterFor registers all handlers under the subjects scoped to identity. // 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) { as := func(h func(context.Context, string, *nats.Msg)) func(context.Context, *nats.Msg) {
return func(ctx context.Context, msg *nats.Msg) { return func(ctx context.Context, msg *nats.Msg) {
scoped := identity scoped := identity
@@ -181,7 +181,7 @@ func (s *Server) RegisterFor(nc *nats.Conn, identity string) (unsubscribe func()
h(ctx, scoped, msg) 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, SubjectComment), Handler: as(s.handleComment)},
{Subject: serverSubject(identity, SubjectCreateIssue), Handler: as(s.handleCreateIssue)}, {Subject: serverSubject(identity, SubjectCreateIssue), Handler: as(s.handleCreateIssue)},
{Subject: serverSubject(identity, SubjectCloseIssue), Handler: as(s.handleCloseIssue)}, {Subject: serverSubject(identity, SubjectCloseIssue), Handler: as(s.handleCloseIssue)},
@@ -333,12 +333,12 @@ func (t *Transport) handleTask(
var request taskrun.Request var request taskrun.Request
if err := json.Unmarshal(msg.Data, &request); err != nil { if err := json.Unmarshal(msg.Data, &request); err != nil {
log.ErrorContext(ctx, "taskrun decode failed", "err", err) 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 return
} }
if err := validateTaskRequest(msg.Subject, request, bootTaskID); err != nil { if err := validateTaskRequest(msg.Subject, request, bootTaskID); err != nil {
log.ErrorContext(ctx, "taskrun validation failed", "subject", msg.Subject, "err", err) 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 return
} }
t.startTracing(ctx, request, log) t.startTracing(ctx, request, log)
@@ -346,7 +346,7 @@ func (t *Transport) handleTask(
ctx, span := natsrpc.StartServer(ctx, msg) ctx, span := natsrpc.StartServer(ctx, msg)
defer span.End() defer span.End()
response, err := handler(ctx, request) 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 { 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 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 { if response == nil {
response = &taskrun.Response{} response = &taskrun.Response{}
} }
@@ -375,10 +375,10 @@ func (*Transport) respondTask(msg *natsio.Msg, response *taskrun.Response, runEr
} }
data, err := json.Marshal(response) data, err := json.Marshal(response)
if err != nil { if err != nil {
log.Error("taskrun encode response failed", "err", err) log.ErrorContext(ctx, "taskrun encode response failed", "err", err)
return return
} }
if err := msg.RespondMsg(&natsio.Msg{Data: data}); err != nil { 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)
} }
} }
@@ -112,7 +112,7 @@ func TestSetStateLabelFailureReachesTheCaller(t *testing.T) {
}, },
Log: slog.New(slog.DiscardHandler), Log: slog.New(slog.DiscardHandler),
} }
unsubscribe, err := fs.RegisterFor(nc, "bot") unsubscribe, err := fs.RegisterFor(t.Context(), nc, "bot")
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
+2 -2
View File
@@ -47,8 +47,8 @@ type Server struct {
} }
// Register serves the issue subjects on nc. // Register serves the issue subjects on nc.
func (s *Server) Register(nc *nats.Conn) (func(), error) { func (s *Server) Register(ctx context.Context, nc *nats.Conn) (func(), error) {
return natsrpc.RegisterAll(nc, []natsrpc.Registration{ return natsrpc.RegisterAll(ctx, nc, []natsrpc.Registration{
{Subject: listSubject, Handler: func(ctx context.Context, msg *nats.Msg) { {Subject: listSubject, Handler: func(ctx context.Context, msg *nats.Msg) {
var req request var req request
if err := json.Unmarshal(msg.Data, &req); err != nil { if err := json.Unmarshal(msg.Data, &req); err != nil {
+2 -2
View File
@@ -14,8 +14,8 @@ import (
const daemonSubject = "archie.logs.archied" const daemonSubject = "archie.logs.archied"
func RegisterDaemon(nc *nats.Conn, feed *logging.Feed, log *slog.Logger) (func(), error) { func RegisterDaemon(ctx context.Context, 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) { return natsrpc.RegisterAll(ctx, nc, []natsrpc.Registration{{Subject: daemonSubject, Handler: func(_ context.Context, msg *nats.Msg) {
var q logging.Query var q logging.Query
if err := json.Unmarshal(msg.Data, &q); err != nil { if err := json.Unmarshal(msg.Data, &q); err != nil {
natsrpc.Respond(msg, log, "logs", reply{Error: "invalid log query"}) natsrpc.Respond(msg, log, "logs", reply{Error: "invalid log query"})
+2 -2
View File
@@ -109,8 +109,8 @@ func actionErrorFor(kind string, err error) error {
} }
// Register serves identity-scoped task actions over NATS. // Register serves identity-scoped task actions over NATS.
func Register(nc *nats.Conn, service taskactions.Service, log *slog.Logger) (func(), error) { func Register(ctx context.Context, nc *nats.Conn, service taskactions.Service, log *slog.Logger) (func(), error) {
return natsrpc.RegisterAll(nc, []natsrpc.Registration{{ return natsrpc.RegisterAll(ctx, nc, []natsrpc.Registration{{
Subject: actionSubject, Subject: actionSubject,
Handler: func(ctx context.Context, msg *nats.Msg) { Handler: func(ctx context.Context, msg *nats.Msg) {
var req actionRequest var req actionRequest
+2 -2
View File
@@ -59,8 +59,8 @@ type Server struct {
// RegisterFor registers the handler under the subject scoped to identity; // RegisterFor registers the handler under the subject scoped to identity;
// "*" answers every identity. // "*" answers every identity.
func (s *Server) RegisterFor(nc *nats.Conn, identity string) (func(), error) { func (s *Server) RegisterFor(ctx context.Context, nc *nats.Conn, identity string) (func(), error) {
return natsrpc.RegisterAll(nc, []natsrpc.Registration{{ return natsrpc.RegisterAll(ctx, nc, []natsrpc.Registration{{
Subject: serverSubject(identity), Subject: serverSubject(identity),
Handler: func(ctx context.Context, msg *nats.Msg) { Handler: func(ctx context.Context, msg *nats.Msg) {
scoped := identity scoped := identity
+7 -4
View File
@@ -130,7 +130,7 @@ type Registration struct {
// RegisterAll subscribes every registration and flushes, unsubscribing all // RegisterAll subscribes every registration and flushes, unsubscribing all
// of them on any failure. The returned func unsubscribes 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)) subs := make([]*nats.Subscription, 0, len(regs))
unsubscribeAll := func() { unsubscribeAll := func() {
for _, s := range subs { for _, s := range subs {
@@ -139,7 +139,7 @@ func RegisterAll(nc *nats.Conn, regs []Registration) (unsubscribe func(), err er
} }
for _, r := range regs { 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 { if subErr != nil {
unsubscribeAll() unsubscribeAll()
return nil, fmt.Errorf("subscribe %s: %w", r.Subject, subErr) 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 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) { return func(msg *nats.Msg) {
ctx, span := StartServer(context.Background(), msg) ctx, span := StartServer(base, msg)
defer span.End() defer span.End()
h(ctx, msg) h(ctx, msg)
} }
+2 -2
View File
@@ -90,7 +90,7 @@ func (s *Server) handlerContext(parent context.Context) (context.Context, contex
} }
// RegisterFor registers publication under the subject scoped to identity. // 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) subject, baseline := SubjectFor(identity, SubjectPush), SubjectFor(identity, SubjectBaseline)
if identity == "*" { if identity == "*" {
subject, baseline = "archie.worktree.*.push", "archie.worktree.*.baseline" 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 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: 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) }}, {Subject: baseline, Handler: func(ctx context.Context, msg *nats.Msg) { s.handleBaseline(ctx, scope(msg), msg) }},
}) })