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
}
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()
+26 -27
View File
@@ -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
+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
// 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
+5 -5
View File
@@ -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
@@ -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()
+1 -1
View File
@@ -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 {
+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.
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
}
+7 -7
View File
@@ -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()
+4 -3
View File
@@ -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
}
+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/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
}
+7 -7
View File
@@ -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
}
+7 -7
View File
@@ -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
+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)
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)
}
}
+4 -4
View File
@@ -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
+2 -2
View File
@@ -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)},
@@ -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)
}
}
@@ -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)
}
+2 -2
View File
@@ -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 {
+2 -2
View File
@@ -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"})
+2 -2
View File
@@ -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
+2 -2
View File
@@ -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
+7 -4
View File
@@ -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)
}
+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.
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) }},
})