feat(error-notifications): workspace-level configuration of slack, email, webhook notifications for workflow execution (#2157)

* feat(notification): slack, email, webhook notifications from logs

* retain search params for filters to link in notification

* add alerting rules

* update selector

* fix lint

* add limits on num of emails and notification triggers per workspace

* address greptile comments

* add search to combobox

* move notifications to react query

* fix lint

* fix email formatting

* add more alert types

* fix imports

* fix test route

* use emcn componentfor modal

* refactor: consolidate notification config fields into jsonb objects

* regen migration

* fix delete notif modal ui

* make them multiselect dropdowns

* update tag styling

* combobox font size with multiselect tags'

Author: icecrasher321

apps/docs/content/docs/en/execution/api.mdx

@@ -240,32 +240,78 @@ Retrieve execution details including the workflow state snapshot.
   </Tab>
 </Tabs>
 
-## Webhook Subscriptions
+## Notifications
 
-Get real-time notifications when workflow executions complete. Webhooks are configured through the Sim UI in the workflow editor.
+Get real-time notifications when workflow executions complete via webhook, email, or Slack. Notifications are configured at the workspace level from the Logs page.
 
 ### Configuration
 
-Webhooks can be configured for each workflow through the workflow editor UI. Click the webhook icon in the control bar to set up your webhook subscriptions.
+Configure notifications from the Logs page by clicking the menu button and selecting "Configure Notifications".
 
-<div className="mx-auto w-full overflow-hidden rounded-lg">
-  <Video src="configure-webhook.mp4" width={700} height={450} />
-</div>
+**Notification Channels:**
+- **Webhook**: Send HTTP POST requests to your endpoint
+- **Email**: Receive email notifications with execution details
+- **Slack**: Post messages to a Slack channel
 
-**Available Configuration Options:**
+**Workflow Selection:**
+- Select specific workflows to monitor
+- Or choose "All Workflows" to include current and future workflows
+
+**Filtering Options:**
+- `levelFilter`: Log levels to receive (`info`, `error`)
+- `triggerFilter`: Trigger types to receive (`api`, `webhook`, `schedule`, `manual`, `chat`)
+
+**Optional Data:**
+- `includeFinalOutput`: Include the workflow's final output
+- `includeTraceSpans`: Include detailed execution trace spans
+- `includeRateLimits`: Include rate limit information (sync/async limits and remaining)
+- `includeUsageData`: Include billing period usage and limits
+
+### Alert Rules
+
+Instead of receiving notifications for every execution, configure alert rules to be notified only when issues are detected:
+
+**Consecutive Failures**
+- Alert after X consecutive failed executions (e.g., 3 failures in a row)
+- Resets when an execution succeeds
+
+**Failure Rate**
+- Alert when failure rate exceeds X% over the last Y hours
+- Requires minimum 5 executions in the window
+- Only triggers after the full time window has elapsed
+
+**Latency Threshold**
+- Alert when any execution takes longer than X seconds
+- Useful for catching slow or hanging workflows
+
+**Latency Spike**
+- Alert when execution is X% slower than the average
+- Compares against the average duration over the configured time window
+- Requires minimum 5 executions to establish baseline
+
+**Cost Threshold**
+- Alert when a single execution costs more than $X
+- Useful for catching expensive LLM calls
+
+**No Activity**
+- Alert when no executions occur within X hours
+- Useful for monitoring scheduled workflows that should run regularly
+
+**Error Count**
+- Alert when error count exceeds X within a time window
+- Tracks total errors, not consecutive
+
+All alert types include a 1-hour cooldown to prevent notification spam.
+
+### Webhook Configuration
+
+For webhooks, additional options are available:
 - `url`: Your webhook endpoint URL
 - `secret`: Optional secret for HMAC signature verification
-- `includeFinalOutput`: Include the workflow's final output in the payload
-- `includeTraceSpans`: Include detailed execution trace spans
-- `includeRateLimits`: Include the workflow owner's rate limit information
-- `includeUsageData`: Include the workflow owner's usage and billing data
-- `levelFilter`: Array of log levels to receive (`info`, `error`)
-- `triggerFilter`: Array of trigger types to receive (`api`, `webhook`, `schedule`, `manual`, `chat`)
-- `active`: Enable/disable the webhook subscription
 
-### Webhook Payload
+### Payload Structure
 
-When a workflow execution completes, Sim sends a POST request to your webhook URL:
+When a workflow execution completes, Sim sends the following payload (via webhook POST, email, or Slack):
 
 ```json
 {
@@ -316,7 +362,7 @@ When a workflow execution completes, Sim sends a POST request to your webhook UR
 
 ### Webhook Headers
 
-Each webhook request includes these headers:
+Each webhook request includes these headers (webhook channel only):
 
 - `sim-event`: Event type (always `workflow.execution.completed`)
 - `sim-timestamp`: Unix timestamp in milliseconds

apps/docs/content/docs/en/execution/logging.mdx

@@ -147,4 +147,4 @@ The snapshot provides:
 
 - Learn about [Cost Calculation](/execution/costs) to understand workflow pricing
 - Explore the [External API](/execution/api) for programmatic log access
-- Set up [Webhook notifications](/execution/api#webhook-subscriptions) for real-time alerts
+- Set up [Notifications](/execution/api#notifications) for real-time alerts via webhook, email, or Slack

apps/sim/app/api/auth/accounts/route.ts

@@ -0,0 +1,40 @@
+import { db } from '@sim/db'
+import { account } from '@sim/db/schema'
+import { and, eq } from 'drizzle-orm'
+import { type NextRequest, NextResponse } from 'next/server'
+import { getSession } from '@/lib/auth'
+import { createLogger } from '@/lib/logs/console/logger'
+
+const logger = createLogger('AuthAccountsAPI')
+
+export async function GET(request: NextRequest) {
+  try {
+    const session = await getSession()
+    if (!session?.user?.id) {
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+    }
+
+    const { searchParams } = new URL(request.url)
+    const provider = searchParams.get('provider')
+
+    const whereConditions = [eq(account.userId, session.user.id)]
+
+    if (provider) {
+      whereConditions.push(eq(account.providerId, provider))
+    }
+
+    const accounts = await db
+      .select({
+        id: account.id,
+        accountId: account.accountId,
+        providerId: account.providerId,
+      })
+      .from(account)
+      .where(and(...whereConditions))
+
+    return NextResponse.json({ accounts })
+  } catch (error) {
+    logger.error('Failed to fetch accounts', { error })
+    return NextResponse.json({ error: 'Internal server error' }, { status: 500 })
+  }
+}

apps/sim/app/api/notifications/poll/route.ts

@@ -0,0 +1,62 @@
+import { nanoid } from 'nanoid'
+import { type NextRequest, NextResponse } from 'next/server'
+import { verifyCronAuth } from '@/lib/auth/internal'
+import { acquireLock, releaseLock } from '@/lib/core/config/redis'
+import { createLogger } from '@/lib/logs/console/logger'
+import { pollInactivityAlerts } from '@/lib/notifications/inactivity-polling'
+
+const logger = createLogger('InactivityAlertPoll')
+
+export const maxDuration = 120
+
+const LOCK_KEY = 'inactivity-alert-polling-lock'
+const LOCK_TTL_SECONDS = 120
+
+export async function GET(request: NextRequest) {
+  const requestId = nanoid()
+  logger.info(`Inactivity alert polling triggered (${requestId})`)
+
+  try {
+    const authError = verifyCronAuth(request, 'Inactivity alert polling')
+    if (authError) {
+      return authError
+    }
+
+    const locked = await acquireLock(LOCK_KEY, requestId, LOCK_TTL_SECONDS)
+
+    if (!locked) {
+      return NextResponse.json(
+        {
+          success: true,
+          message: 'Polling already in progress – skipped',
+          requestId,
+          status: 'skip',
+        },
+        { status: 202 }
+      )
+    }
+
+    const results = await pollInactivityAlerts()
+
+    return NextResponse.json({
+      success: true,
+      message: 'Inactivity alert polling completed',
+      requestId,
+      status: 'completed',
+      ...results,
+    })
+  } catch (error) {
+    logger.error(`Error during inactivity alert polling (${requestId}):`, error)
+    return NextResponse.json(
+      {
+        success: false,
+        message: 'Inactivity alert polling failed',
+        error: error instanceof Error ? error.message : 'Unknown error',
+        requestId,
+      },
+      { status: 500 }
+    )
+  } finally {
+    await releaseLock(LOCK_KEY).catch(() => {})
+  }
+}