From dbd5c9740b44177527a54cf71daea8f0d162323b Mon Sep 17 00:00:00 2001 From: Charly Gomez Date: Fri, 15 May 2026 14:36:36 +0200 Subject: [PATCH 1/3] add span streaming migration skill --- AGENTS.md | 1 + SKILL_TREE.md | 1 + skills/sentry-feature-setup/SKILL.md | 4 +- skills/sentry-span-streaming/SKILL.md | 395 ++++++++++++++++++++++++++ 4 files changed, 400 insertions(+), 1 deletion(-) create mode 100644 skills/sentry-span-streaming/SKILL.md diff --git a/AGENTS.md b/AGENTS.md index 298c93d..d951123 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -50,6 +50,7 @@ Skills use YAML frontmatter with `allowed-tools` — this is required by Cursor |-------|-------------| | `sentry-setup-ai-monitoring` | Instrument OpenAI/Anthropic/Vercel AI/LangChain/Google GenAI | | `sentry-otel-exporter-setup` | Setup OTel Collector with Sentry Exporter | +| `sentry-span-streaming` | Migrate from transaction-based to streamed span delivery | ### Workflow Skills | Skill | Description | diff --git a/SKILL_TREE.md b/SKILL_TREE.md index 1868835..ab8e2d2 100644 --- a/SKILL_TREE.md +++ b/SKILL_TREE.md @@ -111,6 +111,7 @@ Configure specific Sentry capabilities beyond basic SDK setup. | Create Sentry alerts using the workflow engine API | [`sentry-create-alert`](skills/sentry-create-alert/SKILL.md) | `sentry-create-alert/SKILL.md` | | Configure the OpenTelemetry Collector with Sentry Exporter for multi-project routing and automatic project creation | [`sentry-otel-exporter-setup`](skills/sentry-otel-exporter-setup/SKILL.md) | `sentry-otel-exporter-setup/SKILL.md` | | Setup Sentry AI Agent Monitoring in any project | [`sentry-setup-ai-monitoring`](skills/sentry-setup-ai-monitoring/SKILL.md) | `sentry-setup-ai-monitoring/SKILL.md` | +| Migrate to Sentry span streaming (span-first trace lifecycle) | [`sentry-span-streaming`](skills/sentry-span-streaming/SKILL.md) | `sentry-span-streaming/SKILL.md` | ## Quick Lookup diff --git a/skills/sentry-feature-setup/SKILL.md b/skills/sentry-feature-setup/SKILL.md index 5c5b9ca..beb2e6f 100644 --- a/skills/sentry-feature-setup/SKILL.md +++ b/skills/sentry-feature-setup/SKILL.md @@ -1,6 +1,6 @@ --- name: sentry-feature-setup -description: Configure specific Sentry features beyond basic SDK setup. Use when asked to monitor AI/LLM calls, set up OpenTelemetry pipelines, or create alerts and notifications. +description: Configure specific Sentry features beyond basic SDK setup. Use when asked to monitor AI/LLM calls, set up OpenTelemetry pipelines, create alerts and notifications, or enable span streaming. license: Apache-2.0 role: router --- @@ -26,6 +26,7 @@ Append the path from the `Path` column in the table below to `https://skills.sen 1. If the user mentions **AI monitoring, LLM tracing, or instrumenting an AI SDK** (OpenAI, Anthropic, LangChain, Vercel AI, Google GenAI, Pydantic AI) → `sentry-setup-ai-monitoring` 2. If the user mentions **OpenTelemetry, OTel Collector, or multi-service telemetry routing** → `sentry-otel-exporter-setup` 3. If the user mentions **alerts, notifications, on-call, Slack/PagerDuty/Discord integration, or workflow rules** → `sentry-create-alert` +4. If the user mentions **span streaming, traceLifecycle, spanStreamingIntegration, or switching from transactions to streamed spans** → `sentry-span-streaming` When unclear, **ask the user** which feature they want to configure. Do not guess. @@ -38,6 +39,7 @@ When unclear, **ask the user** which feature they want to configure. Do not gues | AI/LLM monitoring — instrument OpenAI, Anthropic, LangChain, Vercel AI, Google GenAI, Pydantic AI | [`sentry-setup-ai-monitoring`](../sentry-setup-ai-monitoring/SKILL.md) | `sentry-setup-ai-monitoring/SKILL.md` | | OpenTelemetry Collector with Sentry Exporter — multi-project routing, automatic project creation | [`sentry-otel-exporter-setup`](../sentry-otel-exporter-setup/SKILL.md) | `sentry-otel-exporter-setup/SKILL.md` | | Alerts via workflow engine API — email, Slack, PagerDuty, Discord | [`sentry-create-alert`](../sentry-create-alert/SKILL.md) | `sentry-create-alert/SKILL.md` | +| Span streaming — migrate from transaction-based to streamed span delivery | [`sentry-span-streaming`](../sentry-span-streaming/SKILL.md) | `sentry-span-streaming/SKILL.md` | Each skill contains its own detection logic, prerequisites, and step-by-step instructions. Trust the skill — read it carefully and follow it. Do not improvise or take shortcuts. diff --git a/skills/sentry-span-streaming/SKILL.md b/skills/sentry-span-streaming/SKILL.md new file mode 100644 index 0000000..c0de0eb --- /dev/null +++ b/skills/sentry-span-streaming/SKILL.md @@ -0,0 +1,395 @@ +--- +name: sentry-span-streaming +description: Migrate to Sentry span streaming (span-first trace lifecycle). Use when asked to "enable span streaming", "migrate to span streaming", "use traceLifecycle stream", "add spanStreamingIntegration", or switch from transaction-based to streamed span delivery. +license: Apache-2.0 +category: feature-setup +parent: sentry-feature-setup +disable-model-invocation: true +allowed-tools: Bash, Read, Edit, Write, Grep, Glob +--- + +> [All Skills](../../SKILL_TREE.md) > [Feature Setup](../sentry-feature-setup/SKILL.md) > Span Streaming + +# Sentry Span Streaming Migration + +Migrate from the default transaction-based trace lifecycle (`static`) to span streaming (`stream`), where spans are sent individually as they complete instead of being batched into a transaction at the end. + +## Invoke This Skill When + +- User asks to "enable span streaming" or "migrate to span streaming" +- User wants to switch from transaction-based to streamed span delivery +- User mentions `traceLifecycle`, `spanStreamingIntegration`, or `withStreamedSpan` +- User wants lower latency span delivery or per-span processing + +## Prerequisites + +- Sentry JavaScript SDK `>=10.53.1` (span streaming is not available in earlier versions) +- Existing Sentry setup with tracing enabled (`tracesSampleRate` or `tracesSampler` configured) + +--- + +## Phase 1: Detect + +Identify the user's environment, SDK version, and current tracing configuration. + +### 1.1 Detect SDK and Environment + +```bash +# Find Sentry packages and versions +cat package.json 2>/dev/null | grep -E '"@sentry/' + +# Detect if browser, server, or both +grep -rn "from '@sentry/browser'\|from '@sentry/react'\|from '@sentry/vue'\|from '@sentry/angular'\|from '@sentry/svelte'\|from '@sentry/nextjs'\|from '@sentry/nuxt'\|from '@sentry/sveltekit'\|from '@sentry/remix'\|from '@sentry/solidstart'\|from '@sentry/astro'\|from '@sentry/react-router'" --include="*.ts" --include="*.js" --include="*.tsx" --include="*.jsx" --include="*.mjs" -l 2>/dev/null | head -20 + +grep -rn "from '@sentry/node'\|from '@sentry/bun'\|from '@sentry/deno'\|from '@sentry/cloudflare'" --include="*.ts" --include="*.js" --include="*.tsx" --include="*.jsx" --include="*.mjs" -l 2>/dev/null | head -20 +``` + +### 1.2 Find Existing Sentry Config + +```bash +# Find Sentry.init calls +grep -rn "Sentry\.init\|init({" --include="*.ts" --include="*.js" --include="*.tsx" --include="*.jsx" --include="*.mjs" -l 2>/dev/null | head -20 + +# Find beforeSendSpan usage +grep -rn "beforeSendSpan" --include="*.ts" --include="*.js" --include="*.tsx" --include="*.jsx" --include="*.mjs" -l 2>/dev/null + +# Find beforeSendTransaction usage +grep -rn "beforeSendTransaction" --include="*.ts" --include="*.js" --include="*.tsx" --include="*.jsx" --include="*.mjs" -l 2>/dev/null + +# Find ignoreSpans usage +grep -rn "ignoreSpans" --include="*.ts" --include="*.js" --include="*.tsx" --include="*.jsx" --include="*.mjs" -l 2>/dev/null +``` + +### 1.3 Classify Environment + +Based on detection results, classify each `Sentry.init` call as: + +| Environment | Packages | Migration Path | +|---|---|---| +| **Browser** | `@sentry/browser`, `@sentry/react`, `@sentry/vue`, `@sentry/angular`, `@sentry/svelte` | Add `spanStreamingIntegration()` | +| **Server** | `@sentry/node`, `@sentry/bun`, `@sentry/deno`, `@sentry/cloudflare` | Add `traceLifecycle: 'stream'` | +| **Framework (both)** | `@sentry/nextjs`, `@sentry/nuxt`, `@sentry/sveltekit`, `@sentry/remix`, `@sentry/astro`, `@sentry/solidstart`, `@sentry/react-router` | Migrate both client and server configs separately | + +--- + +## Phase 2: Migrate + +Apply changes to each `Sentry.init` call. Work through each file identified in Phase 1. + +### 2.1 Enable Span Streaming + +#### Server-Side SDKs + +Add `traceLifecycle: 'stream'` to `Sentry.init()`: + +```js +// Before +Sentry.init({ + dsn: '...', + tracesSampleRate: 1.0, +}); + +// After +Sentry.init({ + dsn: '...', + tracesSampleRate: 1.0, + traceLifecycle: 'stream', +}); +``` + +#### Browser-Side SDKs + +Add `Sentry.spanStreamingIntegration()` to the `integrations` array. The integration automatically enables `traceLifecycle: 'stream'` — you do not need to set it manually. + +```js +// Before +Sentry.init({ + dsn: '...', + integrations: [ + Sentry.browserTracingIntegration(), + ], + tracesSampleRate: 1.0, +}); + +// After +Sentry.init({ + dsn: '...', + integrations: [ + Sentry.spanStreamingIntegration(), + Sentry.browserTracingIntegration(), + ], + tracesSampleRate: 1.0, +}); +``` + +Place `spanStreamingIntegration()` **before** `browserTracingIntegration()` in the array. + +#### Framework SDKs (Client + Server) + +Apply the browser migration to client config files and the server migration to server config files. Common patterns: + +| Framework | Client Config | Server Config | +|---|---|---| +| Next.js | `sentry.client.config.ts` | `sentry.server.config.ts`, `sentry.edge.config.ts` | +| Nuxt | Client-side `Sentry.init` in module | Server-side `Sentry.init` in module | +| SvelteKit | `src/hooks.client.ts` | `src/hooks.server.ts` | +| Remix | `entry.client.tsx` | `entry.server.tsx` | +| Astro | Client-side init | Server-side init | + +### 2.2 Migrate `beforeSendSpan` + +If the user has a `beforeSendSpan` callback, it **must** be wrapped with `Sentry.withStreamedSpan()` to work in streaming mode. Without this wrapper, the SDK falls back to static mode. + +The callback shape also changes: +- `description` is now `name` +- `data` is now `attributes` +- The span object is `StreamedSpanJSON` instead of `SpanJSON` + +```js +// Before (static mode) +Sentry.init({ + beforeSendSpan: (span) => { + if (span.description?.includes('/health')) { + span.description = '[filtered]'; + } + // 'data' contains span attributes + delete span.data?.['http.request.body']; + return span; + }, +}); + +// After (streaming mode) +Sentry.init({ + traceLifecycle: 'stream', + beforeSendSpan: Sentry.withStreamedSpan((span) => { + if (span.name?.includes('/health')) { + span.name = '[filtered]'; + } + // 'attributes' replaces 'data' + if (span.attributes) { + delete span.attributes['http.request.body']; + } + return span; + }), +}); +``` + +**Key differences in the callback:** + +| Static (`SpanJSON`) | Streaming (`StreamedSpanJSON`) | +|---|---| +| `span.description` | `span.name` | +| `span.data` (processed attributes) | `span.attributes` (raw attributes) | +| `span.timestamp` (end time) | `span.end_timestamp` | +| `span.status` (optional string) | `span.status` (`'ok'` or `'error'`) | +| `span.op` | `span.attributes['sentry.op']` | + +Returning `null` from `beforeSendSpan` does **not** drop the span — it is ignored and a warning is logged. + +### 2.3 Remove or Replace `beforeSendTransaction` + +`beforeSendTransaction` has **no effect** in streaming mode. Spans are sent individually, not batched into transactions. + +```js +// Before +Sentry.init({ + beforeSendTransaction: (event) => { + // This entire callback is ignored in streaming mode + if (event.transaction === '/health') { + return null; + } + return event; + }, +}); +``` + +**Migration paths depending on what `beforeSendTransaction` was used for:** + +| Use Case | Streaming Replacement | +|---|---| +| Drop spans by name/route | Use `ignoreSpans` option | +| Modify span data before send | Use `beforeSendSpan` with `withStreamedSpan` | +| Filter by transaction name | Use `ignoreSpans` with string/RegExp pattern | +| Add tags/context to transaction | Use `beforeSendSpan` with `withStreamedSpan` | + +Remove the `beforeSendTransaction` option from `Sentry.init()` after migrating its logic. + +### 2.4 Configure `ignoreSpans` (Optional) + +`ignoreSpans` works in both static and streaming modes. It filters spans at creation time, preventing them from being recorded or sent. + +```js +Sentry.init({ + traceLifecycle: 'stream', + ignoreSpans: [ + // String match against span name + '/health', + '/ready', + + // RegExp match against span name + /^OPTIONS /, + + // Object filter — all conditions must match + { + op: 'middleware.handle', + name: /^corsMiddleware/, + }, + + // Filter by attributes + { + op: 'http.server', + attributes: { + 'http.route': '/internal/*', + }, + }, + ], +}); +``` + +**Filter object properties:** + +| Property | Type | Matches Against | +|---|---|---| +| `name` | `string \| RegExp` | Span name (description) | +| `op` | `string \| RegExp` | Span operation | +| `attributes` | `Record` | Span attributes | + +When multiple properties are specified in a filter object, **all** must match for the span to be ignored. + +### 2.5 Set Up Browser Profiling (Optional) + +When using span streaming in the browser, use the **v2 profiling options** — not the legacy `profilesSampleRate`. The legacy option is deprecated and does not integrate with the span streaming lifecycle. + +Add `browserProfilingIntegration()` and configure the two v2 options: + +```js +// Before (legacy profiling — do NOT use with span streaming) +Sentry.init({ + integrations: [ + Sentry.browserTracingIntegration(), + ], + tracesSampleRate: 1.0, + profilesSampleRate: 0.5, // deprecated +}); + +// After (v2 profiling with span streaming) +Sentry.init({ + integrations: [ + Sentry.spanStreamingIntegration(), + Sentry.browserTracingIntegration(), + Sentry.browserProfilingIntegration(), + ], + tracesSampleRate: 1.0, + profileSessionSampleRate: 1.0, + profileLifecycle: 'trace', +}); +``` + +**v2 profiling options:** + +| Option | Type | Description | +|---|---|---| +| `profileSessionSampleRate` | `number` (0–1) | Percentage of user sessions that have profiling enabled. Default: `0` (disabled). | +| `profileLifecycle` | `'trace' \| 'manual'` | `'trace'`: profiler runs automatically while sampled root spans exist. `'manual'`: start/stop profiler explicitly via `Sentry.uiProfiler.startProfiler()` / `stopProfiler()`. Default: `'manual'`. | + +**`profileLifecycle: 'trace'`** requires tracing to be enabled (`tracesSampleRate` or `tracesSampler`). The profiler starts when a root span begins and stops when no sampled root spans remain. Profile chunks are sent independently every 60 seconds or when the last root span ends. + +Do **not** mix legacy and v2 options. If `profilesSampleRate` is set, `profileSessionSampleRate` has no effect and the SDK logs a warning. + +--- + +## Phase 3: Verify + +After applying changes, verify the migration works correctly. + +### 3.1 Build Check + +```bash +# TypeScript check +npx tsc --noEmit 2>&1 | head -30 + +# Build +npm run build 2>&1 | tail -20 +``` + +### 3.2 Runtime Verification + +Instruct the user to verify in their browser devtools or server logs: + +1. **Check network tab**: Span envelopes should appear as individual requests with content type `application/vnd.sentry.items.span.v2+json` rather than transaction envelopes +2. **Check Sentry dashboard**: Spans should appear in the Traces view shortly after they complete, without waiting for the full transaction to finish +3. **Check for fallback warnings**: If the SDK logs warnings about falling back to static mode, the `beforeSendSpan` callback is likely missing the `withStreamedSpan` wrapper + +### 3.3 Common Issues + +| Symptom | Cause | Fix | +|---|---|---| +| SDK falls back to static mode | `beforeSendSpan` not wrapped with `withStreamedSpan` | Wrap callback: `Sentry.withStreamedSpan(callback)` | +| `beforeSendTransaction` not called | Expected in streaming mode | Migrate logic to `beforeSendSpan` or `ignoreSpans` | +| Spans still arrive as transactions | `traceLifecycle` not set or integration missing | Server: add `traceLifecycle: 'stream'`; Browser: add `spanStreamingIntegration()` | +| Type errors on `span.description` | `StreamedSpanJSON` uses `name` not `description` | Change `span.description` to `span.name` in callback | +| Type errors on `span.data` | `StreamedSpanJSON` uses `attributes` not `data` | Change `span.data` to `span.attributes` in callback | +| `profileSessionSampleRate` has no effect | Legacy `profilesSampleRate` is also set | Remove `profilesSampleRate` and use only `profileSessionSampleRate` + `profileLifecycle` | + +--- + +## Quick Reference + +### Minimal Server Setup + +```js +import * as Sentry from '@sentry/node'; + +Sentry.init({ + dsn: '__DSN__', + tracesSampleRate: 1.0, + traceLifecycle: 'stream', +}); +``` + +### Minimal Browser Setup + +```js +import * as Sentry from '@sentry/browser'; + +Sentry.init({ + dsn: '__DSN__', + integrations: [ + Sentry.spanStreamingIntegration(), + Sentry.browserTracingIntegration(), + ], + tracesSampleRate: 1.0, +}); +``` + +### Browser Setup with Profiling + +```js +import * as Sentry from '@sentry/browser'; + +Sentry.init({ + dsn: '__DSN__', + integrations: [ + Sentry.spanStreamingIntegration(), + Sentry.browserTracingIntegration(), + Sentry.browserProfilingIntegration(), + ], + tracesSampleRate: 1.0, + profileSessionSampleRate: 1.0, + profileLifecycle: 'trace', +}); +``` + +### Full Migration Checklist + +- [ ] SDK version is `>=10.53.1` +- [ ] Server configs: added `traceLifecycle: 'stream'` +- [ ] Browser configs: added `spanStreamingIntegration()` before `browserTracingIntegration()` +- [ ] `beforeSendSpan` callbacks wrapped with `Sentry.withStreamedSpan()` +- [ ] `beforeSendSpan` callbacks updated: `description` -> `name`, `data` -> `attributes` +- [ ] `beforeSendTransaction` logic migrated to `beforeSendSpan` or `ignoreSpans` +- [ ] `beforeSendTransaction` removed from config +- [ ] (If profiling) Replaced `profilesSampleRate` with `profileSessionSampleRate` + `profileLifecycle` +- [ ] (If profiling) Added `browserProfilingIntegration()` to integrations +- [ ] Build passes with no type errors +- [ ] Spans visible in Sentry dashboard From 62630daf05360a47b10af657214a84bc1cea60df Mon Sep 17 00:00:00 2001 From: Charly Gomez Date: Fri, 15 May 2026 14:42:30 +0200 Subject: [PATCH 2/3] platform agnostic --- skills/sentry-span-streaming/SKILL.md | 44 +++++++++++++++++++++------ 1 file changed, 34 insertions(+), 10 deletions(-) diff --git a/skills/sentry-span-streaming/SKILL.md b/skills/sentry-span-streaming/SKILL.md index c0de0eb..208ced7 100644 --- a/skills/sentry-span-streaming/SKILL.md +++ b/skills/sentry-span-streaming/SKILL.md @@ -21,30 +21,52 @@ Migrate from the default transaction-based trace lifecycle (`static`) to span st - User mentions `traceLifecycle`, `spanStreamingIntegration`, or `withStreamedSpan` - User wants lower latency span delivery or per-span processing -## Prerequisites +## Supported Platforms -- Sentry JavaScript SDK `>=10.53.1` (span streaming is not available in earlier versions) -- Existing Sentry setup with tracing enabled (`tracesSampleRate` or `tracesSampler` configured) +| Platform | Status | +|---|---| +| JavaScript (Browser, Node.js, Bun, Deno, Cloudflare) | Supported | +| Python | Not yet available | +| Ruby | Not yet available | +| Go | Not yet available | +| Other SDKs | Not yet available | + +If the user's project does not use a JavaScript Sentry SDK, inform them that span streaming is currently only available for JavaScript SDKs and stop here. --- ## Phase 1: Detect -Identify the user's environment, SDK version, and current tracing configuration. +Identify the user's platform, SDK version, and current tracing configuration. -### 1.1 Detect SDK and Environment +### 1.1 Detect Platform and SDK ```bash -# Find Sentry packages and versions +# Check for JavaScript Sentry packages cat package.json 2>/dev/null | grep -E '"@sentry/' +# Check for Python Sentry +cat requirements.txt setup.py pyproject.toml 2>/dev/null | grep -i sentry + +# Check for Ruby Sentry +cat Gemfile 2>/dev/null | grep sentry + +# Check for Go Sentry +cat go.mod 2>/dev/null | grep sentry +``` + +If a non-JavaScript Sentry SDK is detected, inform the user that span streaming is not yet available for their platform. + +### 1.2 Detect JavaScript Environment + +```bash # Detect if browser, server, or both grep -rn "from '@sentry/browser'\|from '@sentry/react'\|from '@sentry/vue'\|from '@sentry/angular'\|from '@sentry/svelte'\|from '@sentry/nextjs'\|from '@sentry/nuxt'\|from '@sentry/sveltekit'\|from '@sentry/remix'\|from '@sentry/solidstart'\|from '@sentry/astro'\|from '@sentry/react-router'" --include="*.ts" --include="*.js" --include="*.tsx" --include="*.jsx" --include="*.mjs" -l 2>/dev/null | head -20 grep -rn "from '@sentry/node'\|from '@sentry/bun'\|from '@sentry/deno'\|from '@sentry/cloudflare'" --include="*.ts" --include="*.js" --include="*.tsx" --include="*.jsx" --include="*.mjs" -l 2>/dev/null | head -20 ``` -### 1.2 Find Existing Sentry Config +### 1.3 Find Existing Sentry Config ```bash # Find Sentry.init calls @@ -60,7 +82,7 @@ grep -rn "beforeSendTransaction" --include="*.ts" --include="*.js" --include="*. grep -rn "ignoreSpans" --include="*.ts" --include="*.js" --include="*.tsx" --include="*.jsx" --include="*.mjs" -l 2>/dev/null ``` -### 1.3 Classify Environment +### 1.4 Classify Environment Based on detection results, classify each `Sentry.init` call as: @@ -72,7 +94,9 @@ Based on detection results, classify each `Sentry.init` call as: --- -## Phase 2: Migrate +## Phase 2: Migrate (JavaScript) + +**Prerequisites:** Sentry JavaScript SDK `>=10.53.1` with tracing enabled (`tracesSampleRate` or `tracesSampler` configured). Apply changes to each `Sentry.init` call. Work through each file identified in Phase 1. @@ -333,7 +357,7 @@ Instruct the user to verify in their browser devtools or server logs: --- -## Quick Reference +## Quick Reference (JavaScript) ### Minimal Server Setup From be477833749194cf486ef74359e3cec0fa7d99ea Mon Sep 17 00:00:00 2001 From: Charly Gomez Date: Mon, 18 May 2026 10:49:13 +0200 Subject: [PATCH 3/3] fix: Use RegExp instead of glob pattern in ignoreSpans example String matching in ignoreSpans uses substring includes, not glob patterns. The `*` was treated as a literal character. Co-Authored-By: Claude Opus 4.6 (1M context) --- skills/sentry-span-streaming/SKILL.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/skills/sentry-span-streaming/SKILL.md b/skills/sentry-span-streaming/SKILL.md index 208ced7..af215be 100644 --- a/skills/sentry-span-streaming/SKILL.md +++ b/skills/sentry-span-streaming/SKILL.md @@ -259,11 +259,11 @@ Sentry.init({ name: /^corsMiddleware/, }, - // Filter by attributes + // Filter by attributes (string = substring match, RegExp for patterns) { op: 'http.server', attributes: { - 'http.route': '/internal/*', + 'http.route': /^\/internal\//, }, }, ],