What Is OpenTelemetry? Distributed Tracing and Observability Explained

OpenTelemetry is the open standard for collecting traces, metrics, and logs across any stack, without locking your telemetry into one vendor’s proprietary agent.

The OpenTelemetry project logo icon in color
Image: OpenTelemetry.

OpenTelemetry — often shortened to OTel — is an open-source, vendor-neutral framework for generating, collecting, and exporting telemetry data: the traces, metrics, and logs that show what software is actually doing while it runs. It gives developers one common set of APIs, SDKs, and a standard wire protocol for instrumenting code, so the same telemetry can be sent to any compatible backend instead of being locked into a single vendor’s proprietary agent. In May 2026, the Cloud Native Computing Foundation (CNCF) named OpenTelemetry a Graduated project — the same top tier held by Kubernetes and Prometheus — confirming it as the de facto standard for observability across cloud-native software.

Key facts
  • What it is: an open-source observability framework and toolkit for traces, metrics, and logs, hosted by the CNCF.
  • What it is not: a monitoring backend or dashboard — OpenTelemetry collects and exports data, it does not store or visualize it.
  • Origin: formed in 2019 from a merger of two earlier projects, OpenTracing and OpenCensus.
  • Core pieces: language APIs/SDKs, instrumentation libraries, the OpenTelemetry Collector, and the OTLP protocol.
  • Status: a CNCF Graduated project as of May 21, 2026, with more than 12,000 contributors from over 2,800 companies.

What Is OpenTelemetry, Exactly?

OpenTelemetry is best understood as plumbing, not a product. It is a specification plus a set of language-specific implementations that define how an application should generate telemetry data and in what shape that data should travel. The project’s own documentation describes it as an “observability framework and toolkit” for generating, exporting, and collecting telemetry such as traces, metrics, and logs, built to be open source and vendor- and tool-agnostic from the ground up.

That last part is the whole point. OpenTelemetry does not store your data, and it is not a dashboard you log into. Instead, it standardizes two things that used to be tightly coupled to whichever commercial tool a team bought: how telemetry is produced inside the code, and how it is shipped out to wherever it will be stored and analyzed. Teams can route that data to an open-source backend, a commercial observability platform, or several destinations at once, without rewriting their instrumentation each time they switch tools.

Why OpenTelemetry Exists

Before OpenTelemetry, instrumenting an application for tracing or metrics usually meant installing a proprietary agent or SDK tied to one specific monitoring vendor. Switching vendors, or even just adding a second one for a specialized use case, meant re-instrumenting services from scratch — a real cost that discouraged teams from ever changing tools, regardless of price or features. Distributed tracing had its own fragmented history too: the earlier OpenTracing project offered vendor-neutral tracing APIs, while Google’s OpenCensus offered libraries for metrics and traces with built-in exporters, and the two efforts overlapped awkwardly until they merged into OpenTelemetry in 2019.

OpenTelemetry’s documentation frames its purpose around two guiding principles: users should own the telemetry data they generate, free of vendor lock-in, and they should only need to learn one set of APIs and conventions to instrument everything, regardless of which backend eventually receives the data. As systems moved to microservices, containers, and Kubernetes-style orchestration, a single request could cross dozens of services, making a shared, portable instrumentation standard far more valuable than it would have been for a single monolithic application.

The Three Signals: Traces, Metrics, and Logs

OpenTelemetry organizes telemetry into three primary “signals,” each answering a different question about a running system. A trace follows a single request as it moves across services, showing where time was spent and where something broke. A metric is a numeric measurement captured at a point in time, like CPU usage or request counts. A log is a timestamped record of a discrete event, the most familiar form of telemetry to most developers.

SignalWhat it capturesTypical question it answers
TracesThe end-to-end path of one request across services and processesWhere did this specific request slow down or fail?
MetricsNumeric measurements sampled over time (counters, gauges, histograms)How is the system behaving on average, right now?
LogsTimestamped records of discrete events, often with free-form detailWhat exactly happened at this moment?

Because all three signals share a common underlying data model and travel over the same OpenTelemetry Protocol (OTLP), they can be correlated — a trace can point to the exact logs and metrics that were recorded during the same request — instead of living in three disconnected tools the way they often did under older, siloed monitoring setups.

The Core Pieces: APIs, SDKs, and Instrumentation

OpenTelemetry’s building blocks split cleanly into a few layers. The API defines how telemetry is generated in code — the calls a developer makes to start a trace span or record a metric — without specifying how that data is actually processed or sent anywhere. The SDK is the implementation that plugs into the API, handling batching, sampling, and export according to configuration. Sitting on top of both is instrumentation: the actual code, often packaged as libraries, that calls into the API on an application’s behalf.

Instrumentation comes in two flavors. Automatic instrumentation attaches to common frameworks and libraries — an API framework, a database driver, an HTTP client — and generates telemetry with little to no code changes, which is why it is often the fastest way to get started. Manual instrumentation means a developer adds OpenTelemetry calls directly into application code to capture business-specific detail that generic auto-instrumentation can’t know about, such as a custom step in a checkout flow. Most real deployments use both: automatic instrumentation for broad, free coverage, and manual spans layered on top for the logic that matters most to a given team.

The OpenTelemetry Collector Explained

The OpenTelemetry Collector is a separate, standalone piece of the project: a vendor-agnostic service, described in the official docs as a proxy, that receives telemetry data, processes it, and exports it onward to one or more destinations. It can run as an agent alongside an application or as a standalone gateway service, and it supports a wide range of open formats on the way in and out, including OTLP as well as formats associated with tools like Prometheus and Fluent Bit.

Applications can export telemetry data directly to a backend, which is fine for getting started or for small, low-traffic setups. For anything approaching production scale, the Collector is the recommended path, because it takes over work that would otherwise have to be built into every single service: batching data efficiently, retrying failed exports, encrypting traffic, and filtering out sensitive fields before data ever leaves the environment. Because default OTLP exporters already point at a local collector endpoint, standing up a single Collector instance is often all that is needed to start receiving telemetry from many instrumented services at once.

OpenTelemetry vs. Prometheus

OpenTelemetry and Prometheus are frequently mentioned together, and both are CNCF Graduated projects, but they solve different parts of the same problem and are not direct substitutes for each other. Prometheus is a metrics-focused monitoring system with its own time-series database, query language (PromQL), and a pull-based model for scraping metrics from targets. OpenTelemetry is broader in scope — it covers traces, metrics, and logs — and it is explicitly not a storage or query backend at all; it only standardizes how telemetry is generated and transported.

OpenTelemetryPrometheus
ScopeTraces, metrics, and logsPrimarily metrics
RoleInstrumentation standard and data pipelineMetrics storage, querying, and alerting backend
Collection modelPush-based via SDKs/Collector (OTLP)Pull-based scraping of metrics endpoints
Typical pairingExports metrics to Prometheus or another backendCan scrape or receive OTLP metrics via the Collector

In practice, the two complement each other: OpenTelemetry’s own documentation includes a dedicated Prometheus compatibility section covering how the two interoperate, and the Collector can translate between Prometheus’s exposition format and OTLP in either direction. A team can instrument services with OpenTelemetry and still send the resulting metrics into Prometheus for storage and alerting, rather than treating the choice as either-or.

OpenTelemetry vs. Older Proprietary APM Tools

Traditional application performance monitoring (APM) products typically ship their own proprietary instrumentation agent: install the vendor’s library, and telemetry flows straight into that vendor’s backend in that vendor’s format. It works well as long as a team never wants to change vendors, add a second tool, or self-host any part of the pipeline. OpenTelemetry decouples those two steps. Instrumentation is written once against an open specification, and the resulting data can be routed, via the Collector or direct export, to any backend that accepts OTLP or another supported format — open source or commercial — without touching application code again.

This is also why most major observability and APM vendors now support ingesting OpenTelemetry data directly, often alongside or in place of their own legacy agents. The shift mirrors how standardized protocols elsewhere in infrastructure and DevOps tooling have reduced lock-in over time: the standard doesn’t eliminate vendors, it just stops the instrumentation layer from being a captive part of any single vendor’s product.

Who Governs OpenTelemetry

OpenTelemetry is hosted by the Cloud Native Computing Foundation, a subsidiary of the Linux Foundation that also hosts Kubernetes and Prometheus. On May 21, 2026, the CNCF announced that OpenTelemetry had reached Graduated status — the foundation’s highest project maturity tier — citing more than 12,000 contributors from over 2,800 companies and a project velocity ranked second only to Kubernetes among the more than 240 projects in the CNCF’s portfolio. CNCF CTO Chris Aniszczyk said the graduation “solidifies it as the essential, unified observability standard,” while OpenTelemetry governance committee member Austin Parker noted that when the project launched, “none of us expected that it would reach this level of popularity and impact.”

Graduation follows a defined path through the CNCF: projects are first accepted, then move to incubating status, and only graduate after demonstrating sustained adoption, a diverse set of committers, and documented security and governance practices. OpenTelemetry was originally contributed to the CNCF in 2019, following the OpenTracing/OpenCensus merger, and spent several years in incubation before reaching this top tier.

How to Get Started With OpenTelemetry

For a team evaluating OpenTelemetry for the first time, the practical path generally follows the same shape regardless of language or stack:

  • Pick a language SDK. OpenTelemetry maintains official SDKs for languages including Java, Python, Go, JavaScript/Node.js, .NET, and Ruby, each implementing the same underlying specification.
  • Start with automatic instrumentation. Most languages offer a zero-code or low-code auto-instrumentation path that covers common frameworks, HTTP clients, and database drivers without requiring source changes.
  • Run a Collector. Rather than exporting straight from every service to a final backend, standing up one OpenTelemetry Collector instance centralizes batching, retries, and filtering, and gives a single place to change destinations later.
  • Add manual instrumentation selectively. Once broad coverage exists, add targeted manual spans or metrics around the specific business logic a team most needs visibility into.
  • Choose a backend last. Because the instrumentation layer is decoupled from storage and visualization, the choice of where telemetry ultimately lands — an open-source stack, a commercial platform, or several at once — can be made, and changed, independently of the instrumentation work already done.

Because OpenTelemetry instrumentation libraries, exporters, and Collector components are developed in the open, the official GitHub organization is the canonical place to find current releases, language-specific repositories, and the Collector’s component registry.

What OpenTelemetry Doesn’t Do

It’s worth being precise about the boundary. OpenTelemetry does not provide dashboards, alerting rules, long-term storage, or a query language of its own — those remain the job of whatever backend receives the exported data, whether that’s an open-source project, a self-hosted stack, or a commercial platform. Some Collector components and language features also carry different stability markings (stable, beta, or experimental), so teams adopting less mature pieces should check a component’s current status before relying on it in production, a point the project’s own documentation calls out directly.

Bottom Line

OpenTelemetry is the standard way modern software reports what it’s doing: one set of APIs and a shared wire protocol for traces, metrics, and logs, decoupled from whichever backend eventually stores and visualizes that data. Its May 2026 CNCF graduation — alongside Kubernetes and Prometheus — reflects just how broadly it has already been adopted across the industry as the default alternative to proprietary, single-vendor instrumentation. For teams building anything beyond a single service, instrumenting with OpenTelemetry from the start avoids re-doing that work later, no matter which observability tools come and go around it.

Video: OpenTelemetry · What is OTel? | OTel for Beginners - The JavaScript Journey

Frequently asked questions

What is OpenTelemetry in simple terms?

OpenTelemetry is an open-source, vendor-neutral set of APIs, SDKs, and tools for generating and collecting telemetry data — traces, metrics, and logs — from software, so that data can be sent to any compatible monitoring backend instead of being locked to one vendor's proprietary agent.

What is OpenTelemetry used for?

It's used to instrument applications and infrastructure so teams can see how requests move through distributed systems, measure performance over time, and correlate logs, metrics, and traces when diagnosing issues, without rewriting instrumentation if the monitoring backend changes.

Is OpenTelemetry a replacement for Prometheus?

No. OpenTelemetry is an instrumentation and data-collection standard covering traces, metrics, and logs, while Prometheus is a metrics storage, querying, and alerting backend. OpenTelemetry's Collector can send metrics to Prometheus, and the two are commonly used together rather than as substitutes.

What is the difference between OpenTelemetry and a proprietary APM agent?

A proprietary APM agent ties instrumentation directly to one vendor's backend and format. OpenTelemetry instruments code once against an open specification, so the resulting telemetry can be routed to any backend that supports it, open source or commercial, without re-instrumenting the application.

What is the OpenTelemetry Collector?

The Collector is a standalone, vendor-agnostic service that receives telemetry data from instrumented applications, processes it (batching, filtering, retries), and exports it to one or more backends. It is recommended for production use rather than exporting straight from each service.

Do I need to instrument my code manually to use OpenTelemetry?

Not necessarily at first. Automatic instrumentation covers many common frameworks, libraries, and database drivers with little to no code changes. Manual instrumentation is typically added afterward, to capture custom, business-specific detail that automatic instrumentation can't infer on its own.

Sources

More on OpenTelemetry →OpenTelemetryObservabilityCNCFDevOpsAPMDistributed Tracing
Felix Moreau
Written byFelix Moreau

Felix Moreau writes Pandromeda's software coverage and how-to guides. He covers Windows, macOS and Linux updates, the apps people rely on, emulators and developer tools, and turns official documentation into clear, numbered steps that work on the current version.

More from Software & Guides

See all