Milestone Achieved: Over 1 Million Apps!

Developer tools have always been about power, focusing less around ease-of-use and the overall user experience. When Jeff and I founded Crashlytics four years ago, we made it our mission to fix this. We didn’t just want to build the most powerful, yet lightest weight crash reporting tool – we wanted to focus on the entire experience. From how you onboard Crashlytics, to what happens when you close an issue, to how we handle support requests, every detail was tailored to building the best developer experience for you.

Today, after four years of tremendous focus and effort by our team, we’re proud to share that we’ve reached a major milestone: our systems have now seen more than 1 million apps integrated with Crashlytics!

Crashlytics is a truly revolutionary offering thanks to how easy it is to implement and use.

Ryan Johnson, VP of Mobile Engineering,


Across those apps, our systems now analyze over 7 billion crash events every 30 days and we’ve learned a tremendous amount about what it takes to support you as you build incredible apps.

What has made Crashlytics such an integral part of every app developer’s toolkit? We asked and below are some of your favorite features that make Crashlytics so valuable to you.

Deep, insightful reports

Crash reporting is more than just a raw paste of a stack trace. To make debugging easier, we built Crashlytics to perform deep analysis of each and every thread, deprioritizing lines that don't matter and highlighting the most interesting ones.

We then went several layers deeper, giving you precise information on the performance of the devices and operating system that your apps run on.

Often, the cause of your crashes goes beyond the device model or operating system. With Crashlytics, you gain even deeper insights – for example, if your app only crashes in landscape mode, or if the proximity sensor is always on. You can resolve crashes caused by more complex factors, like rooted or jailbroken devices, memory, version-specific issues, etc. – factors you would not otherwise have visibility into. By having this insight, you’d be able to ignore an issue that only occurs on jailbroken devices or focus on how things like orientation and memory can be indicative of what is causing the crash.

Dynamic, real-time notifications

Critical issues require your immediate attention, and you just never know when they might occur. With real-time alerts on your web dashboard, there’s no need to wait days for a crash report: we’ll notify you with what’s important so you can fix the crashes that affect the most users as they happen.

Unlike typical notification systems, your alerts will automatically update themselves in real time, grouping crashes by type so they don't pile up as subsequent crashes come in. You’ll know exactly how many new crashes there are and can scan through them with minimal effort.

Find reports you need, when you need them

Context is king when debugging crashes, and knowing the values of critical variables in your app, such as the level of the game the user got to or the byte size of the last photo they took, can help you shave hours off your debugging time. Also, it’s helpful to know which of your users experienced a given crash to help them resolve the issues and keep them happy.

With Crashlytics, you can instantly locate specific crashes with custom keys and user information using our real-time search.

Of course, you can also find crashes by file names, method names, line numbers or issue notes. Our search functionality empowers you to hunt down the important issues and know precisely what happened leading up to the critical moment.

World-class service: more than just a tool

Instead of a tool that merely displays stack traces or data charts, we built Crashlytics into a full service that makes your life easier. Not only can you search for and fix the most important issues in real time, but more importantly, you can easily collaborate with your team to tackle these issues.

When a critical bug comes in, the last thing you want is to struggle with sharing that crash report with your team. We’ve made this incredibly simple within your web dashboard, so that you can invite multiple members – all at once – to join your org. And in just two clicks, you can share the intricate details of each crash with your team, either by sharing the report via email (we generate for you!), or using our short link (crashes.to/...) within your favorite IRC client.

On top of email and shareable links, you can seamlessly share your reports through Slack or directly into JIRA, Hipchat, and more through our third-party integrations. Besides collaboration tools, we also integrate with project management services you use every day – like Trello, GitLab, and more – so you can manage your apps with minimal effort.

But as an app developer, understanding your app’s performance starts before you launch. That’s why we built Beta. Not only can you easily control the list of testers you send your app builds to and track their progress, but you can also hone in on those crashes with the greatest impact on your testers.

In just one click you’ll be in your Crashlytics Issues dashboard, with all of our deep analysis tools to help you debug the most complex crashes.

With Beta’s deep integration with Crashlytics’ crash reporting and its crash-to-tester functionality, you can instantly identify the individual tester who experienced a specific crash right within your crash reports. Going one step further we automatically tag all crashes of your beta builds with your testers’ names and email addresses so you can trace the exact steps and situation your testers were in when they encountered the issue.

Finally, thank you.

Since the birth of Crashlytics, we’ve kept to our passion for building services that developers love. This major milestone is just the beginning.

Thank you for being part of our journey. We look forward to continuing to support you in building even more amazing apps!

Crashlytics March Update

march _2015_update

Between St. Patrick’s Day, warmer weather and Bunsen Burner Day (no kidding), we’ve been working around the clock to bring you more new features and upgrades!

In February, we launched Dark Mode support for Yosemite, performed massive internal refactoring on our infrastructure, and continued building out our NDK support. In March, we rolled out a new feature that lets you export select user IDs so you can quickly reach out to those who experienced a specific crash. We also revamped the front-end code for Beta by Crashlytics to be powered by React, so we can enhance and debug our dashboards more efficiently than ever.

Export user ID meta data

With Crashlytics, you can already leverage user ID meta data to identify users who have experienced a specific crash. Many of you have asked for new functionality to easily extract that data. We heard you loud and clear, so now you’ll have the ability to export user IDs in order to communicate with those users faster and with more relevancy.

crashlytics_export_id

For example, you can offer a coupon for a lost purchase, or the ability to download a better version of your app. With Crashlytics, you can keep more of your users happy and build better relationships with them.

Working React into the Crashlytics UI

We’ve spent some time working the powerful UI framework React into the Beta by  Crashlytics UI. With that in place, we can enhance our dashboards much more efficiently with even better code. Our own Pete Hopkins recently wrote a detailed post on this (it was featured on HackerNews, too – enjoy!).

Here’s our internal changelog:

Crash Reporting

  • Web
    • Implemented userIDs export functionality on crash reporting dashboard.
  • Crashlytics Labs

Crashlytics for OSX

  • iOS SDK
    • Extended crash reporting support for OSX apps to the Fabric platform.

Beta Distribution

  • Mac App
    • Fixed a bug that prevented Beta distribution if the ZIP environment variable was set.
    • Fixed entitlements to be compatible with ad-hoc distribution.

We're heads down on more enhancements in the upcoming months – stay tuned!

Why We Are Converting to React

 

I feel weird writing about React. I’m not a contributor or upstanding community member. I’m not even an early adopter – we only started working React into Crashlytics about six months ago.

I’m a fan, though. A huge fan. And even though I thought I was the last person to this party, I keep running into frontend developer pals who haven’t given React a try.

Let’s change that!

The models who couldn’t save themselves

My React fervor was sparked by a bug I wrote. I work on Beta by Crashlytics, and much of our web frontend is written in Backbone. Late last summer, our dialog for managing groups of testers regressed: every so often, it would stop working. Any attempt to edit the group’s name, or add or remove testers, would be met with the same error in the JavaScript console: A “url” property or function must be specified.

How could this be? I had a Group model object, a whole collection of them in fact. You can see them right there in the sidebar. They each had their IDs, and their collection was very clear about how to turn those IDs into URLs. And yet, somehow “save” was broken. Why wasn’t it making its URL?

Let’s be clear, this is my bug. And –  full disclosure  –  I wrote it when converting some other parts of the UI to React. I was finding the Backbone Collection’s “set” method to be too chatty announcing change events, so, for the code that updated our global Group collection in response to a periodic server poll, I changed over to “reset” instead. It even seemed more correct, in my mind: make the groups list exactly like the latest state from the server.

Unfortunately, “reset” works by first emptying the collection of its existing models, then re-populating it. That emptying carries the consequence that those previous occupants — such as the Group object that the editing UI had a reference to — would be orphaned, no longer a member of anything. No parent collection meant no “url” method, and that meant no way to save.

I felt a bit stupid for having caused such a regression, but that was eclipsed by my frustration that such a bug was even possible. Model objects that are capable of saving themselves had already been a pet peeve of mine due to how they hindered testability, but now I found model objects that could arbitrarily lose their ability to save themselves in the middle of my program!

This was a mutation bug on steroids: an object’s functionality changing not even due to local state modifications, but by whether or not another object was holding a reference to it. How could I reason about behavior if this possibility was lurking in my code? What automated test would have even exercised this?

I was determined. I was vengeful. It was now time to, as they say, React all the things.

The DOM Doctors

Doubling down on a new UI rendering library might seem a strange way to solve a model logic problem, but React has the remarkable power to send ripples of correctness through your codebase. Consciously or not, libraries like Backbone end up encoding assumptions about how views work in their data classes. If we fundamentally changed how rendering happens, why wouldn’t that affect how we managed data?

If you’ve heard anything about React, it’s probably that it has a “virtual DOM” that makes its HTML fast using an efficient tree diff algorithm. If you’re like me, the first time you heard that you may have dismissed it. My HTML isn’t slow.

And maybe it’s not that slow, but only because we frontend developers learned not to push it. We joined together our template strings for one big innerHTML splat at the outset and then just modified individual elements going forward. We couldn’t conceive of being so callous as to re-render an entire dialog just because a group’s name changed. We were good programmers, we were precise. We were surgeons, jQuery was our scalpel, and when the “name changed” event came in we made only the tiniest incision in the page to bring it up-to-date.

There’s another reason for why we stepped lightly in the tree: DOM elements are stateful beyond how we created them. They have focus, or scroll positions, or in-progress edits. Some cavalier re-rendering wouldn’t just be slow, it would stomp user data at the same time. And that, at least, was unacceptable.

These constraints had a profound effect on our code. We couldn’t just write the state of what our UI should look like (“the button is disabled because a network request is in progress”). Instead, we were condemned to write the state transitions between those UIs. On network request start? Add class “disabled.” On complete? Remove class “disabled.” If we were lucky, we found all the ways that state tended to linger on our pages. On showing a form? Remove any error messages from the last time we showed this form.

Testing this style of code is both painful and approximate. On top of exercising your initial rendering, you need to test your transitions. They need plausible prior states just to run, but to have good coverage you need to test them against each important variation of prior state that your application is capable of getting itself into. A “finite” state machine perhaps, but only in theory.

Spared from Change

Enter React. The real benefit of that O(n) tree-diffing algorithm isn’t performance per se. It’s that it frees us from having to hand-write every state transition in our UI. Besides reducing drudgery, that actually eliminates the entire class of leaky-state bugs mentioned above. If you declare that your UI is a dialog with an active button and no error message, React will transition to exactly that, performing DOM manipulations that ensure that your button is active and no error message is seen. Any vestiges of previous state are cleansed with no extra effort on your part.

Fundamentally, your old state transition code was a function over your application data, but also over the previous state of the UI. That’s why you needed to consider varied “prior states” when testing. In contrast, your React rendering code is a function over just the application data. You can imagine how much more pleasant that makes your tests.

The real answer to how “just” a view library can affect your data handling is that React is a view library because that’s all that it needs to be. When I talked about the Backbone data classes having assumptions about the way you displayed your UI, I was thinking of mutation handling and attribute-level change events. If you’re writing minimal state transitions, that kind of information is important for doing precise DOM surgery. If you’re writing a React component, though, where declaring UI state is cheap and getting to it is fast, the only notification you really need is “something has changed, probably.”

Since all you need are coarse-grained change notifications, your data objects can be correspondingly simpler. One could argue that React even works best on just plain hashes and arrays. All you need is for a data source to hand your component hierarchy the latest values, and everything flows efficiently from there. No mutation-tracking, self-saving, collection-inhabiting model objects necessary.

Efficient coarse updating also enables what may be my favorite part of React: props and state.

In a correctly-written React component, the only inputs to the UI rendering method are its “props” and its “state.” These are exposed as a pair of hashes on the component object, and changes to either of them cause the component to re-render. (Something has changed, probably.)

The difference between the two is how they change. “props” can be thought of as the input from the outside world. It’s set from the parameters your component is called with, and its values should be treated as immutable. “State,” on the other hand, is the data that’s owned by your component. You update it via the “setState” method, and no one else should be changing it on you.

To give a concrete example, consider a component for editing a group. The props would include the group’s name, while the state might be whether it’s showing a “delete” link or the “confirm” / “cancel” buttons that appear instead when that link is clicked.

This may seem like just a helpful little pattern, but by calling out this distinction between props and state, React has bestowed an enormous understandability boon on your code. Gone is the catch-all “options” hash that contains everything, internal and external. Your data is going to naturally fall into one hash or the other, so there’s one fewer choice to make when structuring your component, and, more importantly, one more signal of your intent when your team comes back to your code months later to extend it.

In practice, the state of one component actually ends up trickling into its child components as props, and establishing your intention is even more valuable. When the same data is “state” here and “props” there it’s perfectly clear what level of your component hierarchy is responsible for coordinating its changes.

Finally, when you consider testability, you can, in almost every case, proceed in ignorance of changes to your component’s props. So, while you and I both know that group names can change, all the component that renders the list of groups in the sidebar needs to do is render the names it’s given. If they change, it’ll be given new names, and it’ll render them just the same. No need to waste time in your tests verifying that case.

Path to salvation

React is fascinating because it takes this rather clever little algorithm for fast tree diffing and follows it to its logical extreme, introducing an incredibly effective paradigm to web developers: If we can diff in O(n) time we can quickly convert one DOM tree to another. That means it’s efficient even if the difference is small. It also means we can keep that partially-filled <input> around. That means we can do coarse-grained updates for any change. That means that re-rendering can be triggered automatically by the framework. That means we can have a simple, standard pattern for state management. And so on.

As a library, React doesn’t really let you build anything that you couldn’t do before with any other UI framework. Maybe some things will be more performant out-of-the-box, but functionality-wise your product will be very much the same. What React gives you instead is much less, better code, sooner. Declarative UIs are faster to write, simpler to test, and far far far easier to reason about.

It feels like nothing short of giving you frontend engineering superpowers.

Hopefully this has whet your appetite for React. Maybe it will be as revelatory for you as it has been for me. Soon, I’ll follow this post up with some more specifics about how we’re using React on Crashlytics, why you don’t need JSX, and our take on a unidirectional data flow pattern :)

We're helping our customers build the best apps in the world. Want to be a part of the Crashlytics team and build awesome stuff? Ping us @ jointheflock@twitter.com. We look forward to chatting with you!

(Big thanks to Kevin Robinson, Sam Neubardt and Sam Phillips for contributing to this post.)

Crashlytics February Update

Crashlytics_February_2015_Update

Roses are red, violets are blue..and we are thrilled to ship new upgrades to you! Last month, we launched two brand new integrations with GitLab and OpsGenie to help you stay on top of crashes and collaborate with your team to fix the most critical issues. In February, despite having Valentine’s day, the Super Bowl and the endless New England blizzards, we still worked around the clock to bring you even more feature enhancements and new functionality :)

Finally, Dark Mode Support

For those of you building on Yosemite, we recognized that some of you have customized your desktop’s look and feel with its new “dark mode“. This month we’ve solved the hardest computer science problem yet: Crashlytics now supports Yosemite dark mode! Your Mac App now automatically detects the mode and displays the Crashlytics icon in its light or dark version accordingly, ensuring that the icon is always visible within the OS X toolbar. All jokes aside, we've actually been heads down building lots of other great stuff in the past few months which you’ll be seeing in the near future -- so stay tuned!

crash_icon_on_yosemite_dark_mode_screenshot-e1424973461809.png

A More Robust Foundation

We’ve been fortunate to power many of the world’s top apps and be trusted by thousands of companies since building Crashlytics three years ago. Like all services of this scale, we’ve accumulated some technical debt, so we spent this month performing some massive internal refactoring on our infrastructure. We started by segmenting large classes into smaller parts and re-organizing our code to make writing unit tests easier. We also brought up a new cluster, implemented sampling and migrated data from old cluster to scale our session service. Now, we can deploy feature enhancements and bug fixes for you faster and safer than ever before, while laying the foundation for more stability and better performance in the future.

Latest Toys from Crashlytics Labs

Many of you who are building awesome apps with the NDK on Android have requested support from Crashlytics. Since opening access to our beta program in October, our Labs team has continued building this out and enhancing its functionalities every day. We're now working with top companies who have already shipped their apps with our beta -- so if you haven’t test out our NDK beta yet, request early access here :)

Here’s our internal changelog:

Crash Reporting

  • iOS SDK
    • Improved crash reporting latency when devices have no network access.
    • Fixed an issue with NSUserDefaults access while an app is in the background.
  • Mac App
    • Implemented icon support for Yosemite in dark mode.
  • Infrastructure
    • Performed large scale internal refactoring.
    • Segmented large classes into smaller parts.
    • Re-organized code structure to make writing unit tests easier.
    • Enabled enhancements and bug fixes to be deployed faster and safer for customers in the future.
  • Web
    • Fixed minor bug for Crashlytics and Fabric related accounts.

Beta Distribution

  • Build Tools
    • Fixed minor bugs within Gradle integration to make distribution uploading more robust with flavor dimensions.

Crashlytics January Update

 

It was exactly two years ago that we joined forces with Twitter. Since the acquisition, not only have we continued to make Crashlytics even more powerful, we also released several major products in 2014 -- Beta by Crashlytics, Answers, and most recently, Fabric. What an incredible journey it has been!

In December, we were busy crafting a dozen new gifts for you just before the holidays: more upgrades for Beta by Crashlytics, new app installs tracking with Answers, and more. Even though we were stuffed from all the holiday feasts, we are kicking off the new year strong with two new integrations and a ton of feature enhancements :)

Brand New Integrations

Just two months ago, we launched our integrations with Slack and FogBugz to help you strengthen team collaboration and manage your projects. Now, we’re excited to unveil two more integrations: GitLab and OpsGenie.

We understand the importance of staying on top of crashes and collaborating with your team to fix the most critical issues as they occur. Based on overwhelming demand from many of you, Jeremy Durham built the Crashlytics integration with GitLab. With this integration, crashes are automatically delivered to your issues management dashboard on GitLab so you can track all issues and bug fixes in one central place. On the other hand, our OpsGenie integration, built by Halit Okumuş, automatically alerts you if an issue changes status or a new issue occurs. Now, you can sit back and focus on the fun stuff, like coding the next coolest app!

Digits: Login for Web

For those of you building mobile-first services, the best signup experience is likely to be through the native app. But you may also want your users to continue to engage with your apps on the web. This month, we launched Digits login for web which allows you to implement a simple and secure login on your app’s website with just a few lines of code. To help you preserve the mobile-first experience of your service, your users still sign up first through your mobile app, as they normally would, before they can log in to your site. But now, not only can Digits help you drive more downloads for your app, it also enables you to bring your mobile service onto the web — giving you a consistent identity experience across platforms.

Here’s our internal changelog:

Fabric Platform

  • Android Studio
    • Tweaked the plugin so it does not appear on top of other application windows.
    • Added support for multiple monitors.
  • IntelliJ
    • Tweaked the plugin so it does not appear on top of other application windows.
    • Added support for multiple monitors.
  • Eclipse
    • Improved kit refreshing functionality by adding 'Refresh Kits' option from 'kits.properties'.
    • Enhanced support for multiple monitors.

Crashlytics Kit

  • Crashlytics
    • Integrated crash reporting functionality with GitLab issues management.
    • Integrated crash reporting functionality with OpsGenie issues alert service.

Twitter Kit

  • Digits
    • Web
      • Launched Login for Web functionality to make it easy for mobile-first-apps to to use phone number identity across the web.
    • Android
      • Removed Twitter login from fallback screen.
      • Fixed Resources$NotFoundException on Gingerbread devices.
      • Fixed theme detection when building with Eclipse.
      • Fixed functionality to update old guest authentication token.
      • Improved handling of different target SDKs.
  • TwitterCore
    • Android
      • Added logInGuest method to enable guest access to statuses endpoints user_timeline, show, and lookup, search/tweets, and favorites/list.

Crashlytics December Update

 

Just like the best holiday cards are written from the heart, every line of code we’ve written since the birth of Crashlytics came from our passion of building tools that developers love. In November, we were heads down coding up new 3rd party integrations, a more powerful Swift Support and an upgraded Beta by Crashlytics -- all while continuing to build out our NDK support at Crashlytics Labs. This month, we’ve been busy crafting a dozen new gifts for you: more upgrades for Beta by Crashlytics, new app installs tracking with Answers, and more. We’re excited to share these gifts with you before the year draws to a close!

Beta by Crashlytics: Share Your Builds Anywhere

Many of you have requested the ability to share your builds through other channels beyond email. Now, with share links for Beta, you can create direct links to specific builds while having complete control over who can access those builds -- whether it’s external press or internal employees for dogfooding. To help you fix crashes even faster, we now identify the exact tester who experienced the particular issue right within your crash report -- so you can contact that tester and gather feedback immediately.

Answers: Free App Installs Tracking

Running marketing campaigns to grow and monetize your apps can be difficult, especially when it’s expensive to measure installs. Together with teams at Twitter, we've integrated Answers with Twitter’s advertising platform to make tracking installs incredibly simple. Now, within seconds, you can have total visibility into the installs driven by your paid and organic campaigns on Twitter -- completely free, with no additional code! Also, our solution is now self-serves so you can easily manage your campaigns. Learn more about app installs tracking with Answers here.

Digits: Now Themed to Your App

Your app’s sign-in experience is crucial to growing and retaining your user base. When Digits was first released back in October, you could already launch the Digits sign-in flow from any button anywhere within your app. This month, the Digits team launched theming support to help you further optimize your onboarding experience on both iOS and Android. With the new support, you can match Digits exactly to your app’s ambience so your Digits sign-in flow looks indistinguishable from your app. Theming requires just a few lines of code, and Digits will do the rest!

Here’s our internal changelog:

Fabric Platform

  • iOS SDK
    • Fixed minor bug that occurred for users with multiple accounts.
  • Android SDK
    • Shipped multiple bugfixes.
    • Updated Android tests to make them compatible with Level 21.
    • Updated SDK version from 7 to 8.
    • Fixed kit initialization error that affected a small amount of developers.
  • Mac App
    • Released updated Kits and enabled update by customers through the app.
  • Android Studio Plugin
    • Released updated Kits and enabled update by customers through the plugin.
  • IntelliJ Plugin
    • Released updated Kits and enabled update by customers through the plugin.
  • Eclipse Plugin
    • Released updated Kits and enabled update by customers through the plugin.

Crashlytics Kit

  • Crashlytics
    • Web
      • Shipped crash-to-tester feature to identify the tester who experienced a specific crash.
      • Implemented auto-tagging of all crashes of beta builds with testers’ names and email addresses.
  • Beta by Crashlytics
    • iOS SDK
      • Shipped upgrades to allow for future Beta and Answers integrations.
    • Android SDK
      • Shipped upgrades to allow for future Beta and Answers integrations.
    • Web
      • Increased tester limit on groups to 500.
      • Implemented share links for sending specific builds.
      • Shipped domain restriction functionality for share links.
      • Deployed dashboards for managing share links and tester access.
      • Shipped functionality to automatically point internal share links to the latest build.
      • Implemented auto-tagging of all crashes of beta builds with testers’ names and email addresses.
  • Answers
    • iOS SDK
      • Implemented functionality to enable Twitter conversion tracking.
      • Shipped upgrades to allow for future Beta and Answers integrations.
    • Android SDK
      • Implemented functionality to enable Twitter conversion tracking.
      • Shipped upgrades to allow for future Beta and Answers integrations.
    • Web
      • Shipped ability for customers to select Answers on ads.twitter.com and analytics.twitter.com UI.
      • Implemented functionality to enable app install tracking via self-service.

Twitter Kit

  • Base
    • Improved proguard configuration by bundling Consumer Proguard Config file with AAR.
  • Digits
    • iOS
      • Shipped custom theming support.
    • Android
      • Shipped custom theming support.
  • Twitter Sign In
    • Improved stability of Twitter login on devices that do not have the Twitter for Android App.
    • Ensured Login with Twitter and Share Tweet button text doesn't show in all caps on API 21.

MoPub Kit

  • iOS
    • Shipped MRAID 2.0 support.
    • Shipped specification to enable rich media ads in banners and interstitial ad units.
    • Shipped automatic geolocation updates for apps that already have location permissions.
    • Implemented functionality to automatically attempt to acquire location data for ad requests (permission-based).
    • Added support for AdColony SDK 2.4.12.
  • Android
    • Shipped MRAID 2.0 support.
    • Shipped specification to enable rich media ads in banners and interstitial ad units.
    • Shipped geolocation polling updates.
    • Updated the ChartboostInterstitial custom event to support Chartboost SDK 5.0.4.

This year has been full of fun and excitement and we can’t wait to continue to celebrate with you into next year. Happy holidays from our Crashlytics family to yours :-)

Announcing Share Links and Crash-to-tester for Beta by Crashlytics

beta-share-links-header-v2

It’s been just seven months since we launched Beta by Crashlytics. We’ve been thrilled by the response from developers looking for a seamless way to distribute beta builds of their apps to testers. In August, we released groups support, the first of many product additions, and in October, we re-released Beta as part of Fabric. Today, we’re excited to share the next evolution of Beta.

We heard you loud and clear that you need an even lighter-weight way of sending out builds – without email – and be able to control who gets access. Another challenge: how to efficiently get detailed, actionable feedback from testers about your crashes. Now we think we’ve got you covered with share links, the most convenient way to onboard testers to your builds, and crash-to-tester Identification, which combines the power of Crashlytics and Beta to help you quickly get to the bottom of your builds’ crashes.

Total Flexibility for Onboarding Testers

Many of you want to share your builds through channels beyond email. Now, with share links, you can seamlessly create onboarding links for each build and invite testers through any medium you choose – without needing to know their email addresses. Whichever channel you prefer, you have the flexibility to tailor your message to testers.

beta-share-link-v2

Within your share link dashboard, you can manage all your links in one place -- with complete control over who can access your builds. Share a public link with the press or your investors, or create a private link for internal dogfooding by setting domain restrictions. We also automatically point your internal links to the latest build so your testers can always access the latest from one reliable place.

No need to worry about manually adding new testers either! With share links, you can automatically assign new testers to a group when they sign up via your link. This ensures that everyone will receive your updates in the future, as soon as you send them out. On top of that, you can now create specific groups ahead of time based on where you plan to post your links. Organizing testers have never been easier.

Deep, Actionable Testers Feedback

One of the most powerful features of Beta is its deep integration with Crashlytics’ crash reporting, which empowers you to fix the most critical issues with the least effort before your app goes into the wild. With our new crash-to-tester functionality, you can instantly identify the individual tester who experienced a specific crash right within your crash reports.

crash-to-tester-v3

We automatically tag all crashes of your beta builds with your testers’ names and email addresses. Now, you can immediately contact your testers for feedback and even work with them to reproduce an issue. Coupled with your crash reports and custom meta data, you’ll be able to trace the exact steps and situation your testers were in when they encountered the issue.

From our friends at Lyft:

Using the direct share links has made distribution simple and easy. I can now use one link to ensure our testers always have the latest builds by sharing the link across multiple channels, including email, SMS, and social. In addition, the crash-to-tester feature has reduced time spent investigating issues by connecting users to specific crashes, tracing their actions leading up to them, and including relevant contact information for easy follow-up.

Will Farino,


Let us know what you think. Our roadmap is full of exciting features which we’ll continue to roll out in the coming months. Stay tuned!

 

Crashlytics November Update

 

It’s that time of year! The falling leaves, checkered scarves, pumpkin-flavored everything..the perfectly cozy atmosphere to sit down, code and ship something awesome. In October, we were thrilled to ship and unveil Fabric, the easiest way to build the best apps. But we didn’t stop there. Going into November, we were heads down building out even more new functionality and upgrades that you can play with before the holiday arrives :)

Finally, the Easiest Way to Build the Best Apps

Since the birth of Crashlytics, our mission has been to build the best suite of tools and services for mobile developers. We’ve thought long and hard about how to help developers address the most pervasive challenges: stability, distribution, revenue and identity. At Twitter Flight on 10/22, we officially launched Fabric, a modular mobile platform that helps you solve any one – or all – of these challenges. Learn more about Fabric here.

Since the launch, we’ve been inundated with requests for access. If you haven’t signed up for Fabric yet, request an invite!

Brand New Integrations

Since open sourcing our integrations code last year, we’ve seen many developers build and submit integrations on top of our existing infrastructure. Now, we’re excited to unveil two new integrations to help you strengthen team collaboration and manage your projects: Slack and FogBugz.

We understand the importance in team collaboration and being in constant communication to understand who’s working on what. Emmanuel Pinault built the Crashlytics integration with team collaboration service Slack. With this integration, messages are posted directly into your preferred channels so you can quickly and easily communicate with your team about your app stability. On the other hand, our FogBugz integration, built by Jeremy Durham, automatically organizes and imports your app crashes into your issues tracker on FogBugz. Now, you can keep a close eye on the performance of all your projects -- mobile or web -- in one central place!

More Powerful Swift Support

We’ve been working on enhancing our official support for Swift since launching it two months ago. Now, by combining our new logging functionality for Swift with real-time search, you can instantly locate the exact crashes you were looking for in your apps and know precisely what happened leading up to the critical moment. Enjoy coding in Swift -- we’ve got you covered.

Fine-Tuned Beta by Crashlytics

To make it even simpler for you to manage your testers, we added “groups on release” to your Beta web dashboard. You can now, at a glance, track the progress of all your groups and individual testers associated with a specific build. Also, your testers progress dashboard now updates in real-time!

Latest Toys from Crashlytics Labs

Since launching Crashlytics two years ago we’ve been tirelessly seeking out feedback from our customers. Many of you who are building awesome apps with the NDK tool set on Android have requested support within Crashlytics. Our Labs team has been hard at work building this out, and we are very excited to invite you to request access to participate in our beta program.

Growth & Monetization, Simplified

Beyond stability, we wanted to help you tackle the challenges of growing and monetizing your apps. Together with teams at Twitter and MoPub, we’ve built the Twitter Kit and MoPub Kit for Fabric. With the Twitter Kit, you can create a seamless onboarding experience through Digits and instantly tap into Twitter’s network and content to grow your audience. The MoPub Kit, on the other hand, empowers you to turn your app into a business by making it dead simple to integrate ads with just a few clicks. Both kits are easily accessible in your new Mac app / Android IDE plugins.

Here’s our internal changelog:

Fabric Platform

  • iOS SDK
    • Integrated Crashlytics Kit (Crashlytics, Beta by Crashlytics and Answers by Crashlytics).
    • Integrated Twitter Kit (Digits, Sign In to Twitter and Tweet Embeds).
    • Integrated MoPub Kit.
    • Shipped one-line-of-code install functionalities for Crashlytics Kit, Twitter Kit and MoPub Kit.
    • Implemented Swift onboarding support for kits.
    • Simplified usage of Tweet IDs throughout iOS codebase.
  • Android SDK
    • Integrated Crashlytics Kit (Crashlytics, Beta by Crashlytics and Answers by Crashlytics).
    • Integrated Twitter Kit (Digits, Sign In to Twitter and Tweet Embeds).
    • Integrated MoPub Kit.
    • Shipped one-line-of-code install functionalities for Crashlytics Kit, Twitter Kit and MoPub Kit.
    • Refactored Android session management to include Digits support.
    • Shipped network stack refactorings to reduce SDK size.
  • Mac App
    • Shipped new Fabric Mac app with kits selector.
    • Implemented support for XCode 6 and legacy XCode versions in the new Mac app.
    • Deployed ability to install individual kits or upgrade to new kit versions.
  • Android IDE Plugins
    • Shipped new Fabric Android IDE plugins with kits selector.
    • Implemented support for Android Studio, IntelliJ and Eclipse in the IDE plugins.
    • Deployed ability to install individual kits or upgrade to new kit versions.
  • Web
    • Shipped new Fabric web dashboard to include Crashlytics, Beta by Crashlytics,  Answers by Crashlytics, Twitter Kit and MoPub.
    • Redesigned entire onboarding experience (i.e. Mac app/Android IDE plugins installation, build tools integrations, email notifications) with Fabric branding.
    • Implemented auto-download functionality for Android IDE plugin install packages.

Crashlytics Kit

  • Crashlytics
    • iOS SDK
      • Integrated into Crashlytics Kit on Fabric.
      • Shipped new reports endpoint to prepare for new SDK version.
      • Launched logging functionality for Swift.
      • Shipped extension support for iOS 8.
    • Android SDK
      • Integrated into Crashlytics Kit on Fabric.
    • Integrations
      • Implemented Slack and FogBugz service hooks.
  • Beta by Crashlytics
    • iOS SDK
      • Integrated into Crashlytics Kit on Fabric.
    • Android SDK
      • Integrated into Crashlytics Kit on Fabric.
    • Web
      • Launched direct URLs for onboarding testers to specific builds.
      • Implemented ability to identify specific tester who experienced a specific crash inside crash reports.
      • Resolved javascript errors on tester side.
      • Fixed group summary counts.
  • Answers by Crashlytics
    • iOS SDK
      • Integrated into Crashlytics Kit on Fabric.
    • Android SDK
      • Integrated into Crashlytics Kit on Fabric.
      • Shipped IDFA collection in Fabric.
  • Crashlytics Labs
    • Opened private access via /secret to beta program of NDK support.

Twitter Kit

  • Digits
    • iOS
      • Launched integration and sign in button initialization support.
      • Shipped sign in, sign up and phone number confirmation functionalities.
      • Shipped unique user IDs and OAuth tokens support.
      • Shipped “Find Friends” functionality for your apps’ end-users.
      • Launched support for 28 languages.
    • Android
      • Launched integration and sign in button initialization support.
      • Shipped sign in, sign up and phone number confirmation functionalities.
      • Shipped unique user IDs and OAuth tokens support.
      • Shipped “Find Friends” functionality for your apps’ end-users.
      • Launched support for 28 languages.
    • Web
      • Launched integration support with Javascript.
      • Shipped sign in, sign up and phone number confirmation functionalities.
    • Digits.com
      • Implemented custom security settings (i.e. two-factor authentication) for your apps’ end users.
  • Twitter Sign In
    • iOS
      • Launched single sign-on functionality.
      • Shipped support for Twitter sessions callback and exceptions handling.
      • Shipped functionality to request Twitter end-user email.
    • Android
      • Launched single sign-on functionality.
      • Shipped layout XML support for sign in button integration.
      • Shipped support for Twitter sessions callback and exceptions handling.
      • Shipped functionality to request Twitter end-user email.
  • Tweet Compose
    • iOS
      • Shipped Tweet composer for end-users to share your app’s content on Twitter.
    • Android
      • Shipped Tweet composer for end-users to share your app’s content on Twitter.
  • Embedded Tweets
    • iOS
      • Shipped embeddable Tweet objects in native apps.
      • Implement support for custom sizing and theming Tweets to match your app fonts/colors.
      • Shipped localization support.
      • Implemented OAuth Echo support.
    • Android
      • Shipped embeddable Tweet objects in native apps.
      • Implemented support for custom sizing and theming Tweets to match your app fonts/colors.
      • Shipped localization support.
      • Implemented OAuth Echo support.
  • Web
    • Shipped new dashboard for Twitter on fabric.io.

MoPub Kit

  • Mac App
    • Implemented ads format selector.
  • Android IDE Plugins
    • Implemented ads format selector.
  • Ads Integration
    • Native Ads
      • Shipped integration, sizing, placement, targeting and auto-caching support inside Fabric.
    • Video Ads
      • Shipped integration, placement, targeting and auto-caching support inside Fabric.
    • Interstitial Ads
      • Shipped integration, placement, targeting and auto-caching support inside Fabric.
    • Banner Ads
      • Shipped integration, placement, targeting and auto-caching support inside Fabric.
  • Web
    • Shipped new dashboard for MoPub Kit on fabric.io.

Introducing Fabric

  Introducing Fabric

Almost three years ago, we set out to solve the problem of mobile crash reporting. Since then, we’ve launched our deeply technical, award-winning crash reporting service, and with Twitter, expanded our product line to include a white-labeled beta distribution tool and our real-time mobile analytics product. Our mission has been, and remains, to build the best mobile developer tools.

Today at Flight, we announced the evolution of all of this work: Fabric, a modular mobile platform that makes it easy to build great apps.

We’ve thought long and hard about how to deliver great solutions to address the challenges developers face. The Crashlytics team, together with teams at Twitter and MoPub, have developed Fabric. It’s exactly what we hoped to build back when we started the company.

Fabric is modular, so you pick just the features — we call them kits — you want. If the Crashlytics Kit is the one you need for your app, you can easily add just that one. Crashlytics customers will recognize the Fabric interface: it’s based on our existing IDE plugins but with a fresh new look. You’ll even see the same familiar dashboard.

Read more about the Fabric features and individual kits on the Twitter developer blog.

What’s next

In the coming weeks, we’ll be rolling out Fabric to current Crashlytics customers. We’ve worked to make the upgrade experience very simple for you. If you’re interested in exploring the other kits (Twitter and MoPub), they are easily accessible in the new plugin.

As with all our launches, your experience and feedback is critical to us. Write to support@fabric.io to let us know your thoughts. We really want to build the tools that you love to use.

Onward,

 

Crashlytics September Update

September_Update

School’s back in session, and we have lots of upgrades and enhancements for you.

Last month, we launched group support for Beta by Crashlytics and improved plugin support on Android. This month (while many of you were no doubt waiting in line for your new iPhone), we shipped enhanced features for Answers by Crashlytics and Beta by Crashlytics, launching Swift support and improved version tracking. Oh, and we also unveiled our participation in Twitter’s first mobile developer conference, Flight. Will we see you there?

Improved alerts

When we launched Answers by Crashlytics, we set out to create a mobile analytics tool that required zero analysis. We wanted the alerts to be so intuitive that you could understand the pulse of your app with just a glance. Now with email alerts, it’s even easier for you.

Our daily digest offers a summary of your app’s performance from the previous day. With these top-level metrics, you easily get a sense for how your apps are performing without you needing to do any analysis – delivered right to your inbox. With our real-time stability alert email, you know immediately if the stability of your apps has changed. No need to sit and watch your dashboard all day, we’ll deliver the information to you, with the ability to easily jump back into the stability page of your Answers dashboard. And as with all of our email notifications, you can easily manage your preferences in your settings dashboard.

The more the merrier

Last month, we launched group support for Beta by Crashlytics, giving you the ability to send specific builds to a specific set of testers based on their development cycle. This month, we added the ability to upload .csv files. Now you can easily import lists and add testers to groups to get even more of them up and running.

Gone, but not forgotten

We know many you have very active release cycles; older versions of your app quickly become outdated. We heard you loud and clear when you asked for the ability to archive old versions so you can declutter your version list. Now, your dashboard shows a quick view of the versions that matter most.

We love when you share ideas of how we can make app development easier, and are always eager to learn how we can help. Make sure you keeping sending along feedback, product requests or just say hi to our team at support@crashlytics.com.

Build how you want, where you want

When Apple promoted Swift as a language that was easier to read and maintain, we wanted to get on board. So this month, we launched support for Swift apps, providing developers with the flexibility you need to build inside existing workflows and streamline the overall development process. We developed a customized onboarding experience with our Mac app letting you choose between building with Objective-C or Swift. Whether you’re new to Crashlytics or migrating to this new language, you’ll experience the same powerful features, combined with native support for Swift-based builds.

Join us at Flight

In case you missed it, we announced Twitter Flight: Twitter’s first conference exclusively for mobile developers. There’s still time to apply to attend. We’d love to see you there, so don’t miss out!

Here’s our internal changelog:

General

  • iOS SDK
    • Removes requirement to import Crashlytics in your bridging header for Swift apps.
    • Mac App
      • Support for seamless Swift app onboarding via plug-in.

Beta by Crashlytics

  • Web
    • Added .csv upload allowing you to easily import tester lists.

Answers by Crashlytics

  • Web
    • Launched the daily digest email highlighting your key metrics from the previous day and the real-time stability alert email.

Crash Reporting

  • Web
    • Added version archiving to declutter your version list.

Join Crashlytics at Twitter Flight

 

Today Twitter announced Flight, the company’s first annual conference for mobile developers, and we’re joining in on the fun. Flight will take place on October 22nd in San Francisco. At Flight, you’ll have a chance to learn how Twitter can help you build the best mobile apps. You can learn more about Flight on the Twitter Developers blog.

As a friend of Crashlytics, we want to give you the first chance to apply to attend Flight. So take a peek at the details, apply, and we hope to see you there!

Launching Crashlytics Swift Support

swift_header_image

When Apple introduced Swift, their new programming language, at this year’s WWDC, like you our engineers didn’t waste any time and dove in to see what it was all about. After spending the past few months testing out support in our developer preview, we’re excited to announce Crashlytics official support for Swift!

Build How You Want, Where You Want

At Crashlytics, we’re huge supporters of making it as easy as possible to develop mobile apps. When Apple promoted Swift as a language that was easier to read and maintain, we knew we wanted to get on board. In anticipation of Apple’s upcoming announcement, we’re rolling out our official support so that developers can quickly get up and running. Our support for Swift provides developers with the flexibility they need to build inside their existing workflows and streamline the overall development process.

Our engineers worked tirelessly updating our backend to support the demangling of Swift crashes and took meticulous care to preserve our seamless onboarding and pristine UI. To provide you with a customized onboarding experience, our Mac app allows you to choose between building with Objective-C or Swift. Whether you're new to Crashlytics or migrating to this new language, you’ll experience the same powerful features, combined with native support for Swift based builds.

swift_screenshot (1)

We love supporting developers as they continue to experiment with new and improved ways for building mobile apps. We’re excited for the launch of Crashlytics support for Swift, get started here.

Crashlytics August Update

 

The buzz from the Emmy’s is still in the air and while we all can’t be as lucky as Breaking Bad, the updates we have for you this month are certainly something to celebrate! Last month we launched our latest product, Answers by Crashlytics, and already have thousands of developers viewing their dashboard daily to understand their apps growth. This month we bring you enhanced features for Beta by Crashlytics and upgraded support for your Android IDE’s.

New Features for Beta by Crashlytics

Just last week we launched group support for Beta by Crashlytics, the first of many new features to build on top of our existing service. With groups, we’ve developed a smooth and intuitive workflow allowing you to distribute builds to select groups of testers with minimal effort. Through our intuitive tester management UI, you can easily find the testers you’re looking for and create tester groups.

With group management now integrated into our Mac app and Android IDE plugins, you can send builds to your groups within your existing workflow. For those of you who prefer continuous integration, using our build server support, you can now automatically send builds, specify the receiving groups, and publish release notes from the command line.

We’ve also made updates to the Android IDE plugins to show only the 20 testers with the most recent activity, with the ability to quickly jump into your dashboard for a full view of all testers -- coming soon for the Mac app.

Improved Experience for the Latest Builds

We understand that developers are constantly upgrading their tools to the latest and greatest. We’ve added support and improved our plugin UI on IntelliJ and Android Studio for developers running Java 8.

On the iOS side, we’ve also made a commitment to ensure that developers are always having the best experience possible, even running Apple’s betas. We’ve improved support when distributing beta builds through Beta by Crashlytics for users running latest Mac OS X betas.

Hang out with Crashlytics

Curious to learn more about what we’re building and meet the team behind the scenes? We’re hosting a meetup in Boston and would love to meet you! Stay tuned for more meetups near your area coming soon.

Here’s our internal changelog:

General

  • Android SDK
    • Improvements to the onboarding experience to prevent errors when Android Projects aren’t parsed correctly.
    • Visual enhancements to code snippets when manually adding code while onboarding.

Beta by Crashlytics

  • Mac App
    • Upgrades to support groups distribution.
    • Improved support for distributing beta builds for users running latest Mac OS X betas.
  • IntelliJ Plugin
    • Upgrades to support groups distribution.
    • Updated the Beta distribution status screen to reflect the 20 testers with the most recent activity, including a link to your dashboard to view all testers.
    • Added support and improved plugin UI for developers running Java 8.
  • Eclipse Plugin
    • Upgrades to support groups distribution.
    • Updated the Beta distribution status screen to reflect the 20 testers with the most recent activity, including a link to your dashboard to view all testers.
  • Android Studio Plugin
    • Upgrades to support groups distribution
    • Updated the Beta distribution status screen to reflect the 20 testers with the most recent activity, including a link to your dashboard to view all testers.
    • Added support and improved plugin UI for developers running Java 8.
  • Android Beta App
    • Fixed corner case crashers on the App list screen and App details screen.
    • Made improvements to address network timeouts to better accommodate flaky connections.

Introducing Groups for Beta by Crashlytics

groups-beta-by-crashlytics-header1.png

We launched Beta by Crashlytics with the goal of creating the most seamless beta distribution tool for developers and testers. After seeing a rapid adoption of our service, we recognized that there are other features we could build that would make beta distribution even more streamlined. We’re excited to launch group support, the first of many new features to build on top of our existing service.

We understand that often times developers need to send specific builds to a specific set of testers based on their development cycle. To combat the tedious process of individually selecting testers, we developed a much smoother and intuitive workflow. With our new groups feature, you can now distribute builds to select groups of testers with minimal effort.

With our smart search and dynamic interface, you can instantly find the testers you’re looking for. We’ve built an intuitive tester management UI allowing you to easily create tester groups and send builds to these groups within just a few clicks. To further streamline the group creation process, you now have access to your groups across every app within your organization, eliminating the need to create the same group twice.

groups-beta-by-crashlytics-screenshot.gif

To give you the most flexibility, we’ve integrated group management into our Mac app and Android IDE plugins -- so you can send builds to your groups right within your existing workflow. For those of you who prefer continuous integration, using our build server support, you can now automatically send builds, specify the receiving groups, and publish release notes. You can collaborate with your team having them manage the testers and create groups ahead of time and just hit “send” when the time is right.

From our friends at Opera Software:

Group support from Crashlytics simplifies distributing our apps to a large set of testers. Not only is it easy to add, manage and distribute to a group, but it's pretty too! This is exactly what every company distributing their app needs.

Carsten Zeiffert,


We hope you enjoy using groups for Beta by Crashlytics. We have many more functionalities on our roadmap and plan to continue rolling out new features in the coming months -- stay tuned!

Crashlytics July Update

 

Last month, amidst the World Cup excitement, we shipped several new integrations and tons of enhancements for both crash reporting and Beta by Crashlytics. With the summer in full swing, this month we officially released Answers by Crashlytics along with more new features and performance upgrades for Beta by Crashlytics.

Finally, Mobile Analytics You Don’t Need to Analyze

Ever since we launched Crashlytics two years ago, we saw a need for powerful tools that can help developers not only build, but also grow great apps. Two weeks ago, we launched Answers by Crashlytics, a new approach to mobile analytics that provides live insights into app usage, user growth, engagement and retention. Built into our existing Crashlytics SDK, you’ll have instant visibility into the key metrics and drivers of your app’s growth -- with just one click and no extra code changes!

With Answers by Crashlytics, you can immediately understand your most important metrics, without having to guess the cause of abnormal user engagement; we’ll connect the dots for you. By intelligently analyzing long term trends, Answers provides a clear picture of true user engagement and retention, with proactive alerts when there are important changes. Combining Answers with our existing crash reporting tool and Beta by Crashlytics, you can immediately fix the critical bugs and rapidly test your new builds.

If you are already using Crashlytics and want to access Answers, login here and look for the new Answers icon on the left sidebar of your dashboard!

Fine-tuned Product Enhancements

In a day of overflowing emails, we’ve heard that sometimes beta testers lose their invites in their inboxes. We’ve added the ability for you to re-send your invitations to testers directly from your web dashboard, so you can be confident that you’ll reach every tester. We also dramatically improved the speed and performance of your web dashboard -- everything from page load to tester search. Now, you’ll have an even smoother experience using Beta by Crashlytics.

For those of you who prefer the command line over your web dashboard, we’ve enhanced our build server support to give you more flexibility. Now, you can add testers and publish release notes right in the command line. To gear up for more new features for Beta in the coming months, we’ve also enhanced the performance and stability of our backend.

Here’s our internal changelog:

General

  • iOS SDK
    • Fixed an intermittent memory leak.

Beta by Crashlytics

  • Mac App
    • Added the ability to add testers and release notes to Beta builds directly from the command line.
  • Ant Support
    • Added the ability to add testers and release notes to Beta builds directly from the command line.
  • Maven Support
    • Added the ability to add testers and release notes to Beta builds directly from the command line.
  • Gradle Support
    • Added the ability to add testers and release notes to Beta builds directly from the command line.
  • Web
    • Shipped the ability to re-send invitations to testers directly from the dashboard.
    • Improved the speed and performance for page load and tester search.

Answers by Crashlytics

  • iOS SDK
    • Integrated Answers by Crashlytics.
    • Improved event collection speed by intelligently and quickly sending data at low impact times to optimize and reduce traffic on your app.
  • Android SDK
    • Integrated Answers by Crashlytics.
    • Improved event collection speed by intelligently and quickly sending data at low impact times to optimize and reduce traffic on your app.
  • Web
    • Implemented live tracking of active users with a real-time, auto-updating chart that displays the data stream.
    • Shipped a dynamic dashboard that summarizes the key metrics and highlights significant shifts.
    • Deployed engine to track Daily Active Users and their breakdown by device and OS.
    • Deployed engine to calculate Daily New Users and the ratio of New Users over Active Users.
    • Deployed engine to calculate Monthly Active Users, DAU/MAU ratio, and Retention metrics with breakdown between 1-day, 7-day and 30-day bases.
    • Deployed engine to track Top Builds and key metrics for each of those builds including Daily Users, Average Session Length and Percentage of Crash-free Users.
    • Deployed engine to track Percentage of Crash-free Users and Percentage of Crash-free Sessions.
    • Integrated crash reporting to identify top issues by date, number of occurrences and impact.
    • Deployed engine to calculate User Sessions and Average Sessions per User.
    • Deployed engine to calculate Median Session Length and Time in App per User.
    • Shipped user behavior analytics engine to determine cyclicality and truly abnormal patterns.
    • Implemented in-chart alerts on note-worthy changes for all key metrics.

Infrastructure

  • Enhanced our backend to improve performance and stability for future feature development.

And Now, The Party Photos...

Every year, top mobile developers convene in San Francisco for WWDC and Google I/O, and as always, we want to be part of the fun. That’s why this year we hosted not one, but two parties, for iOS and Android developers.

You can guess from the line around the corner that the place was packed and the crowd was buzzing. It was great to meet and hang out with awesome developers from Apple, Google, Square, Path, Pandora, Pinterest and many more of the top mobile app companies.

Since we can’t travel back in time, here are some great photos to relive the memories.

If you didn’t get the chance to be there, experience the night here.

Launching Answers by Crashlytics

Today, we’re excited to unveil our latest project: Answers by Crashlytics. Finally, mobile analytics you don't need to analyze.

When we first launched Crashlytics more than two years ago, we were focused solely on solving the problem of mobile crash reporting. Since then, we’ve seen a need for powerful tools across other areas of app development — and we knew that we could apply the same design principles to meet the many challenges faced by today’s mobile app developers. With Answers by Crashlytics, along with our award-winning crash reporting tool and Beta by Crashlytics, developers now have access to a powerful, lightweight suite of products to help them not only build, but also grow great apps.

It’s been an honor to work with many of the top iOS and Android mobile teams as we have crafted Answers, and we’ve received incredible feedback:

We have Answers by Crashlytics displayed on two of our big TVs (one for iOS and one for Android) so the entire team can view the live updates of our app’s key metrics -- everyone loves it!

Lars Vedo, Mobile Product Manager,


Zero Steps

Terms like ‘bloated’, ‘bulky’, and ‘unreliable’ should never describe any developer tool. We know how hard it can be to gather real-time data, gain actionable insights about user behavior, and iterate quickly to optimize your app. Don’t worry — this is what we do.

Answers streamlines the process of revealing the key drivers of your app’s growth. With just one click, and no extra code changes, you’ll have the power to understand your app’s key usage and retention metrics. We intelligently and quickly send data at low impact times to optimize and reduce traffic on your app. Built into our existing Crashlytics SDK, Answers gives you instant visibility and a constant pulse on your app’s key metrics. And it’s free.

A Dashboard That Makes Sense

Your time is precious. We don’t want to bog you down with data overload. Answers streamlines your day with a UI that calls attention only to your most critical app usage metrics. With full visibility into your growth and engagement indicators, you can immediately understand the current state of your app and intelligently decide where to invest your time.

See a spike in activity? We’ll tell you why. No more guessing if an increase in daily actives is a result of new users or your existing users becoming more active. We’ll connect the dots for you.

And if you’re anticipating increases in usage related to a major event, you can see at a glance how many users are engaging with your app at this very moment. Bring the popcorn and display this data for your team to watch the action live.

No Analysis Required

Once enabled, Answers by Crashlytics intelligently analyzes and learns your app’s behavior and begins delivering live data within minutes. We know you’re busy, and we’ve built Answers with that in mind. You no longer need to don a lab coat and pull out a calculator to understand what’s going on. We look at the long-term trend and understand that there are certain metrics that are cyclical, so we’ll proactively alert you when a pattern is truly abnormal.

You’re constantly pushing out new features and bug fixes, so you’ll want to understand how your top builds compare and how users are engaging with your latest build. View build adoption over time to see the stability of each build with a breakdown of session length and crash-free users per build.

All About Growth

We know that retention is an important metric for understanding growth — that a large increase in new users doesn’t always translate to a long-term increase in your monthly actives. At a glance, monitor what percentage of your new users are coming back within a day, week, or month of installing your app for a clear picture of true user retention.

Sometimes, simply knowing usage numbers isn’t enough to understand overall performance. Answers dives deeper, showing you the total number of user sessions and the average number of sessions per user. For more granularity, we include the median session length, along with the amount of time per day the average user spends in your app. What better way to know that your users are having an awesome experience than to see them spending more time in your app?

Finally, app stability is crucial to ensuring your users have a great experience. Know how many of your users are having crash-free days and crash-free sessions and instantly see the top issues related to your app’s stability. Since Answers is built into the same SDK that powers your crash reporting, you can immediately dive into the issues that have the greatest impact and start fixing bugs.

Experience the Power

This is just the beginning. Our engineers are already working to take Answers to the next level and we have a lot planned. As always, send us your thoughts at support@crashlytics.com or find us on Twitter @Crashlytics. We’d love to hear what you think we should tackle next.

If you already have a Crashlytics account, you’ll soon see the new Answers tab on your dashboard. Otherwise, sign up here to get started with Crashlytics.

Don’t just take our word for it:

Answers by Crashlytics is the first thing I check every day. Its breakdown of crash-free users and crash-free sessions are the fundamental metrics we use to measure the stability of our app. I can't imagine shipping an app without it.

Ryan Johnson, VP of Mobile Engineering,


Answers by Crashlytics is exactly what we've been looking for! We just launched a new version and it was amazing to immediately compare it's stability to our previous versions.

Philip Connaughton, Software Engineer,

 

Highlights from Twitterverse:

Crashlytics June Update

june_update_header.png

In May, we officially released Beta by Crashlytics, shipped tons of crash reporting upgrades and announced our most recent Labs project: Crashlytics for OS X. While the World Cup fever catches on and excitement looms around every corner of our office, we still spared no time and hunkered down to keep shipping new upgrades for you -- even if that means missing a game or two!

More Options, More Powerful Beta

Ever since we started building Beta by Crashlytics, our mission has been to deliver a single, cross-platform toolset that gives you a completely streamlined experience for distributing apps to your testers. To give you even more flexibility in managing your testers, we’ve built out the ability for you to grant or revoke a tester’s access right within our already intuitive, easy-to-use web dashboard.

For those of you building on iOS, we improved the UI of the distribution tab within our Mac app, making it easier to manage your distributions. We also enhanced the reliability of our upload functionality to make sending builds to your testers an absolute breeze. For those building on Android, we added a new file selector for APKs within our IDE plugins -- so you can select and manually upload your APKs in case those files are playing hide-and-seek. :)

Supporting the Latest & Greatest

While we’ve been heads down on Beta by Crashlytics, we also found the time to give our crash reporting solution another boost. We added support for version 0.11 of the Android Gradle plugin just hours after it was released, which in turn allowed us to support the latest version of Android Studio (0.6.0). Since many of you have already upgraded to the latest Android Studio, we took a proactive approach to adding this new support to prevent any upgrading issues!

Never Miss a Crash

For crash reporting on iOS, we’ve added the capability for you to manually upload your dSYM files. Now you can be sure that you won't ever miss crashes occurring in some edge cases where your dSYM files couldn’t be detected by our system. You can sit back, relax and watch the detailed crash reports roll in. While at it, we also improved the stability for your users who are running your app on iOS 8 with Crashlytics installed.

Brand New Integrations

Ever since we announced our open-sourced integrations a year ago, we are very thankful to all those developers who have built on top of our foundation and contributed their integrations. We just announced our brand new integrations with some of the most popular project management and collaboration tools. Now you can manage your projects with less effort and have an even easier time working with your team to fix crashes.

Celebrating with Developers

For two years running, we’ve welcomed the mobile developer community to SF with our WWDC Kick-off Party. This year, we hosted our third annual WWDC party and, for the first time ever, brought our memorable event to the growing Android community with our party at Google I/O. The house was packed for both events, and once again we had a great time celebrating with the world’s top mobile app developers and seeing the amazing apps you’re all building. We’ll be sharing photos soon -- stay tuned!

Here’s our internal changelog:

General

  • Android IDE Plugins
    • Added support for Gradle plugin version 0.11 in order to support the latest version of Android Studio (0.6.0).
    • Web
  • Shipped ability to upload dSYM files manually.

Beta by Crashlytics

  • iOS SDK
    • Improved stability for users running iOS 8 encountered rare crashes in apps with Crashlytics included.
    • Solved issue that created deadlock for testers running an app distributed through Beta by Crashlytics on iOS 6.
  • Mac App
    • Improved plugin UI of the distribution tab.
    • Enhanced upload reliability when sending builds to testers.
  • IntelliJ
    • Enhanced drag-and-drop support when distributing your APKs.
    • Added a new file selector in case your APKs are playing hide-and-seek.
    • Improved exception handling in the command line build tools.
  • Eclipse
    • Enhanced drag-and-drop support when distributing your APKs.
    • Added a new file selector in case your APKs are playing hide-and-seek.
    • Improved exception handling in the command line build tools.
  • Android Studio
    • Enhanced drag-and-drop support when distributing your APKs.
    • Added a new file selector in case your APKs are playing hide-and-seek.
    • Improved exception handling in the command line build tools.
  • Web
    • Shipped ability to revoke a tester’s access within the web dashboard.

Announcing Brand New Integrations

  integrations

Just one year ago, we announced our open-sourced integrations, inviting the developer community to build on our existing infrastructure. Since then, we’ve had many developers build and submit integrations that are used today by thousands of other developers! We’ve loved seeing the community support and are excited to announce three new integrations to help you strengthen team collaboration and manage your projects.

Trello

Since you’re constantly multitasking, we know you're relying on Red Bull and to-do list tools like Trello to help you manage and prioritize your workload. Our integration with Trello, built by Andrey Chernih, allows you to turn your crashes into Trello cards. Add your crash cards to any of your Trello boards so you can see what crashes need your attention and collaborate with your team to understand who is working on each crash.

Bitbucket

Built by Mufri, our Bitbucket integration turns your crashes into Bitbucket issues that are added to your preferred repository. We know your time is valuable and with this integration you can seamlessly jump from your Bitbucket repository directly into your crashes. With this seamless integration, you now have more time for the fun stuff, like coding the next hottest app!

Hall

We understand the importance in team collaboration and being in constant communication to understand who’s working on what. Andy McSherry built the Crashlytics integration with messaging service Hall. With this integration, messages are posted into your preferred group so you can quickly and easily communicate with your team about your crashes. No more waiting by the water cooler to track down teammates for status updates, we've got you covered. ;-)

Interested in adding your own integration? We’d love to work with you and see what you can come up with. See our existing integrations and get started.

Crashlytics + Twitter Invite You to Our I/O Party

Why do it once when you can do it twice? After years of being the hottest party at WWDC, we’re excited to throw our very firstCrashlytics + Twitter party at Google I/O. Come hang out with the top Android mobile developers as we celebrate the awesome apps you’re building. We’ve been humbled by the support for Crashlytics for Android and Beta by Crashlytics, and are excited to share a preview of what’s to come.

Read More