fix(logs): persist execution diagnostics markers

Store last-started and last-completed block markers with finalization metadata so later read surfaces can explain how a run ended without reconstructing executor state.

Author: test

apps/sim/lib/logs/execution/diagnostics.test.ts

@@ -0,0 +1,55 @@
+import { describe, expect, it } from 'vitest'
+import { buildExecutionDiagnostics } from '@/lib/logs/execution/diagnostics'
+
+describe('buildExecutionDiagnostics', () => {
+  it('derives trace span counts and preserves finalization details', () => {
+    const diagnostics = buildExecutionDiagnostics({
+      status: 'failed',
+      level: 'error',
+      startedAt: '2025-01-01T00:00:00.000Z',
+      endedAt: '2025-01-01T00:00:05.000Z',
+      executionData: {
+        traceSpans: [
+          {
+            id: 'span-1',
+            children: [{ id: 'span-1-child' }],
+          },
+          { id: 'span-2' },
+        ],
+        lastStartedBlock: { blockId: 'block-1' },
+        lastCompletedBlock: { blockId: 'block-2' },
+        finalizationPath: 'force_failed',
+        completionFailure: 'fallback store failed',
+        executionState: { blockStates: {} },
+      },
+    })
+
+    expect(diagnostics.traceSpanCount).toBe(3)
+    expect(diagnostics.hasTraceSpans).toBe(true)
+    expect(diagnostics.lastStartedBlock).toEqual({ blockId: 'block-1' })
+    expect(diagnostics.lastCompletedBlock).toEqual({ blockId: 'block-2' })
+    expect(diagnostics.finalizationPath).toBe('force_failed')
+    expect(diagnostics.completionFailure).toBe('fallback store failed')
+    expect(diagnostics.errorMessage).toBe('fallback store failed')
+    expect(diagnostics.hasExecutionState).toBe(true)
+  })
+
+  it('uses explicit trace flags and falls back to final output errors', () => {
+    const diagnostics = buildExecutionDiagnostics({
+      status: 'completed',
+      startedAt: '2025-01-01T00:00:00.000Z',
+      executionData: {
+        hasTraceSpans: false,
+        traceSpanCount: 7,
+        finalOutput: { error: 'stored error' },
+        finalizationPath: 'not-valid',
+      },
+    })
+
+    expect(diagnostics.hasTraceSpans).toBe(false)
+    expect(diagnostics.traceSpanCount).toBe(7)
+    expect(diagnostics.errorMessage).toBe('stored error')
+    expect(diagnostics.finalizationPath).toBeUndefined()
+    expect(diagnostics.hasExecutionState).toBe(false)
+  })
+})

apps/sim/lib/logs/execution/diagnostics.ts

@@ -0,0 +1,90 @@
+import type { ExecutionFinalizationPath } from '@/lib/logs/types'
+import { isExecutionFinalizationPath } from '@/lib/logs/types'
+
+type ExecutionData = {
+  error?: string
+  traceSpans?: unknown[]
+  executionState?: unknown
+  finalOutput?: { error?: unknown }
+  lastStartedBlock?: unknown
+  lastCompletedBlock?: unknown
+  hasTraceSpans?: boolean
+  traceSpanCount?: number
+  completionFailure?: string
+  finalizationPath?: unknown
+}
+
+function countTraceSpans(traceSpans: unknown[] | undefined): number {
+  if (!Array.isArray(traceSpans) || traceSpans.length === 0) {
+    return 0
+  }
+
+  return traceSpans.reduce<number>((count, span) => {
+    const children =
+      span && typeof span === 'object' && 'children' in span && Array.isArray(span.children)
+        ? (span.children as unknown[])
+        : undefined
+
+    return count + 1 + countTraceSpans(children)
+  }, 0)
+}
+
+export function buildExecutionDiagnostics(params: {
+  status: string
+  level?: string | null
+  startedAt: string
+  endedAt?: string | null
+  executionData?: ExecutionData | null
+}): {
+  status: string
+  level?: string
+  startedAt: string
+  endedAt?: string
+  lastStartedBlock?: unknown
+  lastCompletedBlock?: unknown
+  hasTraceSpans: boolean
+  traceSpanCount: number
+  hasExecutionState: boolean
+  finalizationPath?: ExecutionFinalizationPath
+  completionFailure?: string
+  errorMessage?: string
+} {
+  const executionData = params.executionData ?? {}
+  const derivedTraceSpanCount = countTraceSpans(executionData.traceSpans)
+  const traceSpanCount =
+    typeof executionData.traceSpanCount === 'number'
+      ? executionData.traceSpanCount
+      : derivedTraceSpanCount
+  const hasTraceSpans =
+    typeof executionData.hasTraceSpans === 'boolean'
+      ? executionData.hasTraceSpans
+      : traceSpanCount > 0
+  const completionFailure =
+    typeof executionData.completionFailure === 'string'
+      ? executionData.completionFailure
+      : undefined
+  const errorMessage =
+    completionFailure ||
+    (typeof executionData.error === 'string' ? executionData.error : undefined) ||
+    (typeof executionData.finalOutput?.error === 'string'
+      ? executionData.finalOutput.error
+      : undefined)
+  const finalizationPath = isExecutionFinalizationPath(executionData.finalizationPath)
+    ? executionData.finalizationPath
+    : undefined
+
+  return {
+    status: params.status,
+    level: params.level ?? undefined,
+    startedAt: params.startedAt,
+    endedAt: params.endedAt ?? undefined,
+    lastStartedBlock: executionData.lastStartedBlock,
+    lastCompletedBlock: executionData.lastCompletedBlock,
+    hasTraceSpans,
+    traceSpanCount,
+    hasExecutionState: executionData.executionState !== undefined,
+    ...(finalizationPath ? { finalizationPath } : {}),
+    ...(completionFailure ? { completionFailure } : {}),
+    ...(errorMessage ? { errorMessage } : {}),
+  }
+}

apps/sim/lib/logs/execution/logger.test.ts

@@ -112,7 +112,7 @@ describe('ExecutionLogger', () => {
       expect(typeof logger.getWorkflowExecution).toBe('function')
     })
 
-    test('preserves start correlation data when execution completes', () => {
+    test('preserves correlation and diagnostics when execution completes', () => {
       const loggerInstance = new ExecutionLogger() as any
 
       const completedData = loggerInstance.buildCompletedExecutionData({
@@ -140,9 +140,24 @@ describe('ExecutionLogger', () => {
               },
             },
           },
+          lastStartedBlock: {
+            blockId: 'block-start',
+            blockName: 'Start',
+            blockType: 'agent',
+            startedAt: '2025-01-01T00:00:00.000Z',
+          },
+          lastCompletedBlock: {
+            blockId: 'block-end',
+            blockName: 'Finish',
+            blockType: 'api',
+            endedAt: '2025-01-01T00:00:05.000Z',
+            success: true,
+          },
         },
         traceSpans: [],
         finalOutput: { ok: true },
+        finalizationPath: 'completed',
+        completionFailure: 'fallback failure',
         executionCost: {
           tokens: { input: 0, output: 0, total: 0 },
           models: {},
@@ -161,6 +176,12 @@ describe('ExecutionLogger', () => {
       })
       expect(completedData.correlation).toEqual(completedData.trigger?.data?.correlation)
       expect(completedData.finalOutput).toEqual({ ok: true })
+      expect(completedData.lastStartedBlock?.blockId).toBe('block-start')
+      expect(completedData.lastCompletedBlock?.blockId).toBe('block-end')
+      expect(completedData.finalizationPath).toBe('completed')
+      expect(completedData.completionFailure).toBe('fallback failure')
+      expect(completedData.hasTraceSpans).toBe(false)
+      expect(completedData.traceSpanCount).toBe(0)
     })
   })
 

apps/sim/lib/logs/execution/logger.ts

@@ -26,6 +26,7 @@ import { snapshotService } from '@/lib/logs/execution/snapshot/service'
 import type {
   BlockOutputData,
   ExecutionEnvironment,
+  ExecutionFinalizationPath,
   ExecutionTrigger,
   ExecutionLoggerService as IExecutionLoggerService,
   TraceSpan,
@@ -48,11 +49,21 @@ export interface ToolCall {
 
 const logger = createLogger('ExecutionLogger')
 
+function countTraceSpans(traceSpans?: TraceSpan[]): number {
+  if (!Array.isArray(traceSpans) || traceSpans.length === 0) {
+    return 0
+  }
+
+  return traceSpans.reduce((count, span) => count + 1 + countTraceSpans(span.children), 0)
+}
+
 export class ExecutionLogger implements IExecutionLoggerService {
   private buildCompletedExecutionData(params: {
     existingExecutionData?: WorkflowExecutionLog['executionData']
     traceSpans?: TraceSpan[]
     finalOutput: BlockOutputData
+    finalizationPath?: ExecutionFinalizationPath
+    completionFailure?: string
     executionCost: {
       tokens: {
         input: number
@@ -63,7 +74,16 @@ export class ExecutionLogger implements IExecutionLoggerService {
     }
     executionState?: SerializableExecutionState
   }): WorkflowExecutionLog['executionData'] {
-    const { existingExecutionData, traceSpans, finalOutput, executionCost, executionState } = params
+    const {
+      existingExecutionData,
+      traceSpans,
+      finalOutput,
+      finalizationPath,
+      completionFailure,
+      executionCost,
+      executionState,
+    } = params
+    const traceSpanCount = countTraceSpans(traceSpans)
 
     return {
       ...(existingExecutionData?.environment
@@ -77,6 +97,17 @@ export class ExecutionLogger implements IExecutionLoggerService {
               existingExecutionData?.trigger?.data?.correlation,
           }
         : {}),
+      ...(existingExecutionData?.error ? { error: existingExecutionData.error } : {}),
+      ...(existingExecutionData?.lastStartedBlock
+        ? { lastStartedBlock: existingExecutionData.lastStartedBlock }
+        : {}),
+      ...(existingExecutionData?.lastCompletedBlock
+        ? { lastCompletedBlock: existingExecutionData.lastCompletedBlock }
+        : {}),
+      ...(completionFailure ? { completionFailure } : {}),
+      ...(finalizationPath ? { finalizationPath } : {}),
+      hasTraceSpans: traceSpanCount > 0,
+      traceSpanCount,
       traceSpans,
       finalOutput,
       tokens: {
@@ -172,6 +203,8 @@ export class ExecutionLogger implements IExecutionLoggerService {
           environment,
           trigger,
           ...(trigger.data?.correlation ? { correlation: trigger.data.correlation } : {}),
+          hasTraceSpans: false,
+          traceSpanCount: 0,
         },
         cost: {
           total: BASE_EXECUTION_CHARGE,
@@ -230,6 +263,8 @@ export class ExecutionLogger implements IExecutionLoggerService {
     traceSpans?: TraceSpan[]
     workflowInput?: any
     executionState?: SerializableExecutionState
+    finalizationPath?: ExecutionFinalizationPath
+    completionFailure?: string
     isResume?: boolean
     level?: 'info' | 'error'
     status?: 'completed' | 'failed' | 'cancelled' | 'pending'
@@ -243,6 +278,8 @@ export class ExecutionLogger implements IExecutionLoggerService {
       traceSpans,
       workflowInput,
       executionState,
+      finalizationPath,
+      completionFailure,
       isResume,
       level: levelOverride,
       status: statusOverride,
@@ -313,6 +350,16 @@ export class ExecutionLogger implements IExecutionLoggerService {
         ? Math.max(0, Math.round(rawDurationMs))
         : 0
 
+    const completedExecutionData = this.buildCompletedExecutionData({
+      existingExecutionData,
+      traceSpans: redactedTraceSpans,
+      finalOutput: redactedFinalOutput,
+      finalizationPath,
+      completionFailure,
+      executionCost,
+      executionState,
+    })
+
     const [updatedLog] = await db
       .update(workflowExecutionLogs)
       .set({
@@ -321,13 +368,7 @@ export class ExecutionLogger implements IExecutionLoggerService {
         endedAt: new Date(endedAt),
         totalDurationMs: totalDuration,
         files: executionFiles.length > 0 ? executionFiles : null,
-        executionData: this.buildCompletedExecutionData({
-          existingExecutionData,
-          traceSpans: redactedTraceSpans,
-          finalOutput: redactedFinalOutput,
-          executionCost,
-          executionState,
-        }),
+        executionData: completedExecutionData,
         cost: executionCost,
       })
       .where(eq(workflowExecutionLogs.executionId, executionId))