When OpenTelemetry first came into the picture with the merger of OpenCensus and OpenTracing in 2019, it was pretty much all about classic telemetry data, namely- logs, metrics, and traces.

Since then, OpenTelemetry has become an indispensable tool in the modern observability landscape. With frequent integrations and introduction to new capabilities every year or so, it has poised itself as an invaluable tool for cloud enterprises.

Most recently, as of March 19th, 2024, to be precise, Otel announced support for something called “Profiling”.

In this part of our OpenTelemetry blog posts series, we’ll talk about tracing and profiling, clear the mist around the differences between the two and discuss the path ahead for OpenTelemetry in the coming years.

OpenTelemerty: A Quick Overview

OpenTelemetry Defined

Before we get ahead of ourselves, let’s have a quick recap of what is OpenTelemetry.

Designed as a comprehensive toolkit for collecting telemetry data—including metrics, logs, and traces—OpenTelemetry simplifies the process of application instrumentation, empowering developers to gain deeper insights into their applications’ performance.

Simply put, OpenTelemetry is an open-source project that provides a unified set of tools, APIs, and SDKs to collect and export telemetry data (metrics, logs, and traces) from cloud-native software applications.

However, that definition is going to be a bit longer in the coming years. Why because OTel is evolving and for much-required reasons, given the rapid evolution of data and the way it’s being managed. Not to mention the ubiquity of AI in recent times.

That said, let’s jump right into profiles along with their purpose and benefits with OpenTelemetry.
Presently, OpenTelemetry stands as the 2nd most active project within the Cloud Native Computing Foundation (CNCF), highlighting its escalating significance in the realm of observability.

What is Profiling?

Profiles are a trending feature in OpenTelemetry designed to enhance the toolkit’s capabilities by providing deeper insights into application performance. This new data type or signal, which is currently in the early stages of development, focuses on profiling—an approach that dynamically examines the runtime behavior of application code. 

Profiling helps identify areas for optimization, particularly in terms of CPU usage, memory consumption, and execution time hot spots by capturing instances of the code at various intervals. 

Moreover, sustained profiling not only sheds light on resource utilization at the code level but also enables the storage, querying, and analysis of this data over time. 

What is Tracing?

In OpenTelemetry, tracing is a method used to track the execution of requests or transactions as they flow through various services and components of a distributed system.

It involves collecting and recording data about operations (represented as spans) that occur during the processing of a request. Each span contains information about the operation such as its start and end time, metadata, and details about any errors encountered. Spans are linked together to form traces, which provide a detailed, end-to-end picture of a request’s path through the system.

This allows developers and operations teams to visualize the sequence and interaction of operations, helping them diagnose issues, optimize performance, and understand system behavior in complex, distributed environments. 

Understanding the Difference: Tracing and Profiling

While tracing is at the core of OTel, think of profiling as an augmentation to the capabilities. Let’s have a look at the differences thoroughly:  

Tracing in OpenTelemetry provides a means to track the journey of a request through various services and processes. It helps developers understand the flow of requests, identify bottlenecks, and pinpoint failures in a distributed system.  

Additionally, Traces are composed of spans, where each span represents a single operation or unit of work. This makes it easier to visualize the path of a request and observe how different parts of the system interact. 

Profiling, on the other hand, is slightly different. While it’s a newer addition to OpenTelemetry, profiling offers a way to measure where a program spends its time or uses other resources like CPU or memory.

Profilers run in the background and can provide a granular view of resource usage over time, making them invaluable for optimizing performance and understanding system behavior under different load conditions.

The Complementary Nature of Profiling and Tracing

Profiling and Tracing

In OpenTelemtery, tracing and profiling serve complementary purposes in application monitoring and performance optimization:

– Tracing: provides a high-level overview of request paths and interactions within your distributed system, making it essential for identifying and diagnosing systemic issues such as latency and errors. 

– Profiling: dives deeper into individual processes, offering detailed insights into resource usage and potential inefficiencies at the code level.

By combining these two techniques, you get a well-rounded view of application performance.
To put it a bit simply: 

  • Tracing (Macro-level): Shows you the big picture – how requests flow and where delays might be happening. 
  • Profiling (Micro-level): Shows you the granular details – why a specific code section is slow and what resources it’s consuming.

This comprehensive approach is especially valuable for developers and performance engineers. They can use it to:

  • Understand exactly how the application functions. 
  • Identify root causes of performance problems. 
  • Optimize code for better efficiency.

Limitations of OpenTelemetry

OpenTelemetry excels as a unified telemetry collector, yet there are some limitations:  

  • Documentation/Support: Navigating the vast documentation and finding timely support can be cumbersome. 
  • No Built-in Analysis: OpenTelemetry lacks its own backend analysis, requiring integration with separate tools, adding complexity and vendor lock-in concerns. 
  • Feature Immaturity: Certain functionalities, particularly in metrics and logging, are still under development, limiting feature parity. 
  • Distributed Overhead: The distributed architecture can introduce performance overhead compared to centralized tracing solutions. 

What’s Next for OpenTelemetry?

Looking ahead to 2024, OpenTelemetry is poised to expand its capabilities significantly. The focus will be on stabilizing the current features and introducing advanced ones like profiling and client-side Real User Monitoring (RUM). These additions are expected to provide developers and organizations with even more tools to monitor and optimize their applications effectively. 

OpenTelemetry has significantly transformed the way telemetry data is aggregated by standardizing data formats across different technologies. This uniform format simplifies the processes of working with, combining, and analyzing data.  

The introduction of profiling as a signal type is particularly exciting because it would further enhance this standardization, enabling a unified approach to understanding and optimizing code performance across diverse environments and languages. This development promises to make telemetry data even more accessible and actionable for users.

Leveraging OpenTelemetry for Better Insights

For developers and companies aiming to improve their application performance insights, leveraging both profiling and tracing within OpenTelemetry offers a robust solution. By utilizing tracing, you can ensure that your application interactions and flows are seamless and efficient.  

Meanwhile, profiling allows you to drill down into specific areas where performance could be enhanced, ensuring that your applications not only work well together but are also optimized individually for better overall performance. 

Furthermore, Profiles are currently being developed as a new type of signal in OpenTelemetry, which already supports three main signal types: metrics, traces, and logs. These signal types correspond with backend tools that ingest and process them.  

Now, the proposed addition of profiling aims to delve deeper into the runtime performance of code in a manner that is consistent and universal across various programming languages. 

As we move towards a more connected and data-driven future, the tools provided by OpenTelemetry are becoming essential for anyone looking to ensure their applications are not just functional but fully optimized and reliable. 

Whether you’re already on board with OpenTelemetry or considering its integration into your tech stack, the advancements in tracing and profiling are set to revolutionize how we understand and improve our applications. 

This is the first post in our OpenTelemetry Blog post series. Stay tuned as we explore more OTel concepts in the upcoming parts.


  • Profiling: Enhances application insights by monitoring runtime behavior and identifying optimization needs.

  • Tracing: Tracks and documents request execution paths across services, aiding in performance diagnostics.

  • Differences and Synergies: Tracing offers system-level views; profiling provides deep dives into resource and code performance.

  • Future Directions: Plans to expand features including profiling and Real User Monitoring (RUM) for comprehensive insights.