fix storage write context

Author: icecrasher321

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

@@ -715,8 +715,10 @@ const TraceDetailPane = memo(function TraceDetailPane({ span }: { span: TraceSpa
   if (cacheRead) metaEntries.push({ label: 'Cache read', value: cacheRead })
   if (cacheWrite) metaEntries.push({ label: 'Cache write', value: cacheWrite })
   if (reasoning) metaEntries.push({ label: 'Reasoning tokens', value: reasoning })
-  const costTotal = formatCostAmount(span.cost?.total)
-  if (costTotal) metaEntries.push({ label: 'Cost', value: costTotal })
+  // Per-span cost is intentionally not shown: cost lives only in the usage_log
+  // ledger (the authoritative, multiplier-inclusive run total drives the header
+  // chip). Persisted spans are cost-stripped, so a per-span row would render on
+  // live runs but vanish on reload — show one consistent total instead.
   if (span.errorType) metaEntries.push({ label: 'Error type', value: span.errorType })
   if (span.iterationIndex !== undefined)
     metaEntries.push({ label: 'Iteration', value: String(span.iterationIndex + 1) })

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

@@ -738,14 +738,22 @@ export class ExecutionLogger implements IExecutionLoggerService {
 
     stripSpanCosts((completedExecutionData as Record<string, unknown>).traceSpans)
 
-    const storedExecutionData = await externalizeExecutionData(
-      completedExecutionData as Record<string, unknown>,
-      {
+    // Externalization requires the execution owner (workspace_files.user_id is
+    // NOT NULL). billingUserId comes from environment.userId and is effectively
+    // always present for a real run; if it's somehow absent, keep data inline.
+    let storedExecutionData = completedExecutionData as Record<string, unknown>
+    if (billingUserId) {
+      storedExecutionData = await externalizeExecutionData(storedExecutionData, {
         workspaceId: existingLog?.workspaceId ?? null,
         workflowId: existingLog?.workflowId ?? null,
         executionId,
-      }
-    )
+        userId: billingUserId,
+      })
+    } else {
+      execLog.warn('Skipping execution-data externalization: missing owner userId', {
+        executionId,
+      })
+    }
     const completedExecutionLargeValueKeys = collectLargeValueReferenceKeys(storedExecutionData)
 
     const updatedLog = await db.transaction(async (tx) => {

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

@@ -22,12 +22,26 @@ export const TRACE_STORE_REF_KEY = 'traceStoreRef'
  */
 const INLINE_MARKER_KEYS = ['hasTraceSpans', 'traceSpanCount'] as const
 
-interface TraceStoreContext {
+/**
+ * Read-path context. Resolves an externalized payload by storage key, authorized
+ * via the (already-authorized) workspace — no owner needed.
+ */
+interface TraceStoreReadContext {
   workspaceId: string | null
   workflowId: string | null
   executionId: string
 }
 
+/**
+ * Write-path context. Requires the execution owner's `userId`: the externalized
+ * object is tracked in `workspace_files`, whose `user_id` column is NOT NULL
+ * (FK -> user.id). Requiring it here makes "a write needs an owner" a
+ * compile-time invariant, so callers must resolve the owner before persisting.
+ */
+interface TraceStoreWriteContext extends TraceStoreReadContext {
+  userId: string
+}
+
 /**
  * Recovers the workflowId embedded in a large-value storage key
  * (`execution/{workspaceId}/{workflowId}/{executionId}/<file>`). Used when the
@@ -66,10 +80,14 @@ export function stripSpanCosts(spans: unknown): void {
  */
 export async function externalizeExecutionData(
   executionData: Record<string, unknown>,
-  context: TraceStoreContext
+  context: TraceStoreWriteContext
 ): Promise<Record<string, unknown>> {
-  const { workspaceId, workflowId, executionId } = context
-  if (!workspaceId || !workflowId) return executionData
+  const { workspaceId, workflowId, executionId, userId } = context
+  // workspaceId/workflowId build the storage key and can be null for
+  // deleted-workflow rows. userId is type-guaranteed by TraceStoreWriteContext;
+  // the falsy check is a defensive guard against an empty string. If any are
+  // missing the durable write can't succeed, so keep the data inline.
+  if (!workspaceId || !workflowId || !userId) return executionData
 
   try {
     const json = JSON.stringify(executionData)
@@ -82,6 +100,7 @@ export async function externalizeExecutionData(
       workspaceId,
       workflowId,
       executionId,
+      userId,
       requireDurable: true,
     })
 
@@ -111,7 +130,7 @@ export async function externalizeExecutionData(
  */
 export async function materializeExecutionData(
   executionData: Record<string, unknown> | null | undefined,
-  context: TraceStoreContext
+  context: TraceStoreReadContext
 ): Promise<Record<string, unknown>> {
   if (!executionData) return {}
 

apps/sim/scripts/backfill-trace-spans.ts

@@ -174,10 +174,20 @@ async function backfillTraceStorage(
         executionData.hasTraceSpans = traceSpanCount > 0
         executionData.traceSpanCount = traceSpanCount
         stripSpanCosts(executionData.traceSpans)
+        // workspace_files.user_id (NOT NULL) needs the execution owner; legacy
+        // rows carry it under executionData.environment.userId. Rows without an
+        // owner can't be externalized — count them as failed and skip.
+        const environment = executionData.environment as { userId?: string } | undefined
+        const ownerUserId = environment?.userId
+        if (!ownerUserId) {
+          failed++
+          continue
+        }
         const slim = await externalizeExecutionData(executionData, {
           workspaceId: row.workspaceId,
           workflowId: row.workflowId,
           executionId: row.executionId,
+          userId: ownerUserId,
         })
 
         if (!(TRACE_STORE_REF_KEY in slim)) {