Profiling
Profiling provides code-level insights into your application performance in production — so you can get to the line of code or function that’s causing a slowdown.
Code-level insight into performance bottlenecks in production
Drill into the exact functions and lines of code causing a performance issue without writing manual tests or searching through spans.
Sentry profiles code in every environment your application is running on so you can quickly see which functions are contributing to a slow span – so you can fix what’s urgent faster.
Optimize resource consumption
Visualize call stacks as a flame chart to identify hot code paths consuming the most resources. Improve user experience and reduce infrastructure costs by optimizing slow code that causes long load times and UI jank.
Actionable context to solve critical performance issues
Get alerted on performance issues like JSON or image decoding on the main thread that can cause jank or dropped frames for users. See a full stack trace and function evidence to debug the exact problem – then triage, assign, and resolve directly from your issues feed.
“With the flame charts, we were able to find our slowest database requests for our customer payment services. Using Profiling, we’ve been able to reduce the time-to-execution of our requests from 1000ms to 300ms.”
Why Choose Sentry for Profiling?
Easy Set Up
No agents or custom instrumentation needed. 5 lines of code is all it takes to get started.
Code-Level Visibility
Connect higher-level transaction views with function-level details in a profile to see where and why slowdowns are happening in your code.
Direct Performance Impact
Fix bottlenecks to reduce time-to-execution of requests. Track the direct impact on your app performance all in one tool – using Sentry’s performance metrics and dashboards.
Reduced Time to Resolution
Quickly diagnose a performance issue and start fixing the issue in your existing workflow – whether it’s in Slack, GitHub, or another tool/interface.
FAQs
Profiling gives code-level insight into your application performance in a variety of environments, including in production. By periodically capturing information about the code running in your app during a performance transaction, Sentry’s Profiling tool helps pinpoint the exact functions in your code that are consuming excessive CPU and causing performance problems – whether it’s loading screen issues or stuttering scrolls for the frontend user, or heavy infrastructure costs on the backend – so you can take action and fix them quickly.
Profiling supports Python, Node, PHP, Android, and iOS SDKs. Our PHP support includes Laravel and Symfony. Our mobile support is limited to native iOS (Swift and Objective-C only) and Android (Java and Kotlin only). Other platform support is coming soon.
Core performance monitoring functionality like Tracing gives you a high-level overview of your system’s performance, relying on transactions to tell you what is slow and to measure how long it takes. Profiling helps you understand why it’s slow at the code-level, pinpointing the exact file/line number causing the slow request.
Think of profiling as taking a magnifying glass to a transaction or span and seeing exactly what’s happening in the app while that transaction or span is captured. The additional context provided by a profile associated with a transaction can help you quickly debug and fix your performance issue.
Read more about how Profiling complements Tracing and improves your Performance experience here.
You’ll first have to enable performance monitoring in your app (which takes just 5 lines of code). Profiling hooks into the existing performance transactions in your app so there is no additional work to integrate beyond just enabling profiling in the SDK configuration.
The cost of Profiling is based on a unit consumption model that allows customers to pay for only what they need. Please check out our pricing page for details.
Monitor slow requests, No Agents Needed
With support for every major language, Sentry lets you catch performance bottlenecks and fix them quickly – without manually stitching together user transactions.
