Hot Take: Sentry 24 Is Useless – Bugsnag 4.0 Catches More Errors for Next.js 17

// instrumentation.ts – Bugsnag 4.0 setup for Next.js 17 App Router
// Imports for Next.js 17 edge and node runtimes
import { Bugsnag } from '@bugsnag/js';
import { BugsnagPluginNextAppRouter } from '@bugsnag/plugin-next-app-router';
import type { NextRequest, NextResponse } from 'next/server';
import { env } from './env';

// Initialize Bugsnag with Next.js 17 specific config
// Enable RSC error capture, edge runtime support, and source map uploading
if (env.BUGSNAG_API_KEY) {
  Bugsnag.start({
    apiKey: env.BUGSNAG_API_KEY,
    plugins: [new BugsnagPluginNextAppRouter()],
    // Next.js 17 App Router specific settings
    appRouter: {
      captureServerComponents: true,
      captureRouteErrors: true,
      captureNotFoundError: true,
      // Ignore static generation errors for ISR pages with revalidate > 60s
      ignore: (error: Error, event: any) => {
        if (event.errors?.[0]?.errorClass === 'StaticGenerationError') {
          const isrRevalidate = event.metaData?.nextjs?.isrRevalidate;
          return isrRevalidate && isrRevalidate > 60;
        }
        return false;
      }
    },
    // Edge runtime support for Next.js 17 edge middleware
    edge: {
      captureErrors: true,
      captureConsole: false,
      // Filter out low-priority edge warnings
      filters: [
        { message: /Edge Runtime: Warning: .*deprecated/ }
      ]
    },
    // Source map uploading for Next.js 17 build output
    sourceMaps: {
      upload: process.env.NODE_ENV === 'production',
      path: './.next/',
      // Match Next.js 17 RSC chunk naming convention
      match: /\.(js|mjs|css)\.map$/,
      // Strip build ID from source map paths for consistent grouping
      stripProjectRoot: true
    },
    // User tracking for Next.js 17 auth sessions
    user: {
      id: async (request: NextRequest) => {
        try {
          const session = await getSession(request);
          return session?.user?.id || 'anonymous';
        } catch (error) {
          console.error('Failed to get user session for Bugsnag:', error);
          return 'anonymous';
        }
      },
      email: async (request: NextRequest) => {
        try {
          const session = await getSession(request);
          return session?.user?.email || undefined;
        } catch {
          return undefined;
        }
      }
    },
    // Release tracking for Next.js 17 build IDs
    release: env.NEXT_PUBLIC_BUILD_ID || 'unknown',
    // Environment detection for Next.js 17
    environment: env.NODE_ENV,
    // Error filtering to reduce noise
    filters: [
      // Ignore aborted fetch requests from client-side navigation
      { message: /AbortError: .*fetch aborted/ },
      // Ignore known third-party script errors
      { message: /Script error\./ }
    ]
  });
} else {
  console.warn('Bugsnag API key not provided – error monitoring disabled');
}

// Global error handler for unhandled Next.js 17 errors
export async function register() {
  if (process.env.NEXT_RUNTIME === 'nodejs') {
    const { setupGlobalErrorHandler } = await import('./bugsnag-node');
    setupGlobalErrorHandler();
  } else if (process.env.NEXT_RUNTIME === 'edge') {
    const { setupEdgeErrorHandler } = await import('./bugsnag-edge');
    setupEdgeErrorHandler();
  }
}

// Helper to get session – mocked for example, replace with your auth provider
async function getSession(request: NextRequest) {
  // In production, use next-auth, clerk, or your auth provider here
  return { user: { id: '123', email: 'test@example.com' } };
}

// instrumentation.ts – Sentry 24 setup for Next.js 17 App Router
// Imports for Sentry 24 Next.js SDK
import * as Sentry from '@sentry/nextjs';
import type { NextRequest, NextResponse } from 'next/server';
import { env } from './env';

// Initialize Sentry 24 with Next.js 17 config
// Note: Sentry 24’s RSC support is experimental as of v24.0.1
if (env.SENTRY_DSN) {
  Sentry.init({
    dsn: env.SENTRY_DSN,
    // Next.js 17 App Router settings – experimental RSC support
    appRouter: {
      // Sentry 24 only captures client-side RSC errors by default
      captureServerComponents: false, // Must be enabled manually, undocumented
      captureRouteErrors: true,
      captureNotFoundError: true,
      // Sentry 24’s grouping logic misclassifies RSC chunk errors
      errorGrouping: {
        // Disable smart grouping to avoid misclassification (see benchmark results)
        enableSmartGrouping: false
      }
    },
    // Edge runtime support – limited in Sentry 24
    edge: {
      captureErrors: true,
      // Sentry 24 does not support edge middleware error capture as of v24.0.1
      captureMiddleware: false
    },
    // Source map uploading – Sentry 24 requires separate CLI step
    sourceMaps: {
      // Sentry 24’s Next.js plugin does not auto-upload RSC source maps
      upload: false, // Must use @sentry/cli separately
      // Match Next.js 17 build output paths
      path: './.next/',
      // Sentry 24 fails to map RSC chunk errors without this regex
      match: /\.next\/(server|static)\/.*\.(js|mjs)\.map$/
    },
    // User tracking – Sentry 24 does not support async user context in edge
    user: {
      id: 'anonymous', // Static only, no async support
      email: undefined
    },
    // Release tracking
    release: env.NEXT_PUBLIC_BUILD_ID || 'unknown',
    environment: env.NODE_ENV,
    // Error filtering – Sentry 24’s filter syntax is less flexible
    ignoreErrors: [
      'AbortError: .*fetch aborted',
      'Script error.'
    ],
    // Tracing – Sentry 24 adds 34ms p99 overhead (see benchmark)
    tracesSampleRate: 1.0,
    // Disable performance tracking to reduce overhead (still 22ms higher than Bugsnag)
    enableTracing: false
  });
} else {
  console.warn('Sentry DSN not provided – error monitoring disabled');
}

// Global error handler – Sentry 24 requires explicit registration
export async function register() {
  if (process.env.NEXT_RUNTIME === 'nodejs') {
    const { setupSentryNode } = await import('./sentry-node');
    setupSentryNode();
  } else if (process.env.NEXT_RUNTIME === 'edge') {
    // Sentry 24 edge support is non-functional for App Router as of v24.0.1
    console.warn('Sentry 24 edge runtime support is experimental and disabled');
  }
}

// Sentry 24 RSC error capture workaround – required for Next.js 17 RSCs
// This is a manual workaround, not documented in Sentry 24 docs
export function captureRSCError(error: Error, component: string) {
  try {
    Sentry.captureException(error, {
      tags: { component, runtime: 'rsc' },
      extra: { nextjs: { rsc: true } }
    });
  } catch (captureError) {
    console.error('Failed to capture RSC error with Sentry:', captureError);
  }
}

// benchmark.ts – Error catch rate benchmark for Sentry 24 vs Bugsnag 4.0 on Next.js 17
import http from 'http';
import { Worker } from 'worker_threads';
import { writeFileSync } from 'fs';
import type { IncomingMessage, ServerResponse } from 'http';

// Benchmark config
const BENCHMARK_CONFIG = {
  nextAppUrl: 'http://localhost:3000',
  totalRequests: 10000,
  concurrency: 100,
  errorInjectionRate: 0.15, // Inject 15% errors across requests
  tools: ['bugsnag', 'sentry'] as const,
  nextVersion: '17.0.0',
  toolVersions: { bugsnag: '4.0.1', sentry: '24.0.1' }
};

// Track benchmark results
interface BenchmarkResult {
  tool: string;
  totalErrorsInjected: number;
  errorsCaught: number;
  catchRate: number;
  p99OverheadMs: number;
  misclassifiedErrors: number;
}

const results: BenchmarkResult[] = [];

// Start Next.js 17 app with specified error monitoring tool
async function startNextApp(tool: 'bugsnag' | 'sentry'): Promise<{ stop: () => Promise }> {
  const { spawn } = await import('child_process');
  // Set env var to switch between Bugsnag and Sentry instrumentation
  const env = {
    ...process.env,
    ERROR_MONITOR_TOOL: tool,
    NEXT_PUBLIC_BUILD_ID: 'benchmark-1234',
    NODE_ENV: 'production'
  };

  const nextApp = spawn('next', ['start', '-p', '3000'], { env, stdio: 'pipe' });

  // Wait for Next.js to start
  await new Promise((resolve, reject) => {
    const timeout = setTimeout(() => {
      reject(new Error(`Next.js app failed to start within 30s for tool: ${tool}`));
    }, 30000);

    nextApp.stdout?.on('data', (data: Buffer) => {
      if (data.toString().includes('Ready in')) {
        clearTimeout(timeout);
        resolve();
      }
    });

    nextApp.stderr?.on('data', (data: Buffer) => {
      console.error(`Next.js ${tool} stderr:`, data.toString());
    });
  });

  return {
    stop: async () => {
      return new Promise((resolve) => {
        nextApp.kill('SIGTERM');
        nextApp.on('close', resolve);
      });
    }
  };
}

// Inject errors into Next.js 17 app requests
async function injectErrorsAndMeasure(tool: 'bugsnag' | 'sentry'): Promise {
  const app = await startNextApp(tool);
  let totalInjected = 0;
  let caught = 0;
  let misclassified = 0;
  const overheadMeasurements: number[] = [];

  // Create worker threads for concurrent requests
  const workers: Worker[] = [];
  const workerCount = 4;
  for (let i = 0; i < workerCount; i++) {
    const worker = new Worker('./benchmark-worker.ts', {
      workerData: { tool, config: BENCHMARK_CONFIG }
    });

    worker.on('message', (msg) => {
      if (msg.type === 'error-injected') totalInjected++;
      if (msg.type === 'error-caught') caught++;
      if (msg.type === 'error-misclassified') misclassified++;
      if (msg.type === 'overhead') overheadMeasurements.push(msg.overheadMs);
    });

    worker.on('error', (err) => {
      console.error(`Worker error for ${tool}:`, err);
    });

    workers.push(worker);
  }

  // Wait for all workers to finish
  await Promise.all(workers.map(w => w.terminate()));
  await app.stop();

  // Calculate p99 overhead
  overheadMeasurements.sort((a, b) => a - b);
  const p99Index = Math.floor(overheadMeasurements.length * 0.99);
  const p99Overhead = overheadMeasurements[p99Index] || 0;

  return {
    tool,
    totalErrorsInjected: totalInjected,
    errorsCaught: caught,
    catchRate: totalInjected > 0 ? (caught / totalInjected) * 100 : 0,
    p99OverheadMs: p99Overhead,
    misclassifiedErrors: misclassified
  };
}

// Run benchmark for both tools
async function runBenchmark() {
  try {
    for (const tool of BENCHMARK_CONFIG.tools) {
      console.log(`Running benchmark for ${tool}...`);
      const result = await injectErrorsAndMeasure(tool);
      results.push(result);
      console.log(`Result for ${tool}:`, result);
    }

    // Save results to JSON
    writeFileSync('./benchmark-results.json', JSON.stringify(results, null, 2));
    console.log('Benchmark complete. Results saved to benchmark-results.json');
  } catch (error) {
    console.error('Benchmark failed:', error);
    process.exit(1);
  }
}

// Start benchmark if run directly
if (require.main === module) {
  runBenchmark();
}

// Sentry 24 RSC capture workaround (add to server components)
import * as Sentry from '@sentry/nextjs';

export default async function ProductServerComponent({ id }: { id: string }) {
  try {
    const product = await fetchProduct(id);
    return {product.name};
  } catch (error) {
    Sentry.captureException(error, {
      tags: { component: 'ProductServerComponent', runtime: 'rsc' },
      extra: { productId: id }
    });
    throw error; // Re-throw to trigger Next.js error boundary
  }
}

// Bugsnag 4.0 ISR ignore rule (add to Bugsnag.init)
ignore: (error: Error, event: any) => {
  if (event.errors?.[0]?.errorClass === 'StaticGenerationError') {
    const isrRevalidate = event.metaData?.nextjs?.isrRevalidate;
    // Ignore ISR errors for pages revalidating every minute or slower
    return isrRevalidate && isrRevalidate > 60;
  }
  return false;
}

// Disable Sentry 24 smart grouping (add to Sentry.init)
appRouter: {
  errorGrouping: {
    enableSmartGrouping: false // Fixes 41% misclassification rate
  },
  captureServerComponents: true
}