Free and Open Source Distributed Tracing Tools

The best tracing tools can help you eliminate performance bottlenecks and recover from incidents faster. Use our guide to pick the right one for you.

Distributed tracingopen in new window tools allows you to see how a request progresses through different services and systems, timings of each operation, any logs and errors as they occur.

In a distributed environment, tracing tools also help you understand relationships and interactions between microservices. Tracing tools gives an insight into how a particular microservice is performing and how that service affects other microservices.

Using tracing, you can break down requests into . Span is an operation (unit of work) your app performs handling a request, for example, a database query or a network call.

Trace is a tree of spans that shows the path that a request makes through an app. Root span is the first span in a trace.

To learn more about tracing, see Distributed tracing using OpenTelemetryopen in new window.

is a vendor-neutral standard that allows you to collect and export tracesopen in new window, , and metricsopen in new window.

OpenTelemetry is available for most programming languages and allows to send performance data to any of your choice.

OpenTelemetry is a community-driven open source project that offers several components:

• OpenTelemetry API is a programming interface that you can use to instrument codeopen in new window and collect telemetry data.

• OpenTelemetry SDK is the official implementation of OpenTelemetry API that processes and exports collected telemetry to backends.

• is a proxy between your application and a backend. It receives telemetry data, transforms it, and then exports data to backends that can store it permanently. Collector can also act as an agent that pulls telemetry data from monitored systems, for example, Redisopen in new window or filesystem metrics.

• OTLP is the OpenTelemetry protocol used by SDK and Collector to export data to backends or other collectors. As a transport, OTLP can use gRPC (OTLP/gRPC) or HTTP (OTLP/HTTP).

is an OpenTelemetry tracing tool that monitors performance, errors, and logs. Main features include an intuitive query builder, rich dashboards, percentiles, users and projects management.

Tech stack:

• Backend: Go
• Frontend: Vue.js
• Instrumentation: OpenTelemetry / OTLP
• Storage: ClickHouse with S3

Pros:

• Rich UI with charts
• Advanced filtering capabilities
• Simple setup with ClickHouse being the only dependency
• OpenTelemetry support including pre-configured distros

Cons:

• ClickHouse is the only supported DBMS
• Metrics are supported only in the Uptrace Cloud version

Jaeger

is a distributed tracing platform created by Uber Technologies. It can be used for monitoring microservices-based distributed systems.

Tech stack:

• Backend: Go
• Frontend: React
• Instrumentation: OpenTelemetry / OTLP

Pros:

• Stable and well-known project
• Adaptive sampling
• Support for multiple DBMS via plugins
• Sponsored by CNCF

Cons:

• No charts / percentiles
• Limited filtering capabilities
• Not all plugins are maintained and usable
• ClickHouse support requires a plugin

Sentryopen in new window tracks your software performance, measures metrics like throughput and latency, and displays the impact of errors across multiple systems.

Tech stack:

• Backend: Python
• Frontend: React
• Instrumentation: Sentry SDK
• Storage: Kafka, Redis, PostgreSQL, ClickHouse

Pros:

• Excellent errors monitoring
• Quality SDK
• Friendly UI

Cons:

• Complex setup
• No OpenTelemetry support
• The UI is built around errors monitoring

SkyWalking

SkyWalkingopen in new window is an open source APM system, including monitoring, tracing, diagnosing capabilities for distributed system in Cloud Native architecture.

Tech stack:

• Backend: Java
• Frontend: Vue.js
• Instrumentation: SkyWalking
• Storage: ElasticSearch, MySQL, TiDB, InfluxDB, and more

• Rich UI with charts
• Good metrics support (including dashboards)
• Alarms
• Support for multiple DBMS

Cons:

• Complex setup
• Complex and overloaded UI
• OpenTelemetry support requires OpenTelemetry Collector

is an open-source APM. It helps developers monitor their applications & troubleshoot problems.

Tech stack:

• Backend: Go
• Frontend: React
• Instrumentation: OpenTelemetry / OTLP
• Storage: ClickHouse

Pros:

• Native OpenTelemetry support
• Rich UI with charts
• Metrics support using Prometheus as a backend and custom UI
• Alarms

Cons:

• There are a lot features, but the UI is not very friendly and only supports basic functionality

Zipkin

is a distributed tracing system. It helps gather timing data needed to troubleshoot latency problems in service architectures. Features include both the collection and lookup of this data.

Zipkin’s UI is minimalistic, but you can replace it with Grafana/Kibana configured to work with Zipkin data source.

Tech stack:

• Backend: Java
• Frontend: React
• Instrumentation: Zipkin span model; OpenTelemetry via adapter
• Storage: MySQL, Cassandra, or Elasticsearch.

Pros:

• Stable and well-known project
• Support for multiple DBMS

Cons:

• No active development
• Limited UI and filtering capabilities
• OpenTelemetry support requires an adapter
• No ClickHouse support

Grafana Tempoopen in new window is an open source, easy-to-use, and high-scale distributed tracing backend. Tempo is cost-efficient, requiring only object storage to operate, and is deeply integrated with Grafana, Prometheus, and Loki. Tempo can ingest common open source tracing protocols, including Jaeger, Zipkin, and OpenTelemetry.

Tech stack:

• Backend: Go
• Frontend: React
• Instrumentation: OpenTelemetry / OTLP
• Storage: Grafana Tempo

Pros:

• Integration with Grafana metrics dashboard
• OpenTelemetry support

• The UI is built around metrics and feels awkward / clumsy for everything else
• Limited filtering capabilities

If you looking for a paid tracing tool in the cloud, see our guide for .