【Go性能生死线】超时自动关闭不生效？92.7%的线上故障源于这2个context使用反模式

第一章：Go超时自动关闭机制的本质与挑战

Go 语言中，超时自动关闭并非一种独立的“机制”，而是 context.Context、net/http.Client、time.Timer 等组件协同构建的协作式取消模型。其本质是信号传递而非强制终止：goroutine 需主动监听 ctx.Done() 通道并自行清理资源；若忽略该信号，超时不会杀死 goroutine，也不会释放其持有的内存、文件描述符或网络连接。

常见挑战包括：

• 资源泄漏风险：未在 select 中监听 ctx.Done() 或未正确调用 defer cancel() 导致连接/数据库句柄长期滞留；
• 不可中断的阻塞操作：如 os.Read、net.Conn.Read 在底层不响应 context，需配合 SetReadDeadline 手动实现超时；
• 上下文生命周期错配：父 context 被取消后，子 context 若未及时传播，将导致“幽灵 goroutine”。

以下为安全的 HTTP 请求超时示例：

func fetchWithTimeout(url string, timeout time.Duration) ([]byte, error) {
    ctx, cancel := context.WithTimeout(context.Background(), timeout)
    defer cancel() // 必须确保 cancel 调用，避免 context 泄漏

    req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
    if err != nil {
        return nil, err
    }

    client := &http.Client{
        Timeout: 10 * time.Second, // 底层 TCP 连接与 TLS 握手超时
    }
    resp, err := client.Do(req)
    if err != nil {
        // ctx.Err() 可区分是超时还是其他错误
        if errors.Is(err, context.DeadlineExceeded) {
            return nil, fmt.Errorf("request timed out after %v", timeout)
        }
        return nil, err
    }
    defer resp.Body.Close()

    return io.ReadAll(resp.Body)
}

关键点说明：

• context.WithTimeout 创建可取消的上下文，defer cancel() 防止 context 泄漏；
• http.Client.Timeout 控制底层连接建立阶段，而 context 控制整个请求生命周期（含读取响应体）；
• errors.Is(err, context.DeadlineExceeded) 是识别超时的可靠方式，优于字符串匹配。

场景	推荐方案
数据库查询超时	使用 context.WithTimeout 传入 db.QueryContext
文件读取超时	调用 file.SetReadDeadline 配合 io.ReadFull
自定义阻塞操作	在循环中定期检查 select { case <-ctx.Done(): ... }

真正的超时保障，永远依赖于开发者对 context 的显式响应与资源的确定性释放。

第二章：context超时控制的五大核心反模式

2.1 超时context未传递至底层IO操作：理论剖析goroutine泄漏链与net.Conn底层阻塞原理

goroutine泄漏的触发路径

当context.WithTimeout创建的上下文未透传至net.Conn.Read/Write调用链，goroutine将永久阻塞在系统调用层（如epoll_wait或select），无法响应取消信号。

net.Conn阻塞本质

标准库net.Conn接口不接收context.Context参数，其底层conn.read()直接调用syscall.Read，绕过Go运行时的调度干预：

// ❌ 错误示例：超时context未下沉
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
_, err := conn.Read(buf) // ⚠️ 此处不感知ctx，永不超时

逻辑分析：conn.Read内部无select{ case <-ctx.Done(): ... }分支；syscall.Read属于同步阻塞IO，在内核态等待数据就绪，Go runtime无法强制唤醒。

阻塞传播链

graph TD
A[HTTP Handler goroutine] --> B[context.WithTimeout]
B --> C[net.Conn.Read]
C --> D[syscall.Read]
D --> E[内核socket recv缓冲区空]
E --> F[goroutine持续阻塞]

组件	是否感知Context	后果
http.Server	✅ 是	可中断Handler
net.Conn	❌ 否	IO永不返回
syscall.Read	❌ 否	内核级阻塞不可打断

2.2 WithTimeout嵌套导致deadline被意外覆盖：实践复现多层调用中time.Now().Add()精度丢失问题

复现场景：三层WithContext链式调用

当 WithTimeout(ctx, 100ms) 在外层创建，内层又调用 WithTimeout(childCtx, 50ms)，子context的 deadline 实际由 time.Now().Add(50 * time.Millisecond) 计算——而 time.Now() 返回纳秒级时间，Add() 在毫秒级截断时可能丢失亚毫秒偏移，导致子deadline早于父deadline。

关键代码复现

parent := context.WithTimeout(context.Background(), 100*time.Millisecond)
time.Sleep(10 * time.Millisecond) // 模拟调度延迟
child := context.WithTimeout(parent, 50*time.Millisecond)
fmt.Printf("Parent deadline: %v\n", parent.Deadline())
fmt.Printf("Child deadline:  %v\n", child.Deadline()) // 可能早于 parent!

逻辑分析：WithTimeout 内部调用 time.Now().Add(d)，若当前纳秒时间是 1234567890123 ns（即 1234.567890123 ms），Add(50ms) 后仍保留纳秒精度，但高并发下系统时钟采样抖动+调度延迟，使两次 Now() 值偏差达数微秒，最终 child.Deadline() 可能比 parent.Deadline() 早 1–3ms。

精度丢失影响对比

场景	调用间隔	实际子deadline偏移	风险等级
理想无延迟	0ns	0ms	低
典型调度延迟	~15μs	-0.015ms	中
GC STW期间	~100μs	-0.1ms	高

根本原因流程图

graph TD
    A[Parent WithTimeout] --> B[time.Now().Add(100ms)]
    B --> C[Parent deadline]
    C --> D[调度延迟/时钟抖动]
    D --> E[Child WithTimeout]
    E --> F[time.Now().Add(50ms)]
    F --> G[Child deadline < Parent deadline]

2.3 忽略Done通道的主动监听与资源清理：结合http.Transport与database/sql连接池演示panic式关闭风险

http.Transport 的连接泄漏陷阱

当 http.Transport 的 CloseIdleConnections() 未被显式调用，且 RoundTrip 期间忽略 context.Done() 监听时，空闲连接将持续驻留：

// 错误示例：未监听ctx.Done()，也未配置IdleConnTimeout
tr := &http.Transport{
    MaxIdleConns:        10,
    MaxIdleConnsPerHost: 10,
}
client := &http.Client{Transport: tr}
// 若请求上下文超时但transport未感知，连接不会及时归还池

此代码导致连接长期滞留于 idleConn map 中，直至 GC 或进程退出。

database/sql 连接池的 panic 关闭链式反应

sql.DB.Close() 非阻塞，若在活跃查询中调用，将触发内部 panic("sql: database is closed")：

场景	行为	后果
db.Close() 后立即 db.Query()	panic 抛出	goroutine crash
ctx.Done() 未提前取消 db.QueryContext()	查询继续占用连接	连接池耗尽

资源清理的正确路径

必须同步监听 Done 通道并协调关闭顺序：

graph TD
    A[启动HTTP请求] --> B{ctx.Done() 可读？}
    B -->|是| C[调用 transport.CloseIdleConnections()]
    B -->|否| D[执行 RoundTrip]
    C --> E[释放 idleConn]
    D --> F[返回响应或错误]

2.4 使用WithCancel替代WithTimeout引发的伪超时：通过pprof火焰图验证goroutine堆积真实成因

问题复现：看似超时，实为阻塞

当用 context.WithTimeout 替换为 context.WithCancel 但未显式调用 cancel()，goroutine 无法被及时回收，导致 pprof 火焰图中 runtime.gopark 占比异常升高。

关键差异对比

场景	生命周期控制	自动触发取消	goroutine 泄漏风险
WithTimeout	定时器自动触发	✅	低（超时即 cancel）
WithCancel	需手动调用 cancel()	❌	高（易遗漏）

典型错误代码

func badHandler(w http.ResponseWriter, r *http.Request) {
    ctx, _ := context.WithCancel(r.Context()) // ❌ 忘记 defer cancel()
    go func() {
        time.Sleep(5 * time.Second)
        fmt.Fprintln(w, "done")
    }()
}

逻辑分析：WithCancel 返回的 cancel 函数未被调用，子 goroutine 持有 ctx 引用，阻塞在 w.Write 或等待 HTTP 连接关闭，pprof 显示大量 net/http.(*conn).serve 堆栈。

验证路径

graph TD
    A[HTTP 请求] --> B[启动 goroutine]
    B --> C{ctx.Done() 是否可关闭？}
    C -->|否| D[goroutine 挂起]
    C -->|是| E[正常退出]

• 正确做法：defer cancel() + select 监听 ctx.Done()
• pprof 命令：go tool pprof -http=:8080 http://localhost:6060/debug/pprof/goroutine?debug=2

2.5 context.Value滥用干扰超时传播路径：分析中间件注入value后cancel信号中断的内存屏障失效案例

问题根源：Value覆盖掩盖cancel状态

当中间件调用 ctx = context.WithValue(parent, key, val) 时，返回新 context 实例，但未继承 parent 的 cancel channel 关联性：

// ❌ 危险模式：Value包装破坏cancel链路
func middleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        ctx := r.Context()
        // 注入value后，ctx.Done()仍指向原parent，但cancel信号无法穿透包装层
        wrapped := context.WithValue(ctx, "traceID", "abc123")
        r = r.WithContext(wrapped)
        next.ServeHTTP(w, r)
    })
}

此处 wrapped 的 Done() 方法仍返回原始 ctx.Done()，但若上游提前 cancel，wrapped 不会触发 GC 可见的内存屏障，导致 goroutine 泄漏。

内存屏障失效示意

组件	是否触发 atomic.StorePointer	是否建立 happens-before 关系
context.WithCancel	✅ 是	✅ 是
context.WithValue	❌ 否	❌ 否

正确解法：显式传递取消能力

// ✅ 安全模式：保留cancel语义
func safeMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // 仅在必要时派生子ctx，并确保cancel链完整
        child, cancel := context.WithTimeout(r.Context(), 5*time.Second)
        defer cancel()
        r = r.WithContext(context.WithValue(child, "traceID", "abc123"))
        next.ServeHTTP(w, r)
    })
}

WithTimeout 创建新 cancel channel 并注册监听器，WithValue 在其基础上封装，保障 Done() 通道有效性与内存可见性同步。

第三章：超时生效的三大关键保障机制

3.1 可取消IO原语的正确适配：基于go1.22 net.Conn.CancelRead/CancelWrite的迁移实践

Go 1.22 引入 net.Conn.CancelRead() 和 CancelWrite()，替代旧式 SetReadDeadline 配合 context.WithTimeout 的脆弱组合。

核心迁移差异

• 旧方式依赖 deadline 状态机，易受竞态干扰
• 新原语直接触发底层 I/O 取消，零延迟响应 cancel signal

典型适配代码

// 原始（Go < 1.22）
conn.SetReadDeadline(time.Now().Add(5 * time.Second))
n, err := conn.Read(buf)

// 迁移后（Go 1.22+）
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
n, err := conn.Read(buf) // 非阻塞读，由 CancelRead() 主动中断
if errors.Is(err, net.ErrClosed) || errors.Is(err, context.Canceled) {
    conn.CancelRead() // 显式通知内核终止等待
}

CancelRead() 不会关闭连接，仅中止当前/后续阻塞读操作；需配合 errors.Is(err, context.Canceled) 判断取消原因。CancelWrite() 同理，适用于流式写入场景。

场景	推荐策略
HTTP/2 流复用	每 stream 独立调用 CancelRead
TLS 连接	在 tls.Conn 上直接调用
自定义协议解析器	在 parser loop 入口检查 ctx.Done()

graph TD
    A[goroutine 开始 Read] --> B{是否已调用 CancelRead?}
    B -- 是 --> C[内核立即返回 context.Canceled]
    B -- 否 --> D[正常阻塞等待数据]

3.2 HTTP客户端超时的全链路对齐：对比http.Client.Timeout、Request.Context()与底层transport.DialContext的优先级博弈

HTTP超时控制存在三层独立但耦合的机制，其生效顺序决定最终行为。

优先级规则

• Request.Context() 超时最高优先级，可中断任意阶段（Dial、TLS握手、Read/Write）
• http.Client.Timeout 是兜底全局超时，仅作用于整个请求生命周期（不含Dial前准备）
• transport.DialContext 的超时仅约束连接建立，且被 Context 显式覆盖

超时层级关系（mermaid）

graph TD
    A[Context Deadline] -->|中断所有阶段| B[Transport RoundTrip]
    C[Client.Timeout] -->|覆盖RoundTrip总耗时| B
    D[DialContext Timeout] -->|仅约束TCP/TLS建连| E[Dialer]
    A -->|可取消Dialer| E

关键代码示意

client := &http.Client{
    Timeout: 10 * time.Second,
    Transport: &http.Transport{
        DialContext: func(ctx context.Context, netw, addr string) (net.Conn, error) {
            // 此处ctx已含Request.Context()的Deadline
            return (&net.Dialer{Timeout: 5 * time.Second}).DialContext(ctx, netw, addr)
        },
    },
}
req, _ := http.NewRequestWithContext(
    context.WithTimeout(context.Background(), 3*time.Second), 
    "GET", "https://api.example.com", nil,
)

context.WithTimeout 的 3s 会强制终止 Dial（即使 Dialer 设为 5s），而 Client.Timeout 仅在 Context 未设限时生效。DialContext 中的硬编码超时仅作为 fallback。

3.3 数据库驱动超时的context穿透验证：以pgx/v5和sqlx为例演示queryContext如何触发lib/pq连接层中断

context超时如何抵达底层驱动

Go 的 database/sql 接口要求驱动实现 QueryContext，而 pgx/v5 和 sqlx（基于 database/sql）均将 context.Context 透传至连接层。关键路径为：
sqlx.DB.QueryContext → sql.DB.QueryContext → driver.QueryerContext → pgx.Conn.Query → net.Conn.SetDeadline

驱动层中断机制对比

驱动	是否响应 ctx.Done()	中断触发点	超时后错误类型
pgx/v5	✅ 原生支持	conn.writeBuf.Flush()	context.DeadlineExceeded
sqlx+lib/pq	✅（通过database/sql封装）	pq.writeBuffer.Flush()	pq: server closed the connection

ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
defer cancel()
_, err := db.QueryContext(ctx, "SELECT pg_sleep(1)") // 触发超时

此调用最终在 pgx 的 writeBuf.Flush() 中检测 ctx.Err() != nil，立即返回并关闭底层 net.Conn；lib/pq 则依赖 database/sql 的 cancel 通道通知，延迟略高。

中断传播时序（简化）

graph TD
    A[QueryContext] --> B[Driver QueryerContext]
    B --> C{pgx/v5?}
    C -->|是| D[Check ctx.Err() before write]
    C -->|否| E[lib/pq: wait on cancel channel]
    D --> F[SetDeadline + return error]
    E --> F

第四章：线上故障根因定位与修复实战

4.1 基于trace.Span与context.DeadlineExceeded的故障归因自动化脚本

核心归因逻辑

当 HTTP 请求超时时，context.DeadlineExceeded 错误会沿调用链向上传播，而 OpenTelemetry 的 trace.Span 记录了各服务节点的耗时、状态码及父/子关系。二者结合可精准定位超时源头。

自动化脚本关键能力

• 解析 Jaeger/OTLP 导出的 span 数据流
• 匹配 error=true + status.code=2（即 DeadlineExceeded）的 span
• 回溯 span 链路，提取最深且耗时逼近 deadline 的上游 span

示例：超时根因提取逻辑

def find_root_span(spans: List[Span], deadline_ms: float) -> Span:
    # 筛选所有失败且含 DeadlineExceeded 的 span
    failed_spans = [s for s in spans if s.status.code == StatusCode.ERROR 
                    and "DeadlineExceeded" in s.status.description]
    # 按 duration 降序，取首个接近 deadline 的 span（非叶子节点）
    return max(failed_spans, key=lambda s: s.end_time - s.start_time)

逻辑说明：status.description 中显式包含 "DeadlineExceeded" 是 gRPC/HTTP middleware 注入的关键标识；end_time - start_time 提供真实耗时，避免仅依赖 duration 字段（部分 exporter 可能截断精度）。

归因结果结构

字段	含义	示例
span_id	根因 span ID	0xabcdef1234567890
service_name	所属服务	payment-service
duration_ms	实际执行耗时	1120.3
parent_span_id	上游调用方	0x9876543210fedcba

graph TD
    A[Client Request] --> B[API Gateway]
    B --> C[Order Service]
    C --> D[Payment Service]
    D --> E[Bank Adapter]
    E -.->|DeadlineExceeded| D
    D -.->|propagated error| C
    style D fill:#ff9999,stroke:#d00

4.2 使用gops+pprof定位“看似超时实则卡死”的goroutine阻塞点

当HTTP请求返回context deadline exceeded，但服务CPU/内存平稳，极可能是goroutine在系统调用或锁上永久阻塞，而非真正超时。

gops：实时诊断运行时状态

# 查看所有goroutine堆栈（含阻塞状态）
gops stack $(pidof myapp)

该命令直接调用runtime.Stack()，输出含syscall、semacquire等关键词的阻塞goroutine，精准区分“等待IO”与“死锁”。

pprof联动分析

# 抓取阻塞概览（非CPU profile！）
curl -s "http://localhost:6060/debug/pprof/goroutine?debug=2" > goroutines.txt

debug=2参数启用完整栈跟踪，可识别runtime.gopark调用链中的chan receive、sync.Mutex.Lock等阻塞原语。

常见阻塞模式对比

阻塞类型	pprof栈特征	典型修复方式
channel阻塞	runtime.chanrecv + select	检查发送方是否存活
mutex争用	sync.(*Mutex).Lock	引入读写锁或减少临界区
系统调用挂起	syscall.Syscall + epoll_wait	设置socket超时或改用非阻塞IO

graph TD
    A[HTTP超时告警] --> B{gops stack}
    B --> C[发现goroutine停在runtime.park]
    C --> D[pprof/goroutine?debug=2]
    D --> E[定位到chan recv on nil channel]
    E --> F[修复未初始化channel]

4.3 构建超时合规性静态检查工具：AST解析context.WithTimeout调用链完整性

核心挑战

context.WithTimeout 的有效性依赖于显式传递与及时取消：若返回的 ctx 未被下游函数接收，或被丢弃（如仅取 cancel 而忽略 ctx），则超时机制完全失效。

AST关键节点识别

需在 Go AST 中定位三类节点：

• *ast.CallExpr：调用 context.WithTimeout
• *ast.AssignStmt：解构返回值（ctx, cancel := context.WithTimeout(...)）
• *ast.Ident：后续函数调用中 ctx 参数的实际传入位置

示例检测代码片段

// 检测 ctx 是否在 defer 或关键调用中被使用
ctx, cancel := context.WithTimeout(parent, 5*time.Second)
defer cancel() // ✅ 必须存在 cancel 调用
http.Get(ctx, "https://api.example.com") // ✅ ctx 作为首参传入

逻辑分析：工具遍历 AssignStmt 后续语句，匹配 Ident 名为 ctx 的参数出现在函数调用第 1 位；同时验证同作用域内存在 defer cancel() 或显式 cancel() 调用。参数 parent 需非 nil，timeout 需为编译期可判定正数常量或变量（避免 或负值）。

检查规则矩阵

规则项	合规示例	违规模式
ctx 传递完整性	f(ctx, req)	f(req)（缺失 ctx）
cancel 调用保障	defer cancel()	无任何 cancel() 调用
timeout 有效性	time.Second * 5	time.Duration(0)

graph TD
    A[Parse Go source] --> B[Find WithTimeout call]
    B --> C[Extract ctx/cancel identifiers]
    C --> D[Trace ctx usage in calls]
    C --> E[Verify cancel invocation]
    D & E --> F[Report missing link]

4.4 灰度发布中超时策略渐进式升级方案：从defaultTimeout→serviceLevelTimeout→endpointGranularTimeout

灰度发布中，粗粒度超时配置易引发级联失败。渐进式升级通过三层超时控制实现精准治理：

超时策略演进路径

• defaultTimeout：全局默认值（如3s），适用于初期快速上线
• serviceLevelTimeout：按服务名差异化（如user-service: 2.5s, order-service: 4s）
• endpointGranularTimeout：细化至接口级（如POST /v1/orders/create: 5s, GET /v1/users/profile: 1.8s）

配置示例（Spring Cloud Gateway）

spring:
  cloud:
    gateway:
      routes:
        - id: user-service
          uri: lb://user-service
          predicates:
            - Path=/api/users/**
          metadata:
            timeout: 1800  # 单位：毫秒 → endpointGranularTimeout

该配置覆盖全局defaultTimeout，并被serviceLevelTimeout继承；实际生效优先级为：endpoint > service > default。

超时决策流程

graph TD
    A[请求到达] --> B{是否命中endpointGranularTimeout？}
    B -->|是| C[使用接口级超时]
    B -->|否| D{是否匹配serviceLevelTimeout？}
    D -->|是| E[使用服务级超时]
    D -->|否| F[回退defaultTimeout]

策略层级	生效范围	动态热更新	典型响应时间
defaultTimeout	全局	✅	≥3000ms
serviceLevelTimeout	服务维度	✅	1500–4000ms
endpointGranularTimeout	接口维度	✅	800–6000ms

第五章：下一代超时治理范式的演进方向

智能自适应超时决策引擎

某头部电商在大促期间引入基于实时指标反馈的动态超时调节系统。该引擎每10秒采集服务P99响应延迟、线程池活跃度、下游错误率三类信号，通过轻量级XGBoost模型预测最优超时阈值。上线后，订单创建链路超时熔断率下降62%，同时因超时导致的重复下单投诉归零。其核心配置片段如下：

adaptive_timeout:
  enabled: true
  feedback_interval_ms: 10000
  predictors:
    - metric: "p99_latency_ms"
      weight: 0.45
    - metric: "thread_pool_active_ratio"
      weight: 0.35
    - metric: "downstream_5xx_rate"
      weight: 0.20

全链路超时预算建模

金融风控平台采用“超时预算（Timeout Budget）”机制重构调用树。将端到端3s SLA按调用深度逐层分配：网关层预留200ms，规则引擎层800ms，特征服务层1.2s，外部征信API仅分配600ms。当某次征信调用耗时达580ms时，系统自动触发降级策略——启用本地缓存特征并标记“弱一致性”。下表为典型链路预算分配与实际执行数据对比：

组件层级	预算(ms)	实际均值(ms)	预算使用率	降级触发次数/日
API网关	200	42	21%	0
规则引擎	800	715	89%	12
征信服务	600	592	99%	217

超时语义化标注体系

在Kubernetes集群中，通过OpenTelemetry Span属性注入超时语义标签。例如对支付回调接口打标timeout.behavior=retry-on-408，对库存扣减接口打标timeout.behavior=abort-and-compensate。APM平台据此生成差异化告警策略：前者仅当连续3次408且重试失败才触发P1告警，后者在首次超时即启动Saga补偿事务。该实践使误报率降低73%，补偿事务成功率提升至99.98%。

混沌工程驱动的超时韧性验证

某物流调度系统将超时配置纳入Chaos Mesh实验矩阵。每周自动执行三类故障注入：① 强制下游服务响应延迟突增至2s（模拟网络抖动）；② 随机丢弃15%超时响应包（验证重试幂等性）；③ 动态修改Envoy超时Header字段（测试客户端兼容性）。所有实验均通过预设SLO校验：订单状态最终一致性误差

跨语言超时契约标准化

Dubbo+gRPC混合架构团队制定《超时契约规范V2.1》，强制要求所有跨进程调用必须声明@TimeoutContract注解。Java侧生成IDL时自动注入timeout_ms=3000元数据，Go微服务通过gRPC拦截器解析该字段并映射为context.WithTimeout参数。当某次版本升级导致契约字段缺失时，服务注册中心直接拒绝实例注册，并输出结构化错误码TIMEOUT_CONTRACT_MISSING=0x1A03。该机制使跨语言调用超时不一致问题归零。

多模态超时可观测性看板

运维团队构建融合指标、日志、追踪的超时诊断看板。左侧实时渲染超时热力图（按服务名×时间窗口着色），中部展示Top5超时根因分析树（含网络延迟、GC停顿、锁竞争占比），右侧嵌入可交互Mermaid时序图：

sequenceDiagram
    participant C as Client
    participant S as Service A
    participant D as DB Proxy
    C->>S: HTTP POST /order (timeout=2s)
    S->>D: JDBC query (timeout=1.5s)
    D-->>S: TimeoutException after 1520ms
    S-->>C: 504 Gateway Timeout