Files
archie/internal/infrastructure/postgres/events.go
T
2026-10-13 15:27:36 +11:00

159 lines
5.7 KiB
Go

package postgres
import (
"context"
"encoding/json"
"fmt"
"math"
"time"
"github.com/samcharles93/archie-core/internal/domain/org"
"github.com/samcharles93/archie-core/internal/domain/storecontract"
"github.com/samcharles93/archie-core/internal/events"
"github.com/samcharles93/archie-core/internal/infrastructure/postgres/postgresdb"
)
// insertEventQ writes one event through q (a pool- or tx-scoped Queries value)
// and returns its row id. It reproduces the SQLite insertEvent's write-side
// semantics: a zero At becomes now-UTC, an unmarshallable Data becomes the
// marshal_error envelope, and Detail is clipped to 4000 bytes.
func insertEventQ(ctx context.Context, q *postgresdb.Queries, e events.Event) (int64, error) {
if e.At.IsZero() {
e.At = time.Now().UTC()
}
data, err := json.Marshal(e.Data)
if err != nil {
data = fmt.Appendf(nil, `{"marshal_error":%q}`, err.Error())
}
return q.InsertEvent(ctx, postgresdb.InsertEventParams{
At: e.At.UTC(), Kind: e.Kind, TaskID: e.TaskID, Repo: e.Repo,
Issue: int64(e.Issue), Workflow: e.Workflow, Stage: e.Stage,
Attempt: int64(e.Attempt), ActorID: e.ActorID, ActorKind: e.ActorKind,
PrincipalID: e.PrincipalID, Detail: clip(e.Detail, 4000), Data: string(data),
OrgID: string(org.OrgFromContext(ctx)),
})
}
// InsertEvent appends an event to the log and returns its row id.
func (s *Store) InsertEvent(ctx context.Context, e events.Event) (int64, error) {
return insertEventQ(ctx, s.queries(), e)
}
// eventFromRow maps the generated event row to the domain event, decoding the
// stored JSON data document back into a map.
func eventFromRow(e postgresdb.Event) events.Event {
var data map[string]any
_ = json.Unmarshal([]byte(e.Data), &data)
return events.Event{
ID: e.ID, At: e.At.UTC(), Kind: e.Kind, TaskID: e.TaskID,
Repo: e.Repo, Issue: int(e.Issue), Workflow: e.Workflow, Stage: e.Stage,
Attempt: int(e.Attempt), ActorID: e.ActorID, ActorKind: e.ActorKind,
PrincipalID: e.PrincipalID, Detail: e.Detail, Data: data,
}
}
// EventsSince returns up to limit events after the opaque cursor, oldest
// first. The cursor carries the total order (at, id): an empty or malformed
// cursor means "from the beginning".
func (s *Store) EventsSince(ctx context.Context, cursor string, limit int) ([]events.Event, error) {
at, id, ok := storecontract.ParseEventCursor(cursor)
if !ok {
return s.listEventsFromBeginning(ctx, limit)
}
atTime, err := time.Parse(storecontract.EventCursorLayout, at)
if err != nil {
// A malformed sort key means "from the beginning".
return s.listEventsFromBeginning(ctx, limit)
}
rows, err := s.queries().ListEventsAfter(ctx, postgresdb.ListEventsAfterParams{
At: atTime, ID: id, PageLimit: clampInt32(limit), ScopeOrg: scopeOrg(ctx),
})
if err != nil {
return nil, err
}
return eventsFromRows(rows), nil
}
func (s *Store) listEventsFromBeginning(ctx context.Context, limit int) ([]events.Event, error) {
rows, err := s.queries().ListEventsFromBeginning(ctx, postgresdb.ListEventsFromBeginningParams{PageLimit: clampInt32(limit), ScopeOrg: scopeOrg(ctx)})
if err != nil {
return nil, err
}
return eventsFromRows(rows), nil
}
func eventsFromRows(rows []postgresdb.Event) []events.Event {
out := make([]events.Event, 0, len(rows))
for _, r := range rows {
out = append(out, eventFromRow(r))
}
return out
}
// TaskEvents returns a task's full timeline, oldest first.
func (s *Store) TaskEvents(ctx context.Context, taskID int64) ([]events.Event, error) {
rows, err := s.queries().TaskEventsByID(ctx, postgresdb.TaskEventsByIDParams{TaskID: taskID, ScopeOrg: scopeOrg(ctx)})
if err != nil {
return nil, err
}
return eventsFromRows(rows), nil
}
// WorkflowStats aggregates outcomes and spend per workflow.
func (s *Store) WorkflowStats(ctx context.Context) ([]storecontract.WorkflowStat, error) {
rows, err := s.queries().WorkflowStats(ctx, scopeOrg(ctx))
if err != nil {
return nil, err
}
stats := make([]storecontract.WorkflowStat, 0, len(rows))
for _, r := range rows {
stats = append(stats, storecontract.WorkflowStat{
Workflow: r.Workflow,
Runs: int(r.Runs),
Merged: int(r.Merged),
Completed: int(r.Completed),
PROpen: int(r.PrOpen),
Parked: int(r.Parked),
AvgTokens: int(r.AvgTokens),
AvgSteps: r.AvgSteps,
TotalToken: int(r.TotalTokens),
})
}
return stats, nil
}
// StageStats aggregates stage_finish events -- where time goes, and which
// stages fail.
func (s *Store) StageStats(ctx context.Context) ([]storecontract.StageStat, error) {
rows, err := s.queries().StageStats(ctx, scopeOrg(ctx))
if err != nil {
return nil, err
}
stats := make([]storecontract.StageStat, 0, len(rows))
for _, r := range rows {
stats = append(stats, storecontract.StageStat{
Workflow: r.Workflow, Stage: r.Stage, Runs: int(r.Runs),
AvgMs: int(r.AvgMs), Errors: int(r.Errors),
})
}
return stats, nil
}
// TokensByDay sums task token spend per UTC day, using agent_finish events as
// the per-run accounting source and tasks.tokens_used as the durable fallback.
func (s *Store) TokensByDay(ctx context.Context, days int) ([]storecontract.DayTokens, error) {
rows, err := s.queries().TokensByDay(ctx, postgresdb.TokensByDayParams{Days: clampInt32(days), ScopeOrg: scopeOrg(ctx)})
if err != nil {
return nil, err
}
tokens := make([]storecontract.DayTokens, 0, len(rows))
for _, r := range rows {
tokens = append(tokens, storecontract.DayTokens{Day: r.Day, Tokens: int(r.Tokens)})
}
return tokens, nil
}
// clampInt32 bounds a caller-supplied count to what a sqlc int32 parameter holds,
// so an oversized limit returns the deepest page instead of wrapping negative.
func clampInt32(n int) int32 { return int32(min(n, math.MaxInt32)) } //nolint:gosec // bounded above