refactor: log through the injected logger with context; NATS handlers root in the registering context (#1927)
This commit is contained in:
23 files changed
+139
-129
No files matched your search
@@ -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()
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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()
|
||||
|
||||
@@ -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 {
|
||||
|
||||
@@ -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
|
||||
}
|
||||
|
||||
@@ -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()
|
||||
|
||||
@@ -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
|
||||
}
|
||||
|
||||
|
||||
@@ -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
|
||||
}
|
||||
|
||||
@@ -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
|
||||
}
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
|
||||
@@ -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 {
|
||||
|
||||
@@ -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"})
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
|
||||
@@ -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) }},
|
||||
})
|
||||
|
||||
Reference in new issue
Block a user