Crashlytics for Android delivers deep, rich crash reporting across devices in real-time.
Crashlytics performs a detailed analysis of every thread on every Android device to identify
the most important issues.
We’re obsessed with making developing apps as easy as possible. Crashlytics for Android Studio, Eclipse and IntelliJ gives you instant reports right in your workplace environment.
Our plugin keeps you informed of the issues within your app so you can track the most prevalent crashes without leaving your IDE.
The Crashlytics SDK works seamlessly across all devices, versions (even the outdated ones) and from all types of apps -- from widgets to wallpapers to your favorite gaming apps.
When your app throws an uncaught exception, Crashlytics quickly records the stack trace and state of the device at the time the exception was thrown and sends the crash information to our servers for processing. You get complete visibility for every crash, effortlessly.
Crashlytics isn't just for uncaught exceptions! Adding a single line of code in your catch block will report caught exceptions to Crashlytics for processing, and you are still free to handle the exception however is best for your users. You get the full stack trace and all the same device information we collect for fatal crashes, so you can identify and fix bugs even if your app doesn't crash!
We automate deobfuscation of ProGuarded stack traces for apps built using our ant tools, maven tools or IDE plugins. We did the legwork for you. Built into your existing workflow, our SDK will have negligible impact on your app.
The Crashlytics SDK uses a multi-step process to analyze your crashes and automatically deobfuscates stack traces. We start with on-device exception handling.
Once a crash report makes it into our system, stack frames are then re-processed against your application’s mapping file that was automatically uploaded to our servers at build time.
This process, coupled with our advanced aggregation algorithms, provides the highest information fidelity available.
We recognize that fixing native crashes within your Android app is no walk in the park. You need a crash reporting solution that not only gives you total visibility into your app’s performance but is also dead simple to integrate.
With Crashlytics, we’ve built out powerful signal handlers to detect and
capture even the most
prevalent crashes within the NDK. We’ll give you deep and actionable insights, with the exact
line of code in your native app.
Now, spend less time finding and more time fixing crashes.
Instantly address native crashes with the same powerful stack traces that you’re familiar with in Java.
Access the same deep, actionable insights on devices, hardware and more.
Maintaining stability for graphics intensive and lower level native apps is already challenging for developers. The last thing you need is cumbersome, tedious configurations just to get crash reporting on NDK.
Normal NDK Installation:
Crashlytics for Android NDK Installation:
With Crashlytics, you don't need to download new tools or jump through configuration hoops to enable NDK support. We’ll automatically pull in all the dependencies you need.
If you’re already using our build tool plugins, all you need to do is modify a few lines of code and you’re off and running (and you’ll actually know you are!)
We’ve made installation totally seamless through our support for both Gradle and Ant.
Not building from a standard IDE? We'll even auto provision your keys and onboard your app from the command line, just like our plugins!
Many crash reporting tools for NDK today still rely on you uploading all
of your symbolized,
unstripped binaries to generate symbol files server side. This poses significant risk for your
code,
sending your bread and butter or secret sauce to third parties outside of your control.
Not to mention wasting bandwidth from transmitting your code in bloated file sizes!
With Crashlytics, you’ll never have to give away your proprietary code. Our build tools use your debug and runtime binaries to generate the needed symbols in a much smaller file -- completely client side before uploading it to our servers.
Don't worry -- you’ll have total control over the upload process.
Our symbol file is lightweight, requiring minimal bandwidth over SSL transmission.
The Crashlytics SDK was designed with the utmost care to guarantee that
it
has no
negative impact on your app’s performance:
On average, Crashlytics adds less than the size of a single image to the weight of your application.
We don't require linking against any additional frameworks or libraries.
When initialized at start-up, Crashlytics performs only a minimal amount of required work and defers the rest until a few seconds after app startup completes. This delay time is configurable -- we want your app to start as quickly as possible!
Our memory footprint has been carefully tuned to be the minimum necessary.
We care tremendously about the stability of your app and the experience for your users. If for any reason our SDK fails to do what it's supposed to do, it has no impact on your app or to your users.
We use run-time feature detection to ensure compatibility with version 2.1 and beyond.
Our exception handler waits silently until an uncaught exception is thrown. We process the crash quickly and efficiently before returning control to the Android runtime, with no noticeable impact on your app’s performance. Your users will never know we’re there!
When the device is in airplane mode or experiencing a bad network connection, we will queue the crash reports so you still see every crash - with no impact on your app's performance.
