fix passing of spans to be in block log

Author: icecrasher321

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

@@ -57,40 +57,6 @@ function useSetToggle() {
   )
 }
 
-/**
- * Generates a unique key for a trace span
- */
-function getSpanKey(span: TraceSpan): string {
-  if (span.id) {
-    return span.id
-  }
-  const name = span.name || 'span'
-  const start = span.startTime || 'unknown-start'
-  const end = span.endTime || 'unknown-end'
-  return `${name}|${start}|${end}`
-}
-
-/**
- * Merges multiple arrays of trace span children, deduplicating by span key
- */
-function mergeTraceSpanChildren(...groups: TraceSpan[][]): TraceSpan[] {
-  const merged: TraceSpan[] = []
-  const seen = new Set<string>()
-
-  groups.forEach((group) => {
-    group.forEach((child) => {
-      const key = getSpanKey(child)
-      if (seen.has(key)) {
-        return
-      }
-      seen.add(key)
-      merged.push(child)
-    })
-  })
-
-  return merged
-}
-
 /**
  * Parses a time value to milliseconds
  */
@@ -116,34 +82,16 @@ function hasErrorInTree(span: TraceSpan): boolean {
 
 /**
  * Normalizes and sorts trace spans recursively.
- * Merges children from both span.children and span.output.childTraceSpans,
- * deduplicates them, and sorts by start time.
+ * Deduplicates children and sorts by start time.
  */
 function normalizeAndSortSpans(spans: TraceSpan[]): TraceSpan[] {
   return spans
     .map((span) => {
       const enrichedSpan: TraceSpan = { ...span }
 
-      // Clean output by removing childTraceSpans after extracting
-      if (enrichedSpan.output && typeof enrichedSpan.output === 'object') {
-        enrichedSpan.output = { ...enrichedSpan.output }
-        if ('childTraceSpans' in enrichedSpan.output) {
-          const { childTraceSpans, ...cleanOutput } = enrichedSpan.output as {
-            childTraceSpans?: TraceSpan[]
-          } & Record<string, unknown>
-          enrichedSpan.output = cleanOutput
-        }
-      }
-
-      // Merge and deduplicate children from both sources
-      const directChildren = Array.isArray(span.children) ? span.children : []
-      const outputChildren = Array.isArray(span.output?.childTraceSpans)
-        ? (span.output!.childTraceSpans as TraceSpan[])
-        : []
-
-      const mergedChildren = mergeTraceSpanChildren(directChildren, outputChildren)
-      enrichedSpan.children =
-        mergedChildren.length > 0 ? normalizeAndSortSpans(mergedChildren) : undefined
+      // Process and deduplicate children
+      const children = Array.isArray(span.children) ? span.children : []
+      enrichedSpan.children = children.length > 0 ? normalizeAndSortSpans(children) : undefined
 
       return enrichedSpan
     })

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

@@ -18,6 +18,7 @@ import {
 import { ScrollArea } from '@/components/ui/scroll-area'
 import { BASE_EXECUTION_CHARGE } from '@/lib/billing/constants'
 import { cn } from '@/lib/core/utils/cn'
+import { filterHiddenOutputKeys } from '@/lib/logs/execution/trace-spans/trace-spans'
 import {
   ExecutionSnapshot,
   FileCards,
@@ -274,16 +275,13 @@ export const LogDetails = memo(function LogDetails({
     return isWorkflowExecutionLog && log?.cost
   }, [log, isWorkflowExecutionLog])
 
-  // Extract and clean the workflow final output (remove childTraceSpans for cleaner display)
+  // Extract and clean the workflow final output (recursively remove hidden keys for cleaner display)
   const workflowOutput = useMemo(() => {
     const executionData = log?.executionData as
       | { finalOutput?: Record<string, unknown> }
       | undefined
     if (!executionData?.finalOutput) return null
-    const { childTraceSpans, ...cleanOutput } = executionData.finalOutput as {
-      childTraceSpans?: unknown
-    } & Record<string, unknown>
-    return cleanOutput
+    return filterHiddenOutputKeys(executionData.finalOutput) as Record<string, unknown>
   }, [log?.executionData])
 
   useEffect(() => {

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

@@ -152,9 +152,6 @@ export class BlockExecutor {
         blockLog.durationMs = duration
         blockLog.success = true
         blockLog.output = filterOutputForLog(block.metadata?.id || '', normalizedOutput, { block })
-
-        // Extract childTraceSpans for nested workflow execution
-        // Store separately to keep output clean for display while preserving for trace processing
         if (normalizedOutput.childTraceSpans && Array.isArray(normalizedOutput.childTraceSpans)) {
           blockLog.childTraceSpans = normalizedOutput.childTraceSpans
         }

apps/sim/executor/utils/output-filter.ts

@@ -1,3 +1,4 @@
+import { filterHiddenOutputKeys } from '@/lib/logs/execution/trace-spans/trace-spans'
 import { getBlock } from '@/blocks'
 import { isHiddenFromDisplay } from '@/blocks/types'
 import { isTriggerBehavior, isTriggerInternalKey } from '@/executor/constants'
@@ -7,6 +8,7 @@ import type { SerializedBlock } from '@/serializer/types'
 /**
  * Filters block output for logging/display purposes.
  * Removes internal fields and fields marked with hiddenFromDisplay.
+ * Also recursively filters globally hidden keys from nested objects.
  *
  * @param blockType - The block type string (e.g., 'human_in_the_loop', 'workflow')
  * @param output - The raw block output to filter
@@ -44,7 +46,8 @@ export function filterOutputForLog(
       continue
     }
 
-    filtered[key] = value
+    // Recursively filter globally hidden keys from nested objects
+    filtered[key] = filterHiddenOutputKeys(value)
   }
 
   return filtered

apps/sim/lib/logs/execution/trace-spans/trace-spans.ts

@@ -5,6 +5,39 @@ import type { ExecutionResult } from '@/executor/types'
 
 const logger = createLogger('TraceSpans')
 
+/**
+ * Keys that should be recursively filtered from output display.
+ * These are internal fields used for execution tracking that shouldn't be shown to users.
+ */
+const HIDDEN_OUTPUT_KEYS = new Set(['childTraceSpans'])
+
+/**
+ * Recursively filters hidden keys from nested objects for cleaner display.
+ * Used by both executor (for log output) and UI (for display).
+ */
+export function filterHiddenOutputKeys(value: unknown): unknown {
+  if (value === null || value === undefined) {
+    return value
+  }
+
+  if (Array.isArray(value)) {
+    return value.map((item) => filterHiddenOutputKeys(item))
+  }
+
+  if (typeof value === 'object') {
+    const filtered: Record<string, unknown> = {}
+    for (const [key, val] of Object.entries(value as Record<string, unknown>)) {
+      if (HIDDEN_OUTPUT_KEYS.has(key)) {
+        continue
+      }
+      filtered[key] = filterHiddenOutputKeys(val)
+    }
+    return filtered
+  }
+
+  return value
+}
+
 function isSyntheticWorkflowWrapper(span: TraceSpan | undefined): boolean {
   if (!span || span.type !== 'workflow') return false
   return !span.blockId
@@ -21,43 +54,17 @@ function flattenWorkflowChildren(spans: TraceSpan[]): TraceSpan[] {
       return
     }
 
-    const processedSpan = ensureNestedWorkflowsProcessed(span)
+    // Recursively process children - spans are already clean from buildTraceSpans
+    const processedSpan: TraceSpan = {
+      ...span,
+      children: Array.isArray(span.children) ? flattenWorkflowChildren(span.children) : undefined,
+    }
     flattened.push(processedSpan)
   })
 
   return flattened
 }
 
-function getTraceSpanKey(span: TraceSpan): string {
-  if (span.id) {
-    return span.id
-  }
-
-  const name = span.name || 'span'
-  const start = span.startTime || 'unknown-start'
-  const end = span.endTime || 'unknown-end'
-
-  return `${name}|${start}|${end}`
-}
-
-function mergeTraceSpanChildren(...childGroups: TraceSpan[][]): TraceSpan[] {
-  const merged: TraceSpan[] = []
-  const seen = new Set<string>()
-
-  childGroups.forEach((group) => {
-    group.forEach((child) => {
-      const key = getTraceSpanKey(child)
-      if (seen.has(key)) {
-        return
-      }
-      seen.add(key)
-      merged.push(child)
-    })
-  })
-
-  return merged
-}
-
 export function buildTraceSpans(result: ExecutionResult): {
   traceSpans: TraceSpan[]
   totalDuration: number
@@ -332,7 +339,7 @@ export function buildTraceSpans(result: ExecutionResult): {
 
       if (childTraceSpans) {
         const flattenedChildren = flattenWorkflowChildren(childTraceSpans)
-        span.children = mergeTraceSpanChildren(span.children || [], flattenedChildren)
+        span.children = flattenedChildren
 
         // Clean childTraceSpans from output if present
         if (span.output && typeof span.output === 'object' && 'childTraceSpans' in span.output) {
@@ -741,47 +748,3 @@ function groupIterationBlocks(spans: TraceSpan[]): TraceSpan[] {
 
   return result
 }
-
-function ensureNestedWorkflowsProcessed(span: TraceSpan): TraceSpan {
-  const processedSpan: TraceSpan = { ...span }
-
-  if (processedSpan.output && typeof processedSpan.output === 'object') {
-    processedSpan.output = { ...processedSpan.output }
-  }
-
-  const normalizedChildren = Array.isArray(span.children)
-    ? span.children.map((child) => ensureNestedWorkflowsProcessed(child))
-    : []
-
-  const outputChildSpans = (() => {
-    if (!processedSpan.output || typeof processedSpan.output !== 'object') {
-      return [] as TraceSpan[]
-    }
-
-    const maybeChildSpans = (processedSpan.output as { childTraceSpans?: TraceSpan[] })
-      .childTraceSpans
-    if (!Array.isArray(maybeChildSpans) || maybeChildSpans.length === 0) {
-      return [] as TraceSpan[]
-    }
-
-    return flattenWorkflowChildren(maybeChildSpans)
-  })()
-
-  const mergedChildren = mergeTraceSpanChildren(normalizedChildren, outputChildSpans)
-
-  if (
-    processedSpan.output &&
-    typeof processedSpan.output === 'object' &&
-    processedSpan.output !== null &&
-    'childTraceSpans' in processedSpan.output
-  ) {
-    const { childTraceSpans, ...cleanOutput } = processedSpan.output as {
-      childTraceSpans?: TraceSpan[]
-    } & Record<string, unknown>
-    processedSpan.output = cleanOutput
-  }
-
-  processedSpan.children = mergedChildren.length > 0 ? mergedChildren : undefined
-
-  return processedSpan
-}