Retrospective: 3 Years Using Sentry 24 for Error Tracking and Performance Monitoring

// sentry.node.config.js
// Custom Sentry 24 Node.js SDK wrapper for production microservices
// Version: @sentry/node@24.3.1, @sentry/tracing@24.3.1
const Sentry = require('@sentry/node');
const { nodeProfilingIntegration } = require('@sentry/profiling-node');
const { RewriteFrames } = require('@sentry/integrations');
const os = require('os');
const packageJson = require('../package.json');

// Initialize Sentry 24 with production-grade config
Sentry.init({
  dsn: process.env.SENTRY_DSN, // Set via env var, never hardcode
  environment: process.env.NODE_ENV || 'staging',
  release: `my-service@${packageJson.version}`,
  tracesSampleRate: process.env.NODE_ENV === 'production' ? 0.1 : 1.0, // 10% sampling in prod
  profilesSampleRate: process.env.NODE_ENV === 'production' ? 0.05 : 1.0, // 5% profiling in prod
  integrations: [
    // Enable distributed tracing for HTTP/Express
    new Sentry.Integrations.Http({ tracing: true }),
    new Sentry.Integrations.Express({ app: require('./app') }),
    // Rewrite stack frames to remove build path noise
    new RewriteFrames({
      root: global.__dirname,
      iteratee: (frame) => {
        if (frame.filename?.startsWith('/app/build')) {
          frame.filename = frame.filename.replace('/app/build', 'app');
        }
        return frame;
      },
    }),
    // Enable Node.js profiling for performance bottlenecks
    nodeProfilingIntegration(),
  ],
  // Filter out noisy, non-actionable errors before sending to Sentry
  beforeSend: (event, hint) => {
    const error = hint.originalException;
    // Skip 4xx client errors (not server faults)
    if (error?.statusCode && error.statusCode >= 400 && error.statusCode < 500) {
      return null;
    }
    // Skip known noisy third-party errors (e.g., ad blockers, bot scrapers)
    if (event.request?.url?.includes('googleadservices')) {
      return null;
    }
    // Enrich event with host-level metadata
    event.tags = {
      ...event.tags,
      host_region: process.env.AWS_REGION || 'us-east-1',
      host_instance: os.hostname(),
      node_version: process.version,
    };
    return event;
  },
  // Dynamic trace sampling: sample 100% of /checkout endpoints, 5% of others
  tracesSampler: (samplingContext) => {
    const path = samplingContext.request?.url?.pathname;
    if (path?.startsWith('/api/checkout')) {
      return 1.0; // Full sampling for revenue-critical paths
    }
    if (path?.startsWith('/api/health')) {
      return 0; // No sampling for health checks
    }
    return 0.1; // Default 10% sampling
  },
});

// Graceful shutdown: flush pending events before process exit
process.on('SIGTERM', async () => {
  try {
    await Sentry.close(2000); // Wait up to 2s for pending events
    console.log('Sentry flush complete, shutting down');
    process.exit(0);
  } catch (err) {
    console.error('Failed to flush Sentry events:', err);
    process.exit(1);
  }
});

module.exports = Sentry;

// main.go
// Go microservice integration with Sentry 24 for distributed tracing and error tracking
// Sentry SDK version: github.com/getsentry/sentry-go@v24.0.0
package main

import (
    \"context\"
    \"encoding/json\"
    \"fmt\"
    \"log\"
    \"net/http\"
    \"os\"
    \"runtime\"
    \"time\"

    \"github.com/getsentry/sentry-go\"
    sentryhttp \"github.com/getsentry/sentry-go/http\"
)

func main() {
    // Initialize Sentry 24 for Go
    err := sentry.Init(sentry.ClientOptions{
        Dsn:              os.Getenv(\"SENTRY_DSN\"),
        Environment:      os.Getenv(\"GO_ENV\"),
        Release:          fmt.Sprintf(\"go-payment-service@%s\", os.Getenv(\"SERVICE_VERSION\")),
        TracesSampleRate: 0.2, // 20% trace sampling in production
        BeforeSend: func(event *sentry.Event, hint *sentry.EventHint) *sentry.Event {
            // Filter out health check errors
            if hint.OriginalException != nil {
                if httpErr, ok := hint.OriginalException.(httpError); ok && httpErr.StatusCode == 400 {
                    return nil
                }
            }
            // Add custom tags for Go runtime metadata
            event.Tags[\"go_version\"] = runtime.Version()
            event.Tags[\"service_region\"] = os.Getenv(\"AWS_REGION\")
            return event
        },
        BeforeSendTransaction: func(tx *sentry.Transaction, hint *sentry.TransactionHint) *sentry.Transaction {
            // Drop transactions for /health endpoints
            if tx.Source == \"/health\" {
                return nil
            }
            return tx
        },
    })
    if err != nil {
        log.Fatalf(\"Failed to initialize Sentry: %v\", err)
    }
    // Flush buffered events on shutdown
    defer sentry.Flush(2 * time.Second)

    // Wrap HTTP handler with Sentry middleware
    sentryHandler := sentryhttp.New(sentryhttp.Options{
        Repanic: true, // Repanic after capturing to let other middleware handle
    })
    http.HandleFunc(\"/api/payments/charge\", sentryHandler.HandleFunc(chargePaymentHandler))
    http.HandleFunc(\"/health\", healthCheckHandler)

    log.Println(\"Starting Go payment service on :8080\")
    if err := http.ListenAndServe(\":8080\", nil); err != nil {
        sentry.CaptureException(err)
        log.Fatalf(\"HTTP server failed: %v\", err)
    }
}

// chargePaymentHandler processes payment requests with distributed tracing
func chargePaymentHandler(w http.ResponseWriter, r *http.Request) {
    ctx := r.Context()
    // Start a new Sentry transaction span for this request
    span := sentry.StartSpan(ctx, \"charge_payment\", sentry.TransactionName(\"charge_payment\"))
    defer span.Finish()
    ctx = span.Context()

    // Simulate calling a downstream user service with tracing
    user, err := getUserFromDownstream(ctx, r.Header.Get(\"X-User-ID\"))
    if err != nil {
        // Capture error with context
        sentry.CaptureException(err, sentry.WithContext(ctx))
        http.Error(w, \"Failed to fetch user\", http.StatusInternalServerError)
        return
    }

    // Process payment logic here
    time.Sleep(100 * time.Millisecond) // Simulate work

    w.WriteHeader(http.StatusOK)
    fmt.Fprintf(w, \"Payment processed for user %s\", user.ID)
}

// getUserFromDownstream simulates a downstream HTTP call with tracing context propagation
func getUserFromDownstream(ctx context.Context, userID string) (*User, error) {
    span := sentry.StartSpan(ctx, \"downstream_call\", sentry.OpName(\"http.client\"))
    defer span.Finish()
    span.SetTag(\"downstream_service\", \"user-service\")
    span.SetData(\"user_id\", userID)

    // Propagate Sentry trace headers to downstream request
    req, _ := http.NewRequestWithContext(ctx, \"GET\", fmt.Sprintf(\"http://user-service:8080/api/users/%s\", userID), nil)
    sentryhttp.SetTransactionHeaders(req, span.Transaction())

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        span.SetStatus(sentry.SpanStatusInternalError)
        return nil, fmt.Errorf(\"downstream user service call failed: %w\", err)
    }
    defer resp.Body.Close()

    // Parse response
    var user User
    if err := json.NewDecoder(resp.Body).Decode(&user); err != nil {
        span.SetStatus(sentry.SpanStatusInternalError)
        return nil, fmt.Errorf(\"failed to decode user response: %w\", err)
    }
    span.SetStatus(sentry.SpanStatusOK)
    return &user, nil
}

type User struct {
    ID string `json:\"id\"`
}

type httpError struct {
    StatusCode int
    Message    string
}

func (e httpError) Error() string { return e.Message }

func healthCheckHandler(w http.ResponseWriter, r *http.Request) {
    w.WriteHeader(http.StatusOK)
    fmt.Fprintf(w, \"healthy\")
}

// sentry.browser.config.js
// React 18 frontend Sentry 24 configuration with performance monitoring and error boundaries
// SDK versions: @sentry/react@24.3.1, @sentry/browser@24.3.1
import * as Sentry from '@sentry/react';
import { BrowserTracing } from '@sentry/tracing';
import { useEffect } from 'react';
import { createRoot } from 'react-dom/client';
import { useLocation, useNavigationType, createRoutesFromChildren, matchRoutes } from 'react-router-dom';
import App from './App';

// Initialize Sentry 24 for React frontend
Sentry.init({
  dsn: process.env.REACT_APP_SENTRY_DSN,
  environment: process.env.REACT_APP_ENV || 'staging',
  release: `frontend@${process.env.REACT_APP_VERSION}`,
  integrations: [
    // Enable React specific error capturing (error boundaries, component stack traces)
    new Sentry.ReactIntegration(),
    // Enable browser tracing for page loads and navigations
    new BrowserTracing({
      // Set up routing instrumentation for React Router v6
      routingInstrumentation: Sentry.reactRouterV6Instrumentation(
        useEffect,
        useLocation,
        useNavigationType,
        createRoutesFromChildren,
        matchRoutes
      ),
      // Trace all XHR/fetch requests
      traceXHR: true,
      traceFetch: true,
      // Capture long tasks (tasks > 50ms) as spans
      captureLongTasks: true,
    }),
  ],
  // Sample 20% of page load traces, 10% of navigation traces
  tracesSampleRate: 0.2,
  // Dynamic sampling for specific routes
  tracesSampler: (samplingContext) => {
    const path = samplingContext.location?.pathname;
    if (path?.startsWith('/checkout')) {
      return 1.0; // Full sampling for checkout flow
    }
    if (path?.startsWith('/admin')) {
      return 0.5; // 50% sampling for admin routes
    }
    return 0.2; // Default 20%
  },
  // Filter out known noisy errors (e.g., browser extensions, ad blockers)
  beforeSend: (event, hint) => {
    const error = hint.originalException;
    if (error?.message?.includes('ResizeObserver loop limit exceeded')) {
      return null; // Known Chrome harmless error
    }
    if (event.request?.url?.includes('extension://')) {
      return null; // Browser extension errors
    }
    // Add user context if available
    const user = JSON.parse(localStorage.getItem('current_user') || '{}');
    if (user.id) {
      event.user = {
        id: user.id,
        email: user.email,
        username: user.username,
      };
    }
    return event;
  },
  // Enable session replay for P1 frontend errors
  replaysSessionSampleRate: 0.1, // 10% of sessions
  replaysOnErrorSampleRate: 1.0, // 100% of sessions with errors
});

// Custom error boundary component wrapping the app
const SentryErrorBoundary = Sentry.withErrorBoundary(App, {
  fallback: ({ error, resetError }) => (

      Something went wrong
      Our team has been notified. Please try again.
      Retry
       Sentry.captureException(error)}>Report Issue

  ),
  beforeCapture: (scope, error) => {
    // Add component stack trace to scope
    scope.setTag('component_stack', error.componentStack);
  },
});

// Render app with Sentry error boundary
const container = document.getElementById('root');
const root = createRoot(container);
root.render(

);

// Track custom user interactions as spans
export const trackCheckoutStep = (stepName) => {
  const span = Sentry.startSpan({
    name: `checkout.step.${stepName}`,
    op: 'ui.interaction',
  });
  span.setTag('checkout_step', stepName);
  // Finish span after 1s (or when step completes)
  setTimeout(() => span.finish(), 1000);
};

// Capture unhandled promise rejections
window.addEventListener('unhandledrejection', (event) => {
  Sentry.captureException(event.reason);
});

tracesSampler: (samplingContext) => {
  const path = samplingContext.request?.url?.pathname;
  if (path?.startsWith('/api/checkout')) return 1.0;
  if (path?.startsWith('/api/health')) return 0;
  if (process.env.NODE_ENV === 'staging') return 1.0;
  return 0.1;
}

// Add order context to Sentry scope
Sentry.configureScope((scope) => {
  scope.setTag('order_id', req.body.orderId);
  scope.setContext('order', {
    total: req.body.total,
    currency: req.body.currency,
    items: req.body.items.length,
  });
});

Sentry.init({
  // ... other config
  replaysSessionSampleRate: 0.1,
  replaysOnErrorSampleRate: 1.0,
  integrations: [
    Sentry.replayIntegration({
      maskAllText: false, // Mask only input fields by default
      blockAllMedia: true, // Don't record images/videos
    }),
  ],
});