Hey mobile game developers, does this sound familiar?

  • Users complain about a bug that you struggle to reproduce.
  • Your crash reporter does not catch it.
  • Your logging does not provide visibility into it.
  • You release multiple “fixes” that miss the mark.
  • You yearn for the roadmap you could be working on if not for endless, frustrating bug hunts.

At Embrace, we know how you feel. We’re the only data driven toolset built specifically for the needs of the modern mobile team.

We know that making mobile games is an incredibly difficult endeavor. You’re battling endless combinations of variables like versions, devices, regions, and networking conditions, to name a few.

The problem you’re facing is that you are relying on tooling that simply isn’t built for the challenge.

That’s why Embrace is here to help. We now officially support Unity mobile games, and we’re happy to empower mobile game teams to identify, prioritize, and solve user-impacting issues faster than ever before.

In this post, we’ll cover:

  • The problem with current tooling for mobile games.
  • How Embrace is the solution you’ve been waiting for.

The problem with current tooling for mobile games

It’s no secret that mobile games are incredibly complex. That’s why building them is challenging, creative, and ultimately rewarding. In addition, in mobile games delivering a great user experience is the sole purpose of the app. People are not playing your game as a means to accomplish something else.

For e-commerce apps, you want to deliver a good user experience so people can efficiently find and buy the products they want.

For mobile games, you want people to enjoy playing the game so they can spend more time playing the game.

Anything that reduces a player’s enjoyment within your game is a reason they might consider searching for a better option to spend their time and money on.

So what tools do mobile game teams traditionally rely on for monitoring performance and stability?

  • Crash reporter
  • Logging
  • Possibly a homegrown solution to fill in any known gaps

When a user submits a bug report, if it’s a crash, the developers check the stack trace and see if they can debug the issue. If not, they’ll start running queries to check the logs. If both of those options fail to yield insights, developers try stitching together data from different tools. At a certain point, developers must manually reproduce the issue to discover the conditions when it occurs and to properly test solutions.

Frequently, developers will not be able to manually reproduce an issue, or if they can, it comes at a high price — time. Time that could be spent building features and expanding the game.

The problem is that this method of debugging is inefficient. Your team is not attacking bugs from a high vantage point. By building up visibility with manual steps across multiple toolsets, your team is forced into a position of guessing at solutions and timelines.

Debugging should be a streamlined process with the engineering team having access to the complete picture so they immediately know what is wrong. The team should know the state of the device, user, and game for every moment of every user session in the game.

The device:

  • The characteristics of the device (e.g. the OS, app version, and region)
  • The current state of the device (e.g. memory, CPU, and battery usage)

The user:

  • The actions a user takes in the game (e.g. taps, button presses)

The game:

  • The state where the issue occurred (e.g. which state machine was last entered, from where, and with what data)
  • The user’s journey throughout the game (e.g. complete recreation of every game state encountered)
  • The technical events throughout the user session (e.g. the screens/views/activities, network calls, webviews)

When a user submits a bug report, the team should be able to look up the actual game session and immediately reproduce what happened.

This streamlined process will allow the team to instantly know what the issue is, how many users were affected, and whether it is worth fixing — resulting in time saved during the debugging process.

Embrace is the solution you’ve been waiting for

Embrace is built to enable mobile teams to spend as little time as possible identifying, prioritizing, and solving issues within their apps. This empowers you to dedicate more time and resources on growing the product. The end result is you are able to build and release features faster, discover problems sooner, and fix them before they affect a large number of users.

The reason we are able to accomplish this is that we operate at the user session-level as opposed to the event-level. Embrace does this through collecting the technical events and user actions of every user session and recreating the entire user experience on demand.

Instead of querying a database for a list of logs that you then have to grep through, Embrace shows the order and duration of every event within the user session. For logs, you would see:

  • The screens where they were sent
  • The game state when they were sent
  • The order they were sent in relation to other events like network calls
  • The user journey that triggered them

You no longer have to scour through logs to understand the context that led to them. With Embrace, you get the context delivered directly to you.

At a high level, you can think about Embrace as offering three key benefits:

Proactive alerting

The faster you can identify an issue, the faster you can address it. With Embrace, you get notified immediately without having to wait for support tickets or bad app store reviews.

With proactive alerting, you’ll get notified when things go wrong that are outside your control, like first-seen errors and third-party network errors. In addition, you can set broad thresholds so you’re covered when any first-party call exceeds a predefined limit.

With targeted alerting, you can set alerts for any metric (not just crashes and logs) and any threshold. That way, you decide exactly when issues demand your attention. By configuring recovery levels, you eliminate duplicate alerts so you’re only notified once for the same spike.

Now, your team can get ahead of any issues that pop up so they’re never in the position of doing damage control. Your team can prioritize and debug problems before they get out of hand.

Comprehensive session data

When we say comprehensive session data, we mean way more than logs. Embrace collects all the technical events and user actions within every user session. That way, your team can go from any bug report to reproducing the exact session it occurred on.

Your team no longer has to log every event and then pore through logs to understand what happened. You get to replace a manual and time-consuming process with one that provides visibility immediately.

Our session replay is a time-based visualization of the entire user experience. For any moment within the session, you get to know exactly what happened and under what conditions. And because we collect 100% of user sessions, your team can troubleshoot any user-impacting issue.

Before working on a fix, your team can easily understand the impact of any issue so they can efficiently prioritize and allocate engineering resources. After all, some problems are simply not worth addressing. Thus, your team doesn’t waste time chasing down the bugs that don’t matter.

A predictable workflow

Because Embrace is the single source of truth for your mobile game, we enable a predictable workflow for issue identification, prioritization, and resolution. You don’t need to stitch together data from multiple tools. Your debugging doesn’t need to span multiple release cycles just so you can add enough logs to understand what happened.

With comprehensive data from every session, you can discover issues that elude traditional monitoring solutions. You can surface problems that occur at specific intersections of device state and game state. You can see which slow network calls lead to freezes and timeouts. You can understand exactly when users force quit your game in frustration.

You can find every reason you’re not delivering a stellar user experience. And you can do it before it affects a significant number of users.

Summing it all up

With Embrace, your team can spend more time building games and less time fixing them.

Want to learn how Embrace can help improve the performance and stability of your Unity mobile games? Request a demo now.