System DesignTimeout Patterns

Timeout Patterns in Synchronous Communication

LevelIntermediate

Duration60 mins

TopicTimeout Patterns

3 / 5

Timeout Propagation

The Timeout Coordination Problem

In isolation, configuring timeouts seems straightforward: set a reasonable value and move on. But in a microservices architecture where a single user request traverses multiple services, a fundamental coordination problem emerges: How should timeout values flow through the call chain? Consider a request that flows: Client \to Gateway (30s timeout) \to Service A (10s timeout) \to Service B (15s timeout). If Service A spends 8 seconds processing before calling Service B, and Service B has a 15-second timeout, the Gateway will timeout (30s exceeded) while Service B is still happily working. The work is wasted, the resources are consumed, and the user already received an error. Timeout propagation solves this problem by communicating remaining time budgets across service boundaries, ensuring that downstream services know how much time they have to complete their work before the upstream caller gives up.

What You Will Learn

By the end of this page, you will understand the timeout coordination problem in distributed systems, learn strategies for propagating timeout budgets, see how to implement timeout propagation in practice, and understand the trade-offs between different propagation approaches.

The Coordination Problem Illustrated

Let's trace through a concrete example to understand why timeout propagation matters. Scenario: E-commerce order placement A user clicks "Place Order" which triggers: API Gateway receives request (user expects response within 10 seconds) Order Service validates the order (takes 1 second) Order Service calls Inventory Service to reserve items (takes 2 seconds) Order Service calls Payment Service to charge the card (takes 3 seconds) Order Service calls Notification Service to send confirmation (takes 1 second) Response returned to user Total processing time: 7 seconds — within the user's 10-second expectation. But what happens when Payment Service is slow?

Converting Mermaid diagram...

The wasted work problem: In this scenario: The user received an error at T+10s Payment Service continued processing until T+15s For 5 seconds, Payment Service worked on a request whose caller was already gone Database transactions were committed, external APIs were called, resources were consumed—all for nothing Worse, the user might retry, creating a duplicate payment because the first attempt actually succeeded (just not in time). The root cause: Payment Service had no way to know that its caller (Order Service) only had ~7 seconds of budget remaining. It used its default 15-second timeout, unaware that this exceeded the upstream budget. The solution: Timeout propagation If Order Service told Payment Service: "You have 7 seconds remaining," Payment Service could: Use 7 seconds as its timeout instead of 15 Fail fast if it can't complete in time Avoid wasting resources on doomed requests

The Cascade of Waste

Without timeout propagation, every service in the chain might continue working after the request is already failed. In a 5-service chain, a single slow leaf service can cause 4 other services to waste resources processing a request whose answer will never be seen.

Timeout Propagation Strategies

There are several approaches to communicating timeout budgets across service boundaries. Each has different trade-offs in terms of accuracy, complexity, and protocol support.

Strategy 1: Header-Based Propagation

•Mechanism: Include remaining timeout or deadline in HTTP headers (e.g., X-Timeout-Remaining: 7000ms or X-Request-Deadline: 2024-01-15T10:30:45Z).
•Advantages: Works with any HTTP client/server; explicit and inspectable; language/framework agnostic.
•Disadvantages: Requires manual header management; not standardized (various naming conventions); clock skew issues with absolute deadlines.
•Best for: Organizations with mixed technology stacks who need explicit control.

Strategy 2: gRPC Deadline Propagation

•Mechanism: gRPC has built-in deadline propagation. Deadlines are automatically passed through the grpc-timeout header and respected by the framework.
•Advantages: Automatic and consistent; built into the protocol; handles clock conversion.
•Disadvantages: Only works for gRPC-to-gRPC calls; requires gRPC adoption.
•Best for: gRPC-native microservice architectures.

Strategy 3: Context Propagation Libraries

•Mechanism: Use context propagation frameworks (e.g., OpenTelemetry baggage, custom middleware) to carry deadline information across boundaries.
•Advantages: Integrates with existing tracing infrastructure; can propagate other context too.
•Disadvantages: Adds dependency on context propagation framework; may have overhead.
•Best for: Organizations already using distributed tracing who want unified context propagation.

Propagation Strategy Comparison
Strategy	Protocol Support	Automation	Accuracy	Complexity
Custom Headers	HTTP, gRPC, any	Manual	Depends on implementation	Low
gRPC Deadlines	gRPC only	Automatic	High (framework-managed)	Low (if using gRPC)
Context Libraries	Any (with adapters)	Semi-automatic	Medium	Medium
No Propagation	N/A	N/A	N/A	Simplest (but problematic)

Relative vs. Absolute Time

You can propagate either relative remaining time (X-Timeout-Remaining: 7000ms) or an absolute deadline (X-Deadline: 2024-01-15T10:30:45.123Z). Relative time is simpler but doesn't account for network latency. Absolute deadlines require synchronized clocks but are more accurate across hops.

Implementing Timeout Propagation

Let's walk through implementing timeout propagation in practice. We'll cover both HTTP header-based propagation and gRPC's built-in mechanism. Header-based propagation implementation: The pattern involves three components: Incoming middleware: Extract deadline from incoming request headers Context management: Store deadline in request context and decrement as time passes Outgoing interceptor: Attach remaining time to outgoing request headers

timeout-propagation-middleware
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
// Timeout propagation middleware for Express/Node.js
import { Request, Response, NextFunction } from 'express';
 
// Header names (customize as needed)
const DEADLINE_HEADER = 'x-request-deadline';
const REMAINING_HEADER = 'x-timeout-remaining-ms';
 
// Default timeout if none specified
const DEFAULT_TIMEOUT_MS = 30000;
 
// Minimum timeout to bother propagating
const MIN_TIMEOUT_MS = 100;
 
interface DeadlineContext {
  deadline: Date;
  getRemainingMs: () => number;
  isExpired: () => boolean;
}
 
// Extend Express Request to include deadline context
declare global {
  namespace Express {
    interface Request {
      deadlineContext?: DeadlineContext;
    }
  }
}
 
/**
 * Middleware to extract and manage request deadline
 */
export function deadlineMiddleware(
  req: Request,
  res: Response,
  next: NextFunction
): void {
  let deadline: Date;
  
  // Check for absolute deadline header
  const deadlineHeader = req.get(DEADLINE_HEADER);
  if (deadlineHeader) {
    deadline = new Date(deadlineHeader);
    if (isNaN(deadline.getTime())) {
      // Invalid date, use default
      deadline = new Date(Date.now() + DEFAULT_TIMEOUT_MS);
    }
  } 
  // Check for remaining time header
  else {
    const remainingHeader = req.get(REMAINING_HEADER);
    const remainingMs = remainingHeader 
      ? parseInt(remainingHeader, 10) 
      : DEFAULT_TIMEOUT_MS;
    deadline = new Date(Date.now() + remainingMs);
  }
  
  // Attach deadline context to request
  req.deadlineContext = {
    deadline,
    getRemainingMs: () => Math.max(0, deadline.getTime() - Date.now()),
    isExpired: () => Date.now() >= deadline.getTime(),
  };
  
  // Set response timeout to deadline
  const remainingMs = req.deadlineContext.getRemainingMs();
  if (remainingMs > 0) {
    res.setTimeout(remainingMs, () => {
      // Request exceeded deadline
      if (!res.headersSent) {
        res.status(504).json({ error: 'Request deadline exceeded' });
      }
    });
  }
  
  next();
}
 
/**
 * HTTP client wrapper that propagates deadline
 */
export function createDeadlineAwareClient(baseClient: any) {
  return {
    async request(url: string, options: RequestInit & { 
      deadlineContext?: DeadlineContext 
    }) {
      const { deadlineContext, ...fetchOptions } = options;
      
      if (!deadlineContext) {
        // No deadline context, use defaults
        return baseClient.request(url, fetchOptions);
      }
      
      const remainingMs = deadlineContext.getRemainingMs();
      
      // Check if we have enough time
      if (remainingMs < MIN_TIMEOUT_MS) {
        throw new Error('Insufficient time remaining for downstream call');
      }
      
      // Subtract buffer for network latency and processing
      const propagatedTimeoutMs = Math.floor(remainingMs * 0.9);
      
      const headers = new Headers(fetchOptions.headers);
      headers.set(REMAINING_HEADER, propagatedTimeoutMs.toString());
      headers.set(DEADLINE_HEADER, deadlineContext.deadline.toISOString());
      
      // Create abort controller for timeout
      const controller = new AbortController();
      const timeoutId = setTimeout(
        () => controller.abort(),
        propagatedTimeoutMs
      );
      
      try {
        return await baseClient.request(url, {
          ...fetchOptions,
          headers,
          signal: controller.signal,
        });
      } finally {
        clearTimeout(timeoutId);
      }
    },
  };
}

gRPC deadline propagation: With gRPC, deadline propagation is largely automatic. When you set a deadline on a context, it's automatically propagated to downstream gRPC calls.

grpc-deadline-propagation
Go (gRPC)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
package main
 
import (
    "context"
    "time"
    
    "google.golang.org/grpc"
    pb "example.com/order/proto"
)
 
func (s *OrderServer) PlaceOrder(
    ctx context.Context,
    req *pb.OrderRequest,
) (*pb.OrderResponse, error) {
    // The context already has the deadline from the incoming request
    // gRPC automatically extracted it from the grpc-timeout header
    
    deadline, ok := ctx.Deadline()
    if ok {
        log.Printf("Request deadline: %v (remaining: %v)", 
            deadline, time.Until(deadline))
    }
    
    // When making downstream calls, just pass the context
    // The deadline is automatically propagated
    inventoryResp, err := s.inventoryClient.ReserveItems(ctx, &pb.ReserveRequest{
        Items: req.Items,
    })
    if err != nil {
        // Could be context.DeadlineExceeded if we ran out of time
        return nil, err
    }
    
    // Continue with payment call - same context, deadline still applies
    paymentResp, err := s.paymentClient.ChargeCard(ctx, &pb.ChargeRequest{
        Amount: req.TotalAmount,
    })
    if err != nil {
        return nil, err
    }
    
    return &pb.OrderResponse{Success: true}, nil
}
 
// Client side: setting the initial deadline
func main() {
    conn, _ := grpc.Dial("order-service:50051", grpc.WithInsecure())
    client := pb.NewOrderServiceClient(conn)
    
    // Set deadline for the entire operation
    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()
    
    // This deadline will propagate through all downstream calls
    resp, err := client.PlaceOrder(ctx, &pb.OrderRequest{...})
    if err != nil {
        if ctx.Err() == context.DeadlineExceeded {
            log.Println("Order placement timed out")
        }
    }
}

gRPC Deadline Header

gRPC transmits deadlines via the grpc-timeout header, which contains a relative timeout value with a unit suffix (e.g., 5000m for 5000 milliseconds). The gRPC library handles conversion between absolute deadlines in context and relative timeouts in headers.

Timeout Budget Management

When propagating timeouts, you must account for overhead at each hop. If you simply pass the remaining time unchanged, you ignore: Network latency — The request takes time to travel to the downstream service Processing overhead — Serialization, logging, middleware execution Response transmission — The response takes time to travel back Without accounting for this overhead, downstream services might use their full budget, leaving no time for the response to reach the caller. Budget reduction strategies:

Timeout Budget Reduction Strategies
Strategy	Formula	Pros	Cons
Fixed reduction	propagated = remaining - 500ms	Simple, predictable	Doesn't scale with timeout size
Percentage reduction	propagated = remaining × 0.9	Scales with timeout	May be too aggressive for short timeouts
Adaptive reduction	propagated = remaining - (latencyP99 × 2)	Accurate if you have latency data	Requires metrics infrastructure
Per-hop budget	propagated = remaining - perHopBudget	Consistent across services	Requires coordination on per-hop value

A practical budget management example: Let's trace a request through a 4-service chain with budgets managed at each hop: Initial request: 10000ms deadline Gateway (receives request): - Remaining: 10000ms - Local processing: 100ms - Propagate to Service A: 10000ms \times 0.9 = 9000ms - Time used: 100ms, Remaining after: 9900ms Service A (receives 9000ms budget): - Local processing: 200ms - Propagate to Service B: 9000ms \times 0.9 = 8100ms - Actual remaining after local work: 8800ms Service B (receives 8100ms budget): - Local processing: 500ms - Propagate to Database: 8100ms \times 0.9 = 7290ms - Actual remaining: 7600ms Database (receives 7290ms budget): - Query execution: 1000ms - Returns in 1000ms - Remaining at return: 6290ms Response propagates back: - Each hop uses some time for response processing - Total expected: well under 10000ms deadline The 10% reduction at each hop creates a buffer for response transmission and processing overhead.

Minimum Timeout Threshold

Always check that the reduced budget exceeds a minimum threshold (e.g., 100ms) before making a downstream call. If remaining time is too short, fail fast rather than attempting a doomed call that will waste resources.

budget-reduction
TypeScript
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
interface BudgetStrategy {
  calculatePropagatedTimeout(remainingMs: number): number;
}
 
// Strategy 1: Fixed reduction
class FixedReduction implements BudgetStrategy {
  constructor(private reductionMs: number = 500) {}
  
  calculatePropagatedTimeout(remainingMs: number): number {
    return Math.max(0, remainingMs - this.reductionMs);
  }
}
 
// Strategy 2: Percentage reduction
class PercentageReduction implements BudgetStrategy {
  constructor(private percentage: number = 0.9) {}
  
  calculatePropagatedTimeout(remainingMs: number): number {
    return Math.floor(remainingMs * this.percentage);
  }
}
 
// Strategy 3: Combined (percentage with minimum reduction)
class CombinedReduction implements BudgetStrategy {
  constructor(
    private percentage: number = 0.9,
    private minReductionMs: number = 100
  ) {}
  
  calculatePropagatedTimeout(remainingMs: number): number {
    const percentageResult = Math.floor(remainingMs * this.percentage);
    const fixedResult = remainingMs - this.minReductionMs;
    return Math.min(percentageResult, fixedResult);
  }
}
 
// Strategy 4: Latency-aware reduction
class LatencyAwareReduction implements BudgetStrategy {
  constructor(
    private getP99LatencyMs: () => number,
    private multiplier: number = 2
  ) {}
  
  calculatePropagatedTimeout(remainingMs: number): number {
    const expectedOverhead = this.getP99LatencyMs() * this.multiplier;
    return Math.max(0, remainingMs - expectedOverhead);
  }
}
 
// Usage with minimum threshold check
const MIN_TIMEOUT_MS = 100;
 
function shouldMakeDownstreamCall(
  remainingMs: number,
  strategy: BudgetStrategy
): { proceed: boolean; timeout: number } {
  const propagatedTimeout = strategy.calculatePropagatedTimeout(remainingMs);
  
  if (propagatedTimeout < MIN_TIMEOUT_MS) {
    return { proceed: false, timeout: 0 };
  }
  
  return { proceed: true, timeout: propagatedTimeout };
}

Challenges and Edge Cases

Timeout propagation introduces several challenges that require careful handling.

Challenge 1: Clock Skew

•Problem: If you propagate absolute deadlines (timestamps), clock differences between servers can cause issues. Server A might think there's 5 seconds remaining while Server B thinks the deadline already passed.
•Magnitude: Cloud providers typically keep clocks synchronized within a few milliseconds using NTP, but on-premise or edge deployments can have seconds or even minutes of skew.
•Solutions: (1) Use relative remaining time instead of absolute deadlines; (2) Ensure NTP is configured and monitored across all hosts; (3) Build in tolerance for small skew when calculating remaining time.

Challenge 2: Fan-Out Requests

•Problem: When a service makes parallel requests to multiple downstream services, how should the timeout budget be split?
•Example: Service A has 5 seconds remaining and needs to call Service B and Service C in parallel. Should each get 5 seconds? 2.5 seconds each?
•Solutions: (1) Give each parallel call the same remaining budget (they run concurrently); (2) Use the minimum expected response time among all calls; (3) Set a maximum timeout per call regardless of remaining budget.

Challenge 3: Retries and Propagation

•Problem: If a downstream call fails and is retried, how should the retry's timeout be calculated?
•Example: First attempt uses 3 seconds of a 10-second budget. Should the retry get 7 seconds? Or should it get the original timeout minus elapsed time?
•Solutions: (1) Calculate timeout from current remaining budget for each attempt; (2) Pre-allocate budget per attempt (e.g., 3 attempts × 3 seconds = 9 second budget); (3) Use exponential backoff with decreasing timeouts.

Challenge 4: Mixing propagation-aware and unaware services In heterogeneous environments, some services might support deadline propagation while others don't. Strategies for handling this: Conservative defaults: Services that don't receive deadline headers use conservative default timeouts Gateway normalization: Edge gateways always inject deadline headers, ensuring downstream services have the information Service mesh handling: Sidecar proxies can enforce timeouts even if application code doesn't implement propagation Gradual adoption: Implement propagation in critical paths first, expand coverage over time

Observability is Key

When implementing timeout propagation, add metrics and logging for: timeout budget received, timeout budget propagated, and whether requests completed within budget. This observability helps tune budget reduction strategies and identify services that consistently exceed their budgets.

Service Mesh and Sidecar Approaches

Modern service mesh implementations like Istio, Linkerd, and Envoy can handle timeout propagation at the infrastructure layer, reducing the burden on application code. How service meshes handle timeouts: Sidecar proxy interception: All traffic flows through sidecar proxies that can enforce and propagate timeouts Policy-based configuration: Timeout values can be configured via mesh policies rather than in application code Automatic propagation: Some meshes support automatic deadline header propagation between sidecars Per-route timeouts: Different timeout values for different endpoints without code changes

istio-timeout-config
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
# Istio VirtualService with timeout configuration
apiVersion: networking.istio.io/v1beta1
kind: VirtualService
metadata:
  name: order-service
spec:
  hosts:
  - order-service
  http:
  - match:
    - uri:
        prefix: "/api/orders"
    route:
    - destination:
        host: order-service
        port:
          number: 8080
    timeout: 30s  # Overall request timeout
    retries:
      attempts: 3
      perTryTimeout: 10s  # Timeout per retry attempt
      retryOn: gateway-error,connect-failure,retriable-4xx
 
---
# Route-specific timeouts
apiVersion: networking.istio.io/v1beta1
kind: VirtualService
metadata:
  name: payment-service
spec:
  hosts:
  - payment-service
  http:
  - match:
    - headers:
        x-request-type:
          exact: "batch-payment"
    route:
    - destination:
        host: payment-service
    timeout: 120s  # Longer timeout for batch operations
  - route:
    - destination:
        host: payment-service
    timeout: 30s  # Standard timeout

Service Mesh Timeout Capabilities
Feature	Istio	Linkerd	Envoy (standalone)
Request timeout	✓	✓	✓
Per-retry timeout	✓	✓	✓
Idle timeout	✓	✓	✓
Deadline propagation	Via headers (manual)	Limited	Via headers
Per-route configuration	✓	Via profiles	✓
Dynamic timeout (response headers)	Limited	Limited	✓

Mesh vs. Application Timeouts

Service mesh timeouts and application-level timeouts should work together. Mesh timeouts provide a safety net and policy enforcement; application timeouts provide business logic awareness and finer control. Configure mesh timeouts slightly longer than application timeouts to allow application-level handling first.

Observability and Debugging

Timeout propagation creates new observability requirements. When a request fails due to timeout, you need to answer: Where in the call chain did time run out? What was the original deadline? How was budget consumed across services? Which service(s) exceeded their budget? Essential metrics for timeout propagation:

Timeout Propagation Metrics

•timeout_budget_received_ms — Histogram of timeout budgets received from upstream callers
•timeout_budget_propagated_ms — Histogram of timeout budgets sent to downstream services
•timeout_budget_remaining_at_completion_ms — How much budget was left when the request completed
•timeout_exceeded_total — Counter of requests that exceeded their deadline
•insufficient_budget_rejections_total — Counter of downstream calls not made due to insufficient remaining time

Distributed tracing integration: Distributed traces are invaluable for debugging timeout issues. Enhance your traces with: Deadline annotations: Add the deadline to span tags so you can see what each service thought its deadline was Budget waterfall: Visualize how budget decreased across the call chain Timeout causation: When a timeout occurs, link to the span that was executing when time ran out

timeout-tracing
TypeScript (OpenTelemetry)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
import { trace, SpanStatusCode } from '@opentelemetry/api';
 
const tracer = trace.getTracer('timeout-propagation');
 
async function handleRequest(req: Request): Promise<Response> {
  const deadline = req.deadlineContext?.deadline;
  const remainingMs = req.deadlineContext?.getRemainingMs() ?? 0;
  
  const span = tracer.startSpan('handle-order', {
    attributes: {
      'timeout.deadline_iso': deadline?.toISOString(),
      'timeout.budget_received_ms': remainingMs,
    },
  });
  
  try {
    // ... processing ...
    
    const budgetBeforeDownstream = req.deadlineContext?.getRemainingMs() ?? 0;
    const propagatedBudget = calculatePropagatedTimeout(budgetBeforeDownstream);
    
    span.setAttribute('timeout.budget_before_downstream_ms', budgetBeforeDownstream);
    span.setAttribute('timeout.budget_propagated_ms', propagatedBudget);
    
    const result = await callDownstreamService(propagatedBudget);
    
    const budgetAfterDownstream = req.deadlineContext?.getRemainingMs() ?? 0;
    span.setAttribute('timeout.budget_remaining_ms', budgetAfterDownstream);
    
    return result;
    
  } catch (error) {
    if (error.name === 'TimeoutError' || req.deadlineContext?.isExpired()) {
      span.setStatus({ code: SpanStatusCode.ERROR, message: 'Deadline exceeded' });
      span.setAttribute('timeout.exceeded', true);
      span.setAttribute('timeout.exceeded_by_ms', 
        Date.now() - (deadline?.getTime() ?? Date.now()));
    }
    throw error;
  } finally {
    span.end();
  }
}

Budget Waterfall Dashboard

Create a dashboard that shows timeout budget as a waterfall chart across service calls. This visualization immediately reveals which services consume the most budget and where timeout issues originate.

3 / 5

Propagation Strategy Comparison

Strategy

Protocol Support

Automation

Accuracy

Complexity

Custom Headers

HTTP, gRPC, any

Manual

Depends on implementation

Low

gRPC Deadlines

gRPC only

Automatic

High (framework-managed)

Low (if using gRPC)

Context Libraries

Any (with adapters)

Semi-automatic

Medium

No Propagation

N/A

Simplest (but problematic)

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

// Timeout propagation middleware for Express/Node.js import { Request, Response, NextFunction } from 'express'; // Header names (customize as needed) const DEADLINE_HEADER = 'x-request-deadline'; const REMAINING_HEADER = 'x-timeout-remaining-ms'; // Default timeout if none specified const DEFAULT_TIMEOUT_MS = 30000; // Minimum timeout to bother propagating const MIN_TIMEOUT_MS = 100; interface DeadlineContext { deadline: Date; getRemainingMs: () => number; isExpired: () => boolean; } // Extend Express Request to include deadline context declare global { namespace Express { interface Request { deadlineContext?: DeadlineContext; } } } /** * Middleware to extract and manage request deadline */ export function deadlineMiddleware( req: Request, res: Response, next: NextFunction ): void { let deadline: Date; // Check for absolute deadline header const deadlineHeader = req.get(DEADLINE_HEADER); if (deadlineHeader) { deadline = new Date(deadlineHeader); if (isNaN(deadline.getTime())) { // Invalid date, use default deadline = new Date(Date.now() + DEFAULT_TIMEOUT_MS); } } // Check for remaining time header else { const remainingHeader = req.get(REMAINING_HEADER); const remainingMs = remainingHeader ? parseInt(remainingHeader, 10) : DEFAULT_TIMEOUT_MS; deadline = new Date(Date.now() + remainingMs); } // Attach deadline context to request req.deadlineContext = { deadline, getRemainingMs: () => Math.max(0, deadline.getTime() - Date.now()), isExpired: () => Date.now() >= deadline.getTime(), }; // Set response timeout to deadline const remainingMs = req.deadlineContext.getRemainingMs(); if (remainingMs > 0) { res.setTimeout(remainingMs, () => { // Request exceeded deadline if (!res.headersSent) { res.status(504).json({ error: 'Request deadline exceeded' }); } }); } next(); } /** * HTTP client wrapper that propagates deadline */ export function createDeadlineAwareClient(baseClient: any) { return { async request(url: string, options: RequestInit & { deadlineContext?: DeadlineContext }) { const { deadlineContext, ...fetchOptions } = options; if (!deadlineContext) { // No deadline context, use defaults return baseClient.request(url, fetchOptions); } const remainingMs = deadlineContext.getRemainingMs(); // Check if we have enough time if (remainingMs < MIN_TIMEOUT_MS) { throw new Error('Insufficient time remaining for downstream call'); } // Subtract buffer for network latency and processing const propagatedTimeoutMs = Math.floor(remainingMs * 0.9); const headers = new Headers(fetchOptions.headers); headers.set(REMAINING_HEADER, propagatedTimeoutMs.toString()); headers.set(DEADLINE_HEADER, deadlineContext.deadline.toISOString()); // Create abort controller for timeout const controller = new AbortController(); const timeoutId = setTimeout( () => controller.abort(), propagatedTimeoutMs ); try { return await baseClient.request(url, { ...fetchOptions, headers, signal: controller.signal, }); } finally { clearTimeout(timeoutId); } }, }; }

package main import ( "context" "time" "google.golang.org/grpc" pb "example.com/order/proto" ) func (s *OrderServer) PlaceOrder( ctx context.Context, req *pb.OrderRequest, ) (*pb.OrderResponse, error) { // The context already has the deadline from the incoming request // gRPC automatically extracted it from the grpc-timeout header deadline, ok := ctx.Deadline() if ok { log.Printf("Request deadline: %v (remaining: %v)", deadline, time.Until(deadline)) } // When making downstream calls, just pass the context // The deadline is automatically propagated inventoryResp, err := s.inventoryClient.ReserveItems(ctx, &pb.ReserveRequest{ Items: req.Items, }) if err != nil { // Could be context.DeadlineExceeded if we ran out of time return nil, err } // Continue with payment call - same context, deadline still applies paymentResp, err := s.paymentClient.ChargeCard(ctx, &pb.ChargeRequest{ Amount: req.TotalAmount, }) if err != nil { return nil, err } return &pb.OrderResponse{Success: true}, nil } // Client side: setting the initial deadline func main() { conn, _ := grpc.Dial("order-service:50051", grpc.WithInsecure()) client := pb.NewOrderServiceClient(conn) // Set deadline for the entire operation ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) defer cancel() // This deadline will propagate through all downstream calls resp, err := client.PlaceOrder(ctx, &pb.OrderRequest{...}) if err != nil { if ctx.Err() == context.DeadlineExceeded { log.Println("Order placement timed out") } } }

Timeout Budget Reduction Strategies

Strategy

Formula

Pros

Cons

Fixed reduction

propagated = remaining - 500ms

Simple, predictable

Doesn't scale with timeout size

Percentage reduction

propagated = remaining × 0.9

Scales with timeout

May be too aggressive for short timeouts

Adaptive reduction

propagated = remaining - (latencyP99 × 2)

Accurate if you have latency data

Requires metrics infrastructure

Per-hop budget

propagated = remaining - perHopBudget

Consistent across services

Requires coordination on per-hop value

Initial request: 10000ms deadline Gateway (receives request): - Remaining: 10000ms - Local processing: 100ms - Propagate to Service A: 10000ms × 0.9 = 9000ms - Time used: 100ms, Remaining after: 9900ms Service A (receives 9000ms budget): - Local processing: 200ms - Propagate to Service B: 9000ms × 0.9 = 8100ms - Actual remaining after local work: 8800ms Service B (receives 8100ms budget): - Local processing: 500ms - Propagate to Database: 8100ms × 0.9 = 7290ms - Actual remaining: 7600ms Database (receives 7290ms budget): - Query execution: 1000ms - Returns in 1000ms - Remaining at return: 6290ms Response propagates back: - Each hop uses some time for response processing - Total expected: well under 10000ms deadline

interface BudgetStrategy { calculatePropagatedTimeout(remainingMs: number): number; } // Strategy 1: Fixed reduction class FixedReduction implements BudgetStrategy { constructor(private reductionMs: number = 500) {} calculatePropagatedTimeout(remainingMs: number): number { return Math.max(0, remainingMs - this.reductionMs); } } // Strategy 2: Percentage reduction class PercentageReduction implements BudgetStrategy { constructor(private percentage: number = 0.9) {} calculatePropagatedTimeout(remainingMs: number): number { return Math.floor(remainingMs * this.percentage); } } // Strategy 3: Combined (percentage with minimum reduction) class CombinedReduction implements BudgetStrategy { constructor( private percentage: number = 0.9, private minReductionMs: number = 100 ) {} calculatePropagatedTimeout(remainingMs: number): number { const percentageResult = Math.floor(remainingMs * this.percentage); const fixedResult = remainingMs - this.minReductionMs; return Math.min(percentageResult, fixedResult); } } // Strategy 4: Latency-aware reduction class LatencyAwareReduction implements BudgetStrategy { constructor( private getP99LatencyMs: () => number, private multiplier: number = 2 ) {} calculatePropagatedTimeout(remainingMs: number): number { const expectedOverhead = this.getP99LatencyMs() * this.multiplier; return Math.max(0, remainingMs - expectedOverhead); } } // Usage with minimum threshold check const MIN_TIMEOUT_MS = 100; function shouldMakeDownstreamCall( remainingMs: number, strategy: BudgetStrategy ): { proceed: boolean; timeout: number } { const propagatedTimeout = strategy.calculatePropagatedTimeout(remainingMs); if (propagatedTimeout < MIN_TIMEOUT_MS) { return { proceed: false, timeout: 0 }; } return { proceed: true, timeout: propagatedTimeout }; }

# Istio VirtualService with timeout configuration apiVersion: networking.istio.io/v1beta1 kind: VirtualService metadata: name: order-service spec: hosts: - order-service http: - match: - uri: prefix: "/api/orders" route: - destination: host: order-service port: number: 8080 timeout: 30s # Overall request timeout retries: attempts: 3 perTryTimeout: 10s # Timeout per retry attempt retryOn: gateway-error,connect-failure,retriable-4xx --- # Route-specific timeouts apiVersion: networking.istio.io/v1beta1 kind: VirtualService metadata: name: payment-service spec: hosts: - payment-service http: - match: - headers: x-request-type: exact: "batch-payment" route: - destination: host: payment-service timeout: 120s # Longer timeout for batch operations - route: - destination: host: payment-service timeout: 30s # Standard timeout

Service Mesh Timeout Capabilities

Feature

Istio

Linkerd

Envoy (standalone)

Request timeout

✓

Per-retry timeout

✓

Idle timeout

✓

Deadline propagation

Via headers (manual)

Limited

Via headers

Per-route configuration

✓

Via profiles

✓

Dynamic timeout (response headers)

Limited

✓

import { trace, SpanStatusCode } from '@opentelemetry/api'; const tracer = trace.getTracer('timeout-propagation'); async function handleRequest(req: Request): Promise<Response> { const deadline = req.deadlineContext?.deadline; const remainingMs = req.deadlineContext?.getRemainingMs() ?? 0; const span = tracer.startSpan('handle-order', { attributes: { 'timeout.deadline_iso': deadline?.toISOString(), 'timeout.budget_received_ms': remainingMs, }, }); try { // ... processing ... const budgetBeforeDownstream = req.deadlineContext?.getRemainingMs() ?? 0; const propagatedBudget = calculatePropagatedTimeout(budgetBeforeDownstream); span.setAttribute('timeout.budget_before_downstream_ms', budgetBeforeDownstream); span.setAttribute('timeout.budget_propagated_ms', propagatedBudget); const result = await callDownstreamService(propagatedBudget); const budgetAfterDownstream = req.deadlineContext?.getRemainingMs() ?? 0; span.setAttribute('timeout.budget_remaining_ms', budgetAfterDownstream); return result; } catch (error) { if (error.name === 'TimeoutError' || req.deadlineContext?.isExpired()) { span.setStatus({ code: SpanStatusCode.ERROR, message: 'Deadline exceeded' }); span.setAttribute('timeout.exceeded', true); span.setAttribute('timeout.exceeded_by_ms', Date.now() - (deadline?.getTime() ?? Date.now())); } throw error; } finally { span.end(); } }

Timeout Propagation

The Timeout Coordination Problem

The Coordination Problem Illustrated

Timeout Propagation Strategies

Implementing Timeout Propagation

Timeout Budget Management

Challenges and Edge Cases

Service Mesh and Sidecar Approaches

Observability and Debugging

There’s more to understand.

Timeout Propagation

The Timeout Coordination Problem

The Coordination Problem Illustrated

Timeout Propagation Strategies

Implementing Timeout Propagation

Timeout Budget Management

Challenges and Edge Cases

Service Mesh and Sidecar Approaches

Observability and Debugging

There’s more to understand.