451 lines
11 KiB
Go
451 lines
11 KiB
Go
// Code generated by sqlc. DO NOT EDIT.
|
|
// versions:
|
|
// sqlc v1.31.1
|
|
// source: events.sql
|
|
|
|
package postgresdb
|
|
|
|
import (
|
|
"context"
|
|
"time"
|
|
|
|
"github.com/jackc/pgx/v5/pgtype"
|
|
)
|
|
|
|
const insertEvent = `-- name: InsertEvent :one
|
|
|
|
WITH append_lock AS (
|
|
SELECT pg_advisory_xact_lock(hashtextextended('archie.events.insert', 0))
|
|
)
|
|
INSERT INTO events (at, kind, task_id, repo, issue, workflow, stage, attempt, actor_id, actor_kind, principal_id, detail, data, org_id, workspace_id)
|
|
SELECT $1, $2, $3, $4, $5, $6, $7,
|
|
$8, $9, $10, $11, $12, $13,
|
|
COALESCE(t.org_id, $14::text), COALESCE(t.workspace_id, 'default')
|
|
FROM append_lock LEFT JOIN tasks t ON t.id = $3
|
|
RETURNING id
|
|
`
|
|
|
|
type InsertEventParams struct {
|
|
At time.Time
|
|
Kind string
|
|
TaskID int64
|
|
Repo string
|
|
Issue int64
|
|
Workflow string
|
|
Stage string
|
|
Attempt int64
|
|
ActorID string
|
|
ActorKind string
|
|
PrincipalID string
|
|
Detail string
|
|
Data string
|
|
OrgID string
|
|
}
|
|
|
|
// Event-log queries. The (at, id) cursor is a wire contract: at is the
|
|
// fixed-width sort key and id only breaks ties, so a reader pages by
|
|
// "after (at, id)" and never skips or repeats a row. See
|
|
// internal/domain/storecontract/cursor.go.
|
|
// InsertEvent takes the event-append lock before the row draws its id, and
|
|
// holds it until the enclosing transaction commits, so ids become visible in
|
|
// the order they were drawn. The lock is inside the statement so a standalone
|
|
// insert and one inside a longer transaction both take it.
|
|
func (q *Queries) InsertEvent(ctx context.Context, arg InsertEventParams) (int64, error) {
|
|
row := q.db.QueryRow(ctx, insertEvent,
|
|
arg.At,
|
|
arg.Kind,
|
|
arg.TaskID,
|
|
arg.Repo,
|
|
arg.Issue,
|
|
arg.Workflow,
|
|
arg.Stage,
|
|
arg.Attempt,
|
|
arg.ActorID,
|
|
arg.ActorKind,
|
|
arg.PrincipalID,
|
|
arg.Detail,
|
|
arg.Data,
|
|
arg.OrgID,
|
|
)
|
|
var id int64
|
|
err := row.Scan(&id)
|
|
return id, err
|
|
}
|
|
|
|
const listEventsAfter = `-- name: ListEventsAfter :many
|
|
SELECT id, at, kind, task_id, repo, issue, workflow, stage, attempt, actor_id, actor_kind, principal_id, detail, data, org_id, workspace_id
|
|
FROM events
|
|
WHERE (at > $1 OR (at = $1 AND id > $2)) AND ($3::text IS NULL OR org_id = $3)
|
|
ORDER BY at, id
|
|
LIMIT $4
|
|
`
|
|
|
|
type ListEventsAfterParams struct {
|
|
At time.Time
|
|
ID int64
|
|
ScopeOrg pgtype.Text
|
|
PageLimit int32
|
|
}
|
|
|
|
func (q *Queries) ListEventsAfter(ctx context.Context, arg ListEventsAfterParams) ([]Event, error) {
|
|
rows, err := q.db.Query(ctx, listEventsAfter,
|
|
arg.At,
|
|
arg.ID,
|
|
arg.ScopeOrg,
|
|
arg.PageLimit,
|
|
)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []Event
|
|
for rows.Next() {
|
|
var i Event
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.At,
|
|
&i.Kind,
|
|
&i.TaskID,
|
|
&i.Repo,
|
|
&i.Issue,
|
|
&i.Workflow,
|
|
&i.Stage,
|
|
&i.Attempt,
|
|
&i.ActorID,
|
|
&i.ActorKind,
|
|
&i.PrincipalID,
|
|
&i.Detail,
|
|
&i.Data,
|
|
&i.OrgID,
|
|
&i.WorkspaceID,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const listEventsFromBeginning = `-- name: ListEventsFromBeginning :many
|
|
SELECT id, at, kind, task_id, repo, issue, workflow, stage, attempt, actor_id, actor_kind, principal_id, detail, data, org_id, workspace_id
|
|
FROM events
|
|
WHERE ($1::text IS NULL OR org_id = $1)
|
|
ORDER BY at, id
|
|
LIMIT $2
|
|
`
|
|
|
|
type ListEventsFromBeginningParams struct {
|
|
ScopeOrg pgtype.Text
|
|
PageLimit int32
|
|
}
|
|
|
|
func (q *Queries) ListEventsFromBeginning(ctx context.Context, arg ListEventsFromBeginningParams) ([]Event, error) {
|
|
rows, err := q.db.Query(ctx, listEventsFromBeginning, arg.ScopeOrg, arg.PageLimit)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []Event
|
|
for rows.Next() {
|
|
var i Event
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.At,
|
|
&i.Kind,
|
|
&i.TaskID,
|
|
&i.Repo,
|
|
&i.Issue,
|
|
&i.Workflow,
|
|
&i.Stage,
|
|
&i.Attempt,
|
|
&i.ActorID,
|
|
&i.ActorKind,
|
|
&i.PrincipalID,
|
|
&i.Detail,
|
|
&i.Data,
|
|
&i.OrgID,
|
|
&i.WorkspaceID,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const stageStats = `-- name: StageStats :many
|
|
SELECT workflow, stage,
|
|
COUNT(*)::int AS runs,
|
|
COALESCE(CAST(AVG((data::jsonb ->> 'duration_ms')::numeric) AS bigint), 0)::bigint AS avg_ms,
|
|
COUNT(*) FILTER (WHERE (data::jsonb ->> 'error') IS NOT NULL)::int AS errors
|
|
FROM events
|
|
WHERE kind = 'stage_finish' AND ($1::text IS NULL OR org_id = $1)
|
|
AND task_id NOT IN (SELECT id FROM tasks WHERE source = 'test')
|
|
GROUP BY workflow, stage
|
|
ORDER BY workflow, stage
|
|
`
|
|
|
|
type StageStatsRow struct {
|
|
Workflow string
|
|
Stage string
|
|
Runs int32
|
|
AvgMs int64
|
|
Errors int32
|
|
}
|
|
|
|
func (q *Queries) StageStats(ctx context.Context, scopeOrg pgtype.Text) ([]StageStatsRow, error) {
|
|
rows, err := q.db.Query(ctx, stageStats, scopeOrg)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []StageStatsRow
|
|
for rows.Next() {
|
|
var i StageStatsRow
|
|
if err := rows.Scan(
|
|
&i.Workflow,
|
|
&i.Stage,
|
|
&i.Runs,
|
|
&i.AvgMs,
|
|
&i.Errors,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const taskEventsByID = `-- name: TaskEventsByID :many
|
|
SELECT id, at, kind, task_id, repo, issue, workflow, stage, attempt, actor_id, actor_kind, principal_id, detail, data, org_id, workspace_id
|
|
FROM events
|
|
WHERE task_id = $1 AND kind <> 'agent_transcript' AND ($2::text IS NULL OR org_id = $2)
|
|
ORDER BY id
|
|
`
|
|
|
|
type TaskEventsByIDParams struct {
|
|
TaskID int64
|
|
ScopeOrg pgtype.Text
|
|
}
|
|
|
|
func (q *Queries) TaskEventsByID(ctx context.Context, arg TaskEventsByIDParams) ([]Event, error) {
|
|
rows, err := q.db.Query(ctx, taskEventsByID, arg.TaskID, arg.ScopeOrg)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []Event
|
|
for rows.Next() {
|
|
var i Event
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.At,
|
|
&i.Kind,
|
|
&i.TaskID,
|
|
&i.Repo,
|
|
&i.Issue,
|
|
&i.Workflow,
|
|
&i.Stage,
|
|
&i.Attempt,
|
|
&i.ActorID,
|
|
&i.ActorKind,
|
|
&i.PrincipalID,
|
|
&i.Detail,
|
|
&i.Data,
|
|
&i.OrgID,
|
|
&i.WorkspaceID,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const taskTranscript = `-- name: TaskTranscript :many
|
|
SELECT id, at, kind, task_id, repo, issue, workflow, stage, attempt, actor_id, actor_kind, principal_id, detail, data, org_id, workspace_id
|
|
FROM events
|
|
WHERE task_id = $1 AND attempt = $2 AND kind = 'agent_transcript' AND ($3::text IS NULL OR org_id = $3)
|
|
ORDER BY id
|
|
`
|
|
|
|
type TaskTranscriptParams struct {
|
|
TaskID int64
|
|
Attempt int64
|
|
ScopeOrg pgtype.Text
|
|
}
|
|
|
|
func (q *Queries) TaskTranscript(ctx context.Context, arg TaskTranscriptParams) ([]Event, error) {
|
|
rows, err := q.db.Query(ctx, taskTranscript, arg.TaskID, arg.Attempt, arg.ScopeOrg)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []Event
|
|
for rows.Next() {
|
|
var i Event
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.At,
|
|
&i.Kind,
|
|
&i.TaskID,
|
|
&i.Repo,
|
|
&i.Issue,
|
|
&i.Workflow,
|
|
&i.Stage,
|
|
&i.Attempt,
|
|
&i.ActorID,
|
|
&i.ActorKind,
|
|
&i.PrincipalID,
|
|
&i.Detail,
|
|
&i.Data,
|
|
&i.OrgID,
|
|
&i.WorkspaceID,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const tokensByDay = `-- name: TokensByDay :many
|
|
WITH event_totals AS (
|
|
SELECT task_id, to_char(at AT TIME ZONE 'UTC', 'YYYY-MM-DD') AS day,
|
|
SUM(CASE WHEN jsonb_typeof(data::jsonb -> 'tokens') = 'number'
|
|
THEN (data::jsonb ->> 'tokens')::bigint ELSE 0 END) AS tokens,
|
|
SUM(CASE WHEN jsonb_typeof(data::jsonb -> 'tokens') = 'number' THEN 1 ELSE 0 END) AS valid_tokens
|
|
FROM events WHERE kind = 'agent_finish' AND ($2::text IS NULL OR org_id = $2)
|
|
GROUP BY task_id, day
|
|
), usage AS (
|
|
SELECT day, tokens FROM event_totals WHERE valid_tokens > 0
|
|
UNION ALL
|
|
SELECT to_char(t.updated_at AT TIME ZONE 'UTC', 'YYYY-MM-DD'), t.tokens_used
|
|
FROM tasks t
|
|
WHERE t.tokens_used != 0 AND ($2::text IS NULL OR t.org_id = $2) AND NOT EXISTS (
|
|
SELECT 1 FROM event_totals e
|
|
WHERE e.task_id = t.id AND e.valid_tokens > 0
|
|
)
|
|
)
|
|
SELECT day, SUM(tokens)::bigint AS tokens
|
|
FROM usage GROUP BY day ORDER BY day DESC LIMIT $1
|
|
`
|
|
|
|
type TokensByDayParams struct {
|
|
Days int32
|
|
ScopeOrg pgtype.Text
|
|
}
|
|
|
|
type TokensByDayRow struct {
|
|
Day string
|
|
Tokens int64
|
|
}
|
|
|
|
func (q *Queries) TokensByDay(ctx context.Context, arg TokensByDayParams) ([]TokensByDayRow, error) {
|
|
rows, err := q.db.Query(ctx, tokensByDay, arg.Days, arg.ScopeOrg)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []TokensByDayRow
|
|
for rows.Next() {
|
|
var i TokensByDayRow
|
|
if err := rows.Scan(&i.Day, &i.Tokens); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const workflowStats = `-- name: WorkflowStats :many
|
|
SELECT workflow,
|
|
COUNT(*)::int AS runs,
|
|
COUNT(*) FILTER (WHERE status = 'merged')::int AS merged,
|
|
COUNT(*) FILTER (WHERE status = 'completed')::int AS completed,
|
|
COUNT(*) FILTER (WHERE status = 'pr_open')::int AS pr_open,
|
|
COUNT(*) FILTER (WHERE status = 'parked')::int AS parked,
|
|
COUNT(*) FILTER (WHERE status = 'running')::int AS running,
|
|
COALESCE((ARRAY_AGG(status ORDER BY id DESC))[1], '')::text AS last_status,
|
|
MAX(id)::bigint AS last_run_id,
|
|
MAX(created_at)::timestamptz AS last_run_at,
|
|
CAST(AVG(tokens_used) AS bigint) AS avg_tokens,
|
|
AVG(iterations)::float8 AS avg_steps,
|
|
SUM(tokens_used)::bigint AS total_tokens
|
|
FROM tasks
|
|
WHERE workflow <> '' AND source <> 'test' AND ($1::text IS NULL OR org_id = $1)
|
|
GROUP BY workflow
|
|
ORDER BY COUNT(*) DESC
|
|
`
|
|
|
|
type WorkflowStatsRow struct {
|
|
Workflow string
|
|
Runs int32
|
|
Merged int32
|
|
Completed int32
|
|
PrOpen int32
|
|
Parked int32
|
|
Running int32
|
|
LastStatus string
|
|
LastRunID int64
|
|
LastRunAt time.Time
|
|
AvgTokens int64
|
|
AvgSteps float64
|
|
TotalTokens int64
|
|
}
|
|
|
|
// running and last_status answer what a workflow is doing now without paging
|
|
// the global task list, where a quiet workflow's runs are never in the newest
|
|
// page.
|
|
func (q *Queries) WorkflowStats(ctx context.Context, scopeOrg pgtype.Text) ([]WorkflowStatsRow, error) {
|
|
rows, err := q.db.Query(ctx, workflowStats, scopeOrg)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []WorkflowStatsRow
|
|
for rows.Next() {
|
|
var i WorkflowStatsRow
|
|
if err := rows.Scan(
|
|
&i.Workflow,
|
|
&i.Runs,
|
|
&i.Merged,
|
|
&i.Completed,
|
|
&i.PrOpen,
|
|
&i.Parked,
|
|
&i.Running,
|
|
&i.LastStatus,
|
|
&i.LastRunID,
|
|
&i.LastRunAt,
|
|
&i.AvgTokens,
|
|
&i.AvgSteps,
|
|
&i.TotalTokens,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|