Optimize your
Android user
experience

Embrace’s Android SDK is built to support the diverse, ever-
changing Android ecosystem. Whether you’re writing Koltin,
Java, or building native components using the NDK, using
Jetpack Compose or creating traditional Android UI, Embrace
ensures you have the right tools to optimize your app’s performance.

Get started free

Request a demo

Full context into the Android
user’s experience

Session Play by Play: See every tap, swipe, error, crash, and network call in the context of a full app experience. Embrace captures events in UI created with traditional Android UI components as well as Jetpack Compose, and lets you add custom breadcrumbs in the timeline for even greater insight.
Out of Memory error reporting: A dedicated OOMs dashboard gives you info into where and why users are experiencing memory issues. Correlation scores and metrics provide direction into whether certain UI components were responsible for an OOM termination.
JVM and Native Development Kit support: Embrace reports crashes in Kotlin and Java code right out-of-the-box. To capture NDK crashes for your native components, run a simple command in your config file and you’ll also get deobfuscated C/C++ stack traces.

Unrivaled ANR analysis and
troubleshooting

Stack trace sampling every 100ms: Our SDK provides stack traces of your main thread taken every 100ms prior to, during, and after an ANR is triggered. We highlight known issues in your stack traces that you might not be aware are contributing to an ANR. Since we capture 100% of sessions and ANR instances, you get a list of users that experienced the ANR you’re investigating so you can solve it with context around their full session experience.
Flame graphs for visual analysis, prioritization, and debugging: Embrace’s Flame graph view is a powerful tool to understand which parts of your app are contributing the most to ANRs. It lets you simultaneously look at the hierarchical path of a bad frame alongside how frequently that set path appears in ANR samples – that way, you can prioritize it.
Dedicated method troubleshooting: Examine a particular method with unparalleled granularity via Embrace’s Method Troubleshooting view. This lets you examine all the code paths that lead up to a problematic method, plus all the code paths that follow that method to trace your code’s execution with ultra-fine precision.
Google Play Console correlations: Embrace scrapes the Android Application Exit API to pull in an ANRs list that’s similar to what you’d see in your Google Play Console. We correlate these ANRs to the wealth of information captured by our SDK across many stack trace samples and enable you to solve these high-priority ANRs using all of our advanced analysis tools.

Built for the modern Android
ecosystem

Automatic stack trace deobfuscation: If you’re obfuscating your app with tools like ProGuard or R8, Embrace will automatically upload your mapping file at build time. This ensures you get human-readable stack traces for every crash or handled exception, with a little less manual work on your end.
Monitor requests made via REST APIs, GraphQL, and GRPC: Network monitoring with Embrace gives you insight into requests made via a REST API, GraphQL, or GRPC. Our dashboard makes it easy for you to analyze requests regardless of protocol, and has configuration options that allow you to break up and customize network path names for analyzing performance in a way that meets your needs.
Compatible with popular tools, libraries, and frameworks: Support for modern programming toolkits in Android, including Kotlin Coroutines, Jetpack Compose, and Jetpack Navigation, all within the same simple integration flow. The Embrace SDK is available on Maven Central and can be added to your app with a few lines of code in your Gradle file.

Black Friday is one of the most important events of the year. We use Embrace to monitor our platform and troubleshoot any problems while the live event is going on.