Despite the fact that we still have snow in our ten-day forecast, spring has officially sprung! For many of us that means March Madness — time to root for our alma maters and stream midday games at our desks — or if any of us is a real “balla” maybe courtside seats at the championship game. Sigh, wouldn’t beating all your buddies in the office NCAA bracket be so so sweet? Especially after you picked Harvard to go all the way just because Good Will Hunting is your favorite movie. The only thing better would be having a top seeded app if Mobile March Madness was a thing!

Well guess what? We’re so excited to share our March Update that we’re not even going to force one final sports analogy to transition into talking about all the amazing upgrades we’ve shipped recently.  So here goes….

Last month, we launched a slew of upgrades: optimized stack traces, real-time UI with new navigation experience — and a new beta distribution tool from Crashlytics Labs. Just like your favorite Big Ten team training for March Madness, we’ve been heads down shipping several enhancements for our crash reporting tool — while prepping for several major, upcoming releases for this summer. Stay tuned! (Remember we made no promises about withholding additional sports analogies later in this post).

Redefining Performance

Many of you have a handful of apps using the Crashlytics SDK — and some even have thousands! Not only have we been hard at work building new features, we also took the time to get back to the basics and improve the start up speed and performance of our web app. You never can practice too many layups before the big game, right? By reducing dependencies and implementing eager loading in all the appropriate places, our web application now cuts down the start data request time dramatically!

Pushing the Envelope

Last month, we announced the availability of our beta distribution tool, Beta by Crashlytics. Ever since we started Crashlytics to tackle crash reporting, we’ve heard many frustrations related to the process of testing new apps and distributing beta builds. As the mobile ecosystem becomes fragmented and beta testing processes get more complex, we’ve embarked on our goal to deliver the most powerful, cross-platform beta distribution tool that supports both iOS and Android.

We’ve been overwhelmed with the massive demand, and since the announcement we’ve been slowly rolling out access to try out our tool. We’re extremely thankful to those of you who’ve provided us feedback! If you want to test out our beta distribution tool and other secret projects we’re working on, sign up here to become a Crashlytics Lab Rat!

Here’s our internal changelog:

Mac App

  • Extended private access via /secret to test version with beta distribution functionality enabled.

Android IDE Plugins

  • Fixed null pointer exception that occurs when processing a manifest with no application label.
  • Fixed bug in the Eclipse plugin which can cause issues with adding Crashlytics after a project is renamed.
  • Improved threading behaviors during application compilation to reduce blocking issues for users with proxies.
  • Ensured that the application is correctly added when its package renamed via the renameManifestPackage attribute while a user is adding Crashlytics to a Maven application.
  • Revised the issues table to only display “no issues” after the user’s issues have been retrieved.
  • Extended private access via /secret to test version with beta distribution functionality enabled.


  • Reduced dependencies and implemented eager loading to improve the speed and performance of the start up process.

Blog Post

  • Deployed maybe one too many sports jokes. We’ll try to stick to developer humor in the future — but we make no promises ;)

View More


If you’re going to be trapped in an office all winter with your co-workers (and possibly missing quality time with your Valentine) you’ve got two choices. You can spend your days watching the snow peacefully falling, wishing you were by a fire and on the slopes OR you can hunker down and ship things! Guess which route we took this winter? Hint: it doesn’t involve sipping hot toddies at the mountain lodge—although we might have cracked open a bottle of something when the heat was broken in the office that one day ;)

We spent the month of February shipping new features and a new look — while making room in the Crashlytics Labs roster for shiny new toys like a beta distribution tool. So as you cozy up to your cubicle buddy in lieu of being in that luxury log cabin with aforementioned Valentine out in Park City, feel free to whip up a batch of toddies in the office kitchenette. It’s time to settle in and check out what we’ve been building!

Latest Toys from Crashlytics Labs

Since we launched Crashlytics two years ago we’ve been tirelessly seeking out feedback from our customers. That’s why we know how cumbersome the beta distribution process can be. At Crashlytics Labs, we’re always tinkering with new ideas and have been hard at work building a beta distribution tool for both iOS and Android. After privately testing the tool with some of the best app developers out there (who are also hunkered down working through this chilly winter), we were very excited to open this up to more of you last week. We’ve been inundated with requests for access and will continue to roll out the invites — stay tuned!

High Performing & Platform-Centric

Stack traces are core to any debugging tool, and they are an integral part of our mission to build the most powerful tools for developers. This month, we enhanced the performance of our UI that now renders stackframes up to 181x faster while achieving a 55% reduction in memory. We also upgraded our iOS SDK to support threads and selectors, which allows you to track down certain classes of crashes and gain additional context that can be otherwise inscrutable. For the Android fanatics, we now present our stack traces in a way that’s in line with the traditional Java counterpart — surfacing the traces in their most familiar context.

We also added the functionality to copy & paste raw stack traces, so you can seamlessly share details of your crashes even outside of our shareable crash reports feature. Additionally, we’ve made it more effortless to find the right issue. Our search feature now also indexes Crashlytics Session IDs, so you can locate issues even more precisely, beyond custom logged events and keys!

Real-Time & Intuitive

We care deeply about the developer experience in all the tools we build. What better time to optimize our UI than having the new stack traces in place? We added a new notifications system that keeps your focus on the crash report, with alert boxes that updates itself in real-time and intelligently organize issues by type. This enables you to scan through all incoming crashes with minimal effort — without your flow being disrupted.

We also completely redesigned our navigation experience.  The new context control automatically sort your list of apps based on your recent interactions, so the most actively managed apps are always at your fingertips. Our new navigation sidebar also sports a more intuitive menu structure while maximizing the horizontal space for optimal viewing of all your critical crash data.

Effortless One-Click Sign In

We’ve been accelerating our build-out since joining forces with Twitter last year. Using our new one-click, OAuth integration with Twitter’s user system, you can now link your existing Crashlytics account to your Twitter account during sign in. The next time you sign into Crashlytics, it’s just one simple click!

Here’s our internal changelog:


  • Jazzed up our backend to support future product and feature development!
  • Fixed a minor bug to improve SDK configuration.
  • Upgraded SDK to support threads and selectors.

Mac App

  • Enhanced support when a build occurs during sign in, for all of you who are multi-taskers!
  • Opened private access via /secret to test version with beta distribution functionality enabled.

Android SDK

  • Improved the initialization support and increased startup speed in multithreaded environments.

Android IDE Plugins

  • Deployed a new version of the Gradle plugin that performs much faster and prevents any classpath issues on Windows.
  • Opened private access via /secret to test version with beta distribution functionality enabled.


  • Enhanced UI performance to render stackframes up to 181x faster.
  • Updated Android stack traces to be in line with the traditional Java counterpart.
  • Added copy & paste functionality for raw stack traces.
  • Redesigned navigation side bar with slick buttons and new menu structure.
  • Expanded horizontal space of web dashboard to display more data.
  • Implemented new real-time notifications system that automatically organizes crashes.
  • Shipped new context control that sorts your list of apps by recent interactions.
  • Enabled search by Crashlytics Session IDs for finding issues.
  • Deployed one-click Twitter sign in functionality for existing users.

View More


In the 2+ years since we launched Crashlytics to solve mobile crash reporting, we’ve heard you loud and clear about another problem in mobile development: the beta distribution process. Testing new apps with real beta testers can be a cumbersome and unnecessarily complex process.

At Crashlytics, our mission is to deliver the easiest and most powerful tools for mobile developers. Through Crashlytics Labs, we’re always pushing the boundaries and tinkering with new ideas. I’m excited to share that we’ve been hard at work in our Labs building a beta distribution tool for both iOS and Android.

By focusing on multi-platform support, our beta distribution tool streamlines the process and shreds the complexity of managing different toolsets. We’ve been privately testing this tool with some of the best app developers out there. Now, we’re ready to open this up to more of you.

If you want to apply to test our new tool for beta distribution and other secret projects we’re working on, sign up to become a Crashlytics Lab Rat.


Wayne Chang

View More


While sheer performance and deep insights are essential in a crash reporting solution, we’re passionate about also delivering an unparalleled user experience. After launching our optimized stack traces just a few weeks ago, we were heads down again meticulously refining our user interface and reporting features. With the latest Crashlytics real-time interface, you can now keep tabs on your most prevalent crashes with prominent, intelligently organized crash notifications — inside an optimized, redesigned navigation experience.

Additionally, for the very first time, we’re offering an effortless, one-click sign in using your Twitter account!

Dynamic, Real-Time Notifications

You just never know when a critical issue might occur and require your immediate attention. While we’ve always offered real-time functionalities in our web dashboard, we wanted to take the experience even further. Our new notifications system keeps the interface even more pristine, with real-time alerts appearing on the lower righthand corner.

As subsequent crashes come in, the alert box automatically updates itself in real-time, grouping crashes by type so they don’t pile up! Additionally, each alert displays the filename and line number prominently for easy identification. Now you can know exactly how many new crashes there are and scan through all of them with minimal effort — without any incoming crashes disrupting your flow.

From our friends at Blackboard:

Our dashboard is composed of hundreds of apps with thousands of app versions. Refinements to the navigation and the incorporation of real-time notifications on the dashboard have made it incredibly simple to zero in on a problem and trace it to a solution. Crashlytics is by far the best solution to monitor, track, and resolve crashes at scale.

Bryan Musial,

Intuitive, Responsive Navigation

Tackling complex bugs can be a frustrating process for many developers — let alone having to manage the process across multiple apps and organizations. For those of you with multiple apps, our new context control now automatically orders your list of apps based on recent interactions. Coupled with a seamless search functionality, the apps you’re most actively managing are always at your fingertips.  Each app is also labeled with its corresponding organization, so you know precisely where it belongs.

Since the birth of Crashlytics, we’ve continually upgraded the navigation experience with highly visible tabs and efficient menu structures. To take the experience to the next level, we made our new navigation sidebar ultra-thin which maximizes the horizontal space for displaying all the critical crash data. We also replaced the tabs with slick, eye-catching buttons.

In our newly redesigned menu structure, each button has a drop down menu that gives you seamless access to all of the following options:

  • Add a new app, organization or account
  • Manage settings across your apps, organization and account
  • Access the Crashlytics Knowledge Base, TOS and blog
  • Download plugins

As your app scales and acquires more users, the issues list can get quite long, requiring you to scroll down. Our new navigation bar now rests in a fixed position on the left side, so you’ll always have access to the app selector as well as all the menu items as you scroll up or down. Given all the different screen sizes in today’s world, we’ve also made our navigation bar vertically responsive which automatically adjusts to the height of the browser window.

Seamless, One-Click Twitter Sign In

Ever since we joined forces with Twitter, we’ve been accelerating our build-out and remain dedicated to delivering the key app performance insights that every developer needs. With Twitter’s infrastructure, we hoped to deliver new features faster than ever before. Today, we officially announce that you can sign into Crashlytics with our one-click, OAuth integration with Twitter.

For existing Crashlytics users, you will be able to link your Crashlytics account to your Twitter account during sign in. Once you’ve synced up the two accounts, it’s just one simple click the next time you sign into Crashlytics!

As we continue on our mission to improve the debugging experience for developers all around the world, we couldn’t wait to get these upgrades into your hands. Sign in or request an invite to experience the new Crashlytics interface — we’re always eager to hear your feedback!

Already have an account? Sign in here.


View More


ProGuard, a code optimization and obfuscation tool provided as part of the Android SDK, can be a double edge sword — it presents bootstrapping challenges but when applied correctly, provides tremendous benefits! At Crashlytics we’ve spent a lot of time leveraging the power of ProGuard to develop lightweight libraries to help app developers ship awesome products — in particular, we use these four features in our day-to-day development.


As your codebase grows and becomes more full featured, it’s important to keep a small binary in mind. Reducing the size of the APK can be extremely advantageous, since large binaries are much less likely to be installed in poor network conditions or on older less powerful devices.

It’s been well publicized among the developer community that the Dalvik Virtual Machine is memory limited to 64k methods. With this restriction, ProGuard can help provide a buffer as you consider which measures to take to reduce your code size. Removing unused code, which likely exists in a 64k method project, enables your development team to work on features unimpeded by technical limitations, while refactoring or external class loading is considered.

Even though shrinking is advantageous, simply identifying unused code to remove is a good practice. By using the printusage flag in Proguard.cfg, your configuration file, ProGuard will list the unused code to allow for proper code maintenance and cleanup.

 1 # This is a configuration file for ProGuard.
 2 #
 4 -dontusemixedcaseclassnames
 5 -dontskipnonpubliclibraryclasses
 6 -verbose
 8 -printseeds seeds.txt
 9 -printusage unused.txt
10 -printmapping mapping.txt


With tools available to extract the contents of APK’s, deodex, and read the class files, it’s important to obfuscate to protect the proprietary aspects of your codebase. ProGuard generates a mapping file that allows you to map the stack traces of obfuscated code to actual methods.

Original code:

 1 package;
 3 public class Data
 4 {
 5    public final static int RESULT_ERROR = -1;
 6    public final static int RESULT_UNKNOWN = 0;
 7    public final static int RESULT_SUCCESS = 1;
 9    private final int mId;
10    private final int mResult;
11    private final String mMessage;
13    public Data(int id, int result, String message) {
14       mId = id;
15       mResult = result;
16       mMessage = message;
17    }
19    public int getId() {
20       return mId;
21    }
23    public int getResult() {
24       return mResult;
25    }
27    public String getMessage() {
28       return mMessage;
29    }
30 }

Code obfuscated by ProGuard:

 1 package;
 3 public class a
 4 {
 5    private final int a;
 6    private final int b;
 7    private final String c;
 9    public a(int paramInt1, int paramInt2, String paramString)
10    {
11       this.a = paramInt1;
12       this.b = paramInt2;
13       this.c = paramString;
14    }
16    public int a()
17    {
18       return this.a;
19    }
21    public int b()
22    {
23       return this.b;
24    }
26    public String c()
27    {
28       return this.c;
29    }
30 }

By automatically collecting the mapping files on build, Crashlytics streamlines the deobfuscation process of your code and intelligently prioritize stack traces to make your debugging process effortless.


Repackaging allows ProGuard to take externals jars and class files and move them to a single container with a common java package location:

 1 # com.example.networking contains the networking level
 2 # com.example.database contains the persistence level
 3 # repackage low level services into common package for simplicity
 4 -repackageclasses "com.example.internal"
 6 # com.example.public contains public interfaces
 7 # ignore these in repacking
 8 -keep public class com.example.public.* {
 9    public *;
10 }

For those of you building libraries, repackaging is extremely helpful if you choose to show a simple interface to third party developers while keeping a maintainable and well structured project hierarchy in the source repository. This can also be useful in organizing lower level packages while exposing well defined interfaces!


Optimizing works on compiled classes to implement many small optimizations based on the java version. By default the proguard-android.txt that ships with the Android tools has optimizations turned off, but the proguard-android-optimize.txt has the presets if needed.

 1 # Optimizations: If you don't want to optimize, use the
 2 # proguard-android.txt configuration file instead of this one, which
 3 # turns off the optimization flags.  Adding optimization introduces
 4 # certain risks, since for example not all optimizations performed by
 5 # ProGuard works on all versions of Dalvik.  The following flags turn
 6 # off various optimizations known to have issues, but the list may not
 7 # be complete or up to date. (The "arithmetic" optimization can be
 8 # used if you are only targeting Android 2.0 or later.)  Make sure you
 9 # test thoroughly if you go this route.
11 -optimizations !code/simplification/arithmetic,!code/simplification/cast,!field/*,!class/merging/*
12 -optimizationpasses 5
13 -allowaccessmodification
14 -dontpreverify

Optimizations provide performance improvements for language operations. However, there are known incompatibility issues with various Dalvik versions, so we encourage a thorough review of the code base and device target demographic before enabling.

Beyond leveraging these four core features of ProGuard, we crafted several strategies for those of you looking to build lightweight apps/libraries and optimize your interaction with ProGuard.

Improving Build Times

Adding ProGuard to the build process can slow down build time, so it’s important to minimize the amount of code ProGuard needs to examine. This is vital when considering third party libraries, like Crashlytics, that have already been processed by ProGuard — it’s just a waste of CPU to reprocess with ProGuard again, and it’s much slower!

We thought it would be valuable to estimate the improvement in build times when preprocessed, third party libraries are ignored in ProGuard. Using the Crashlytics library as an example, we conducted numerous runs with internal test apps across various sizes. We found that build times improved by up to 5% when the Crashlytics package is ignored. But that’s just one library that is already ultra-lightweight. Imagine the build time improvements for apps leveraging additional libraries — it can be tremendous.

To avoid processing a library that may have been preprocessed, simply add the following to Proguard.cfg:

1 -libraryjars libs
2 -keep class com.crashlytics.** { *; }

As obfuscation is usually done for security, if using an open source library, there may be no reason to obfuscate it. By following a similar pattern as listed above, processing can be further reduced ultimately improving build time. The Android support library is a great example:

1 -libraryjars libs
2 -keep class** { *; }
3 -keep interface** { *; }


Using reflection in Android is highly discouraged for many well known reasons, including performance and instability in changing APIs, however, it can be quite useful for Unit Testing. Common use includes changing the scope of methods to set test data or mock objects. If you’re using ProGuard during development build to obfuscate, it’s important to understand that when a method or class name is changed, string representations of them are not. When designing testable interfaces, if tests are run on a device using a build that has been processed by ProGuard, this will cause method not found exceptions.

Library development

Additional complexity is introduced when developing libraries that are processed with ProGuard, both when they are distributed and when the app developer runs the process. When the code is obfuscated twice, it is much more challenging to track down bugs as two mapping.txt files would be required to de-obfuscate the stack trace. To avoid processing these libraries with ProGuard a second time, be sure to follow our steps in section above on improving build times!

For those of you building libraries, you may have encountered more challenges with ProGuard because in any sufficiently complex project, the possibility for custom ProGuard rules exists. We recommend not requiring custom ProGuard rules because the library can break if a different set of rules is applied after a custom set. If custom rules are required, be sure that those using your library include any custom ProGuard rules in their own config file. This will ensure compatibility between your library and the app!

1  # Custom Rules
2 -keep class com.example.mylibrary.** { *; }

Ever since Crashlytics was born, we’ve made it our mission to make developers’ lives easy. We hope that these strategies will help you build the next groundbreaking Android app/library and perhaps in the process, make a dent in the universe ;)

External Resources

View More