Sentry Changelog

You will no longer see Codecov data in Sentry.

Sentry's Slack integration now provides previews for additional charts.

Sentry can use AI to analyze your traces and logs to detect issues that traditional pattern-matching would miss, like database inefficiencies, blocking operations, and security concerns.

Sentry can use AI to analyze your traces and logs to detect issues that traditional pattern-matching would miss, like database inefficiencies, blocking operations, and security concerns.

Conversations is now in open beta for all Sentry users. It gives you a readable view into past sessions with your agent, showing the full exchange of messages and tool calls so you can understand exactly what happened during each session.

A regression in data scrubbing prevented specific attributes from being scrubbed

Send Seer’s root cause to Copilot for the fix.

Dashboards now maintain a revision history of your most recent changes.

Trigger Claude to fix bugs using Seer’s root cause

Sentry alerts is splitting into two features — Monitors and Alerts — giving you more control over what you track and how your team gets notified. Monitors define what to watch — span attributes, logs, custom metrics, and more. When a threshold is breached, Sentry creates an issue in your stream automatically. Crons and Uptime now live here too.

Alerts define who gets notified and how — Slack, email, PagerDuty, and more. One alert rule can cover multiple monitors across projects, so you can change routing without touching your monitor config.

What this gets you:

• Not every breach deserves a page. Now you can define what your team tracks separately from who gets alerted.
• Every breach creates a trackable issue with context.
• Change who gets paged without touching what's being monitored, and vice versa.

Existing Metric Alerts have been migrated as Metric Monitors and your alert rules are intact, scoped to routing.

Read the FAQ for a full breakdown of what changed, or check out the product docs to get started.

Sentry's Application Metrics are now GA.

If you missed the beta: Application Metrics let you track the signals that matter in your application — checkout completion rate, job queue depth, auth failure rate — using counters, gauges, and distributions using the Sentry SDK.

What makes Sentry's metrics different: they're high-cardinality and trace-connected. Tag a metric with user ID, region, plan type, or any attribute you care about, and slice by any of them at query time so you can ask questions about your application or users. When something spikes, you get the connected trace, log, or error to find out why.

We've also added several new features leading up to this launch:

• Equations: Perform arithmetic across multiple metric series. Compute things like failure rate or Apdex directly in the explorer.
• Cross Event Querying: find exemplar traces for a specific metric value. Useful when you want to see the exact request behind a data point.
• Alerts: Create a monitor on any metric and get notified when it breaches a threshold. When it fires, the traces, logs, and errors are already connected.

5 GB of Application Metrics is included on all Sentry plans, beyond this they're priced the same as logs at $0.50/GB. Get started by going to Explore > Metrics or checkout the with the docs, and Join the conversation on GitHub.

Snapshots, now in Early Access, handles image storage, diffing, and CI checks to help you catch unintended visual regressions in CI. Snapshots will post on your PR if there are any visual changes and lets you examine any differences.

To learn more about how to use Snapshots in Sentry, make sure you have the Early Adopter flag turned on for your organization and Read the docs

Cross-Event Querying in Trace Explorer lets you search for traces using queries joined across multiple event types, including logs, Application Metrics, and spans.

For example, if you emit a page.view metric on soft navigations, you can find frontend traces for a specific user that emitted that metric:

Cross-Event Querying makes it easy to find full traces that correlate with logs or metrics, even when traces are sampled at a lower rate.

This feature is now available for all Sentry users. Give the docs a read and try it out.

The Sentry + Perforce P4 integration is now generally available for all Sentry organizations. The integration connects your P4 server directly to Sentry, unlocking the same source-code-aware debugging workflows that Git-based teams have relied on for years:

What's included:

• Stack trace linking— Click from an error's stack trace directly to the corresponding file in your Perforce P4 depot or P4 Code Review (formerly Helix Swarm) instance.
• Commit tracking — Associate Perforce P4 changelists with Sentry releases so you always know exactly what code shipped.
• Suspect commits — Sentry automatically identifies which changelists likely introduced an error, cutting your triage time.
• Suggested assignees — Get assignment recommendations based on changelist authorship.
• P4 Code Review (formerly Swarm) linking - If your team uses the P4 Code Review (formerly Helix Swarm) application for code reviews and browser-based depot browsing, Sentry links directly to your P4 Code Review instance. Stack trace links open the exact file in P4 Code Review's web UI, so reviewers and investigators can jump from an error straight into the code without needing a local workspace.

Getting started:

• Go to Settings > Integrations > Perforce, and enter your credentials.
• Configure code mappings to connect your Sentry projects to P4 depots.
• (Optional) enable SCM source context for inline code in stack traces.

Read the docs or check out the blog to get started.

Version 10.51.0 of the Sentry JavaScript SDKs is now available. Highlights from this release:

• New @sentry/nitro SDK in beta

  First-class Sentry support for Nitro applications, with HTTP handler and error instrumentation, middleware tracing, request isolation, and build-time source map uploading via withSentryConfig. Read more in the Nitro SDK readme.

• Trace propagation across Cloudflare RPC calls

  Trace context now flows across Cloudflare Workers RPC calls, connecting traces between Workers and Durable Objects. This is opt-in via enableRpcTracePropagation: true in your SDK configuration.

• Breaking change for @sentry/hono/node (alpha)

  The sentry() middleware no longer accepts configuration options. Instead, configure the SDK by calling Sentry.init() in a dedicated instrumentation file that runs before your application code. See the Hono SDK readme for the new setup.

• Improved support for Hono Route Groups

  The Hono SDK now creates middleware spans for nested route groups, giving you better visibility into sub-app routing.

• LangGraph instrumentation

  The SDK now instruments createReactAgent from LangGraph, giving you visibility into agent runs alongside your other AI telemetry.

• Customized Feedback errors

  The Feedback widget now supports customizing error messages shown to users.

Many additional fixes and improvements across core, browser, server, and framework SDKs. See full release notes

Setting up Source Context for JVM projects used to require pointing sentry-cli debug-files bundle-jvm at a flat directory of source files. For projects with standard layouts (Gradle, Maven, multi-module), this meant manually listing every src/main/java, src/main/kotlin, etc. — or writing wrapper scripts to collect sources into a staging directory first.

Starting with sentry-cli 3.4.1, bundle-jvm accepts a project or module root and does the right thing automatically:

sentry-cli debug-files bundle-jvm \
    --output ./out \
    --debug-id YOUR_UUID \
    ./path/to/root

The command walks the directory tree and:

• Collects only JVM source files (.java, .kt, .scala, .groovy, .clj)
• Skips build output and IDE directories (build/, .gradle/, .idea/, target/, etc.)
• Respects .gitignore - vendored dependencies and generated code won't end up in the bundle

Handling Multi-Variant Projects

Android and other multi-variant projects often have overlapping source sets (src/main/, src/debug/, src/release/) where the same fully-qualified class name appears under multiple directories. When bundle-jvm detects a collision, it keeps the first occurrence and warns you about the rest:

WARN: URL collision on ~/com/example/Foo.jvm: skipping 'src/debug/java/com/example/Foo.java'
 (already bundled from 'src/main/java/com/example/Foo.java').
 Use --exclude to drop the unwanted source set (e.g. --exclude='**/src/debug/**').

Use --exclude to scope the bundle to the source sets you care about. For example, here's how we bundle sentry-java itself — excluding test sources, Android test sources, and the buildSrc directory:

sentry-cli debug-files bundle-jvm \
    --output ./out \
    --debug-id YOUR_UUID \
    --exclude '**/src/test/**' \
    --exclude '**/src/androidTest/**' \
    --exclude '**/buildSrc/**' \
    --exclude '**/build-logic/**' \
    ./path/to/root

What This Means for You

• No more wrapper scripts - point at your project root and go
• Source Context just works - stack traces in Sentry show your actual source code, matched correctly even for Gradle/Maven layouts
• CI-friendly - a single command replaces multi-step source collection pipelines

Check out the CLI docs on JVM Source Bundles for the full reference, or the Source Context setup guide to get started.

To access Seer Agent through Slack, update Slack permissions

Seer Agent is now in open beta for all Sentry users. Seer Agent helps you investigate any issue in your application. Ask it a question about an error, an anomaly, a spike, and it traverses the connections between your traces, spans, logs, deploys, and commits to surface what's relevant. It can automatically query sentry telemetry, fetch Sentry docs, search repos/git history.

You can use it to answer open-ended questions about your telemetry and app, and accelerate debugging in situations where Sentry may not have already identified an issue (e.g. incident, customer bug report, metric trending in the wrong direction).

Ask it things like:

• Why did my p95 latency spike after the last deploy?
• What's causing this crash loop, and where in the code is it coming from?
• Why does this specific user keep hitting errors?
• Which services were unhealthy when this endpoint started failing?

To try it out:

In Sentry: Open any page and hit Cmd + / or click "Ask Seer" in the upper right. If you're not sure where to start, try one of the suggested prompts.

In Slack: Available through the Sentry Slack integration. Investigations happen in-thread, so anyone in the channel can add context, redirect mid-step, or search back through findings after the incident resolves.

Let us know how it went through the feedback button (it looks like a loudspeaker) in the toolbar.

Check out the blog for a walkthrough or the docs to get started.

Sentry Alerts is splitting into two features — Monitors and Alerts — to give you more control over what you track and how your team gets notified. We know not every problem throws an error, so configure Monitors around the things your team actually cares about — a slow checkout, a failed job, a traffic drop — and alert the right people, when it matters.

Monitors: Set conditions across different data types to detect problems. When a monitor threshold is breached, Sentry creates an issue automatically. Crons and Uptime have also moved to the new Monitors tab.

Alerts: Define who gets paged, when, and how. Alerts are triggered when issues are created or updated. Connect one alert to many monitors so you configure routing once and reuse it everywhere.

Existing Metric Alerts have been migrated as Metric Monitors and are waiting for you in the new Monitors tab. Read our FAQ article for more details.

Check out the product docs to get started.

Mobile SDKs now support a shake gesture to open the User Feedback form. When enabled, shaking the device triggers the feedback form using the platform's built-in accelerometer without additional permissions being required.

Users often encounter bugs in the moment but have no easy way to report them. Shake-to-report gives them an always-available gesture to submit feedback without needing a visible UI element.

Setup

Android

You can enable shake-to-report at initialization. This uses the device's accelerometer and does not require any additional permissions.

SentryAndroid.init(context, options -> {
 options.getFeedbackOptions().setUseShakeGesture(true);
});

Available in Android SDK 8.36.0 (documentation)

iOS

The feature is only supported on iOS and can be enabled like below:

SentrySDK.start { options in
 options.configureUserFeedback { config in
 config.useShakeGesture = true
 }
}

Available in iOS SDK 9.7.0 (documentation)

React Native

You can enable shake-to-report declaratively via the feedbackIntegration option:

Sentry.feedbackIntegration({
 enableShakeToReport: true,
});

Or control it programmatically:

Sentry.enableFeedbackOnShake();
Sentry.disableFeedbackOnShake(); 

Available in React Native SDK 8.5.0 (documentation)

The feature is soon coming to Flutter too.