From 21d8250cde4e8a83632b327d2a6a8075cb171ddd Mon Sep 17 00:00:00 2001 From: Sam Catlow Date: Thu, 17 Sep 2026 12:12:43 +0000 Subject: [PATCH] feat(webui): read a task's log through the State Store and let it be downloaded The dashboard's attempt-log panel answered every read with "task logging is optional and was not enabled for this run". That message was false: logging is wired unconditionally in the daemon, and the log files exist. The dashboard process simply had no reader -- composition left TaskLogs absent because no contract carried it -- so the handler saw a nil registry and reported the disabled shape, which the page rendered as a claim about configuration. internal/logging now answers whether an attempt has a log at all: Tail sets Result.Found, so "this attempt has no log" is a value rather than an empty list indistinguishable from a read that never happened. Its registry gains TaskLog (a decoded page) and TaskLogContent (the file verbatim, streamed, because a log is unbounded input), and an absent reader reports ErrTaskLogsUnavailable rather than an empty page -- a process that cannot read logs must not implicate the attempt. Those two answers travel the State Store contract as storecontract.TaskLogStore (ReadTaskLog, StreamTaskLogContent) and are rehydrated on the client by (Unavailable, canonical message), so archie-ui composes the reader from its own store client instead of opening another process's files. The daemon's registry is wired as the server-side reader in the State Store process only. On top of that read, GET /api/tasks/{id}/logs/download serves the attempt's log as a Content-Disposition attachment named task--attempt-.log, and the panel offers it. The JSON route keeps its shape and gains found, so the page states the attempt has no log instead of blaming a setting. Task log files stay owned by their directory's owner: archiving still removes a task's log directory, and that removal is the daemon's, not the dashboard's. --- internal/app/archied/state_store.go | 16 ++ internal/app/archied/state_store_test.go | 31 +++ internal/app/archieui/compose.go | 28 ++- internal/app/archieui/compose_test.go | 11 +- internal/app/archieui/degraded_routes_test.go | 22 +- internal/app/archieui/task_logs_test.go | 201 +++++++++++++++ .../domain/storecontract/storecontract.go | 23 ++ internal/infrastructure/staterpc/client.go | 54 ++++ .../staterpc/conformance_test.go | 18 ++ internal/infrastructure/staterpc/server.go | 136 +++++++++- .../infrastructure/staterpc/task_log_test.go | 200 +++++++++++++++ internal/infrastructure/staterpc/values.go | 75 +++++- internal/logging/reader.go | 98 ++++++++ internal/store/interface.go | 1 + internal/webui/api_tasks_actions_test.go | 25 +- internal/webui/api_tasks_log_download_test.go | 147 +++++++++++ internal/webui/api_tasks_logs.go | 236 +++++++++++++----- internal/webui/api_tasks_logs_test.go | 12 +- internal/webui/server.go | 15 +- 19 files changed, 1266 insertions(+), 83 deletions(-) create mode 100644 internal/app/archieui/task_logs_test.go create mode 100644 internal/infrastructure/staterpc/task_log_test.go create mode 100644 internal/webui/api_tasks_log_download_test.go diff --git a/internal/app/archied/state_store.go b/internal/app/archied/state_store.go index fe4b129f1..d2f2eea3f 100644 --- a/internal/app/archied/state_store.go +++ b/internal/app/archied/state_store.go @@ -125,6 +125,22 @@ func (b *boot) openStateStore(ctx context.Context) error { // degrades that group rather than aborting boot. func (b *boot) stateStoreDeps(grants *staterpc.TaskGrants) staterpc.Deps { deps := staterpc.Deps{Tasks: b.st, Log: b.log, Grants: grants} + // Task logs live in the state directory, which this process owns, and the + // dashboard process owns no such directory -- so this is where a task-log + // read is served from (docs/prds/ui-service-boundary.md). The reader is + // the daemon's own registry, built over the same state-directory + // derivation this process uses for its SQLite file; both resolve from the + // same configured DBPath, so they agree on where archie keeps its state. + // + // The nil check is on the registry, not on the interface it is assigned + // to: a nil *logging.TaskRegistry stored in this field produces a non-nil + // interface holding a nil pointer, which the server's own + // `deps.TaskLogs == nil` guard would not catch. Leaving the field unset is + // what makes the RPC answer Unavailable -- the honest "this process cannot + // read logs" -- instead of depending on nil-receiver behaviour to notice. + if b.taskLogs != nil { + deps.TaskLogs = b.taskLogs + } if cs, ok := b.st.(storecontract.CaptureStore); ok { deps.Captures = cs } diff --git a/internal/app/archied/state_store_test.go b/internal/app/archied/state_store_test.go index 2d922ed30..fede02cf5 100644 --- a/internal/app/archied/state_store_test.go +++ b/internal/app/archied/state_store_test.go @@ -11,7 +11,9 @@ import ( "github.com/samcharles93/archie-core/internal/config" pb "github.com/samcharles93/archie-core/internal/contracts/state/v1" + "github.com/samcharles93/archie-core/internal/domain/storecontract" "github.com/samcharles93/archie-core/internal/infrastructure/staterpc" + "github.com/samcharles93/archie-core/internal/logging" "github.com/samcharles93/archie-core/internal/store" ) @@ -98,6 +100,35 @@ func TestServeStateStoreServesContract(t *testing.T) { } } +// TestStateStoreDepsServeTaskLogs proves the standalone State Store process is +// where a task-log read is served from: the daemon process holds no dashboard +// listener any more, so the service the UI process dials is the only place this +// contract can have a server-side reader, and it must be the daemon's own +// registry over the state directory. +// +// Without this wiring the RPC exists and answers Unavailable for every task, +// which the dashboard reports as "this process cannot read logs" -- honest, but +// still not a working download (archie-core-iaqx). +func TestStateStoreDepsServeTaskLogs(t *testing.T) { + b := newBootstrap() + logs := logging.NewTaskRegistry(filepath.Join(t.TempDir(), "logs", "tasks"), logging.NewFeed(10), logging.TaskSinkOptions{}) + b.taskLogs = logs + + deps := b.stateStoreDeps(&staterpc.TaskGrants{}) + if deps.TaskLogs == nil { + t.Fatal("stateStoreDeps leaves TaskLogs nil; the State Store process is the only server-side reader the dashboard can reach") + } + if deps.TaskLogs != storecontract.TaskLogStore(logs) { + t.Fatalf("TaskLogs = %T, want the daemon's own registry over the state directory", deps.TaskLogs) + } + // A boot without a registry must not fabricate one: an empty reader would + // answer found=false for every attempt, which reads as "the attempt has no + // log" rather than "this process cannot read logs". + if plain := (&boot{}).stateStoreDeps(&staterpc.TaskGrants{}); plain.TaskLogs != nil { + t.Errorf("TaskLogs = %T with no registry on the boot, want nil so the RPC reports unavailability", plain.TaskLogs) + } +} + // TestStateStoreDataSurvivesRestart is the .4.7 restart/recovery check: a // task written by one archie-state-store process must still be there for a // fresh process opening the same archie.db path, proving b.openStateStore diff --git a/internal/app/archieui/compose.go b/internal/app/archieui/compose.go index 47de3e8a6..06e16c9ec 100644 --- a/internal/app/archieui/compose.go +++ b/internal/app/archieui/compose.go @@ -38,12 +38,17 @@ type deps struct { // UpdateRepoField: the configuration owner stays the daemon. The read // crosses as the snapshot ConfigSource renders; the write routes answer // 503 and the page hides their controls (archie-core-ymut). -// - LogFeed, TaskLogs, Events, Channels, ReloadChannel, Curators, Memory, +// - LogFeed, Events, Channels, ReloadChannel, Curators, Memory, // Workflows, WorkRequests, RunningVersions, Chat.Updates, // UpdateReportPath: no contract exists for these yet. // Defining one amends the owning service's contract first // (docs/prds/ui-service-boundary.md:205-207); the route migration is // archie-core-8cda.5.3. +// - TaskLogs: wired below from the store client's TaskLogStore contract. +// Task log files live in the state directory the State Store owns, so this +// process reads one attempt's log over that contract rather than opening +// the file itself -- which would only work on a single host and is exactly +// what the boundary forbids (archie-core-iaqx). // - Captures, CaptureIntake, CaptureMaxEvents: wired below. From the // cutover change (archie-core-8cda.5.4) this process is the only // listener serving POST /webhooks/capture/{source}: the receiver is a @@ -77,10 +82,31 @@ func compose(d deps) *webui.Server { if d.Chat != nil { srv.Chat = &webui.ChatService{Contract: d.Chat} } + // The task-log read crosses the State Store contract: the files live in + // the state directory that process owns, so this one asks for the log + // rather than opening a path (docs/prds/ui-service-boundary.md). Withholding + // it would degrade a page that has an owner, and would leave the dashboard + // claiming task logging was not enabled -- see wireTaskLogs. + wireTaskLogs(d, srv) wireCaptureSurfaces(d, srv) return srv } +// wireTaskLogs attaches the task-log read when the store client carries the +// 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) { + logs, ok := d.Store.(storecontract.TaskLogStore) + if !ok { + if d.Store != nil { + d.Log.Warn("task logs unavailable: state store does not implement TaskLogStore") + } + return + } + srv.TaskLogs = logs +} + // wireCaptureSurfaces attaches the capture read and the intake receiver. // Both resolve from d.Store's contracts: CaptureStore backs the inspector's // list and the mapping preview's scan window, BindingDispatcher resolves the diff --git a/internal/app/archieui/compose_test.go b/internal/app/archieui/compose_test.go index 4240197f4..39f9e30dc 100644 --- a/internal/app/archieui/compose_test.go +++ b/internal/app/archieui/compose_test.go @@ -88,7 +88,6 @@ func TestComposeUIServerHoldsNoDaemonState(t *testing.T) { "Memory": srv.Memory, "Channels": srv.Channels, "LogFeed": srv.LogFeed, - "TaskLogs": srv.TaskLogs, "WorkRequests": srv.WorkRequests, } for name, handle := range unwired { @@ -105,6 +104,16 @@ func TestComposeUIServerHoldsNoDaemonState(t *testing.T) { if srv.Mappings == nil || srv.Bindings == nil { t.Error("Mappings/Bindings are unwired; both are State Store contracts the composed client implements") } + // TaskLogs is the same shape as Mappings/Bindings -- the store client + // carries TaskLogStore -- and it is the one that used to answer "task + // logging was not enabled for this run" for every attempt in a deployment + // where logging is unconditional (archie-core-iaqx). + if srv.TaskLogs == nil { + t.Error("TaskLogs is unwired; the State Store client implements TaskLogStore, so leaving it nil degrades a page that has an owner") + } + if _, ok := srv.TaskLogs.(*staterpc.Client); !ok { + t.Errorf("TaskLogs = %T, want the remote *staterpc.Client: the UI process owns no state directory to read a log file from", srv.TaskLogs) + } if srv.UpdateReportPath != "" { t.Error("UpdateReportPath is set; host-local update relay stays with the daemon") } diff --git a/internal/app/archieui/degraded_routes_test.go b/internal/app/archieui/degraded_routes_test.go index b1d3370c8..e3879a2d3 100644 --- a/internal/app/archieui/degraded_routes_test.go +++ b/internal/app/archieui/degraded_routes_test.go @@ -14,6 +14,7 @@ import ( "google.golang.org/grpc" "github.com/samcharles93/archie-core/internal/infrastructure/staterpc" + "github.com/samcharles93/archie-core/internal/logging" "github.com/samcharles93/archie-core/internal/store" "github.com/samcharles93/archie-core/internal/webui" ) @@ -51,11 +52,13 @@ func TestRoutesWithoutAContractDegradeExplicitly(t *testing.T) { want: http.StatusServiceUnavailable, }, { - // The task exists; its logs do not, because the files live on - // the daemon's host. "disabled" is the same answer the daemon - // gives when task logging is off, and the page already reads it. + // Task logs are a State Store read contract now + // (archie-core-iaqx), so the route answers with real data + // rather than the degrade. The task exists and its attempt + // has no log file, which is the found=false answer -- the + // page says the attempt has no log, not that logging is off. name: "per-task logs", method: http.MethodGet, path: "/api/tasks/" + strconv.FormatInt(taskID, 10) + "/logs", - want: http.StatusOK, emptyJSON: `"disabled":true`, + want: http.StatusOK, emptyJSON: `"found":false`, }, { name: "release version and update flow", method: http.MethodGet, path: "/api/version", @@ -159,8 +162,17 @@ func composeUIProcess(t *testing.T) (*webui.Server, int64) { } t.Cleanup(func() { _ = st.Close() }) + // The task-log reader lives on the state-directory side of the boundary: + // the State Store process holds a registry over the directory it owns, and + // the dashboard reads through it (archie-core-iaqx). Nothing is written to + // it here, so every attempt reads as found=false. + logs := logging.NewTaskRegistry(filepath.Join(t.TempDir(), "logs", "tasks"), logging.NewFeed(10), logging.TaskSinkOptions{}) + target, stop := serveGRPC(t, func(r grpc.ServiceRegistrar) { - staterpc.RegisterServer(r, staterpc.Deps{Tasks: st, Captures: st, BindingDispatcher: st, ConfigSnapshots: st, Log: slog.New(slog.DiscardHandler)}) + staterpc.RegisterServer(r, staterpc.Deps{ + Tasks: st, Captures: st, BindingDispatcher: st, ConfigSnapshots: st, + TaskLogs: logs, Log: slog.New(slog.DiscardHandler), + }) }) t.Cleanup(stop) client, closeClient, err := staterpc.Dial(target, "") diff --git a/internal/app/archieui/task_logs_test.go b/internal/app/archieui/task_logs_test.go new file mode 100644 index 000000000..c634420e4 --- /dev/null +++ b/internal/app/archieui/task_logs_test.go @@ -0,0 +1,201 @@ +package archieui + +import ( + "encoding/json" + "io" + "log/slog" + "net/http" + "net/http/httptest" + "path/filepath" + "strconv" + "strings" + "testing" + + "google.golang.org/grpc" + + "github.com/samcharles93/archie-core/internal/infrastructure/staterpc" + "github.com/samcharles93/archie-core/internal/logging" + "github.com/samcharles93/archie-core/internal/store" + "github.com/samcharles93/archie-core/internal/webui" +) + +// TestUIProcessReadsTaskLogsOverTheStateStoreContract is the dashboard bug, +// pinned end to end: the extracted UI process serves GET /api/tasks/{id}/logs +// and has no way to read a task's persisted log at all, because the only reader +// it ever had was a daemon-local file handle. The page therefore answered "Task +// logging is optional and was not enabled for this run" for every attempt of +// every task, on a deployment where task logging is unconditional and the files +// exist. +// +// The fix is a State Store read contract, so this drives the real thing: a log +// file written on the state-directory side, a gRPC server over it, a dashboard +// composed exactly as the UI process composes one, and an HTTP request through +// the composed handler. +func TestUIProcessReadsTaskLogsOverTheStateStoreContract(t *testing.T) { + srv, taskID, wantAttempt := composeUIProcessWithLog(t) + ts := httptest.NewServer(srv.Handler()) + defer ts.Close() + + path := "/api/tasks/" + strconv.FormatInt(taskID, 10) + "/logs" + req, err := http.NewRequestWithContext(t.Context(), http.MethodGet, ts.URL+path, nil) + if err != nil { + t.Fatalf("request: %v", err) + } + resp, err := ts.Client().Do(req) + if err != nil { + t.Fatalf("GET %s: %v", path, err) + } + defer resp.Body.Close() + raw, err := io.ReadAll(resp.Body) + if err != nil { + t.Fatalf("read body: %v", err) + } + var body struct { + Entries []logging.Entry `json:"entries"` + Attempt int `json:"attempt"` + Found bool `json:"found"` + File string `json:"file"` + } + if err := json.Unmarshal(raw, &body); err != nil { + t.Fatalf("decode response: %v (%s)", err, raw) + } + if !body.Found { + t.Errorf("found = false for an attempt whose log exists on the state-directory side (%s)", raw) + } + if body.Attempt != wantAttempt { + t.Errorf("attempt = %d, want %d (the task's current attempt, resolved without a query param)", body.Attempt, wantAttempt) + } + if len(body.Entries) != 1 || body.Entries[0].Message != "gate failed" { + t.Fatalf("entries = %+v, want the one entry the log holds", body.Entries) + } + if got, ok := body.Entries[0].Fields["component"]; !ok || got != "gate" { + t.Errorf("entry fields = %+v, want the structured component field to survive the hop", body.Entries[0].Fields) + } + // The path is reported, not used: the UI process must not be able to open + // it, and the page only names where the log came from. + if !strings.HasSuffix(body.File, "attempt-"+strconv.Itoa(wantAttempt)+".jsonl") { + t.Errorf("file = %q, want the attempt's own log path", body.File) + } +} + +// TestUIProcessServesTaskLogDownload drives the download endpoint through the +// real composition: the bytes arrive over the contract, and the response is an +// attachment named for the attempt rather than an SPA page. +// +// A GET that falls through to the asset handler answers 200 with HTML, which +// is why this asserts the attachment headers and the content, not the status. +func TestUIProcessServesTaskLogDownload(t *testing.T) { + srv, taskID, wantAttempt := composeUIProcessWithLog(t) + ts := httptest.NewServer(srv.Handler()) + defer ts.Close() + + path := "/api/tasks/" + strconv.FormatInt(taskID, 10) + "/logs/download" + req, err := http.NewRequestWithContext(t.Context(), http.MethodGet, ts.URL+path, nil) + if err != nil { + t.Fatalf("request: %v", err) + } + resp, err := ts.Client().Do(req) + if err != nil { + t.Fatalf("GET %s: %v", path, err) + } + defer resp.Body.Close() + raw, err := io.ReadAll(resp.Body) + if err != nil { + t.Fatalf("read body: %v", err) + } + wantName := "task-" + strconv.FormatInt(taskID, 10) + "-attempt-" + strconv.Itoa(wantAttempt) + ".log" + if got := resp.Header.Get("Content-Disposition"); got != `attachment; filename="`+wantName+`"` { + t.Errorf("Content-Disposition = %q, want the attempt's own filename %q (status %d, body %s)", got, wantName, resp.StatusCode, raw) + } + if !strings.Contains(string(raw), "gate failed") { + t.Errorf("download body = %s, want the attempt's own log content", raw) + } +} + +// TestUIProcessReportsMissingTaskLogsHonestly pins the second half of the fix: +// with the reader wired and no log on disk, the page must be able to say that +// the ATTEMPT has no log. It is a different claim from "this process cannot +// read logs", and only the second one is about the operator's configuration. +func TestUIProcessReportsMissingTaskLogsHonestly(t *testing.T) { + srv, taskID := composeUIProcess(t) + ts := httptest.NewServer(srv.Handler()) + defer ts.Close() + + path := "/api/tasks/" + strconv.FormatInt(taskID, 10) + "/logs" + req, err := http.NewRequestWithContext(t.Context(), http.MethodGet, ts.URL+path, nil) + if err != nil { + t.Fatalf("request: %v", err) + } + resp, err := ts.Client().Do(req) + if err != nil { + t.Fatalf("GET %s: %v", path, err) + } + defer resp.Body.Close() + raw, _ := io.ReadAll(resp.Body) + + var body struct { + Disabled bool `json:"disabled"` + Found bool `json:"found"` + } + if err := json.Unmarshal(raw, &body); err != nil { + t.Fatalf("decode response: %v (%s)", err, raw) + } + if body.Disabled { + t.Fatalf("disabled = true for a process that can read task logs (%s); the page turns that into \"logging was not enabled for this run\"", raw) + } + if body.Found { + t.Errorf("found = true for an attempt with no log file (%s)", raw) + } +} + +// composeUIProcessWithLog is composeUIProcess plus one real log on the +// state-directory side: a gRPC server whose task-log reader holds an attempt's +// file, so the dashboard's read has to cross the wire to see anything. +func composeUIProcessWithLog(t *testing.T) (*webui.Server, int64, int) { + t.Helper() + st, err := store.Open(t.Context(), filepath.Join(t.TempDir(), "tasks.sqlite")) + if err != nil { + t.Fatalf("open store: %v", err) + } + t.Cleanup(func() { _ = st.Close() }) + + task, err := st.EnqueueChatTask(t.Context(), "acme", "widget", "a task", "body", "implement", "") + if err != nil { + t.Fatalf("seed task: %v", err) + } + + // The state directory the State Store process owns. The dashboard never + // learns this path: it asks the contract for the log. + logs := logging.NewTaskRegistry(filepath.Join(t.TempDir(), "logs", "tasks"), logging.NewFeed(10), logging.TaskSinkOptions{}) + if err := logs.Open(task.ID, task.Attempt); err != nil { + t.Fatalf("open task log: %v", err) + } + logs.Write(task.ID, logging.Entry{ + Level: "ERROR", Message: "gate failed", Fields: map[string]any{"component": "gate"}, + }) + if err := logs.Close(task.ID); err != nil { + t.Fatalf("close task log: %v", err) + } + + target, stop := serveGRPC(t, func(r grpc.ServiceRegistrar) { + staterpc.RegisterServer(r, staterpc.Deps{ + Tasks: st, Captures: st, BindingDispatcher: st, ConfigSnapshots: st, + TaskLogs: logs, Log: slog.New(slog.DiscardHandler), + }) + }) + t.Cleanup(stop) + client, closeClient, err := staterpc.Dial(target, "") + if err != nil { + t.Fatalf("dial state store: %v", err) + } + t.Cleanup(closeClient) + + options := Options{Listen: "127.0.0.1:0", DependencyTimeout: defaultDependencyTimeout} + srv := compose(deps{ + Options: options, + Log: slog.New(slog.DiscardHandler), + Store: client, + Health: newReadinessRegistry(options, client, nil), + }) + return srv, task.ID, task.Attempt +} diff --git a/internal/domain/storecontract/storecontract.go b/internal/domain/storecontract/storecontract.go index 6766ddd1a..6f9b280d3 100644 --- a/internal/domain/storecontract/storecontract.go +++ b/internal/domain/storecontract/storecontract.go @@ -18,12 +18,14 @@ package storecontract import ( "context" "errors" + "io" "time" "github.com/samcharles93/archie-core/internal/domain/binding" "github.com/samcharles93/archie-core/internal/domain/mapping" "github.com/samcharles93/archie-core/internal/domain/workflow/task" "github.com/samcharles93/archie-core/internal/events" + "github.com/samcharles93/archie-core/internal/logging" ) // TaskStore is the full store surface the daemon needs. @@ -160,6 +162,27 @@ type BindingTaskCreator interface { EnqueueBindingTask(ctx context.Context, owner, repo, title, body, wf, identity string, bindingID int64, bindingVersion int) (*task.Task, error) } +// TaskLogStore reads one task attempt's persisted log. Deliberately separate +// from TaskQueries: the log is not a row, it is a file the logging package +// owns the format of, and a process that can read the task board should not +// have to acquire a log reader to do it. The dashboard's UI process is the +// consumer this exists for -- it holds no daemon-local file handle, so the +// read crosses the State Store contract (docs/prds/ui-service-boundary.md). +// +// Found=false with a nil error is the not-found convention every read here +// uses, and it is load-bearing: "this attempt has no log" is not "this +// process cannot read logs". The second one is an error +// (logging.ErrTaskLogsUnavailable), because a caller that conflates them +// reports a configuration change where none is needed. +type TaskLogStore interface { + // TaskLog returns a page of one attempt's decoded log. attempt 0 selects + // the task's current attempt. + TaskLog(ctx context.Context, taskID int64, attempt int, q logging.Query) (logging.TaskLogPage, error) + // TaskLogContent writes one attempt's log verbatim to w, for a download. + // found is false, with a nil error, when the attempt has no log file. + TaskLogContent(ctx context.Context, taskID int64, attempt int, w io.Writer) (found bool, err error) +} + // CapturedEvent is one unbound inbound webhook capture: no workflow binding, // no forge/task association -- just what arrived, from where, and when. // See docs/prds/event-capture-storage.md. diff --git a/internal/infrastructure/staterpc/client.go b/internal/infrastructure/staterpc/client.go index 817cdee86..958cc4d6d 100644 --- a/internal/infrastructure/staterpc/client.go +++ b/internal/infrastructure/staterpc/client.go @@ -14,6 +14,7 @@ import ( "github.com/samcharles93/archie-core/internal/domain/storecontract" "github.com/samcharles93/archie-core/internal/domain/workflow/task" "github.com/samcharles93/archie-core/internal/events" + "github.com/samcharles93/archie-core/internal/logging" ) // Client is the single remote adapter wrapping one StateStoreServiceClient, @@ -36,6 +37,7 @@ func (c *Client) Close() error { return nil } var ( _ task.Store = (*Client)(nil) _ storecontract.TaskStore = (*Client)(nil) + _ storecontract.TaskLogStore = (*Client)(nil) _ storecontract.CaptureStore = (*Client)(nil) _ storecontract.MappingStore = (*Client)(nil) _ storecontract.BindingStore = (*Client)(nil) @@ -417,6 +419,58 @@ func (c *Client) EnqueueBindingTask(ctx context.Context, owner, repo, title, bod return taskValue(r.Task), nil } +// Task log + +// TaskLog reads one task attempt's decoded log over the wire. found=false with +// a nil error is the attempt-has-no-log answer; a process with no reader at +// all comes back as an unavailable error, not as an empty page, so a caller +// can tell the two apart. +func (c *Client) TaskLog(ctx context.Context, taskID int64, attempt int, q logging.Query) (logging.TaskLogPage, error) { + r, err := c.client.ReadTaskLog(ctx, taskLogRequestProto(taskID, attempt, q)) + if err != nil { + return logging.TaskLogPage{}, unmapError(err) + } + if !r.Found { + return logging.TaskLogPage{ + Entries: []logging.Entry{}, + Components: []string{}, + }, nil + } + return logging.TaskLogPage{ + Entries: mapValues(r.Entries, taskLogEntryValue), + Truncated: r.Truncated, + File: r.File, + Found: true, + Components: r.Components, + }, nil +} + +// TaskLogContent streams one attempt's log verbatim into w, for a download. +// found is false, with a nil error, when the attempt has no log file. +func (c *Client) TaskLogContent(ctx context.Context, taskID int64, attempt int, w io.Writer) (bool, error) { + stream, err := c.client.StreamTaskLogContent(ctx, &pb.StreamTaskLogContentRequest{TaskId: taskID, Attempt: int64(attempt)}) + if err != nil { + return false, unmapError(err) + } + found := false + for { + r, err := stream.Recv() + if errors.Is(err, io.EOF) { + return found, nil + } + if err != nil { + return found, unmapError(err) + } + found = found || r.Found + if len(r.Chunk) == 0 { + continue + } + if _, err := w.Write(r.Chunk); err != nil { + return found, err + } + } +} + func derefTasks(in []*pb.Task) []task.Task { if in == nil { return nil diff --git a/internal/infrastructure/staterpc/conformance_test.go b/internal/infrastructure/staterpc/conformance_test.go index 9902a5438..90d1a9f92 100644 --- a/internal/infrastructure/staterpc/conformance_test.go +++ b/internal/infrastructure/staterpc/conformance_test.go @@ -31,13 +31,31 @@ type contract interface { store.ConfigSnapshotStore } +// taskLogContract is the task-log read group, driven separately because it is +// not a *store.Store surface: the reader is internal/logging's own registry, +// which owns the log format, so the local side of this contract is a registry +// rather than a store. +type taskLogContract interface { + store.TaskLogStore +} + func remoteContract(t *testing.T, local *store.Store) contract { + t.Helper() + return remoteTaskStore(t, local, nil) +} + +// remoteTaskStore serves local behind a bufconn listener with a task-log +// reader attached, and returns a client for it. The reader is a parameter +// because the log files are internal/logging's, not the store's: this contract +// fronts a reader rather than a table. +func remoteTaskStore(t *testing.T, local *store.Store, logs store.TaskLogStore) *Client { t.Helper() listener := bufconn.Listen(1 << 20) server := grpc.NewServer() RegisterServer(server, Deps{ Tasks: local, Captures: local, Mappings: local, Bindings: local, BindingDispatcher: local, BindingTaskCreator: local, ConfigSnapshots: local, + TaskLogs: logs, }) go func() { _ = server.Serve(listener) }() t.Cleanup(func() { server.Stop(); _ = listener.Close() }) diff --git a/internal/infrastructure/staterpc/server.go b/internal/infrastructure/staterpc/server.go index ab53cba4e..577969246 100644 --- a/internal/infrastructure/staterpc/server.go +++ b/internal/infrastructure/staterpc/server.go @@ -5,7 +5,9 @@ package staterpc import ( + "bytes" "context" + "errors" "log/slog" "time" @@ -17,6 +19,7 @@ import ( "github.com/samcharles93/archie-core/internal/domain/binding" "github.com/samcharles93/archie-core/internal/domain/mapping" "github.com/samcharles93/archie-core/internal/domain/storecontract" + "github.com/samcharles93/archie-core/internal/logging" ) // Unavailable-capability errors, mirroring gatewayrpc's missing-session-store @@ -30,10 +33,23 @@ var ( errBindingUnavailable = status.Error(codes.Unavailable, "binding store unavailable") errBindingDispatchUnavailable = status.Error(codes.Unavailable, "binding dispatcher unavailable") errBindingTaskCreatorUnavailable = status.Error(codes.Unavailable, "binding task creator unavailable") + // errTaskLogsUnavailable is the "this process cannot read task logs at + // all" answer, and it is deliberately distinct from a found=false read + // result: only the first is a deployment matter. A dashboard that receives + // this reports that the log cannot be read here; it must never turn it + // into "task logging was not enabled for this run", which is what the + // absent-handle path used to do. + errTaskLogsUnavailable = status.Error(codes.Unavailable, msgTaskLogsUnavailable) ) func timeSeconds(s int64) time.Duration { return time.Duration(s) * time.Second } +// taskLogChunkBytes bounds one streamed message. A log file rotates at +// logging.DefaultMaxSizeMB, well past gRPC's 4MiB unary cap, so the download +// is served in pieces (the same reason StreamCaptures superseded ListCaptures) +// and the pieces must be small enough to carry. +const taskLogChunkBytes = 256 << 10 + // Deps groups the store surfaces the StateStore service fronts. TaskStore is // required; the rest are optional (nil disables that group's RPCs, returning // codes.Unavailable) exactly as their daemon-side consumers already treat a @@ -47,7 +63,14 @@ type Deps struct { Bindings storecontract.BindingStore BindingDispatcher storecontract.BindingDispatcher BindingTaskCreator storecontract.BindingTaskCreator - Log *slog.Logger + // TaskLogs reads one task attempt's persisted log out of the state + // directory this process owns. Optional, and nil is the honest default for + // a store service that shares no state directory with the daemon: + // ReadTaskLog then answers codes.Unavailable, which the dashboard reports + // as "this process cannot read logs" rather than as "this attempt has no + // log". Conflating those two is the bug this contract exists to fix. + TaskLogs storecontract.TaskLogStore + Log *slog.Logger } type server struct { @@ -565,6 +588,117 @@ func (s *server) EnqueueBindingTask(ctx context.Context, r *pb.EnqueueBindingTas return &pb.EnqueueBindingTaskResponse{Task: taskProto(t)}, nil } +// Task log + +func (s *server) taskLogs() (storecontract.TaskLogStore, error) { + if s.deps.TaskLogs == nil { + return nil, errTaskLogsUnavailable + } + return s.deps.TaskLogs, nil +} + +func (s *server) ReadTaskLog(ctx context.Context, r *pb.ReadTaskLogRequest) (*pb.ReadTaskLogResponse, error) { + logs, err := s.taskLogs() + if err != nil { + return nil, err + } + page, err := logs.TaskLog(ctx, r.TaskId, int(r.Attempt), taskLogQueryValue(r)) + if err != nil { + // A store that cannot read its own state directory keeps its own + // identity: this is unavailability, not a missing log, and a caller + // has to be able to tell them apart. + if errors.Is(err, logging.ErrTaskLogsUnavailable) { + return nil, errTaskLogsUnavailable + } + return nil, s.logErr("ReadTaskLog", err) + } + if !page.Found { + return &pb.ReadTaskLogResponse{Attempt: r.Attempt}, nil + } + return &pb.ReadTaskLogResponse{ + Entries: mapValues(page.Entries, taskLogEntryProto), + Truncated: page.Truncated, + Attempt: r.Attempt, + Found: true, + Components: page.Components, + File: page.File, + }, nil +} + +// StreamTaskLogContent sends one attempt's log verbatim, one chunk per +// message, for a download. A single reply reports found=false with no chunks: +// the attempt has no log file, which is a normal state rather than a failure. +func (s *server) StreamTaskLogContent(r *pb.StreamTaskLogContentRequest, stream pb.StateStoreService_StreamTaskLogContentServer) error { + logs, err := s.taskLogs() + if err != nil { + return err + } + // The chunking the client sees is owned by the reader that writes into + // this buffer, so the wire never holds a whole log to re-slice it. + buf := &chunkWriter{stream: stream, attempt: r.Attempt} + found, err := logs.TaskLogContent(stream.Context(), r.TaskId, int(r.Attempt), buf) + if err != nil { + if errors.Is(err, logging.ErrTaskLogsUnavailable) { + return errTaskLogsUnavailable + } + return s.logErr("StreamTaskLogContent", err) + } + if err := buf.flush(); err != nil { + return err + } + // A found log with no bytes still reports found: an attempt whose file is + // empty did produce a log, and found is what tells the download it may + // write an empty file rather than answer 404. + if found && buf.sent { + return nil + } + return stream.Send(&pb.StreamTaskLogContentResponse{Attempt: r.Attempt, Found: found}) +} + +// chunkWriter packs everything a log reader writes into stream-sized messages +// on its way through. It exists so the read can be one io.CopyBuffer of the +// file into this writer: the reader keeps its own chunk size, and the bytes +// are never all held at once. +type chunkWriter struct { + stream pb.StateStoreService_StreamTaskLogContentServer + attempt int64 + pending []byte + // sent records whether any chunk reached the client, which is how the + // caller tells "the file was empty" from "the file was read". + sent bool +} + +func (w *chunkWriter) Write(p []byte) (int, error) { + w.pending = append(w.pending, p...) + for len(w.pending) >= taskLogChunkBytes { + if err := w.emit(w.pending[:taskLogChunkBytes]); err != nil { + return 0, err + } + w.pending = w.pending[taskLogChunkBytes:] + } + return len(p), nil +} + +func (w *chunkWriter) emit(chunk []byte) error { + w.sent = true + // The slice is copied into the message: the reader's buffer is reused + // across writes and must not be aliased by a message in flight. + return w.stream.Send(&pb.StreamTaskLogContentResponse{ + Chunk: bytes.Clone(chunk), + Attempt: w.attempt, + Found: true, + }) +} + +func (w *chunkWriter) flush() error { + if len(w.pending) == 0 { + return nil + } + chunk := w.pending + w.pending = nil + return w.emit(chunk) +} + func mappingProtoPtr(m *mapping.Mapping) *pb.Mapping { if m == nil { return nil diff --git a/internal/infrastructure/staterpc/task_log_test.go b/internal/infrastructure/staterpc/task_log_test.go new file mode 100644 index 000000000..c4a01630b --- /dev/null +++ b/internal/infrastructure/staterpc/task_log_test.go @@ -0,0 +1,200 @@ +package staterpc + +import ( + "bytes" + "errors" + "os" + "path/filepath" + "strings" + "testing" + + "github.com/samcharles93/archie-core/internal/logging" + "github.com/samcharles93/archie-core/internal/store" +) + +// TestTaskLogContract drives the task-log read group through both adapters, +// matching the §11 conformance requirement the rest of this package already +// satisfies: the same battery runs against the local reader (a +// *logging.TaskRegistry over this process's own state directory) and against +// the remote *Client. +// +// The two answers this pins as DIFFERENT are the point of the contract. A +// process with no reader reports unavailability; an attempt with no log file +// reports found=false with no error. A caller that cannot tell those apart +// tells an operator task logging is switched off when it is not. +func TestTaskLogContract(t *testing.T) { + for _, mode := range []string{"local", "grpc"} { + t.Run(mode, func(t *testing.T) { + ctx := t.Context() + baseDir := filepath.Join(t.TempDir(), "logs", "tasks") + reader := logging.NewTaskRegistry(baseDir, logging.NewFeed(10), logging.TaskSinkOptions{}) + + const taskID = 7 + if err := reader.Open(taskID, 0); err != nil { + t.Fatalf("open sink: %v", err) + } + reader.Write(taskID, logging.Entry{Level: "INFO", Message: "starting", Fields: map[string]any{"component": "daemon"}}) + reader.Write(taskID, logging.Entry{Level: "ERROR", Message: "gate failed", Fields: map[string]any{"component": "gate"}}) + if err := reader.Close(taskID); err != nil { + t.Fatalf("close sink: %v", err) + } + + var c taskLogContract = reader + if mode == "grpc" { + c = remoteTaskStore(t, store.OpenTest(t), reader) + } + + t.Run("a page carries the decoded entries and their fields", func(t *testing.T) { + page, err := c.TaskLog(ctx, taskID, 0, logging.Query{}) + if err != nil { + t.Fatalf("TaskLog: %v", err) + } + if !page.Found { + t.Fatal("Found = false for an attempt whose log exists") + } + if len(page.Entries) != 2 { + t.Fatalf("entries = %d, want 2", len(page.Entries)) + } + if page.Entries[1].Message != "gate failed" || page.Entries[1].Level != "ERROR" { + t.Errorf("entry = %+v, want the ERROR line the sink wrote", page.Entries[1]) + } + if got, _ := page.Entries[0].Fields["component"].(string); got != "daemon" { + t.Errorf("fields = %+v, want the structured component to survive the hop", page.Entries[0].Fields) + } + if !strings.HasSuffix(page.File, "attempt-0.jsonl") { + t.Errorf("file = %q, want the attempt's own path", page.File) + } + }) + + t.Run("filters and the limit cross the wire", func(t *testing.T) { + page, err := c.TaskLog(ctx, taskID, 0, logging.Query{Levels: []string{"ERROR"}}) + if err != nil { + t.Fatalf("TaskLog: %v", err) + } + if len(page.Entries) != 1 || page.Entries[0].Message != "gate failed" { + t.Fatalf("level filter = %+v, want just the ERROR line", page.Entries) + } + page, err = c.TaskLog(ctx, taskID, 0, logging.Query{Component: "daemon"}) + if err != nil { + t.Fatalf("TaskLog: %v", err) + } + if len(page.Entries) != 1 || page.Entries[0].Message != "starting" { + t.Fatalf("component filter = %+v, want just the daemon line", page.Entries) + } + page, err = c.TaskLog(ctx, taskID, 0, logging.Query{Contains: "gate"}) + if err != nil { + t.Fatalf("TaskLog: %v", err) + } + if len(page.Entries) != 1 || page.Entries[0].Message != "gate failed" { + t.Fatalf("contains filter = %+v, want just the gate line", page.Entries) + } + page, err = c.TaskLog(ctx, taskID, 0, logging.Query{Limit: 1}) + if err != nil { + t.Fatalf("TaskLog: %v", err) + } + if len(page.Entries) != 1 || !page.Truncated { + t.Fatalf("limit = 1 gave %d entries (truncated %v), want one and a truncated marker", len(page.Entries), page.Truncated) + } + }) + + t.Run("components list what the log actually contains", func(t *testing.T) { + page, err := c.TaskLog(ctx, taskID, 0, logging.Query{}) + if err != nil { + t.Fatalf("TaskLog: %v", err) + } + if len(page.Components) != 2 || page.Components[0] != "daemon" || page.Components[1] != "gate" { + t.Fatalf("components = %v, want the sorted distinct set", page.Components) + } + }) + + t.Run("an attempt with no log is found=false, not an error", func(t *testing.T) { + page, err := c.TaskLog(ctx, taskID, 99, logging.Query{}) + if err != nil { + t.Fatalf("TaskLog for a missing attempt = %v, want no error", err) + } + if page.Found { + t.Error("Found = true for an attempt with no log file") + } + if len(page.Entries) != 0 { + t.Errorf("entries = %+v, want none", page.Entries) + } + }) + + t.Run("content is the file verbatim, and found is false when there is none", func(t *testing.T) { + var buf bytes.Buffer + found, err := c.TaskLogContent(ctx, taskID, 0, &buf) + if err != nil { + t.Fatalf("TaskLogContent: %v", err) + } + if !found { + t.Fatal("found = false for an attempt whose log exists") + } + body := buf.String() + if !strings.Contains(body, "gate failed") || !strings.Contains(body, "starting") { + t.Fatalf("content = %q, want the raw log lines", body) + } + // Byte-for-byte: the contract transports the log, it does not + // re-encode it. Every line must still parse as the package's + // own JSONL. + for line := range strings.Lines(strings.TrimSpace(body)) { + if _, ok := loggingTailDecodes(t, line); !ok { + t.Fatalf("line %q does not decode as the logging package's own format", line) + } + } + + buf.Reset() + found, err = c.TaskLogContent(ctx, taskID, 99, &buf) + if err != nil { + t.Fatalf("TaskLogContent for a missing attempt = %v, want no error", err) + } + if found || buf.Len() != 0 { + t.Errorf("found = %v with %d bytes, want false and nothing", found, buf.Len()) + } + }) + }) + } +} + +// TestTaskLogContractWithoutAReaderIsUnavailable pins the other half of the +// distinction, and the one the dashboard's misleading message came from: a +// service with no task-log reader at all must say UNAVAILABLE rather than +// answer an empty page. An empty page is indistinguishable from an attempt +// that has no log, and the dashboard rendered that as "task logging is +// optional and was not enabled for this run". +func TestTaskLogContractWithoutAReaderIsUnavailable(t *testing.T) { + local := store.OpenTest(t) + // remoteContract leaves Deps.TaskLogs nil, which is what a store service + // sharing no state directory with the daemon looks like. + c := remoteContract(t, local) + logs, ok := c.(taskLogContract) + if !ok { + t.Fatalf("remote client does not carry the task-log contract (%T)", c) + } + + if _, err := logs.TaskLog(t.Context(), 1, 0, logging.Query{}); !errors.Is(err, logging.ErrTaskLogsUnavailable) { + t.Errorf("TaskLog without a reader = %v, want ErrTaskLogsUnavailable; an empty page here is what the dashboard read as \"logging was not enabled\"", err) + } + var buf bytes.Buffer + if _, err := logs.TaskLogContent(t.Context(), 1, 0, &buf); !errors.Is(err, logging.ErrTaskLogsUnavailable) { + t.Errorf("TaskLogContent without a reader = %v, want ErrTaskLogsUnavailable", err) + } +} + +// loggingTailDecodes reports whether one line is a record the logging package +// can decode, using that package's own reader rather than a second opinion +// about its format. +func loggingTailDecodes(t *testing.T, line string) (logging.Entry, bool) { + t.Helper() + path := filepath.Join(t.TempDir(), "one.jsonl") + if err := os.WriteFile(path, []byte(line+"\n"), 0o600); err != nil { + t.Fatalf("write temp log: %v", err) + } + res, err := logging.Tail(path, logging.Query{}) + if err != nil { + t.Fatalf("Tail: %v", err) + } + if len(res.Entries) != 1 { + return logging.Entry{}, false + } + return res.Entries[0], true +} diff --git a/internal/infrastructure/staterpc/values.go b/internal/infrastructure/staterpc/values.go index 3573f98fd..54cdb0895 100644 --- a/internal/infrastructure/staterpc/values.go +++ b/internal/infrastructure/staterpc/values.go @@ -17,6 +17,7 @@ import ( "github.com/samcharles93/archie-core/internal/domain/storecontract" "github.com/samcharles93/archie-core/internal/domain/workflow/task" "github.com/samcharles93/archie-core/internal/events" + "github.com/samcharles93/archie-core/internal/logging" ) func timestamp(t time.Time) *timestamppb.Timestamp { @@ -245,6 +246,12 @@ const ( msgBindingTransition = "binding transition rejected" msgAlreadyDispatched = "already dispatched" msgInternal = "state store: internal error" + // msgTaskLogsUnavailable is the public phrase for "this service has no + // task-log reader". It is a wire contract like the sentinels above: the + // client rehydrates logging.ErrTaskLogsUnavailable from (Unavailable, this + // message), and a caller depends on that to tell "this process cannot read + // logs" from "this attempt has no log". + msgTaskLogsUnavailable = "task log reader unavailable" ) // mapError converts a store sentinel error into a structured gRPC status @@ -301,6 +308,12 @@ func mapError(err error) error { // *status.Error whose code is DeadlineExceeded or Canceled, so we rehydrate // those back to the standard context sentinels -- otherwise the consumer // would (wrongly) park a task that was merely interrupted. +// +// Unavailable carries one message this package owns: the absent task-log +// reader. It is rehydrated for the same reason the error sentinels are -- +// the dashboard's whole bug was rendering "this process cannot read logs" as +// "the attempt has no log", and only the typed error makes that distinction +// available to a caller. func unmapError(err error) error { if err == nil { return nil @@ -314,6 +327,19 @@ func unmapError(err error) error { return context.Canceled case codes.DeadlineExceeded: return context.DeadlineExceeded + } + if sentinel := sentinelForStatus(st); sentinel != nil { + return sentinel + } + return fmt.Errorf("state store: %s: %w", st.Message(), err) +} + +// sentinelForStatus maps a status to the store or logging sentinel it stands +// for, matched on (code, exact canonical message) -- those message constants +// are part of the wire contract (§4). A code whose message is not one this +// package defines returns nil, so the caller falls back to the wrapped form. +func sentinelForStatus(st *status.Status) error { + switch st.Code() { case codes.FailedPrecondition: switch st.Message() { case msgStaleTransition: @@ -334,8 +360,12 @@ func unmapError(err error) error { if st.Message() == msgAlreadyDispatched { return storecontract.ErrAlreadyDispatched } + case codes.Unavailable: + if st.Message() == msgTaskLogsUnavailable { + return logging.ErrTaskLogsUnavailable + } } - return fmt.Errorf("state store: %s: %w", st.Message(), err) + return nil } // configSnapshotProto and configSnapshotValue carry the dashboard's @@ -359,3 +389,46 @@ func configSnapshotValue(snapshot *pb.ConfigSnapshot) storecontract.ConfigSnapsh PublishedAt: timeValue(snapshot.PublishedAt), } } + +// taskLogEntryProto and taskLogEntryValue mirror internal/logging.Entry, whose +// Fields map crosses as a JSON object string exactly as events.Event.Data does +// (see eventDataJSON above). The logging package owns that format end to end; +// this is a transport of it, not a second definition. +func taskLogEntryProto(e logging.Entry) *pb.TaskLogEntry { + return &pb.TaskLogEntry{ + Id: e.ID, Time: timestamp(e.Time), Level: e.Level, Msg: e.Message, + FieldsJson: eventDataJSON(e.Fields), + } +} + +func taskLogEntryValue(e *pb.TaskLogEntry) logging.Entry { + if e == nil { + return logging.Entry{} + } + return logging.Entry{ + ID: e.Id, Time: timeValue(e.Time), Level: e.Level, Message: e.Msg, + Fields: eventDataValue(e.FieldsJson), + } +} + +// taskLogRequestProto is the client half of the ReadTaskLog mapping and +// taskLogQueryValue the server half: the whole logging.Query crosses, not a +// subset of it, so a filter cannot silently stop working at the boundary. +func taskLogRequestProto(taskID int64, attempt int, q logging.Query) *pb.ReadTaskLogRequest { + return &pb.ReadTaskLogRequest{ + TaskId: taskID, Attempt: int64(attempt), Limit: int64(q.Limit), + Levels: q.Levels, Component: q.Component, Contains: q.Contains, + Since: timestamp(q.Since), Until: timestamp(q.Until), + } +} + +func taskLogQueryValue(r *pb.ReadTaskLogRequest) logging.Query { + return logging.Query{ + Levels: r.Levels, + Component: r.Component, + Contains: r.Contains, + Limit: int(r.Limit), + Since: timeValue(r.Since), + Until: timeValue(r.Until), + } +} diff --git a/internal/logging/reader.go b/internal/logging/reader.go index 13a0c6aa9..5d6a6df6e 100644 --- a/internal/logging/reader.go +++ b/internal/logging/reader.go @@ -2,8 +2,11 @@ package logging import ( "bytes" + "context" "encoding/json" + "errors" "fmt" + "io" "os" "slices" "strings" @@ -65,6 +68,88 @@ type Result struct { Truncated bool `json:"truncated"` // File is the path read, for the UI to show where this came from. File string `json:"file"` + // Found reports whether the file existed. False with a nil error is not a + // failure: a caller asking for a log that has no file yet, or one whose + // attempt produced no output, must be told that rather than shown an empty + // page indistinguishable from a log that is genuinely empty. This is also + // what separates "there is no log for this attempt" from "this process + // cannot read logs at all" -- two conditions that a reader has to report + // differently because only the second is a configuration matter. + Found bool `json:"found"` +} + +// TaskLogPage is one task attempt's log as a task-log reader returns it: the +// page Tail selected, whether the attempt has a file at all, and the distinct +// components present in the file's tail so a filter is built from what is +// actually there rather than a hardcoded list that drifts. +type TaskLogPage struct { + Result + Components []string `json:"components"` +} + +// ErrTaskLogsUnavailable reports that this process cannot read task logs at +// all -- no reader is configured here. It is deliberately not the same answer +// as "this attempt has no log" (Result.Found = false): a caller that conflates +// them tells an operator task logging is switched off when it is not, which is +// the bug this error exists to prevent. +var ErrTaskLogsUnavailable = errors.New("logging: task log reader unavailable") + +// taskLogChunkBytes bounds one write a TaskLogContent makes, so a reader that +// pushes into a bounded transport emits chunks that transport can carry. +// io.Copy would otherwise hand it reads of its own choosing. +const taskLogChunkBytes = 256 << 10 + +// TaskLog reads one task attempt's persisted log from this registry. A nil +// registry (task logging not configured for this process) reports +// ErrTaskLogsUnavailable, never an empty page: a process that cannot read logs +// must say so rather than implicate the attempt. Safe to call on a nil +// receiver, like every other method here. +func (r *TaskRegistry) TaskLog(_ context.Context, taskID int64, attempt int, q Query) (TaskLogPage, error) { + if r == nil { + return TaskLogPage{}, ErrTaskLogsUnavailable + } + res, err := Tail(TaskLogPath(r.baseDir, taskID, attempt), q) + if err != nil { + return TaskLogPage{}, err + } + page := TaskLogPage{Result: res, Components: []string{}} + // The filter list is a convenience: failing to build it must not cost the + // caller their entries. Components only reads the tail this page already + // read, so its error is the same "treat as empty" case the daemon-wide + // handler has always applied -- it is dropped deliberately, not missed. + if res.Found { + if components, err := Components(res.File); err == nil { + page.Components = components + } + } + return page, nil +} + +// TaskLogContent writes one task attempt's log to w exactly as it is on disk, +// for a caller that wants the file rather than a decoded page. found is false, +// with a nil error, when the attempt has no log file -- a normal state for an +// attempt that produced no output, and not an error. A nil registry reports +// ErrTaskLogsUnavailable, matching TaskLog. +// +// The content is streamed rather than returned as one slice because a log file +// is unbounded input (it rotates at DefaultMaxSizeMB), and a caller moving it +// across a transport with a message-size limit needs it in pieces. +func (r *TaskRegistry) TaskLogContent(_ context.Context, taskID int64, attempt int, w io.Writer) (bool, error) { + if r == nil { + return false, ErrTaskLogsUnavailable + } + f, err := os.Open(TaskLogPath(r.baseDir, taskID, attempt)) + if err != nil { + if os.IsNotExist(err) { + return false, nil + } + return false, fmt.Errorf("logging: open task log: %w", err) + } + defer func() { _ = f.Close() }() + if _, err := io.CopyBuffer(w, f, make([]byte, taskLogChunkBytes)); err != nil { + return false, fmt.Errorf("logging: read task log: %w", err) + } + return true, nil } // PageResult is what a single forward-paged call returns. @@ -293,6 +378,19 @@ func Tail(path string, q Query) (Result, error) { limit = MaxTailLines } + // found is read before readLines so an absent file is reported as such + // rather than only as an empty entry list -- see Result.Found. It is a + // Stat rather than a second readWindow: readLines reads the whole scan + // window, and doing that twice per Tail call would double the cost of + // every log view for one boolean. + if strings.TrimSpace(path) != "" { + if _, err := os.Stat(path); err == nil { + res.Found = true + } else if !os.IsNotExist(err) { + return Result{}, fmt.Errorf("logging: stat %s: %w", path, err) + } + } + matches := make([]Entry, 0, limit) truncated, _, ok, err := readLines(path, q, 0, func(e Entry, _ int64) bool { if len(matches) == limit { diff --git a/internal/store/interface.go b/internal/store/interface.go index c4a77a86e..bed66d142 100644 --- a/internal/store/interface.go +++ b/internal/store/interface.go @@ -25,6 +25,7 @@ type ( TaskRetryer = storecontract.TaskRetryer TaskQueries = storecontract.TaskQueries TaskEvents = storecontract.TaskEvents + TaskLogStore = storecontract.TaskLogStore CaptureStore = storecontract.CaptureStore ConfigSnapshotStore = storecontract.ConfigSnapshotStore MappingStore = storecontract.MappingStore diff --git a/internal/webui/api_tasks_actions_test.go b/internal/webui/api_tasks_actions_test.go index 7f777e9ba..4ed5dfc94 100644 --- a/internal/webui/api_tasks_actions_test.go +++ b/internal/webui/api_tasks_actions_test.go @@ -56,7 +56,12 @@ type daemonActions struct { // cfg is the daemon's configuration, held by the stand-in daemon // rather than by the dashboard: retry caps are the task owner's // policy and the dashboard does not hold configuration. - cfg *config.Holder + cfg *config.Holder + // logs is the daemon's own task-log registry. Archiving removes a + // task's log files, and that is the daemon's cleanup over the state + // directory it owns -- the dashboard reads logs through a contract and + // has no directory to remove anything from. + logs *logging.TaskRegistry issues *recordingCloser stopper *recordingTaskStopper // scopes records the identity each action arrived with, one per call. @@ -97,10 +102,10 @@ func (d *daemonActions) closeIssue() func(context.Context, string, string, int, } func (d *daemonActions) removeLogs() func(int64) error { - if d.srv.TaskLogs == nil { + if d.logs == nil { return nil } - return d.srv.TaskLogs.Remove + return d.logs.Remove } func (d *daemonActions) publish() func(events.Event) { @@ -701,11 +706,17 @@ func TestArchiveRemovesOnlyOneTerminalTask(t *testing.T) { // logging: without this, an archived task's log files (and every rotated // generation under it) would accumulate on disk forever, since nothing else // in the system ever visits a task again once it leaves the active board. +// +// The removal is the task owner's, not the dashboard's: the log files live in +// the state directory, which the daemon owns, so the stand-in daemon holds the +// registry the way the real one does. The dashboard reads logs through a +// contract and has no directory to remove anything from. func TestArchiveRemovesTheTaskLogDirectory(t *testing.T) { srv := newTestServer(t) ctx := t.Context() baseDir := t.TempDir() - srv.TaskLogs = logging.NewTaskRegistry(baseDir, logging.NewFeed(10), logging.TaskSinkOptions{}) + logs := logging.NewTaskRegistry(baseDir, logging.NewFeed(10), logging.TaskSinkOptions{}) + operatorActions(t, srv).logs = logs if _, err := srv.Store.EnqueueIssue(ctx, "acme", "widget", 1, "done", "", "", ""); err != nil { t.Fatal(err) @@ -715,11 +726,11 @@ func TestArchiveRemovesTheTaskLogDirectory(t *testing.T) { t.Fatal(err) } - if err := srv.TaskLogs.Open(task.ID, task.Attempt); err != nil { + if err := logs.Open(task.ID, task.Attempt); err != nil { t.Fatal(err) } - srv.TaskLogs.Write(task.ID, logging.Entry{Message: "line"}) - if err := srv.TaskLogs.Close(task.ID); err != nil { + logs.Write(task.ID, logging.Entry{Message: "line"}) + if err := logs.Close(task.ID); err != nil { t.Fatal(err) } dir := logging.TaskLogDir(baseDir, task.ID) diff --git a/internal/webui/api_tasks_log_download_test.go b/internal/webui/api_tasks_log_download_test.go new file mode 100644 index 000000000..40d23a9ad --- /dev/null +++ b/internal/webui/api_tasks_log_download_test.go @@ -0,0 +1,147 @@ +package webui + +import ( + "encoding/json" + "io" + "net/http" + "net/http/httptest" + "strconv" + "strings" + "testing" + + "github.com/samcharles93/archie-core/internal/logging" +) + +// TestHandleTaskLogsDistinguishesNoLogForTheAttempt covers the dashboard's +// misleading report. A process that HAS a task-log reader and an attempt that +// genuinely has no file on disk is a different answer from a process that +// cannot read logs at all, and only the second one is "logging is not enabled +// here". The response has to carry that difference or the page cannot state it. +func TestHandleTaskLogsDistinguishesNoLogForTheAttempt(t *testing.T) { + srv := newTestServer(t) + ctx := t.Context() + srv.TaskLogs = logging.NewTaskRegistry(t.TempDir(), logging.NewFeed(10), logging.TaskSinkOptions{}) + + if _, err := srv.Store.EnqueueIssue(ctx, "acme", "widget", 1, "task", "", "", ""); err != nil { + t.Fatal(err) + } + task, err := srv.Store.TaskByIssue(ctx, "acme", "widget", 1) + if err != nil { + t.Fatal(err) + } + // No log is ever opened for this task: the reader works, the attempt has + // no file. + + w := getTaskLogs(t, srv, task.ID, nil) + if w.Code != http.StatusOK { + t.Fatalf("status = %d, body %s", w.Code, w.Body) + } + var body struct { + Disabled bool `json:"disabled"` + Found bool `json:"found"` + } + if err := json.Unmarshal(w.Body.Bytes(), &body); err != nil { + t.Fatalf("decode response: %v (%s)", err, w.Body) + } + if body.Disabled { + t.Error("disabled = true for a process that has a task-log reader; that is the report the page turns into \"logging was not enabled for this run\"") + } + if body.Found { + t.Error("found = true for an attempt with no log file on disk") + } + if !strings.Contains(w.Body.String(), `"found"`) { + t.Errorf("body = %s, want an explicit found marker so the page can say the attempt has no log rather than that logging is off", w.Body) + } +} + +// TestHandleTaskLogsDownloadServesTheAttemptLog pins the deliverable: the +// endpoint hands back the attempt's log as a file download. The route falling +// through to the SPA asset handler would answer 200 with an HTML page, so this +// asserts on the attachment headers and the body, not merely on the status. +func TestHandleTaskLogsDownloadServesTheAttemptLog(t *testing.T) { + srv := newTestServer(t) + ctx := t.Context() + logs := logging.NewTaskRegistry(t.TempDir(), logging.NewFeed(10), logging.TaskSinkOptions{}) + srv.TaskLogs = logs + + if _, err := srv.Store.EnqueueIssue(ctx, "acme", "widget", 1, "task", "", "", ""); err != nil { + t.Fatal(err) + } + task, err := srv.Store.TaskByIssue(ctx, "acme", "widget", 1) + if err != nil { + t.Fatal(err) + } + if err := logs.Open(task.ID, task.Attempt); err != nil { + t.Fatal(err) + } + logs.Write(task.ID, logging.Entry{Level: "ERROR", Message: "gate failed"}) + if err := logs.Close(task.ID); err != nil { + t.Fatal(err) + } + + url := "/api/tasks/" + strconv.FormatInt(task.ID, 10) + "/logs/download" + req := httptest.NewRequestWithContext(ctx, http.MethodGet, url, nil) + w := httptest.NewRecorder() + srv.Handler().ServeHTTP(w, req) + + if w.Code != http.StatusOK { + t.Fatalf("GET %s = %d, body %s", url, w.Code, w.Body) + } + wantName := "task-" + strconv.FormatInt(task.ID, 10) + "-attempt-" + strconv.Itoa(task.Attempt) + ".log" + if got := w.Header().Get("Content-Disposition"); got != `attachment; filename="`+wantName+`"` { + t.Errorf("Content-Disposition = %q, want an attachment named %q", got, wantName) + } + if !strings.Contains(w.Body.String(), "gate failed") { + t.Errorf("download body = %s, want the attempt's own log content", w.Body) + } +} + +// TestHandleTaskLogsDownloadWithoutALogAnswersNotFound keeps the download +// honest: there is nothing to attach, so it says so rather than handing back a +// zero-byte file that looks like a successful download of nothing. +func TestHandleTaskLogsDownloadWithoutALogAnswersNotFound(t *testing.T) { + srv := newTestServer(t) + ctx := t.Context() + srv.TaskLogs = logging.NewTaskRegistry(t.TempDir(), logging.NewFeed(10), logging.TaskSinkOptions{}) + + if _, err := srv.Store.EnqueueIssue(ctx, "acme", "widget", 1, "task", "", "", ""); err != nil { + t.Fatal(err) + } + task, err := srv.Store.TaskByIssue(ctx, "acme", "widget", 1) + if err != nil { + t.Fatal(err) + } + + url := "/api/tasks/" + strconv.FormatInt(task.ID, 10) + "/logs/download" + req := httptest.NewRequestWithContext(ctx, http.MethodGet, url, nil) + w := httptest.NewRecorder() + srv.Handler().ServeHTTP(w, req) + if w.Code != http.StatusNotFound { + t.Fatalf("GET %s with no log = %d, want 404", url, w.Code) + } +} + +// TestHandleTaskLogsDownloadWithoutAReaderAnswersServiceUnavailable is the +// degradation the boundary permits: a process with no task-log contract answers +// 503 rather than 404, because "I cannot read logs" and "there is no log" are +// not the same claim. +func TestHandleTaskLogsDownloadWithoutAReaderAnswersServiceUnavailable(t *testing.T) { + srv := newTestServer(t) + ctx := t.Context() + if _, err := srv.Store.EnqueueIssue(ctx, "acme", "widget", 1, "task", "", "", ""); err != nil { + t.Fatal(err) + } + task, err := srv.Store.TaskByIssue(ctx, "acme", "widget", 1) + if err != nil { + t.Fatal(err) + } + + url := "/api/tasks/" + strconv.FormatInt(task.ID, 10) + "/logs/download" + req := httptest.NewRequestWithContext(ctx, http.MethodGet, url, nil) + w := httptest.NewRecorder() + srv.Handler().ServeHTTP(w, req) + if w.Code != http.StatusServiceUnavailable { + body, _ := io.ReadAll(w.Result().Body) + t.Fatalf("GET %s without a reader = %d (%s), want 503", url, w.Code, body) + } +} diff --git a/internal/webui/api_tasks_logs.go b/internal/webui/api_tasks_logs.go index 1966a5b17..18e045953 100644 --- a/internal/webui/api_tasks_logs.go +++ b/internal/webui/api_tasks_logs.go @@ -1,6 +1,9 @@ package webui import ( + "context" + "errors" + "io" "net/http" "strconv" "strings" @@ -16,84 +19,201 @@ import ( // Attempt from the store, since that is what a human or Archie's own chat // tool means by "why did task N park?" almost every time: the most recent // run, not an arbitrary earlier retry. +// +// Two outcomes are kept apart on purpose, because only one of them is about +// the operator's configuration. A process with no task-log reader cannot say +// anything about an attempt, so it reports disabled and the page explains that +// this process cannot read logs. A process WITH a reader and an attempt with +// no log file reports found=false, which the page states as no log recorded +// for the attempt. Collapsing the second into the first is what made the +// dashboard claim "task logging is optional and was not enabled for this run" +// for every attempt of every task in a deployment where logging is +// unconditional. func (s *Server) handleTaskLogs(w http.ResponseWriter, r *http.Request) { - id, err := strconv.ParseInt(r.PathValue("id"), 10, 64) - if err != nil { - http.Error(w, "bad id", http.StatusBadRequest) + id, attempt, ok := s.taskLogTarget(w, r) + if !ok { return } - - task, err := s.Store.TaskByID(r.Context(), id) - if err != nil { - http.Error(w, err.Error(), http.StatusInternalServerError) - return - } - if task == nil { - http.Error(w, "task not found", http.StatusNotFound) + reader := s.taskLogReader() + if reader == nil { + writeDisabledTaskLogs(w, attempt) return } q := r.URL.Query() - attempt := task.Attempt - if raw := strings.TrimSpace(q.Get("attempt")); raw != "" { - attempt, err = strconv.Atoi(raw) - if err != nil { - http.Error(w, "bad attempt", http.StatusBadRequest) - return - } - } - - path := s.TaskLogs.Path(id, attempt) - if path == "" { - // Not an error: task logging is optional, same convention as - // handleLogs for the daemon-wide log. - writeJSON(w, map[string]any{ - "entries": []logging.Entry{}, - "file": "", - "disabled": true, - "attempt": attempt, - }) + limit, ok := taskLogLimit(w, q.Get("limit")) + if !ok { return } - - limit := logging.DefaultTailLines - if raw := strings.TrimSpace(q.Get("limit")); raw != "" { - parsed, err := strconv.Atoi(raw) - if err != nil { - http.Error(w, "bad limit", http.StatusBadRequest) - return - } - switch { - case parsed <= 0: - limit = logging.DefaultTailLines - case parsed > logging.MaxTailLines: - limit = logging.MaxTailLines - default: - limit = parsed - } - } - result, err := logging.Tail(path, logging.Query{ + page, err := reader.TaskLog(r.Context(), id, attempt, logging.Query{ Levels: splitCSV(q.Get("level")), Component: strings.TrimSpace(q.Get("component")), Contains: strings.TrimSpace(q.Get("q")), Limit: limit, }) if err != nil { + // A reader that exists but cannot read here is still a statement about + // this process rather than about the attempt, so it keeps the disabled + // answer instead of claiming the attempt has no log. + if errors.Is(err, logging.ErrTaskLogsUnavailable) { + writeDisabledTaskLogs(w, attempt) + return + } http.Error(w, err.Error(), http.StatusInternalServerError) return } - components, err := logging.Components(path) - if err != nil { - s.Log.Warn("task log components unavailable", "task_id", id, "err", err) - components = []string{} - } - writeJSON(w, map[string]any{ - "entries": result.Entries, - "truncated": result.Truncated, - "file": result.File, - "components": components, + "entries": page.Entries, + "truncated": page.Truncated, + "file": page.File, + "components": page.Components, "attempt": attempt, + // found is the distinction the page needs: a reader answering with no + // entries because the file is absent is not a reader that is absent. + "found": page.Found, }) } + +// handleTaskLogDownload serves one task attempt's log verbatim as a file +// download -- the log itself rather than a decoded view of it, because an +// operator who asks for a download wants to read it in their own tooling or +// hand it to someone else. +// +// The conditions stay apart here too. A process with no reader answers 503, +// not 404: "there is no log for this attempt" is a claim only a process that +// can look is in a position to make. +func (s *Server) handleTaskLogDownload(w http.ResponseWriter, r *http.Request) { + id, attempt, ok := s.taskLogTarget(w, r) + if !ok { + return + } + reader := s.taskLogReader() + if reader == nil { + http.Error(w, logging.ErrTaskLogsUnavailable.Error(), http.StatusServiceUnavailable) + return + } + + // Headers are set before the read because the body streams straight from + // the reader into the response: a log file is unbounded input, so + // buffering it to size the response would defeat the reason the reader + // streams at all. The attempt's own name is known up front. + w.Header().Set("Content-Type", "application/x-ndjson") + w.Header().Set("Content-Disposition", `attachment; filename="`+taskLogFilename(id, attempt)+`"`) + + found, err := reader.TaskLogContent(r.Context(), id, attempt, w) + if err != nil { + if errors.Is(err, logging.ErrTaskLogsUnavailable) { + http.Error(w, err.Error(), http.StatusServiceUnavailable) + return + } + // Once a 200 and a body are on the wire there is no status left to + // send, so a failure partway through is logged where an operator can + // find it rather than silently truncating the file. + s.logf("task log download failed", "task", id, "attempt", attempt, "err", err) + return + } + if !found { + http.Error(w, "no log recorded for this attempt", http.StatusNotFound) + } +} + +// taskLogTarget resolves the {id} path value and the task it names, returning +// the attempt to read: the "attempt" query parameter when the request names +// one, otherwise the task's current Attempt. It answers the request itself and +// reports false when either step fails. +func (s *Server) taskLogTarget(w http.ResponseWriter, r *http.Request) (id int64, attempt int, ok bool) { + id, err := strconv.ParseInt(r.PathValue("id"), 10, 64) + if err != nil { + http.Error(w, "bad id", http.StatusBadRequest) + return 0, 0, false + } + task, err := s.Store.TaskByID(r.Context(), id) + if err != nil { + http.Error(w, err.Error(), http.StatusInternalServerError) + return 0, 0, false + } + if task == nil { + http.Error(w, "task not found", http.StatusNotFound) + return 0, 0, false + } + + attempt = task.Attempt + if raw := strings.TrimSpace(r.URL.Query().Get("attempt")); raw != "" { + parsed, err := strconv.Atoi(raw) + if err != nil { + http.Error(w, "bad attempt", http.StatusBadRequest) + return 0, 0, false + } + attempt = parsed + } + return id, attempt, true +} + +// taskLogLimit bounds a page the way handleLogs bounds the daemon-wide read: +// the limit is caller-supplied and a log file is unbounded, so a request must +// not be able to pull an arbitrary amount of it into memory. +func taskLogLimit(w http.ResponseWriter, raw string) (int, bool) { + raw = strings.TrimSpace(raw) + if raw == "" { + return logging.DefaultTailLines, true + } + parsed, err := strconv.Atoi(raw) + if err != nil { + http.Error(w, "bad limit", http.StatusBadRequest) + return 0, false + } + switch { + case parsed <= 0: + return logging.DefaultTailLines, true + case parsed > logging.MaxTailLines: + return logging.MaxTailLines, true + default: + return parsed, true + } +} + +// writeDisabledTaskLogs is the "this process cannot read task logs" answer, +// the same convention handleLogs uses for the daemon-wide log: an optional +// capability that is absent here must not turn "why did this task park?" into +// a 500 for every task. +func writeDisabledTaskLogs(w http.ResponseWriter, attempt int) { + writeJSON(w, map[string]any{ + "entries": []logging.Entry{}, + "file": "", + "disabled": true, + "attempt": attempt, + }) +} + +// taskLogFilename names a downloaded attempt's log. It carries the task and +// the attempt because an operator downloading two attempts of the same task +// must not end up with one file overwriting the other, and the attempt is the +// one identifier the log's own path would have given them. +func taskLogFilename(taskID int64, attempt int) string { + return "task-" + strconv.FormatInt(taskID, 10) + "-attempt-" + strconv.Itoa(attempt) + ".log" +} + +// taskLogReader is the task-log read capability this process has, or nil when +// it has none. The seam is a narrow interface rather than a concrete registry +// so the same handlers serve both processes: the daemon holds a registry over +// its own state directory, the dashboard holds the State Store client. A +// consumer-owned seam is the difference between the dashboard degrading +// honestly and the dashboard opening another process's files. +func (s *Server) taskLogReader() TaskLogSource { + if s == nil { + return nil + } + return s.TaskLogs +} + +// TaskLogSource is the read seam the task-log handlers consume. It is the +// logging package's own reader contract, so a registry and a remote client +// satisfy it without either one restating the log format -- the package that +// owns the format also owns the shape of a read of it. +type TaskLogSource interface { + // TaskLog returns a page of one attempt's decoded log. + TaskLog(ctx context.Context, taskID int64, attempt int, q logging.Query) (logging.TaskLogPage, error) + // TaskLogContent writes one attempt's log verbatim to w, for a download. + TaskLogContent(ctx context.Context, taskID int64, attempt int, w io.Writer) (bool, error) +} diff --git a/internal/webui/api_tasks_logs_test.go b/internal/webui/api_tasks_logs_test.go index 6083e7942..8b67119d6 100644 --- a/internal/webui/api_tasks_logs_test.go +++ b/internal/webui/api_tasks_logs_test.go @@ -14,7 +14,8 @@ func TestHandleTaskLogsReturnsEntriesForLatestAttemptByDefault(t *testing.T) { srv := newTestServer(t) ctx := t.Context() baseDir := t.TempDir() - srv.TaskLogs = logging.NewTaskRegistry(baseDir, logging.NewFeed(10), logging.TaskSinkOptions{}) + logs := logging.NewTaskRegistry(baseDir, logging.NewFeed(10), logging.TaskSinkOptions{}) + srv.TaskLogs = logs if _, err := srv.Store.EnqueueIssue(ctx, "acme", "widget", 1, "task", "", "", ""); err != nil { t.Fatal(err) @@ -24,13 +25,13 @@ func TestHandleTaskLogsReturnsEntriesForLatestAttemptByDefault(t *testing.T) { t.Fatal(err) } - if err := srv.TaskLogs.Open(task.ID, task.Attempt); err != nil { + if err := logs.Open(task.ID, task.Attempt); err != nil { t.Fatal(err) } - srv.TaskLogs.Write(task.ID, logging.Entry{ + logs.Write(task.ID, logging.Entry{ Level: "ERROR", Message: "gate failed", Fields: map[string]any{"component": "gate"}, }) - if err := srv.TaskLogs.Close(task.ID); err != nil { + if err := logs.Close(task.ID); err != nil { t.Fatal(err) } @@ -58,7 +59,8 @@ func TestHandleTaskLogsHonoursExplicitAttempt(t *testing.T) { srv := newTestServer(t) ctx := t.Context() baseDir := t.TempDir() - srv.TaskLogs = logging.NewTaskRegistry(baseDir, logging.NewFeed(10), logging.TaskSinkOptions{}) + logs := logging.NewTaskRegistry(baseDir, logging.NewFeed(10), logging.TaskSinkOptions{}) + srv.TaskLogs = logs if _, err := srv.Store.EnqueueIssue(ctx, "acme", "widget", 1, "task", "", "", ""); err != nil { t.Fatal(err) diff --git a/internal/webui/server.go b/internal/webui/server.go index 01c90bf31..cd5cc2193 100644 --- a/internal/webui/server.go +++ b/internal/webui/server.go @@ -43,10 +43,16 @@ type Server struct { // LogFeed is the daemon diagnostic stream. It is separate from Events, // which contains persisted task lifecycle activity only. LogFeed *logging.Feed - // TaskLogs holds each task's persisted log output. Archiving a task - // removes its log files here too, via TaskLogs.Remove -- nil (task - // logging not configured) makes that a no-op. - TaskLogs *logging.TaskRegistry + // TaskLogs reads each task's persisted log output. Composition gives this + // process whichever implementation it can use: the daemon (whose state + // directory holds the files) its own *logging.TaskRegistry, and the + // dashboard process, which owns no such directory, the State Store client + // -- the read crosses a contract rather than opening a file + // (docs/prds/ui-service-boundary.md). Nil means this process has no + // task-log capability at all, which the handlers report as disabled rather + // than as "the attempt has no log": those are different claims and only one + // of them is about configuration. + TaskLogs TaskLogSource // UpdateConfig applies a set of dotted-path config updates through // the same validate-persist-publish path as reload (wired by the @@ -238,6 +244,7 @@ func (s *Server) registerTaskRoutes(mux *http.ServeMux) { mux.HandleFunc("POST /api/tasks/{id}/action", s.handleTaskAction) mux.HandleFunc("GET /api/tasks/{id}", s.handleTask) mux.HandleFunc("GET /api/tasks/{id}/logs", s.handleTaskLogs) + mux.HandleFunc("GET /api/tasks/{id}/logs/download", s.handleTaskLogDownload) } func (s *Server) registerMappingAndBindingRoutes(mux *http.ServeMux) {