Link Fabric events to Firebase: do more with your data

By Shobhit Chugh, Product Manager

Fabric-events-Firebase-integration-blog-banner.png

Most app teams collect data about their users to better serve them. But having data alone doesn’t automatically lead to insight. To be valuable, it needs to be processed, analyzed, and distilled into information that informs strategy and decision-making.

Answers, the analytics engine that powers Fabric, helps you understand your users by tracking events. Events are in-app actions (like login, social share, or purchase) that reveal how people interact with your app. This information is vital to learning how engaged users are, what actions they take most (and least), and how their behavior changes over time.

Today, we’re excited to give you more freedom to explore and examine your event data through a new Fabric events + Firebase integration. Now, all Fabric customers can unlock highly-requested analytics features in Firebase by creating and linking their Firebase account.
 

Fabric & Firebase are stronger together

Firebase is Google’s mobile platform that helps you build and grow high-quality apps without managing infrastructure. As we stated at Google I/O 2017, Fabric joined forces with Firebase because our two platforms are stronger together and offer complementary tools.

For instance, Fabric has always adhered to an opinionated philosophy and presented critical app data in a digestible way. However, we’ve heard from many of you that you want more flexibility. By teaming up with Firebase, we can build on the freedom and power that Firebase gives developers to do deeper analysis without compromising our opinionated approach.

This new Fabric events + Firebase integration allows you to use existing Fabric events with Firebase’s advanced marketing and analytics features to get more flexibility to organize, interpret, and act on your event data.
 

Build custom audiences to get deeper user insight

Although Fabric automatically groups your users into activity segments based on sessions, it’s interesting to group users by their behaviors too. With the Fabric events + Firebase integration, you can create custom audiences (a.k.a. user segments) in Firebase using your Fabric events and event attributes.

For example, you could create a “power users” audience to group people who have completed a key in-app action many times. For gaming apps, this group could consist of users who have who have completed at least 10 levels and made an in-app purchase.

With custom audiences, you can slice and dice your user data by in-app behavior to better understand engagement.


View historical data to unearth long-term trends

Fabric focuses on realtime events for the past 30 days, while Firebase gives you long-term visibility. Once you integrate Fabric events with Firebase, all event data that is collected from that point on will be accessible in Firebase. This extended view into your user behavior will help you uncover persisting trends.


Combine different data sources into one view with custom analysis

The Fabric events + Firebase integration also gives you access to your raw data (something you’ve wanted for a long time!) so you can perform more sophisticated and targeted analysis. Specifically, when you complete the integration and link your Firebase project to BigQuery, your Fabric events will flow into a BigQuery dataset. BigQuery is a petabyte-scale analytics data warehouse that you can use to run SQL-like queries over vast amounts of data.

For example, if you track user events in multiple places (such as Fabric, Google Analytics 360, custom analytics collected by a mobile backend service), you can import and aggregate them from all of these sources in BigQuery to see a complete picture. From there, you can also use data visualization tools, like Data Studio, to turn this aggregated, raw data into informative reports that are easy to read, share, and customize.

In addition, this Fabric events + Firebase integration gives you the ability to manage permissions on projects and datasets so you have control over who is able to share, view, and retrieve your data.

BigQuery


Turning data into action

The Fabric events + Firebase integration gives you enhanced flexibility and control over your data. But what do you do after you’ve dissected, analyzed, and extracted meaning from it? How can you turn these insights into action?

By using these insights to trigger smart marketing campaigns.

Firebase provides tools like Cloud Messaging and Remote Config that can send messages and alter your app in response to Fabric events. For example, ecommerce apps can send a push notification with a discount code to all users who have made an in-app purchase to encourage them to buy something else. Or, ecommerce apps can enable “one-click checkout” for this group.


Tap into the power of Firebase in 3 steps

You can start the integration process right from your dashboard. Simply click the Firebase icon in your Fabric dashboard in the left navigation bar.

Firebase in Fabric nav

The integration only takes a few minutes and can be done by a developer in three simple steps:

  1. Link apps*
    *If you don’t have an existing Firebase account, don’t worry. We’ll walk you through setting one up.
  2. Upgrade the SDKs
  3. Ship your app

For more details on how to implement this, check out our technical docs for iOS and Android. This integration can be enabled with minimal code changes and you won’t need to re-instrument your events.

Once you have completed the set up, your Fabric events (from that point on) will automatically flow to Firebase so you can build audiences, view historical trends, run custom analysis, and trigger personalized marketing campaigns. You’ll also continue to have access to this data in Fabric.

We’re pumped to unveil this integration, as it represents a big step towards our goal of bringing the best of Fabric and Firebase together so you have one place to build, understand, and grow your app. We can’t wait to hear what you think!

Fabric + Firebase: Now stronger together

by Rich Paret, GM, Fabric

DevSummit-Banner-blog.png

Since joining forces with Firebase early this year, we’ve been working closely with our new teammates on the same mission: helping you build apps, understand your users, and grow your business. We want to combine our unique strengths to give you access to better tools and infrastructure, all while continuing to upgrade Fabric. That’s why in May at Google I/O, we upgraded Digits to Firebase phone authentication and launched more features for Fabric.

After I/O, the Fabric + Firebase team have been working hard to integrate our two platforms - with the goal of bringing you the best of both in a thoughtful way. Today, we have some more news to share with you. Check it out:

Upgraded Fabric

As we work on integrating Fabric and Firebase, we're still continuing to improve Fabric. We started by officially releasing crash insights out of beta, so you can triage and resolve issues faster than ever before. Additionally, we launched fastlane precheck to help you avoid unnecessary delays from the iOS app store. We also built a new tool called snapshot in fastlane, which automagically generates app screenshots for all of your devices at the same time.

Crashlytics is now available on Firebase

Eliminating crashes is crucial to improving user experience. That’s why today at the Firebase Dev Summit, we unveiled a beta version of Crashlytics in Firebase to give Firebase developers access to our market-leading crash reporter. Firebase Crashlytics has the core crash reporting features of Fabric’s Crashlytics, but it also includes integrations with other Firebase tools. For example, Firebase customers can use Crashlytics to power custom workflows and get alerts about stability issues that impact a critical app flow (i.e. a payment flow).

Right now, Firebase Crashlytics is still in beta, so there’s no need to switch over if you’re happy with Crashlytics on Fabric. We plan to release more integrations over the coming months and make Crashlytics as awesome on Firebase as it is on Fabric in the future - stay tuned :)

Better together

Over the past months, we’ve been encouraging you to use both Fabric and Firebase since the two platforms are stronger together. Some of you have already started using Crashlytics with Firebase tools, which has been incredibly exciting to see. For instance, Doodle, an app that brings people together, used Crashlytics with Firebase Remote Config to redesign their app and improve engagement by 42%. Learn more about how they did it here:



Additionally, we have started to incorporate what you love about the Fabric dashboard into Firebase. Today, we helped launch a new dashboard experience on Firebase, which begins with a mission control and a new left-hand navigation bar similar to Fabric:

We also helped release a new analytics dashboard that is organized around the questions and tasks that you tackle on a day-to-day basis - with similar traits to Fabric’s dashboard we launched early this year. And much like Fabric’s “Latest Release” dashboard, Firebase now includes a similar section under their analytics as well as real-time data on crashes and active users.

If you’re already using Firebase, these updates will be rolling out over the next few weeks (you can get early access here). We hope these updates are helpful to you, and we’re actively working on giving you one place to build, understand, and grow your app in the future!

Celebrating with the community

We love celebrating with our passionate community. Kristen Johnson (Product Manager, Fabric) shared the new Firebase Crashlytics with many of you during today's Firebase Dev Summit. We also hosted these technical sessions:

  • “Automating your app's release process using fastlane” - by Felix Krause (Creator of fastlane) and Josh Liebowitz (Fabric Engineer)
  • “Building high-quality apps with Crashlytics and Firebase Performance” - by Jason St. Pierre (Product Manager, Fabric)

We hope you enjoyed our conference and found it helpful. If you couldn't make the event this time, check out the recordings for our keynote and technical talks!

Onwards,

-


Introducing Cloud Firestore: our new document database for apps

Originally posted by Alex Dufetel on the Firebase Blog

firebase_firestore-horiz-dark-2.png

Today we’re excited to launch Cloud Firestore, a fully-managed NoSQL document database for mobile and web app development. It's designed to easily store and sync app data at global scale, and it's now available in beta.

Key features of Cloud Firestore include:

  • Documents and collections with powerful querying

  • iOS, Android, and Web SDKs with offline data access

  • Real-time data synchronization

  • Automatic, multi-region data replication with strong consistency

  • Node, Python, Go, and Java server SDKs

And of course, we've aimed for the simplicity and ease-of-use that is always top priority for Firebase, while still making sure that Cloud Firestore can scale to power even the largest apps.

Optimized for app development

Managing app data is still hard; you have to scale servers, handle intermittent connectivity, and deliver data with low latency.

We’ve optimized Cloud Firestore for app development, so you can focus on delivering value to your users and shipping better apps, faster. Cloud Firestore:

  • Synchronizes data between devices in real-time. Our Android, iOS, and Javascript SDKs sync your app data almost instantly. This makes it incredibly easy to build reactive apps, automatically sync data across devices, and build powerful collaborative features -- and if you don’t need real-time sync, one-time reads are a first-class feature.

  • Uses collections and documents to structure and query data. This data model is familiar and intuitive for many developers. It also allows for expressive queries. Queries scale with the size of your result set, not the size of your data set, so you'll get the same performance fetching 1 result from a set of 100, or 100,000,000.

  • Enables offline data access via a powerful, on-device database. This local database means your app will function smoothly, even when your users lose connectivity. This offline mode is available on Web, iOS and Android.

  • Enables serverless development. Cloud Firestore’s client-side SDKs take care of the complex authentication and networking code you’d normally need to write yourself. Then, on the backend, we provide a powerful set of security rules so you can control access to your data. Security rules let you control which users can access which documents, and let you apply complex validation logic to your data as well. Combined, these features allow your mobile app to connect directly to your database.

  • Integrates with the rest of the Firebase platform. You can easily configure Cloud Functions to run custom code whenever data is written, and our SDKs automatically integrate with Firebase Authentication, to help you get started quickly.

Putting the ‘Cloud’ in Cloud Firestore

As you may have guessed from the name, Cloud Firestore was built in close collaboration with the Google Cloud Platform team.

This means it's a fully managed product, built from the ground up to automatically scale. Cloud Firestore is a multi-region replicated database that ensures once data is committed, it's durable even in the face of unexpected disasters. Not only that, but despite being a distributed database, it's also strongly consistent, removing tricky edge cases to make building apps easier regardless of scale.

It also means that delivering a great server-side experience for backend developers is a top priority. We're launching SDKs for Java, Go, Python, and Node.js today, with more languages coming in the future.

Get started!

Cloud Firestore enters public beta starting today. If you're comfortable using a beta product you should give it a spin on your next project. We can’t wait to see what you build and hear what you think of Cloud Firestore!

7 tips for getting the most out of Crashlytics

By Jason St. Pierre, Product Manager

Crashlytics tips

For many years, developers and app teams have relied on Crashlytics to improve their app stability. By now, you’re probably familiar with the main parts of the Crashlytics UI; perhaps you even glance at crash-free users, crash-free sessions, and the issues list multiple times a day (you wouldn’t be the only one!).

In this post, we want to share 7 pro-tips that will help you get even more value out of Crashlytics, which is now part of the new Fabric dashboard, so you can track, prioritize, and solve issues faster.


1. Speed up your troubleshooting by checking out crash insights

In July, we officially released crash insights out of beta. Crash insights helps you understand your crashes better by giving you more context and clarity on why those crashes occurred. When you see a green lightning bolt appear next to an issue in your issues list, click on it to see potential root causes and troubleshooting resources.


2. Mark resolved issues as “closed” to track regressions

Debugging and troubleshooting crashes is time-consuming, hard work. As developers ourselves, we understand the urge to sign-off and return to more exciting tasks (like building new app features) as soon you resolve a pesky issue - but don’t forget to mark this issue as “closed” in Crashlytics! When you formally close out an issue, you get enhanced visibility into that issue’s lifecycle through regression detection. Regression detection alerts you when a previously closed issue reoccurs in a new app version, which is a signal that something else may be awry and you should pay close attention to it.


3. Close and lock issues you want to ignore and declutter your issue list

As a general rule of thumb, you should close issues so you can monitor regression. However, you can also close and lock issues that you don’t want to be notified about because you’re unlikely to fix or prioritize them. These could be low-impact, obscure bugs or issues that are beyond your control because the problem isn’t in your code. To keep these issues out of view and declutter your Crashlytics charts, you can close and lock them. By taking advantage of this “ignore functionality," you can fine tune your stability page so only critical information that needs action bubbles up to the top.


4. Use wildcard builds as a shortcut for adding build versions manually

Sometimes, you may have multiple builds of the same version. These build versions start with the same number, but the tail end contains a unique identifier (such as 9.12 (123), 9.12 (124), 9.12 (125), etc). If you want to see crashes for all of these versions, don’t manually type them into the search bar. Instead, use a wildcard to group similar versions together much faster. You can do this by simply adding a star (aka. an asterisk) at the end of your version prefix (i.e. 9.12*). For example, if you use APK Splits on Android, a wildcard build will quickly show you crashes for the combined set of builds.


5. Pin your most important builds to keep them front and center

As a developer, you probably deploy a handful of builds each day. As a development team, that number can shoot up to tens or hundreds of builds. The speed and agility with which mobile teams ship is impressive and awesome. But you know what’s not awesome? Wasting time having to comb through your numerous builds to find the one (or two, or three, etc.) that matter the most. That’s why Crashlytics allows you to “pin” key builds so that they appear at the top of your builds list. Pinned builds allow you to find your most important builds faster and keep them front and center, for as long as you need. Plus, this feature makes it easier to collaborate with your teammates on fixing crashes because pinned builds will automatically appear at the top of their builds list too.


6. Pay attention to velocity alerts to stay informed about critical stability issues

Stability issues can pop up anytime - even when you’re away from your workstation. Crashlytics intelligently monitors your builds to check if one issue has caused a statistically significant number of crashes. If so, we’ll let you know if you need to ship a hot fix of your app via a velocity alert. Velocity alerts are proactive alerts that appear right in your crash reporting dashboard when an issue suddenly increases in severity or impact. We’ll send you an email too, but you should also install the Fabric mobile app, which will send you a push notification so you can stay in the loop even on the go. Keep an eye out for velocity alerts and you’ll never miss a critical crash, no matter where you are!


7. Use logs, keys, and non-fatals in the right scenarios

The Crashlytics SDK lets you instrument logs, keys, non-fatals, and custom events, which provide additional information and context on why a crash occurred and what happened leading up to it. However, logs, keys, non-fatals, and custom events are designed to track different things so let’s review the right way to use them.

Logs: You should instrument logs to gather important information about user activity before a crash. This could be user behavior (ex. user went to download screen, clicked on download button) to details about the user’s action (ex. image downloaded, image downloaded from). Basically, logs are breadcrumbs that show you what happened prior to a crash. When a crash occurs, we take the contents of the log and attach it to the crash to help you debug faster. Here are instructions for instrumenting logs for iOS, Android, and Unity apps.

Keys: Keys are key value pairs, which provide a snapshot of information at one point in time. Unlike logs, which record a timeline of activity, keys record the last known value and change over time. Since keys are overwritten, you should use keys for something that you would only want the last known value for. For example, use keys to track the last level a user completed, the last step a user completed in a wizard, what image the user looked at last, and what the last custom settings configuration was. Keys are also helpful in providing a summary or “roll-up” of information. For instance, if your log shows “login, retry, retry, retry” your key would show “retry count: 3.” To set up keys, follow these instructions for iOS, Android, and Unity apps.

Non-fatals: While Crashlytics captures crashes automatically, you can also record non-fatal events. Non-fatal events mean that your app is experiencing an error, but not actually crashing.

For example, a good scenario to log a non-fatal is if your app has deep links, but fails to navigate to them. A broken link isn’t something that will necessarily crash your app, but it’s something you’d want to track so you can fix the link. A bad scenario to log a non-fatal is if an image fails to load in your app due to a network failure because this isn’t actionable or specific.

You should set up non-fatal events for something you want the stack trace for so you can triage and troubleshoot the issue.

If you simply want to count the number of times something happens (and don’t need the stack trace), we’d recommend checking out custom events.

These 7 tips will help you get the most out of Crashlytics. If you have other pro-tips that have helped you improve your app stability with Crashlytics, tweet them at us! We can’t wait to learn more about how you use Crashlytics.
 

Faster automated screenshots: fastlane’s snapshot now supports multiple concurrent simulators

by David Ohayon, Software Engineer

fastlane-snapshot-header.png

Every mobile developer needs to take app screenshots in order to have their app listed on the app stores. Like a book cover, screenshots are crucial in depicting the best parts of your app and convincing potential users to download it.

Unfortunately, generating app screenshots is a huge pain because they take a ton of time, especially if your app supports different locales and languages. For example, if you need to take 5 screenshots for your app store listing - but your app supports 20 languages for 6 devices - you’ll manually have to take 600 screenshots (5 x 20 x 6)! It makes us shudder to think how many precious hours that would eat up.

fastlane’s snapshot tool automates the process of taking screenshots (in the background) so you can focus on building features users love. Today, we’re excited to share that snapshot now supports multiple, concurrent simulators for iOS apps in Xcode 9. Taking screenshots just got even faster because you can now generate screenshots for all of your devices at the same time!

Speeding up screenshots (even more!)

Before Xcode 9, only one simulator could be running at a time, which means that you had to run snapshot once for each device you wish to support. While snapshot automated the process of taking screenshots, we wanted to make things even easier.

The launch of Xcode 9 gave us another opportunity to improve snapshot. In Xcode 9, multiple UI tests can run simultaneously, so we added multiple simulator support to snapshot as well. Now, you can take screenshots for all specified devices with a single command, at the same time. This drastically shortens the time it takes to generate your screenshots.

Here's an example:

fastlane-snapshot-comparison.png

More exciting updates on the way

fastlane’s mission is to save you time by automating the cumbersome tasks of app deployment, even as mobile evolves. That’s why we’re fully committed to updating the fastlane toolset to take advantage of new releases and features - such as Xcode 9.

And since fastlane is open source, we’re so thankful that our community also helps us make fastlane better by building and using plugins. In fact, we now have more user-generated plugins available for you to try than native fastlane actions. We recently reorganized these plugins to make it easier to find the right plugins for your unique needs.

We always strive to anticipate your needs and build our tools to be ready for the future. To start using the new version of snapshot, simply update fastlane and run snapshot as you normally would. If you’re taking screenshots manually, check out our guide to start using snapshot (and enjoy the extra free time!). As always, we can’t wait to hear what you think!