chore: import upstream snapshot with attribution

apps/sim/app/api/logs/[id]/route.ts

@@ -0,0 +1,39 @@
+import { createLogger } from '@sim/logger'
+import { type NextRequest, NextResponse } from 'next/server'
+import { getLogDetailContract } from '@/lib/api/contracts/logs'
+import { parseRequest } from '@/lib/api/server'
+import { checkSessionOrInternalAuth } from '@/lib/auth/hybrid'
+import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
+import { fetchLogDetail } from '@/lib/logs/fetch-log-detail'
+
+const logger = createLogger('LogDetailsByIdAPI')
+
+export const GET = withRouteHandler(
+  async (request: NextRequest, context: { params: Promise<{ id: string }> }) => {
+    const authResult = await checkSessionOrInternalAuth(request, { requireWorkflowId: false })
+    if (!authResult.success || !authResult.userId) {
+      return NextResponse.json(
+        { error: authResult.error || 'Authentication required' },
+        { status: 401 }
+      )
+    }
+
+    const parsed = await parseRequest(getLogDetailContract, request, context)
+    if (!parsed.success) return parsed.response
+
+    const { id } = parsed.data.params
+    const { workspaceId } = parsed.data.query
+
+    const data = await fetchLogDetail({
+      userId: authResult.userId,
+      workspaceId,
+      lookupColumn: 'id',
+      lookupValue: id,
+    })
+
+    if (!data) return NextResponse.json({ error: 'Not found' }, { status: 404 })
+
+    logger.debug('Fetched log detail', { id, workspaceId })
+    return NextResponse.json({ data })
+  }
+)

apps/sim/app/api/logs/by-execution/[executionId]/route.ts

@@ -0,0 +1,39 @@
+import { createLogger } from '@sim/logger'
+import { type NextRequest, NextResponse } from 'next/server'
+import { getLogByExecutionIdContract } from '@/lib/api/contracts/logs'
+import { parseRequest } from '@/lib/api/server'
+import { checkSessionOrInternalAuth } from '@/lib/auth/hybrid'
+import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
+import { fetchLogDetail } from '@/lib/logs/fetch-log-detail'
+
+const logger = createLogger('LogDetailsByExecutionAPI')
+
+export const GET = withRouteHandler(
+  async (request: NextRequest, context: { params: Promise<{ executionId: string }> }) => {
+    const authResult = await checkSessionOrInternalAuth(request, { requireWorkflowId: false })
+    if (!authResult.success || !authResult.userId) {
+      return NextResponse.json(
+        { error: authResult.error || 'Authentication required' },
+        { status: 401 }
+      )
+    }
+
+    const parsed = await parseRequest(getLogByExecutionIdContract, request, context)
+    if (!parsed.success) return parsed.response
+
+    const { executionId } = parsed.data.params
+    const { workspaceId } = parsed.data.query
+
+    const data = await fetchLogDetail({
+      userId: authResult.userId,
+      workspaceId,
+      lookupColumn: 'executionId',
+      lookupValue: executionId,
+    })
+
+    if (!data) return NextResponse.json({ error: 'Not found' }, { status: 404 })
+
+    logger.debug('Fetched log by execution id', { executionId, workspaceId })
+    return NextResponse.json({ data })
+  }
+)

apps/sim/app/api/logs/cleanup/route.ts

@@ -0,0 +1,25 @@
+import { createLogger } from '@sim/logger'
+import { type NextRequest, NextResponse } from 'next/server'
+import { verifyCronAuth } from '@/lib/auth/internal'
+import { dispatchCleanupJobs } from '@/lib/billing/cleanup-dispatcher'
+import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
+
+export const dynamic = 'force-dynamic'
+
+const logger = createLogger('LogsCleanupAPI')
+
+export const GET = withRouteHandler(async (request: NextRequest) => {
+  try {
+    const authError = verifyCronAuth(request, 'logs cleanup')
+    if (authError) return authError
+
+    const result = await dispatchCleanupJobs('cleanup-logs')
+
+    logger.info('Log cleanup jobs dispatched', result)
+
+    return NextResponse.json({ triggered: true, ...result })
+  } catch (error) {
+    logger.error('Failed to dispatch log cleanup jobs:', { error })
+    return NextResponse.json({ error: 'Failed to dispatch log cleanup' }, { status: 500 })
+  }
+})

apps/sim/app/api/logs/execution/[executionId]/route.ts

@@ -0,0 +1,181 @@
+import { db } from '@sim/db'
+import {
+  jobExecutionLogs,
+  workflow,
+  workflowExecutionLogs,
+  workflowExecutionSnapshots,
+} from '@sim/db/schema'
+import { createLogger } from '@sim/logger'
+import { eq, inArray } from 'drizzle-orm'
+import { type NextRequest, NextResponse } from 'next/server'
+import { executionIdParamsSchema } from '@/lib/api/contracts/logs'
+import { checkSessionOrInternalAuth } from '@/lib/auth/hybrid'
+import { generateRequestId } from '@/lib/core/utils/request'
+import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
+import { materializeExecutionData } from '@/lib/logs/execution/trace-store'
+import type { TraceSpan, WorkflowExecutionLog } from '@/lib/logs/types'
+import { checkWorkspaceAccess } from '@/lib/workspaces/permissions/utils'
+
+const logger = createLogger('LogsByExecutionIdAPI')
+
+export const GET = withRouteHandler(
+  async (request: NextRequest, { params }: { params: Promise<{ executionId: string }> }) => {
+    const requestId = generateRequestId()
+
+    try {
+      const { executionId } = executionIdParamsSchema.parse(await params)
+
+      const authResult = await checkSessionOrInternalAuth(request, { requireWorkflowId: false })
+      if (!authResult.success || !authResult.userId) {
+        logger.warn(`[${requestId}] Unauthorized execution data access attempt for: ${executionId}`)
+        return NextResponse.json(
+          { error: authResult.error || 'Authentication required' },
+          { status: 401 }
+        )
+      }
+
+      const authenticatedUserId = authResult.userId
+
+      const [workflowLog] = await db
+        .select({
+          id: workflowExecutionLogs.id,
+          workflowId: workflowExecutionLogs.workflowId,
+          workspaceId: workflowExecutionLogs.workspaceId,
+          executionId: workflowExecutionLogs.executionId,
+          stateSnapshotId: workflowExecutionLogs.stateSnapshotId,
+          trigger: workflowExecutionLogs.trigger,
+          startedAt: workflowExecutionLogs.startedAt,
+          endedAt: workflowExecutionLogs.endedAt,
+          totalDurationMs: workflowExecutionLogs.totalDurationMs,
+          costTotal: workflowExecutionLogs.costTotal,
+          executionData: workflowExecutionLogs.executionData,
+        })
+        .from(workflowExecutionLogs)
+        .leftJoin(workflow, eq(workflowExecutionLogs.workflowId, workflow.id))
+        .where(eq(workflowExecutionLogs.executionId, executionId))
+        .limit(1)
+
+      if (
+        workflowLog &&
+        !(await checkWorkspaceAccess(workflowLog.workspaceId, authenticatedUserId)).hasAccess
+      ) {
+        logger.warn(`[${requestId}] Execution access denied: ${executionId}`)
+        return NextResponse.json({ error: 'Workflow execution not found' }, { status: 404 })
+      }
+
+      // Fallback: check job_execution_logs
+      if (!workflowLog) {
+        const [jobLog] = await db
+          .select({
+            id: jobExecutionLogs.id,
+            workspaceId: jobExecutionLogs.workspaceId,
+            executionId: jobExecutionLogs.executionId,
+            trigger: jobExecutionLogs.trigger,
+            startedAt: jobExecutionLogs.startedAt,
+            endedAt: jobExecutionLogs.endedAt,
+            totalDurationMs: jobExecutionLogs.totalDurationMs,
+            cost: jobExecutionLogs.cost,
+            executionData: jobExecutionLogs.executionData,
+          })
+          .from(jobExecutionLogs)
+          .where(eq(jobExecutionLogs.executionId, executionId))
+          .limit(1)
+
+        if (
+          !jobLog ||
+          !(await checkWorkspaceAccess(jobLog.workspaceId, authenticatedUserId)).hasAccess
+        ) {
+          logger.warn(`[${requestId}] Execution not found or access denied: ${executionId}`)
+          return NextResponse.json({ error: 'Workflow execution not found' }, { status: 404 })
+        }
+
+        return NextResponse.json({
+          executionId,
+          workflowId: null,
+          workflowState: null,
+          childWorkflowSnapshots: {},
+          executionMetadata: {
+            trigger: jobLog.trigger,
+            startedAt: jobLog.startedAt.toISOString(),
+            endedAt: jobLog.endedAt?.toISOString(),
+            totalDurationMs: jobLog.totalDurationMs,
+            cost: jobLog.cost || null,
+          },
+        })
+      }
+
+      const [snapshot] = await db
+        .select()
+        .from(workflowExecutionSnapshots)
+        .where(eq(workflowExecutionSnapshots.id, workflowLog.stateSnapshotId))
+        .limit(1)
+
+      if (!snapshot) {
+        logger.warn(
+          `[${requestId}] Workflow state snapshot not found for execution: ${executionId}`
+        )
+        return NextResponse.json({ error: 'Workflow state snapshot not found' }, { status: 404 })
+      }
+
+      const executionData = (await materializeExecutionData(
+        workflowLog.executionData as Record<string, unknown> | null,
+        {
+          workspaceId: workflowLog.workspaceId,
+          workflowId: workflowLog.workflowId,
+          executionId: workflowLog.executionId,
+        }
+      )) as WorkflowExecutionLog['executionData']
+      const traceSpans = (executionData?.traceSpans as TraceSpan[]) || []
+      const childSnapshotIds = new Set<string>()
+      const collectSnapshotIds = (spans: TraceSpan[]) => {
+        spans.forEach((span) => {
+          const snapshotId = span.childWorkflowSnapshotId
+          if (typeof snapshotId === 'string') {
+            childSnapshotIds.add(snapshotId)
+          }
+          if (span.children?.length) {
+            collectSnapshotIds(span.children)
+          }
+        })
+      }
+      if (traceSpans.length > 0) {
+        collectSnapshotIds(traceSpans)
+      }
+
+      const childWorkflowSnapshots =
+        childSnapshotIds.size > 0
+          ? await db
+              .select()
+              .from(workflowExecutionSnapshots)
+              .where(inArray(workflowExecutionSnapshots.id, Array.from(childSnapshotIds)))
+          : []
+
+      const childSnapshotMap = childWorkflowSnapshots.reduce<Record<string, unknown>>(
+        (acc, snap) => {
+          acc[snap.id] = snap.stateData
+          return acc
+        },
+        {}
+      )
+
+      const response = {
+        executionId,
+        workflowId: workflowLog.workflowId,
+        workflowState: snapshot.stateData,
+        childWorkflowSnapshots: childSnapshotMap,
+        executionMetadata: {
+          trigger: workflowLog.trigger,
+          startedAt: workflowLog.startedAt.toISOString(),
+          endedAt: workflowLog.endedAt?.toISOString(),
+          totalDurationMs: workflowLog.totalDurationMs,
+          cost: workflowLog.costTotal != null ? { total: Number(workflowLog.costTotal) } : null,
+        },
+      }
+
+      return NextResponse.json(response)
+    } catch (error) {
+      logger.error(`[${requestId}] Error fetching execution data:`, error)
+      return NextResponse.json({ error: 'Failed to fetch execution data' }, { status: 500 })
+    }
+  }
+)

apps/sim/app/api/logs/export/route.ts

@@ -0,0 +1,188 @@
+import { dbReplica } from '@sim/db'
+import { workflow, workflowExecutionLogs } from '@sim/db/schema'
+import { createLogger } from '@sim/logger'
+import { getErrorMessage } from '@sim/utils/errors'
+import { and, desc, eq, sql } from 'drizzle-orm'
+import { type NextRequest, NextResponse } from 'next/server'
+import { getSession } from '@/lib/auth'
+import { MATERIALIZE_CONCURRENCY, mapWithConcurrency } from '@/lib/core/utils/concurrency'
+import { neutralizeCsvFormula } from '@/lib/core/utils/csv'
+import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
+import { materializeExecutionData } from '@/lib/logs/execution/trace-store'
+import { buildFilterConditions, LogFilterParamsSchema } from '@/lib/logs/filters'
+import { expandFolderIdsWithDescendants } from '@/lib/logs/folder-expansion'
+import { checkWorkspaceAccess } from '@/lib/workspaces/permissions/utils'
+
+const logger = createLogger('LogsExportAPI')
+
+export const revalidate = 0
+
+function escapeCsv(value: any): string {
+  if (value === null || value === undefined) return ''
+  const str = typeof value === 'string' ? neutralizeCsvFormula(value) : String(value)
+  if (/[",\n]/.test(str)) {
+    return `"${str.replace(/"/g, '""')}"`
+  }
+  return str
+}
+
+export const GET = withRouteHandler(async (request: NextRequest) => {
+  try {
+    const session = await getSession()
+    if (!session?.user?.id) {
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+    }
+
+    const userId = session.user.id
+    const { searchParams } = new URL(request.url)
+    const params = LogFilterParamsSchema.parse(Object.fromEntries(searchParams.entries()))
+
+    const selectColumns = {
+      id: workflowExecutionLogs.id,
+      workflowId: workflowExecutionLogs.workflowId,
+      executionId: workflowExecutionLogs.executionId,
+      level: workflowExecutionLogs.level,
+      trigger: workflowExecutionLogs.trigger,
+      startedAt: workflowExecutionLogs.startedAt,
+      endedAt: workflowExecutionLogs.endedAt,
+      totalDurationMs: workflowExecutionLogs.totalDurationMs,
+      costTotal: workflowExecutionLogs.costTotal,
+      executionData: workflowExecutionLogs.executionData,
+      workflowName: sql<string>`COALESCE(${workflow.name}, 'Deleted Workflow')`,
+    }
+
+    if (params.folderIds) {
+      params.folderIds = await expandFolderIdsWithDescendants(params.workspaceId, params.folderIds)
+    }
+
+    const workspaceCondition = eq(workflowExecutionLogs.workspaceId, params.workspaceId)
+    const filterConditions = buildFilterConditions(params)
+    const conditions = filterConditions
+      ? and(workspaceCondition, filterConditions)
+      : workspaceCondition
+
+    const header = [
+      'startedAt',
+      'level',
+      'workflow',
+      'trigger',
+      'durationMs',
+      'costTotal',
+      'workflowId',
+      'executionId',
+      'message',
+      'traceSpans',
+    ].join(',')
+
+    const access = await checkWorkspaceAccess(params.workspaceId, userId)
+    if (!access.hasAccess) {
+      return new NextResponse(`${header}\n`, {
+        status: 200,
+        headers: {
+          'Content-Type': 'text/csv; charset=utf-8',
+          'Content-Disposition': 'attachment; filename="logs-export.csv"',
+          'Cache-Control': 'no-cache',
+        },
+      })
+    }
+
+    const encoder = new TextEncoder()
+    const stream = new ReadableStream<Uint8Array>({
+      start: async (controller) => {
+        controller.enqueue(encoder.encode(`${header}\n`))
+        const pageSize = 1000
+        let offset = 0
+        try {
+          while (true) {
+            const rows = await dbReplica
+              .select(selectColumns)
+              .from(workflowExecutionLogs)
+              .leftJoin(workflow, eq(workflowExecutionLogs.workflowId, workflow.id))
+              .where(conditions)
+              .orderBy(desc(workflowExecutionLogs.startedAt))
+              .limit(pageSize)
+              .offset(offset)
+
+            if (!rows.length) break
+
+            // Heavy execution data may live in object storage; materialize per
+            // row with bounded concurrency so a 1000-row page doesn't fan out
+            // into 1000 simultaneous reads.
+            const materialized = await mapWithConcurrency(
+              rows as any[],
+              MATERIALIZE_CONCURRENCY,
+              (r) =>
+                materializeExecutionData(r.executionData as Record<string, unknown> | null, {
+                  workspaceId: params.workspaceId,
+                  workflowId: r.workflowId,
+                  executionId: r.executionId,
+                })
+            )
+
+            for (let j = 0; j < rows.length; j++) {
+              const r = rows[j] as any
+              const ed = materialized[j] as Record<string, any>
+              // A single malformed/unserializable row must not abort the whole CSV
+              // stream — derive the message/trace columns defensively and fall back
+              // to empty on error so the row's metadata still exports.
+              let message = ''
+              let tracesJson = ''
+              try {
+                if (ed) {
+                  if (ed.finalOutput)
+                    message =
+                      typeof ed.finalOutput === 'string'
+                        ? ed.finalOutput
+                        : JSON.stringify(ed.finalOutput)
+                  if (ed.message) message = ed.message
+                  if (ed.traceSpans) tracesJson = JSON.stringify(ed.traceSpans)
+                }
+              } catch (rowError) {
+                logger.warn('Skipping unserializable execution data for export row', {
+                  executionId: r.executionId,
+                  error: getErrorMessage(rowError),
+                })
+              }
+              const line = [
+                escapeCsv(r.startedAt?.toISOString?.() || r.startedAt),
+                escapeCsv(r.level),
+                escapeCsv(r.workflowName),
+                escapeCsv(r.trigger),
+                escapeCsv(r.totalDurationMs ?? ''),
+                escapeCsv(r.costTotal ?? ''),
+                escapeCsv(r.workflowId ?? ''),
+                escapeCsv(r.executionId ?? ''),
+                escapeCsv(message),
+                escapeCsv(tracesJson),
+              ].join(',')
+              controller.enqueue(encoder.encode(`${line}\n`))
+            }
+
+            offset += pageSize
+          }
+          controller.close()
+        } catch (e: any) {
+          logger.error('Export stream error', { error: e?.message })
+          try {
+            controller.error(e)
+          } catch {}
+        }
+      },
+    })
+
+    const ts = new Date().toISOString().replace(/[:.]/g, '-')
+    const filename = `logs-${ts}.csv`
+
+    return new NextResponse(stream as any, {
+      status: 200,
+      headers: {
+        'Content-Type': 'text/csv; charset=utf-8',
+        'Content-Disposition': `attachment; filename="${filename}"`,
+        'Cache-Control': 'no-cache',
+      },
+    })
+  } catch (error: any) {
+    logger.error('Export error', { error: error?.message })
+    return NextResponse.json({ error: 'Internal server error' }, { status: 500 })
+  }
+})

apps/sim/app/api/logs/route.ts

@@ -0,0 +1,37 @@
+import { createLogger } from '@sim/logger'
+import type { NextRequest } from 'next/server'
+import { NextResponse } from 'next/server'
+import { listLogsContract } from '@/lib/api/contracts/logs'
+import { parseRequest } from '@/lib/api/server'
+import { checkSessionOrInternalAuth } from '@/lib/auth/hybrid'
+import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
+import { listLogs } from '@/lib/logs/list-logs'
+
+const logger = createLogger('LogsAPI')
+
+export const GET = withRouteHandler(async (request: NextRequest) => {
+  const authResult = await checkSessionOrInternalAuth(request, { requireWorkflowId: false })
+  if (!authResult.success || !authResult.userId) {
+    return NextResponse.json(
+      { error: authResult.error || 'Authentication required' },
+      { status: 401 }
+    )
+  }
+  const userId = authResult.userId
+
+  const parsed = await parseRequest(listLogsContract, request, {})
+  if (!parsed.success) return parsed.response
+
+  const params = parsed.data.query
+  const result = await listLogs(params, userId)
+
+  logger.debug('Listed logs', {
+    workspaceId: params.workspaceId,
+    count: result.data.length,
+    hasMore: result.nextCursor !== null,
+    sortBy: params.sortBy,
+    sortOrder: params.sortOrder,
+  })
+
+  return NextResponse.json(result)
+})

apps/sim/app/api/logs/stats/route.ts

@@ -0,0 +1,280 @@
+import { dbReplica } from '@sim/db'
+import { workflow, workflowExecutionLogs } from '@sim/db/schema'
+import { createLogger } from '@sim/logger'
+import { and, eq, sql } from 'drizzle-orm'
+import { type NextRequest, NextResponse } from 'next/server'
+import {
+  type DashboardStatsResponse,
+  type SegmentStats,
+  statsQueryParamsSchema,
+  type WorkflowStats,
+} from '@/lib/api/contracts/logs'
+import { isZodError } from '@/lib/api/server'
+import { getSession } from '@/lib/auth'
+import { generateRequestId } from '@/lib/core/utils/request'
+import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
+import { buildFilterConditions } from '@/lib/logs/filters'
+import { expandFolderIdsWithDescendants } from '@/lib/logs/folder-expansion'
+import { checkWorkspaceAccess } from '@/lib/workspaces/permissions/utils'
+
+const logger = createLogger('LogsStatsAPI')
+
+export const revalidate = 0
+
+export const GET = withRouteHandler(async (request: NextRequest) => {
+  const requestId = generateRequestId()
+
+  try {
+    const session = await getSession()
+    if (!session?.user?.id) {
+      logger.warn(`[${requestId}] Unauthorized logs stats access attempt`)
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+    }
+
+    const userId = session.user.id
+
+    try {
+      const { searchParams } = new URL(request.url)
+      const params = statsQueryParamsSchema.parse(Object.fromEntries(searchParams.entries()))
+
+      const access = await checkWorkspaceAccess(params.workspaceId, userId)
+      if (!access.hasAccess) {
+        return NextResponse.json(
+          {
+            workflows: [],
+            aggregateSegments: [],
+            totalRuns: 0,
+            totalErrors: 0,
+            avgLatency: 0,
+            timeBounds: { start: new Date().toISOString(), end: new Date().toISOString() },
+            segmentMs: 0,
+          } satisfies DashboardStatsResponse,
+          { status: 200 }
+        )
+      }
+
+      const workspaceFilter = eq(workflowExecutionLogs.workspaceId, params.workspaceId)
+
+      if (params.folderIds) {
+        params.folderIds = await expandFolderIdsWithDescendants(
+          params.workspaceId,
+          params.folderIds
+        )
+      }
+
+      const commonFilters = buildFilterConditions(params, { useSimpleLevelFilter: true })
+      const whereCondition = commonFilters ? and(workspaceFilter, commonFilters) : workspaceFilter
+
+      const boundsQuery = await dbReplica
+        .select({
+          minTime: sql<string>`MIN(${workflowExecutionLogs.startedAt})`,
+          maxTime: sql<string>`MAX(${workflowExecutionLogs.startedAt})`,
+        })
+        .from(workflowExecutionLogs)
+        .leftJoin(workflow, eq(workflowExecutionLogs.workflowId, workflow.id))
+        .where(whereCondition)
+
+      const bounds = boundsQuery[0]
+      const now = new Date()
+
+      let startTime: Date
+      let endTime: Date
+
+      if (!bounds?.minTime || !bounds?.maxTime) {
+        endTime = now
+        startTime = new Date(now.getTime() - 24 * 60 * 60 * 1000)
+      } else {
+        startTime = new Date(bounds.minTime)
+        endTime = new Date(Math.max(new Date(bounds.maxTime).getTime(), now.getTime()))
+      }
+
+      const totalMs = Math.max(1, endTime.getTime() - startTime.getTime())
+      const segmentMs = Math.max(60000, Math.floor(totalMs / params.segmentCount))
+      const startTimeIso = startTime.toISOString()
+
+      const statsQuery = await dbReplica
+        .select({
+          workflowId: sql<string>`COALESCE(${workflowExecutionLogs.workflowId}, 'deleted')`,
+          workflowName: sql<string>`COALESCE(${workflow.name}, 'Deleted Workflow')`,
+          segmentIndex:
+            sql<number>`FLOOR(EXTRACT(EPOCH FROM (${workflowExecutionLogs.startedAt} - ${startTimeIso}::timestamp)) * 1000 / ${segmentMs})`.as(
+              'segment_index'
+            ),
+          totalExecutions: sql<number>`COUNT(*)`.as('total_executions'),
+          successfulExecutions:
+            sql<number>`COUNT(*) FILTER (WHERE ${workflowExecutionLogs.level} != 'error')`.as(
+              'successful_executions'
+            ),
+          avgDurationMs:
+            sql<number>`COALESCE(AVG(${workflowExecutionLogs.totalDurationMs}) FILTER (WHERE ${workflowExecutionLogs.totalDurationMs} > 0), 0)`.as(
+              'avg_duration_ms'
+            ),
+        })
+        .from(workflowExecutionLogs)
+        .leftJoin(workflow, eq(workflowExecutionLogs.workflowId, workflow.id))
+        .where(whereCondition)
+        .groupBy(
+          sql`COALESCE(${workflowExecutionLogs.workflowId}, 'deleted')`,
+          sql`COALESCE(${workflow.name}, 'Deleted Workflow')`,
+          sql`segment_index`
+        )
+
+      const workflowMap = new Map<
+        string,
+        {
+          workflowId: string
+          workflowName: string
+          segments: Map<number, SegmentStats>
+          totalExecutions: number
+          totalSuccessful: number
+        }
+      >()
+
+      for (const row of statsQuery) {
+        const segmentIndex = Math.min(
+          params.segmentCount - 1,
+          Math.max(0, Math.floor(Number(row.segmentIndex)))
+        )
+
+        if (!workflowMap.has(row.workflowId)) {
+          workflowMap.set(row.workflowId, {
+            workflowId: row.workflowId,
+            workflowName: row.workflowName,
+            segments: new Map(),
+            totalExecutions: 0,
+            totalSuccessful: 0,
+          })
+        }
+
+        const wf = workflowMap.get(row.workflowId)!
+        wf.totalExecutions += Number(row.totalExecutions)
+        wf.totalSuccessful += Number(row.successfulExecutions)
+
+        const existing = wf.segments.get(segmentIndex)
+        if (existing) {
+          const oldTotal = existing.totalExecutions
+          const newTotal = oldTotal + Number(row.totalExecutions)
+          existing.totalExecutions = newTotal
+          existing.successfulExecutions += Number(row.successfulExecutions)
+          existing.avgDurationMs =
+            newTotal > 0
+              ? (existing.avgDurationMs * oldTotal +
+                  Number(row.avgDurationMs || 0) * Number(row.totalExecutions)) /
+                newTotal
+              : 0
+        } else {
+          wf.segments.set(segmentIndex, {
+            timestamp: new Date(startTime.getTime() + segmentIndex * segmentMs).toISOString(),
+            totalExecutions: Number(row.totalExecutions),
+            successfulExecutions: Number(row.successfulExecutions),
+            avgDurationMs: Number(row.avgDurationMs || 0),
+          })
+        }
+      }
+
+      const workflows: WorkflowStats[] = []
+      for (const wf of workflowMap.values()) {
+        const segments: SegmentStats[] = []
+        for (let i = 0; i < params.segmentCount; i++) {
+          const existing = wf.segments.get(i)
+          if (existing) {
+            segments.push(existing)
+          } else {
+            segments.push({
+              timestamp: new Date(startTime.getTime() + i * segmentMs).toISOString(),
+              totalExecutions: 0,
+              successfulExecutions: 0,
+              avgDurationMs: 0,
+            })
+          }
+        }
+
+        workflows.push({
+          workflowId: wf.workflowId,
+          workflowName: wf.workflowName,
+          segments,
+          totalExecutions: wf.totalExecutions,
+          totalSuccessful: wf.totalSuccessful,
+          overallSuccessRate:
+            wf.totalExecutions > 0 ? (wf.totalSuccessful / wf.totalExecutions) * 100 : 100,
+        })
+      }
+
+      workflows.sort((a, b) => {
+        const errA = a.overallSuccessRate < 100 ? 1 - a.overallSuccessRate / 100 : 0
+        const errB = b.overallSuccessRate < 100 ? 1 - b.overallSuccessRate / 100 : 0
+        if (errA !== errB) return errB - errA
+        return a.workflowName.localeCompare(b.workflowName)
+      })
+
+      const aggregateSegments: SegmentStats[] = []
+      let totalRuns = 0
+      let totalErrors = 0
+      let weightedLatencySum = 0
+      let latencyCount = 0
+
+      for (let i = 0; i < params.segmentCount; i++) {
+        let segTotal = 0
+        let segSuccess = 0
+        let segWeightedLatency = 0
+        let segLatencyCount = 0
+
+        for (const wf of workflows) {
+          const seg = wf.segments[i]
+          segTotal += seg.totalExecutions
+          segSuccess += seg.successfulExecutions
+          if (seg.avgDurationMs > 0 && seg.totalExecutions > 0) {
+            segWeightedLatency += seg.avgDurationMs * seg.totalExecutions
+            segLatencyCount += seg.totalExecutions
+          }
+        }
+
+        totalRuns += segTotal
+        totalErrors += segTotal - segSuccess
+        weightedLatencySum += segWeightedLatency
+        latencyCount += segLatencyCount
+
+        aggregateSegments.push({
+          timestamp: new Date(startTime.getTime() + i * segmentMs).toISOString(),
+          totalExecutions: segTotal,
+          successfulExecutions: segSuccess,
+          avgDurationMs: segLatencyCount > 0 ? segWeightedLatency / segLatencyCount : 0,
+        })
+      }
+
+      const avgLatency = latencyCount > 0 ? weightedLatencySum / latencyCount : 0
+
+      const response: DashboardStatsResponse = {
+        workflows,
+        aggregateSegments,
+        totalRuns,
+        totalErrors,
+        avgLatency,
+        timeBounds: {
+          start: startTime.toISOString(),
+          end: endTime.toISOString(),
+        },
+        segmentMs,
+      }
+
+      return NextResponse.json(response, { status: 200 })
+    } catch (validationError) {
+      if (isZodError(validationError)) {
+        logger.warn(`[${requestId}] Invalid logs stats request parameters`, {
+          errors: validationError.issues,
+        })
+        return NextResponse.json(
+          {
+            error: 'Invalid request parameters',
+            details: validationError.issues,
+          },
+          { status: 400 }
+        )
+      }
+      throw validationError
+    }
+  } catch (error: any) {
+    logger.error(`[${requestId}] logs stats fetch error`, error)
+    return NextResponse.json({ error: error.message }, { status: 500 })
+  }
+})

apps/sim/app/api/logs/triggers/route.ts

@@ -0,0 +1,75 @@
+import { db } from '@sim/db'
+import { workflowExecutionLogs } from '@sim/db/schema'
+import { createLogger } from '@sim/logger'
+import { and, eq, isNotNull, sql } from 'drizzle-orm'
+import { type NextRequest, NextResponse } from 'next/server'
+import { triggersQuerySchema } from '@/lib/api/contracts/logs'
+import { searchParamsToObject, validationErrorResponse } from '@/lib/api/server'
+import { getSession } from '@/lib/auth'
+import { generateRequestId } from '@/lib/core/utils/request'
+import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
+import { checkWorkspaceAccess } from '@/lib/workspaces/permissions/utils'
+
+const logger = createLogger('TriggersAPI')
+
+export const revalidate = 0
+
+/**
+ * GET /api/logs/triggers
+ *
+ * Returns unique trigger types from workflow execution logs
+ * Only includes integration triggers (excludes core types: api, manual, webhook, chat, schedule)
+ */
+export const GET = withRouteHandler(async (request: NextRequest) => {
+  const requestId = generateRequestId()
+
+  try {
+    const session = await getSession()
+    if (!session?.user?.id) {
+      logger.warn(`[${requestId}] Unauthorized triggers access attempt`)
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+    }
+
+    const userId = session.user.id
+
+    const { searchParams } = new URL(request.url)
+    const validation = triggersQuerySchema.safeParse(searchParamsToObject(searchParams))
+    if (!validation.success) {
+      logger.error(`[${requestId}] Invalid query parameters`, { error: validation.error })
+      return validationErrorResponse(validation.error)
+    }
+
+    const params = validation.data
+
+    const access = await checkWorkspaceAccess(params.workspaceId, userId)
+    if (!access.hasAccess) {
+      return NextResponse.json({ triggers: [], count: 0 })
+    }
+
+    const triggers = await db
+      .selectDistinct({
+        trigger: workflowExecutionLogs.trigger,
+      })
+      .from(workflowExecutionLogs)
+      .where(
+        and(
+          eq(workflowExecutionLogs.workspaceId, params.workspaceId),
+          isNotNull(workflowExecutionLogs.trigger),
+          sql`${workflowExecutionLogs.trigger} NOT IN ('api', 'manual', 'webhook', 'chat', 'schedule')`
+        )
+      )
+
+    const triggerValues = triggers
+      .map((row) => row.trigger)
+      .filter((t): t is string => Boolean(t))
+      .sort()
+
+    return NextResponse.json({
+      triggers: triggerValues,
+      count: triggerValues.length,
+    })
+  } catch (err) {
+    logger.error(`[${requestId}] Failed to fetch triggers`, { error: err })
+    return NextResponse.json({ error: 'Internal server error' }, { status: 500 })
+  }
+})