第40周：可观测性与故障诊断

字数统计: 3k字   |   阅读时长≈ 16分

第40周：可观测性与故障诊断

目标：理解现代可观测性体系（Metrics、Logging、Tracing），能够为 L4 负载均衡器添加 per-packet 事件日志，并使用 eBPF 采集网络诊断信息。

1. 可观测性三大支柱

1.1 三个维度

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
可观测性（Observability）= 三个核心支柱

┌─────────────────────────────────────────────────────┐
│                                                       │
│   ┌──────────────┐  ┌──────────────┐  ┌────────────┐ │
│   │   Metrics    │  │   Logging    │  │  Tracing   │ │
│   │   指标       │  │   日志       │  │  追踪      │ │
│   │              │  │              │  │            │ │
│   │ 聚合的数值   │  │离散的事件    │  │请求链路    │ │
│   │ 计数器/直方图 │  │文本/JSON     │  │span/trace  │ │
│   │ Prometheus   │  │ ELK/Loki     │  │Jaeger/Zipkin│
│   └──────────────┘  └──────────────┘  └────────────┘ │
│                                                       │
│   "什么发生了"        "具体细节"      "为什么这么慢"   │
│                                                       │
└─────────────────────────────────────────────────────┘

1.2 网络场景的可观测性

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
网络包的可观测性：

  包级别（per-packet）：
    - 包内容（5 元组、长度、标志）
    - 时间戳（收、发、转发）
    - 路径（经过的每个模块）
    - 处理延迟

  流级别（per-flow）：
    - 5 元组聚合
    - PPS、BPS
    - RTT、重传
    - 持续时间

  节点级别（per-node）：
    - CPU/内存使用
    - 端口利用率
    - 队列长度
    - 丢包统计

2. 性能指标体系

2.1 关键指标

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
// metrics.h — 指标定义
#ifndef METRICS_H
#define METRICS_H

#include <stdint.h>
#include <rte_atomic.h>

// 计数器
typedef struct {
    // 包级指标
    rte_atomic64_t total_packets;
    rte_atomic64_t total_bytes;
    rte_atomic64_t dropped_packets;

    // 流级指标
    rte_atomic64_t tcp_packets;
    rte_atomic64_t udp_packets;
    rte_atomic64_t icmp_packets;
    rte_atomic64_t other_packets;

    // 错误
    rte_atomic64_t checksum_errors;
    rte_atomic64_t mbuf_errors;
    rte_atomic64_t route_misses;

    // 延迟（直方图）
    // 简化：只保留几个分位数
    rte_atomic64_t latency_sum_ns;       // 总延迟
    rte_atomic64_t latency_count;        // 包数
    rte_atomic64_t latency_min_ns;       // 最小
    rte_atomic64_t latency_max_ns;       // 最大

    // 带宽（按时间窗）
    rte_atomic64_t bps_current;
    rte_atomic64_t pps_current;
} lb_metrics_t;

// 全局指标
extern lb_metrics_t g_metrics;

// 更新宏（per-CPU 友好）
#define METRIC_INC(m) rte_atomic64_inc(&g_metrics.m)
#define METRIC_ADD(m, v) rte_atomic64_add(&g_metrics.m, v)
#define METRIC_GET(m) rte_atomic64_read(&g_metrics.m)

#endif

2.2 延迟测量

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
// latency.h — 延迟测量（直方图）
#ifndef LATENCY_H
#define LATENCY_H

#include <stdint.h>
#include <rte_cycles.h>

// 延迟测量点
typedef struct {
    const char *name;
    uint64_t start_ts;       // 起始时间
    uint64_t end_ts;         // 结束时间
} latency_point_t;

// 测量点
#define MEASURE_START() rte_rdtsc()
#define MEASURE_END(start) (rte_rdtsc() - (start))

// 延迟直方图
typedef struct {
    uint64_t count;          // 总数
    uint64_t sum_ns;         // 总和
    uint64_t min_ns;         // 最小
    uint64_t max_ns;         // 最大

    // 直方图桶（指数分桶）
    uint64_t buckets[32];    // 2^0, 2^1, ..., 2^31 ns
} latency_hist_t;

static inline void hist_record(latency_hist_t *h, uint64_t latency_ns) {
    h->count++;
    h->sum_ns += latency_ns;
    if (latency_ns < h->min_ns) h->min_ns = latency_ns;
    if (latency_ns > h->max_ns) h->max_ns = latency_ns;

    // 找到桶
    int bucket = 0;
    while (bucket < 31 && latency_ns > (1ULL << bucket)) {
        bucket++;
    }
    h->buckets[bucket]++;
}

static inline void hist_print(latency_hist_t *h, const char *name) {
    if (h->count == 0) {
        printf("%s: no samples\n", name);
        return;
    }

    printf("%s: count=%lu avg=%.1f ns min=%lu ns max=%lu ns\n",
           name, h->count,
           (double)h->sum_ns / h->count,
           h->min_ns, h->max_ns);

    printf("Histogram (log scale):\n");
    for (int i = 0; i < 32; i++) {
        if (h->buckets[i] > 0) {
            printf("  <%lu ns: %lu\n", 1ULL << i, h->buckets[i]);
        }
    }
}

#endif

2.3 使用示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 在主循环中测量
void process_packet(struct rte_mbuf *m) {
    uint64_t start = MEASURE_START();

    // ... 处理逻辑 ...
    // 阶段1：解析包
    // 阶段2：查找路由
    // 阶段3：修改包
    // 阶段4：发送
    // 阶段5：统计

    uint64_t latency = MEASURE_END(start);
    hist_record(&g_latency_hist, rte_rdtsc_to_ns(latency));
}

3. 日志系统

3.1 日志级别与格式

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
// log.h — 分级日志
#ifndef LOG_H
#define LOG_H

#include <stdio.h>
#include <stdarg.h>
#include <time.h>

typedef enum {
    LOG_DEBUG = 0,
    LOG_INFO,
    LOG_WARN,
    LOG_ERROR,
    LOG_FATAL
} log_level_t;

extern log_level_t g_log_level;
extern FILE *g_log_file;

#define LOG(level, fmt, ...) do { \
    if (level >= g_log_level) { \
        time_t t = time(NULL); \
        struct tm *tm = localtime(&t); \
        fprintf(g_log_file ? g_log_file : stderr, \
                "[%04d-%02d-%02d %02d:%02d:%02d] [%s] " fmt "\n", \
                tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday, \
                tm->tm_hour, tm->tm_min, tm->tm_sec, \
                log_level_name(level), ##__VA_ARGS__); \
        fflush(g_log_file ? g_log_file : stderr); \
    } \
} while(0)

#define LOG_DEBUG(fmt, ...) LOG(LOG_DEBUG, fmt, ##__VA_ARGS__)
#define LOG_INFO(fmt, ...)  LOG(LOG_INFO, fmt, ##__VA_ARGS__)
#define LOG_WARN(fmt, ...)  LOG(LOG_WARN, fmt, ##__VA_ARGS__)
#define LOG_ERROR(fmt, ...) LOG(LOG_ERROR, fmt, ##__VA_ARGS__)
#define LOG_FATAL(fmt, ...) LOG(LOG_FATAL, fmt, ##__VA_ARGS__)

static inline const char *log_level_name(log_level_t level) {
    static const char *names[] = {
        "DEBUG", "INFO", "WARN", "ERROR", "FATAL"
    };
    return names[level];
}

void log_init(log_level_t level, const char *file);
void log_rotate(void);

#endif

3.2 结构化日志（JSON）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// 简单的 JSON 日志
#define JSON_LOG(event, fields...) do { \
    char json[1024]; \
    int n = 0; \
    n += snprintf(json + n, sizeof(json) - n, "{\"event\":\"%s\"", event); \
    fields; \
    n += snprintf(json + n, sizeof(json) - n, "}\n"); \
    write_json_log(json, n); \
} while(0)

// 使用
JSON_LOG("packet_drop", 
    snprintf(json + n, sizeof(json) - n,
             ",\"src_ip\":\"%u.%u.%u.%u\"",
             (saddr >> 24) & 0xFF,
             (saddr >> 16) & 0xFF,
             (saddr >> 8) & 0xFF,
             saddr & 0xFF);
    snprintf(json + n, sizeof(json) - n,
             ",\"reason\":\"%s\"", reason);
    snprintf(json + n, sizeof(json) - n,
             ",\"packet_len\":%u", pkt_len);
);

3.3 高性能日志技巧

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
性能 vs 详细度：

1. 同步写日志（慢）：
   - 每次日志都 write()
   - 阻塞
   - 适合：少量关键事件

2. 异步批量写：
   - 累积到 buffer
   - 批量写
   - 适合：高频事件

3. Ring buffer + 专用 writer 线程：
   - 数据面只写 ring
   - 专用线程读 ring 并写文件
   - 适合：极高频率

4. mmap 日志：
   - 内存映射文件
   - 零拷贝
   - 适合：现代方案

4. 全链路追踪（Tracing）

4.1 概念

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
分布式追踪（Dapper / OpenTracing / OpenTelemetry）：

  Trace = 完整请求链路
  Span = 链路中的一个节点

  ┌─────────────────────────────────────┐
  │         Trace                        │
  │                                       │
  │  ┌────────────┐                     │
  │  │ Span 1     │  ← 根 span          │
  │  │ 接收包      │                     │
  │  └─────┬──────┘                     │
  │        │ parent                     │
  │   ┌────┴────┐                       │
  │   │         │                        │
  │   ▼         ▼                        │
  │  ┌─────┐  ┌──────┐                  │
  │  │Span │  │Span │  ← 子 span         │
  │  │2 解析│  │3 路由│                  │
  │  └──┬──┘  └──┬───┘                  │
  │     │        │                      │
  │     ▼        ▼                      │
  │  ┌────────────────┐                 │
  │  │    Span 4       │                │
  │  │ 发送           │                │
  │  └────────────────┘                │
  └─────────────────────────────────────┘

4.2 包级追踪实现

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
// tracing.h — 包级追踪
#ifndef TRACING_H
#define TRACING_H

#include <stdint.h>
#include <rte_cycles.h>
#include <rte_ring.h>

// 一个 span
typedef struct {
    uint64_t trace_id;     // 唯一 trace ID
    uint64_t span_id;      // 当前 span ID
    uint64_t parent_id;    // 父 span ID
    char     name[32];     // 节点名
    uint64_t start_ts;     // 起始时间（TSC）
    uint64_t end_ts;       // 结束时间
    char     tags[256];     // 标签
} trace_span_t;

// 追踪事件
typedef struct {
    uint64_t trace_id;
    uint64_t span_id;
    uint64_t timestamp;
    char     event[64];
    char     payload[128];
} trace_event_t;

// 全局追踪 buffer
extern struct rte_ring *g_trace_ring;

// 创建 trace ID
static inline uint64_t trace_new_id() {
    static uint64_t counter = 0;
    return __atomic_add_fetch(&counter, 1, __ATOMIC_RELAXED);
}

// 报告 span
static inline void trace_span_report(trace_span_t *span) {
    struct rte_mbuf *m = rte_pktmbuf_alloc(...);
    if (m) {
        rte_memcpy(rte_pktmbuf_mtod(m, void *), span, sizeof(*span));
        rte_ring_enqueue(g_trace_ring, m);
    }
}

#define TRACE_SPAN(trace_id, name) ({ \
    trace_span_t _s = { \
        .trace_id = (trace_id), \
        .span_id = trace_new_id(), \
        .parent_id = 0, \
        .name = (name), \
        .start_ts = rte_rdtsc(), \
        .end_ts = 0, \
    }; \
    _s; \
})

#define TRACE_END(span) do { \
    (span).end_ts = rte_rdtsc(); \
    trace_span_report(&(span)); \
} while(0)

#endif

4.3 在 LB 中集成追踪

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
void lb_process_with_trace(struct rte_mbuf *m, uint32_t trace_id) {
    // 1. 接收 span
    trace_span_t recv_span = TRACE_SPAN(trace_id, "recv");
    // ... 收包处理 ...
    TRACE_END(recv_span);

    // 2. 解析 span
    trace_span_t parse_span = TRACE_SPAN(trace_id, "parse");
    struct rte_ether_hdr *eth = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
    struct rte_ipv4_hdr *ip = (void *)(eth + 1);
    // ... 解析 ...
    TRACE_END(parse_span);

    // 3. 查表 span
    trace_span_t lookup_span = TRACE_SPAN(trace_id, "lookup");
    struct ct_entry *sess = conntrack_lookup(...);
    TRACE_END(lookup_span);

    // 4. 转发 span
    trace_span_t fwd_span = TRACE_SPAN(trace_id, "forward");
    rte_eth_tx_burst(...);
    TRACE_END(fwd_span);
}

4.4 专用 writer 线程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// writer_thread.c — 后台写日志线程
void *trace_writer_thread(void *arg) {
    struct rte_ring *ring = (struct rte_ring *)arg;

    while (1) {
        struct rte_mbuf *m;
        // 阻塞等待 span
        if (rte_ring_dequeue(ring, (void **)&m) == 0) {
            trace_span_t *span = rte_pktmbuf_mtod(m, trace_span_t *);

            // 转为 JSON 写入文件
            uint64_t dur_ns = rte_rdtsc_to_ns(span->end_ts - span->start_ts);
            fprintf(log_file, "{\"trace_id\":%lu,\"span_id\":%lu,"
                              "\"name\":\"%s\",\"duration_ns\":%lu}\n",
                    span->trace_id, span->span_id, span->name, dur_ns);

            rte_pktmbuf_free(m);
        }
    }
    return NULL;
}

5. eBPF 采集网络诊断信息

5.1 采集 TCP 重传

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
// tcp_retrans.bpf.c — 跟踪 TCP 重传
#include <linux/bpf.h>
#include <bpf/bpf_helpers.h>

struct {
    __uint(type, BPF_MAP_TYPE_RINGBUF);
    __uint(max_entries, 256 * 1024);
} events SEC(".maps");

struct tcp_retrans_event {
    u32 pid;
    u32 saddr;
    u32 daddr;
    u16 sport;
    u16 dport;
    u32 seq;
    u64 ts;
};

SEC("tracepoint/tcp/tcp_retransmit_skb")
int trace_retrans(struct trace_event_raw_tcp_retransmit_skb *ctx) {
    struct tcp_retrans_event *e;
    e = bpf_ringbuf_reserve(&events, sizeof(*e), 0);
    if (!e) return 0;

    e->saddr = ctx->saddr;
    e->daddr = ctx->daddr;
    e->sport = ctx->sport;
    e->dport = ctx->dport;
    e->seq = ctx->seq;
    e->ts = bpf_ktime_get_ns();

    bpf_get_current_comm(...);  // 关联进程（如果需要）

    bpf_ringbuf_submit(e, 0);
    return 0;
}

5.2 采集 RTT

1
2
3
4
5
6
7
8
9
10
11
// tcp_rtt.bpf.c — 跟踪 RTT
SEC("tracepoint/tcp/tcp_receive_window")
int trace_rtt(struct trace_event_raw_consume_skb *ctx) {
    // 解析 RTT 采样
    u32 srtt = ctx->srtt_us;
    u32 mdev = ctx->mdev_us;

    bpf_printk("TCP RTT: srtt=%u mdev=%u\n", srtt, mdev);

    return 0;
}

5.3 RTT 估算

1
2
3
4
5
6
7
8
9
10
11
# 使用 bpftrace 跟踪 RTT 分布
bpftrace -e '
kprobe:tcp_v4_rcv {
    $sk = (struct sock *)arg0;
    $srtt = $sk->__sk_common.skc_rcvtimeo / 1000;
    @rtt[comm] = hist($srtt);
}
END {
    print(@rtt);
}
'

5.4 重传统计

1
2
3
4
5
6
7
8
9
10
11
# 重传统计（5 秒间隔）
bpftrace -e '
kprobe:tcp_retransmit_skb {
    @retrans_count[comm] = count();
}
interval:s:5 {
    time("5秒重传统计：");
    print(@retrans_count);
    clear(@retrans_count);
}
'

6. 集成示例：L4 LB 详细日志

6.1 日志结构

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// packet_log.h — 包级日志
typedef struct {
    uint64_t timestamp;
    uint32_t src_ip;
    uint32_t dst_ip;
    uint16_t src_port;
    uint16_t dst_port;
    uint8_t  protocol;
    uint8_t  action;       // DROP / PASS / REDIRECT
    uint32_t session_id;
    char     reason[32];   // drop 原因
} packet_log_t;

// 完整事件链
typedef struct {
    uint64_t trace_id;
    packet_log_t recv_log;        // 接收
    packet_log_t parse_log;       // 解析
    packet_log_t lookup_log;      // 查表
    packet_log_t fwd_log;         // 转发
    uint64_t timestamps[10];      // 关键时间点
} packet_event_chain_t;

6.2 LB 主循环集成日志

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
void lb_process_with_logging(struct rte_mbuf *m) {
    uint64_t trace_id = trace_new_id();
    uint64_t t0 = rte_rdtsc();

    // 1. 接收阶段
    parse_packet(m);  // 解析但不修改
    uint64_t t1 = rte_rdtsc();

    // 2. 查表阶段
    struct ct_entry *sess = conntrack_lookup(...);
    uint64_t t2 = rte_rdtsc();

    if (!sess) {
        // 记录 drop 事件
        packet_log_t log = {
            .timestamp = rte_rdtsc_to_ns(t0),
            .src_ip = ip->saddr,
            .dst_ip = ip->daddr,
            .src_port = tcp->source,
            .dst_port = tcp->dest,
            .protocol = ip->protocol,
            .action = 1,  // DROP
            .session_id = 0,
            .reason = "no_session",
        };
        emit_log(&log);
        rte_pktmbuf_free(m);
        return;
    }

    // 3. 转发阶段
    uint64_t t3 = rte_rdtsc();
    int nb_tx = rte_eth_tx_burst(port, 0, &m, 1);
    uint64_t t4 = rte_rdtsc();

    if (nb_tx > 0) {
        packet_log_t log = {
            .timestamp = rte_rdtsc_to_ns(t0),
            .src_ip = ip->saddr,
            .dst_ip = ip->daddr,
            .src_port = tcp->source,
            .dst_port = tcp->dest,
            .protocol = ip->protocol,
            .action = 0,  // PASS
            .session_id = sess->session_id,
            .reason = "",
        };
        emit_log(&log);
    } else {
        rte_pktmbuf_free(m);
    }

    // 记录延迟直方图
    hist_record(&g_latency_hist, rte_rdtsc_to_ns(t4 - t0));
}

6.3 异步日志输出到 syslog

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
// syslog.c — 异步发送日志到 syslog
#include <syslog.h>
#include <pthread.h>
#include <rte_ring.h>

extern struct rte_ring *g_log_ring;
extern volatile int g_running;

void *syslog_writer_thread(void *arg) {
    openlog("lb", LOG_PID, LOG_DAEMON);

    while (g_running) {
        struct rte_mbuf *m;
        if (rte_ring_dequeue(g_log_ring, (void **)&m) == 0) {
            packet_log_t *log = rte_pktmbuf_mtod(m, packet_log_t *);

            // 格式化为 syslog 消息
            syslog(LOG_INFO,
                   "trace=%lu action=%d proto=%d "
                   "src=%u.%u.%u.%u:%u dst=%u.%u.%u.%u:%u reason=%s",
                   log->timestamp, log->action, log->protocol,
                   (log->src_ip >> 24) & 0xFF, (log->src_ip >> 16) & 0xFF,
                   (log->src_ip >> 8) & 0xFF, log->src_ip & 0xFF, ntohs(log->src_port),
                   (log->dst_ip >> 24) & 0xFF, (log->dst_ip >> 16) & 0xFF,
                   (log->dst_ip >> 8) & 0xFF, log->dst_ip & 0xFF, ntohs(log->dst_port),
                   log->reason);

            rte_pktmbuf_free(m);
        }
    }

    closelog();
    return NULL;
}

7. 监控与告警

7.1 告警阈值

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
// alert.h — 告警阈值
typedef struct {
    uint64_t error_rate_threshold;      // 错误率上限
    uint64_t latency_p99_threshold_ns;   // P99 延迟上限
    uint64_t bps_threshold;             // 带宽上限
    uint64_t pps_threshold;             // PPS 上限
    uint64_t conntrack_utilization;      // conntrack 利用率上限
} alert_thresholds_t;

static alert_thresholds_t g_thresholds = {
    .error_rate_threshold = 1000,         // 每秒错误数
    .latency_p99_threshold_ns = 1000000,   // 1ms
    .bps_threshold = 8ULL * 1000 * 1000 * 1000,  // 8 Gbps
    .pps_threshold = 10 * 1000 * 1000,    // 10 Mpps
    .conntrack_utilization = 90,          // 90%
};

void check_alerts() {
    static uint64_t last_check = 0;
    uint64_t now = rte_rdtsc();
    if (now - last_check < rte_get_timer_hz() * 5) return;  // 每 5 秒
    last_check = now;

    // 检查错误率
    uint64_t errors = METRIC_GET(dropped_packets) -
                     METRIC_GET(dropped_packets_prev);
    if (errors > g_thresholds.error_rate_threshold) {
        LOG_ERROR("ALERT: high error rate: %lu errors in 5s", errors);
    }

    // 检查延迟
    if (g_latency_hist.max_ns > g_thresholds.latency_p99_threshold_ns) {
        LOG_ERROR("ALERT: high latency: %lu ns", g_latency_hist.max_ns);
    }

    // 检查 conntrack
    uint64_t ct_size = g_lb_ctx.ct->size;
    if (ct_size > g_thresholds.conntrack_utilization * g_lb_ctx.ct->max / 100) {
        LOG_ERROR("ALERT: conntrack high utilization");
    }
}

7.2 Prometheus 集成

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
// prometheus_exporter.c — 通过 HTTP 暴露指标
void prometheus_expose() {
    // 启动 HTTP 服务器（轻量级库）
    // 监听 9090 端口
    // GET /metrics 返回 Prometheus 格式

    char buffer[4096];
    int n = 0;
    n += snprintf(buffer + n, sizeof(buffer) - n,
                  "# HELP lb_packets_total Total packets\n"
                  "# TYPE lb_packets_total counter\n"
                  "lb_packets_total %lu\n",
                  METRIC_GET(total_packets));

    n += snprintf(buffer + n, sizeof(buffer) - n,
                  "# HELP lb_pps Current PPS\n"
                  "# TYPE lb_pps gauge\n"
                  "lb_pps %lu\n",
                  METRIC_GET(pps_current));

    n += snprintf(buffer + n, sizeof(buffer) - n,
                  "# HELP lb_latency_ns Latency nanoseconds\n"
                  "# TYPE lb_latency_ns summary\n"
                  "lb_latency_ns{quantile=\"0.5\"} %lu\n"
                  "lb_latency_ns{quantile=\"0.99\"} %lu\n"
                  "lb_latency_ns{quantile=\"0.999\"} %lu\n",
                  g_latency_hist.p50,
                  g_latency_hist.p99,
                  g_latency_hist.p999);

    write(fd, buffer, n);
}

8. 故障排查技巧

8.1 常见故障

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
LB 常见问题：

1. PPS 突降
   - 检查 conntrack 满？
   - 检查流表满？
   - 检查 CPU 使用率？
   - 抓包看是否有攻击？

2. 延迟突增
   - 检查网卡中断？
   - 检查 cache miss？
   - 检查锁竞争？

3. 后端不通
   - 检查健康检查？
   - 检查后端 RTT？
   - 检查连接跟踪超时？

4. 内存增长
   - 是否有内存泄漏？
   - 是否有 GC 不及时？

8.2 排查工具

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 实时观察 PPS
watch -n 1 "cat /proc/net/softnet_stat"

# 网卡丢包
ip -s link show eth0

# TCP 重传（bpftrace）
bpftrace -e 'kprobe:tcp_retransmit_skb { @[comm] = count(); }'

# RTT 分布
bpftrace -e 'kprobe:tcp_v4_rcv /retval > 0/ {
    $sk = (struct sock *)arg0;
    @rtt[comm] = hist($sk->__sk_common.skc_rcvtimeo / 1000);
}'

# 系统调用跟踪
strace -p $(pidof lb_process) -e network

# 抓包
tcpdump -i eth0 -nn -c 1000 -w capture.pcap

9. 业界最佳实践

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
1. Metrics
   - 始终使用 per-CPU 计数器
   - 关键指标：PPS、BPS、延迟、错误率
   - 导出到 Prometheus + Grafana

2. Logging
   - 结构化日志（JSON）
   - 异步批量写
   - 关键事件而非全部

3. Tracing
   - 包级 span
   - ring buffer + 专用 writer
   - 采样而非全量（高 QPS 时）

4. eBPF
   - 跟踪关键 tracepoint
   - 性能分析
   - 用户态工具
赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

主要涉及技术：
Java后端开发、Linux开发、
公众号开发、开源爱好者、Linux

联系QQ:562054870