Start your free 14-day ContainIQ trial

What is OpenTelemetry?

June 24, 2022

This article aims to clarify and simplify the concept of OpenTelemetry by explaining why it is necessary while also unbuckling misconceptions about what it does.

Taurai Mutimutema
Systems Analyst & Engineer

The emergence of distributed systems brought about a level of administration complexity that engineers couldn’t have foreseen—one that has made collecting and presenting traces, metrics, and logs (telemetry data) significantly more difficult than in monolithic systems.

Most notable is how engineers overseeing the wellness of distributed architectures now have to craft APIs and agents for language-agnostic microservices, in addition to seeing to the instrumentation and presentation of telemetry data from every node/component in their stack. The result was a horde of applications and open-source telemetry collection projects that spewed out inconsistent data.

Often, engineers would (unknowingly) neglect crucial observability points in their blind spots, overwhelmed by the new environment. However, in 2019, with the support of the Cloud Native Computing Foundation (CNCF), Openelemetry rose from the amalgamation of two projects: OpenCensus and OpenTracing.

This article aims to clarify and simplify the concept of OpenTelemetry by explaining why it is necessary while also unbuckling misconceptions about what it does.

A Case for OpenTelemetry

OpenTelemetry is an effort to standardize the efforts outlined above through the provision of community-maintained gateways, instrumentation for specific languages and frameworks, and plug-in points for (commercial) observability applications to capture telemetry data from the entire breadth of a distributed architecture.

Why is OpenTelemetry Important?

Being a standard instrumentation for sending performance data to any backend of your choice, OpenTelemetry is the bedrock for the improvement of not only the infrastructures on which it lays, but also of the cloud computing industry itself.

Implementing OpenTelemetry inherits the following benefits to your performance measuring efforts:

  • Standards make for better telemetry data quality
  • Developers get free SDKs and APIs
  • Feeding telemetry data to your backend becomes an easier endeavor
  • Application performance monitoring (APM) services vendors make better tools
  • Scaling opportunities are facilitated

Let’s take a closer look at each of these benefits.

OpenTelemetry Upholds Quality Standards

Being standard and community-developed, the OpenTelemetry project attracts expertise your business benefits from (for free). As a result, the diverse perspectives invested in building a single performance data collector achieve a more thorough product than an isolated group of developers could ever create.

The quality of telemetry data from the open-source community is always increasing and covers more backend languages and frameworks with each turn.

Free APIs and SDKs

The provision of APIs and SDKs makes integrating OpenTelemetry into your stack much easier, regardless of whether you’re working on green or brownfields. For greenfields, building your backend around OpenTelemetry SDKs blends the highest standard of performance data pipelines into your legacy code.

Brownfield development scenarios can leverage APIs and agents to plant collection mechanisms into existing legacy code without changing application logic or process flows. This non-intrusive integration and a plain motive to standardize and improve telemetry data are welcoming, hence the vast community and usage track record of OpenTelemetry thus far.

Aims to Make Life Easier for Engineers

Monitoring cloud infrastructures (sometimes multi-cloud) with OpenTelemetry removes the strain of trial and error with in-house-made collections of API and agents. The vibrant community that contributes to the OpenTelemetry framework’s expansion extends technical talent into a company using it.

Sometimes the nodes across a microservice infrastructure use different frameworks and programming languages. The various OpenTelemetry components for diverse backends make it so that one doesn’t have to be a full-stack engineer to monitor and support these microservices.

Implementing collection and exports is an automated process. Furnished with libraries pre-coded with all the right calls for you to take advantage of, the speed of implementation and high-quality results are nothing short of impressive. If you prefer maintaining full knowledge of underlying processes, the integration process between OpenTelemetry and your backend is optionally manual as well.

A Vendor-Agnostic Telemetry Bus

By design, OpenTelemetry presents endpoints for data collection applications to plug into, process, and present according to preferences set by their target market. This makes it easy for companies to cycle through vendors in search of the best view (value) into their telemetry data.

What this means is that you can also use a variety of vendors at the same time to cover as much ground into performance monitoring and data visibility as you need to maintain perfect systems.

OpenTelemetry as a Springboard for Scale

With observability concerns out of the way, engineers can safely expand the surface of their applications. The ability to support different backends concurrently makes OpenTelemetry the perfect bedrock on which to scale applications.

K8s Metrics, Logging, and Tracing
Monitor the health of your cluster and troubleshoot issues faster with pre-built dashboards that just work.
Start Free Trial Book a Demo

What is OpenTelemetry?

After digesting the history and motives of OpenTelemetry, the “what” should now be easier to grasp. Yes, there have been other respectable telemetry-handling projects in the market, but without some standard measure of quality control, building cloud-native applications would be a slow concept. Every developer would have to reinvent the wheel just for their unique stack.

OpenTelemetry Collector can be implemented into the codebase of applications. This is the simplest implementation. Thereafter, telemetry data will stream towards your set endpoints.

A common mistake is to regard OpenTelemetry in the same set as data visualization tools (commercial or otherwise), when, in fact, they only connect to the endpoints at which the OpenTelemetry Collector feeds telemetry data. As a framework, OpenTelemetry blends with application code, whereas consumers of data simply form a layer outside the application’s logic for processing.

At the time of writing this article, hundreds of companies and the CNCF give OpenTelemetry a resounding nod for taking distributed performance data handling in the right direction.

Some of the biggest observability industry players, including AWS, Elastic, and Splunk, openly integrate OpenTelemetry to form distributions that include their endpoints.

OpenTelemetry Typical Usage Case

A good example to show the implementation of the OpenTelemetry framework is through sharing the common steps across all supported backend technologies. These include a growing list:

  • .NET
  • Ruby
  • C++
  • PHP
  • Rust
  • Erlang/Elixir
  • Java
  • Go
  • Swift
  • JavaScript
  • Python

Assuming you have an active project, and you wish to import the OpenTelemetry framework into your code, the first step is always adding the free-to-use OpenTelemetry libraries to your dependency files. Depending on the language, this could just be ‘requiring’ the specific libraries into your project globally.

For Rust-lang, this can look like this:


use opentelemetry::{global, sdk::export::trace::stdout, trace::Tracer};

With Ruby, your Gemfile will need to be patched with the following gems:


gem 'opentelemetry-sdk'
gem 'opentelemetry-exporter-otlp'
gem 'opentelemetry-instrumentation-all'

Once you have added the framework, initiate the code. With JavaScript, this can happen through the installation of community-created and managed instrumentations.


npm install @opentelemetry/auto-instrumentations-node

Meanwhile, Golang OpenTelemetry requires that you create spans and attributes for traces as part of the manual instrumentation process.

Most backends have both manual and automatic installation options to streamline integration and break any programming language barrier that might hinder progress. Once the integration is out of the way, you can call export packages to connect your data and ‘dump’ traces into your observability tools.

A Python backend can achieve this by simply running:


pip install opentelemetry-exporter-jaeger

The export destination depends on your preferences, but you have a wide variety to pick from. These include a simple writable file, Kafka, a custom HTTP resource, Prometheus, and Zipkin. Of course, you can customize these export endpoints to reduce latency issues when you save telemetry to text files, only to read them again.

Why Should Engineers Care About OpenTelemetry?

From the language-agnostic example above, it’s clear that OpenTelemetry is fast becoming “the way” to push logs, traces, metrics, and any desired data points directly from code into processing and visualization tools. As an engineer, there’s no point swimming against the current, risking poor reporting and sub-par performance monitoring.

As more backend languages join the list supported by OpenTelemetry, it’ll soon be close to impossible to develop cloud-native distributed applications in its absence. As a developer, it’s worth jumping on board early and gaining a technical advantage over the rest of the market.

Final Words

Telemetry data compiling and exporting was a wild west until OpenTelemetry became the standard in 2019. A child project of OpenTracing and OpenCensus, OpenTelemetry provides the connectors to integrate with backends and push telemetry data to your preferred data observability tools.

The implementation process of OpenTelemetry is simple enough for an engineer to place hooks into backends written in languages barely used before. The open-source community supporting the OpenTelemetry framework keeps adding compatibility with new backend technologies with entire libraries and APIs ready to make data collection a breeze.

The astounding support pouring from tech giants like AWS is a clear signal that engineers must rally behind OpenTelemetry as the default framework to integrate monitoring tools with their stack. Then there’s the hundreds of companies openly using OpenTelemetry to export performance data in pursuit of industry dominance.

A good example would be the use of OpenTelemetry to fetch Kubernetes nodes and push them to ContainIQ, a platform to instantly monitor Kubernetes metrics and events within your cluster. The speed and coverage achievable make troubleshooting container issues a breeze, since you have full visibility of the application from the code, all the way up to the interface where issues are reflected.

Start your free 14-day ContainIQ trial
Start Free TrialBook a Demo
No card required
Taurai Mutimutema
Systems Analyst & Engineer

Taurai is a systems analyst with a knack for writing, which was probably sparked by the need to document technical processes during code and implementation sessions. In his previous role, Taurai was the Director of Information Technology for a private consulting organization in South Africa. He enjoys learning new technology and talks about tech even more than he writes. Taurai has a Bachelor's of Science in Computer Science from Midlands State University.

READ MORE