Embrace: Modern mobile observability built on OpenTelemetry

Embrace is an observability tool, combining open-source SDKs with an analysis dashboard  that, together, enable the entire engineering team to understand the full picture of what is disrupting mobile user experiences, such as:

• Are users abandoning apps during startup because of slow network calls?
• Are third-party SDKs causing issues like crashes and Application Not Responding (ANR) errors?
• Are key user actions like login, add to cart, or checkout running slower than expected or outright failing?
• Are users on certain devices experiencing memory issues from loading too many images and videos?
• Are users experiencing issues when trying to complete tasks across multiple sessions?

Mobile teams integrate the Embrace OpenTelemetry-compliant SDK – supported platforms include iOS, Android, React Native, Unity, and Flutter – and then can access high-fidelity data from every user session in the Embrace analytics and observability dashboard. Engineering teams can then use this data for issue discovery and resolution, optimizing app performance, tracking internal metrics, and powering SLOs by integrating with existing observability solutions.

Let’s focus on three key components of Embrace that highlight the value of this modern approach to mobile observability:

• User-focused observability
• Built on OpenTelemetry
• Connecting mobile teams and DevOps/SREs

In backend systems, you frequently focus on measuring the latency and failure rate of services. However, this approach doesn’t show the full picture of impact on end users. For example:

• Your backend service has a slowdown, but user behavior does not change.
• Your backend service has a spike in failures, but it’s only affecting a small group of users on devices that you’re no longer supporting.
• Your backend service has a spike in failures, but users are able to immediately retry and successfully complete purchases.

The best way to prioritize engineering resources is by understanding the user and business impact of issues. And the only way to do that is by measuring from the perspective of your users.

Embrace collects every session for every user, including when the app is backgrounded, and visualizes them as timelines, providing a complete picture of the end-user experience. If you receive a user complaint, you can look up the user and review everything that happened while they were using your app in order to track down what went wrong.

In the above visual, we’re filtering for crashes from the Sessions page, and we can see every session where a user experienced a  crash. We can also filter by any combination of issue, device, OS, app state, log, and span variables.

When we want to dive into an individual session, we can load the User Timeline, which shows the full technical and behavioral details. We can see where slow and failing network calls, key user flows, breadcrumbs, device state changes, and more happen as a user navigates the app. With this context, mobile engineers can easily troubleshoot key mobile app issues, like crashes, errors, ANRs, out of memory crashes (OOMs), and user terminations.

Logs are one of the core signals in observability, and Embrace provides powerful ways to leverage them. You can enrich them with as much context as you want, and then easily use free-text search and advanced filtering to quickly identify the events you’re interested in. You can also review your raw logs, or use the aggregated view to see big-picture trends before diving into the individual sessions for debugging.

You can instrument spans and traces to monitor key user actions in your mobile app, like login, search, and checkout. Embrace also automatically includes all concurrent network requests as spans within your performance traces. This enhanced context helps engineers clearly understand the temporal relationship between network activity and other events, leading to quicker insights and faster issue resolution.

We’re the first mobile-only vendor in the Cloud Native Computing Foundation (CNCF), which oversees the OpenTelemetry project, and our SDKs are open source and built on OpenTelemetry. That means anyone can integrate the Embrace SDKs and send mobile telemetry to any OTel-compatible backend.

Want to try it for yourself? Check out our iOS and Android OpenTelemetry exporter walkthroughs where you’ll learn how to send spans directly from the Embrace SDK to Zipkin.

We’ve also updated our data models to fit OpenTelemetry wherever possible, and for instances where mobile-specific issues prevent this – such as dealing with in-progress spans that cross lifecycle boundaries – we’re collaborating with the community to help move the standards forward as well as contribute our solutions back into the OTel standards.

If you’d like to learn more about the challenges in modeling mobile telemetry in OpenTelemetry, check out our OTel Community Day talk.

In order to prioritize engineering resources effectively, your org needs to be able to quickly isolate an issue and assign a fix, regardless of where it’s originating across your tech stack. When it comes to mobile apps, however, the problem has historically been that frontend and backend teams have struggled to collaborate, due to data silos and a lack of a shared observability language. This often leads to a much lengthier, more difficult issue resolution process that ends up impacting the end user. Here are a few examples where this disconnect causes significant toil:

• A backend service that powers login has an increase in latency, but the DevOps team doesn’t know the user impact. The mobile team can’t look up whether users are abandoning during login because their tool only measures crashes and errors.
• User complaints increase about search functionality not working properly. The mobile team suspects something’s wrong with the search service, but the DevOps team says everything is fine on their end. The mobile team does not have visibility to resolve the issue.

With user-focused observability like Embrace provides, the mobile team could look up the user abandonment for the login functionality, and they could also tell which searches were processed successfully for users. But what about the visibility gap between the frontend and backend?

Wouldn’t it be much better if mobile signals could be forwarded to the DevOps team, so that they could always see the user impact data alongside the service health data?

Even more powerful, what if the DevOps team could connect directly from a failure in the backend to the affected user experience in the mobile app?

With Embrace, you can do both!

Sending mobile metrics to the backend

Embrace can forward custom metrics to many popular observability tools, including Grafana, Chronosphere, Honeycomb, New Relic, and more. You can create metrics from any number of sources, including crashes, logs, spans, sessions, and networking. You can also filter them by many different dimensions, so that you’re measuring exactly what you want. Within Embrace, you’re just a few clicks away from forwarding any metric.

The following image highlights sending Embrace custom metrics to Grafana.

Embrace has a feature called Network Span Forwarding that works by intercepting a network request on the client side and then injecting a trace parent into it. Your backend monitoring will capture the request with its unique trace ID, and the same trace ID will be tagged to the network request in the corresponding user session in Embrace. That way, when investigating an issue, both the mobile team and the backend team can look up the same network request to understand what went wrong.

Embrace also includes a backlink to the individual session where the network request originated, so you can go from your backend observability solution directly to the full details leading up to the network request.

While observability tooling and practices have improved significantly in recent years, the lion’s share of attention was on backend systems. Companies now realize just how crucial it is to connect the health of their backend systems to the performance and user outcomes within their mobile apps.

Embrace is here to help modernize observability practices for mobile. Our user-focused approach to observability eliminates guesswork by collecting complete user experience datasets. Our investment in OpenTelemetry is improving the open standards of data collection in mobile, so that tools and workflows can have better interoperability. And our innovation in connecting mobile and backend datasets is creating amazing collaboration opportunities between previously siloed teams.

To learn more about how Embrace can help you deliver better mobile user experiences, request a demo today.