244 lines
7.0 KiB
Go
244 lines
7.0 KiB
Go
package store
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"time"
|
|
|
|
"github.com/samcharles93/archie-core/internal/events"
|
|
)
|
|
|
|
const eventsSchema = `
|
|
CREATE TABLE IF NOT EXISTS events (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
at TEXT NOT NULL,
|
|
kind TEXT NOT NULL,
|
|
task_id INTEGER NOT NULL DEFAULT 0,
|
|
repo TEXT NOT NULL DEFAULT '',
|
|
issue INTEGER NOT NULL DEFAULT 0,
|
|
workflow TEXT NOT NULL DEFAULT '',
|
|
stage TEXT NOT NULL DEFAULT '',
|
|
detail TEXT NOT NULL DEFAULT '',
|
|
data TEXT NOT NULL DEFAULT '{}'
|
|
);
|
|
CREATE INDEX IF NOT EXISTS idx_events_task ON events(task_id, id);
|
|
CREATE INDEX IF NOT EXISTS idx_events_kind ON events(kind, id);
|
|
`
|
|
|
|
// InsertEvent appends an event to the log and returns its row id.
|
|
func (s *Store) InsertEvent(ctx context.Context, e events.Event) (int64, error) {
|
|
data, err := json.Marshal(e.Data)
|
|
if err != nil {
|
|
data = fmt.Appendf(nil, `{"marshal_error":%q}`, err.Error())
|
|
}
|
|
res, err := s.db.ExecContext(ctx, `
|
|
INSERT INTO events (at, kind, task_id, repo, issue, workflow, stage, detail, data)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
|
|
e.At.UTC().Format(time.RFC3339Nano), e.Kind, e.TaskID, e.Repo, e.Issue,
|
|
e.Workflow, e.Stage, clip(e.Detail, 4000), string(data))
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return res.LastInsertId()
|
|
}
|
|
|
|
func scanEvents(rows *sql.Rows) (out []events.Event, retErr error) {
|
|
defer func() {
|
|
retErr = errors.Join(retErr, rows.Close())
|
|
}()
|
|
for rows.Next() {
|
|
var e events.Event
|
|
var at, data string
|
|
if err := rows.Scan(&e.ID, &at, &e.Kind, &e.TaskID, &e.Repo, &e.Issue,
|
|
&e.Workflow, &e.Stage, &e.Detail, &data); err != nil {
|
|
return nil, err
|
|
}
|
|
e.At, _ = time.Parse(time.RFC3339Nano, at)
|
|
_ = json.Unmarshal([]byte(data), &e.Data)
|
|
out = append(out, e)
|
|
}
|
|
return out, rows.Err()
|
|
}
|
|
|
|
const eventCols = "id, at, kind, task_id, repo, issue, workflow, stage, detail, data"
|
|
|
|
// EventsSince returns up to limit events with id > sinceID, oldest
|
|
// first — SSE catch-up and the live feed.
|
|
func (s *Store) EventsSince(ctx context.Context, sinceID int64, limit int) ([]events.Event, error) {
|
|
rows, err := s.db.QueryContext(ctx,
|
|
`SELECT `+eventCols+` FROM events WHERE id > ? ORDER BY id LIMIT ?`, sinceID, limit)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return scanEvents(rows)
|
|
}
|
|
|
|
// RecentEvents returns the newest limit events, newest first.
|
|
func (s *Store) RecentEvents(ctx context.Context, limit int) ([]events.Event, error) {
|
|
rows, err := s.db.QueryContext(ctx,
|
|
`SELECT `+eventCols+` FROM events ORDER BY id DESC LIMIT ?`, limit)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return scanEvents(rows)
|
|
}
|
|
|
|
// TaskEvents returns a task's full timeline, oldest first.
|
|
func (s *Store) TaskEvents(ctx context.Context, taskID int64) ([]events.Event, error) {
|
|
rows, err := s.db.QueryContext(ctx,
|
|
`SELECT `+eventCols+` FROM events WHERE task_id = ? ORDER BY id`, taskID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return scanEvents(rows)
|
|
}
|
|
|
|
// Tasks returns all tasks, newest first (dashboard listing).
|
|
func (s *Store) Tasks(ctx context.Context, limit int) (tasks []Task, retErr error) {
|
|
rows, err := s.db.QueryContext(ctx, `
|
|
SELECT id, owner, repo, issue_number, title, status, workflow, stage,
|
|
pr_number, tokens_used, iterations, attempt, park_reason, retry_count
|
|
FROM tasks ORDER BY updated_at DESC LIMIT ?`, limit)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer func() {
|
|
retErr = errors.Join(retErr, rows.Close())
|
|
}()
|
|
for rows.Next() {
|
|
var t Task
|
|
if err := rows.Scan(&t.ID, &t.Owner, &t.Repo, &t.IssueNumber, &t.Title,
|
|
&t.Status, &t.Workflow, &t.Stage, &t.PRNumber, &t.TokensUsed,
|
|
&t.Iterations, &t.Attempt, &t.ParkReason, &t.RetryCount); err != nil {
|
|
return nil, err
|
|
}
|
|
tasks = append(tasks, t)
|
|
}
|
|
return tasks, rows.Err()
|
|
}
|
|
|
|
// StatusCounts returns task counts by status.
|
|
func (s *Store) StatusCounts(ctx context.Context) (counts map[string]int, retErr error) {
|
|
rows, err := s.db.QueryContext(ctx, `SELECT status, COUNT(*) FROM tasks GROUP BY status`)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer func() {
|
|
retErr = errors.Join(retErr, rows.Close())
|
|
}()
|
|
counts = map[string]int{}
|
|
for rows.Next() {
|
|
var st string
|
|
var n int
|
|
if err := rows.Scan(&st, &n); err != nil {
|
|
return nil, err
|
|
}
|
|
counts[st] = n
|
|
}
|
|
return counts, rows.Err()
|
|
}
|
|
|
|
// WorkflowStat is one row of the per-workflow metrics table.
|
|
type WorkflowStat struct {
|
|
Workflow string
|
|
Runs int
|
|
Merged int
|
|
PROpen int
|
|
Parked int
|
|
AvgTokens int
|
|
AvgSteps float64
|
|
TotalToken int
|
|
}
|
|
|
|
// WorkflowStats aggregates outcomes and spend per workflow — the
|
|
// core "is archie getting better per dollar" table.
|
|
func (s *Store) WorkflowStats(ctx context.Context) (stats []WorkflowStat, retErr error) {
|
|
rows, err := s.db.QueryContext(ctx, `
|
|
SELECT workflow, COUNT(*),
|
|
SUM(status='merged'), SUM(status='pr_open'), SUM(status='parked'),
|
|
CAST(AVG(tokens_used) AS INTEGER), AVG(iterations), SUM(tokens_used)
|
|
FROM tasks WHERE workflow != '' GROUP BY workflow ORDER BY COUNT(*) DESC`)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer func() {
|
|
retErr = errors.Join(retErr, rows.Close())
|
|
}()
|
|
for rows.Next() {
|
|
var w WorkflowStat
|
|
if err := rows.Scan(&w.Workflow, &w.Runs, &w.Merged, &w.PROpen, &w.Parked,
|
|
&w.AvgTokens, &w.AvgSteps, &w.TotalToken); err != nil {
|
|
return nil, err
|
|
}
|
|
stats = append(stats, w)
|
|
}
|
|
return stats, rows.Err()
|
|
}
|
|
|
|
// StageStat is average stage duration and failure counts per stage.
|
|
type StageStat struct {
|
|
Workflow, Stage string
|
|
Runs int
|
|
AvgMs int
|
|
Errors int
|
|
}
|
|
|
|
// StageStats aggregates stage_finish events — where does time go, and
|
|
// which stages fail.
|
|
func (s *Store) StageStats(ctx context.Context) (stats []StageStat, retErr error) {
|
|
rows, err := s.db.QueryContext(ctx, `
|
|
SELECT workflow, stage, COUNT(*),
|
|
CAST(AVG(json_extract(data,'$.duration_ms')) AS INTEGER),
|
|
SUM(CASE WHEN json_extract(data,'$.error') IS NOT NULL THEN 1 ELSE 0 END)
|
|
FROM events WHERE kind = 'stage_finish'
|
|
GROUP BY workflow, stage ORDER BY workflow, stage`)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer func() {
|
|
retErr = errors.Join(retErr, rows.Close())
|
|
}()
|
|
for rows.Next() {
|
|
var st StageStat
|
|
var avg sql.NullInt64
|
|
if err := rows.Scan(&st.Workflow, &st.Stage, &st.Runs, &avg, &st.Errors); err != nil {
|
|
return nil, err
|
|
}
|
|
st.AvgMs = int(avg.Int64)
|
|
stats = append(stats, st)
|
|
}
|
|
return stats, rows.Err()
|
|
}
|
|
|
|
// DayTokens is token spend per UTC day.
|
|
type DayTokens struct {
|
|
Day string
|
|
Tokens int
|
|
}
|
|
|
|
// TokensByDay sums agent token spend per day from agent_finish events.
|
|
func (s *Store) TokensByDay(ctx context.Context, days int) (tokens []DayTokens, retErr error) {
|
|
rows, err := s.db.QueryContext(ctx, `
|
|
SELECT substr(at,1,10) AS day,
|
|
CAST(SUM(json_extract(data,'$.tokens')) AS INTEGER)
|
|
FROM events WHERE kind = 'agent_finish'
|
|
GROUP BY day ORDER BY day DESC LIMIT ?`, days)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer func() {
|
|
retErr = errors.Join(retErr, rows.Close())
|
|
}()
|
|
for rows.Next() {
|
|
var d DayTokens
|
|
if err := rows.Scan(&d.Day, &d.Tokens); err != nil {
|
|
return nil, err
|
|
}
|
|
tokens = append(tokens, d)
|
|
}
|
|
return tokens, rows.Err()
|
|
}
|