Request ID: The Case Number for Distributed Systems

[ServiceA] 10:23:45 User requested order
[ServiceB] 10:23:46 Inventory check succeeded
[ServiceC] 10:23:46 Payment call failed
[ServiceA] 10:23:47 Order failed
[ServiceB] 10:23:47 Another user's request...
[ServiceC] 10:23:47 Yet another user's request...

User Request ──▶ ServiceA ──▶ ServiceB ──▶ ServiceC ──▶ Database
      │            │           │           │
      └────────────┴───────────┴───────────┘
                  Same Request ID

// Recommended: UUID v4
requestID := uuid.New().String()  // "550e8400-e29b-41d4-a716-446655440000"

// Or: Snowflake algorithm (ordered + unique)
requestID := snowflake.Generate()  // "1234567890123456789"

// Not recommended: Timestamp (collisions under high concurrency)
requestID := time.Now().UnixNano()  // Dangerous!

┌─────────┐     ┌─────────┐     ┌─────────┐
│Service A│────▶│Service B│────▶│Service C│
│X-Req-ID │     │X-Req-ID │     │X-Req-ID │
│=abc123  │     │=abc123  │     │=abc123  │
└─────────┘     └─────────┘     └─────────┘

// Service A: Generate and pass
func handler(w http.ResponseWriter, r *http.Request) {
    requestID := uuid.New().String()
    r.Header.Set("X-Request-ID", requestID)
    // Call downstream services...
}

// Service B: Receive and continue passing
func handler(w http.ResponseWriter, r *http.Request) {
    requestID := r.Header.Get("X-Request-ID")
    // Log...
    // Continue passing when calling downstream...
}

// Use metadata for propagation
md := metadata.Pairs("x-request-id", requestID)
ctx := metadata.NewOutgoingContext(context.Background(), md)

User ──▶ API Gateway ──▶ ServiceA ──▶ ServiceB
              │
              ▼
          Generate Request ID
              │
              └──────────┴──────────▶ All services use the same ID

# Nginx configuration
location / {
    set $request_id $request_id;  # Use Nginx built-in variable
    proxy_set_header X-Request-ID $request_id;
    proxy_pass http://backend;
}

// Gin middleware example
func RequestIDMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        // Prefer upstream-provided ID
        requestID := c.GetHeader("X-Request-ID")
        if requestID == "" {
            requestID = uuid.New().String()
        }

        // Store in context for later use
        c.Set("requestID", requestID)

        // Return in response header for debugging
        c.Header("X-Request-ID", requestID)

        c.Next()
    }
}

// Use structured logging
log := logger.WithField("request_id", requestID)

// All logs automatically carry request_id
log.Info("Query inventory")   // {"level":"info","request_id":"abc123","msg":"Query inventory"}
log.Error("Payment failed")   // {"level":"error","request_id":"abc123","msg":"Payment failed"}

X-Request-ID      # Most common in industry
X-Trace-ID        # Tracing systems
X-Correlation-ID  # Correlation ID

{
  "timestamp": "2026-03-19T10:23:45.123Z",
  "level": "ERROR",
  "request_id": "550e8400-e29b-41d4-a716-446655440000",
  "service": "order-service",
  "msg": "Payment call failed",
  "error": "connection timeout"
}

Request ID (business layer) ──▶ User-readable, log search
Trace ID (tracing layer)    ──▶ System-generated, chain visualization

// Link Request ID and Trace ID
span := trace.SpanFromContext(ctx)
span.SetAttributes(
    attribute.String("request.id", requestID),
)

// Producer
msg := kafka.Message{
    Headers: map[string]string{
        "X-Request-ID": requestID,
    },
    Value: orderData,
}

// Consumer
requestID := msg.Headers["X-Request-ID"]
ctx := context.WithValue(context.Background(), "requestID", requestID)

// Pass Request ID to goroutine
go func(requestID string) {
    log := logger.WithField("request_id", requestID)
    // Async processing...
}(requestID)

# ELK query
request_id:"550e8400-e29b-41d4-a716-446655440000"

# Result: Sorted by time, complete chain at a glance
[10:23:45] ServiceA Received order request
[10:23:45] ServiceA Called inventory service
[10:23:46] ServiceB Inventory check succeeded
[10:23:46] ServiceA Called payment service
[10:23:46] ServiceC Payment call failed: connection timeout
[10:23:47] ServiceA Order failed

package main

import (
    "github.com/gin-gonic/gin"
    "github.com/google/uuid"
    "go.uber.org/zap"
)

var logger *zap.Logger

func main() {
    r := gin.New()

    // Request ID middleware
    r.Use(func(c *gin.Context) {
        requestID := c.GetHeader("X-Request-ID")
        if requestID == "" {
            requestID = uuid.New().String()
        }
        c.Set("requestID", requestID)
        c.Header("X-Request-ID", requestID)
        c.Next()
    })

    // Logging middleware
    r.Use(func(c *gin.Context) {
        requestID, _ := c.Get("requestID")
        logger.Info("Request started",
            zap.String("request_id", requestID.(string)),
            zap.String("path", c.Request.URL.Path),
        )
        c.Next()
    })

    r.POST("/order", createOrder)

    r.Run(":8080")
}

func createOrder(c *gin.Context) {
    requestID, _ := c.Get("requestID")

    // Pass Request ID when calling downstream services
    // req.Header.Set("X-Request-ID", requestID.(string))

    logger.Info("Creating order",
        zap.String("request_id", requestID.(string)),
    )

    c.JSON(200, gin.H{
        "request_id": requestID,
        "status":     "success",
    })
}