Elevating the mobile logs game with more data, better user context, and OpenTelemetry

Traditional logging tools miss the mark for mobile engineers who need more detail and better, actionable data. With Embrace’s OpenTelemetry Logs in Context, engineers now get the full scope of logging resources they need to effectively troubleshoot their issues. 

Logs are often referred to as a developer’s best friend when it comes to troubleshooting. 

They’re incredibly flexible, simple to implement, and can provide critical context to understand and resolve issues. Existing logging solutions, however, are often designed for backend system engineering. When it comes to mobile app development, these solutions can quickly turn into a dumping ground of uncorrelated data. 

When trying to achieve truly modern observability, this lack of context makes logging data a lot less useful – especially when you consider its associated cost. 

With our latest logging feature, there’s a better way forward for mobile. Embrace’s OpenTelemetry Logs in Context gives mobile engineers the full scope of logging resources they need to effectively troubleshoot their issues. 

Using our OpenTelemetry-powered SDKs, engineering teams can now log messages up to 4,000 characters. What’s more, these log messages are fully contextualized within the user session and are fully searchable inside the Embrace UI. 

Plus, we’ve made it easier to take action when you find an anomaly across your log messages. Once you find a message worth investigating further, you can quickly isolate any user sessions that experienced the event to understand the full context behind it. 

Read on to learn more. 

The limitations of traditional logging tools

Like many facets of traditional observability, context-rich logging was slow to adapt for the mobile environment. Mobile teams have long been dealing with unhelpful “data dumps” and log indexes that only show them half the picture. With specialized tools like Embrace, this is quickly changing.

Log indexes miss the mark for mobile

One major pain point for mobile devs is the inadequacy of log indexes, something that hasn’t translated well from backend to mobile observability. 

Given the volume of data produced by backend logging, indexing makes sense to be able to group data, search through older records, and easily find historical patterns. The use case for mobile development is not the same. 

Rather than extensive historical indexes – which can complicate the troubleshooting process – mobile devs typically require quick, raw logs for real-time debugging. 

Another issue with log indexes is that, for the majority of solutions out there, they typically rely on sampling to limit the number of logs collected and indexed on a daily basis, usually for cost reasons. If you’re working on backend systems, this might be ok – the number of unique conditions and variables that need monitoring are limited. When it comes to mobile, however, limiting your logs via sampling rates runs the risk of reducing your visibility into the application’s health, often quite seriously. 

In mobile particularly, sampling is a huge limitation in that it prevents you from understanding the full scope of the problem. In so many words: you don’t know what you don’t know

And so, in an ideal world, developers have the freedom to collect and filter their logs as needed, without being limited by samples and indexes.

Context into the true user impact is missing

Perhaps the biggest disconnect between mobile-focused vs. backend observability tooling is the end user context. Understanding exactly how your users experience and navigate through your app is crucial to ensure they keep coming back. 

Logs can offer insight into this, but their value is limited when analyzed without the context of your end users’ overall activity and your software’s response. 

Unfortunately, most tools do not offer that level of insight, but rather provide a traditional list of logs that engineers can search through and filter.  With these types of tools, you have to rely on examining logs in isolation to other related events and behaviors across a user’s session, such as network calls, crashes, slow traces, taps, clicks, push notifications, etc. 

This doesn’t offer much context into how your end users are truly impacted by whatever activity you’re logging, nor does it provide real insight into how the many different variables and conditions of the mobile environment might be affecting each other to create unexpected issues.

Embrace’s new features make logs richer, more actionable data types for engineers

All of these limitations of traditional logging tools motivated us to create a better, more actionable solution that brings true end user context to mobile logs.

Attach large messages to your logs with no constraints on data type and format

You can now send logs with messages up to 4,000 characters. This means you’ll be able to capture every nuance of your app’s performance with comprehensive, detailed information attached to your logs. For example, you might need to attach the full state of your application/user to an error log, or you may want to attach the cookie of a specific request. This size gives you the flexibility to add any information you need.You can also send key/value properties along with your log entry, providing additional structured data alongside the main log message. 

This helps you make better, more informed decisions by attaching specific tags to your logs that allow you to identify certain users, devices, conditions etc. and easily isolate them for analysis.  

Lastly, you can also capture your log’s stack trace for error and warning logs.

Navigate through your logs and analyze your data efficiently with a new UI oriented around the problem

As part of this feature update, we’re also rolling out some changes to the Embrace dashboard UI that make navigating through and analyzing high-volume logs data much easier. 

Firstly, this update provides full text search capabilities, regardless of the format you sent your logs message in. You can find all logs sent with the search result, and then find all related sessions.

Additionally, our UI updates give you the ability to analyze your logs data in aggregate. 

While seeing all of your raw logs within a certain time frame is crucial to troubleshoot at a deep level, having aggregated metrics is necessary for a high-level view into overall health and trends.  Aggregated log metrics are what let you quickly detect patterns and anomalies, such as an error log that’s affecting a large percentage of your users. 

Both options exist inside Embrace’s improved UI. You can search, filter, and view unaggregated logs, or use our log groupings to see the aggregated impact of a particular log across all user sessions.

Additionally, our advanced filtering capabilities let you isolate logs based on a wide variety of attributes about the user, device, operating system, and session. For example, if you’re looking for logs from a specific device used by users in the UK, you can rapidly zero in on those logs and then view their correlated sessions.

List view of logs in Embrace's dashboard

Investigate logs data within the full context of a user’s experience

Understanding issues within the context of a user’s entire mobile experience is crucial. Now you can do exactly that. 

With our tool, you can easily explore user sessions containing specific strings or even parts of log messages. You can also identify user sessions that contain logs with specific properties. 

When you find a specific user session you want to analyze containing the log you were looking for, you can scroll through all the activity of this session within our User Timeline feature. This gives you a trail of both technical and behavioral events – your logs included – that an individual user experienced over the course of their session on your app. 

This gives you unrivaled, detail-rich context into the events, activities, and conditions that the end user experienced on your app, so you can prioritize what to troubleshoot and get real insight into how to do so.

View of logs in the Embrace User Timeline

Ensure a consistent data model with our Otel logging solution

Embrace’s SDKs are built on OpenTelemetry, a popular and highly versatile framework for collecting and processing observability data. You might already be familiar with OTel, as it’s quickly become a gold standard for collecting backend telemetry. 

As we’ve built out our OTel SDKs, we’re bridging the gap in the data model used for mobile vs. backend so that engineers across both teams can speak a common language when trying to solve user-impacting issues. 

Our new logging capabilities follow this track, ensuring that you don’t have to adjust the way you send your logs to every monitoring tool since Embrace adheres to the OTel standard.

More to come from Embrace

Watch this space as we continue to build out our new logging feature. 

An exciting part of our vision for logs further down the road is the upcoming “blob” feature. With this feature you will be able to  attach messages of up to 300 KB per log.  “Blobs” represent conditional snapshots; they are essentially files with a full application state at a point in time and can be retrieved as part of your log instance when troubleshooting, to be downloaded directly from the Embrace dashboard. We’ll also be exposing an OTel Logger that will allow any developer to send us 3rd party logging data. 

Excited about logs? We are too! You can learn more about this feature in our docs, or check out some of our other products to see how Embrace is building best-in-class, OpenTelemetry-based observability to totally change the game for mobile. 

Embrace Deliver incredible mobile experiences with Embrace.

Get started today with 1 million free user sessions.

Get started free

Build better mobile apps with Embrace

Find out how Embrace helps engineers identify, prioritize, and resolve app issues with ease.