fix(logs): record how long a cancelled run had been going

A cancelled run got an end timestamp and no duration. Every other
terminal transition writes both — the completion path sets them together,
and a paused run already records its elapsed time — but cancellation
writes the log row directly rather than through completion, so it had no
in-memory duration to store and simply omitted the column.

That is not cosmetic. `GET /api/v2/logs` filters on `minDurationMs` and
`maxDurationMs`, and a null column drops the row out of every such query,
so cancellations are invisible to exactly the searches someone runs when
investigating cancellations. The published contract also says the end
timestamp is null only while a run is active, which a cancelled run
is not.

Both cancellation writes now derive the duration in the same statement
from the row's own `started_at`, through one shared expression so the two
cannot drift apart the way they did from the completion path. The end
instant is computed once and reused, so the stamped end and the derived
duration describe the same moment rather than two clock reads.

The instant is bound as an explicit `timestamp` rather than a `Date`:
`started_at` is `timestamp without time zone` holding a UTC wall clock,
and a driver-bound date would infer `timestamptz` and make the interval
depend on the session zone. The floor of one millisecond matches the
completion path, so a run cancelled inside its first millisecond still
records that it ran.

Author: waleedlatif1

apps/sim/lib/execution/cancel-workflow-execution.test.ts

@@ -281,4 +281,17 @@ describe('cancelWorkflowExecution', () => {
     expect(mockPublishWorkflowGroupCancellationEvent).not.toHaveBeenCalled()
     expect(mockUpdateSet).toHaveBeenCalledWith(expect.objectContaining({ status: 'cancelled' }))
   })
+
+  /**
+   * A cancelled run is terminal, so it owes the same two fields every other
+   * terminal write records. Without the duration it is invisible to the
+   * `minDurationMs`/`maxDurationMs` filters on `GET /api/v2/logs`.
+   */
+  it('records how long the cancelled run had been going, not just when it stopped', async () => {
+    await cancelWorkflowExecution(INPUT)
+
+    const [values] = mockUpdateSet.mock.calls.at(-1) as [Record<string, unknown>]
+    expect(values.endedAt).toBeInstanceOf(Date)
+    expect(values.totalDurationMs).toBeDefined()
+  })
 })

apps/sim/lib/execution/cancel-workflow-execution.ts

@@ -12,6 +12,7 @@ import {
 } from '@/lib/execution/cancellation'
 import { createExecutionEventWriter, readExecutionMetaState } from '@/lib/execution/event-buffer'
 import { abortManualExecution } from '@/lib/execution/manual-cancellation'
+import { elapsedDurationMsSql } from '@/lib/logs/execution/duration'
 import { captureServerEvent } from '@/lib/posthog/server'
 import {
   cancelWorkflowGroupExecution,
@@ -377,9 +378,14 @@ export async function cancelWorkflowExecution(
     !pausedCancelled
   ) {
     try {
+      const cancelledAt = new Date()
       await db
         .update(workflowExecutionLogs)
-        .set({ status: 'cancelled', endedAt: new Date() })
+        .set({
+          status: 'cancelled',
+          endedAt: cancelledAt,
+          totalDurationMs: elapsedDurationMsSql(cancelledAt),
+        })
         .where(
           and(
             eq(workflowExecutionLogs.executionId, executionId),

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

@@ -0,0 +1,52 @@
+/**
+ * @vitest-environment node
+ */
+
+// Renders the real expression against the real drizzle dialect and schema. It
+// is a raw `sql` template, so a rendering or type-cast bug only surfaces when
+// Postgres executes it — the global drizzle/schema mocks would hide it.
+import { describe, expect, it, vi } from 'vitest'
+
+vi.unmock('drizzle-orm')
+vi.unmock('@sim/db')
+vi.unmock('@sim/db/schema')
+
+process.env.DATABASE_URL ??= 'postgresql://user:pass@localhost:5432/test'
+
+const { PgDialect } = await import('drizzle-orm/pg-core')
+const { elapsedDurationMsSql } = await import('@/lib/logs/execution/duration')
+
+function render(endedAt: Date) {
+  return new PgDialect().sqlToQuery(elapsedDurationMsSql(endedAt))
+}
+
+describe('elapsedDurationMsSql', () => {
+  it('measures against the row started_at rather than a second clock read', () => {
+    const { sql } = render(new Date('2026-08-13T12:00:05.000Z'))
+
+    expect(sql).toContain('"started_at"')
+    expect(sql).not.toContain('now()')
+  })
+
+  /**
+   * `started_at` is `timestamp without time zone` holding a UTC wall clock. A
+   * driver-bound `Date` infers `timestamptz`, which would make the interval
+   * depend on the session zone; the explicit cast is what keeps it stable.
+   */
+  it('binds the end instant as a zone-free timestamp', () => {
+    const { sql, params } = render(new Date('2026-08-13T12:00:05.000Z'))
+
+    expect(sql).toContain('::timestamp')
+    expect(params).toEqual(['2026-08-13T12:00:05.000Z'])
+    expect(params.some((param) => Array.isArray(param))).toBe(false)
+  })
+
+  /** The column is `integer`, and a sub-millisecond run still ran. */
+  it('yields a whole number of milliseconds, floored at one', () => {
+    const { sql } = render(new Date('2026-08-13T12:00:05.000Z'))
+
+    expect(sql).toContain('GREATEST(1,')
+    expect(sql).toContain('ROUND(')
+    expect(sql).toContain('::integer')
+  })
+})

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

@@ -0,0 +1,25 @@
+import { workflowExecutionLogs } from '@sim/db/schema'
+import { type SQL, sql } from 'drizzle-orm'
+
+/**
+ * Elapsed run time for a terminal write that does not go through
+ * `completeWorkflowExecution`, expressed against the row's own `started_at`.
+ *
+ * Cancellation writes the log row directly rather than through the completion
+ * path, so it has no in-memory duration to store. Deriving it in the same
+ * statement keeps `ended_at` and `total_duration_ms` describing one instant,
+ * and keeps a cancelled run visible to the duration filters on
+ * `GET /api/v2/logs` — a null there reads as "no duration recorded" and drops
+ * the run out of every `minDurationMs`/`maxDurationMs` query.
+ *
+ * `ended_at` is bound as an explicit `timestamp` rather than a `Date`, because
+ * `started_at` is `timestamp without time zone` holding a UTC wall clock: an
+ * ISO string casts to the same naive reading, while a driver-bound `Date`
+ * would infer `timestamptz` and make the interval depend on the session zone.
+ *
+ * Floored at 1ms to match `completeWorkflowExecution`, so a cancellation that
+ * lands inside the same millisecond as the start still records that it ran.
+ */
+export function elapsedDurationMsSql(endedAt: Date): SQL<number> {
+  return sql<number>`GREATEST(1, ROUND(EXTRACT(EPOCH FROM (${endedAt.toISOString()}::timestamp - ${workflowExecutionLogs.startedAt})) * 1000))::integer`
+}

apps/sim/lib/table/workflow-group-cancellation.test.ts

@@ -218,9 +218,15 @@ describe('cancelWorkflowGroupExecution', () => {
     })
 
     expect(dbChainMockFns.update).toHaveBeenCalledOnce()
+    /**
+     * `totalDurationMs` is derived in-statement from the row's `started_at`, so
+     * a cancelled run carries the duration every other terminal write records
+     * and stays visible to the `/api/v2/logs` duration filters.
+     */
     expect(dbChainMockFns.set).toHaveBeenCalledWith({
       status: 'cancelled',
       endedAt: expect.any(Date),
+      totalDurationMs: expect.anything(),
       executionDeadlineAt: null,
     })
     const logUpdateValues = collectConditionValues(dbChainMockFns.where.mock.calls[2]?.[0])

apps/sim/lib/table/workflow-group-cancellation.ts

@@ -3,6 +3,7 @@ import { tableRowExecutions, userTableDefinitions, workflowExecutionLogs } from
 import { createLogger } from '@sim/logger'
 import { toError } from '@sim/utils/errors'
 import { and, eq, inArray } from 'drizzle-orm'
+import { elapsedDurationMsSql } from '@/lib/logs/execution/duration'
 import { appendTableEvent } from '@/lib/table/events'
 
 const logger = createLogger('WorkflowGroupCancellation')
@@ -149,9 +150,15 @@ export async function cancelWorkflowGroupExecution(
         return { result: { kind: 'already_cancelled_without_sidecar' } as const }
       }
 
+      const cancelledAt = new Date()
       const [cancelledLog] = await tx
         .update(workflowExecutionLogs)
-        .set({ status: 'cancelled', endedAt: new Date(), executionDeadlineAt: null })
+        .set({
+          status: 'cancelled',
+          endedAt: cancelledAt,
+          totalDurationMs: elapsedDurationMsSql(cancelledAt),
+          executionDeadlineAt: null,
+        })
         .where(
           and(
             eq(workflowExecutionLogs.workspaceId, options.workspaceId),