Skip to content
Technology transformation expertise firm · ARDIANE Group Innovate, secure, succeed

Glossary

OpenTelemetry: definition, signals, Collector and the OTLP protocol

Domain

Cloud and platforms

In brief

OpenTelemetry is an open source project of the Cloud Native Computing Foundation (CNCF) that provides specifications, programming interfaces, software development kits and a collector to generate, collect and export telemetry data: traces, metrics and logs. Vendor-neutral, OpenTelemetry is not an observability backend: it neither stores nor displays this data.

Page contents

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.

FAQ

Frequently asked questions

Another question? Ask us

What is OpenTelemetry?

OpenTelemetry, abbreviated to OTel, is an open source project of the Cloud Native Computing Foundation. Its documentation describes it as an observability framework and toolkit that make it easier to generate, export and collect telemetry data such as traces, metrics and logs. It is independent of vendors and analysis tools.

Is OpenTelemetry a monitoring tool?

No. The OpenTelemetry documentation specifies that the project is not an observability backend: storage and visualisation of telemetry are left to other tools, open source or commercial. OpenTelemetry covers what comes before, that is, instrumentation of the code, the data format and its transport.

What is the OpenTelemetry Collector for?

The OpenTelemetry Collector is a vendor-neutral intermediary that receives, processes and exports telemetry data. It is organised into pipelines made up of receivers, optional processors and exporters, and can send the same data to several destinations. It is deployed as an agent, close to the application, or as a gateway, as a standalone service.

What is the OTLP protocol?

OTLP (OpenTelemetry Protocol) is the protocol designed by the OpenTelemetry project to transmit telemetry. Its specification describes the encoding, transport and delivery mechanism of data between sources, intermediate nodes such as collectors, and backends. It defines it over gRPC and over HTTP, with messages in Protocol Buffers format.

A project to bring to completion?

A first conversation is enough to understand your challenge, identify the right people and tell you frankly what we can bring.