fix: correct graph and multimodal processing traces

This commit is contained in:
unknown
2026-07-22 14:51:43 +08:00
committed by lyingbug
parent b9b81a6c3c
commit ab0b1d65b5
7 changed files with 331 additions and 32 deletions
@@ -3,26 +3,15 @@ import { ref, reactive, onMounted, onBeforeUnmount, watch, computed, nextTick }
import { MessagePlugin } from 'tdesign-vue-next'
import { useI18n } from 'vue-i18n'
import { getKnowledgeSpans, reparseKnowledge, cancelKnowledgeParse, getKnowledgeDetails } from '@/api/knowledge-base/index'
import { knowledgeSpansPayloadHasTrace } from '@/utils/knowledgeTrace'
import {
groupPostprocessGraphSpans,
knowledgeSpansPayloadHasTrace,
type KnowledgeTraceNode,
} from '@/utils/knowledgeTrace'
import { resolveTimelineHeaderStatus } from '@/utils/knowledgeProcessingStatus'
import type { KnowledgeProcessOverrides } from '@/types/knowledgeProcess'
interface SpanNode {
span_id?: string
parent_span_id?: string
name: string
kind: string
status: string
started_at?: string | null
finished_at?: string | null
duration_ms?: number
error_code?: string
error_message?: string
input?: any
output?: any
metadata?: any
children?: SpanNode[]
}
type SpanNode = KnowledgeTraceNode
interface LastError {
name: string
@@ -160,7 +149,9 @@ const stages = computed<SpanNode[]>(() => {
const children = trace?.children || []
const byName = new Map<string, SpanNode>()
for (const c of children) {
if (c && c.kind === 'stage' && c.name) byName.set(c.name, c)
if (c && c.kind === 'stage' && c.name) {
byName.set(c.name, c.name === 'postprocess' ? groupPostprocessGraphSpans(c) : c)
}
}
return STAGES.map((n) => byName.get(n) || ({ name: n, kind: 'stage', status: 'pending' } as SpanNode))
})
@@ -197,6 +188,13 @@ function formatRelativeTime(ts: number): string {
return t('knowledgeStages.minutesAgo', { n: min })
}
// A skipped stage did not execute. Its tiny bookkeeping interval is not
// processing time, so do not present it as (for example) multimodal time.
function formatSpanDuration(node: SpanNode): string {
if (node.status === 'skipped' || node.status === 'pending') return '—'
return formatDuration(node.duration_ms)
}
function isPolling(status?: string): boolean {
// finalizing is the post-process fan-out window — subspans
// (summary / question / graph.chunk[*]) are still actively producing
@@ -954,6 +952,9 @@ function localizedStatus(status: string): string {
function rowLabel(row: FlatRow): string {
if (row.isRoot) return t('knowledgeStages.root')
if (row.isStage) return t(`knowledgeStages.stage.${row.node.name}`)
if (row.node.name === 'postprocess.graph') return t('knowledgeStages.processConfig.graph')
const graphChunk = /^postprocess\.graph\.chunk\[(\d+)\]$/.exec(row.node.name)
if (graphChunk) return `${t('knowledgeStages.processConfig.graph')} #${Number(graphChunk[1]) + 1}`
return row.node.name
}
@@ -1558,7 +1559,7 @@ const processConfigLines = computed<string[]>(() => {
<span class="kp-running-time">{{ formatDuration(liveElapsedMs(row.node)) }}</span>
</template>
<template v-else>
{{ formatDuration(row.node.duration_ms) }}
{{ formatSpanDuration(row.node) }}
</template>
</div>
@@ -1587,8 +1588,9 @@ const processConfigLines = computed<string[]>(() => {
<span class="kp-bar-tip">
<span class="kp-bar-tip-name">{{ rowLabel(row) }}</span>
<span class="kp-bar-tip-sep">·</span>
<span class="kp-mono">{{ formatDuration(row.node.status === 'running' ? liveElapsedMs(row.node)
: row.node.duration_ms) }}</span>
<span class="kp-mono">{{ row.node.status === 'running'
? formatDuration(liveElapsedMs(row.node))
: formatSpanDuration(row.node) }}</span>
<span class="kp-bar-tip-sep">·</span>
<span>{{ localizedStatus(row.node.status) }}</span>
</span>
@@ -1674,7 +1676,7 @@ const processConfigLines = computed<string[]>(() => {
<span class="kp-kv-tag-live">{{ t('knowledgeStages.detail.elapsed') }}</span>
</template>
<template v-else>
{{ formatDuration(selectedRow.node.duration_ms) }}
{{ formatSpanDuration(selectedRow.node) }}
</template>
</span>
</div>
@@ -1726,7 +1728,9 @@ const processConfigLines = computed<string[]>(() => {
<div class="kp-breakdown-track">
<div class="kp-breakdown-bar" :class="['kp-bar-' + s.status]" :style="{ width: s.pct + '%' }" />
</div>
<span class="kp-breakdown-dur kp-mono">{{ formatDuration(s.duration_ms) }}</span>
<span class="kp-breakdown-dur kp-mono">{{ s.status === 'skipped' || s.status === 'pending'
? '—'
: formatDuration(s.duration_ms) }}</span>
</div>
</div>
</div>
+109
View File
@@ -0,0 +1,109 @@
import assert from 'node:assert/strict'
import test from 'node:test'
import { groupPostprocessGraphSpans, type KnowledgeTraceNode } from './knowledgeTrace.ts'
function graphChunk(index: number, overrides: Partial<KnowledgeTraceNode> = {}): KnowledgeTraceNode {
return {
span_id: `graph-${index}`,
parent_span_id: 'postprocess',
name: `postprocess.graph.chunk[${index}]`,
kind: 'subspan',
status: 'done',
started_at: `2026-07-21T08:00:0${index}.000Z`,
finished_at: `2026-07-21T08:00:0${index + 2}.000Z`,
duration_ms: 2000,
...overrides,
}
}
test('groups graph chunks and reports their wall-clock duration', () => {
const summary: KnowledgeTraceNode = {
span_id: 'summary',
name: 'postprocess.summary',
kind: 'subspan',
status: 'done',
}
const stage: KnowledgeTraceNode = {
span_id: 'postprocess',
name: 'postprocess',
kind: 'stage',
status: 'done',
children: [summary, graphChunk(0), graphChunk(1)],
}
const grouped = groupPostprocessGraphSpans(stage)
assert.equal(grouped.children?.length, 2)
assert.equal(grouped.children?.[0], summary)
const graph = grouped.children?.[1]
assert.equal(graph?.name, 'postprocess.graph')
assert.equal(graph?.status, 'done')
assert.equal(graph?.duration_ms, 3000)
assert.equal(graph?.children?.length, 2)
assert.deepEqual(graph?.output, {
chunk_count: 2,
status_counts: { done: 2 },
})
})
test('keeps graph group live while any graph chunk is running', () => {
const stage: KnowledgeTraceNode = {
span_id: 'postprocess',
name: 'postprocess',
kind: 'stage',
status: 'done',
children: [
graphChunk(0),
graphChunk(1, { status: 'running', finished_at: null, duration_ms: undefined }),
],
}
const graph = groupPostprocessGraphSpans(stage).children?.[0]
assert.equal(graph?.status, 'running')
assert.equal(graph?.finished_at, null)
assert.equal(graph?.duration_ms, undefined)
})
test('surfaces a failed graph chunk on the aggregate graph row', () => {
const stage: KnowledgeTraceNode = {
span_id: 'postprocess',
name: 'postprocess',
kind: 'stage',
status: 'done',
children: [graphChunk(0), graphChunk(1, { status: 'failed' })],
}
const graph = groupPostprocessGraphSpans(stage).children?.[0]
assert.equal(graph?.status, 'failed')
assert.equal(graph?.duration_ms, 3000)
})
test('keeps the aggregate running until all graph chunks are terminal', () => {
const stage: KnowledgeTraceNode = {
span_id: 'postprocess',
name: 'postprocess',
kind: 'stage',
status: 'done',
children: [
graphChunk(0, { status: 'failed' }),
graphChunk(1, { status: 'running', finished_at: null, duration_ms: undefined }),
],
}
const graph = groupPostprocessGraphSpans(stage).children?.[0]
assert.equal(graph?.status, 'running')
assert.equal(graph?.duration_ms, undefined)
})
test('leaves postprocess unchanged when it has no graph chunks', () => {
const stage: KnowledgeTraceNode = {
span_id: 'postprocess',
name: 'postprocess',
kind: 'stage',
status: 'done',
children: [],
}
assert.equal(groupPostprocessGraphSpans(stage), stage)
})
+100
View File
@@ -5,3 +5,103 @@ export function knowledgeSpansPayloadHasTrace(
if (!data?.trace) return false
return !!(data.trace.span_id || (data.current_attempt ?? 0) > 0)
}
export interface KnowledgeTraceNode {
span_id?: string
parent_span_id?: string
name: string
kind: string
status: string
started_at?: string | null
finished_at?: string | null
duration_ms?: number
error_code?: string
error_message?: string
input?: unknown
output?: unknown
metadata?: unknown
children?: KnowledgeTraceNode[]
}
const graphChunkName = /^postprocess\.graph\.chunk\[(\d+)\]$/
function timestamp(value?: string | null): number | null {
if (!value) return null
const parsed = Date.parse(value)
return Number.isNaN(parsed) ? null : parsed
}
function nodeEnd(node: KnowledgeTraceNode): number | null {
const finished = timestamp(node.finished_at)
if (finished !== null) return finished
const started = timestamp(node.started_at)
if (started !== null && typeof node.duration_ms === 'number' && node.duration_ms >= 0) {
return started + node.duration_ms
}
return null
}
function aggregateStatus(nodes: KnowledgeTraceNode[]): string {
if (nodes.some(node => node.status === 'running' || node.status === 'pending')) return 'running'
if (nodes.some(node => node.status === 'failed')) return 'failed'
if (nodes.every(node => node.status === 'skipped')) return 'skipped'
if (nodes.some(node => node.status === 'cancelled')) return 'cancelled'
return 'done'
}
/**
* Groups persisted postprocess.graph.chunk[i] spans into one derived graph
* node. The derived duration is wall-clock time from the first graph worker
* start to the final graph worker finish; children retain per-chunk detail.
*/
export function groupPostprocessGraphSpans(
stage: KnowledgeTraceNode,
): KnowledgeTraceNode {
const children = stage.children || []
const graphChildren = children.filter(child => graphChunkName.test(child.name))
if (graphChildren.length === 0) return stage
const starts = graphChildren
.map(child => timestamp(child.started_at))
.filter((value): value is number => value !== null)
const ends = graphChildren
.map(nodeEnd)
.filter((value): value is number => value !== null)
const status = aggregateStatus(graphChildren)
const start = starts.length > 0 ? Math.min(...starts) : null
const terminal = status !== 'running'
const end = terminal && ends.length > 0 ? Math.max(...ends) : null
const counts = graphChildren.reduce<Record<string, number>>((result, child) => {
result[child.status] = (result[child.status] || 0) + 1
return result
}, {})
const group: KnowledgeTraceNode = {
span_id: `virtual:postprocess.graph:${stage.span_id || 'stage'}`,
parent_span_id: stage.span_id,
name: 'postprocess.graph',
kind: 'group',
status,
started_at: start === null ? null : new Date(start).toISOString(),
finished_at: end === null ? null : new Date(end).toISOString(),
duration_ms: start !== null && end !== null ? Math.max(0, end - start) : undefined,
input: { chunk_count: graphChildren.length },
output: { chunk_count: graphChildren.length, status_counts: counts },
children: graphChildren,
}
let inserted = false
const groupedChildren: KnowledgeTraceNode[] = []
for (const child of children) {
if (graphChunkName.test(child.name)) {
if (!inserted) {
groupedChildren.push(group)
inserted = true
}
continue
}
groupedChildren.push(child)
}
return { ...stage, children: groupedChildren }
}
@@ -692,7 +692,9 @@ function initFromKbInfo(kb: any) {
customInstructions: kb.question_generation_config?.custom_instructions || '',
},
nodeExtractConfig: {
enabled: kb.extract_config?.enabled || false,
// This dialog exposes one graph switch, so show the effective state.
// The backend only runs graph extraction when both flags are enabled.
enabled: !!kb.extract_config?.enabled && !!kb.indexing_strategy?.graph_enabled,
text: kb.extract_config?.text || '',
tags: kb.extract_config?.tags || [],
nodes: (kb.extract_config?.nodes || []).map((node: any) => ({
@@ -808,6 +810,9 @@ function applyOverridesToState(o?: KnowledgeProcessOverrides | null) {
if (ec.custom_instructions != null) s.nodeExtractConfig.customInstructions = ec.custom_instructions
}
if (o.graph_enabled != null) s.graphEnabled = o.graph_enabled
// Older saved overrides may contain mismatched graph/extract flags. Keep
// the single visible switch aligned with the backend's effective state.
s.nodeExtractConfig.enabled = s.nodeExtractConfig.enabled && s.graphEnabled
if (o.parser_engine_overrides && o.parser_engine_overrides.pdf_force_scanned === 'true') {
s.pdfForceScanned = true
} else {
@@ -905,6 +910,10 @@ const handleQuestionGenerationUpdate = (config: { enabled: boolean; questionCoun
const handleNodeExtractUpdate = (config: UploadUIState['nodeExtractConfig']) => {
uiState.value.nodeExtractConfig = { ...config }
// GraphSettings is the only graph switch in the upload dialog. Update both
// backend flags; otherwise the hidden KB default can silently override the
// user's checked switch and prevent graph tasks from being created.
uiState.value.graphEnabled = config.enabled
}
const validateBeforeConfirm = (): boolean => {
@@ -54,6 +54,25 @@ func (s *KnowledgePostProcessService) tracker() SpanTracker {
return s.spanTracker
}
// finishRunningMultimodalStage closes the multimodal stage only when image
// work really ran and is still open. The canonical stage also exists when
// multimodal processing is disabled, but that row is already "skipped" and
// must not be rewritten to "done" with the postprocess queueing delay as its
// duration.
func (s *KnowledgePostProcessService) finishRunningMultimodalStage(
ctx context.Context,
knowledgeID string,
attempt int,
) {
mm := s.tracker().LookupStage(ctx, knowledgeID, attempt, types.StageMultimodal)
if mm == nil ||
mm.Kind != types.SpanKindStage ||
mm.Status != types.SpanStatusRunning {
return
}
s.tracker().EndSpan(ctx, mm, nil)
}
// Handle implements asynq handler for TypeKnowledgePostProcess.
func (s *KnowledgePostProcessService) Handle(ctx context.Context, task *asynq.Task) error {
var payload types.KnowledgePostProcessPayload
@@ -79,15 +98,12 @@ func (s *KnowledgePostProcessService) Handle(ctx context.Context, task *asynq.Ta
// Close the multimodal stage span (parent enqueued it as "running"
// and we never see the per-image fan-in here other than by reaching
// post-process). If the parent skipped multimodal entirely, the
// stage row will already be in "skipped" state and EndSpan is a
// no-op for missing rows. Per-image success/failure counts are NOT
// stage row will already be in "skipped" state and must remain so.
// Per-image success/failure counts are NOT
// aggregated here — the frontend already walks the children when
// rendering the multimodal stage detail and counts them itself,
// avoiding an extra query path.
if mm := s.tracker().LookupStage(ctx, payload.KnowledgeID, attempt, types.StageMultimodal); mm != nil &&
mm.Kind == types.SpanKindStage {
s.tracker().EndSpan(ctx, mm, nil)
}
s.finishRunningMultimodalStage(ctx, payload.KnowledgeID, attempt)
postSpan := s.tracker().BeginStage(ctx, payload.KnowledgeID, attempt, types.StagePostProcess, nil)
@@ -0,0 +1,54 @@
package service
import (
"context"
"testing"
"github.com/Tencent/WeKnora/internal/types"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestFinishRunningMultimodalStage_PreservesSkippedStage(t *testing.T) {
tracker, db := setupSpanTrackerTest(t)
ctx := context.Background()
_, attempt, err := tracker.OpenAttempt(ctx, "kid-multimodal-disabled", "")
require.NoError(t, err)
mm := tracker.BeginStage(ctx, "kid-multimodal-disabled", attempt, types.StageMultimodal, nil)
require.NotNil(t, mm)
tracker.SkipSpan(ctx, mm, "skipped")
service := &KnowledgePostProcessService{spanTracker: tracker}
service.finishRunningMultimodalStage(ctx, "kid-multimodal-disabled", attempt)
var row types.KnowledgeProcessingSpan
require.NoError(t, db.Table("knowledge_processing_spans").
Where("knowledge_id = ? AND attempt = ? AND name = ?",
"kid-multimodal-disabled", attempt, types.StageMultimodal).
First(&row).Error)
assert.Equal(t, types.SpanStatusSkipped, row.Status)
assert.Equal(t, int64(0), row.DurationMs)
}
func TestFinishRunningMultimodalStage_CompletesRunningStage(t *testing.T) {
tracker, db := setupSpanTrackerTest(t)
ctx := context.Background()
_, attempt, err := tracker.OpenAttempt(ctx, "kid-multimodal-enabled", "")
require.NoError(t, err)
mm := tracker.BeginStage(ctx, "kid-multimodal-enabled", attempt, types.StageMultimodal, nil)
require.NotNil(t, mm)
service := &KnowledgePostProcessService{spanTracker: tracker}
service.finishRunningMultimodalStage(ctx, "kid-multimodal-enabled", attempt)
var row types.KnowledgeProcessingSpan
require.NoError(t, db.Table("knowledge_processing_spans").
Where("knowledge_id = ? AND attempt = ? AND name = ?",
"kid-multimodal-enabled", attempt, types.StageMultimodal).
First(&row).Error)
assert.Equal(t, types.SpanStatusDone, row.Status)
assert.NotNil(t, row.FinishedAt)
assert.GreaterOrEqual(t, row.DurationMs, int64(0))
}
@@ -76,6 +76,7 @@ type Span struct {
ParentSpanID string
Name string
Kind string
Status string
StartedAt time.Time
}
@@ -279,6 +280,7 @@ func (t *spanTracker) OpenAttempt(ctx context.Context, knowledgeID, langfuseTrac
SpanID: rootID,
Name: "knowledge_processing",
Kind: types.SpanKindRoot,
Status: types.SpanStatusRunning,
StartedAt: now,
}, attempt, nil
}
@@ -309,8 +311,8 @@ func (t *spanTracker) BeginStage(ctx context.Context, knowledgeID string, attemp
return nil
}
var (
rootID string
existing *types.KnowledgeProcessingSpan
rootID string
existing *types.KnowledgeProcessingSpan
)
for i := range rows {
r := rows[i]
@@ -365,6 +367,7 @@ func (t *spanTracker) BeginStage(ctx context.Context, knowledgeID string, attemp
ParentSpanID: existing.ParentSpanID,
Name: existing.Name,
Kind: existing.Kind,
Status: types.SpanStatusRunning,
StartedAt: now,
}
}
@@ -394,6 +397,7 @@ func (t *spanTracker) BeginStage(ctx context.Context, knowledgeID string, attemp
ParentSpanID: rootID,
Name: stage,
Kind: types.SpanKindStage,
Status: types.SpanStatusRunning,
StartedAt: now,
}
}
@@ -441,6 +445,7 @@ func (t *spanTracker) BeginSubSpan(ctx context.Context, parent *Span, name, kind
ParentSpanID: parent.SpanID,
Name: name,
Kind: kind,
Status: types.SpanStatusRunning,
StartedAt: now,
}
}
@@ -578,6 +583,7 @@ func (t *spanTracker) LookupStage(ctx context.Context, knowledgeID string, attem
ParentSpanID: r.ParentSpanID,
Name: r.Name,
Kind: r.Kind,
Status: r.Status,
StartedAt: started,
}
}
@@ -611,6 +617,7 @@ func (t *spanTracker) LookupSpanByName(ctx context.Context, knowledgeID string,
ParentSpanID: r.ParentSpanID,
Name: r.Name,
Kind: r.Kind,
Status: r.Status,
StartedAt: started,
}
}