What Is OpenTelemetry?
OpenTelemetry (OTel) is a vendor-neutral, open-source framework for instrumenting, generating, collecting, and exporting telemetry: traces, metrics, logs, and profiles. It is not a backend or database. It provides standard APIs, SDKs, and protocols so applications can send telemetry to tools such as Prometheus, Jaeger, or commercial platforms.
The difference from storage systems becomes clear when comparing OpenTelemetry vs Prometheus: OpenTelemetry deliberately leaves retention, querying, and dashboards to other systems. It was formed in the CNCF by merging OpenTracing and OpenCensus and reached CNCF graduated status in May 2026.
The project is free and open source under Apache 2.0, as described in the official OpenTelemetry documentation, and more than 90 observability vendors support it natively.
Recent milestones include continuous profiling entering public alpha, with profiles linked to trace and span IDs, and stable declarative configuration. Semantic conventions for generative AI and MCP workloads are still in development and are maintained in their own repository.
How OpenTelemetry Works
OpenTelemetry separates instrumentation from routing and storage by combining language APIs and SDKs, standard semantic conventions, the OpenTelemetry Protocol (OTLP), and a proxy pipeline called the OpenTelemetry Collector.
Libraries and applications import a lightweight API that defines how to record telemetry, while operators configure a separate SDK at startup that processes, aggregates, and exports it. Official SDKs cover C++, .NET, Go, Java, JavaScript, PHP, Python, Ruby, Rust, Swift, and more, with traces and metrics stable in the main languages. For code you cannot change, automatic instrumentation and eBPF-based zero-code instrumentation capture traces and metrics at the kernel level.
Telemetry travels over OTLP using gRPC on port 4317 or HTTP on port 4318. Small setups can export directly to a backend, but production systems route through the OpenTelemetry Collector, a vendor-agnostic proxy that handles retries, batching, encryption, and filtering so applications do not run several vendor agents.
The Collector can run as an agent on each host or as a Kubernetes DaemonSet, as a central gateway, or in a layered agent-to-gateway setup deployed with the Kubernetes Operator or Helm. Its pipelines are built from the components in the table below.
| Component | Role in the Collector | Example |
|---|---|---|
| Receivers | Ingest telemetry in various wire formats. | OTLP, Prometheus scrape, host metrics. |
| Processors | Transform, batch, filter, redact, and enrich data in flight. | Memory limiter, redaction, tail sampling. |
| Exporters | Send processed data to one or more backends. | Prometheus, Jaeger, commercial APM. |
| Connectors | Join two pipelines as exporter for one and receiver for the other. | Generate metrics from spans. |
| Extensions | Operational features outside the data path. | Health checks and service discovery. |
OpenTelemetry is the right foundation for distributed systems across several languages and when you want to control telemetry cost and routing without code changes: you can send data to Prometheus and a commercial APM at the same time, or switch vendors by editing Collector configuration. The most common production failure is the Collector running out of memory during traffic spikes or backend outages, as batch, sampling, and queue components buffer faster than exports drain. We put memory_limiter first in every pipeline with GOMEMLIMIT set, enforce semantic conventions from day one, build lean Collectors with the Collector Builder, and redact PII before data leaves the network.
Vendor-neutral observability framework
Traces, metrics, logs, and profiles (alpha)
Apache 2.0, CNCF graduated
OTLP over gRPC or HTTP
Years in business
Senior engineers
Projects delivered
What OpenTelemetry Is Used For
Software teams use OpenTelemetry to standardize instrumentation across languages, correlate traces with metrics, logs, and profiles, avoid vendor lock-in, and filter telemetry before it leaves their infrastructure.
Polyglot Microservice Instrumentation
Teams running services in .NET, Go, Java, Python, JavaScript, or Rust instrument everything with one set of semantic conventions, so engineers jump from a latency spike to the exact trace and CPU profile.
Vendor-Neutral Migration and Dual-Shipping
Code is instrumented once against OpenTelemetry APIs, and switching between more than 90 vendors, or sending metrics to Prometheus and traces to a commercial backend, is a Collector configuration change.
Zero-Code Observability for Legacy Services
For unmaintained services or compiled binaries, eBPF instrumentation and language agents capture network traffic, traces, metrics, and trace-log correlation without touching application code.
Telemetry Security and AI Workloads
The Collector acts as an egress gate that strips secrets and PII and controls volume with sampling. For AI applications, the in-development generative AI conventions record model calls and MCP tool use alongside normal traces.
OpenTelemetry vs Prometheus and Vendor Agents
OpenTelemetry is a multi-signal instrumentation and transport layer, Prometheus is a metrics collection and storage backend, and proprietary agents such as Datadog’s tie instrumentation to one commercial platform. Many teams combine OpenTelemetry with Prometheus.
| Criterion | |||
|---|---|---|---|
| Role & storage | Instrumentation and transport; no storage, query engine, or UI. | Complete metrics system with time-series database, query language, and alerting. | Vendor SDKs and agents tied to a commercial backend. |
| Signals | Traces, metrics, logs, baggage, and profiles (alpha). | Metrics only. | Multiple signals in proprietary schemas. |
| Collection model | Push over OTLP; can also expose scrape endpoints or push to Prometheus’s OTLP endpoint. | Pull-based scraping of /metrics, plus an OTLP receiver enabled with --web.enable-otlp-receiver. | Push through vendor protocols and forwarders. |
| Metric model | Cumulative or delta temporality; separate Gauge and UpDownCounter instruments. | Cumulative only; one Gauge type for values that go up and down. | Defined by the vendor. |
| Client libraries | No upfront label declaration; dotted names scoped to a meter. | Labels declared at registration; flat snake_case namespace. | Vendor-specific APIs and tags in code. |
| Portability | Routes to 90+ vendors or open-source tools without code changes. | Open standard for metrics exposition. | High lock-in; switching vendors means re-instrumenting. |
When to Choose OpenTelemetry
Choose OpenTelemetry when you want one instrumentation standard for traces, metrics, logs, and profiles across languages, and the freedom to route data to several backends without changing code. Even with Prometheus as the metrics database, services can use OpenTelemetry SDKs and either expose a scrape endpoint or push to Prometheus’s native OTLP endpoint.
When OpenTelemetry Is Not the Right Fit
OpenTelemetry alone cannot replace a monitoring backend, because it has no time-series database, trace store, query engine, or dashboards; pair it with Prometheus, Jaeger, or a commercial platform. If you only need metrics and rely on Prometheus client library behavior, such as pre-initializing series to zero or pre-bound label caching, native Prometheus clients remain simpler.
How We Approach OpenTelemetry Projects
We design OpenTelemetry pipelines that survive traffic spikes, enforce semantic conventions across .NET and polyglot services, and reduce telemetry volume before it reaches paid storage.
Memory-Safe Collector Pipelines
Production Kubernetes and cloud workloads use an agent-to-gateway topology that isolates applications from backend slowdowns. Every pipeline starts with memory_limiter and GOMEMLIMIT, followed by redaction and batching, so the Collector applies backpressure instead of crashing.
Lean, Hardened Collectors
We compile custom Collectors with the OpenTelemetry Collector Builder containing only the components a system uses, run them as non-root with TLS and authentication, and bind local agent receivers to localhost rather than every interface.
Clean Metrics and Conventions
SDKs across .NET, Go, Java, Python, and JavaScript follow stable semantic conventions, and every service sets unique service.name and service.instance.id attributes so Prometheus exports never collide into duplicate series.
Sound like the right partner?
Frequently Asked Questions
Direct answers to common architectural and operational questions about OpenTelemetry, the Collector, and Prometheus.
Does OpenTelemetry replace Prometheus?
No. OpenTelemetry has no time-series database, query language, alerting, or dashboards. It generates and routes telemetry, while Prometheus stores and analyzes metrics. The two CNCF projects are often used together: OpenTelemetry pushes metrics to Prometheus’s OTLP endpoint, which is enabled with the --web.enable-otlp-receiver flag, or exposes a scrape endpoint from the SDK or Collector.
How do you send OpenTelemetry metrics to Prometheus?
Either push OTLP metrics to Prometheus’s OTLP receiver, after enabling it with --web.enable-otlp-receiver, or configure a Prometheus exporter for Prometheus to scrape. During export, names are converted to Prometheus style, units are expanded, counters get a _total suffix, and service.name and service.instance.id become job and instance labels. Set unique values for both attributes to avoid duplicate series.
When should you use the Collector instead of exporting directly from an SDK?
In almost every production environment. Direct SDK exports suit small or local setups. Running the Collector as an agent, sidecar, DaemonSet, or gateway offloads batching, retries, encryption, and connections from your applications, and gives one place to redact PII and route data to several backends without redeploying code.
How do you prevent out-of-memory crashes in the Collector?
Put the memory_limiter processor first in every pipeline, before batch, transform, or tail sampling processors, and set Go’s GOMEMLIMIT. Crashes typically happen during traffic spikes, high-cardinality bursts, or backend slowdowns, when buffers fill faster than exporters flush. The memory limiter makes the Collector refuse new data before memory runs out.
Which signals does OpenTelemetry support?
Traces, metrics, logs, baggage, and continuous profiles. Traces and metrics are stable in the main languages, including C++, .NET, Go, Java, JavaScript, PHP, and Python. Profiles are in public alpha, with a format compatible with pprof and samples linked to trace and span IDs.