Timeout Budgets

Without deadline propagation:
  A sets 5s deadline → B sets 5s deadline → C sets 5s deadline
  Total possible time: 15s (exceeds A's deadline)

With deadline propagation:
  A sets 5s deadline → B propagates remaining 4s → C propagates remaining 3s
  Total possible time: 5s (matches A's deadline)

import time

class TimeoutBudget:
    def __init__(self, deadline_seconds: float):
        self.start = time.monotonic()
        self.deadline = deadline_seconds
    
    @property
    def remaining(self) -> float:
        elapsed = time.monotonic() - self.start
        return max(0, self.deadline - elapsed)
    
    @property
    def expired(self) -> bool:
        return self.remaining <= 0
    
    def child_budget(self, fraction: float = 0.5) -> 'TimeoutBudget':
        """Create a child budget with a fraction of remaining time"""
        return TimeoutBudget(self.remaining * fraction)

# Usage
budget = TimeoutBudget(deadline_seconds=10)

# Call downstream with 50% of remaining time
child = budget.child_budget(0.5)
response = call_service_b(timeout=child.remaining)

routes:
  - match:
      prefix: /api/v1/orders
    route:
      cluster: order-service
      timeout: 30s
      retry_policy:
        retry_on: "5xx,reset,connect-failure"
        num_retries: 3
        per_try_timeout: 10s
    request_headers_to_add:
      - header:
          key: x-timeout-budget
          value: "%REQUEST_DEADLINE%"