【Go语言网络协议全栈解析】：HTTP/HTTPS、TCP/UDP、WebSocket、gRPC、QUIC五大协议底层实现与实战优化

第一章：HTTP/HTTPS协议的Go语言底层实现与演进

Go 语言标准库 net/http 是 HTTP 协议实现的典范——它不依赖第三方 C 库，完全用 Go 编写，兼顾性能、安全与可维护性。其设计遵循分层抽象原则：底层基于 net.Conn 封装 TCP 连接，中层构建 http.Request 和 http.Response 的序列化/解析逻辑，上层提供 ServeMux 路由器与 Handler 接口契约。

核心连接模型

Go 的 HTTP 服务器默认启用 Keep-Alive 和连接复用。每个 *http.Server 实例通过 srv.Serve(lis) 启动监听，内部为每个新连接启动 goroutine 执行 c.serve(connCtx)。该 goroutine 持有连接状态、读取请求头（支持 HTTP/1.1 分块传输与 Transfer-Encoding: chunked）、解析 URI 和方法，并构造 http.Request 结构体。值得注意的是，Request.Body 是惰性读取的 io.ReadCloser，避免内存预分配。

TLS 握手集成机制

HTTPS 并非独立协议栈，而是 HTTP over TLS。Go 通过 http.Server.TLSConfig 字段注入 *tls.Config，在 ListenAndServeTLS 中自动包装 net.Listener 为 tls.Listener。握手由 crypto/tls 包完成，支持 ALPN 协商（如 h2 或 http/1.1），并透明传递至 HTTP 层——当客户端声明 ALPN: h2 时，Go 会触发 http2.ConfigureServer(srv, nil) 自动启用 HTTP/2 支持（Go 1.6+ 默认内置）。

协议演进关键节点

版本	关键变更	影响
Go 1.0	初始 HTTP/1.1 支持	无 HTTP/2、无 Server-Sent Events
Go 1.6	内置 HTTP/2（ALPN 自动协商）	无需额外 import，ServeTLS 自动升级
Go 1.8	引入 http.Pusher 接口（HTTP/2 Server Push）	支持主动推送资源，需 ResponseWriter 类型断言
Go 1.19	http.Request.WithContext 成为推荐模式	显式传递上下文替代隐式 r.Context()

以下代码演示如何强制启用 HTTP/2 并验证 ALPN：

srv := &http.Server{
    Addr: ":8443",
    Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        if r.TLS != nil && len(r.TLS.NegotiatedProtocol) > 0 {
            w.Header().Set("X-Proto", r.TLS.NegotiatedProtocol) // 如 "h2"
        }
        w.Write([]byte("OK"))
    }),
}
// 启动前显式配置 TLS（需证书）
srv.TLSConfig = &tls.Config{NextProtos: []string{"h2", "http/1.1"}}
log.Fatal(srv.ListenAndServeTLS("cert.pem", "key.pem"))

第二章：TCP/UDP协议的Go语言网络编程深度解析

2.1 Go net.Conn接口与TCP三次握手的底层建模

Go 的 net.Conn 接口抽象了双向字节流，却不暴露连接建立细节——它将三次握手完全封装在底层 sysConn 和 poll.FD 中。

TCP状态迁移与 Conn 生命周期

// Dialer 默认启用 TCP Fast Open（Linux 4.11+）
d := &net.Dialer{
    KeepAlive: 30 * time.Second,
    Timeout:   5 * time.Second, // 控制 connect(2) 系统调用超时
}
conn, err := d.Dial("tcp", "example.com:80")

Timeout 参数直接映射到 connect(2) 系统调用的阻塞等待，失败时返回 os.SyscallError，内含 EINPROGRESS（非阻塞）或 ECONNREFUSED（RST响应）等底层 errno。

关键状态映射表

Conn 方法	对应 TCP 状态	触发条件
conn.Write()	ESTABLISHED	握手完成，发送缓冲区就绪
conn.Read()	ESTABLISHED	收到 SYN-ACK 后内核自动完成
conn.Close()	FIN-WAIT-1	内核发起 FIN，触发半关闭流程

graph TD
    A[Client.Dial] --> B[SYN sent]
    B --> C[SYN-ACK received]
    C --> D[ACK sent → ESTABLISHED]
    D --> E[net.Conn.Read/Write usable]

2.2 UDP无连接通信的Go实现与高并发Datagram处理实践

UDP 的轻量特性使其成为实时音视频、IoT上报和游戏状态同步的理想选择。Go 通过 net.ListenUDP 提供原生支持，但高并发下需规避阻塞式 ReadFrom 的性能瓶颈。

高效 Datagram 处理模式

• 使用 syscall.RecvMsg（通过 golang.org/x/sys/unix）实现零拷贝接收
• 基于 sync.Pool 复用 []byte 缓冲区，避免频繁 GC
• 每个 goroutine 绑定独立 UDPConn 并启用 SetReadBuffer

核心实现片段

conn, _ := net.ListenUDP("udp", &net.UDPAddr{Port: 8080})
bufPool := sync.Pool{New: func() interface{} { return make([]byte, 65536) }}

for {
    buf := bufPool.Get().([]byte)
    n, addr, err := conn.ReadFrom(buf)
    if err != nil { continue }

    go func(b []byte, n int, addr net.Addr) {
        defer bufPool.Put(b) // 归还缓冲区
        processDatagram(b[:n], addr)
    }(buf, n, addr)
}

逻辑说明：bufPool.Get() 复用大缓冲区；ReadFrom 返回实际字节数 n，确保仅处理有效载荷；defer bufPool.Put(b) 在 goroutine 结束时归还内存，防止泄漏。processDatagram 应为无阻塞业务逻辑。

方案	吞吐量（万 pkt/s）	内存分配/秒	适用场景
单 goroutine 阻塞	1.2	高	调试/低负载
Goroutine 池	8.7	中	中等规模服务
IO 多路复用+Pool	24.3	低	百万级设备接入

graph TD
    A[UDP Socket] --> B{RecvMsg 系统调用}
    B --> C[内核缓冲区]
    C --> D[用户态 Pool 缓冲区]
    D --> E[并发 goroutine 处理]
    E --> F[业务逻辑/响应]

2.3 基于syscall.Socket的Raw Socket编程与协议栈绕过优化

Raw Socket通过syscall.Socket直接调用内核socket系统调用，跳过TCP/UDP协议栈封装，适用于自定义协议、高性能探测或内核旁路场景。

核心系统调用链

• syscall.Socket(AF_INET, SOCK_RAW, IPPROTO_ICMP) 创建原始套接字
• 需CAP_NET_RAW能力（非root需sudo setcap cap_net_raw+ep ./binary）

ICMP Echo请求示例

fd, err := syscall.Socket(syscall.AF_INET, syscall.SOCK_RAW, syscall.IPPROTO_ICMP)
if err != nil {
    log.Fatal(err) // 返回文件描述符fd，非*net.Conn
}

AF_INET指定IPv4地址族；SOCK_RAW启用原始报文收发；IPPROTO_ICMP告知内核不自动填充IP头校验和——由用户空间完全控制IP+ICMP头布局。

协议栈绕过对比

特性	标准net.Conn	syscall.RawSocket
IP头控制权	❌（内核生成）	✅（用户填充）
校验和计算	内核自动	必须手动计算
端口绑定必要性	必须	无需

graph TD
    A[应用层构造ICMP包] --> B[syscall.Write(fd, rawBytes)]
    B --> C[内核仅执行链路层封装]
    C --> D[绕过IPv4/ICMP校验、分片、路由缓存等]

2.4 TCP粘包/拆包问题的Go原生解决方案与自定义FrameCodec设计

TCP 是面向字节流的协议，无法天然区分应用层消息边界，导致粘包（多个逻辑包被合并接收）与拆包（单个逻辑包被分片接收）问题。

Go 原生应对策略

• bufio.Scanner：适合行分隔场景，但不支持自定义长度字段；
• io.ReadFull + 固定头长解析：需手动读取 header 获取 payload length；
• net.Conn 配合循环 Read() + 状态机缓冲：灵活但易出错。

自定义 FrameCodec 核心设计

type FrameCodec struct {
    buf     []byte
    header  [4]byte // uint32 BE length prefix
}

func (c *FrameCodec) Decode(conn net.Conn) ([]byte, error) {
    if _, err := io.ReadFull(conn, c.header[:]); err != nil {
        return nil, err
    }
    length := binary.BigEndian.Uint32(c.header[:])
    c.buf = make([]byte, length)
    _, err := io.ReadFull(conn, c.buf) // 阻塞直到收齐
    return c.buf, err
}

逻辑说明：先读 4 字节大端长度头，再按该长度精确读取有效载荷；io.ReadFull 保证原子性，避免拆包干扰。binary.BigEndian 确保跨平台字节序一致。

方案	边界识别方式	适用场景
bufio.Scanner	换行符	日志、文本协议
Header-based	固定长度前缀	二进制 RPC 协议
TLV	Type-Length-Value	复杂可扩展协议

graph TD
    A[Client Send] -->|TCP Stream| B[Kernel Buffer]
    B --> C{FrameCodec.Decode}
    C --> D[Read 4B Header]
    D --> E[Extract Length]
    E --> F[Read Exactly N Bytes]
    F --> G[Deliver Complete Frame]

2.5 连接池、Keep-Alive与TIME_WAIT状态的Go运行时调优实战

Go 的 http.Transport 是连接复用与资源控制的核心。默认配置在高并发短连接场景下易触发大量 TIME_WAIT，拖慢端口复用效率。

连接池关键参数调优

transport := &http.Transport{
    MaxIdleConns:        100,           // 全局空闲连接上限
    MaxIdleConnsPerHost: 100,           // 每主机空闲连接上限（避免单域名占满）
    IdleConnTimeout:     30 * time.Second, // 空闲连接保活时长
    KeepAlive:           30 * time.Second, // TCP keep-alive探测间隔
}

MaxIdleConnsPerHost 必须显式设置，否则默认为 2，成为性能瓶颈；IdleConnTimeout 应略大于后端服务的 keepalive_timeout，防止连接被服务端静默关闭。

TIME_WAIT 缓解策略对比

方案	是否需 root 权限	风险	Go 层可控性
net.ipv4.tcp_tw_reuse=1	是	低（仅对 TIME_WAIT 套接字重用于 outbound）	❌ 系统级
transport.ForceAttemptHTTP2 = true	否	中（依赖服务端支持）	✅
主动复用 + 合理超时	否	无	✅✅

TCP 状态流转示意

graph TD
    A[ESTABLISHED] -->|KeepAlive 探测成功| A
    A -->|FIN 收发完成| B[FIN_WAIT_1]
    B --> C[TIME_WAIT]
    C -->|2MSL 超时| D[CLOSED]

第三章：WebSocket协议的Go语言全生命周期管理

3.1 RFC 6455握手流程的Go标准库与gorilla/websocket源码级剖析

WebSocket 握手本质是 HTTP 升级协商：客户端发送 Upgrade: websocket 请求，服务端返回 101 Switching Protocols 响应。

标准库 net/http 的握手关键点

http.ResponseWriter 的 Hijack() 被用于接管底层 TCP 连接，绕过 HTTP 流水线。

// src/net/http/server.go (简化示意)
func (w *response) Hijack() (net.Conn, *bufio.ReadWriter, error) {
    if !w.canHijack() {
        return nil, nil, errors.New("http: connection has been hijacked")
    }
    w.wroteHeader = true // 防止后续 WriteHeader 干扰
    return w.conn.conn, w.bufrw, nil
}

w.conn.conn 是原始 net.Conn；w.bufrw 提供带缓冲的读写能力，为后续 WebSocket 帧解析奠定基础。

gorilla/websocket 的增强逻辑

• 自动校验 Sec-WebSocket-Key / Accept Base64-SHA1
• 支持自定义 CheckOrigin
• 严格遵循 RFC 6455 §4.2.2 的 header 验证顺序

验证项	标准库支持	gorilla/websocket
Upgrade: websocket	✅（需手动检查）	✅（Upgrade() 内置）
Connection: upgrade	✅	✅
Sec-WebSocket-Key	❌（需自行解析）	✅（checkKey()）

graph TD
    A[Client GET /ws] --> B{Server reads headers}
    B --> C[Validate Upgrade, Connection, Key]
    C --> D[Generate Accept hash]
    D --> E[Write 101 + headers]
    E --> F[Hijack & switch to WS frame mode]

3.2 消息帧解析、Masking算法与二进制/文本消息的零拷贝处理

WebSocket 协议要求客户端发送的所有帧必须启用掩码（Masking），服务端则禁止掩码——这是强制性的安全机制，防止代理缓存污染。

Masking 算法原理

掩码密钥为 4 字节随机值，按字节循环异或载荷数据：

fn unmask_payload(mask: [u8; 4], payload: &mut [u8]) {
    for (i, byte) in payload.iter_mut().enumerate() {
        *byte ^= mask[i % 4];
    }
}

mask: 客户端帧首部中 masking-key 字段；payload: payload-length 指向的实际数据区。异或操作可逆，加解密逻辑完全对称。

零拷贝处理策略

• 文本帧：直接映射 UTF-8 字节切片，延迟验证（std::str::from_utf8_unchecked() + 后置校验）
• 二进制帧：Bytes（bytes::Bytes）引用计数共享，避免 Vec<u8> 复制

帧类型	内存模型	验证时机
TEXT	&[u8] → &str（延迟）	首次访问时
BINARY	Bytes（ARC）	无需解码

graph TD
    A[接收原始帧] --> B{FIN == 1?}
    B -->|是| C[提取mask+payload]
    B -->|否| D[聚合分片]
    C --> E[unmask_payload]
    E --> F[零拷贝视图构造]

3.3 长连接保活、心跳机制与异常断连的自动重连策略实现

心跳包设计原则

• 频率：间隔 ≤ 服务端超时阈值的 1/3（如服务端 idle timeout=90s，则心跳周期设为≤30s）
• 轻量：仅含协议头+时间戳+校验字段，避免业务数据混入
• 双向：客户端发 PING，服务端必须响应 PONG，单向探测无法发现对端静默崩溃

客户端心跳与重连核心逻辑

import asyncio
import time

async def heartbeat_loop(ws, interval=25):
    while ws.open:  # 仅在连接活跃时发送
        try:
            await ws.send(json.dumps({"type": "PING", "ts": int(time.time())}))
            await asyncio.sleep(interval)
        except websockets.exceptions.ConnectionClosed:
            break  # 触发重连流程

逻辑说明：ws.open 实时检测连接状态；await ws.send() 阻塞直到帧写入缓冲区；ConnectionClosed 异常捕获网络中断或服务端主动关闭。该协程与主业务流并发运行，不阻塞数据收发。

重连策略状态机

graph TD
    A[断连] --> B{重试次数 < 5?}
    B -->|是| C[指数退避：1s→2s→4s→8s]
    B -->|否| D[告警并暂停]
    C --> E[尝试重建WebSocket]
    E --> F{连接成功?}
    F -->|是| G[重置计数器，启动心跳]
    F -->|否| B

重连参数对照表

参数	推荐值	说明
初始重试间隔	1000 ms	避免雪崩式重连
退避倍数	2.0	每次失败后乘以该系数
最大重试次数	5	防止无限循环耗尽资源
连接超时	5000 ms	防止 SYN 半开连接阻塞

第四章：gRPC与QUIC协议的Go语言融合实践

4.1 gRPC over HTTP/2的Go底层适配：http2.Server与Stream生命周期追踪

gRPC在Go中并非直接构建于net/http之上，而是深度复用net/http2包提供的http2.Server，并注入自定义Handler拦截HTTP/2流。

Stream生命周期关键钩子

• http2.Server.NewWriteScheduler：控制帧调度策略（如RoundRobin或Priority）
• http2.Server.MaxConcurrentStreams：限制单连接最大活跃Stream数（默认100）
• http2.Server.ReadTimeout / WriteTimeout：影响Stream空闲超时行为

内部Stream状态流转

// grpc-go/internal/transport/http2_server.go 片段
func (t *http2Server) operateHeaders(frame *http2.MetaHeadersFrame) error {
    // 创建新stream时触发，绑定rpcMethod、ctx、recvMsg等
    s := &Stream{
        id:       frame.HeaderStreamID(),
        method:   methodNameFromHeaders(frame),
        ctx:      t.ctx,
        recv:     make(chan *transport.Message, 1),
    }
    t.activeStreams[s.id] = s // 注册到活跃流映射表
    return nil
}

该函数在接收到HEADERS帧时创建Stream实例，完成RPC上下文初始化与流注册；id由HTTP/2协议分配，method从:path伪头解析，recv通道用于后续RecvMsg阻塞读取。

流终止时机对照表

触发事件	对应回调机制	是否释放资源
客户端发送RST_STREAM	stream.finish(errors.New("cancelled"))	是
服务端调用SendAndClose	stream.st.Close()（关闭send方向）	否（需等待recv结束）
TCP连接断开	http2Server.closeAllStreams()	是

graph TD
    A[Client SEND HEADERS] --> B[http2Server.operateHeaders]
    B --> C[Stream created & registered]
    C --> D{Stream active?}
    D -->|Yes| E[DATA frames → RecvMsg]
    D -->|No| F[finish called → cleanup]
    E --> G[Server SEND trailers]
    G --> F

4.2 Protocol Buffer序列化在Go中的内存布局优化与Unsafe反射加速

Protocol Buffer 默认的 Go 生成代码使用 interface{} 和反射，带来显著的内存分配与类型检查开销。优化核心在于绕过反射路径、复用内存、直接操作结构体字段偏移。

零拷贝字段访问

通过 unsafe.Offsetof() 提前计算字段内存偏移，结合 unsafe.Pointer 直接读写：

// 假设 pb.Message 结构体首字段为 int32 size
offset := unsafe.Offsetof(pb.Message{}.Size_)
sizePtr := (*int32)(unsafe.Pointer(uintptr(unsafe.Pointer(&msg)) + offset))
*sizePtr = 1024 // 直接写入，无反射、无接口转换

逻辑：unsafe.Offsetof 在编译期确定字段偏移（常量），uintptr + offset 跳转到目标地址；(*int32) 强制类型转换实现零成本写入。需确保结构体未被 GC 移动（如 &msg 是栈变量或已 pin）。

性能对比（序列化 10K 次）

方式	平均耗时	分配内存	GC 次数
标准 proto.Marshal	18.2 µs	1.2 KiB	0.8
Unsafe 字段直写	3.1 µs	0 B	0

注：Unsafe 方案要求字段内存布局稳定（禁用 //go:build gcflags=-l 等干扰优化），且仅适用于已知 schema 的高频热路径。

4.3 基于quic-go库的QUIC连接建立、0-RTT握手与多路复用实测对比

连接建立与0-RTT启用关键配置

启用0-RTT需客户端缓存早期密钥材料，并在quic.Config中显式开启：

config := &quic.Config{
    Enable0RTT: true,
    TLSConfig: &tls.Config{
        NextProtos: []string{"h3"},
        // 必须设置ClientSessionCache以复用会话
        ClientSessionCache: tls.NewLRUClientSessionCache(100),
    },
}

该配置使客户端在重连时可直接发送加密应用数据（0-RTT），但服务端需调用session.ConnectionState().Used0RTT判别数据安全性。

多路复用性能对比（10并发流，单位：ms）

场景	平均延迟	连接建立耗时	数据吞吐量
TCP + HTTP/1.1	42.3	89.1	14.2 MB/s
QUIC + 0-RTT	18.7	12.4	36.8 MB/s

流程差异示意

graph TD
    A[客户端发起连接] --> B{是否命中0-RTT缓存？}
    B -->|是| C[立即发送加密应用数据]
    B -->|否| D[执行完整1-RTT握手]
    C & D --> E[并行创建多个Stream]
    E --> F[独立流控与帧复用]

4.4 gRPC-QUIC混合传输层抽象：自定义Transport与流控策略迁移方案

为支持gRPC over QUIC的无缝集成，需剥离底层TCP绑定，构建可插拔的Transport抽象接口：

type Transport interface {
    DialContext(ctx context.Context, addr string) (StreamConn, error)
    Accept() (StreamConn, error)
    Close() error
}

该接口解耦连接生命周期管理与协议实现，使quic-go可直接注入为底层传输。

流控策略迁移关键点

• 原gRPC TCP流控（tcpInfo.sendQuota）需映射为QUIC的stream.SendWindow()动态窗口
• 应用层写入需适配quic.Stream.Write()的非阻塞语义与context.Deadline传播

协议栈适配对比

维度	TCP Transport	QUIC Transport
连接建立延迟	3×RTT（含TLS）	0–1×RTT（0-RTT支持）
流控粒度	连接级窗口	每流独立窗口+连接级信用
错误恢复	重传依赖内核TCP栈	应用层可控丢包响应

graph TD
    A[gRPC Client] -->|Unary/Streaming| B[Transport Interface]
    B --> C[TCP Implementation]
    B --> D[QUIC Implementation]
    D --> E[quic-go Session]
    E --> F[Per-Stream Flow Control]

第五章：五大协议协同演进与云原生网络架构展望

在混合云大规模生产环境中，Kubernetes集群跨AZ调度Pod时，常面临服务发现延迟高、东西向流量加密开销大、多租户策略冲突等现实问题。某金融级云平台（日均处理2.3亿API请求）通过重构底层网络协议栈，实现了五大核心协议的深度协同演进——HTTP/3、QUIC、gRPC-Web、eBPF-based CNI（Cilium）、以及Service Mesh控制面协议（xDS v3）。该实践并非孤立升级，而是以数据平面一致性为约束条件进行联合调优。

协议语义对齐驱动配置收敛

传统方案中，Ingress控制器、Sidecar代理、CNI插件各自维护独立的TLS终止策略，导致同一服务在不同层级出现证书链不一致。新架构将TLS 1.3握手参数、ALPN协商列表、0-RTT启用开关统一注入xDS v3的TransportSocket配置，并通过eBPF程序在veth pair入口处动态校验QUIC Initial包的SNI字段是否匹配服务注册名。以下为实际部署中验证过的配置片段：

# xDS v3 TransportSocket 配置节（已上线生产）
transport_socket:
  name: envoy.transport_sockets.tls
  typed_config:
    "@type": type.googleapis.com/envoy.extensions.transport_sockets.tls.v3.UpstreamTlsContext
    common_tls_context:
      tls_params:
        tls_maximum_protocol_version: TLSv1_3
        tls_minimum_protocol_version: TLSv1_3
      alpn_protocols: ["h3", "http/1.1"]

流量路径压缩实现毫秒级故障切换

当某Region的gRPC后端因硬件故障不可达时，旧架构依赖kube-proxy iptables链式跳转（平均5层NAT），故障检测+重路由耗时达320ms。新方案利用eBPF bpf_redirect_peer()直接在TC ingress hook将流量重定向至同节点的QUIC代理缓存池，并通过HTTP/3的SETTINGS帧携带服务健康状态码（0x0A=“graceful drain”），使客户端在2个RTT内完成无损重连。下表对比了关键指标：

指标	旧架构（iptables + kube-proxy）	新架构（eBPF + QUIC + xDS）
故障检测延迟	18s（默认kubelet探针间隔）	280ms（eBPF socket统计+gRPC Keepalive）
流量重定向耗时	320ms	14ms（内核态直通）
连接复用率提升	—	67%（QUIC connection migration）

安全策略的协议感知执行

某政务云客户要求PCI-DSS合规的三级隔离：数据库访问必须禁用TLS 1.2且强制双向mTLS。传统NetworkPolicy无法识别TLS版本，而Cilium 1.14+支持基于QUIC CONNECTION_ID和gRPC method前缀的L7策略。其策略定义如下（已部署至23个集群）：

flowchart LR
    A[Pod A] -->|gRPC call<br>method: /payment.Process| B[eBPF L7 Filter]
    B --> C{QUIC version == 1?}
    C -->|Yes| D[Check mTLS cert SAN]
    C -->|No| E[Drop packet]
    D --> F{SAN matches<br>db-payment.svc.cluster.local?}
    F -->|Yes| G[Forward to Pod B]
    F -->|No| H[Reject with error code 0x0F]

多协议状态同步机制

为避免HTTP/3流控窗口与gRPC流控令牌不一致导致死锁，平台开发了共享内存环形缓冲区（ringbuf），由eBPF程序实时采集每个QUIC stream的max_data值与gRPC initial_window_size差值，并通过bpf_map_update_elem()写入用户态策略引擎。该机制已在日均17TB东西向流量场景中稳定运行217天。

运维可观测性增强

所有协议交互事件（包括QUIC ACK帧丢失率、gRPC status code分布、xDS资源版本热更新延迟）均通过eBPF perf_event_array输出至OpenTelemetry Collector，经采样后写入ClickHouse。运维团队可直接查询SQL定位协议层瓶颈：

SELECT 
  protocol, 
  quantile(0.99)(rtt_ms) AS p99_rtt,
  count() AS total_events
FROM otel_traces 
WHERE timestamp > now() - INTERVAL '1 HOUR'
  AND span_name IN ('quic_handshake', 'grpc_server_stream')
GROUP BY protocol