Interactive v11 Migration Guide for Browser JavaScript
Migrate from Sentry JavaScript SDK 10.x to 11.x with an interactive checklist for your platform.
Using a framework?
Make sure to select your framework in the dropdown in the top left corner of the page.
Use curl to download and read https://docs.sentry.io/platforms/javascript/migration/v10-to-v11.md before making changes. Upgrade this project from Sentry JavaScript SDK v10 to v11. Inspect the project's Sentry packages, configuration, runtime, and framework versions, then apply every migration step that applies. Preserve the intended data collection behavior when migrating sendDefaultPii to dataCollection. Use the project's package manager to update dependencies and its existing checks to verify the migration. Summarize the changes and any remaining manual steps.Version 11 of the Sentry JavaScript SDK focuses on better OpenTelemetry interoperability, more flexible instrumentation, and better out-of-the-box defaults. It raises the minimum versions of Node.js, TypeScript, and several frameworks.
We recommend upgrading to the most recent 10.x release first, because most of what v11 removes is already deprecated there.
This checklist shows all migration steps for your selected platform. Some steps only apply to specific integrations or configuration options. For the full write-up of every change, see the migration guide.
TypeScript and other tooling won't catch all of these changes. Read through the steps below before upgrading, rather than upgrading and fixing what breaks.
Check prerequisites
4 leftRuntime, language and framework versions you need before upgrading.
Self-hosted Sentry 26.4.2 is the new minimum
Action requiredVersion 11 of the SDK requires Sentry self-hosted 26.4.2 or higher. Lower versions may continue to work, but are not supported. We recommend that you update self-hosted Sentry to the latest version.
Node.js 20.19.0 is the new minimum
Action requiredNode.js 18 is no longer supported. The minimum is 20.19.0, and Node.js 22 needs 22.12 or higher while Node.js 23 needs 23.2 or higher (>=20.19.0 <22.0.0 || >=22.12.0 <23.0.0 || >=23.2.0).
Move to a supported version everywhere the SDK is installed or your app is built: Dockerfiles, CI images, engines, .nvmrc, and serverless runtime settings.
The same supported Node.js range applies if you use Node.js to install dependencies or build a browser project. Loading the SDK directly in a browser from a CDN does not require Node.js.
Safari 14 support was dropped
Behavior changeSafari 14 is no longer supported. It lacks performance.timeOrigin and full visibilitychange support, which the web vitals instrumentation had to work around. The SDK still requires ES2020, so the rest of the matrix is unchanged:
- Chrome 80
- Edge 80
- Safari 15, iOS Safari 15
- Firefox 74
- Opera 67
- Samsung Internet 13.0
The same supported Node.js range applies if you use Node.js to install dependencies or build a browser project. Loading the SDK directly in a browser from a CDN does not require Node.js.
TypeScript 5.0.4 is the new minimum
Action requiredThe minimum required TypeScript version is 5.0.4. The SDK no longer ships down-leveled types. Older TypeScript versions may continue to work, but no guarantees apply.
Update packages
4 leftInstalls, removals and moved entry points.
`@sentry/types` is no longer published
Action required@sentry/types is no longer published. Import all types from @sentry/core. The package has only re-exported from @sentry/core since v8.
Browser and server exports moved to `@sentry/core` subpaths
Action required@sentry/core exports only isomorphic code now. Browser-only exports live on @sentry/core/browser and server-only ones on @sentry/core/server, which keeps server code out of browser bundles. This only affects imports straight from @sentry/core, since the platform SDKs re-export as before. TypeScript reports it as has no exported member.
// Before
import { loadModule, trpcMiddleware } from "@sentry/core";
import type { BrowserClientReplayOptions } from "@sentry/core";
// After
import { loadModule, trpcMiddleware } from "@sentry/core/server";
import type { BrowserClientReplayOptions } from "@sentry/core/browser";
// Before
import { loadModule, trpcMiddleware } from "@sentry/core";
import type { BrowserClientReplayOptions } from "@sentry/core";
// After
import { loadModule, trpcMiddleware } from "@sentry/core/server";
import type { BrowserClientReplayOptions } from "@sentry/core/browser";
Metrics moved out of the base CDN bundle
Action requiredMetrics moved out of the base CDN bundle. They ship only in the *.logs.metrics bundles now. On the other bundles, Sentry.metrics.* is a no-op that warns in debug builds.
The webpack plugin requires webpack 5.1 and a new import path
Action requiredThe Sentry webpack plugin requires webpack 5.1 or newer. The @sentry/bundler-plugins/webpack5 entry point was removed. Update imports to @sentry/bundler-plugins/webpack:
// Before
import { sentryWebpackPlugin } from "@sentry/bundler-plugins/webpack5";
// After
import { sentryWebpackPlugin } from "@sentry/bundler-plugins/webpack";
// Before
import { sentryWebpackPlugin } from "@sentry/bundler-plugins/webpack5";
// After
import { sentryWebpackPlugin } from "@sentry/bundler-plugins/webpack";
Make required code changes
20 leftOptions, APIs and config that changed and need your attention.
`sendDefaultPii` is replaced by `dataCollection`
Action requiredsendDefaultPii is replaced by dataCollection, which controls each category of collected data separately. Our blog post The Data Collection Control Panel covers the thinking behind it.
This is a behavior change, not a rename. In v10, an unset sendDefaultPii was restrictive. In v11, an unset dataCollection collects everything by default.
| Category | v10 default (sendDefaultPii off) | v11 default |
|---|---|---|
userInfo | false | true |
cookies | not collected | true |
httpHeaders | request + response, PII scrubbed | request + response |
httpBodies | not collected (size only) | all request/response |
urlQueryParams | true | true |
genAI | inputs + outputs not collected | inputs + outputs |
databaseQueryData | false | true |
stackFrameVariables | true | true |
frameContextLines | 7 | 5 |
If you set sendDefaultPii: true, remove it. The v11 default matches that behavior.
If you relied on the v10 default, set the baseline explicitly.
Sentry scrubs values whose key looks sensitive (e.g. auth, token, secret, password). The match runs on the key name, so treat it as best effort: a credential in a field that isn't named like one still reaches Sentry. Review your data scrubbing config for the categories v11 collects now, especially request and response bodies.
See the dataCollection option for the full list of categories.
Span streaming is now the default
Behavior changeTracing moves to span streaming in v11. Instead of holding a trace in memory and sending one transaction when the root span ends, the SDK sends spans in small batches as they finish. Transactions no longer exist: what used to be one transaction event is a service span with its child spans.
That changes how spans are sent, named, and filtered. Most of it isn't caught by TypeScript, so check your filters, dashboards, and alerts.
Spans are no longer capped at 1000 per transaction, and individual payload limits are higher. See stream mode for how it works.
Because no transaction events are produced, beforeSendTransaction and ignoreTransactions no longer do anything, and beforeSendSpan receives a different payload.
Scope tags and extra no longer apply to spans
Action requiredStreamed spans only carry attributes, so scope tags and extra no longer reach any span, including the service span that replaced the transaction. They still apply to errors, so you don't have to remove them. In transaction mode (traceLifecycle: 'static') they keep landing on the transaction as before.
Set attributes for everything that should be searchable on spans, which also applies them to logs and metrics:
// Before: applied to the transaction
Sentry.setTag("order_id", order.id);
Sentry.setTags({ user_tier: user.tier });
// After: applied to spans, logs, and metrics
Sentry.setAttribute("order_id", order.id);
Sentry.setAttributes({ user_tier: user.tier });
// Before: applied to the transaction
Sentry.setTag("order_id", order.id);
Sentry.setTags({ user_tier: user.tier });
// After: applied to spans, logs, and metrics
Sentry.setAttribute("order_id", order.id);
Sentry.setAttributes({ user_tier: user.tier });
Attributes accept strings, numbers, booleans, and arrays of those, so numbers and booleans no longer have to be stringified. Like tags, they can be set on a specific scope:
// Applied to all spans, logs, and metrics of the application
Sentry.getGlobalScope().setAttributes({ "app.version": "2.1.0" });
// Applied to a single operation
Sentry.withScope((scope) => {
scope.setAttribute("checkout.step", "payment");
});
// Applied to all spans, logs, and metrics of the application
Sentry.getGlobalScope().setAttributes({ "app.version": "2.1.0" });
// Applied to a single operation
Sentry.withScope((scope) => {
scope.setAttribute("checkout.step", "payment");
});
`beforeSendSpan` receives the streamed span format
Action requiredbeforeSendSpan now runs as each span finishes and receives a StreamedSpanJSON object. Its fields were renamed:
Before (SpanJSON) | After (StreamedSpanJSON) |
|---|---|
description | name |
data | attributes |
op | attributes['sentry.op'] |
timestamp | end_timestamp |
status (string) | status ('ok' or 'error') |
// Before
Sentry.init({
beforeSendSpan: (span) => {
if (span.op === "db.query") {
span.description = scrub(span.description);
span.data["db.statement"] = scrub(span.data["db.statement"]);
}
return span;
},
});
// After
Sentry.init({
beforeSendSpan: (span) => {
if (span.attributes["sentry.op"] === "db.query") {
span.name = scrub(span.name);
span.attributes["db.query.text"] = scrub(
span.attributes["db.query.text"]
);
}
return span;
},
});
// Before
Sentry.init({
beforeSendSpan: (span) => {
if (span.op === "db.query") {
span.description = scrub(span.description);
span.data["db.statement"] = scrub(span.data["db.statement"]);
}
return span;
},
});
// After
Sentry.init({
beforeSendSpan: (span) => {
if (span.attributes["sentry.op"] === "db.query") {
span.name = scrub(span.name);
span.attributes["db.query.text"] = scrub(
span.attributes["db.query.text"]
);
}
return span;
},
});
The status field of that payload is always set, and holds only 'ok' or 'error'. The finer-grained statuses of v10 (internal_error, not_found, and the rest) all map to 'error', with the original value kept on the span's sentry.status.message attribute.
If you used withStreamedSpan(), remove the wrapper.
A callback that doesn't match your traceLifecycle is never invoked: an unwrapped one is ignored in transaction mode, a wrapped one in stream mode. In transaction mode, wrap it with Sentry.withStaticSpan() and it keeps receiving the old SpanJSON. Turn on debug logging to see a warning about the mismatch.
`beforeSendTransaction` no longer runs
Action requiredMove data changes to beforeSendSpan and guard on is_segment to target the service span, which is what used to be the transaction. Use ignoreSpans to drop spans: beforeSendSpan can only change spans, not drop them.
// Before
Sentry.init({
ignoreTransactions: ["GET /health"],
beforeSendTransaction: (event) => {
event.transaction = scrubIds(event.transaction);
return event;
},
});
// After
Sentry.init({
ignoreSpans: ["GET /health"],
beforeSendSpan: (span) => {
if (span.is_segment) {
span.name = scrubIds(span.name);
}
return span;
},
});
// Before
Sentry.init({
ignoreTransactions: ["GET /health"],
beforeSendTransaction: (event) => {
event.transaction = scrubIds(event.transaction);
return event;
},
});
// After
Sentry.init({
ignoreSpans: ["GET /health"],
beforeSendSpan: (span) => {
if (span.is_segment) {
span.name = scrubIds(span.name);
}
return span;
},
});
Scope tags and extra aren't carried over to streamed spans either.
`ignoreTransactions` is replaced by `ignoreSpans`
Action requiredignoreTransactions no longer does anything in stream mode because no transaction events are produced. Use ignoreSpans to drop spans.
Ignoring a service span drops its child spans with it, which is the same result as dropping a transaction. Because ignoreSpans applies to every span, narrow the filter with the object form so that child spans with the same name are kept:
Sentry.init({
ignoreSpans: [
{ name: "GET /health", attributes: { "sentry.op": "http.server" } },
],
});
Sentry.init({
ignoreSpans: [
{ name: "GET /health", attributes: { "sentry.op": "http.server" } },
],
});
`spanToJSON` returns the streamed span format
Action requiredSentry.spanToJSON() now returns a StreamedSpanJSON object, the same shape beforeSendSpan receives. The spanToStreamedSpanJSON helper was removed, so replace calls to it with spanToJSON.
Opting out of span streaming
FYISet traceLifecycle: 'static' to keep the previous model. In Node.js, Bun, Vercel Edge, and Cloudflare you can set the SENTRY_TRACE_LIFECYCLE=static environment variable instead.
Sentry.init({
traceLifecycle: "static",
// `beforeSendSpan` must be wrapped with `Sentry.withStaticSpan`
beforeSendSpan: Sentry.withStaticSpan((span) => {
span.description = scrub(span.description);
return span;
}),
});
Sentry.init({
traceLifecycle: "static",
// `beforeSendSpan` must be wrapped with `Sentry.withStaticSpan`
beforeSendSpan: Sentry.withStaticSpan((span) => {
span.description = scrub(span.description);
return span;
}),
});
In transaction mode, spanToStaticSpanJSON returns the static SpanJSON format.
Transaction mode only exists for backwards compatibility and will be removed in a future major version. Treat it as a temporary measure.
Span names are low cardinality
Behavior changeIn stream mode, span names follow the Sentry span name conventions. URLs, route parameters, and other client-supplied values are no longer part of the name:
| Span op | Before | After |
|---|---|---|
http.client | GET https://api.example.com/users/123 | GET api.example.com |
http.server | GET /users/123 | GET /users/:id, or GET |
pageload, navigation | /users/123 | /users/:id, or Pageload |
resource.* | /assets/app.js | cdn.example.com, or Resource |
graphql | query GetUser | GraphQL query |
queue.* | my-queue process, poll my-topic | process my-queue, receive my-topic |
db.query | SELECT * FROM "User" WHERE "id" = $1 | SELECT "User", or Database operation |
http.server names are unchanged when the SDK resolves a route, and fall back to the method alone when it can't. pageload and navigation fall back to Pageload and Navigation.
Database spans work the same way: a statement that touches no table (SELECT NOW()) summarizes to the bare operation (SELECT), and without a statement to summarize the name falls back to the database namespace, then to Database operation.
Whatever the name no longer carries stays on an attribute, in both trace lifecycles: url.full and url.domain, graphql.operation.name and the new graphql.processing.type, db.query.text, and so on.
ignoreSpans and tracesSampler both run when a span starts, so a span may not have its final name yet. Match on attributes instead:
Sentry.init({
// Before
ignoreSpans: ["/health", "SELECT * FROM health_check"],
tracesSampler: ({ name, inheritOrSampleWith }) =>
inheritOrSampleWith(name === "GET /health" ? 0 : 1),
// After
ignoreSpans: [
{ attributes: { "sentry.op": "pageload", "url.path": "/health" } },
{ attributes: { "db.query.text": "SELECT * FROM health_check" } },
],
tracesSampler: ({ attributes, inheritOrSampleWith }) =>
inheritOrSampleWith(attributes?.["url.path"] === "/health" ? 0 : 1),
});
Sentry.init({
// Before
ignoreSpans: ["/health", "SELECT * FROM health_check"],
tracesSampler: ({ name, inheritOrSampleWith }) =>
inheritOrSampleWith(name === "GET /health" ? 0 : 1),
// After
ignoreSpans: [
{ attributes: { "sentry.op": "pageload", "url.path": "/health" } },
{ attributes: { "db.query.text": "SELECT * FROM health_check" } },
],
tracesSampler: ({ attributes, inheritOrSampleWith }) =>
inheritOrSampleWith(attributes?.["url.path"] === "/health" ? 0 : 1),
});
The `enableLogs` option was removed
Action requiredThe enableLogs option was removed, including its _experiments variant. Logs are captured whenever you use their API (Sentry.logger.*) or add a logging integration such as consoleLoggingIntegration().
// Before
Sentry.init({
enableLogs: true,
});
// After
Sentry.init({});
// Before
Sentry.init({
enableLogs: true,
});
// After
Sentry.init({});
The `enableMetrics` option was removed
Action requiredThe enableMetrics option was removed, including its _experiments variant. Metrics are captured whenever you use their API (Sentry.metrics.*). The _experiments.beforeSendMetric callback moved to the top-level beforeSendMetric option.
// Before
Sentry.init({
_experiments: {
enableMetrics: true,
beforeSendMetric: (metric) => metric,
},
});
// After
Sentry.init({
beforeSendMetric: (metric) => metric,
});
// Before
Sentry.init({
_experiments: {
enableMetrics: true,
beforeSendMetric: (metric) => metric,
},
});
// After
Sentry.init({
beforeSendMetric: (metric) => metric,
});
`@sentry/core` API removals
Action requiredThe following APIs were removed:
Scope.clear()was removed. To reset scope state, re-initialize the SDK or run your code in a fresh scope withwithScopeorwithIsolationScope.- The
disableInstrumentationWarningsoption and theMissingInstrumentationContexttype were removed. With channel-based instrumentation, the SDK can no longer detect that a framework was imported beforeSentry.init(). createSpanEnvelopeand theSpanEnvelopeandSpanItemtypes were removed. Standalone spans are gone: spans are sent on their transaction, or as streamed spans.- The positional
spanOriginargument ofinstrumentFetchRequestwas removed. Pass an options object as the last argument instead. - The internal
addAutoIpAddressToUserexport was removed.
The low-level propagateTrace option of getHttpClientSubscriptions and patchHttpModuleClient is called tracePropagation now, matching the httpIntegration option of the same name.
Console breadcrumbs moved to `consoleIntegration`
Action requiredThe console option of breadcrumbsIntegration was removed. Console breadcrumbs come from the default consoleIntegration now, which matches the server SDKs.
To disable console breadcrumbs, filter out the Console integration:
Sentry.init({
integrations: (integrations) =>
integrations.filter((integration) => integration.name !== "Console"),
});
Sentry.init({
integrations: (integrations) =>
integrations.filter((integration) => integration.name !== "Console"),
});
If you set defaultIntegrations: false, add Sentry.consoleIntegration() to keep capturing them.
`performance.mark()` spans moved to `userTimingIntegration`
Action requiredbrowserTracingIntegration no longer captures performance.mark() and performance.measure() spans by default. The ignorePerformanceApiSpans option moved to userTimingIntegration as ignore.
// Before
Sentry.init({
integrations: [
Sentry.browserTracingIntegration({
ignorePerformanceApiSpans: ["third-party-mark"],
}),
],
});
// After
Sentry.init({
integrations: [
Sentry.browserTracingIntegration(),
Sentry.userTimingIntegration({ ignore: ["third-party-mark"] }),
],
});
// Before
Sentry.init({
integrations: [
Sentry.browserTracingIntegration({
ignorePerformanceApiSpans: ["third-party-mark"],
}),
],
});
// After
Sentry.init({
integrations: [
Sentry.browserTracingIntegration(),
Sentry.userTimingIntegration({ ignore: ["third-party-mark"] }),
],
});
See UserTiming for configuration and CDN loading instructions.
Interaction spans moved to `interactionsIntegration`
Action requiredThe _experiments.enableInteractions option of browserTracingIntegration was removed. Use interactionsIntegration() instead.
// Before
Sentry.init({
integrations: [
Sentry.browserTracingIntegration({
_experiments: { enableInteractions: true },
}),
],
});
// After
Sentry.init({
integrations: [
Sentry.browserTracingIntegration(),
Sentry.interactionsIntegration(),
],
});
// Before
Sentry.init({
integrations: [
Sentry.browserTracingIntegration({
_experiments: { enableInteractions: true },
}),
],
});
// After
Sentry.init({
integrations: [
Sentry.browserTracingIntegration(),
Sentry.interactionsIntegration(),
],
});
Configure idleTimeout, finalTimeout, and childSpanTimeout for interaction spans on interactionsIntegration, with the same defaults as before. BrowserTracing's timeout options still control pageload and navigation spans. See Interactions for configuration and CDN loading instructions.
Web Vitals moved to a dedicated integration
Action requiredThe _experiments.enableStandalone*Spans options were removed, and browserTracingIntegration no longer accepts an _experiments object. BrowserTracing automatically adds webVitalsIntegration to collect Web Vitals.
CLS and LCP are recorded as measurements on the pageload span, or as dedicated spans in stream mode.
Configure collection through browserTracingIntegration({ webVitals: { ... } }). The enableInp option is deprecated. Use webVitals: { ignore: ["inp"] } to disable INP, or include "cls" or "lcp" in ignore to skip those vitals. If you explicitly add webVitalsIntegration(), its options take precedence.
Soft-navigation vitals are enabled by default in stream mode on supporting browsers. Set webVitals: { softNavigations: false } to keep one set of vitals for the page lifetime. Back/forward-cache vitals are also enabled by default in stream mode when BrowserTracing's instrumentBfcacheRestore is enabled. Set webVitals: { bfcacheNavigations: false } to disable collection for restores. See WebVitals for requirements.
LCP and CLS spans no longer set browser.web_vital.lcp.report_event or browser.web_vital.cls.report_event, including when soft-navigation reporting is disabled. Finalization timing is unchanged. Remove filters on these attributes from searches and dashboards.
Restore vitals carry browser.navigation.type: bfcache. Filter by that attribute to analyze restores separately from page loads, since near-instant restores can lower combined aggregates.
`trackFetchStreamPerformance` moved to its own integration
Action requiredThe trackFetchStreamPerformance option of browserTracingIntegration was removed. Use fetchStreamPerformanceIntegration() instead.
// Before
Sentry.init({
integrations: [
Sentry.browserTracingIntegration({
trackFetchStreamPerformance: true,
}),
],
});
// After
Sentry.init({
integrations: [
Sentry.browserTracingIntegration(),
Sentry.fetchStreamPerformanceIntegration(),
],
});
// Before
Sentry.init({
integrations: [
Sentry.browserTracingIntegration({
trackFetchStreamPerformance: true,
}),
],
});
// After
Sentry.init({
integrations: [
Sentry.browserTracingIntegration(),
Sentry.fetchStreamPerformanceIntegration(),
],
});
See FetchStreamPerformance for supported response types and setup instructions.
`profilesSampleRate` and `profilesSampler` were removed
Action requiredThe legacy per-transaction profiling options were removed. Configure session-based profiling with profileSessionSampleRate and a profileLifecycle of 'trace' or 'manual' instead.
AI integrations were removed from browser SDKs
Action requiredAI integrations are no longer available in the browser SDK. They remain available in the server-side SDKs.
`InboundFilters` was renamed to `EventFilters`
Action requiredThe inboundFiltersIntegration export was removed, and the integration reports itself as EventFilters. Update references by name, for example in client.getIntegrationByName():
// Before
Sentry.init({
integrations: (integrations) =>
integrations.filter((integration) => integration.name !== "InboundFilters"),
});
// After
Sentry.init({
integrations: (integrations) =>
integrations.filter((integration) => integration.name !== "EventFilters"),
});
// Before
Sentry.init({
integrations: (integrations) =>
integrations.filter((integration) => integration.name !== "InboundFilters"),
});
// After
Sentry.init({
integrations: (integrations) =>
integrations.filter((integration) => integration.name !== "EventFilters"),
});
Verify behavior changes
9 leftCheck dashboards and alerts.
Browser sessions use `unhandled` instead of `crashed`
Behavior changeSessions affected by an uncaught error are recorded as unhandled instead of crashed. If you track crash-free session rates or have alerts built on them, expect the rate to shift.
See BrowserSession for session health details.
`page` is the default browser session lifecycle mode
Behavior changeThe lifecycle mode of browserSessionIntegration defaults to 'page', so a session is created on page load and is not renewed on navigation.
// Restore a new session on load and on every navigation
Sentry.init({
integrations: [Sentry.browserSessionIntegration({ lifecycle: "route" })],
});
// Restore a new session on load and on every navigation
Sentry.init({
integrations: [Sentry.browserSessionIntegration({ lifecycle: "route" })],
});
See BrowserSession for lifecycle configuration and session health details.
`attachStacktrace` now defaults to `true`
Behavior changeSentry.captureMessage() events, and non-Error values passed to Sentry.captureException(), now attach a synthetic stack trace that points to the call site. Set attachStacktrace: false to restore the previous behavior.
Two consequences are worth checking after you upgrade:
- Issue grouping: Sentry groups events with and without stack traces differently, so you may see new issue groups.
- Release health: Events with a stack trace count as errors, so a
captureMessage()call marks the current session as errored. Crash-free session rate is not affected. For purely informational output, consider Sentry Logs instead.
`tracePropagationTargets` matching is now case-insensitive
Behavior changeString and regular expression matching for tracePropagationTargets no longer depends on casing. In browsers this was especially surprising, because the URL is normalized with new URL() before matching, which lower-cases the origin. A target such as 'myApi.com' could therefore never match a request to https://myApi.com.
Sentry.init({
// In a browser, neither of these matched `https://myApi.com` in v10. In v11 both do.
tracePropagationTargets: ["myApi.com", /^https:\/\/myApi\.com/],
});
Sentry.init({
// In a browser, neither of these matched `https://myApi.com` in v10. In v11 both do.
tracePropagationTargets: ["myApi.com", /^https:\/\/myApi\.com/],
});
If you relied on case-sensitive matching to tell two targets apart, narrow the target with a more specific path. The g and y flags are ignored now, because they made matching stateful and a target like /myApi\.com/g matched only every other request.
Span attributes were renamed to match semantic conventions
Behavior changeLegacy span attributes were replaced by their semantic-convention equivalents. Update any custom instrumentation, beforeSendSpan logic, dashboards, or alerts that reference them.
Span operations were consolidated
Behavior changeSpan ops are now a smaller, framework-neutral set. The detail that used to live in the op, such as the framework, library, method name, or lifecycle phase, is preserved in attributes like code.function.name, sentry.origin, db.system.name, db.operation.name, and faas.trigger.
Update anything that filters, groups, or alerts on span ops: dashboards, dynamic sampling rules, ignoreSpans, and beforeSendSpan. TypeScript doesn't catch these.
INP is always sent as a web vital span
Behavior changeWhen collected, INP is always sent as a Web Vital span, carrying its value in the browser.web_vital.inp.value attribute instead of as a span measurement. Update custom dashboards and alerts that read it as a measurement. Built-in dashboards do not need adjustments.
See WebVitals for collection options and the attributes sent with each vital.
The `DOMException.code` tag was removed
Behavior changeEvents created from a DOMException no longer carry a DOMException.code tag, because the code property is deprecated in favor of DOMException.name, which is already the exception type. Switch searches and alert rules that use the tag to error.type.
`sendFeedback` rejects with an `Error`
Behavior changeSentry.sendFeedback() now rejects with an Error in all cases. Previously it rejected with a plain string when the request timed out, was rejected with a 403, or otherwise failed to send. The message text is unchanged and is still customizable through the errorMessages hint, so read it from error.message.
Optional cleanup
2 leftDeprecations and type tightening you can address later.
Type changes
FYISeveral public types changed:
- Several public types that used
anynow useunknown, includingStackFrame,SamplingContext,SentryError, andUser. You may need to narrow types explicitly. - Attribute typing and serialization were unified across the SDK.
- The
attributesfield of theSamplingContextpassed totracesSampleris required now. The SDK always provides it, so this only affects code that narrows or buildsSamplingContextobjects by hand. - The
attributesfield ofScopeDatais required now. This only affects code that constructsScopeDataobjects manually: addattributes: {}there. - The
endTimestampproperty was removed fromSentrySpanArguments. Callspan.end(timestamp)instead. BrowserOptionssupports theTransportOptionsgeneric now.
`withStreamedSpan()` is now a no-op
FYIIf you wrapped beforeSendSpan with withStreamedSpan() to opt into the streamed payload in v10, drop the wrapper. It's a no-op now that streamed payloads are the default, and it's deprecated.
Our documentation is open source and available on GitHub. Your contributions are welcome, whether fixing a typo (drat!) or suggesting an update ("yeah, this would be better").