Observabilityintermediate

Jaeger vs Grafana Tempo

Jaeger vs Grafana Tempo compared for 2026: Jaeger 2.23 (Apache-2.0, CNCF graduated, built on the OpenTelemetry Collector, Cassandra/Elasticsearch/OpenSearch storage, its own UI) vs Tempo 3.1 (AGPL-3.0, object storage only, Parquet blocks, TraceQL, queried through Grafana). Includes a run we did sending the same 20,000 spans to both, Grafana Cloud Traces prices, sizing, sampling, service maps and a clear pick per situation.

Quick Answer

Jaeger and Grafana Tempo are the two main open-source distributed tracing backends, and both accept OpenTelemetry (OTLP), Jaeger and Zipkin data. Jaeger 2.23.0 (5 November 2026, Apache-2.0, CNCF graduated) is a customised OpenTelemetry Collector distribution with its own web UI, storing traces in Cassandra, Elasticsearch or OpenSearch, with ClickHouse experimental and Badger for single-node setups. Tempo 3.1.1 (21 October 2026, AGPL-3.0) stores everything as Apache Parquet blocks in S3, GCS or Azure, is queried with TraceQL, and has no UI of its own: you use Grafana. In our run on 19 November 2026, both found exactly the 241 traces with a slow Postgres span out of 5,000; only Tempo could answer 'slow database call under the /pay route' in one query, while Jaeger needed us to download 423 KB of traces and filter them ourselves. Pick Jaeger if you already run Elasticsearch/OpenSearch or Cassandra, want a standalone tracing UI with adaptive sampling, or need a permissive licence; pick Tempo if you run Grafana, want cheap object storage at high volume, or want TraceQL and metrics from traces.

Last updated November 19, 2026. Covers Jaeger 2.23.0 (5 November 2026) and Grafana Tempo 3.1.1 (21 October 2026) with their current docs, Tempo 3.0 release notes and Grafana Cloud pricing, all read on 19 November 2026, plus a side-by-side ingest and query run we did the same day.

Feature comparison of Jaeger vs Grafana Tempo
FeatureJaegerGrafana Tempo
Licence & Governance
Apache-2.0; CNCF graduated; jaegertracing/jaeger ~23.4k stars
AGPL-3.0; Grafana Labs; grafana/tempo ~5.6k stars
Latest Release (Nov 2026)
2.23.0 on 5 Nov 2026 (monthly-ish cadence; v1 EOL 31 Dec 2025, last 1.76)
3.1.1 on 21 Oct 2026 (also 3.0.5 and 2.10.10 that day); 3.0.0 on 28 May 2026
Architecture
One OpenTelemetry Collector-based binary; roles collector, query, ingester, all-in-one
One binary, -target per component; monolithic (no Kafka) or microservices (Kafka-compatible queue)
Trace Storage
Cassandra 4.x/5.x, Elasticsearch 7/8, OpenSearch 1.0+; ClickHouse experimental; Badger (single node); memory; remote gRPC storage API
Amazon S3 and S3-compatible (MinIO etc.), Google Cloud Storage, Azure Blob; local filesystem for dev/test
On-disk Format
Backend-specific schema (Cassandra tables, Elasticsearch/OpenSearch indices)
Apache Parquet blocks with bloom filters
Ingest Protocols
OTLP gRPC/HTTP, Jaeger gRPC/Thrift (legacy), Zipkin v1/v2, Kafka
OTLP gRPC/HTTP, Jaeger (Thrift and gRPC), Zipkin, Kafka receivers
Query Language / Search
Search by service, operation, tags, duration and time; API v3 (OTLP-based gRPC and JSON)
Trace ID lookup and TraceQL search; TraceQL metrics (rate, quantiles, comparisons)
Cross-span (Structural) Queries
No; filter in the client after search
Yes: TraceQL structural operators such as >> (descendant)
User Interface
Built-in React UI on port 16686; embedded mode used by the Jaeger plugin for Grafana
None built in; Grafana Tempo data source, Traces Drilldown app, HTTP API, tempo-cli
Metrics From Traces
SPM: spanmetrics connector plus Prometheus-compatible store; Monitor tab with RED metrics
TraceQL metrics (GA in 3.0, alerting experimental) and metrics-generator (RED, service graphs)
Service Dependency Graph
In-memory: on the fly; distributed storage: spark-dependencies job
Metrics-generator service graphs, shown in Grafana
Sampling
Remote sampling (file or adaptive), tail sampling processor; default 0.1% if no strategy file
Done upstream in OpenTelemetry SDKs or Collector; metrics-generator has a span multiplier for sampled data
Retention
Backend-specific: Cassandra TTL (schema default trace_ttl 48h); Elasticsearch/OpenSearch via index rotation or es-index-cleaner
block_retention, default 336h (14 days), enforced by backend workers
Write Durability / Buffering
Optional Kafka between collectors and ingesters; drops data if storage cannot keep up
Microservices: write acknowledged after Kafka; RF1 with no object-store duplication
Scaling Model
Stateless collectors and query; scale the database
Per component: e.g. 1 distributor per 10 MB/s, 1 querier per 1-2 MB/s (docs' starting point)
Multi-tenancy
No built-in tenant isolation in the UI
Yes, X-Scope-OrgID per request
Authentication
OpenTelemetry Collector authenticators (e.g. basicauth) or a reverse proxy
Tenant header only in the configuration we read; plan an authenticating gateway in front
Managed Option & Price
No first-party hosted service; third-party vendors not priced here
Grafana Cloud Traces: Free 50 GB/month, 14 days; Pro from $19/month + $0.05 process, $0.40 write, $0.10 retain per GB; Enterprise from $25,000/year
AI / MCP
MCP server and AG-UI-based AI assistant
MCP server and LLM-optimised APIs per the docs
Our Run: 5,000 traces, 20,000 spans
241/241 slow-span traces in 12 ms; structural query needed client-side filtering; ~183 MB RSS (memory storage)
241/241 in 45-63 ms; structural 77/77 in one query (36-39 ms); ~146 MB RSS; 1.43 MB Parquet block

Jaeger

Jaeger is a distributed tracing platform open-sourced by Uber in 2016 and donated to the CNCF, where it was one of the first graduated projects. Jaeger v2, released in November 2024, is a single binary built on the OpenTelemetry Collector framework that can run as collector, query, ingester or all-in-one, writing to Cassandra, Elasticsearch, OpenSearch, Badger, memory or a remote gRPC storage plugin. Jaeger v1 reached end of life on 31 December 2025.

Pros

  • Apache-2.0 and CNCF-governed, with no copyleft obligations for internal modifications or hosting
  • Own web UI with trace timeline, graph, flame graph, statistics, deep dependency graph and a GenAI span view
  • Built on the OpenTelemetry Collector, so tail sampling, attribute redaction and Kafka buffering are standard components
  • Remote sampling with per-service and per-operation strategies, including adaptive sampling computed from traffic
  • Fast lookups in our test: 12 ms to return the 241 slow-span traces from in-memory storage
  • Ships an MCP server and AI assistant that narrow down suspicious spans without loading a whole trace

Cons

  • Needs a database cluster for production: OpenSearch/Elasticsearch (recommended) or Cassandra, each with its own operations burden
  • Search is per span (service, operation, tags, duration); cross-span conditions have to be filtered client-side
  • Service maps on distributed storage need a separate Spark (or experimental Flink) job
  • Service Performance Monitoring needs a Prometheus-compatible metrics store alongside
  • No accounts or roles in the UI: authentication is basic auth or a reverse proxy, with no per-team isolation

Best For

Teams that already run Elasticsearch, OpenSearch or Cassandra, want a standalone tracing UI without Grafana, need adaptive or remote sampling control, or need a permissive licence for an internal platform.

Grafana Tempo

Grafana Tempo is an open-source, high-scale distributed tracing backend from Grafana Labs. It stores trace data only in object storage as Apache Parquet blocks, queries it with TraceQL, and can derive RED metrics and service graphs from traces. Tempo 3.0 (May 2026) replaced ingesters and the compactor with a Kafka-backed write path in microservices mode, while monolithic mode runs everything in one process without Kafka.

Pros

  • Object storage only (S3, GCS, Azure Blob): no Elasticsearch or Cassandra cluster to run
  • TraceQL handles cross-span queries; our 'slow DB call under /pay' query returned the exact 77 traces in one call
  • Compact storage: our 20,000 spans (7.2 MB of OTLP JSON) became a 1.43 MB Parquet block
  • TraceQL metrics GA since 3.0, plus an optional metrics-generator for RED metrics and service graphs
  • Built-in multi-tenancy via the X-Scope-OrgID header
  • Grafana Cloud Traces has a free tier (50 GB a month, 14-day retention) if you would rather not self-host

Cons

  • AGPL-3.0: offering a modified Tempo as a network service carries source-sharing obligations
  • No UI of its own: you need Grafana (Explore, Traces Drilldown) or the HTTP API and tempo-cli
  • Microservices mode, recommended for production, requires a Kafka-compatible system
  • Monolithic mode cannot run as more than one instance and is sized for up to about 25-35 MB/s
  • In our default single-binary setup, TraceQL metrics returned nothing until the metrics-generator is configured, and live-store data landed in /var/tempo

Best For

Teams already on Grafana, high-volume tracing where object storage cost matters, platform teams serving many tenants, and anyone who wants TraceQL and metrics derived from traces.

Storage model: a database you run versus object storage

This is the decision that drives everything else. Jaeger writes to a database: Cassandra 4.x or 5.x, Elasticsearch 7/8 or OpenSearch 1.0+, with ClickHouse marked experimental. Jaeger's own FAQ recommends Elasticsearch or OpenSearch over Cassandra, because Cassandra is key-value and Jaeger has to implement search on top of it with heavy write amplification; the storage page recommends OpenSearch for large production deployments. Cassandra's advantage is native TTL (the auto-created schema defaults to a 48-hour trace TTL), whereas Elasticsearch and OpenSearch need index rotation or the jaeger-es-index-cleaner job. Badger gives you a persistent single-node store inside the binary, fine for small installs but not horizontally scalable. Tempo writes only to object storage: S3 and compatibles such as MinIO, Google Cloud Storage or Azure Blob, as Apache Parquet blocks with bloom filters, and its retention default is 14 days. There is no index cluster to size, patch or rebalance, and storage is billed at object-store prices. The cost is query latency on older data, which comes from fetching Parquet columns rather than hitting an index. If you already pay for and know how to run OpenSearch, Jaeger reuses that skill; if you do not, Tempo removes a whole class of operations work.

Querying: tag search versus TraceQL

Jaeger's search is span-shaped: service, operation, tags, minimum and maximum duration and a time window, returning whole traces. It is quick and familiar, and API v3 returns OTLP-shaped JSON. What it cannot do is relate spans to each other. Tempo's TraceQL selects spans by resource and span attributes, status, duration and kind, and adds structural operators. In our run we wanted traces where the frontend served /pay and a Postgres span below it took at least 300 ms. In Tempo that was one query, { resource.service.name = "frontend" && span.http.route = "/pay" } >> { span.db.system = "postgresql" && duration >= 300ms }, which returned 77 traces in under 40 ms. Jaeger could find the 241 traces with a slow Postgres span, but we had to download them (423 KB of JSON) and filter for /pay in a script to get the same 77. TraceQL metrics, generally available since Tempo 3.0, go further: rate(), quantiles and comparison operators computed from trace data, with alerting on them still experimental. Jaeger's equivalent for aggregate views is Service Performance Monitoring, which needs the spanmetrics connector and a Prometheus-compatible store.

Running it: roles, Kafka and sizing

Jaeger v2 is one binary configured by YAML. All-in-one with in-memory storage starts with no config at all, which is how we ran it; production usually splits collector and query, both stateless, and optionally puts Kafka between collectors and an ingester so a slow database does not drop spans. The Jaeger FAQ is blunt that adding collectors does not prevent data loss when storage cannot keep up. Because it is an OpenTelemetry Collector distribution, you can add standard processors (tail sampling, attributes for redaction, filter) or build a custom distribution with the Collector Builder. Tempo also ships as one binary with a -target flag. Monolithic mode needs no Kafka and the docs size it for up to about 25-35 MB/s or 55,000-80,000 spans/s, but only one instance can run because the backend scheduler is a singleton. Microservices mode, recommended for production, requires Kafka, Redpanda, WarpStream or another Kafka-compatible system and splits distributors, live-stores, block-builders, queriers and backend workers. The docs' starting point is one distributor per 10 MB/s and one querier per 1-2 MB/s of ingest. Tempo 3.0 moved to replication factor 1, which the release notes say removes the 2 to 2.5 times object-store duplication of the old RF3 design.

Cost and licensing

Both are free to self-host, so the real cost is infrastructure and people. For Jaeger, that is the database: an OpenSearch or Cassandra cluster sized for write throughput and search, plus Kafka if you buffer. For Tempo, it is object storage, a modest set of stateless pods and, in microservices mode, Kafka. Licensing differs more than people expect. Jaeger is Apache-2.0 under CNCF governance. Tempo is AGPL-3.0: using it internally, even modified, is fine, but if you modify Tempo and let others interact with it over a network, the AGPL requires offering them the source of your changes. That matters for vendors and internal platform teams that fork. On the hosted side, Jaeger has no first-party service. Grafana Cloud Traces, the managed Tempo, lists a Free tier with 50 GB ingested per month and 14-day retention, and a Pro tier starting at $19 per month plus usage, with traces starting at $0.05 per GB processed, $0.40 per GB written and $0.10 per GB retained, and 30-day retention; Enterprise starts at a $25,000 yearly commit. Those are list starting rates read on 19 November 2026 and are volume-discounted, so model your own ingest rather than multiplying them blindly.

Worked example: the same 20,000 spans into both

On 19 November 2026 we downloaded Jaeger 2.23.0 and Tempo 3.1.1 for linux-amd64, checked both SHA-256 sums against the projects' checksum files and ran them on a 2-vCPU cloud sandbox: Jaeger as all-in-one with memory storage, Tempo monolithic with a 16-line config pointing at a local directory. A script sent one identical OTLP/HTTP JSON batch to each: 5,000 traces of four spans across frontend, checkout and payments, 7.2 MB in all, with about 5% slow Postgres spans and 3% errors. Both accepted all 20,000 spans and both returned exactly the 241 traces with a Postgres span of 300 ms or more, Jaeger in 12 ms and Tempo in 45-63 ms. Tempo answered the structural /pay query directly (77 traces); Jaeger needed client-side filtering to get the same 77. Tempo returned 150 traces for { status = error }. After ingest Tempo used about 146 MB of RAM and Jaeger about 183 MB, mostly because memory storage keeps every span in RAM. Tempo flushed a 1.43 MB Parquet block. Two gotchas: Tempo's TraceQL metrics returned no series because the metrics-generator stays disabled without a storage path, and the live-store wrote to /var/tempo outside our configured paths, so a restart served stale traces until we cleared it.

Verdict

Pick Jaeger when you already operate Elasticsearch, OpenSearch or Cassandra and want traces next to that investment, when you want a dedicated tracing UI without adopting Grafana, when you need centrally managed head sampling (per-service strategies or adaptive sampling) handed to SDKs, or when your legal team prefers Apache-2.0 over AGPL for a platform you modify and host. Run all-in-one with Badger for small setups, and split collector and query with OpenSearch plus optional Kafka as volume grows. Pick Tempo when you run Grafana already (especially with Loki and Prometheus or Mimir), when trace volume is high enough that a search cluster becomes the biggest line item, when you need tenants isolated on one backend, or when engineers will ask cross-span questions that TraceQL answers directly. Start monolithic with object storage, configure the metrics-generator from day one if you want RED metrics or TraceQL metrics on recent data, and move to microservices mode with a Kafka-compatible queue once you need high availability. If you do not want to run either, Grafana Cloud Traces is the only first-party hosted option of the two, with a 50 GB monthly free tier.

All Comparisons

Jaeger vs Grafana Tempo — FAQ

Common questions answered from the comparison above

Is Grafana Tempo better than Jaeger?

For high volume on object storage, Grafana users and cross-span queries, Tempo usually fits better. For teams with existing OpenSearch or Cassandra, a standalone tracing UI, adaptive sampling or a need for Apache-2.0, Jaeger does. Both ingest OTLP, so instrumentation does not lock you in.

Can Grafana show Jaeger traces?

Yes. Jaeger's UI has an embedded mode that the Jaeger plugin for Grafana uses to show trace search and trace views in dashboard panels. Tempo, by contrast, has no UI of its own and is designed to be used from Grafana.

Does Tempo need Kafka?

Not in monolithic mode, which runs everything in one process. Microservices mode, which the docs recommend for production and high availability, requires a Kafka-compatible system such as Apache Kafka, Redpanda or WarpStream.

What storage does Jaeger use in 2026?

Cassandra 4.x/5.x, Elasticsearch 7/8 and OpenSearch 1.0+ are the primary distributed backends, with OpenSearch recommended for large deployments. ClickHouse is experimental, Badger covers single-node setups, memory is for testing, and a remote gRPC API supports community backends such as PostgreSQL.

Is Jaeger v1 still supported?

No. Jaeger v1 reached end of life on 31 December 2025; the last v1 images are 1.76. Jaeger v2, built on the OpenTelemetry Collector, is the supported line, at 2.23.0 as of 5 November 2026.

Can I migrate from Jaeger to Tempo without re-instrumenting?

Usually yes. Tempo accepts OTLP, Jaeger (Thrift and gRPC) and Zipkin, so you can point existing exporters or an OpenTelemetry Collector at Tempo. Stored Jaeger data does not move automatically; most teams run both until the old retention window expires.

Get the next comparison by email

One email a week: new and trending developer tools, fresh comparisons, and what shipped. Unsubscribe in one click.