fix(logs): surface handled errors as info in logs

Author: waleedlatif1

apps/sim/app/workspace/[workspaceId]/logs/components/log-details/components/trace-spans/trace-spans.tsx

@@ -67,7 +67,7 @@ function parseTime(value?: string | number | null): number {
 }
 
 /**
- * Checks if a span or any of its descendants has an error
+ * Checks if a span or any of its descendants has an error (any error).
  */
 function hasErrorInTree(span: TraceSpan): boolean {
   if (span.status === 'error') return true
@@ -80,6 +80,28 @@ function hasErrorInTree(span: TraceSpan): boolean {
   return false
 }
 
+/**
+ * Checks if a span or any of its descendants has an unhandled error.
+ * Container spans (loop, iteration, parallel) are skipped — only leaf
+ * block spans with errorHandled are considered. Used only for the root
+ * workflow span to match the actual workflow status.
+ */
+const CONTAINER_TYPES = new Set(['loop', 'loop-iteration', 'parallel', 'parallel-iteration'])
+function hasUnhandledErrorInTree(span: TraceSpan): boolean {
+  const type = span.type?.toLowerCase() || ''
+  if (CONTAINER_TYPES.has(type)) {
+    return span.children ? span.children.some(hasUnhandledErrorInTree) : false
+  }
+  if (span.status === 'error' && !span.errorHandled) return true
+  if (span.children && span.children.length > 0) {
+    return span.children.some((child) => hasUnhandledErrorInTree(child))
+  }
+  if (span.toolCalls && span.toolCalls.length > 0) {
+    return span.toolCalls.some((tc) => tc.error)
+  }
+  return false
+}
+
 /**
  * Normalizes and sorts trace spans recursively.
  * Deduplicates children and sorts by start time.
@@ -478,14 +500,13 @@ const TraceSpanNode = memo(function TraceSpanNode({
   const duration = span.duration || spanEndTime - spanStartTime
 
   const isDirectError = span.status === 'error'
-  const hasNestedError = hasErrorInTree(span)
+  const isRootWorkflow = depth === 0
+  const isRootWorkflowSpan = isRootWorkflow && span.type?.toLowerCase() === 'workflow'
+  const hasNestedError = isRootWorkflowSpan ? hasUnhandledErrorInTree(span) : hasErrorInTree(span)
   const showErrorStyle = isDirectError || hasNestedError
 
   const { icon: BlockIcon, bgColor } = getBlockIconAndColor(span.type, span.name)
 
-  // Root workflow execution is always expanded and has no toggle
-  const isRootWorkflow = depth === 0
-
   // Build all children including tool calls
   const allChildren = useMemo(() => {
     const children: TraceSpan[] = []

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/workflow-edge/workflow-edge.tsx

@@ -95,7 +95,6 @@ const WorkflowEdgeComponent = ({
       color = 'var(--brand-tertiary-2)'
     } else if (edgeRunStatus === 'success') {
       // Use green for preview mode, default for canvas execution
-      // This also applies to error edges that were taken (error path executed)
       color = previewExecutionStatus ? 'var(--brand-tertiary-2)' : 'var(--border-success)'
     } else if (edgeRunStatus === 'error') {
       color = 'var(--text-error)'

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/hooks/use-workflow-execution.ts

@@ -55,7 +55,7 @@ interface DebugValidationResult {
 interface BlockEventHandlerConfig {
   workflowId?: string
   executionId?: string
-  workflowEdges: Array<{ id: string; target: string }>
+  workflowEdges: Array<{ id: string; target: string; sourceHandle?: string | null }>
   activeBlocksSet: Set<string>
   accumulatedBlockLogs: BlockLog[]
   accumulatedBlockStates: Map<string, BlockState>
@@ -322,7 +322,8 @@ export function useWorkflowExecution() {
         if (!workflowId) return
         const incomingEdges = workflowEdges.filter((edge) => edge.target === blockId)
         incomingEdges.forEach((edge) => {
-          setEdgeRunStatus(workflowId, edge.id, 'success')
+          const status = edge.sourceHandle === 'error' ? 'error' : 'success'
+          setEdgeRunStatus(workflowId, edge.id, status)
         })
       }
 

apps/sim/executor/execution/block-executor.ts

@@ -288,6 +288,9 @@ export class BlockExecutor {
 
     const hasErrorPort = this.hasErrorPortEdge(node)
     if (hasErrorPort) {
+      if (blockLog) {
+        blockLog.errorHandled = true
+      }
       logger.info('Block has error port - returning error output instead of throwing', {
         blockId: node.id,
         error: errorMessage,

apps/sim/executor/types.ts

@@ -112,6 +112,8 @@ export interface BlockLog {
   output?: any
   input?: any
   error?: string
+  /** Whether this error was handled by an error handler path (error port) */
+  errorHandled?: boolean
   loopId?: string
   parallelId?: string
   iterationIndex?: number

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

@@ -219,11 +219,18 @@ export class ExecutionLogger implements IExecutionLoggerService {
       | { traceSpans?: TraceSpan[] }
       | undefined
 
-    // Determine if workflow failed by checking trace spans for errors
+    // Determine if workflow failed by checking trace spans for unhandled errors
+    // Errors handled by error handler paths (errorHandled: true) don't count as workflow failures
     // Use the override if provided (for cost-only fallback scenarios)
+    const containerTypes = ['loop', 'loop-iteration', 'parallel', 'parallel-iteration']
     const hasErrors = traceSpans?.some((span: any) => {
       const checkSpanForErrors = (s: any): boolean => {
-        if (s.status === 'error') return true
+        if (containerTypes.includes(s.type?.toLowerCase() || '')) {
+          return s.children && Array.isArray(s.children)
+            ? s.children.some(checkSpanForErrors)
+            : false
+        }
+        if (s.status === 'error' && !s.errorHandled) return true
         if (s.children && Array.isArray(s.children)) {
           return s.children.some(checkSpanForErrors)
         }

apps/sim/lib/logs/execution/logging-session.ts

@@ -299,9 +299,15 @@ export class LoggingSession {
             '@/lib/core/telemetry'
           )
 
+          const containerTypes = ['loop', 'loop-iteration', 'parallel', 'parallel-iteration']
           const hasErrors = traceSpans.some((span: any) => {
             const checkForErrors = (s: any): boolean => {
-              if (s.status === 'error') return true
+              if (containerTypes.includes(s.type?.toLowerCase() || '')) {
+                return s.children && Array.isArray(s.children)
+                  ? s.children.some(checkForErrors)
+                  : false
+              }
+              if (s.status === 'error' && !s.errorHandled) return true
               if (s.children && Array.isArray(s.children)) {
                 return s.children.some(checkForErrors)
               }