Definition of OpenTelemetry, a CNCF project dedicated to telemetry
OpenTelemetry is an open source project hosted by the Cloud Native Computing Foundation (CNCF). Its documentation presents it as an observability framework and toolkit, which make it easier to generate, export and collect telemetry data: traces, metrics and logs. It is independent of vendors and of analysis tools alike.
The project resulted from the merger of two earlier projects, OpenTracing and OpenCensus, each of which aimed at a standard for instrumenting code. According to the CNCF page dedicated to it, it was accepted by the foundation on 7 May 2019, moved to the “Incubating” maturity level on 26 August 2021, then to the “Graduated” level on 11 May 2026.
The need for an instrumentation standard
For a system to be observable, its code must emit signals, sent to an analysis tool. When each tool brings its own libraries and format, changing tools means reworking the instrumentation of applications.
The project’s documentation sums up its answer in two principles: the organisation remains the owner of the data it generates, with no dependency on a vendor, and teams learn only one set of interfaces and conventions. Whether monitoring is enough is a different question, addressed in our article observability vs monitoring.
OpenTelemetry signals and components
The project calls signals the categories of telemetry it supports. Its documentation cites four: traces (the path of a request through the application), metrics (a measurement captured at runtime), logs (the record of an event) and baggage (context passed from one signal to another). Profiles and events appear as in development or at the proposal stage.
| Component | Role |
|---|---|
| Specification | Sets the requirements common to all implementations, whatever the language |
| API and SDK per language | The API is used to generate telemetry in the code; the SDK implements it, processes the data and exports it |
| Instrumentation | Through code, or without modifying it (zero-code) for common libraries |
| Semantic conventions | Common names for operations and data |
| OTLP (OpenTelemetry Protocol) | The protocol that sets the encoding, transport and delivery of data |
| Collector | The intermediary that receives, processes and exports telemetry |
The OTLP specification defines it over gRPC and over HTTP. At the time of writing, it declares itself stable for traces, metrics and logs.
The Collector is a single executable, organised into pipelines: receivers collect the data, optional processors transform or filter it, and exporters send it to one or more destinations. The documentation describes two deployment modes: as an agent, alongside the application or on the same host, and as a gateway, a standalone service that offers a single OTLP entry point, for example per cluster.
OpenTelemetry, observability backend, SRE: not to be confused
OpenTelemetry is not an observability backend: its documentation deliberately leaves storage and visualisation to other tools, open source ones such as Jaeger or Prometheus, or commercial ones. Adopting it does not remove the need to choose where the data is kept.
Nor is it a method. The project provides formats and tools; choosing the journey to instrument, propagating context from one service to another and setting the sampling rule remain team decisions, set out in our article on distributed systems observability. Finally, OpenTelemetry sets no reliability objective: that notion belongs to SRE.
Example: the journey of a trace, from service to backend
Take a booking service. Zero-code instrumentation generates traces for its incoming and outgoing HTTP requests. The team adds, through the API, a business attribute: the sales channel. The SDK exports this data over OTLP to a Collector deployed as an agent, which forwards it to a gateway.
There, a processor removes a sensitive attribute, then two exporters send the traces to a tracing tool and the metrics to a time series database. If the organisation adopts another compatible analysis tool, it reconfigures the exporter: the service’s instrumentation is not reworked.
Linking these signals to service level objectives and to alerts is the purpose of our page on SRE and observability.