Introduction

Jaeger is a distributed tracing system designed by Uber and adopted by the Cloud Native Computing Foundation (CNCF). It is widely used for monitoring and troubleshooting microservices architectures by enabling end-to-end tracing of requests across multiple services.

This article explains:
✅ Jaeger’s architecture and its core components
✅ How Jaeger components work together in the backend
✅ How traces flow through Jaeger
✅ Storage backends for Jaeger

📌 Key Components of Jaeger Architecture

Jaeger consists of five main components:

1. Jaeger Client (Instrumentation Library)

2. Jaeger Agent

3. Jaeger Collector

4. Jaeger Query Service

5. Jaeger Storage (Database Backend: Elasticsearch, Cassandra, ClickHouse, etc.)

Each component plays a specific role in trace collection, processing, and visualization. Let’s explore them in detail.

1️⃣ Jaeger Client (Instrumentation Library)

💡 What is it?

• The Jaeger Client is a library that instruments applications to generate traces and spans.

• It is embedded in application code and propagates trace context across microservices.

🔹 How does it work?

1. Instrumentation: Jaeger Client injects trace IDs into requests and propagates them using HTTP headers (traceparent, tracestate) or gRPC metadata.

2. Span Creation: When a request starts, a root span is created.

3. Context Propagation: As the request moves across microservices, child spans are created and linked to the root span.

4. Data Collection: Trace data is sent asynchronously to the Jaeger Agent.

🔹 Supported Languages:
✅ OpenTelemetry SDK (Jaeger supports OpenTelemetry instrumentation)
✅ Jaeger Clients for Java, Go, Python, Node.js, C++, .NET, etc.

✅ Example (Python - OpenTelemetry Jaeger Client):

from opentelemetry import trace
from opentelemetry.exporter.jaeger.thrift import JaegerExporter
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import SimpleSpanProcessor

trace.set_tracer_provider(TracerProvider())
tracer = trace.get_tracer(__name__)

jaeger_exporter = JaegerExporter(agent_host_name="jaeger-agent", agent_port=6831)
trace.get_tracer_provider().add_span_processor(SimpleSpanProcessor(jaeger_exporter))

with tracer.start_as_current_span("process-order"):
    print("Processing order...")

2️⃣ Jaeger Agent

💡 What is it?

• The Jaeger Agent is a lightweight daemon running as a sidecar or DaemonSet in Kubernetes.

• It receives trace data from Jaeger Clients and forwards it to the Jaeger Collector.

🔹 How does it work?

1. Listens for spans on UDP ports (6831, 6832).

2. Buffers spans before forwarding them to the Jaeger Collector.

3. Performs sampling if configured.

🔹 Deployment in Kubernetes (as DaemonSet):

apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: jaeger-agent
  namespace: observability
spec:
  selector:
    matchLabels:
      app: jaeger-agent
  template:
    metadata:
      labels:
        app: jaeger-agent
    spec:
      containers:
      - name: jaeger-agent
        image: jaegertracing/jaeger-agent
        args: ["--reporter.grpc.host-port=jaeger-collector:14250"]
        ports:
        - containerPort: 6831

3️⃣ Jaeger Collector

💡 What is it?

• The Jaeger Collector receives spans from Jaeger Agents and processes them before storing them in the database backend.

🔹 How does it work?

1. Receives spans from Agents or OpenTelemetry Collectors.

2. Validates and processes trace data.

3. Sends traces to storage (Elasticsearch, Cassandra, ClickHouse, etc.).

🔹 Collector Deployment in Kubernetes:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: jaeger-collector
  namespace: observability
spec:
  replicas: 2
  selector:
    matchLabels:
      app: jaeger-collector
  template:
    metadata:
      labels:
        app: jaeger-collector
    spec:
      containers:
      - name: jaeger-collector
        image: jaegertracing/jaeger-collector
        args: ["--es.server-urls=http://elasticsearch:9200"]
        ports:
        - containerPort: 14250

4️⃣ Jaeger Query Service

💡 What is it?

• The Jaeger Query Service provides a web-based UI for searching and visualizing traces.

🔹 How does it work?

1. Reads trace data from the storage backend (e.g., Elasticsearch, Cassandra).

2. Provides an API for querying and filtering traces.

3. Integrates with Grafana for visualizations.

🔹 Access Jaeger UI in Kubernetes:

kubectl port-forward svc/jaeger-query 16686:16686 -n observability

Then, open localhost:16686.

5️⃣ Jaeger Storage (Backend Database)

💡 What is it?

• Stores traces and spans collected by Jaeger.

• Elasticsearch is the most recommended storage for production.

🔹 Supported Storage Backends:
✅ Elasticsearch (Scalable for large traces)
✅ Cassandra (Highly available, but slower queries)
✅ ClickHouse (Fast, but less common)
✅ Kafka (Used as a buffer before indexing in a database)

🔹 Deploying Jaeger with Elasticsearch in Kubernetes:

helm repo add elastic https://helm.elastic.co
helm install elasticsearch elastic/elasticsearch
helm install jaeger jaegertracing/jaeger --set storage.type=elasticsearch --set storage.elasticsearch.host="http://elasticsearch:9200"

📌 How Data Flows in Jaeger Backend

Step-by-step trace flow in a microservices architecture:

1. Application generates a trace via the Jaeger Client (OpenTelemetry SDK).

2. Trace is sent to the Jaeger Agent, which buffers and batches spans.

3. Jaeger Agent forwards spans to Jaeger Collector for processing.

4. Jaeger Collector stores trace data in a backend (e.g., Elasticsearch, Cassandra, ClickHouse).

5. Jaeger Query Service reads traces from storage and displays them in the Jaeger UI.

📌 Why Use Jaeger for Observability?

• Scales easily for high-volume microservices logs.

• Supports OpenTelemetry for industry-wide compatibility.

• Enables detailed root-cause analysis of distributed transactions.

• Integrates with Prometheus, Grafana, and Kubernetes.

• Provides deep insights into API performance, errors, and dependencies.

Conclusion

Jaeger is a powerful distributed tracing tool that provides end-to-end observability for microservices and Kubernetes applications. By leveraging Jaeger Clients, Agents, Collectors, and Storage, DevOps teams can monitor, debug, and optimize complex distributed applications efficiently.

With Jaeger integrated into your Kubernetes environment, you gain full visibility into latency issues, error propagation, and system performance bottlenecks—making it a must-have for modern cloud-native observability. 🚀