← Back to Articles

Distributed Tracing: Following a Request Through the Chaos

4 min read

In a monolith, debugging is straightforward: follow the stack trace. In microservices, your stack trace ends at the network boundary. Now what?

The Problem

Picture this: a user clicks "checkout" and waits. And waits. Eventually, the page times out.

In a monolithic application, you'd check one set of logs. But in microservices, that checkout request touched:

  • The API gateway
  • The authentication service
  • The cart service
  • The inventory service
  • The payment provider
  • The order service
  • The notification service

Seven services. Each has its own logs. Which one caused the timeout? Good luck finding out.

The Solution: Trace IDs

Distributed tracing works by assigning a unique ID to each request as it enters your system. That ID gets passed along as the request moves from service to service.

Now, instead of searching seven log files, you search for one ID. Every log entry, error message, and metric tagged with that ID tells part of the story.

What a Trace Looks Like

A trace is a tree of "spans." Each span represents one unit of work:

checkout-api 0ms - 850ms
├── auth-service 10ms - 55ms
├── cart-service 60ms - 120ms
├── payment-provider 125ms - 780ms ⚠️ SLOW
└── order-service 785ms - 845ms

One glance: the payment provider took 655ms. That's 77% of the total request time. You've found your bottleneck.

What You Can Learn

Traces answer questions that logs and metrics can't:

  • Where did this request slow down? — See timing for each service hop
  • What order did things happen? — Trace the causal chain
  • Which service threw the error? — Find where the failure originated, not just where it surfaced
  • Is it always slow, or just sometimes? — Compare traces to find patterns

The Practical Impact

Without tracing, debugging microservices is archaeology. You piece together fragments from different logs, hoping they're from the same request. With tracing, you have a map.

Teams with good tracing solve incidents faster, understand their systems better, and spend less time on frustrating debugging sessions.

Getting Started

Most modern frameworks support distributed tracing through OpenTelemetry. The basics:

  1. Instrument your services to generate spans
  2. Propagate trace context in HTTP headers
  3. Send traces to a collector (Jaeger, Zipkin, or a commercial platform)
  4. Query traces when debugging

The initial setup takes effort. The debugging time it saves makes it worthwhile.