sanitize workflow output logs

Author: Bill Leoutsakos

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

@@ -73,6 +73,7 @@ vi.mock('@/lib/logs/execution/logging-factory', () => ({
 }))
 
 import { calculateCostSummary } from '@/lib/logs/execution/logging-factory'
+import { createEnvironmentSecretSanitizer } from '@/executor/utils/environment-secret-sanitizer'
 import { LoggingSession } from './logging-session'
 
 afterAll(resetDbChainMock)
@@ -268,6 +269,123 @@ describe('LoggingSession completion retries', () => {
     )
   })
 
+  it('sanitizes workflow output and final trace spans without mutating runtime values', async () => {
+    const session = new LoggingSession('workflow-1', 'execution-safe', 'api', 'req-1')
+    const secret = 'sk-demo / trace?token=7f3a91'
+    const rawFinalOutput = {
+      result: {
+        resolvedAtRuntime: true,
+        echoed: `prefix:${secret}:suffix`,
+        encoded: encodeURIComponent(secret),
+        ordinary: 'us-east-1',
+      },
+    }
+    const rawTraceSpans = [
+      {
+        id: 'span-safe',
+        name: 'Function',
+        type: 'function',
+        duration: 1,
+        startTime: '2026-07-01T00:00:00.000Z',
+        endTime: '2026-07-01T00:00:00.001Z',
+        status: 'success',
+        output: { echoed: secret },
+      },
+    ]
+
+    session.setEnvironmentSecretSanitizer(
+      createEnvironmentSecretSanitizer(
+        { code: 'return "{{OPENAI_API_KEY}}"' },
+        {
+          OPENAI_API_KEY: secret,
+          UNREFERENCED_REGION: 'us-east-1',
+        }
+      )
+    )
+    completeWorkflowExecutionMock.mockResolvedValue({})
+
+    await session.safeComplete({
+      finalOutput: rawFinalOutput,
+      traceSpans: rawTraceSpans as any,
+    })
+
+    expect(completeWorkflowExecutionMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        finalOutput: {
+          result: {
+            resolvedAtRuntime: true,
+            echoed: 'prefix:{{OPENAI_API_KEY}}:suffix',
+            encoded: '{{OPENAI_API_KEY}}',
+            ordinary: 'us-east-1',
+          },
+        },
+        traceSpans: [
+          expect.objectContaining({
+            output: { echoed: '{{OPENAI_API_KEY}}' },
+          }),
+        ],
+      })
+    )
+    expect(rawFinalOutput.result.echoed).toBe(`prefix:${secret}:suffix`)
+    expect(rawTraceSpans[0].output.echoed).toBe(secret)
+    expect(calculateCostSummary).toHaveBeenCalledWith(rawTraceSpans)
+  })
+
+  it('sanitizes synthetic workflow errors and completion failure metadata', async () => {
+    const session = new LoggingSession('workflow-1', 'execution-error-safe', 'api', 'req-1')
+    const secret = 'sk-demo-error-7f3a91'
+
+    session.setEnvironmentSecretSanitizer(
+      createEnvironmentSecretSanitizer(
+        { code: 'throw new Error("{{OPENAI_API_KEY}}")' },
+        { OPENAI_API_KEY: secret }
+      )
+    )
+    completeWorkflowExecutionMock.mockResolvedValue({})
+
+    await session.safeCompleteWithError({
+      error: { message: `Function failed with ${secret}` },
+    })
+
+    expect(completeWorkflowExecutionMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        finalOutput: { error: 'Function failed with {{OPENAI_API_KEY}}' },
+        traceSpans: [
+          expect.objectContaining({
+            output: { error: 'Function failed with {{OPENAI_API_KEY}}' },
+          }),
+        ],
+        completionFailure: 'Function failed with {{OPENAI_API_KEY}}',
+      })
+    )
+  })
+
+  it('keeps workflow output sanitized when completion falls back to cost-only persistence', async () => {
+    const session = new LoggingSession('workflow-1', 'execution-fallback-safe', 'api', 'req-1')
+    const secret = 'sk-demo-fallback-7f3a91'
+
+    session.setEnvironmentSecretSanitizer(
+      createEnvironmentSecretSanitizer(
+        { code: 'return "{{OPENAI_API_KEY}}"' },
+        { OPENAI_API_KEY: secret }
+      )
+    )
+    completeWorkflowExecutionMock
+      .mockRejectedValueOnce(new Error('primary persistence failed'))
+      .mockResolvedValueOnce({})
+
+    await session.safeComplete({
+      finalOutput: { echoed: secret },
+    })
+
+    expect(completeWorkflowExecutionMock).toHaveBeenLastCalledWith(
+      expect.objectContaining({
+        finalOutput: { echoed: '{{OPENAI_API_KEY}}' },
+        finalizationPath: 'fallback_completed',
+      })
+    )
+  })
+
   it('derives fallback cost from trace spans when the primary completion fails', async () => {
     const session = new LoggingSession('workflow-1', 'execution-6', 'api', 'req-1') as any
 

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

@@ -30,6 +30,7 @@ import type {
   WorkflowState,
 } from '@/lib/logs/types'
 import type { SerializableExecutionState } from '@/executor/execution/types'
+import type { EnvironmentSecretSanitizer } from '@/executor/utils/environment-secret-sanitizer'
 
 type TriggerData = Record<string, unknown> & {
   correlation?: NonNullable<ExecutionTrigger['data']>['correlation']
@@ -86,6 +87,8 @@ const logger = createLogger('LoggingSession')
 
 type CompletionAttempt = 'complete' | 'error' | 'cancelled' | 'paused'
 
+const identityEnvironmentSecretSanitizer: EnvironmentSecretSanitizer = <T>(value: T): T => value
+
 export interface SessionStartParams {
   userId?: string
   /** Explicit initiating actor for callers that do not populate `userId`. */
@@ -155,6 +158,8 @@ export class LoggingSession {
   private completionAttemptFailed = false
   private pendingProgressWrites = new Set<Promise<void>>()
   private postExecutionPromise: Promise<void> | null = null
+  private environmentSecretSanitizer: EnvironmentSecretSanitizer =
+    identityEnvironmentSecretSanitizer
 
   constructor(
     workflowId: string,
@@ -170,6 +175,19 @@ export class LoggingSession {
     this.requestId = requestId
   }
 
+  /**
+   * Installs the workflow-scoped sanitizer used only for persisted and emitted
+   * observability values. The closure is retained in memory for this session
+   * and is never added to execution data.
+   */
+  setEnvironmentSecretSanitizer(sanitizer: EnvironmentSecretSanitizer): void {
+    this.environmentSecretSanitizer = sanitizer
+  }
+
+  private sanitizeForLog<T>(value: T): T {
+    return this.environmentSecretSanitizer(value)
+  }
+
   async onBlockStart(
     blockId: string,
     blockName: string,
@@ -287,17 +305,24 @@ export class LoggingSession {
     level?: 'info' | 'error'
     status?: 'completed' | 'failed' | 'cancelled' | 'pending'
   }): Promise<void> {
+    const finalOutput = this.sanitizeForLog(params.finalOutput)
+    const traceSpans = this.sanitizeForLog(params.traceSpans)
+    const completionFailure =
+      params.completionFailure === undefined
+        ? undefined
+        : this.sanitizeForLog(params.completionFailure)
+
     await executionLogger.completeWorkflowExecution({
       executionId: this.executionId,
       endedAt: params.endedAt,
       totalDurationMs: params.totalDurationMs,
       costSummary: params.costSummary,
-      finalOutput: params.finalOutput,
-      traceSpans: params.traceSpans,
+      finalOutput,
+      traceSpans,
       workflowInput: params.workflowInput,
       executionState: params.executionState,
       finalizationPath: params.finalizationPath,
-      completionFailure: params.completionFailure,
+      completionFailure,
       isResume: this.isResume,
       level: params.level,
       status: params.status,
@@ -403,34 +428,36 @@ export class LoggingSession {
     }
     this.completing = true
 
-    const { endedAt, totalDurationMs, finalOutput, traceSpans, workflowInput, executionState } =
-      params
+    const { endedAt, totalDurationMs, workflowInput, executionState } = params
+    const finalOutput = this.sanitizeForLog(params.finalOutput || {})
+    const rawTraceSpans = params.traceSpans || []
+    const traceSpans = this.sanitizeForLog(rawTraceSpans)
 
     try {
-      const costSummary = calculateCostSummary(traceSpans || [])
+      const costSummary = calculateCostSummary(rawTraceSpans)
       const endTime = endedAt || new Date().toISOString()
       const duration = totalDurationMs || 0
 
       await this.completeExecutionWithFinalization({
         endedAt: endTime,
         totalDurationMs: duration,
         costSummary,
-        finalOutput: finalOutput || {},
-        traceSpans: traceSpans || [],
+        finalOutput,
+        traceSpans,
         workflowInput,
         executionState,
         finalizationPath: 'completed',
       })
 
       this.completed = true
 
-      if (traceSpans && traceSpans.length > 0) {
+      if (traceSpans.length > 0) {
         try {
           const { PlatformEvents, createOTelSpansForWorkflowExecution } = await import(
             '@/lib/core/telemetry'
           )
 
-          const hasErrors = traceSpans.some((span: any) => {
+          const hasErrors = rawTraceSpans.some((span: any) => {
             const checkForErrors = (s: any): boolean => {
               if (s.status === 'error' && !s.errorHandled) return true
               if (s.children && Array.isArray(s.children)) {
@@ -506,13 +533,15 @@ export class LoggingSession {
         return
       }
 
-      const { endedAt, totalDurationMs, error, traceSpans, skipCost } = params
+      const { endedAt, totalDurationMs, error, skipCost } = params
+      const rawTraceSpans = params.traceSpans || []
+      const traceSpans = this.sanitizeForLog(rawTraceSpans)
 
       const endTime = endedAt ? new Date(endedAt) : new Date()
       const durationMs = typeof totalDurationMs === 'number' ? totalDurationMs : 0
       const startTime = new Date(endTime.getTime() - Math.max(1, durationMs))
 
-      const hasProvidedSpans = Array.isArray(traceSpans) && traceSpans.length > 0
+      const hasProvidedSpans = traceSpans.length > 0
 
       // calculateCostSummary([]) / (undefined) already returns the base-charge
       // summary, so the no-spans branch needs no separate literal.
@@ -528,9 +557,9 @@ export class LoggingSession {
             models: {},
             charges: {},
           }
-        : calculateCostSummary(traceSpans)
+        : calculateCostSummary(rawTraceSpans)
 
-      const message = error?.message || 'Run failed before starting blocks'
+      const message = this.sanitizeForLog(error?.message || 'Run failed before starting blocks')
 
       const errorSpan: TraceSpan = {
         id: 'workflow-error-root',
@@ -615,7 +644,9 @@ export class LoggingSession {
     this.completing = true
 
     try {
-      const { endedAt, totalDurationMs, traceSpans } = params
+      const { endedAt, totalDurationMs } = params
+      const rawTraceSpans = params.traceSpans || []
+      const traceSpans = this.sanitizeForLog(rawTraceSpans)
 
       const endTime = endedAt ? new Date(endedAt) : new Date()
       const durationMs = typeof totalDurationMs === 'number' ? totalDurationMs : 0
@@ -639,14 +670,14 @@ export class LoggingSession {
 
       // calculateCostSummary handles empty/undefined spans by returning the
       // base-charge summary, so no separate no-spans literal is needed.
-      const costSummary = calculateCostSummary(traceSpans)
+      const costSummary = calculateCostSummary(rawTraceSpans)
 
       await this.completeExecutionWithFinalization({
         endedAt: endTime.toISOString(),
         totalDurationMs: Math.max(1, durationMs),
         costSummary,
         finalOutput: { cancelled: true },
-        traceSpans: traceSpans || [],
+        traceSpans,
         finalizationPath: 'cancelled',
         status: 'cancelled',
       })
@@ -662,11 +693,11 @@ export class LoggingSession {
           durationMs: Math.max(1, durationMs),
           status: 'cancelled',
           trigger: this.triggerType,
-          blocksExecuted: traceSpans?.length || 0,
+          blocksExecuted: traceSpans.length,
           hasErrors: false,
         })
 
-        if (traceSpans && traceSpans.length > 0) {
+        if (traceSpans.length > 0) {
           const startTime = new Date(endTime.getTime() - Math.max(1, durationMs))
           createOTelSpansForWorkflowExecution({
             workflowId: this.workflowId,
@@ -709,7 +740,9 @@ export class LoggingSession {
     this.completing = true
 
     try {
-      const { endedAt, totalDurationMs, traceSpans, workflowInput } = params
+      const { endedAt, totalDurationMs, workflowInput } = params
+      const rawTraceSpans = params.traceSpans || []
+      const traceSpans = this.sanitizeForLog(rawTraceSpans)
 
       const endTime = endedAt ? new Date(endedAt) : new Date()
       const durationMs = typeof totalDurationMs === 'number' ? totalDurationMs : 0
@@ -733,14 +766,14 @@ export class LoggingSession {
 
       // calculateCostSummary handles empty/undefined spans by returning the
       // base-charge summary, so no separate no-spans literal is needed.
-      const costSummary = calculateCostSummary(traceSpans)
+      const costSummary = calculateCostSummary(rawTraceSpans)
 
       await this.completeExecutionWithFinalization({
         endedAt: endTime.toISOString(),
         totalDurationMs: Math.max(1, durationMs),
         costSummary,
         finalOutput: { paused: true },
-        traceSpans: traceSpans || [],
+        traceSpans,
         workflowInput,
         finalizationPath: 'paused',
         status: 'pending',
@@ -757,12 +790,12 @@ export class LoggingSession {
           durationMs: Math.max(1, durationMs),
           status: 'paused',
           trigger: this.triggerType,
-          blocksExecuted: traceSpans?.length || 0,
+          blocksExecuted: traceSpans.length,
           hasErrors: false,
           totalCost: costSummary.totalCost || 0,
         })
 
-        if (traceSpans && traceSpans.length > 0) {
+        if (traceSpans.length > 0) {
           const startTime = new Date(endTime.getTime() - Math.max(1, durationMs))
           createOTelSpansForWorkflowExecution({
             workflowId: this.workflowId,