fix(sdnotify,staterpc): log with the request context so lines carry a trace id (#1936)
This commit is contained in:
26 files changed
+150
-150
No files matched your search
@@ -766,7 +766,7 @@ func exitCode(err error) int {
|
||||
|
||||
func (b *boot) runLoop(ctx context.Context, once bool) error {
|
||||
b.health.markServing()
|
||||
b.announceReady()
|
||||
b.announceReady(ctx)
|
||||
if once {
|
||||
b.d.RunOnce(ctx)
|
||||
return nil
|
||||
|
||||
@@ -31,8 +31,8 @@ import (
|
||||
// archie-state-store, which have health surfaces of their
|
||||
// own and would otherwise hang a Type=notify unit until TimeoutStartSec while
|
||||
// perfectly healthy.
|
||||
func (b *boot) announceReady() {
|
||||
sdnotify.Ready(b.log)
|
||||
func (b *boot) announceReady(ctx context.Context) {
|
||||
sdnotify.Ready(ctx, b.log)
|
||||
}
|
||||
|
||||
// startWatchdog arms the heartbeat. It does
|
||||
@@ -43,14 +43,14 @@ func (b *boot) startWatchdog(ctx context.Context) {
|
||||
if !n.Enabled() {
|
||||
return
|
||||
}
|
||||
interval, ok := sdnotify.Heartbeat(os.Getenv, os.Getpid(), b.log)
|
||||
interval, ok := sdnotify.Heartbeat(ctx, os.Getenv, os.Getpid(), b.log)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
|
||||
sampler := sdnotify.Watchdog{
|
||||
Interval: interval,
|
||||
Beat: func() { n.Send(sdnotify.WatchdogState) },
|
||||
Beat: func(ctx context.Context) { n.Send(ctx, sdnotify.WatchdogState) },
|
||||
}
|
||||
b.log.InfoContext(ctx, "systemd watchdog armed",
|
||||
"heartbeat", interval.String())
|
||||
|
||||
@@ -29,7 +29,7 @@ func (b *server) serveGatewayListener(ctx context.Context, listener net.Listener
|
||||
// from a second notion of "started". Not later: Serve
|
||||
// begins accepting the moment it is called, and a unit whose
|
||||
// TimeoutStartSec expires first would restart a healthy process.
|
||||
b.announceReady()
|
||||
b.announceReady(ctx)
|
||||
return serveGateway(ctx, listener, contract, b.chatSessionStore, b.chatCatalog(), opts)
|
||||
}
|
||||
|
||||
|
||||
@@ -147,9 +147,9 @@ func (b *server) cleanup() {
|
||||
}
|
||||
}
|
||||
|
||||
func (b *server) chatLLM() *runtime.Runtime { return b.llm.Load() }
|
||||
func (b *server) setLLM(rt *runtime.Runtime) { b.llm.Store(rt) }
|
||||
func (b *server) announceReady() { sdnotify.Ready(b.log) }
|
||||
func (b *server) chatLLM() *runtime.Runtime { return b.llm.Load() }
|
||||
func (b *server) setLLM(rt *runtime.Runtime) { b.llm.Store(rt) }
|
||||
func (b *server) announceReady(ctx context.Context) { sdnotify.Ready(ctx, b.log) }
|
||||
|
||||
func (b *server) loadConfig(ctx context.Context, cfgPath, overlayPath string) error {
|
||||
_, doc, err := servicekit.Resolve(b.log, cfgPath, overlayPath)
|
||||
|
||||
@@ -62,11 +62,11 @@ func (s *Service) announceReady(ctx context.Context, awaited map[string]bool) {
|
||||
return
|
||||
case <-timeout.C:
|
||||
s.log.WarnContext(ctx, "announcing readiness before every channel bound", "waiting_for", len(awaited))
|
||||
sdnotify.Ready(s.log)
|
||||
sdnotify.Ready(ctx, s.log)
|
||||
return
|
||||
case id := <-s.runningSignal:
|
||||
delete(awaited, id)
|
||||
}
|
||||
}
|
||||
sdnotify.Ready(s.log)
|
||||
sdnotify.Ready(ctx, s.log)
|
||||
}
|
||||
@@ -75,4 +75,4 @@ func (b *server) serveHealth(ctx context.Context, addr string, mux http.Handler,
|
||||
return nil
|
||||
}
|
||||
|
||||
func (b *server) announceReady() { sdnotify.Ready(b.log) }
|
||||
func (b *server) announceReady(ctx context.Context) { sdnotify.Ready(ctx, b.log) }
|
||||
@@ -135,7 +135,7 @@ func Run(ctx context.Context, options Options) error { //nolint:cyclop // the co
|
||||
// Not earlier: a readiness surface that fails to bind
|
||||
// fails the boot, and READY must not precede it. Not later: Serve begins
|
||||
// accepting the moment it is called.
|
||||
b.announceReady()
|
||||
b.announceReady(ctx)
|
||||
|
||||
deps := b.stateStoreDeps(ctx, grants)
|
||||
controlPlaneDeps(&deps, control)
|
||||
|
||||
@@ -180,7 +180,7 @@ func (s *auditServer) ListAudit(ctx context.Context, request *pb.ListAuditReques
|
||||
}
|
||||
page, err := s.deps.Audit.ListAudit(withInstanceAdmin(ctx), filter, cursor, int(request.GetLimit()))
|
||||
if err != nil {
|
||||
return nil, s.logErr("ListAudit", err)
|
||||
return nil, s.logErr(ctx, "ListAudit", err)
|
||||
}
|
||||
entries := make([]*pb.AuditEntry, len(page.Entries))
|
||||
for i := range page.Entries {
|
||||
@@ -199,7 +199,7 @@ func (s *auditServer) GetAuditHead(ctx context.Context, _ *pb.GetAuditHeadReques
|
||||
}
|
||||
token, err := s.deps.Audit.AuditHead(withInstanceAdmin(ctx))
|
||||
if err != nil {
|
||||
return nil, s.logErr("GetAuditHead", err)
|
||||
return nil, s.logErr(ctx, "GetAuditHead", err)
|
||||
}
|
||||
return &pb.GetAuditHeadResponse{Token: token}, nil
|
||||
}
|
||||
@@ -214,7 +214,7 @@ func (s *auditServer) CountAudit(ctx context.Context, request *pb.CountAuditRequ
|
||||
}
|
||||
count, err := s.deps.Audit.CountAudit(withInstanceAdmin(ctx), filter)
|
||||
if err != nil {
|
||||
return nil, s.logErr("CountAudit", err)
|
||||
return nil, s.logErr(ctx, "CountAudit", err)
|
||||
}
|
||||
return &pb.CountAuditResponse{Count: count}, nil
|
||||
}
|
||||
@@ -224,7 +224,7 @@ func (s *auditServer) RecordAuditExport(ctx context.Context, request *pb.RecordA
|
||||
return nil, errAuditUnavailable
|
||||
}
|
||||
if err := s.deps.Audit.RecordAuditExport(ctx, request.GetFormat(), request.GetFiltersHash(), request.GetRows()); err != nil {
|
||||
return nil, s.logErr("RecordAuditExport", err)
|
||||
return nil, s.logErr(ctx, "RecordAuditExport", err)
|
||||
}
|
||||
return &pb.RecordAuditExportResponse{}, nil
|
||||
}
|
||||
@@ -31,7 +31,7 @@ func (s *bindingServer) InsertBinding(ctx context.Context, r *pb.InsertBindingRe
|
||||
}
|
||||
id, err := bs.InsertBinding(ctx, value)
|
||||
if err != nil {
|
||||
return nil, s.logErr("InsertBinding", err)
|
||||
return nil, s.logErr(ctx, "InsertBinding", err)
|
||||
}
|
||||
return &pb.InsertBindingResponse{Id: id}, nil
|
||||
}
|
||||
@@ -43,7 +43,7 @@ func (s *bindingServer) GetBinding(ctx context.Context, r *pb.GetBindingRequest)
|
||||
}
|
||||
b, err := bs.GetBinding(ctx, r.Id)
|
||||
if err != nil {
|
||||
return nil, s.logErr("GetBinding", err)
|
||||
return nil, s.logErr(ctx, "GetBinding", err)
|
||||
}
|
||||
return &pb.GetBindingResponse{Binding: bindingProtoPtr(b), Found: b != nil}, nil
|
||||
}
|
||||
@@ -55,7 +55,7 @@ func (s *bindingServer) ListBindings(ctx context.Context, _ *pb.ListBindingsRequ
|
||||
}
|
||||
bindings, err := bs.ListBindings(ctx)
|
||||
if err != nil {
|
||||
return nil, s.logErr("ListBindings", err)
|
||||
return nil, s.logErr(ctx, "ListBindings", err)
|
||||
}
|
||||
return &pb.ListBindingsResponse{Bindings: mapValues(bindings, bindingProto)}, nil
|
||||
}
|
||||
@@ -70,7 +70,7 @@ func (s *bindingServer) UpdateBinding(ctx context.Context, r *pb.UpdateBindingRe
|
||||
return nil, validationFailure(err)
|
||||
}
|
||||
if err := bs.UpdateBinding(ctx, value); err != nil {
|
||||
return nil, s.logErr("UpdateBinding", err)
|
||||
return nil, s.logErr(ctx, "UpdateBinding", err)
|
||||
}
|
||||
return &pb.UpdateBindingResponse{}, nil
|
||||
}
|
||||
@@ -81,7 +81,7 @@ func (s *bindingServer) DeleteBinding(ctx context.Context, r *pb.DeleteBindingRe
|
||||
return nil, err
|
||||
}
|
||||
if err := bs.DeleteBinding(ctx, r.Id); err != nil {
|
||||
return nil, s.logErr("DeleteBinding", err)
|
||||
return nil, s.logErr(ctx, "DeleteBinding", err)
|
||||
}
|
||||
return &pb.DeleteBindingResponse{}, nil
|
||||
}
|
||||
@@ -92,7 +92,7 @@ func (s *bindingServer) PauseBinding(ctx context.Context, r *pb.PauseBindingRequ
|
||||
return nil, err
|
||||
}
|
||||
if err := bs.PauseBinding(ctx, r.Id); err != nil {
|
||||
return nil, s.logErr("PauseBinding", err)
|
||||
return nil, s.logErr(ctx, "PauseBinding", err)
|
||||
}
|
||||
return &pb.PauseBindingResponse{}, nil
|
||||
}
|
||||
@@ -103,7 +103,7 @@ func (s *bindingServer) ResumeBinding(ctx context.Context, r *pb.ResumeBindingRe
|
||||
return nil, err
|
||||
}
|
||||
if err := bs.ResumeBinding(ctx, r.Id); err != nil {
|
||||
return nil, s.logErr("ResumeBinding", err)
|
||||
return nil, s.logErr(ctx, "ResumeBinding", err)
|
||||
}
|
||||
return &pb.ResumeBindingResponse{}, nil
|
||||
}
|
||||
@@ -114,7 +114,7 @@ func (s *bindingServer) ApproveBinding(ctx context.Context, r *pb.ApproveBinding
|
||||
return nil, err
|
||||
}
|
||||
if err := bs.ApproveBinding(ctx, r.Id); err != nil {
|
||||
return nil, s.logErr("ApproveBinding", err)
|
||||
return nil, s.logErr(ctx, "ApproveBinding", err)
|
||||
}
|
||||
return &pb.ApproveBindingResponse{}, nil
|
||||
}
|
||||
|
||||
@@ -27,7 +27,7 @@ func (s *captureServer) RecordCaptureRefusal(ctx context.Context, r *pb.RecordCa
|
||||
return nil, errRefusalsUnavailable
|
||||
}
|
||||
if err := s.deps.Refusals.RecordCaptureRefusal(ctx, r.Source, r.Addr, timeValue(r.RefusedAt)); err != nil {
|
||||
return nil, s.logErr("RecordCaptureRefusal", err)
|
||||
return nil, s.logErr(ctx, "RecordCaptureRefusal", err)
|
||||
}
|
||||
return &pb.RecordCaptureRefusalResponse{}, nil
|
||||
}
|
||||
@@ -38,7 +38,7 @@ func (s *captureServer) ListCaptureRefusals(ctx context.Context, r *pb.ListCaptu
|
||||
}
|
||||
sources, err := s.deps.Refusals.CaptureRefusals(ctx, timeValue(r.Since))
|
||||
if err != nil {
|
||||
return nil, s.logErr("ListCaptureRefusals", err)
|
||||
return nil, s.logErr(ctx, "ListCaptureRefusals", err)
|
||||
}
|
||||
out := make([]*pb.CaptureRefusals, 0, len(sources))
|
||||
for _, c := range sources {
|
||||
@@ -54,7 +54,7 @@ func (s *captureServer) InsertCapture(ctx context.Context, r *pb.InsertCaptureRe
|
||||
}
|
||||
id, err := cs.InsertCapture(ctx, capturedEventValue(r.Capture), timeSeconds(r.RetentionSeconds), int(r.MaxEvents))
|
||||
if err != nil {
|
||||
return nil, s.logErr("InsertCapture", err)
|
||||
return nil, s.logErr(ctx, "InsertCapture", err)
|
||||
}
|
||||
return &pb.InsertCaptureResponse{Id: id}, nil
|
||||
}
|
||||
@@ -68,7 +68,7 @@ func (s *captureServer) StreamCaptures(r *pb.StreamCapturesRequest, stream pb.Ca
|
||||
}
|
||||
captures, err := cs.ListCaptures(stream.Context(), int(r.Limit))
|
||||
if err != nil {
|
||||
return s.logErr("StreamCaptures", err)
|
||||
return s.logErr(stream.Context(), "StreamCaptures", err)
|
||||
}
|
||||
for _, c := range captures {
|
||||
if err := stream.Send(&pb.StreamCapturesResponse{Capture: capturedEventProto(c)}); err != nil {
|
||||
@@ -87,7 +87,7 @@ func (s *captureServer) StreamUndispatchedCaptures(r *pb.StreamUndispatchedCaptu
|
||||
}
|
||||
captures, err := s.deps.BindingDispatcher.ListUndispatchedCaptures(stream.Context(), r.Bindings, int(r.Limit))
|
||||
if err != nil {
|
||||
return s.logErr("StreamUndispatchedCaptures", err)
|
||||
return s.logErr(stream.Context(), "StreamUndispatchedCaptures", err)
|
||||
}
|
||||
for _, c := range captures {
|
||||
if err := stream.Send(&pb.StreamUndispatchedCapturesResponse{Capture: capturedEventProto(c)}); err != nil {
|
||||
|
||||
@@ -21,7 +21,7 @@ func (s *dispatchServer) RecordDispatch(ctx context.Context, r *pb.RecordDispatc
|
||||
return nil, errBindingDispatchUnavailable
|
||||
}
|
||||
if err := s.deps.BindingDispatcher.RecordDispatch(ctx, r.BindingId, r.BindingVersion, r.CaptureId, r.TaskId, r.Reason); err != nil {
|
||||
return nil, s.logErr("RecordDispatch", err)
|
||||
return nil, s.logErr(ctx, "RecordDispatch", err)
|
||||
}
|
||||
return &pb.RecordDispatchResponse{}, nil
|
||||
}
|
||||
@@ -39,7 +39,7 @@ func (s *dispatchServer) ListDispatches(ctx context.Context, r *pb.ListDispatche
|
||||
BindingID: r.BindingId, CaptureID: r.CaptureId, TaskID: r.TaskId, Limit: int(r.Limit),
|
||||
})
|
||||
if err != nil {
|
||||
return nil, s.logErr("ListDispatches", err)
|
||||
return nil, s.logErr(ctx, "ListDispatches", err)
|
||||
}
|
||||
return &pb.ListDispatchesResponse{Dispatches: mapValues(dispatches, func(d storecontract.Dispatch) *pb.Dispatch {
|
||||
return &pb.Dispatch{
|
||||
@@ -56,7 +56,7 @@ func (s *dispatchServer) RecordPlaybookDispatch(ctx context.Context, r *pb.Recor
|
||||
return nil, errPlaybookDispatcherUnavailable
|
||||
}
|
||||
if err := s.deps.PlaybookDispatcher.RecordPlaybookDispatch(ctx, r.PlaybookId, r.PlaybookVersion, r.EventId, r.ActionId); err != nil {
|
||||
return nil, s.logErr("RecordPlaybookDispatch", err)
|
||||
return nil, s.logErr(ctx, "RecordPlaybookDispatch", err)
|
||||
}
|
||||
return &pb.RecordPlaybookDispatchResponse{}, nil
|
||||
}
|
||||
@@ -66,7 +66,7 @@ func (s *dispatchServer) DeletePlaybookDispatches(ctx context.Context, r *pb.Del
|
||||
return nil, errPlaybookDispatcherUnavailable
|
||||
}
|
||||
if err := s.deps.PlaybookDispatcher.DeletePlaybookDispatches(ctx, r.PlaybookId); err != nil {
|
||||
return nil, s.logErr("DeletePlaybookDispatches", err)
|
||||
return nil, s.logErr(ctx, "DeletePlaybookDispatches", err)
|
||||
}
|
||||
return &pb.DeletePlaybookDispatchesResponse{}, nil
|
||||
}
|
||||
@@ -81,7 +81,7 @@ func (s *dispatchServer) EnqueueBindingTask(ctx context.Context, r *pb.EnqueueBi
|
||||
}
|
||||
t, err := s.deps.BindingTaskCreator.EnqueueBindingTask(ctx, r.Owner, r.Repo, r.Title, r.Body, r.Workflow, r.Identity, r.BindingId, int(r.BindingVersion), r.CaptureId, inputs)
|
||||
if err != nil {
|
||||
return nil, s.logErr("EnqueueBindingTask", err)
|
||||
return nil, s.logErr(ctx, "EnqueueBindingTask", err)
|
||||
}
|
||||
return &pb.EnqueueBindingTaskResponse{Task: taskProto(t)}, nil
|
||||
}
|
||||
|
||||
@@ -77,7 +77,7 @@ func (s *eventTypeServer) InsertEventType(ctx context.Context, r *pb.InsertEvent
|
||||
}
|
||||
id, err := et.InsertEventType(ctx, eventTypeValue(r.EventType))
|
||||
if err != nil {
|
||||
return nil, s.logErr("InsertEventType", err)
|
||||
return nil, s.logErr(ctx, "InsertEventType", err)
|
||||
}
|
||||
return &pb.InsertEventTypeResponse{Id: id}, nil
|
||||
}
|
||||
@@ -88,7 +88,7 @@ func (s *eventTypeServer) UpdateEventType(ctx context.Context, r *pb.UpdateEvent
|
||||
return nil, err
|
||||
}
|
||||
if err := et.UpdateEventType(ctx, eventTypeValue(r.EventType)); err != nil {
|
||||
return nil, s.logErr("UpdateEventType", err)
|
||||
return nil, s.logErr(ctx, "UpdateEventType", err)
|
||||
}
|
||||
return &pb.UpdateEventTypeResponse{}, nil
|
||||
}
|
||||
@@ -99,7 +99,7 @@ func (s *eventTypeServer) DeleteEventType(ctx context.Context, r *pb.DeleteEvent
|
||||
return nil, err
|
||||
}
|
||||
if err := et.DeleteEventType(ctx, r.Id); err != nil {
|
||||
return nil, s.logErr("DeleteEventType", err)
|
||||
return nil, s.logErr(ctx, "DeleteEventType", err)
|
||||
}
|
||||
return &pb.DeleteEventTypeResponse{}, nil
|
||||
}
|
||||
@@ -111,7 +111,7 @@ func (s *eventTypeServer) ListEventTypes(ctx context.Context, _ *pb.ListEventTyp
|
||||
}
|
||||
types, err := et.ListEventTypes(ctx)
|
||||
if err != nil {
|
||||
return nil, s.logErr("ListEventTypes", err)
|
||||
return nil, s.logErr(ctx, "ListEventTypes", err)
|
||||
}
|
||||
return &pb.ListEventTypesResponse{EventTypes: mapValues(types, eventTypeProto)}, nil
|
||||
}
|
||||
|
||||
@@ -31,7 +31,7 @@ func (s *executionServer) StartStep(ctx context.Context, r *pb.StartStepRequest)
|
||||
CalledExecutionID: r.CalledExecutionId,
|
||||
})
|
||||
if err != nil {
|
||||
return nil, s.logErr("StartStep", err)
|
||||
return nil, s.logErr(ctx, "StartStep", err)
|
||||
}
|
||||
return &pb.StartStepResponse{StepId: stepID, Event: eventProto(event)}, nil
|
||||
}
|
||||
@@ -49,7 +49,7 @@ func (s *executionServer) RecordUsage(ctx context.Context, r *pb.RecordUsageRequ
|
||||
// applies; anything else is the calling principal's.
|
||||
record.Org = string(org.OrgFromContext(ctx))
|
||||
if err := s.deps.Usage.RecordUsage(ctx, record); err != nil {
|
||||
return nil, s.logErr("RecordUsage", err)
|
||||
return nil, s.logErr(ctx, "RecordUsage", err)
|
||||
}
|
||||
return &pb.RecordUsageResponse{}, nil
|
||||
}
|
||||
@@ -64,7 +64,7 @@ func (s *executionServer) CancelExecution(ctx context.Context, r *pb.CancelExecu
|
||||
}
|
||||
ids, err := s.deps.Canceller.CancelExecution(ctx, r.TaskId, r.Reason, r.To)
|
||||
if err != nil {
|
||||
return nil, s.logErr("CancelExecution", err)
|
||||
return nil, s.logErr(ctx, "CancelExecution", err)
|
||||
}
|
||||
return &pb.CancelExecutionResponse{CancelledCalleeIds: ids}, nil
|
||||
}
|
||||
@@ -79,7 +79,7 @@ func (s *executionServer) FinishStep(ctx context.Context, r *pb.FinishStepReques
|
||||
Detail: r.Detail, TokensUsed: r.TokensUsed, Results: r.Results,
|
||||
})
|
||||
if err != nil {
|
||||
return nil, s.logErr("FinishStep", err)
|
||||
return nil, s.logErr(ctx, "FinishStep", err)
|
||||
}
|
||||
return &pb.FinishStepResponse{Event: eventProto(event)}, nil
|
||||
}
|
||||
@@ -90,7 +90,7 @@ func (s *executionServer) ListSteps(ctx context.Context, r *pb.ListStepsRequest)
|
||||
}
|
||||
steps, err := s.deps.StepReader.ListSteps(ctx, r.ExecutionId, int(r.Attempt))
|
||||
if err != nil {
|
||||
return nil, s.logErr("ListSteps", err)
|
||||
return nil, s.logErr(ctx, "ListSteps", err)
|
||||
}
|
||||
return &pb.ListStepsResponse{Steps: mapValues(steps, stepExecutionProto)}, nil
|
||||
}
|
||||
|
||||
@@ -34,7 +34,7 @@ func (s *mappingServer) InsertMapping(ctx context.Context, r *pb.InsertMappingRe
|
||||
}
|
||||
id, err := ms.InsertMapping(ctx, value)
|
||||
if err != nil {
|
||||
return nil, s.logErr("InsertMapping", err)
|
||||
return nil, s.logErr(ctx, "InsertMapping", err)
|
||||
}
|
||||
return &pb.InsertMappingResponse{Id: id}, nil
|
||||
}
|
||||
@@ -46,7 +46,7 @@ func (s *mappingServer) GetMapping(ctx context.Context, r *pb.GetMappingRequest)
|
||||
}
|
||||
m, err := ms.GetMapping(ctx, r.Id)
|
||||
if err != nil {
|
||||
return nil, s.logErr("GetMapping", err)
|
||||
return nil, s.logErr(ctx, "GetMapping", err)
|
||||
}
|
||||
return &pb.GetMappingResponse{Mapping: mappingProtoPtr(m), Found: m != nil}, nil
|
||||
}
|
||||
@@ -58,7 +58,7 @@ func (s *mappingServer) ListMappings(ctx context.Context, _ *pb.ListMappingsRequ
|
||||
}
|
||||
mappings, err := ms.ListMappings(ctx)
|
||||
if err != nil {
|
||||
return nil, s.logErr("ListMappings", err)
|
||||
return nil, s.logErr(ctx, "ListMappings", err)
|
||||
}
|
||||
return &pb.ListMappingsResponse{Mappings: mapValues(mappings, mappingProto)}, nil
|
||||
}
|
||||
@@ -73,7 +73,7 @@ func (s *mappingServer) UpdateMapping(ctx context.Context, r *pb.UpdateMappingRe
|
||||
return nil, validationFailure(err)
|
||||
}
|
||||
if err := ms.UpdateMapping(ctx, value); err != nil {
|
||||
return nil, s.logErr("UpdateMapping", err)
|
||||
return nil, s.logErr(ctx, "UpdateMapping", err)
|
||||
}
|
||||
return &pb.UpdateMappingResponse{}, nil
|
||||
}
|
||||
@@ -84,7 +84,7 @@ func (s *mappingServer) DeleteMapping(ctx context.Context, r *pb.DeleteMappingRe
|
||||
return nil, err
|
||||
}
|
||||
if err := ms.DeleteMapping(ctx, r.Id); err != nil {
|
||||
return nil, s.logErr("DeleteMapping", err)
|
||||
return nil, s.logErr(ctx, "DeleteMapping", err)
|
||||
}
|
||||
return &pb.DeleteMappingResponse{}, nil
|
||||
}
|
||||
@@ -94,7 +94,7 @@ func (s *mappingServer) RecordMappingMatch(ctx context.Context, r *pb.RecordMapp
|
||||
return nil, status.Error(codes.Unavailable, "mapping match recorder unavailable")
|
||||
}
|
||||
if err := s.deps.MappingMatches.RecordMappingMatch(ctx, r.MappingId, r.CaptureId); err != nil {
|
||||
return nil, s.logErr("RecordMappingMatch", err)
|
||||
return nil, s.logErr(ctx, "RecordMappingMatch", err)
|
||||
}
|
||||
return &pb.RecordMappingMatchResponse{}, nil
|
||||
}
|
||||
|
||||
@@ -34,8 +34,8 @@ func orgStatus(err error) error {
|
||||
}
|
||||
|
||||
// orgErr logs and maps one org RPC's failure.
|
||||
func (s *server) orgErr(rpc string, err error) error {
|
||||
s.logFailure(rpc, err)
|
||||
func (s *server) orgErr(ctx context.Context, rpc string, err error) error {
|
||||
s.logFailure(ctx, rpc, err)
|
||||
return orgStatus(err)
|
||||
}
|
||||
|
||||
@@ -67,7 +67,7 @@ func (s *orgServer) ListOrgs(ctx context.Context, _ *pb.ListOrgsRequest) (*pb.Li
|
||||
}
|
||||
values, err := s.deps.Orgs.ListOrgs(ctx)
|
||||
if err != nil {
|
||||
return nil, s.orgErr("ListOrgs", err)
|
||||
return nil, s.orgErr(ctx, "ListOrgs", err)
|
||||
}
|
||||
// Only an instance admin or an internal service sees every org; anyone
|
||||
// else sees their own.
|
||||
@@ -123,7 +123,7 @@ func (s *orgServer) GetOrg(ctx context.Context, r *pb.GetOrgRequest) (*pb.GetOrg
|
||||
}
|
||||
value, err := s.deps.Orgs.GetOrg(ctx, orgFor(ctx, r.GetOrgId()))
|
||||
if err != nil {
|
||||
return nil, s.orgErr("GetOrg", err)
|
||||
return nil, s.orgErr(ctx, "GetOrg", err)
|
||||
}
|
||||
return &pb.GetOrgResponse{Org: orgProto(value)}, nil
|
||||
}
|
||||
@@ -137,12 +137,12 @@ func (s *orgServer) CreateOrg(ctx context.Context, r *pb.CreateOrgRequest) (*pb.
|
||||
}
|
||||
value, err := s.deps.Orgs.CreateOrg(ctx, orgValue(&pb.Org{Id: r.GetId(), Name: r.GetName()}), identity.IdentityID(r.GetOwnerIdentityId()))
|
||||
if err != nil {
|
||||
return nil, s.orgErr("CreateOrg", err)
|
||||
return nil, s.orgErr(ctx, "CreateOrg", err)
|
||||
}
|
||||
// The new org's role policies are what let its owner act in it.
|
||||
if s.deps.Policies != nil {
|
||||
if err := s.deps.Policies.EnsureShippedOrgPolicies(ctx, value.ID); err != nil {
|
||||
return nil, s.logErr("CreateOrg policies", err)
|
||||
return nil, s.logErr(ctx, "CreateOrg policies", err)
|
||||
}
|
||||
}
|
||||
return &pb.CreateOrgResponse{Org: orgProto(value)}, nil
|
||||
@@ -154,7 +154,7 @@ func (s *orgServer) ListWorkspaces(ctx context.Context, r *pb.ListWorkspacesRequ
|
||||
}
|
||||
values, err := s.deps.Orgs.ListWorkspaces(ctx, memberOrgFor(ctx, r.GetOrgId()))
|
||||
if err != nil {
|
||||
return nil, s.orgErr("ListWorkspaces", err)
|
||||
return nil, s.orgErr(ctx, "ListWorkspaces", err)
|
||||
}
|
||||
out := make([]*pb.Workspace, len(values))
|
||||
for i := range values {
|
||||
@@ -170,7 +170,7 @@ func (s *orgServer) CreateWorkspace(ctx context.Context, r *pb.CreateWorkspaceRe
|
||||
value := workspaceValue(&pb.Workspace{Id: r.GetId(), OrgId: string(orgFor(ctx, r.GetOrgId())), Name: r.GetName(), Environment: r.GetEnvironment()})
|
||||
created, err := s.deps.Orgs.CreateWorkspace(ctx, value)
|
||||
if err != nil {
|
||||
return nil, s.orgErr("CreateWorkspace", err)
|
||||
return nil, s.orgErr(ctx, "CreateWorkspace", err)
|
||||
}
|
||||
return &pb.CreateWorkspaceResponse{Workspace: workspaceProto(created)}, nil
|
||||
}
|
||||
@@ -181,7 +181,7 @@ func (s *orgServer) ListMembers(ctx context.Context, r *pb.ListMembersRequest) (
|
||||
}
|
||||
values, err := s.deps.Orgs.ListMembers(ctx, orgFor(ctx, r.GetOrgId()))
|
||||
if err != nil {
|
||||
return nil, s.orgErr("ListMembers", err)
|
||||
return nil, s.orgErr(ctx, "ListMembers", err)
|
||||
}
|
||||
out := make([]*pb.Member, len(values))
|
||||
for i := range values {
|
||||
@@ -201,7 +201,7 @@ func (s *orgServer) SetMembership(ctx context.Context, r *pb.SetMembershipReques
|
||||
Role: org.Role(r.GetRole()),
|
||||
})
|
||||
if err != nil {
|
||||
return nil, s.orgErr("SetMembership", err)
|
||||
return nil, s.orgErr(ctx, "SetMembership", err)
|
||||
}
|
||||
return &pb.SetMembershipResponse{}, nil
|
||||
}
|
||||
@@ -216,7 +216,7 @@ func (s *orgServer) RemoveMembership(ctx context.Context, r *pb.RemoveMembership
|
||||
WorkspaceID: org.WorkspaceID(r.GetWorkspaceId()),
|
||||
})
|
||||
if err != nil {
|
||||
return nil, s.orgErr("RemoveMembership", err)
|
||||
return nil, s.orgErr(ctx, "RemoveMembership", err)
|
||||
}
|
||||
return &pb.RemoveMembershipResponse{}, nil
|
||||
}
|
||||
@@ -230,7 +230,7 @@ func (s *orgServer) AssignAgent(ctx context.Context, r *pb.AssignAgentRequest) (
|
||||
OrgID: orgFor(ctx, r.GetOrgId()),
|
||||
})
|
||||
if err != nil {
|
||||
return nil, s.orgErr("AssignAgent", err)
|
||||
return nil, s.orgErr(ctx, "AssignAgent", err)
|
||||
}
|
||||
return &pb.AssignAgentResponse{}, nil
|
||||
}
|
||||
@@ -245,7 +245,7 @@ func (s *orgServer) ListOrgAgents(ctx context.Context, r *pb.ListOrgAgentsReques
|
||||
}
|
||||
values, err := s.deps.Orgs.ListOrgAgents(ctx, owner)
|
||||
if err != nil {
|
||||
return nil, s.orgErr("ListOrgAgents", err)
|
||||
return nil, s.orgErr(ctx, "ListOrgAgents", err)
|
||||
}
|
||||
out := make([]*pb.AgentAssignment, len(values))
|
||||
for i, value := range values {
|
||||
@@ -267,7 +267,7 @@ func (s *orgServer) CallerModels(ctx context.Context, _ *pb.CallerModelsRequest)
|
||||
orgID := string(org.OrgFromContext(ctx))
|
||||
aliases, _, err := s.deps.OrgModels(ctx, orgID)
|
||||
if err != nil {
|
||||
return nil, s.logErr("CallerModels", err)
|
||||
return nil, s.logErr(ctx, "CallerModels", err)
|
||||
}
|
||||
return &pb.CallerModelsResponse{OrgId: orgID, Aliases: aliases}, nil
|
||||
}
|
||||
|
||||
@@ -18,7 +18,7 @@ func (s *packageServer) InstallPackage(ctx context.Context, request *pb.InstallP
|
||||
}
|
||||
p, err := s.deps.Packages.InstallPackage(ctx, string(org.OrgFromContext(ctx)), request.GetName(), request.GetReference(), request.GetDigest())
|
||||
if err != nil {
|
||||
return nil, s.logErr("InstallPackage", err)
|
||||
return nil, s.logErr(ctx, "InstallPackage", err)
|
||||
}
|
||||
return &pb.InstallPackageResponse{Package: packageProto(p, true)}, nil
|
||||
}
|
||||
@@ -29,7 +29,7 @@ func (s *packageServer) GetInstalledPackage(ctx context.Context, request *pb.Get
|
||||
}
|
||||
p, err := s.deps.Packages.GetInstalled(ctx, string(org.OrgFromContext(ctx)), request.GetName())
|
||||
if err != nil {
|
||||
return nil, s.logErr("GetInstalledPackage", err)
|
||||
return nil, s.logErr(ctx, "GetInstalledPackage", err)
|
||||
}
|
||||
return &pb.GetInstalledPackageResponse{Package: packageProto(p, true)}, nil
|
||||
}
|
||||
@@ -40,7 +40,7 @@ func (s *packageServer) ListInstalledPackages(ctx context.Context, request *pb.L
|
||||
}
|
||||
packages, err := s.deps.Packages.ListInstalled(ctx, string(org.OrgFromContext(ctx)))
|
||||
if err != nil {
|
||||
return nil, s.logErr("ListInstalledPackages", err)
|
||||
return nil, s.logErr(ctx, "ListInstalledPackages", err)
|
||||
}
|
||||
result := &pb.ListInstalledPackagesResponse{}
|
||||
for _, p := range packages {
|
||||
@@ -55,7 +55,7 @@ func (s *packageServer) AcceptPackageAuthority(ctx context.Context, request *pb.
|
||||
}
|
||||
p, err := s.deps.Packages.AcceptPackageAuthority(ctx, string(org.OrgFromContext(ctx)), request.GetName(), authorityValue(request.GetAccepted()))
|
||||
if err != nil {
|
||||
return nil, s.logErr("AcceptPackageAuthority", err)
|
||||
return nil, s.logErr(ctx, "AcceptPackageAuthority", err)
|
||||
}
|
||||
return &pb.AcceptPackageAuthorityResponse{Package: packageProto(p, true)}, nil
|
||||
}
|
||||
@@ -65,7 +65,7 @@ func (s *packageServer) RemoveInstalledPackage(ctx context.Context, request *pb.
|
||||
return nil, status.Error(codes.Unavailable, "package store unavailable")
|
||||
}
|
||||
if err := s.deps.Packages.RemoveInstalled(ctx, string(org.OrgFromContext(ctx)), request.GetName()); err != nil {
|
||||
return nil, s.logErr("RemoveInstalledPackage", err)
|
||||
return nil, s.logErr(ctx, "RemoveInstalledPackage", err)
|
||||
}
|
||||
return &pb.RemoveInstalledPackageResponse{}, nil
|
||||
}
|
||||
@@ -207,7 +207,7 @@ func (s *packageServer) ListCatalogue(ctx context.Context, _ *pb.ListCatalogueRe
|
||||
}
|
||||
catalogue, err := s.deps.Packages.ListCatalogue(ctx)
|
||||
if err != nil {
|
||||
return nil, s.logErr("ListCatalogue", err)
|
||||
return nil, s.logErr(ctx, "ListCatalogue", err)
|
||||
}
|
||||
out := make([]*pb.CatalogueEntry, 0, len(catalogue.Packages))
|
||||
for _, e := range catalogue.Packages {
|
||||
@@ -225,7 +225,7 @@ func (s *packageServer) InstallFromCatalogue(ctx context.Context, request *pb.In
|
||||
}
|
||||
p, err := s.deps.Packages.InstallFromCatalogue(ctx, string(org.OrgFromContext(ctx)), request.GetName())
|
||||
if err != nil {
|
||||
return nil, s.logErr("InstallFromCatalogue", err)
|
||||
return nil, s.logErr(ctx, "InstallFromCatalogue", err)
|
||||
}
|
||||
return &pb.InstallFromCatalogueResponse{Package: packageProto(p, true)}, nil
|
||||
}
|
||||
@@ -259,7 +259,7 @@ func (s *packageServer) UpdatePackage(ctx context.Context, request *pb.UpdatePac
|
||||
}
|
||||
p, err := s.deps.Packages.UpdatePackage(ctx, string(org.OrgFromContext(ctx)), request.GetName())
|
||||
if err != nil {
|
||||
return nil, s.logErr("UpdatePackage", err)
|
||||
return nil, s.logErr(ctx, "UpdatePackage", err)
|
||||
}
|
||||
return &pb.UpdatePackageResponse{Package: packageProto(p, true)}, nil
|
||||
}
|
||||
@@ -270,7 +270,7 @@ func (s *packageServer) ApprovePackageUpdate(ctx context.Context, request *pb.Ap
|
||||
}
|
||||
p, err := s.deps.Packages.ApprovePackageUpdate(ctx, string(org.OrgFromContext(ctx)), request.GetName())
|
||||
if err != nil {
|
||||
return nil, s.logErr("ApprovePackageUpdate", err)
|
||||
return nil, s.logErr(ctx, "ApprovePackageUpdate", err)
|
||||
}
|
||||
return &pb.ApprovePackageUpdateResponse{Package: packageProto(p, true)}, nil
|
||||
}
|
||||
@@ -281,7 +281,7 @@ func (s *packageServer) RollbackPackage(ctx context.Context, request *pb.Rollbac
|
||||
}
|
||||
p, err := s.deps.Packages.RollbackPackage(ctx, string(org.OrgFromContext(ctx)), request.GetName())
|
||||
if err != nil {
|
||||
return nil, s.logErr("RollbackPackage", err)
|
||||
return nil, s.logErr(ctx, "RollbackPackage", err)
|
||||
}
|
||||
return &pb.RollbackPackageResponse{Package: packageProto(p, true)}, nil
|
||||
}
|
||||
@@ -316,7 +316,7 @@ func (s *packageServer) SetPackageUpdatePolicy(ctx context.Context, request *pb.
|
||||
}
|
||||
p, err := s.deps.Packages.SetPackageUpdatePolicy(ctx, string(org.OrgFromContext(ctx)), request.GetName(), request.GetPolicy())
|
||||
if err != nil {
|
||||
return nil, s.logErr("SetPackageUpdatePolicy", err)
|
||||
return nil, s.logErr(ctx, "SetPackageUpdatePolicy", err)
|
||||
}
|
||||
return &pb.SetPackageUpdatePolicyResponse{Package: packageProto(p, true)}, nil
|
||||
}
|
||||
|
||||
@@ -13,28 +13,28 @@ type reviewServer struct {
|
||||
|
||||
func (s *reviewServer) RespondReviewGate(ctx context.Context, r *pb.RespondReviewGateRequest) (*pb.RespondReviewGateResponse, error) {
|
||||
if err := s.deps.Tasks.RespondReviewGate(ctx, r.TaskId, r.FromStatus, r.Gate, r.Rereview, int(r.Cap)); err != nil {
|
||||
return nil, s.logErr("RespondReviewGate", err)
|
||||
return nil, s.logErr(ctx, "RespondReviewGate", err)
|
||||
}
|
||||
return &pb.RespondReviewGateResponse{}, nil
|
||||
}
|
||||
|
||||
func (s *reviewServer) BeginRemediation(ctx context.Context, r *pb.BeginRemediationRequest) (*pb.BeginRemediationResponse, error) {
|
||||
if err := s.deps.Tasks.BeginRemediation(ctx, r.TaskId, r.Payload); err != nil {
|
||||
return nil, s.logErr("BeginRemediation", err)
|
||||
return nil, s.logErr(ctx, "BeginRemediation", err)
|
||||
}
|
||||
return &pb.BeginRemediationResponse{}, nil
|
||||
}
|
||||
|
||||
func (s *reviewServer) UpdateReviewPayload(ctx context.Context, r *pb.UpdateReviewPayloadRequest) (*pb.UpdateReviewPayloadResponse, error) {
|
||||
if err := s.deps.Tasks.UpdateReviewPayload(ctx, r.TaskId, r.Payload); err != nil {
|
||||
return nil, s.logErr("UpdateReviewPayload", err)
|
||||
return nil, s.logErr(ctx, "UpdateReviewPayload", err)
|
||||
}
|
||||
return &pb.UpdateReviewPayloadResponse{}, nil
|
||||
}
|
||||
|
||||
func (s *reviewServer) SetReviewCursors(ctx context.Context, r *pb.SetReviewCursorsRequest) (*pb.SetReviewCursorsResponse, error) {
|
||||
if err := s.deps.Tasks.SetReviewCursors(ctx, r.TaskId, r.ReviewCursor, r.CommentCursor); err != nil {
|
||||
return nil, s.logErr("SetReviewCursors", err)
|
||||
return nil, s.logErr(ctx, "SetReviewCursors", err)
|
||||
}
|
||||
return &pb.SetReviewCursorsResponse{}, nil
|
||||
}
|
||||
|
||||
@@ -70,7 +70,7 @@ func (s *scheduleServer) ListSchedules(ctx context.Context, _ *pb.ListSchedulesR
|
||||
}
|
||||
list, err := s.deps.Schedules.ListSchedules(ctx)
|
||||
if err != nil {
|
||||
return nil, s.logErr("ListSchedules", err)
|
||||
return nil, s.logErr(ctx, "ListSchedules", err)
|
||||
}
|
||||
return &pb.ListSchedulesResponse{Schedules: mapValues(list, scheduleProto)}, nil
|
||||
}
|
||||
@@ -123,7 +123,7 @@ func (s *scheduleServer) EnsureBuiltinSchedules(ctx context.Context, r *pb.Ensur
|
||||
return scheduling.Builtin{ID: b.GetId(), Name: b.GetName(), Interval: time.Duration(b.GetIntervalSeconds()) * time.Second}
|
||||
})
|
||||
if err := s.deps.Schedules.EnsureBuiltins(ctx, builtins, loc); err != nil {
|
||||
return nil, s.logErr("EnsureBuiltinSchedules", err)
|
||||
return nil, s.logErr(ctx, "EnsureBuiltinSchedules", err)
|
||||
}
|
||||
return &pb.EnsureBuiltinSchedulesResponse{}, nil
|
||||
}
|
||||
@@ -138,7 +138,7 @@ func (s *scheduleServer) ClaimDueRuns(ctx context.Context, r *pb.ClaimDueRunsReq
|
||||
}
|
||||
claims, err := s.deps.ScheduleRuns.ClaimDue(ctx, timeValue(r.GetNow()), time.Duration(r.GetStaleSeconds())*time.Second, loc)
|
||||
if err != nil {
|
||||
return nil, s.logErr("ClaimDueRuns", err)
|
||||
return nil, s.logErr(ctx, "ClaimDueRuns", err)
|
||||
}
|
||||
return &pb.ClaimDueRunsResponse{Claims: mapValues(claims, func(c scheduling.Claim) *pb.ScheduleClaim {
|
||||
return &pb.ScheduleClaim{Run: scheduleRunProto(c.Run), Name: c.Name, BuiltIn: c.BuiltIn, OrgId: c.Org}
|
||||
@@ -188,7 +188,7 @@ func (s *scheduleServer) ListScheduleRuns(ctx context.Context, r *pb.ListSchedul
|
||||
}
|
||||
runs, err := s.deps.Schedules.ListRuns(ctx, r.GetScheduleId(), int(r.GetLimit()))
|
||||
if err != nil {
|
||||
return nil, s.logErr("ListScheduleRuns", err)
|
||||
return nil, s.logErr(ctx, "ListScheduleRuns", err)
|
||||
}
|
||||
return &pb.ListScheduleRunsResponse{Runs: mapValues(runs, scheduleRunProto)}, nil
|
||||
}
|
||||
|
||||
@@ -206,20 +206,20 @@ func RegisterServer(registrar grpc.ServiceRegistrar, deps Deps) {
|
||||
}
|
||||
}
|
||||
|
||||
func (s *server) logErr(rpc string, err error) error {
|
||||
s.logFailure(rpc, err)
|
||||
func (s *server) logErr(ctx context.Context, rpc string, err error) error {
|
||||
s.logFailure(ctx, rpc, err)
|
||||
return mapError(err)
|
||||
}
|
||||
|
||||
// logFailure records a failed call. A cancelled context is the caller going
|
||||
// away, so it is not a fault.
|
||||
func (s *server) logFailure(rpc string, err error) {
|
||||
func (s *server) logFailure(ctx context.Context, rpc string, err error) {
|
||||
switch {
|
||||
case err == nil:
|
||||
case errors.Is(err, context.Canceled):
|
||||
s.deps.Log.Debug("staterpc call cancelled", "rpc", rpc)
|
||||
s.deps.Log.DebugContext(ctx, "staterpc call cancelled", "rpc", rpc)
|
||||
default:
|
||||
s.deps.Log.Error("staterpc call failed", "rpc", rpc, "err", err)
|
||||
s.deps.Log.ErrorContext(ctx, "staterpc call failed", "rpc", rpc, "err", err)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -26,7 +26,7 @@ func (s *sourceServer) InsertSource(ctx context.Context, r *pb.InsertSourceReque
|
||||
return nil, err
|
||||
}
|
||||
if err := ss.InsertSource(ctx, sourceValue(r.Source)); err != nil {
|
||||
return nil, s.logErr("InsertSource", err)
|
||||
return nil, s.logErr(ctx, "InsertSource", err)
|
||||
}
|
||||
return &pb.InsertSourceResponse{}, nil
|
||||
}
|
||||
@@ -38,7 +38,7 @@ func (s *sourceServer) GetSource(ctx context.Context, r *pb.GetSourceRequest) (*
|
||||
}
|
||||
src, err := ss.GetSource(ctx, r.Path)
|
||||
if err != nil {
|
||||
return nil, s.logErr("GetSource", err)
|
||||
return nil, s.logErr(ctx, "GetSource", err)
|
||||
}
|
||||
if src == nil {
|
||||
return &pb.GetSourceResponse{}, nil
|
||||
@@ -53,7 +53,7 @@ func (s *sourceServer) ListSources(ctx context.Context, _ *pb.ListSourcesRequest
|
||||
}
|
||||
list, err := ss.ListSources(ctx)
|
||||
if err != nil {
|
||||
return nil, s.logErr("ListSources", err)
|
||||
return nil, s.logErr(ctx, "ListSources", err)
|
||||
}
|
||||
return &pb.ListSourcesResponse{Sources: mapValues(list, sourceProto)}, nil
|
||||
}
|
||||
@@ -64,7 +64,7 @@ func (s *sourceServer) SetSourceSigning(ctx context.Context, r *pb.SetSourceSign
|
||||
return nil, err
|
||||
}
|
||||
if err := ss.SetSourceSigning(ctx, r.Path, source.Signing(r.From), source.Signing(r.To)); err != nil {
|
||||
return nil, s.logErr("SetSourceSigning", err)
|
||||
return nil, s.logErr(ctx, "SetSourceSigning", err)
|
||||
}
|
||||
return &pb.SetSourceSigningResponse{}, nil
|
||||
}
|
||||
@@ -75,7 +75,7 @@ func (s *sourceServer) SetSourceSecret(ctx context.Context, r *pb.SetSourceSecre
|
||||
return nil, err
|
||||
}
|
||||
if err := ss.SetSourceSecret(ctx, r.Path, r.Secret); err != nil {
|
||||
return nil, s.logErr("SetSourceSecret", err)
|
||||
return nil, s.logErr(ctx, "SetSourceSecret", err)
|
||||
}
|
||||
return &pb.SetSourceSecretResponse{}, nil
|
||||
}
|
||||
@@ -86,7 +86,7 @@ func (s *sourceServer) SetSourceName(ctx context.Context, r *pb.SetSourceNameReq
|
||||
return nil, err
|
||||
}
|
||||
if err := ss.SetSourceName(ctx, r.Path, r.Name); err != nil {
|
||||
return nil, s.logErr("SetSourceName", err)
|
||||
return nil, s.logErr(ctx, "SetSourceName", err)
|
||||
}
|
||||
return &pb.SetSourceNameResponse{}, nil
|
||||
}
|
||||
@@ -97,7 +97,7 @@ func (s *sourceServer) SetSourceDeliveryHeader(ctx context.Context, r *pb.SetSou
|
||||
return nil, err
|
||||
}
|
||||
if err := ss.SetSourceDeliveryHeader(ctx, r.Path, r.Header); err != nil {
|
||||
return nil, s.logErr("SetSourceDeliveryHeader", err)
|
||||
return nil, s.logErr(ctx, "SetSourceDeliveryHeader", err)
|
||||
}
|
||||
return &pb.SetSourceDeliveryHeaderResponse{}, nil
|
||||
}
|
||||
@@ -108,7 +108,7 @@ func (s *sourceServer) DeleteSource(ctx context.Context, r *pb.DeleteSourceReque
|
||||
return nil, err
|
||||
}
|
||||
if err := ss.DeleteSource(ctx, r.Path); err != nil {
|
||||
return nil, s.logErr("DeleteSource", err)
|
||||
return nil, s.logErr(ctx, "DeleteSource", err)
|
||||
}
|
||||
return &pb.DeleteSourceResponse{}, nil
|
||||
}
|
||||
|
||||
@@ -19,7 +19,7 @@ type statsServer struct {
|
||||
func (s *statsServer) StatusCounts(ctx context.Context, _ *pb.StatusCountsRequest) (*pb.StatusCountsResponse, error) {
|
||||
counts, err := s.deps.Tasks.StatusCounts(ctx)
|
||||
if err != nil {
|
||||
return nil, s.logErr("StatusCounts", err)
|
||||
return nil, s.logErr(ctx, "StatusCounts", err)
|
||||
}
|
||||
out := make(map[string]int64, len(counts))
|
||||
for k, v := range counts {
|
||||
@@ -33,7 +33,7 @@ func (s *statsServer) StatusCounts(ctx context.Context, _ *pb.StatusCountsReques
|
||||
func (s *statsServer) WorkflowStats(ctx context.Context, _ *pb.WorkflowStatsRequest) (*pb.WorkflowStatsResponse, error) {
|
||||
stats, err := s.deps.Tasks.WorkflowStats(ctx)
|
||||
if err != nil {
|
||||
return nil, s.logErr("WorkflowStats", err)
|
||||
return nil, s.logErr(ctx, "WorkflowStats", err)
|
||||
}
|
||||
return &pb.WorkflowStatsResponse{Stats: mapValues(stats, workflowStatProto)}, nil
|
||||
}
|
||||
@@ -41,7 +41,7 @@ func (s *statsServer) WorkflowStats(ctx context.Context, _ *pb.WorkflowStatsRequ
|
||||
func (s *statsServer) StageStats(ctx context.Context, _ *pb.StageStatsRequest) (*pb.StageStatsResponse, error) {
|
||||
stats, err := s.deps.Tasks.StageStats(ctx)
|
||||
if err != nil {
|
||||
return nil, s.logErr("StageStats", err)
|
||||
return nil, s.logErr(ctx, "StageStats", err)
|
||||
}
|
||||
return &pb.StageStatsResponse{Stats: mapValues(stats, stageStatProto)}, nil
|
||||
}
|
||||
@@ -49,7 +49,7 @@ func (s *statsServer) StageStats(ctx context.Context, _ *pb.StageStatsRequest) (
|
||||
func (s *statsServer) TokensByDay(ctx context.Context, r *pb.TokensByDayRequest) (*pb.TokensByDayResponse, error) {
|
||||
tokens, err := s.deps.Tasks.TokensByDay(ctx, int(r.Days))
|
||||
if err != nil {
|
||||
return nil, s.logErr("TokensByDay", err)
|
||||
return nil, s.logErr(ctx, "TokensByDay", err)
|
||||
}
|
||||
return &pb.TokensByDayResponse{Tokens: mapValues(tokens, dayTokensProto)}, nil
|
||||
}
|
||||
@@ -60,7 +60,7 @@ func (s *statsServer) UsageTotals(ctx context.Context, r *pb.UsageTotalsRequest)
|
||||
}
|
||||
rows, err := s.deps.UsageTotals.UsageTotals(ctx, int(r.GetDays()))
|
||||
if err != nil {
|
||||
return nil, s.logErr("UsageTotals", err)
|
||||
return nil, s.logErr(ctx, "UsageTotals", err)
|
||||
}
|
||||
return &pb.UsageTotalsResponse{Rows: mapValues(rows, usageTotalProto)}, nil
|
||||
}
|
||||
|
||||
@@ -28,7 +28,7 @@ func (s *statusServer) PutApplyStatus(ctx context.Context, r *pb.PutApplyStatusR
|
||||
return nil, err
|
||||
}
|
||||
if err := as.PutApplyStatus(ctx, applyStatusValue(r.Status)); err != nil {
|
||||
return nil, s.logErr("PutApplyStatus", err)
|
||||
return nil, s.logErr(ctx, "PutApplyStatus", err)
|
||||
}
|
||||
return &pb.PutApplyStatusResponse{}, nil
|
||||
}
|
||||
@@ -40,7 +40,7 @@ func (s *statusServer) ListApplyStatus(ctx context.Context, _ *pb.ListApplyStatu
|
||||
}
|
||||
statuses, err := as.ListApplyStatus(ctx)
|
||||
if err != nil {
|
||||
return nil, s.logErr("ListApplyStatus", err)
|
||||
return nil, s.logErr(ctx, "ListApplyStatus", err)
|
||||
}
|
||||
out := make([]*pb.ApplyStatus, 0, len(statuses))
|
||||
for _, status := range statuses {
|
||||
@@ -62,7 +62,7 @@ func (s *statusServer) PutConfigSnapshot(ctx context.Context, r *pb.PutConfigSna
|
||||
return nil, err
|
||||
}
|
||||
if err := cs.PutConfigSnapshot(ctx, configSnapshotValue(r.Snapshot)); err != nil {
|
||||
return nil, s.logErr("PutConfigSnapshot", err)
|
||||
return nil, s.logErr(ctx, "PutConfigSnapshot", err)
|
||||
}
|
||||
return &pb.PutConfigSnapshotResponse{}, nil
|
||||
}
|
||||
@@ -74,7 +74,7 @@ func (s *statusServer) GetConfigSnapshot(ctx context.Context, _ *pb.GetConfigSna
|
||||
}
|
||||
snapshot, found, err := cs.ConfigSnapshot(ctx)
|
||||
if err != nil {
|
||||
return nil, s.logErr("GetConfigSnapshot", err)
|
||||
return nil, s.logErr(ctx, "GetConfigSnapshot", err)
|
||||
}
|
||||
if !found {
|
||||
return &pb.GetConfigSnapshotResponse{}, nil
|
||||
@@ -103,7 +103,7 @@ func (s *statusServer) PutPresence(ctx context.Context, r *pb.PutPresenceRequest
|
||||
}
|
||||
}
|
||||
if err := ps.PutPresence(ctx, record); err != nil {
|
||||
return nil, s.logErr("PutPresence", err)
|
||||
return nil, s.logErr(ctx, "PutPresence", err)
|
||||
}
|
||||
return &pb.PutPresenceResponse{}, nil
|
||||
}
|
||||
@@ -115,7 +115,7 @@ func (s *statusServer) ListPresence(ctx context.Context, _ *pb.ListPresenceReque
|
||||
}
|
||||
presences, err := ps.ListPresence(ctx)
|
||||
if err != nil {
|
||||
return nil, s.logErr("ListPresence", err)
|
||||
return nil, s.logErr(ctx, "ListPresence", err)
|
||||
}
|
||||
out := make([]*pb.Presence, 0, len(presences))
|
||||
for _, presence := range presences {
|
||||
@@ -137,7 +137,7 @@ func (s *statusServer) PutChannelStatus(ctx context.Context, r *pb.PutChannelSta
|
||||
return nil, err
|
||||
}
|
||||
if err := cs.PutChannelStatus(ctx, channelStatusesValue(r.Channels)); err != nil {
|
||||
return nil, s.logErr("PutChannelStatus", err)
|
||||
return nil, s.logErr(ctx, "PutChannelStatus", err)
|
||||
}
|
||||
return &pb.PutChannelStatusResponse{}, nil
|
||||
}
|
||||
@@ -149,7 +149,7 @@ func (s *statusServer) ListChannelStatus(ctx context.Context, _ *pb.ListChannelS
|
||||
}
|
||||
channels, err := cs.ChannelStatus(ctx)
|
||||
if err != nil {
|
||||
return nil, s.logErr("ListChannelStatus", err)
|
||||
return nil, s.logErr(ctx, "ListChannelStatus", err)
|
||||
}
|
||||
return &pb.ListChannelStatusResponse{Channels: channelStatusesProto(channels)}, nil
|
||||
}
|
||||
|
||||
@@ -15,7 +15,7 @@ type taskEventServer struct {
|
||||
func (s *taskEventServer) InsertEvent(ctx context.Context, r *pb.InsertEventRequest) (*pb.InsertEventResponse, error) {
|
||||
id, err := s.deps.Tasks.InsertEvent(ctx, eventValue(r.Event))
|
||||
if err != nil {
|
||||
return nil, s.logErr("InsertEvent", err)
|
||||
return nil, s.logErr(ctx, "InsertEvent", err)
|
||||
}
|
||||
return &pb.InsertEventResponse{Id: id}, nil
|
||||
}
|
||||
@@ -23,7 +23,7 @@ func (s *taskEventServer) InsertEvent(ctx context.Context, r *pb.InsertEventRequ
|
||||
func (s *taskEventServer) EventsSince(ctx context.Context, r *pb.EventsSinceRequest) (*pb.EventsSinceResponse, error) {
|
||||
evs, err := s.deps.Tasks.EventsSince(ctx, r.SinceId, int(r.Limit))
|
||||
if err != nil {
|
||||
return nil, s.logErr("EventsSince", err)
|
||||
return nil, s.logErr(ctx, "EventsSince", err)
|
||||
}
|
||||
return &pb.EventsSinceResponse{Events: mapValues(evs, eventProto)}, nil
|
||||
}
|
||||
@@ -37,7 +37,7 @@ func (s *taskEventServer) TaskEvents(ctx context.Context, r *pb.TaskEventsReques
|
||||
evs, err = s.deps.Tasks.TaskEvents(ctx, r.TaskId)
|
||||
}
|
||||
if err != nil {
|
||||
return nil, s.logErr("TaskEvents", err)
|
||||
return nil, s.logErr(ctx, "TaskEvents", err)
|
||||
}
|
||||
return &pb.TaskEventsResponse{Events: mapValues(evs, eventProto)}, nil
|
||||
}
|
||||
|
||||
@@ -35,7 +35,7 @@ func (s *taskLogServer) ReadTaskLog(ctx context.Context, r *pb.ReadTaskLogReques
|
||||
if errors.Is(err, logging.ErrTaskLogsUnavailable) {
|
||||
return nil, errTaskLogsUnavailable
|
||||
}
|
||||
return nil, s.logErr("ReadTaskLog", err)
|
||||
return nil, s.logErr(ctx, "ReadTaskLog", err)
|
||||
}
|
||||
if !page.Found {
|
||||
return &pb.ReadTaskLogResponse{Attempt: r.Attempt}, nil
|
||||
@@ -68,7 +68,7 @@ func (s *taskLogServer) StreamTaskLogContent(r *pb.StreamTaskLogContentRequest,
|
||||
if errors.Is(err, logging.ErrTaskLogsUnavailable) {
|
||||
return errTaskLogsUnavailable
|
||||
}
|
||||
return s.logErr("StreamTaskLogContent", err)
|
||||
return s.logErr(stream.Context(), "StreamTaskLogContent", err)
|
||||
}
|
||||
if err := buf.flush(); err != nil {
|
||||
return err
|
||||
|
||||
@@ -21,7 +21,7 @@ type taskServer struct {
|
||||
func (s *taskServer) EnqueueIssue(ctx context.Context, r *pb.EnqueueIssueRequest) (*pb.EnqueueIssueResponse, error) {
|
||||
inserted, err := s.deps.Tasks.EnqueueIssue(ctx, r.Owner, r.Repo, int(r.Number), r.Title, r.Body, r.Labels, r.Identity)
|
||||
if err != nil {
|
||||
return nil, s.logErr("EnqueueIssue", err)
|
||||
return nil, s.logErr(ctx, "EnqueueIssue", err)
|
||||
}
|
||||
return &pb.EnqueueIssueResponse{Inserted: inserted}, nil
|
||||
}
|
||||
@@ -29,7 +29,7 @@ func (s *taskServer) EnqueueIssue(ctx context.Context, r *pb.EnqueueIssueRequest
|
||||
func (s *taskServer) ActiveTasksByOrigin(ctx context.Context, r *pb.ActiveTasksByOriginRequest) (*pb.ActiveTasksByOriginResponse, error) {
|
||||
tasks, err := s.deps.Tasks.ActiveTasksByOrigin(ctx, r.Origin)
|
||||
if err != nil {
|
||||
return nil, s.logErr("ActiveTasksByOrigin", err)
|
||||
return nil, s.logErr(ctx, "ActiveTasksByOrigin", err)
|
||||
}
|
||||
out := make([]*pb.Task, 0, len(tasks))
|
||||
for _, t := range tasks {
|
||||
@@ -41,7 +41,7 @@ func (s *taskServer) ActiveTasksByOrigin(ctx context.Context, r *pb.ActiveTasksB
|
||||
func (s *taskServer) UnpostedOutcomes(ctx context.Context, _ *pb.UnpostedOutcomesRequest) (*pb.UnpostedOutcomesResponse, error) {
|
||||
tasks, err := s.deps.Tasks.UnpostedOutcomes(ctx)
|
||||
if err != nil {
|
||||
return nil, s.logErr("UnpostedOutcomes", err)
|
||||
return nil, s.logErr(ctx, "UnpostedOutcomes", err)
|
||||
}
|
||||
out := make([]*pb.Task, 0, len(tasks))
|
||||
for _, t := range tasks {
|
||||
@@ -52,7 +52,7 @@ func (s *taskServer) UnpostedOutcomes(ctx context.Context, _ *pb.UnpostedOutcome
|
||||
|
||||
func (s *taskServer) MarkOutcomePosted(ctx context.Context, r *pb.MarkOutcomePostedRequest) (*pb.MarkOutcomePostedResponse, error) {
|
||||
if err := s.deps.Tasks.MarkOutcomePosted(ctx, r.TaskId, r.Status); err != nil {
|
||||
return nil, s.logErr("MarkOutcomePosted", err)
|
||||
return nil, s.logErr(ctx, "MarkOutcomePosted", err)
|
||||
}
|
||||
return &pb.MarkOutcomePostedResponse{}, nil
|
||||
}
|
||||
@@ -64,7 +64,7 @@ func (s *taskServer) EnqueueChatTask(ctx context.Context, r *pb.EnqueueChatTaskR
|
||||
}
|
||||
t, err := s.deps.Tasks.EnqueueChatTask(ctx, r.Owner, r.Repo, r.Title, r.Body, r.Workflow, r.Identity, r.Origin, r.DraftYaml, inputs)
|
||||
if err != nil {
|
||||
return nil, s.logErr("EnqueueChatTask", err)
|
||||
return nil, s.logErr(ctx, "EnqueueChatTask", err)
|
||||
}
|
||||
return &pb.EnqueueChatTaskResponse{Task: taskProto(t)}, nil
|
||||
}
|
||||
@@ -72,7 +72,7 @@ func (s *taskServer) EnqueueChatTask(ctx context.Context, r *pb.EnqueueChatTaskR
|
||||
func (s *taskServer) ClaimNext(ctx context.Context, _ *pb.ClaimNextRequest) (*pb.ClaimNextResponse, error) {
|
||||
t, err := s.deps.Tasks.ClaimNext(ctx)
|
||||
if err != nil {
|
||||
return nil, s.logErr("ClaimNext", err)
|
||||
return nil, s.logErr(ctx, "ClaimNext", err)
|
||||
}
|
||||
return &pb.ClaimNextResponse{Task: taskProto(t), Found: t != nil}, nil
|
||||
}
|
||||
@@ -80,14 +80,14 @@ func (s *taskServer) ClaimNext(ctx context.Context, _ *pb.ClaimNextRequest) (*pb
|
||||
func (s *taskServer) ClaimByIssue(ctx context.Context, r *pb.ClaimByIssueRequest) (*pb.ClaimByIssueResponse, error) {
|
||||
t, err := s.deps.Tasks.ClaimByIssue(ctx, r.Owner, r.Repo, int(r.Number))
|
||||
if err != nil {
|
||||
return nil, s.logErr("ClaimByIssue", err)
|
||||
return nil, s.logErr(ctx, "ClaimByIssue", err)
|
||||
}
|
||||
return &pb.ClaimByIssueResponse{Task: taskProto(t), Found: t != nil}, nil
|
||||
}
|
||||
|
||||
func (s *taskServer) Transition(ctx context.Context, r *pb.TransitionRequest) (*pb.TransitionResponse, error) {
|
||||
if err := s.deps.Tasks.Transition(ctx, r.TaskId, r.From, r.To, r.Detail); err != nil {
|
||||
return nil, s.logErr("Transition", err)
|
||||
return nil, s.logErr(ctx, "Transition", err)
|
||||
}
|
||||
return &pb.TransitionResponse{}, nil
|
||||
}
|
||||
@@ -99,7 +99,7 @@ func (s *taskServer) TaskModels(ctx context.Context, r *pb.TaskModelsRequest) (*
|
||||
}
|
||||
t, err := s.deps.Tasks.TaskByID(ctx, r.TaskId)
|
||||
if err != nil {
|
||||
return nil, s.logErr("TaskModels", err)
|
||||
return nil, s.logErr(ctx, "TaskModels", err)
|
||||
}
|
||||
if t == nil {
|
||||
return nil, status.Error(codes.NotFound, "task not found")
|
||||
@@ -107,7 +107,7 @@ func (s *taskServer) TaskModels(ctx context.Context, r *pb.TaskModelsRequest) (*
|
||||
orgID := t.OrgOrDefault()
|
||||
aliases, providers, err := s.deps.OrgModels(ctx, orgID)
|
||||
if err != nil {
|
||||
return nil, s.logErr("TaskModels", err)
|
||||
return nil, s.logErr(ctx, "TaskModels", err)
|
||||
}
|
||||
out := make(map[string]*pb.ModelProvider, len(providers))
|
||||
for name, p := range providers {
|
||||
@@ -124,14 +124,14 @@ func (s *taskServer) TaskInstructions(ctx context.Context, r *pb.TaskInstruction
|
||||
}
|
||||
t, err := s.deps.Tasks.TaskByID(ctx, r.TaskId)
|
||||
if err != nil {
|
||||
return nil, s.logErr("TaskInstructions", err)
|
||||
return nil, s.logErr(ctx, "TaskInstructions", err)
|
||||
}
|
||||
if t == nil {
|
||||
return nil, status.Error(codes.NotFound, "task not found")
|
||||
}
|
||||
instance, organisation, err := s.deps.OrgInstructions(ctx, t.OrgOrDefault())
|
||||
if err != nil {
|
||||
return nil, s.logErr("TaskInstructions", err)
|
||||
return nil, s.logErr(ctx, "TaskInstructions", err)
|
||||
}
|
||||
return &pb.TaskInstructionsResponse{Instance: instance, Organisation: organisation}, nil
|
||||
}
|
||||
@@ -141,21 +141,21 @@ func (s *taskServer) Update(ctx context.Context, r *pb.UpdateRequest) (*pb.Updat
|
||||
return nil, status.Error(codes.InvalidArgument, "task is required")
|
||||
}
|
||||
if err := s.deps.Tasks.Update(ctx, taskValue(r.Task)); err != nil {
|
||||
return nil, s.logErr("Update", err)
|
||||
return nil, s.logErr(ctx, "Update", err)
|
||||
}
|
||||
return &pb.UpdateResponse{}, nil
|
||||
}
|
||||
|
||||
func (s *taskServer) Requeue(ctx context.Context, r *pb.RequeueRequest) (*pb.RequeueResponse, error) {
|
||||
if err := s.deps.Tasks.Requeue(ctx, r.TaskId, r.FromStatus, r.Workflow); err != nil {
|
||||
return nil, s.logErr("Requeue", err)
|
||||
return nil, s.logErr(ctx, "Requeue", err)
|
||||
}
|
||||
return &pb.RequeueResponse{}, nil
|
||||
}
|
||||
|
||||
func (s *taskServer) ParkTask(ctx context.Context, r *pb.ParkTaskRequest) (*pb.ParkTaskResponse, error) {
|
||||
if err := s.deps.Tasks.ParkTask(ctx, r.TaskId, r.From, r.Detail, r.Class, r.Blocker); err != nil {
|
||||
return nil, s.logErr("ParkTask", err)
|
||||
return nil, s.logErr(ctx, "ParkTask", err)
|
||||
}
|
||||
return &pb.ParkTaskResponse{}, nil
|
||||
}
|
||||
@@ -163,7 +163,7 @@ func (s *taskServer) ParkTask(ctx context.Context, r *pb.ParkTaskRequest) (*pb.P
|
||||
func (s *taskServer) RecoverStale(ctx context.Context, _ *pb.RecoverStaleRequest) (*pb.RecoverStaleResponse, error) {
|
||||
n, err := s.deps.Tasks.RecoverStale(ctx)
|
||||
if err != nil {
|
||||
return nil, s.logErr("RecoverStale", err)
|
||||
return nil, s.logErr(ctx, "RecoverStale", err)
|
||||
}
|
||||
return &pb.RecoverStaleResponse{Count: n}, nil
|
||||
}
|
||||
@@ -173,14 +173,14 @@ func (s *taskServer) RecoverStale(ctx context.Context, _ *pb.RecoverStaleRequest
|
||||
func (s *taskServer) ArchiveTask(ctx context.Context, r *pb.ArchiveTaskRequest) (*pb.ArchiveTaskResponse, error) {
|
||||
eventID, err := s.deps.Tasks.ArchiveTask(ctx, r.TaskId, r.FromStatus, eventValue(r.Audit))
|
||||
if err != nil {
|
||||
return nil, s.logErr("ArchiveTask", err)
|
||||
return nil, s.logErr(ctx, "ArchiveTask", err)
|
||||
}
|
||||
return &pb.ArchiveTaskResponse{EventId: eventID}, nil
|
||||
}
|
||||
|
||||
func (s *taskServer) RetryTask(ctx context.Context, r *pb.RetryTaskRequest) (*pb.RetryTaskResponse, error) {
|
||||
if err := s.deps.Tasks.RetryTask(ctx, r.TaskId, r.FromStatus, r.Workflow, r.RetryMode, task.Resume{From: r.ResumeFrom, After: r.ResumeAfter}, r.CurrentDefinition); err != nil {
|
||||
return nil, s.logErr("RetryTask", err)
|
||||
return nil, s.logErr(ctx, "RetryTask", err)
|
||||
}
|
||||
return &pb.RetryTaskResponse{}, nil
|
||||
}
|
||||
@@ -188,7 +188,7 @@ func (s *taskServer) RetryTask(ctx context.Context, r *pb.RetryTaskRequest) (*pb
|
||||
func (s *taskServer) TaskByIssue(ctx context.Context, r *pb.TaskByIssueRequest) (*pb.TaskByIssueResponse, error) {
|
||||
t, err := s.deps.Tasks.TaskByIssue(ctx, r.Owner, r.Repo, int(r.Number))
|
||||
if err != nil {
|
||||
return nil, s.logErr("TaskByIssue", err)
|
||||
return nil, s.logErr(ctx, "TaskByIssue", err)
|
||||
}
|
||||
return &pb.TaskByIssueResponse{Task: taskProto(t), Found: t != nil}, nil
|
||||
}
|
||||
@@ -196,7 +196,7 @@ func (s *taskServer) TaskByIssue(ctx context.Context, r *pb.TaskByIssueRequest)
|
||||
func (s *taskServer) OpenTaskByPR(ctx context.Context, r *pb.OpenTaskByPRRequest) (*pb.OpenTaskByPRResponse, error) {
|
||||
t, err := s.deps.Tasks.OpenTaskByPR(ctx, r.Owner, r.Repo, int(r.Number))
|
||||
if err != nil {
|
||||
return nil, s.logErr("OpenTaskByPR", err)
|
||||
return nil, s.logErr(ctx, "OpenTaskByPR", err)
|
||||
}
|
||||
return &pb.OpenTaskByPRResponse{Task: taskProto(t), Found: t != nil}, nil
|
||||
}
|
||||
@@ -204,7 +204,7 @@ func (s *taskServer) OpenTaskByPR(ctx context.Context, r *pb.OpenTaskByPRRequest
|
||||
func (s *taskServer) TaskByID(ctx context.Context, r *pb.TaskByIDRequest) (*pb.TaskByIDResponse, error) {
|
||||
t, err := s.deps.Tasks.TaskByID(ctx, r.TaskId)
|
||||
if err != nil {
|
||||
return nil, s.logErr("TaskByID", err)
|
||||
return nil, s.logErr(ctx, "TaskByID", err)
|
||||
}
|
||||
return &pb.TaskByIDResponse{Task: taskProto(t), Found: t != nil}, nil
|
||||
}
|
||||
@@ -212,7 +212,7 @@ func (s *taskServer) TaskByID(ctx context.Context, r *pb.TaskByIDRequest) (*pb.T
|
||||
func (s *taskServer) OpenPRs(ctx context.Context, _ *pb.OpenPRsRequest) (*pb.OpenPRsResponse, error) {
|
||||
tasks, err := s.deps.Tasks.OpenPRs(ctx)
|
||||
if err != nil {
|
||||
return nil, s.logErr("OpenPRs", err)
|
||||
return nil, s.logErr(ctx, "OpenPRs", err)
|
||||
}
|
||||
out := make([]*pb.Task, len(tasks))
|
||||
for i := range tasks {
|
||||
@@ -224,7 +224,7 @@ func (s *taskServer) OpenPRs(ctx context.Context, _ *pb.OpenPRsRequest) (*pb.Ope
|
||||
func (s *taskServer) ClearTerminalTasks(ctx context.Context, _ *pb.ClearTerminalTasksRequest) (*pb.ClearTerminalTasksResponse, error) {
|
||||
n, err := s.deps.Tasks.ClearTerminalTasks(ctx)
|
||||
if err != nil {
|
||||
return nil, s.logErr("ClearTerminalTasks", err)
|
||||
return nil, s.logErr(ctx, "ClearTerminalTasks", err)
|
||||
}
|
||||
return &pb.ClearTerminalTasksResponse{Count: n}, nil
|
||||
}
|
||||
@@ -235,7 +235,7 @@ func (s *taskServer) Tasks(ctx context.Context, r *pb.TasksRequest) (*pb.TasksRe
|
||||
After: storecontract.TaskCursor{UpdatedAt: timeValue(r.AfterUpdatedAt), ID: r.AfterId},
|
||||
})
|
||||
if err != nil {
|
||||
return nil, s.logErr("Tasks", err)
|
||||
return nil, s.logErr(ctx, "Tasks", err)
|
||||
}
|
||||
out := make([]*pb.Task, len(tasks))
|
||||
for i := range tasks {
|
||||
@@ -262,7 +262,7 @@ func (s *taskServer) EnqueueCallTask(ctx context.Context, r *pb.EnqueueCallTaskR
|
||||
}
|
||||
t, err := s.deps.WorkflowCalls.StartCall(ctx, r.CallerTaskId, r.CallKey, r.Workflow, inputs)
|
||||
if err != nil {
|
||||
return nil, s.logErr("EnqueueCallTask", err)
|
||||
return nil, s.logErr(ctx, "EnqueueCallTask", err)
|
||||
}
|
||||
return &pb.EnqueueCallTaskResponse{Task: taskProto(t), Accepted: true}, nil
|
||||
}
|
||||
@@ -276,7 +276,7 @@ func (s *taskServer) HandoffTask(ctx context.Context, r *pb.HandoffTaskRequest)
|
||||
}
|
||||
t, err := s.deps.WorkflowCalls.Handoff(ctx, r.TaskId, r.Workflow, r.Detail)
|
||||
if err != nil {
|
||||
return nil, s.logErr("HandoffTask", err)
|
||||
return nil, s.logErr(ctx, "HandoffTask", err)
|
||||
}
|
||||
return &pb.HandoffTaskResponse{Task: taskProto(t)}, nil
|
||||
}
|
||||
@@ -287,7 +287,7 @@ func (s *taskServer) WorkflowCallStatus(ctx context.Context, r *pb.WorkflowCallS
|
||||
}
|
||||
status, detail, outputs, err := s.deps.WorkflowCalls.CallStatus(ctx, r.CallerTaskId, r.CallTaskId)
|
||||
if err != nil {
|
||||
return nil, s.logErr("WorkflowCallStatus", err)
|
||||
return nil, s.logErr(ctx, "WorkflowCallStatus", err)
|
||||
}
|
||||
return &pb.WorkflowCallStatusResponse{Status: status, Detail: detail, OutputsJson: outputsJSON(outputs)}, nil
|
||||
}
|
||||
|
||||
@@ -54,12 +54,12 @@ func (n Notifier) Enabled() bool { return n.addr != "" }
|
||||
// Send delivers one state line. A failure is logged, never returned: a
|
||||
// notification is an observation about the process, and no observation is
|
||||
// worth refusing to serve over.
|
||||
func (n Notifier) Send(state string) {
|
||||
func (n Notifier) Send(ctx context.Context, state string) {
|
||||
if n.addr == "" {
|
||||
return
|
||||
}
|
||||
if err := sendNotify(n.addr, state); err != nil {
|
||||
n.log.Warn("systemd notify failed", "state", state, "socket", n.addr, "err", err)
|
||||
n.log.WarnContext(ctx, "systemd notify failed", "state", state, "socket", n.addr, "err", err)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -78,13 +78,13 @@ func sendNotify(addr, state string) error {
|
||||
}
|
||||
|
||||
// Ready sends READY=1.
|
||||
func Ready(log *slog.Logger) {
|
||||
New(os.Getenv, log).Send(ReadyState)
|
||||
func Ready(ctx context.Context, log *slog.Logger) {
|
||||
New(os.Getenv, log).Send(ctx, ReadyState)
|
||||
}
|
||||
|
||||
// Heartbeat returns half of WatchdogSec. ok is false when no watchdog is
|
||||
// requested or WATCHDOG_PID is another process.
|
||||
func Heartbeat(getenv func(string) string, pid int, log *slog.Logger) (time.Duration, bool) {
|
||||
func Heartbeat(ctx context.Context, getenv func(string) string, pid int, log *slog.Logger) (time.Duration, bool) {
|
||||
raw := getenv(WatchdogUsecEnv)
|
||||
if raw == "" {
|
||||
return 0, false
|
||||
@@ -92,14 +92,14 @@ func Heartbeat(getenv func(string) string, pid int, log *slog.Logger) (time.Dura
|
||||
if rawPID := getenv(WatchdogPIDEnv); rawPID != "" {
|
||||
wantPID, err := strconv.Atoi(rawPID)
|
||||
if err != nil || wantPID != pid {
|
||||
log.Warn("systemd watchdog disabled: WATCHDOG_PID is not this process",
|
||||
log.WarnContext(ctx, "systemd watchdog disabled: WATCHDOG_PID is not this process",
|
||||
"watchdog_pid", rawPID, "pid", pid, "err", err)
|
||||
return 0, false
|
||||
}
|
||||
}
|
||||
watchdog, err := time.ParseDuration(raw + "us")
|
||||
if err != nil || watchdog <= 0 {
|
||||
log.Warn("systemd watchdog disabled: WATCHDOG_USEC unreadable", "value", raw, "err", err)
|
||||
log.WarnContext(ctx, "systemd watchdog disabled: WATCHDOG_USEC unreadable", "value", raw, "err", err)
|
||||
return 0, false
|
||||
}
|
||||
return watchdog / watchdogHeartbeatDivisor, true
|
||||
@@ -113,7 +113,7 @@ type Watchdog struct {
|
||||
// Interval is the beat cadence: half of systemd's WatchdogSec.
|
||||
Interval time.Duration
|
||||
// Beat emits one WATCHDOG=1.
|
||||
Beat func()
|
||||
Beat func(ctx context.Context)
|
||||
}
|
||||
|
||||
// Run beats until ctx ends and returns ctx.Err().
|
||||
@@ -125,7 +125,7 @@ func (w Watchdog) Run(ctx context.Context) error {
|
||||
case <-ctx.Done():
|
||||
return ctx.Err()
|
||||
case <-ticker.C:
|
||||
w.Beat()
|
||||
w.Beat(ctx)
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user