perf(stats): split stats endpoint per-section and rewrite GetGlobalStats (#1289)

* perf(stats): split stats endpoint per-section and rewrite GetGlobalStats

Stats page used to wait on a single endpoint that ran 7 SQL queries in parallel
and rendered nothing until the slowest one returned. Cold first-paint was the
bottleneck users actually hit.

- Backend: split /api/v1/workspaces/:id/stats into 7 per-section endpoints
  (global, tasks, daily-activity, completed-activity, agent-usage,
  repositories, git). Each handler runs one repo call and returns its DTO.
- Backend: rewrote GetGlobalStats from 9 independent correlated subqueries
  into 4 CTEs (task / session / turn / message). Each underlying table is now
  scanned at most once per request instead of 1-3 times.
- Frontend: replaced the monolithic fetchStats + single PanelState with
  useStatsSections hook (7 parallel fetches, per-section SectionStatus).
  Each panel renders skeleton -> data -> error independently; light queries
  (overview, agent usage, git) paint immediately, heavy ones stream in.
- Tests: added TestGetGlobalStats_AggregatesAcrossTables to lock the
  CTE-based query against regressions for turns, user/tool messages, and
  total duration.

* fix(stats): address PR review feedback

- Restore cache: "no-store" on section fetches; Gin emits no Cache-Control
  headers so the browser could otherwise serve stale stats on revisit
  (Greptile P1, Cubic).
- Stop blanking the Overview panel when /git fails: render OverviewCards as
  soon as `global` is ready and treat `git` as optional, falling back to the
  Averages card. Updates GitOrAveragesCard / OverviewCards types (Claude).
- Fix TaskStatsHasMore off-by-one at exactly taskStatsLimit rows: probe
  taskStatsLimit+1, slice back to the page size, only flag hasMore on a
  confirmed extra row (Claude, Cubic).
- Rename anyError → firstError with a comment documenting the deterministic
  insertion-order iteration; clearer signal that callers should use it as
  "any section failed?" and surface per-section errors in their own panels
  (Claude).

---------

Co-authored-by: Kandev Agent <agent@kandev.dev>
This commit is contained in:
João Salavisa
2026-06-07 13:24:32 +01:00
committed by GitHub
parent 607201be79
commit 31d4ba67fa
7 changed files with 704 additions and 362 deletions
@@ -1,8 +1,6 @@
package handlers
import (
"context"
"fmt"
"net/http"
"time"
@@ -13,12 +11,12 @@ import (
"github.com/kandev/kandev/internal/analytics/repository"
"github.com/kandev/kandev/internal/common/logger"
"go.uber.org/zap"
"golang.org/x/sync/errgroup"
)
// allTimeActivityDays is the number of days shown in the daily activity heatmap for the "all" range.
const allTimeActivityDays = 365
const taskStatsLimit = 200
const agentUsageLimit = 5
type StatsHandlers struct {
repo repository.Repository
@@ -39,150 +37,154 @@ func RegisterStatsRoutes(router *gin.Engine, repo repository.Repository, log *lo
func (h *StatsHandlers) registerHTTP(router *gin.Engine) {
api := router.Group("/api/v1")
api.GET("/workspaces/:id/stats", h.httpGetStats)
api.GET("/workspaces/:id/stats/global", h.httpGetGlobalStats)
api.GET("/workspaces/:id/stats/tasks", h.httpGetTaskStats)
api.GET("/workspaces/:id/stats/daily-activity", h.httpGetDailyActivity)
api.GET("/workspaces/:id/stats/completed-activity", h.httpGetCompletedActivity)
api.GET("/workspaces/:id/stats/agent-usage", h.httpGetAgentUsage)
api.GET("/workspaces/:id/stats/repositories", h.httpGetRepositoryStats)
api.GET("/workspaces/:id/stats/git", h.httpGetGitStats)
}
// rawStats holds all raw stats fetched from the repository before DTO conversion.
type rawStats struct {
globalStats *models.GlobalStats
taskStats []*models.TaskStats
dailyActivity []*models.DailyActivity
completedActivity []*models.CompletedTaskActivity
agentUsage []*models.AgentUsage
repoStats []*models.RepositoryStats
gitStats *models.GitStats
// taskStatsResponse pairs the workload list with a paging flag.
type taskStatsResponse struct {
TaskStats []dto.TaskStatsDTO `json:"task_stats"`
TaskStatsHasMore bool `json:"task_stats_has_more"`
}
func (h *StatsHandlers) httpGetStats(c *gin.Context) {
func (h *StatsHandlers) httpGetGlobalStats(c *gin.Context) {
workspaceID, start, _, ok := h.parseRequest(c)
if !ok {
return
}
stats, err := h.repo.GetGlobalStats(c.Request.Context(), workspaceID, start)
if err != nil {
h.fail(c, workspaceID, "global stats", err)
return
}
c.JSON(http.StatusOK, dto.GlobalStatsDTO{
TotalTasks: stats.TotalTasks,
CompletedTasks: stats.CompletedTasks,
InProgressTasks: stats.InProgressTasks,
TotalSessions: stats.TotalSessions,
TotalTurns: stats.TotalTurns,
TotalMessages: stats.TotalMessages,
TotalUserMessages: stats.TotalUserMessages,
TotalToolCalls: stats.TotalToolCalls,
TotalDurationMs: stats.TotalDurationMs,
AvgTurnsPerTask: stats.AvgTurnsPerTask,
AvgMessagesPerTask: stats.AvgMessagesPerTask,
AvgDurationMsPerTask: stats.AvgDurationMsPerTask,
})
}
func (h *StatsHandlers) httpGetTaskStats(c *gin.Context) {
workspaceID, start, _, ok := h.parseRequest(c)
if !ok {
return
}
// Probe one row past the page size so we can distinguish "exactly N rows"
// from "N rows visible, more after" without a separate COUNT query.
stats, err := h.repo.GetTaskStats(c.Request.Context(), workspaceID, start, taskStatsLimit+1)
if err != nil {
h.fail(c, workspaceID, "task stats", err)
return
}
hasMore := len(stats) > taskStatsLimit
if hasMore {
stats = stats[:taskStatsLimit]
}
c.JSON(http.StatusOK, taskStatsResponse{
TaskStats: taskStatsToDTOs(stats),
TaskStatsHasMore: hasMore,
})
}
func (h *StatsHandlers) httpGetDailyActivity(c *gin.Context) {
workspaceID, _, days, ok := h.parseRequest(c)
if !ok {
return
}
activity, err := h.repo.GetDailyActivity(c.Request.Context(), workspaceID, days)
if err != nil {
h.fail(c, workspaceID, "daily activity", err)
return
}
c.JSON(http.StatusOK, dailyActivityToDTOs(activity))
}
func (h *StatsHandlers) httpGetCompletedActivity(c *gin.Context) {
workspaceID, _, days, ok := h.parseRequest(c)
if !ok {
return
}
activity, err := h.repo.GetCompletedTaskActivity(c.Request.Context(), workspaceID, days)
if err != nil {
h.fail(c, workspaceID, "completed activity", err)
return
}
c.JSON(http.StatusOK, completedActivityToDTOs(activity))
}
func (h *StatsHandlers) httpGetAgentUsage(c *gin.Context) {
workspaceID, start, _, ok := h.parseRequest(c)
if !ok {
return
}
usage, err := h.repo.GetAgentUsage(c.Request.Context(), workspaceID, agentUsageLimit, start)
if err != nil {
h.fail(c, workspaceID, "agent usage", err)
return
}
c.JSON(http.StatusOK, agentUsageToDTOs(usage))
}
func (h *StatsHandlers) httpGetRepositoryStats(c *gin.Context) {
workspaceID, start, _, ok := h.parseRequest(c)
if !ok {
return
}
stats, err := h.repo.GetRepositoryStats(c.Request.Context(), workspaceID, start)
if err != nil {
h.fail(c, workspaceID, "repository stats", err)
return
}
c.JSON(http.StatusOK, repositoryStatsToDTOs(stats))
}
func (h *StatsHandlers) httpGetGitStats(c *gin.Context) {
workspaceID, start, _, ok := h.parseRequest(c)
if !ok {
return
}
stats, err := h.repo.GetGitStats(c.Request.Context(), workspaceID, start)
if err != nil {
h.fail(c, workspaceID, "git stats", err)
return
}
c.JSON(http.StatusOK, dto.GitStatsDTO{
TotalCommits: stats.TotalCommits,
TotalFilesChanged: stats.TotalFilesChanged,
TotalInsertions: stats.TotalInsertions,
TotalDeletions: stats.TotalDeletions,
})
}
// parseRequest extracts the workspace ID and resolves the range query.
// Returns ok=false after writing a 400 response on a missing workspace id.
func (h *StatsHandlers) parseRequest(c *gin.Context) (string, *time.Time, int, bool) {
workspaceID := c.Param("id")
if workspaceID == "" {
c.JSON(http.StatusBadRequest, gin.H{"error": "workspace_id is required"})
return
return "", nil, 0, false
}
rangeKey := c.Query("range")
start, days := parseStatsRange(rangeKey)
raw, err := h.fetchStats(c.Request.Context(), workspaceID, start, days)
if err != nil {
h.logger.Error("failed to get stats", zap.String("workspace_id", workspaceID), zap.Error(err))
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to get stats"})
return
}
response := dto.StatsResponse{
Global: dto.GlobalStatsDTO{
TotalTasks: raw.globalStats.TotalTasks,
CompletedTasks: raw.globalStats.CompletedTasks,
InProgressTasks: raw.globalStats.InProgressTasks,
TotalSessions: raw.globalStats.TotalSessions,
TotalTurns: raw.globalStats.TotalTurns,
TotalMessages: raw.globalStats.TotalMessages,
TotalUserMessages: raw.globalStats.TotalUserMessages,
TotalToolCalls: raw.globalStats.TotalToolCalls,
TotalDurationMs: raw.globalStats.TotalDurationMs,
AvgTurnsPerTask: raw.globalStats.AvgTurnsPerTask,
AvgMessagesPerTask: raw.globalStats.AvgMessagesPerTask,
AvgDurationMsPerTask: raw.globalStats.AvgDurationMsPerTask,
},
TaskStats: taskStatsToDTOs(raw.taskStats),
TaskStatsHasMore: raw.globalStats.TotalTasks > len(raw.taskStats),
DailyActivity: dailyActivityToDTOs(raw.dailyActivity),
CompletedActivity: completedActivityToDTOs(raw.completedActivity),
AgentUsage: agentUsageToDTOs(raw.agentUsage),
RepositoryStats: repositoryStatsToDTOs(raw.repoStats),
GitStats: dto.GitStatsDTO{
TotalCommits: raw.gitStats.TotalCommits,
TotalFilesChanged: raw.gitStats.TotalFilesChanged,
TotalInsertions: raw.gitStats.TotalInsertions,
TotalDeletions: raw.gitStats.TotalDeletions,
},
}
c.JSON(http.StatusOK, response)
start, days := parseStatsRange(c.Query("range"))
return workspaceID, start, days, true
}
func (h *StatsHandlers) fetchStats(ctx context.Context, workspaceID string, start *time.Time, days int) (*rawStats, error) {
var (
globalStats *models.GlobalStats
taskStats []*models.TaskStats
dailyActivity []*models.DailyActivity
completedActivity []*models.CompletedTaskActivity
agentUsage []*models.AgentUsage
repoStats []*models.RepositoryStats
gitStats *models.GitStats
)
group, groupCtx := errgroup.WithContext(ctx)
group.Go(func() error {
result, err := h.repo.GetGlobalStats(groupCtx, workspaceID, start)
if err != nil {
return fmt.Errorf("global stats: %w", err)
}
globalStats = result
return nil
})
group.Go(func() error {
result, err := h.repo.GetTaskStats(groupCtx, workspaceID, start, taskStatsLimit)
if err != nil {
return fmt.Errorf("task stats: %w", err)
}
taskStats = result
return nil
})
group.Go(func() error {
result, err := h.repo.GetDailyActivity(groupCtx, workspaceID, days)
if err != nil {
return fmt.Errorf("daily activity: %w", err)
}
dailyActivity = result
return nil
})
group.Go(func() error {
result, err := h.repo.GetCompletedTaskActivity(groupCtx, workspaceID, days)
if err != nil {
return fmt.Errorf("completed activity: %w", err)
}
completedActivity = result
return nil
})
group.Go(func() error {
result, err := h.repo.GetAgentUsage(groupCtx, workspaceID, 5, start)
if err != nil {
return fmt.Errorf("agent usage: %w", err)
}
agentUsage = result
return nil
})
group.Go(func() error {
result, err := h.repo.GetRepositoryStats(groupCtx, workspaceID, start)
if err != nil {
return fmt.Errorf("repository stats: %w", err)
}
repoStats = result
return nil
})
group.Go(func() error {
result, err := h.repo.GetGitStats(groupCtx, workspaceID, start)
if err != nil {
return fmt.Errorf("git stats: %w", err)
}
gitStats = result
return nil
})
if err := group.Wait(); err != nil {
return nil, err
}
return &rawStats{
globalStats: globalStats,
taskStats: taskStats,
dailyActivity: dailyActivity,
completedActivity: completedActivity,
agentUsage: agentUsage,
repoStats: repoStats,
gitStats: gitStats,
}, nil
func (h *StatsHandlers) fail(c *gin.Context, workspaceID, section string, err error) {
h.logger.Error("failed to get "+section, zap.String("workspace_id", workspaceID), zap.Error(err))
c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to get " + section})
}
func taskStatsToDTOs(taskStats []*models.TaskStats) []dto.TaskStatsDTO {
@@ -227,6 +227,60 @@ func TestGetRepositoryStats_ExcludesSoftDeletedRepos(t *testing.T) {
}
}
// TestGetGlobalStats_AggregatesAcrossTables exercises the CTE-based query path
// for every aggregated field — total/user/tool messages, turn count, and the
// computed total duration — to guard against regressions when the query is
// further consolidated.
func TestGetGlobalStats_AggregatesAcrossTables(t *testing.T) {
dbConn := createTestDB(t)
repo, err := NewWithDB(dbConn, dbConn)
if err != nil {
t.Fatalf("NewWithDB failed: %v", err)
}
ctx := context.Background()
now := time.Now().UTC()
nowStr := now.Format(time.RFC3339)
execOrFatal(t, dbConn, `INSERT INTO workspaces (id, name, created_at, updated_at) VALUES ('ws-1', 'Test', ?, ?)`, nowStr, nowStr)
execOrFatal(t, dbConn, `INSERT INTO boards (id, workspace_id, name, created_at, updated_at) VALUES ('board-1', 'ws-1', 'Board', ?, ?)`, nowStr, nowStr)
execOrFatal(t, dbConn, `INSERT INTO tasks (id, workspace_id, board_id, workflow_step_id, title, is_ephemeral, created_at, updated_at) VALUES ('task-1', 'ws-1', 'board-1', '', 'T1', 0, ?, ?)`, nowStr, nowStr)
execOrFatal(t, dbConn, `INSERT INTO task_sessions (id, task_id, agent_profile_id, state, started_at, updated_at) VALUES ('sess-1', 'task-1', 'agent-1', 'COMPLETED', ?, ?)`, nowStr, nowStr)
// Two turns: 5m + 10m of active duration (= 900_000 ms).
execOrFatal(t, dbConn, `INSERT INTO task_session_turns (id, task_session_id, task_id, started_at, completed_at, created_at, updated_at) VALUES ('turn-1', 'sess-1', 'task-1', '2026-01-01T10:00:00Z', '2026-01-01T10:05:00Z', ?, ?)`, nowStr, nowStr)
execOrFatal(t, dbConn, `INSERT INTO task_session_turns (id, task_session_id, task_id, started_at, completed_at, created_at, updated_at) VALUES ('turn-2', 'sess-1', 'task-1', '2026-01-01T10:10:00Z', '2026-01-01T10:20:00Z', ?, ?)`, nowStr, nowStr)
// Messages: 2 user, 1 tool_call, 1 tool_edit, 1 agent text.
execOrFatal(t, dbConn, `INSERT INTO task_session_messages (id, task_session_id, turn_id, author_type, type, content, created_at) VALUES ('m-1', 'sess-1', 'turn-1', 'user', 'message', 'hi', ?)`, nowStr)
execOrFatal(t, dbConn, `INSERT INTO task_session_messages (id, task_session_id, turn_id, author_type, type, content, created_at) VALUES ('m-2', 'sess-1', 'turn-1', 'user', 'message', 'hello', ?)`, nowStr)
execOrFatal(t, dbConn, `INSERT INTO task_session_messages (id, task_session_id, turn_id, author_type, type, content, created_at) VALUES ('m-3', 'sess-1', 'turn-1', 'agent', 'tool_call', 'bash', ?)`, nowStr)
execOrFatal(t, dbConn, `INSERT INTO task_session_messages (id, task_session_id, turn_id, author_type, type, content, created_at) VALUES ('m-4', 'sess-1', 'turn-1', 'agent', 'tool_edit', 'edit', ?)`, nowStr)
execOrFatal(t, dbConn, `INSERT INTO task_session_messages (id, task_session_id, turn_id, author_type, type, content, created_at) VALUES ('m-5', 'sess-1', 'turn-1', 'agent', 'message', 'reply', ?)`, nowStr)
stats, err := repo.GetGlobalStats(ctx, "ws-1", nil)
if err != nil {
t.Fatalf("GetGlobalStats failed: %v", err)
}
if stats.TotalTasks != 1 {
t.Errorf("TotalTasks: want 1, got %d", stats.TotalTasks)
}
if stats.TotalSessions != 1 {
t.Errorf("TotalSessions: want 1, got %d", stats.TotalSessions)
}
if stats.TotalTurns != 2 {
t.Errorf("TotalTurns: want 2, got %d", stats.TotalTurns)
}
if stats.TotalMessages != 5 {
t.Errorf("TotalMessages: want 5, got %d", stats.TotalMessages)
}
if stats.TotalUserMessages != 2 {
t.Errorf("TotalUserMessages: want 2, got %d", stats.TotalUserMessages)
}
if stats.TotalToolCalls != 2 {
t.Errorf("TotalToolCalls: want 2 (tool_call + tool_edit), got %d", stats.TotalToolCalls)
}
assertDurationAlmostEqual(t, stats.TotalDurationMs, int64(15*60*1000), "TotalDurationMs")
}
func TestGetGlobalStats_EmptyWorkspace(t *testing.T) {
dbConn := createTestDB(t)
repo, err := NewWithDB(dbConn, dbConn)
@@ -142,7 +142,10 @@ func (r *Repository) scanTaskStats(rows *sql.Rows) ([]*models.TaskStats, error)
return results, rows.Err()
}
// GetGlobalStats retrieves workspace-wide aggregated statistics
// GetGlobalStats retrieves workspace-wide aggregated statistics.
// Implemented as a single query over 4 CTEs (tasks, sessions, turns, messages)
// rather than 9 independent correlated subqueries: each underlying table is
// scanned at most once per request.
func (r *Repository) GetGlobalStats(ctx context.Context, workspaceID string, start *time.Time) (*models.GlobalStats, error) {
var startArg any
if start != nil {
@@ -153,61 +156,74 @@ func (r *Repository) GetGlobalStats(ctx context.Context, workspaceID string, sta
dur := dialect.DurationMs(drv, "turn.completed_at", "turn.started_at")
query := fmt.Sprintf(`
WITH
task_agg AS (
SELECT
COUNT(*) AS total_tasks,
SUM(CASE WHEN t.archived_at IS NOT NULL
OR ws.position = (SELECT MAX(ws2.position) FROM workflow_steps ws2 WHERE ws2.workflow_id = ws.workflow_id)
THEN 1 ELSE 0 END) AS completed_tasks,
SUM(CASE WHEN t.state = 'IN_PROGRESS' AND t.archived_at IS NULL THEN 1 ELSE 0 END) AS in_progress_tasks
FROM tasks t
LEFT JOIN workflow_steps ws ON ws.id = t.workflow_step_id
WHERE t.workspace_id = ? AND t.is_ephemeral = 0 AND (? IS NULL OR t.created_at >= ?)
),
session_agg AS (
SELECT COUNT(*) AS total_sessions
FROM task_sessions s
JOIN tasks t ON t.id = s.task_id
WHERE t.workspace_id = ? AND t.is_ephemeral = 0 AND (? IS NULL OR s.started_at >= ?)
),
turn_agg AS (
SELECT
COUNT(*) AS total_turns,
COALESCE(SUM(CASE WHEN turn.completed_at IS NOT NULL THEN %s ELSE 0 END), 0) AS total_duration_ms
FROM task_session_turns turn
JOIN task_sessions s ON s.id = turn.task_session_id
JOIN tasks t ON t.id = s.task_id
WHERE t.workspace_id = ? AND t.is_ephemeral = 0 AND (? IS NULL OR s.started_at >= ?)
),
message_agg AS (
SELECT
COUNT(*) AS total_messages,
SUM(CASE WHEN msg.author_type = 'user' THEN 1 ELSE 0 END) AS total_user_messages,
SUM(CASE WHEN msg.type LIKE 'tool_%%' THEN 1 ELSE 0 END) AS total_tool_calls
FROM task_session_messages msg
JOIN task_sessions s ON s.id = msg.task_session_id
JOIN tasks t ON t.id = s.task_id
WHERE t.workspace_id = ? AND t.is_ephemeral = 0 AND (? IS NULL OR s.started_at >= ?)
)
SELECT
(SELECT COUNT(*) FROM tasks WHERE workspace_id = ? AND is_ephemeral = 0 AND (? IS NULL OR created_at >= ?)) as total_tasks,
(SELECT COUNT(*) FROM tasks t
LEFT JOIN workflow_steps ws ON ws.id = t.workflow_step_id
WHERE t.workspace_id = ?
AND t.is_ephemeral = 0
AND (t.archived_at IS NOT NULL
OR ws.position = (SELECT MAX(ws2.position) FROM workflow_steps ws2 WHERE ws2.workflow_id = ws.workflow_id))
AND (? IS NULL OR t.created_at >= ?)) as completed_tasks,
(SELECT COUNT(*) FROM tasks WHERE workspace_id = ? AND is_ephemeral = 0 AND state = 'IN_PROGRESS' AND archived_at IS NULL AND (? IS NULL OR created_at >= ?)) as in_progress_tasks,
(SELECT COUNT(*) FROM task_sessions s JOIN tasks t ON t.id = s.task_id WHERE t.workspace_id = ? AND t.is_ephemeral = 0 AND (? IS NULL OR s.started_at >= ?)) as total_sessions,
(SELECT COUNT(*) FROM task_session_turns turn
JOIN task_sessions s ON s.id = turn.task_session_id
JOIN tasks t ON t.id = s.task_id
WHERE t.workspace_id = ? AND t.is_ephemeral = 0 AND (? IS NULL OR s.started_at >= ?)) as total_turns,
(SELECT COUNT(*) FROM task_session_messages msg
JOIN task_sessions s ON s.id = msg.task_session_id
JOIN tasks t ON t.id = s.task_id
WHERE t.workspace_id = ? AND t.is_ephemeral = 0 AND (? IS NULL OR s.started_at >= ?)) as total_messages,
(SELECT COUNT(*) FROM task_session_messages msg
JOIN task_sessions s ON s.id = msg.task_session_id
JOIN tasks t ON t.id = s.task_id
WHERE t.workspace_id = ? AND t.is_ephemeral = 0 AND msg.author_type = 'user' AND (? IS NULL OR s.started_at >= ?)) as total_user_messages,
(SELECT COUNT(*) FROM task_session_messages msg
JOIN task_sessions s ON s.id = msg.task_session_id
JOIN tasks t ON t.id = s.task_id
WHERE t.workspace_id = ? AND t.is_ephemeral = 0 AND msg.type LIKE 'tool_%%' AND (? IS NULL OR s.started_at >= ?)) as total_tool_calls,
(SELECT COALESCE(SUM(
CASE WHEN turn.completed_at IS NOT NULL THEN %s ELSE 0 END
), 0) FROM task_session_turns turn
JOIN task_sessions s ON s.id = turn.task_session_id
JOIN tasks t ON t.id = s.task_id
WHERE t.workspace_id = ? AND t.is_ephemeral = 0 AND (? IS NULL OR s.started_at >= ?)) as total_duration_ms
task_agg.total_tasks, task_agg.completed_tasks, task_agg.in_progress_tasks,
session_agg.total_sessions,
turn_agg.total_turns,
message_agg.total_messages, message_agg.total_user_messages, message_agg.total_tool_calls,
turn_agg.total_duration_ms
FROM task_agg, session_agg, turn_agg, message_agg
`, dur)
var stats models.GlobalStats
var totalDurationMs float64
var completedTasks, inProgressTasks sql.NullInt64
var userMessages, toolCalls sql.NullInt64
err := r.ro.QueryRowContext(ctx, r.ro.Rebind(query),
workspaceID, startArg, startArg,
workspaceID, startArg, startArg,
workspaceID, startArg, startArg,
workspaceID, startArg, startArg,
workspaceID, startArg, startArg,
workspaceID, startArg, startArg,
workspaceID, startArg, startArg,
workspaceID, startArg, startArg,
workspaceID, startArg, startArg,
workspaceID, startArg, startArg, // task_agg
workspaceID, startArg, startArg, // session_agg
workspaceID, startArg, startArg, // turn_agg
workspaceID, startArg, startArg, // message_agg
).Scan(
&stats.TotalTasks, &stats.CompletedTasks, &stats.InProgressTasks,
&stats.TotalSessions, &stats.TotalTurns, &stats.TotalMessages,
&stats.TotalUserMessages, &stats.TotalToolCalls, &totalDurationMs,
&stats.TotalTasks, &completedTasks, &inProgressTasks,
&stats.TotalSessions, &stats.TotalTurns,
&stats.TotalMessages, &userMessages, &toolCalls,
&totalDurationMs,
)
if err != nil {
return nil, err
}
stats.CompletedTasks = int(completedTasks.Int64)
stats.InProgressTasks = int(inProgressTasks.Int64)
stats.TotalUserMessages = int(userMessages.Int64)
stats.TotalToolCalls = int(toolCalls.Int64)
stats.TotalDurationMs = int64(totalDurationMs)
if stats.TotalTasks > 0 {