Skip to content

Self-hosted workflows for coding-agent delivery. Orchestrate CodeBuddy, Codex and Claude Code with scripts and human approval gates. Includes Local workflows for coding assistants.

【架构优化】合并 analytics 维度累加函数中重复的用量、状态与耗时累加逻辑 (#646) (#647)

fx-kurumi37d4d1ba9521
diff --git a/internal/repo/analytics.go b/internal/repo/analytics.go
index 06f2c00a..35dd2ad2 100644
--- a/internal/repo/analytics.go
+++ b/internal/repo/analytics.go
@@ -1004,36 +1004,51 @@ func accumulateBreakdown(values map[string]*analyticsAccumulator, key, name stri
}
value.item.Runs++
value.item.Reworks += reworks
- if !usageCostKnown(run.Usage) {
- value.item.CostUnknownRuns++
- }
- value.item.Tokens += run.Usage.TotalTokens
- value.item.CostUSD += run.Usage.CostUSD
value.item.ToolCalls += run.ToolCalls
- value.inputTokens += run.Usage.InputTokens
- value.outputTokens += run.Usage.OutputTokens
- value.cacheReadTokens += run.Usage.CacheReadTokens
- value.cacheWriteTokens += run.Usage.CacheWriteTokens
- if run.Status == "succeeded" {
- value.item.Succeeded++
- }
- if run.Status == "failed" {
- value.item.Failed++
- }
- if run.Status == "cancelled" {
- value.item.Cancelled++
+ accumulateBreakdownUsage(value, run.Usage)
+ countBreakdownStatus(&value.item, run.Status, run.Status == "running" || run.Status == "waiting")
+ if complete {
+ accumulateBreakdownDuration(value, duration, execDuration)
}
- if run.Status == "running" || run.Status == "waiting" {
- value.item.Active++
+}
+
+// accumulateBreakdownUsage 把单次执行的用量累加到维度累加器:Token/成本总量、
+// 成本未识别计数与 Token 四分项。dimension 维度(SOP、节点、模型等)共用。
+func accumulateBreakdownUsage(value *analyticsAccumulator, usage domain.TokenUsage) {
+ if !usageCostKnown(usage) {
+ value.item.CostUnknownRuns++
}
- if complete {
- value.duration += duration
- value.durations = append(value.durations, duration)
- value.execDuration += execDuration
- value.execDurations = append(value.execDurations, execDuration)
+ value.item.Tokens += usage.TotalTokens
+ value.item.CostUSD += usage.CostUSD
+ value.inputTokens += usage.InputTokens
+ value.outputTokens += usage.OutputTokens
+ value.cacheReadTokens += usage.CacheReadTokens
+ value.cacheWriteTokens += usage.CacheWriteTokens
+}
+
+// countBreakdownStatus 按执行状态累加维度终态计数,active 由调用方按各自的状态词表判定。
+func countBreakdownStatus(item *domain.AnalyticsBreakdown, status string, active bool) {
+ switch status {
+ case "succeeded":
+ item.Succeeded++
+ case "failed":
+ item.Failed++
+ case "cancelled":
+ item.Cancelled++
+ }
+ if active {
+ item.Active++
}
}
+// accumulateBreakdownDuration 记录一次有效耗时样本,供均值与 P95 使用。
+func accumulateBreakdownDuration(value *analyticsAccumulator, duration, execDuration int64) {
+ value.duration += duration
+ value.durations = append(value.durations, duration)
+ value.execDuration += execDuration
+ value.execDurations = append(value.execDurations, execDuration)
+}
+
func accumulateNode(values map[string]*analyticsAccumulator, key, name string, node *domain.NodeRun, duration int64, complete bool) {
value := values[key]
if value == nil {
@@ -1045,16 +1060,8 @@ func accumulateNode(values map[string]*analyticsAccumulator, key, name string, n
}
value.item.Runs++
value.item.Reworks += node.ReworkCount
- if !usageCostKnown(node.Usage) {
- value.item.CostUnknownRuns++
- }
- value.item.Tokens += node.Usage.TotalTokens
- value.item.CostUSD += node.Usage.CostUSD
value.item.ToolCalls += node.ToolCalls
- value.inputTokens += node.Usage.InputTokens
- value.outputTokens += node.Usage.OutputTokens
- value.cacheReadTokens += node.Usage.CacheReadTokens
- value.cacheWriteTokens += node.Usage.CacheWriteTokens
+ accumulateBreakdownUsage(value, node.Usage)
value.nodeRuns++
if node.Attempt > 1 {
value.retriedNodes++
@@ -1068,22 +1075,13 @@ func accumulateNode(values map[string]*analyticsAccumulator, key, name string, n
}
value.models[node.Model]++
}
- if node.Status == "succeeded" {
- value.item.Succeeded++
- }
+ countBreakdownStatus(&value.item, node.Status, node.Status == "running" || node.Status == "waiting_approval")
if node.Status == "failed" {
- value.item.Failed++
value.item.FailedNodes++
}
- if node.Status == "running" || node.Status == "waiting_approval" {
- value.item.Active++
- }
if complete {
- value.duration += duration
- value.durations = append(value.durations, duration)
// 节点耗时本身就是"执行耗时",与双口径中的执行耗时同源。
- value.execDuration += duration
- value.execDurations = append(value.execDurations, duration)
+ accumulateBreakdownDuration(value, duration, duration)
}
}
diff --git a/internal/repo/analytics_breakdown_helpers_test.go b/internal/repo/analytics_breakdown_helpers_test.go
new file mode 100644
index 00000000..ae7b476b
--- /dev/null
+++ b/internal/repo/analytics_breakdown_helpers_test.go
@@ -0,0 +1,99 @@
+package repo
+
+import (
+ "testing"
+
+ "agentflow/internal/domain"
+)
+
+func TestAccumulateBreakdownUsageAddsTokensAndCostUnknown(t *testing.T) {
+ usage := domain.TokenUsage{
+ TotalTokens: 10,
+ InputTokens: 4,
+ OutputTokens: 6,
+ CacheReadTokens: 2,
+ CacheWriteTokens: 1,
+ CostUSD: 0.5,
+ CostStatus: "reported",
+ }
+ value := &analyticsAccumulator{}
+ accumulateBreakdownUsage(value, usage)
+ accumulateBreakdownUsage(value, usage)
+
+ if value.item.Tokens != 20 || value.item.CostUSD != 1 {
+ t.Fatalf("unexpected totals: tokens=%d cost=%v", value.item.Tokens, value.item.CostUSD)
+ }
+ if value.inputTokens != 8 || value.outputTokens != 12 || value.cacheReadTokens != 4 || value.cacheWriteTokens != 2 {
+ t.Fatalf("unexpected token split: %+v", value)
+ }
+ if value.item.CostUnknownRuns != 0 {
+ t.Fatalf("expected no unknown-cost runs, got %d", value.item.CostUnknownRuns)
+ }
+
+ accumulateBreakdownUsage(value, domain.TokenUsage{CostStatus: "unknown"})
+ if value.item.CostUnknownRuns != 1 {
+ t.Fatalf("expected 1 unknown-cost run, got %d", value.item.CostUnknownRuns)
+ }
+}
+
+func TestCountBreakdownStatusCountsTerminalStates(t *testing.T) {
+ cases := []struct {
+ status string
+ active bool
+ want domain.AnalyticsBreakdown
+ terminal string
+ }{
+ {status: "succeeded", want: domain.AnalyticsBreakdown{Succeeded: 1}, terminal: "succeeded"},
+ {status: "failed", want: domain.AnalyticsBreakdown{Failed: 1}, terminal: "failed"},
+ {status: "cancelled", want: domain.AnalyticsBreakdown{Cancelled: 1}, terminal: "cancelled"},
+ {status: "running", active: true, want: domain.AnalyticsBreakdown{Active: 1}, terminal: "running"},
+ {status: "waiting", active: true, want: domain.AnalyticsBreakdown{Active: 1}, terminal: "waiting"},
+ {status: "skipped", active: false, want: domain.AnalyticsBreakdown{}, terminal: "skipped"},
+ }
+ for _, c := range cases {
+ t.Run(c.status, func(t *testing.T) {
+ var item domain.AnalyticsBreakdown
+ countBreakdownStatus(&item, c.status, c.active)
+ if item.Succeeded != c.want.Succeeded || item.Failed != c.want.Failed ||
+ item.Cancelled != c.want.Cancelled || item.Active != c.want.Active {
+ t.Fatalf("countBreakdownStatus(%q) = succeeded:%d failed:%d cancelled:%d active:%d, want %+v",
+ c.status, item.Succeeded, item.Failed, item.Cancelled, item.Active, c.want)
+ }
+ })
+ }
+}
+
+func TestAccumulateBreakdownDurationKeepsSamplesInOrder(t *testing.T) {
+ value := &analyticsAccumulator{}
+ accumulateBreakdownDuration(value, 100, 40)
+ accumulateBreakdownDuration(value, 300, 60)
+
+ if value.duration != 400 || value.execDuration != 100 {
+ t.Fatalf("unexpected totals: duration=%d execDuration=%d", value.duration, value.execDuration)
+ }
+ if len(value.durations) != 2 || value.durations[0] != 100 || value.durations[1] != 300 {
+ t.Fatalf("unexpected duration samples: %v", value.durations)
+ }
+ if len(value.execDurations) != 2 || value.execDurations[0] != 40 || value.execDurations[1] != 60 {
+ t.Fatalf("unexpected exec duration samples: %v", value.execDurations)
+ }
+}
+
+func TestAccumulateNodeStillCountsFailedNodes(t *testing.T) {
+ values := map[string]*analyticsAccumulator{}
+ accumulateNode(values, "n1", "节点一", &domain.NodeRun{Status: "failed", Attempt: 2, ReworkCount: 1}, 120, true)
+
+ value := values["n1"]
+ if value == nil {
+ t.Fatal("expected an accumulator for n1")
+ }
+ if value.item.Runs != 1 || value.item.Failed != 1 || value.item.FailedNodes != 1 {
+ t.Fatalf("unexpected status counters: %+v", value.item)
+ }
+ if value.retriedNodes != 1 || value.reworkNodes != 1 || value.nodeRuns != 1 {
+ t.Fatalf("unexpected node counters: %+v", value)
+ }
+ if value.item.AverageDurationMs != 0 && value.duration != 120 {
+ t.Fatalf("expected duration 120, got %d", value.duration)
+ }
+}