What is OpenTelemetry?

OpenTelemetry (OTel) is an open-source observability framework and part of the Cloud Native Computing Foundation (CNCF).

It consists of a collection of specifications, tools, APIs, and SDKs, enabling mobile engineering teams to instrument, generate, collect, and export telemetry data for analysis. This framework is essential for understanding mobile app performance and behavior, particularly in complex environments.

OTel is currently supported by more than 40 observability vendors.

OpenTelemetry (OTel) is an open-source observability framework that standardizes how applications generate, collect, and export telemetry data—metrics, logs, and traces—to monitoring and analysis tools.

Rather than being a monitoring product itself, OpenTelemetry provides:

• APIs and SDKs for instrumenting applications
• A vendor-neutral data model for telemetry signals
• Collectors and exporters that route data to one or more observability backends

OpenTelemetry is a Cloud Native Computing Foundation (CNCF) project and has become the main standard for observability instrumentation across backend services, infrastructure, and increasingly, mobile applications.

OpenTelemetry is not the first of its kind; it evolved from earlier projects like OpenCensus and OpenTracing. In fact, these initiatives were originally aimed at creating vendor-agnostic libraries for collecting traces and metrics. In 2019, these two projects merged under the OTel umbrella to standardize the approach to observability.

In order to better understand OTel, it’s important to first understand observability.

Observability is the ability to infer the internal states of a system based on data gathered by monitoring the constituent parts of the system.

In this context, those outputs are logs, metrics, and traces:

• Logs: These are event-based records providing insights into notable anomalies across the system. Logs can be structured, unstructured, or in plain text and are critical for understanding the outcomes of transactions.
• Metrics: Represented as numerical data points, metrics are often counts or measures aggregated over time. They originate from various sources and are accessible via queries, helping preemptively identify issues needing remediation.
• Traces: Traces track the steps in the execution of a process (like an API request) from start to finish, across underlying services. Span data within traces, including unique identifiers and timestamps, are key to understanding the ecosystem’s effectiveness.

If vendors don’t use the OTel standard, then the way they collect and transmit these outputs may vary, making it difficult or impossible to move data from one vendor to another.

OTel standardizes how this observability data is collected and sent, making it system agnostic, easy to move, and straightforward to correlate data across otherwise disparate systems and services.

Implementing OpenTelemetry in mobile engineering significantly enhances the observability of mobile applications, aiding in monitoring performance and diagnosing issues effectively. Here’s an overview of how this process typically unfolds:

• Integration Process: The first step involves integrating OpenTelemetry Software Development Kits (SDKs) into mobile applications. These SDKs are tailored for iOS and Android platforms, ensuring a smooth integration with each platform’s unique environment.
• Application Instrumentation: This stage focuses on instrumenting the application to gather telemetry data. This data encompasses various metrics such as memory and CPU usage, traces that illustrate the path of a request through multiple services, and logs that assist in debugging and event tracking.
• Configuring Data Collection: Engineers then configure the specifics of data collection, balancing the quantity of data against the application’s performance. This balance is crucial—excessive data can hinder app performance, while insufficient data may not offer adequate insights.
• Data Collection and Aggregation: With the configuration set, the OpenTelemetry SDKs begin collecting data from the application as it operates. This data is subsequently aggregated, either directly on the device or transmitted to a backend server for this purpose.
• Exporting Data: The next step involves exporting the aggregated data to various observability platforms or analysis tools. OpenTelemetry’s compatibility with multiple exporters allows this data to be sent to diverse monitoring tools, such as Prometheus, Jaeger, and Zipkin.
• Analysis and Visualization: Once exported, the data is analyzed and visualized using the chosen observability platform. This analysis is key to understanding the application’s performance, pinpointing bottlenecks, and troubleshooting issues.
• Continuous Monitoring and Alerts: In a production setting, continuous monitoring is established. This includes setting up alerts based on specific data thresholds or anomalies, enabling proactive issue resolution.

val tracer = GlobalOpenTelemetry.getTracer(“mobile-app”)

tracer.spanBuilder(“fetch_user_profile”)

    .setSpanKind(SpanKind.CLIENT)

    .startSpan().use { span ->

        try {

            // Perform network request

            api.fetchUserProfile()

        } catch (e: Exception) {

            span.recordException(e)

            span.setStatus(StatusCode.ERROR)

        }

    }

OpenTelemetry offers several benefits for mobile engineers, aiding in the development, maintenance, and optimization of mobile applications. Here are some key advantages:

• Unified Instrumentation: OpenTelemetry provides a single set of APIs and libraries for various telemetry data (metrics, traces, and logs). This unified approach simplifies the instrumentation process for mobile engineers, allowing them to collect comprehensive data with less effort and more consistency.
• Performance Monitoring: By using OpenTelemetry, mobile engineers can effectively monitor the performance of their applications. This includes tracking response times, detecting performance bottlenecks, and understanding the impact of code changes on app performance.
• Error and Exception Tracking: OpenTelemetry helps in capturing and analyzing errors and exceptions. Mobile engineers can use this data to quickly identify and address issues, improving the overall reliability of the application.
• Enhanced User Experience: Through detailed telemetry data, engineers can understand how users interact with the app, identify common user flows, and detect issues that might affect user experience. This information is crucial for optimizing the app for better user engagement and satisfaction.
• Resource Utilization Insights: OpenTelemetry provides insights into how a mobile application uses system resources like CPU and memory. This information is valuable for optimizing app performance and ensuring efficient resource utilization.
• Interoperability and Vendor Neutrality: As an open-source project, OpenTelemetry is designed to be vendor-neutral. This allows mobile engineers to integrate with a variety of backend analysis tools without being locked into a specific vendor, offering flexibility in choosing or changing monitoring and analytics platforms.
• Debugging and Troubleshooting: The detailed data collected through OpenTelemetry aids in debugging and troubleshooting issues. This can significantly reduce the time and effort required to identify and resolve problems.
• Community and Ecosystem Support: Being an open-source project, OpenTelemetry benefits from strong community support and a rapidly evolving ecosystem. This means mobile engineers have access to a wealth of resources, tools, and best practices.

OpenTelemetry is designed to be flexible, but it may not be the best choice for every team or stage of development. For very small or early-stage applications, simpler logging or basic monitoring may be sufficient until observability needs become more complex.

Teams without an existing backend observability stack may also find it harder to realize immediate value, since OpenTelemetry focuses on collecting and exporting data rather than storing or visualizing it.

Similarly, during early prototyping or rapid experimentation, the overhead of instrumentation, while generally modest, may not be necessary if the primary goal is validating functionality rather than monitoring performance.

Many teams address these considerations by adopting OpenTelemetry incrementally, starting with a limited set of signals or use cases and expanding as their observability needs mature.

In summary, OpenTelemetry provides a comprehensive, flexible, and efficient framework for telemetry in mobile applications, enabling mobile engineers to improve performance, user experience, and reliability of their apps while benefiting from an open-source ecosystem.

Our customers trust Embrace with a very important job – making sure that their apps are performing well and helping them resolve issues when they’re not. 

By making the Embrace SDK they rely on open source, we can give our users greater visibility into how our technology does what we say it does. Developing out in the open like this is about providing a greater level of transparency that fosters trust in our product and our company.