Sentry — Error Tracking & Performance Monitoring Guide

# Self-hosted Sentry (using getsentry/self-hosted)
git clone https://github.com/getsentry/self-hosted.git
cd self-hosted
sudo ./install.sh

# Expected output:
# Checking minimum requirements...
# Creating volumes...
# Building images...
# Creating services...
# Installation complete.
# Your Sentry server is ready! Visit http://your-ip:9000

# Create DSN for your project
# Settings > Projects > Your Project > DSN
# DSN format: https://publicKey@o123456.ingest.sentry.io/654321

// sentry.js — Sentry initialization
const Sentry = require('@sentry/node');
const { nodeProfilingIntegration } = require('@sentry/profiling-node');

Sentry.init({
  dsn: 'https://publicKey@o123456.ingest.sentry.io/654321',
  environment: 'production',
  release: 'dodazip@2.5.0',
  dist: '1',

  // Performance monitoring
  tracesSampleRate: 0.2,
  profilesSampleRate: 0.1,

  // Send errors from all transactions
  errorSampleRate: 1.0,

  integrations: [
    nodeProfilingIntegration(),
  ],

  // Capture unhandled rejections
  captureUnhandledRejections: true,

  // Denylist sensitive data
  denyUrls: [
    /https?:\/\/localhost/,
    /https?:\/\/.*\.local/,
  ],

  beforeSend(event) {
    if (event.user) {
      delete event.user.email;
      delete event.user.ip_address;
    }
    return event;
  },

  // Sampling for performance
  tracesSampler(samplingContext) {
    if (samplingContext.request?.url?.includes('/health')) {
      return 0;
    }
    if (samplingContext.parentSampled) {
      return 1;
    }
    return 0.2;
  },
});

// Automatic error capturing
// Express error handler
const express = require('express');
const app = express();

// RequestHandler creates a separate trace per request
app.use(Sentry.Handlers.requestHandler());
app.use(Sentry.Handlers.tracingHandler());

app.get('/api/users/:id', async (req, res) => {
  try {
    const user = await db.query('SELECT * FROM users WHERE id = $1', [req.params.id]);
    if (!user) {
      throw new Error('User not found');
    }
    res.json(user);
  } catch (error) {
    // Sentry automatically captures in error handler
    Sentry.captureException(error, {
tags: {
        endpoint: 'GET /api/users/:id',
        user_id: req.params.id,
      },
      extra: {
        query: req.query,
        headers: req.headers,
      },
      user: {
        id: req.user?.id,
        username: req.user?.username,
      },
    });
    res.status(500).json({ error: 'Internal server error' });
  }
});

// The error handler middleware
app.use(Sentry.Handlers.errorHandler());

// Manual error capture
Sentry.captureMessage('Database migration completed', {
  level: 'info',
tags: { migration: 'v2.5.0' },
});

// Set user context
Sentry.setUser({
  id: 'user-123',
  username: 'jdoe',
  email: 'jdoe@dodatech.com',
});

// Add breadcrumbs for debugging
Sentry.addBreadcrumb({
  category: 'auth',
  message: 'User authenticated',
  level: 'info',
  data: {
    auth_method: 'OAuth2',
    provider: 'GitHub',
  },
});

// frontend/sentry.js
import * as Sentry from '@sentry/react';
import { BrowserTracing } from '@sentry/react';
import { createRoutesFromChildren, matchRoutes, useLocation, useNavigationType } from 'react-router-dom';

Sentry.init({
  dsn: 'https://publicKey@o123456.ingest.sentry.io/654321',
  environment: 'production',
  release: 'dodazip-frontend@3.1.0',

  integrations: [
    new BrowserTracing({
      routingInstrumentation: Sentry.reactRouterV6Instrumentation(
        React.useEffect,
        useLocation,
        useNavigationType,
        createRoutesFromChildren,
        matchRoutes
      ),
    }),
    new Sentry.Replay({
      maskAllText: false,
      maskAllInputs: false,
      blockAllMedia: false,
    }),
  ],

  tracesSampleRate: 0.1,
  replaysSessionSampleRate: 0.1,
  replaysOnErrorSampleRate: 1.0,
});

// Sentry Error Boundary
import { SentryErrorBoundary } from '@sentry/react';

function App() {
  return (
    <SentryErrorBoundary fallback={({ error, componentStack }) => (
      <div>
        <h2>Something went wrong</h2>
        <p>{error.message}</p>
        <button onClick={() => window.location.reload()}>
          Reload page
        </button>
      </div>
    )}>
      <MainContent />
    </SentryErrorBoundary>
  );
}

# .github/workflows/sentry-release.yml
name: Create Sentry Release

on:
  push:
    branches: [main]

jobs:
  release:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Create Sentry release
        uses: getsentry/action-release@v1
        env:
          SENTRY_AUTH_TOKEN: ${{ secrets.SENTRY_AUTH_TOKEN }}
          SENTRY_ORG: dodatech
          SENTRY_PROJECT: user-service
        with:
          environment: production
          version: dodazip@${{ github.sha }}
          sourcemaps: ./dist
          url_prefix: ~/static/js

// Custom transaction
const transaction = Sentry.startTransaction({
  name: 'User Registration',
  op: 'registration',
  data: {
    method: 'email',
  },
});

Sentry.configureScope(scope => scope.setSpan(transaction));

try {
  // Child span: validation
  const validationSpan = transaction.startChild({
    op: 'validation',
    description: 'Validate user input',
  });
  validateInput(userData);
  validationSpan.finish();

  // Child span: database
  const dbSpan = transaction.startChild({
    op: 'db',
    description: 'Create user in database',
  });
  await createUser(userData);
  dbSpan.finish();

  // Child span: email
  const emailSpan = transaction.startChild({
    op: 'email',
    description: 'Send welcome email',
  });
  await sendEmail(userData.email);
  emailSpan.finish();

  transaction.setStatus('ok');
} catch (error) {
  transaction.setStatus('internal_error');
  Sentry.captureException(error);
} finally {
  transaction.finish();
}