explaingit

jaegertracing/jaeger

📈 Trending22,814GoAudience · ops devopsComplexity · 4/5ActiveLicenseSetup · hard

TLDR

Distributed tracing system that tracks user requests across multiple services to find slowdowns and errors in complex software systems.

Mindmap

mindmap
  root((Jaeger))
    What it does
      Tracks requests across services
      Records spans and timelines
      Visualizes request flow
    How it works
      Instruments application code
      Collects span data
      Stores traces in backend
    Use cases
      Debug microservices issues
      Find performance bottlenecks
      Monitor distributed systems
    Tech stack
      Go
      OpenTelemetry
      Web UI
    Audience
      DevOps engineers
      Backend developers
      System operators

Things people build with this

USE CASE 1

Debug which service in a microservices system is causing a request to be slow.

USE CASE 2

Track a user request through multiple services to find where an error occurred.

USE CASE 3

Monitor and visualize the performance of requests flowing through a Kubernetes-deployed system.

USE CASE 4

Identify bottlenecks in complex multi-service architectures before they impact users.

Tech stack

GoOpenTelemetryKubernetesgRPC

Getting it running

Difficulty · hard Time to first run · 1day+

Requires Kubernetes cluster, multiple service deployments, and OpenTelemetry instrumentation across services to see meaningful tracing data.

Use freely for any purpose, including commercial use, as long as you keep the copyright notice and license text.

In plain English

Jaeger is a distributed tracing system, a tool for understanding what happens inside complex software systems made up of many services working together. When a user request flows through multiple services (for example, a web app that calls a database, an authentication service, and a payment processor), something can go wrong or be slow at any point. Tracing lets you follow that request's journey from start to finish and see exactly where time was spent or where errors occurred. The problem it solves: in traditional single-application software, debugging is straightforward, you look at one log file. In modern systems made of many interconnected services (called microservices), a single user action might touch dozens of services, and finding the source of a slowdown or failure is like tracking a package through a supply chain with no tracking number. Jaeger gives you that tracking number. How it works: your application code is instrumented (meaning small pieces of code are added) to record "spans", units of work with start times, end times, and metadata. These spans are sent to a Jaeger collector, which stores them. You can then use Jaeger's web UI to search for traces, visualize the full timeline of a request, and pinpoint which service caused a delay or error. You would use Jaeger when operating or debugging a system built from multiple services, especially one deployed with Kubernetes or similar infrastructure. The tech stack is Go, with OpenTelemetry support for instrumentation.

Copy-paste prompts

Prompt 1
How do I instrument my Go application to send traces to Jaeger?
Prompt 2
Show me how to set up a Jaeger collector and query traces from the web UI.
Prompt 3
How can I use Jaeger to find which microservice is causing high latency in my system?
Prompt 4
What's the difference between a span and a trace in Jaeger, and how do I create them in my code?
Prompt 5
How do I deploy Jaeger in Kubernetes and connect my services to it?
Open on GitHub → Explain another repo

Generated 2026-05-18 · Model: sonnet-4-6 · Verify against the repo before relying on details.