How to Integrate Sentry 24.0 with Slack 5.0 for 2026 Production Alerts

// sentry.config.js
// Sentry 24.0 Node SDK initialization for 2026 production stacks
// Compatible with Node.js 22+, Express 5, Next.js 15, NestJS 11
import * as Sentry from '@sentry/node';
import { nodeProfilingIntegration } from '@sentry/profiling-node';
import { SlackIntegration } from '@sentry/integrations/slack/v5'; // Slack 5.0 native integration
import { env } from './env.js'; // Typed environment config (Zod-validated)
import { logger } from './logger.js'; // Custom Pino logger

/**
 * Initializes Sentry 24.0 with Slack 5.0 integration, performance monitoring,
 * and production-grade error handling. Throws only in development if config is invalid.
 * @returns {Sentry.NodeClient} Initialized Sentry client
 * @throws {Error} If required env vars are missing in non-production environments
 */
export function initSentry() {
  try {
    // Validate required environment variables upfront
    const requiredEnvVars = ['SENTRY_DSN', 'SLACK_BOT_TOKEN', 'SLACK_CHANNEL_ID'];
    const missingVars = requiredEnvVars.filter(varName => !env[varName]);
    if (missingVars.length > 0) {
      const errorMsg = `Missing required Sentry/Slack env vars: ${missingVars.join(', ')}`;
      if (env.NODE_ENV !== 'production') {
        throw new Error(errorMsg);
      } else {
        logger.fatal(errorMsg, 'Sentry initialization will proceed with partial config');
      }
    }

    // Initialize Sentry with 2026-recommended defaults
    Sentry.init({
      dsn: env.SENTRY_DSN,
      environment: env.NODE_ENV || 'development',
      release: env.GIT_SHA || 'unknown', // Inject git SHA via CI/CD
      tracesSampleRate: env.NODE_ENV === 'production' ? 0.2 : 1.0, // 20% sampling in prod to control costs
      profilesSampleRate: env.NODE_ENV === 'production' ? 0.1 : 1.0, // 10% profiling in prod
      integrations: [
        // Slack 5.0 integration with Block Kit 2.0 support
        new SlackIntegration({
          botToken: env.SLACK_BOT_TOKEN,
          channel: env.SLACK_CHANNEL_ID,
          username: 'Sentry Alerts (2026)',
          iconEmoji: ':rotating_light:',
          // Only send high-severity alerts to Slack by default
          severityThreshold: 'error',
          // Enable interactive Block Kit components (incident actions)
          useBlockKit: true,
          // Filter out noisy known errors (e.g., 404s from scanners)
          ignoreErrors: [
            'ECONNREFUSED',
            'ENOTFOUND',
            / 404$/,
            /ScraperBot/,
          ],
        }),
        // Node profiling integration for 2026 performance monitoring
        nodeProfilingIntegration(),
        // Express 5 integration (auto-captures request data)
        Sentry.expressIntegration({
          // Capture request bodies for POST/PUT errors (truncated to 10kb for PII compliance)
          captureRequestBody: true,
          captureRequestHeaders: true,
          maxRequestBodySize: 10240,
        }),
      ],
      // Production error filtering: ignore errors from health check endpoints
      beforeSend(event) {
        if (event.request?.url?.includes('/healthz')) {
          return null; // Drop health check errors
        }
        // Redact PII from event data (GDPR compliance)
        if (event.user) {
          delete event.user.email;
          delete event.user.ip_address;
        }
        return event;
      },
      // Performance event filtering
      beforeSendTransaction(event) {
        // Drop low-value health check transactions
        if (event.transaction?.includes('/healthz')) {
          return null;
        }
        return event;
      },
    });

    logger.info('Sentry 24.0 initialized successfully with Slack 5.0 integration');
    return Sentry.getCurrentHub().getClient();
  } catch (error) {
    logger.error({ error }, 'Failed to initialize Sentry');
    if (env.NODE_ENV !== 'production') {
      throw error; // Fail fast in development
    }
    // In production, return a no-op client to avoid crashing the app
    return {
      captureException: (e) => logger.error({ e }, 'Sentry not initialized, capturing to logger'),
      captureMessage: (m) => logger.info({ m }, 'Sentry not initialized, capturing to logger'),
    };
  }
}

// slack-alert-customizer.js
// Custom Slack 5.0 Block Kit 2.0 message builder for Sentry 24.0 alerts
// Adds session replay links, performance regression context, and one-click incident actions
import { WebClient } from '@slack/web-api'; // Slack 5.0 SDK
import { env } from './env.js';
import { logger } from './logger.js';

// Initialize Slack 5.0 WebClient with rate limiting and retry logic
const slackClient = new WebClient(env.SLACK_BOT_TOKEN, {
  retryConfig: {
    retries: 3,
    factor: 2,
    minTimeout: 1000,
    maxTimeout: 5000,
  },
  // Slack 5.0 rate limit handling: throw on 429 to trigger retry
  throwOnRateLimit: true,
});

/**
 * Custom Sentry 24.0 alert handler that overrides default Slack payloads
 * @param {Object} sentryAlert - Raw Sentry alert event from beforeSendSlack callback
 * @returns {Object} Custom Slack Block Kit 2.0 message payload
 */
export async function customizeSlackAlert(sentryAlert) {
  try {
    // Only customize high-severity (error+) and performance alerts
    if (!['error', 'performance'].includes(sentryAlert.type) || sentryAlert.level < 'error') {
      return sentryAlert.defaultSlackPayload; // Return default for low-severity
    }

    const { event, tags, release, environment, url } = sentryAlert;
    const issueLink = `${url}/issues/${event.groupID}/`;
    const replayLink = event.sessionReplayURL ? `[View Session Replay](${event.sessionReplayURL})` : 'No replay available';

    // Build Block Kit 2.0 message (Slack 5.0 compliant)
    const slackPayload = {
      channel: env.SLACK_CHANNEL_ID,
      username: 'Sentry 24.0 Alerts',
      iconEmoji: ':rotating_light:',
      blocks: [
        {
          type: 'header',
          text: {
            type: 'plain_text',
            text: `🚨 ${event.level.toUpperCase()}: ${event.title}`,
            emoji: true,
          },
        },
        {
          type: 'section',
          fields: [
            { type: 'mrkdwn', text: `*Environment:*\n${environment}` },
            { type: 'mrkdwn', text: `*Release:*\n${release || 'Unknown'}` },
            { type: 'mrkdwn', text: `*Occurrences:*\n${event.count}` },
            { type: 'mrkdwn', text: `*Users Affected:*\n${event.userCount || 0}` },
          ],
        },
        {
          type: 'section',
          text: {
            type: 'mrkdwn',
            text: `*Stack Trace (truncated):*\n\`\`\`${event.stacktrace?.slice(0, 500) || 'No stack trace available'}\`\`\`\n${replayLink}`,
          },
        },
        {
          type: 'actions',
          elements: [
            {
              type: 'button',
              text: { type: 'plain_text', text: 'View in Sentry', emoji: true },
              url: issueLink,
              style: 'primary',
            },
            {
              type: 'button',
              text: { type: 'plain_text', text: 'Assign to On-Call', emoji: true },
              action_id: 'assign_on_call',
              value: event.groupID,
            },
            {
              type: 'button',
              text: { type: 'plain_text', text: 'Resolve', emoji: true },
              action_id: 'resolve_issue',
              value: event.groupID,
              style: 'danger',
            },
          ],
        },
        {
          type: 'context',
          elements: [
            { type: 'mrkdwn', text: `Alert sent at ${new Date().toISOString()} | Sentry 24.0 + Slack 5.0` },
          ],
        },
      ],
    };

    // Add performance-specific context if applicable
    if (sentryAlert.type === 'performance') {
      slackPayload.blocks.splice(2, 0, {
        type: 'section',
        fields: [
          { type: 'mrkdwn', text: `*p99 Latency:*\n${event.measurements?.p99 || 'N/A'}ms` },
          { type: 'mrkdwn', text: `*Throughput Drop:*\n${event.measurements?.throughputDrop || 'N/A'}%` },
        ],
      });
    }

    // Send custom message to Slack (bypasses default Sentry Slack integration)
    await slackClient.chat.postMessage(slackPayload);
    logger.info({ groupID: event.groupID }, 'Custom Slack alert sent successfully');
    return null; // Return null to prevent default Sentry Slack message
  } catch (error) {
    logger.error({ error, sentryAlert }, 'Failed to customize Slack alert, falling back to default');
    return sentryAlert.defaultSlackPayload; // Fallback to default on error
  }
}

// slack-interactions.js
// Slack 5.0 interactive component handler for Sentry 24.0 alert actions
// Handles assign on-call, resolve issue, and snooze actions from Slack alerts
import express from 'express';
import { verifySlackRequest } from '@slack/bolt'; // Slack 5.0 request verification
import * as Sentry from '@sentry/node';
import { env } from './env.js';
import { logger } from './logger.js';
import { OnCallRotation } from './oncall.js'; // PagerDuty/Opsgenie integration for on-call

const router = express.Router();

// Slack 5.0 requires request verification for all interactive endpoints
const slackVerifier = verifySlackRequest({
  signingSecret: env.SLACK_SIGNING_SECRET,
});

/**
 * POST /slack/interactions
 * Handles all interactive component actions from Sentry Slack alerts
 * Validates Slack signature, parses payload, and executes corresponding action
 */
router.post(
  '/slack/interactions',
  // Raw body parser for Slack signature verification (required for Bolt verifier)
  express.raw({ type: 'application/x-www-form-urlencoded' }),
  async (req, res, next) => {
    try {
      // 1. Verify Slack request signature (prevents spoofed requests)
      const isValid = await slackVerifier(req);
      if (!isValid) {
        logger.warn('Invalid Slack request signature');
        return res.status(401).send('Unauthorized');
      }

      // 2. Parse URL-encoded payload from Slack
      const payload = JSON.parse(req.body.payload);
      const { type, actions, user, channel } = payload;

      // Only handle block_actions (button clicks from our alerts)
      if (type !== 'block_actions' || !actions?.length) {
        return res.status(200).send('OK'); // Acknowledge non-action payloads
      }

      const action = actions[0];
      const groupID = action.value; // Sentry issue group ID

      // 3. Execute action based on action_id
      switch (action.action_id) {
        case 'assign_on_call': {
          // Fetch current on-call engineer from PagerDuty
          const onCall = await OnCallRotation.getCurrentOnCall();
          if (!onCall) {
            await sendSlackEphemeral(channel.id, user.id, 'No on-call engineer found.');
            break;
          }

          // Assign Sentry issue to on-call engineer
          await Sentry.API.assignIssue(groupID, onCall.email);
          // Notify on-call via Slack DM
          await slackClient.chat.postMessage({
            channel: onCall.slackID,
            text: `You’ve been assigned Sentry issue ${groupID}: ${payload.message.blocks[0].text.text}`,
            blocks: payload.message.blocks,
          });

          await sendSlackEphemeral(channel.id, user.id, `Assigned issue to ${onCall.name} (${onCall.email})`);
          logger.info({ groupID, onCall: onCall.email }, 'Issue assigned to on-call');
          break;
        }

        case 'resolve_issue': {
          // Resolve Sentry issue with comment
          await Sentry.API.resolveIssue(groupID, {
            status: 'resolved',
            comment: `Resolved from Slack by @${user.name} (${user.id})`,
          });

          // Update original Slack message to mark as resolved
          await slackClient.chat.update({
            channel: channel.id,
            ts: payload.message.ts,
            blocks: [
              ...payload.message.blocks.map(block => {
                if (block.type === 'header') {
                  return {
                    ...block,
                    text: { ...block.text, text: `✅ RESOLVED: ${block.text.text.replace('🚨 ', '')}` },
                  };
                }
                return block;
              }),
              {
                type: 'context',
                elements: [{ type: 'mrkdwn', text: `Resolved by @${user.name} at ${new Date().toISOString()}` }],
              },
            ],
          });

          await sendSlackEphemeral(channel.id, user.id, 'Issue marked as resolved.');
          logger.info({ groupID, user: user.id }, 'Issue resolved from Slack');
          break;
        }

        default:
          logger.warn({ actionId: action.action_id }, 'Unknown Slack action');
          await sendSlackEphemeral(channel.id, user.id, 'Unknown action.');
      }

      // Acknowledge Slack request (required within 3 seconds)
      res.status(200).send('OK');
    } catch (error) {
      logger.error({ error }, 'Failed to handle Slack interaction');
      Sentry.captureException(error);
      res.status(500).send('Internal Server Error');
    }
  }
);

/**
 * Helper: Send ephemeral Slack message (only visible to the triggering user)
 */
async function sendSlackEphemeral(channel, user, text) {
  try {
    await slackClient.chat.postEphemeral({
      channel,
      user,
      text,
      parse: 'full',
    });
  } catch (error) {
    logger.error({ error }, 'Failed to send ephemeral Slack message');
  }
}

export default router;

// Rate-limited Slack message queue example (p-queue 8.x)
import PQueue from 'p-queue';
import { WebClient } from '@slack/web-api';

const slackClient = new WebClient(env.SLACK_BOT_TOKEN);
const slackQueue = new PQueue({ concurrency: 5 }); // Max 5 Slack requests/s

export async function sendRateLimitedSlackMessage(payload) {
  return slackQueue.add(async () => {
    try {
      return await slackClient.chat.postMessage(payload);
    } catch (error) {
      if (error.code === 429) {
        Sentry.captureMessage(`Slack rate limit hit: retry after ${error.retryAfter}ms`);
        await new Promise(resolve => setTimeout(resolve, error.retryAfter));
        return sendRateLimitedSlackMessage(payload); // Retry after backoff
      }
      throw error;
    }
  });
}

// PII redaction for Sentry + Slack alerts
Sentry.init({
  // ... other config
  scrubPII: true,
  scrubbedFields: ['user.email', 'user.ip_address', 'request.headers.authorization'],
  beforeSendSlack: (slackPayload) => {
    // Redact any remaining PII in Slack message text
    const piiRegex = /\b[\w.-]+@[\w.-]+\.\w{2,}\b/g; // Email regex
    slackPayload.blocks.forEach(block => {
      if (block.text?.text) {
        block.text.text = block.text.text.replace(piiRegex, '[REDACTED EMAIL]');
      }
    });
    return slackPayload;
  },
});

// Benchmark Sentry alert delivery latency
Sentry.startTransaction({
  name: 'sentry.alert.delivery',
  op: 'alert.send',
  data: { alertType: 'error', groupID: event.groupID },
}).setMeasurement('slack.delivery.duration', slackDeliveryTimeMs, 'millisecond');

sentry24-slack5-2026-alerts/
├── src/
│   ├── config/
│   │   ├── sentry.config.js       # Sentry 24.0 initialization (Code Example 1)
│   │   ├── env.js                 # Zod-validated environment config
│   │   └── logger.js              # Pino logger config
│   ├── integrations/
│   │   ├── slack-alert-customizer.js  # Custom Slack Block Kit builder (Code Example 2)
│   │   └── slack-interactions.js      # Slack interactive action handler (Code Example 3)
│   ├── routes/
│   │   └── healthz.js             # Health check endpoint (excluded from Sentry)
│   ├── oncall.js                  # PagerDuty on-call integration
│   └── app.js                     # Express 5 app entry point
├── tests/
│   ├── sentry.test.js             # Sentry initialization tests
│   ├── slack-alerts.test.js       # Slack alert customization tests
│   └── slack-interactions.test.js # Slack action handler tests
├── .env.example                   # Example environment variables
├── package.json                   # Node 22+ dependencies
├── tsconfig.json                  # TypeScript 5.5 config
└── README.md                      # Setup instructions