sentry-architecture-variants

•

1.9k2663 months ago

Execute sentry architecture patterns for different application types. Use when setting up Sentry for monoliths, microservices, serverless, or hybrid architectures. Trigger with phrases like "sentry monolith setup", "sentry microservices", "sentry serverless", "sentry architecture pattern".

Quick Install

npxskills add jeremylongshore/claude-code-plugins-plus-skills--skill sentry-architecture-variants

Instructions

Sentry Architecture Variants

Overview

Choose the right Sentry SDK, project layout, and tracing strategy for each application architecture. Every pattern below uses Sentry SDK v8 APIs — @sentry/node, @sentry/browser, @sentry/react, @sentry/react-native, @sentry/aws-serverless, and @sentry/google-cloud-serverless. The goal is one coherent trace from the user's device through every backend hop, regardless of how many runtimes or deployment targets sit in between.

Prerequisites

Loading…

Related Skills

skill-creator

Create or update AgentSkills. Use when designing, structuring, or packaging skills with scripts, references, and assets.

367,360

skill-creator

Create or update AgentSkills. Use when designing, structuring, or packaging skills with scripts, references, and assets.

367,309

1password

Set up and use 1Password CLI (op). Use when installing the CLI, enabling desktop app integration, signing in (single or multi-account), or reading/injecting/running secrets via op.

365,915

himalaya

CLI to manage emails via IMAP/SMTP. Use `himalaya` to list, read, write, reply, forward, search, and organize emails from the terminal. Supports multiple accounts and message composition with MML (MIME Meta Language).

365,885

Tags & Topics

aiautomationclaude-codedevopsmcpai-agents

Architecture	SDK Package	Sentry Projects	Key Integration
Monolith	`@sentry/node`	1 project, env tags	Module tags + ownership rules
Microservices	`@sentry/node` (per service)	1 project per service	Distributed tracing via headers
Serverless (Lambda)	`@sentry/aws-serverless`	1 per function group	`Sentry.wrapHandler()` + auto-flush
Serverless (GCP)	`@sentry/google-cloud-serverless`	1 per function group	`Sentry.wrapCloudEventFunction()`
Event-driven (Kafka/SQS)	`@sentry/node`	1 per consumer group	`continueTrace()` from message headers
Frontend SPA	`@sentry/browser` or `@sentry/react`	1 frontend project	`browserTracingIntegration()`
Mobile (React Native)	`@sentry/react-native`	1 mobile project	Native crash reporting + JS errors
Hybrid	Mix of above	1 per deployment target	Cross-platform trace correlation

# Monolith / Microservices / Event-driven
npm install @sentry/node @sentry/profiling-node

# Serverless — AWS Lambda
npm install @sentry/aws-serverless

# Serverless — Google Cloud Functions
npm install @sentry/google-cloud-serverless

# Frontend SPA (React)
npm install @sentry/react

# Mobile — React Native
npx @sentry/wizard@latest -i reactNative

// instrument.mjs — load via: node --import ./instrument.mjs app.js
import * as Sentry from '@sentry/node';

Sentry.init({
  dsn: process.env.SENTRY_DSN,
  environment: process.env.NODE_ENV,
  release: process.env.APP_VERSION,
  tracesSampleRate: 0.1,
  initialScope: { tags: { app: 'monolith' } },
});

// Tag errors by module so each team sees only their issues
function captureModuleError(module: string, error: Error) {
  Sentry.withScope((scope) => {
    scope.setTag('module', module);
    scope.setTag('team', getTeamForModule(module));
    Sentry.captureException(error);
  });
}

// Module-based breadcrumbs for traceability
Sentry.addBreadcrumb({ category: 'auth', message: 'Login attempt', level: 'info' });
captureModuleError('auth', new Error('Token expired'));
// Dashboard ownership: tags.module:auth → #platform-team

// packages/sentry-config/index.ts — shared across all services
import * as Sentry from '@sentry/node';

export function initServiceSentry(serviceName: string) {
  Sentry.init({
    dsn: process.env.SENTRY_DSN,
    environment: process.env.NODE_ENV,
    release: `${serviceName}@${process.env.APP_VERSION}`,
    serverName: serviceName,
    tracesSampleRate: 0.1,
    sendDefaultPii: false,
    initialScope: {
      tags: {
        service: serviceName,
        cluster: process.env.K8S_CLUSTER || 'default',
        namespace: process.env.K8S_NAMESPACE || 'default',
      },
    },
  });
}
// Usage: initServiceSentry('api-gateway');

// AWS Lambda — handler.ts
import * as Sentry from '@sentry/aws-serverless';

Sentry.init({
  dsn: process.env.SENTRY_DSN,
  environment: process.env.STAGE,
  tracesSampleRate: 0.1,
});

export const handler = Sentry.wrapHandler(async (event, context) => {
  Sentry.setTag('function', context.functionName);
  Sentry.setTag('region', process.env.AWS_REGION);

  // Track cold starts
  const isColdStart = !global.__sentryWarm;
  global.__sentryWarm = true;
  Sentry.setTag('cold_start', String(isColdStart));

  const result = await processRequest(event);
  return { statusCode: 200, body: JSON.stringify(result) };
});
// wrapHandler auto-calls flush() — do NOT call it yourself (double-flush causes timeout)

// Google Cloud Functions — index.ts
import * as Sentry from '@sentry/google-cloud-serverless';

Sentry.init({ dsn: process.env.SENTRY_DSN, tracesSampleRate: 0.1 });

export const httpHandler = Sentry.wrapHttpFunction(async (req, res) => {
  res.json(await processRequest(req.body));
});

export const eventHandler = Sentry.wrapCloudEventFunction(async (event) => {
  await processEvent(event.data);
});

import * as Sentry from '@sentry/node';

// Producer: embed trace context in message headers
async function publishToKafka(topic: string, payload: object) {
  const activeSpan = Sentry.getActiveSpan();
  const headers: Record<string, string> = {};
  if (activeSpan) {
    headers['sentry-trace'] = Sentry.spanToTraceHeader(activeSpan);
    headers['baggage'] = Sentry.spanToBaggageHeader(activeSpan) || '';
  }
  await Sentry.startSpan(
    { name: `kafka.produce.${topic}`, op: 'queue.publish' },
    () => kafka.send({ topic, messages: [{ value: JSON.stringify(payload), headers }] })
  );
}

// Consumer: continue the producer's trace
async function consumeFromKafka(message: KafkaMessage) {
  const headers = message.headers || {};
  Sentry.continueTrace(
    {
      sentryTrace: headers['sentry-trace']?.toString(), // Buffer → string
      baggage: headers['baggage']?.toString(),
    },
    () => {
      Sentry.startSpan(
        { name: `kafka.consume.${message.topic}`, op: 'queue.process' },
        async (span) => {
          try {
            await processMessage(message);
            span.setStatus({ code: 1 });
          } catch (error) {
            span.setStatus({ code: 2, message: 'consumer_error' });
            Sentry.captureException(error);
            throw error;
          }
        }
      );
    }
  );
}

import * as Sentry from '@sentry/react';

Sentry.init({
  dsn: process.env.REACT_APP_SENTRY_DSN,
  release: process.env.REACT_APP_VERSION,
  tracesSampleRate: 0.1,
  replaysOnErrorSampleRate: 1.0,
  integrations: [
    Sentry.browserTracingIntegration(),
    Sentry.replayIntegration({ maskAllText: true, blockAllMedia: true }),
  ],
  // Must match your API domain or frontend-to-backend traces break
  tracePropagationTargets: ['localhost', /^https:\/\/api\.yourapp\.com/],
});

import * as Sentry from '@sentry/react-native';

Sentry.init({
  dsn: process.env.SENTRY_DSN,
  tracesSampleRate: 0.2,
  integrations: [
    Sentry.reactNativeTracingIntegration({
      routingInstrumentation: Sentry.reactNavigationIntegration(),
    }),
  ],
  tracePropagationTargets: [/^https:\/\/api\.yourapp\.com/],
  enableNativeCrashHandling: true,
  attachScreenshot: true,
  attachViewHierarchy: true,
});

export default Sentry.wrap(App);
// Upload source maps + dSYMs in CI — see mobile deep-dive

Architecture	Projects	Tracing Strategy	SDK Flush	Key Gotcha
Monolith	1	Single-service spans	Automatic	Module tag cardinality — keep under 50
Microservices	1 per service	Distributed via HTTP headers	Automatic	Missing `baggage` breaks sampling
Serverless	1 per function group	Per-invocation, auto-flush	`wrapHandler()`	Double-flush causes timeout
Event-driven	1 per consumer group	`continueTrace()` from headers	Manual periodic	DLQ needs separate error capture
Frontend SPA	1	`browserTracingIntegration()`	Automatic (beacon)	`tracePropagationTargets` required
Mobile	1	`reactNativeTracingIntegration()`	Automatic	Source maps + dSYMs required
Hybrid	Mix of above	End-to-end header propagation	Per-component	One missing link breaks whole trace

Error	Cause	Solution
Distributed traces broken	Missing header propagation	Verify `sentry-trace` AND `baggage` headers in every inter-service call
Lambda events lost after timeout	Calling `flush()` inside `wrapHandler`	Remove manual `flush()` — `wrapHandler` auto-flushes
Kafka consumer traces disconnected	Headers not serialized as strings	Call `.toString()` on Kafka message headers before `continueTrace()`
SPA traces stop at API boundary	`tracePropagationTargets` missing	Add API domain regex to browser SDK init
React Native traces unreadable	Missing source maps / dSYMs	Run `sentry-cli sourcemaps upload` and `sentry-cli upload-dif` in CI
Multi-tenant data leakage	`setTag()` at global scope	Use `withScope()` per request — global tags persist across requests
Worker events silently dropped	No periodic flush	Add `setInterval(() => Sentry.flush(2000), 30_000)`
High cardinality alert	Dynamic values in span names	Use parameterized names: `kafka.consume.orders` not `kafka.consume.order-12345`

sentry-architecture-variants

Sentry Architecture Variants

Overview

Prerequisites

Related Skills

skill-creator

skill-creator

1password

himalaya

Sentry Architecture Variants

Overview

Prerequisites

Instructions

Step 1 — Identify Your Architecture and Select SDK Packages

Step 2 — Initialize Sentry for Each Architecture Pattern

Monolith — Single Project, Module Tags

Microservices — Project-per-Service, Distributed Tracing

Serverless — Lambda and Cloud Functions

Event-Driven — Kafka, SQS, and Message Queues

Frontend SPA — Browser and React

Mobile — React Native

Step 3 — Wire Up Hybrid and Cross-Platform Tracing

Output

Error Handling

Examples

Resources

Next Steps

Related Skills

skill-creator

skill-creator

1password

himalaya

Related Skills

skill-creator

skill-creator

1password

himalaya