Wazuh inventory_sync 压测发送器(benchmark_sender)状态机全解析:Agent 生命周期与会话状态机

原创2026-09-14 21:07:501,901 阅读
文章标签:网络安全SIEM日志分析IDS漏洞扫描合规审计后端

Wazuh inventory_sync 压测发送器(benchmark_sender)状态机全解析:Agent 生命周期与会话状态机

导读

本文是 Wazuh 开源仓库中 inventory_sync 基准测试工具 tool_simulator/benchmark_sender 设计文档系列的第 4 篇深度解读,主题为该 Go 发送器的双层状态机:每个模拟 Agent 走一层"外层 Agent 生命周期状态机",在其迭代(iteration)内部又为每条 lane 派生一个"内层会话状态机"(随 session_type 不同而不同)。阅读本文后,你将掌握模拟 Agent 从注册到退出的完整状态迁移规则、keepalive/关闭控制会话的工作原理、delta/modulecheck/dataclean 三种会话状态机的差异、两阶段 EndAck 超时语义,以及每条状态迁移如何映射为 bench.csv 与 sender_summary.json 中的计数器与延迟指标,并能在真实 Wazuh 仓库源码中找到每一层状态机的实现证据。

本仓库的完整设计文档系列位于 docu 目录,本文所解读的原文为 04-agent-state-machine.md。


一、背景:发送器在压测流水线中的位置

benchmark_sender(Go 二进制,位于 cmd/benchmark_sender)模拟一支 Wazuh Agent 舰队与真实的 wazuh-manager 通信:每个模拟 Agent 先向 wazuh-authd(TCP 1515,TLS,无客户端证书)注册,再向 wazuh-remoted(TCP 1514)建立 TCP 连接,发送启动控制消息后运行一条或多条 lane,每条 lane 驱动一串 inventory_sync 会话(Start → 数据消息 → End → 读取 ack),并按需处理 ReqRet 重传,最终记录逐秒计数器与逐消息延迟。整个流水线由 run_benchmark.sh 编排,输出 bench.csv 与可选的 sender_summary.json(详见 08-metrics-and-output.md)。

理解本文的状态机之前,建议先通读 01-overview.md(动机与 I/O 契约)和 02-functional-requirements.md(功能需求 FR-1~FR-20,其中 FR-2/FR-3/FR-4/FR-8/FR-9/FR-15/FR-17 与本文状态机直接相关)。术语(Agent、Lane、Fleet、Step、Session、ReqRet、EPS、Drain)可查阅 00-index.md 的术语表。


二、外层状态机:Agent 生命周期

每个模拟 Agent 独立运行一个外层状态机,在每次迭代内部再为每条 lane 派生一个会话运行器(SessionRunner)。外层状态机用 ASCII 图固定如下:

                       +-----------+
                       |  Created  |
                       +-----+-----+
                             |
                             v
                      +-------------+
                      | Registering |   authd TCP+TLS, OSSEC A: name
                      +------+------+
                             |
                             v
                      +-------------+
                      |  Registered |   has (id, name, key)
                      +------+------+
                             |  optional --key-wait sleep
                             v
                      +-------------+
                      | Connecting  |   remoted TCP
                      +------+------+
                             |
                             v
                      +-------------+   #!-agent startup control msg
                      |  Connected  |   reader goroutine running
                      +------+------+
                             |
                +------------v-------------+
                |    IterationLoop         | <----+ next iteration
                | (run all lanes once)     |      |
                +------------+-------------+      |
                             |                    |
                  yes  +-----+--------+ no        |
        more passes?-->|  Done?       |-----------+
                       +-----+--------+
                             |
                             v
                      +-------------+   close socket
                      | Disconnecting|
                      +------+------+
                             |
                             v
                       +-----+-----+
                       |   Done    |
                       +-----------+

2.1 迁移规则(Transition rules)

From To Trigger Failure → action
Created Registering Worker pool picks up the agent n/a
Registering Registered OSSEC K:'…' parsed; key derived Retry up to 3× with 1 s sleep; then mark agent failed, exit
Registered Connecting --key-wait elapsed n/a
Connecting Connected TCP connect + startup control message sent Retry up to 3× with 1 s sleep; on exhaustion: agent failed
Connected IterationLoop Reader goroutine ready n/a
IterationLoop IterationLoop Iteration done, repeat_until not elapsed; close socket; sleep 1 s; reconnect If reconnect fails: count remaining sessions as failed, agent exits
IterationLoop Disconnecting repeat_until elapsed OR single-pass scenario n/a
Disconnecting Done Socket closed; reader goroutine joined n/a

源码印证:外层状态机的主要实现在 internal/runner/runner.go 的 runAgent 函数中,可逐段对照:

  • Registering → Registered:agent.Register(cfg.Manager, cfg.RegPort, name, 15*time.Second) 打开到 authd 的 TLS 连接,发送 OSSEC A:'<name>\n',解析 OSSEC K:'<id> <name> <ip> <key>' 响应并取出 (ID, Name, ManagerKey),实现在 internal/agent/registration.go。Agent 命名遵循 FR-2:使用 fleets 时为 bench-<fleet>-<NNNN>-<rand12>,使用 total_agents 简写时为 bench-<NNNN>-<rand12>。
  • Registered → Connecting 之间的 --key-wait:runner.go 中 if cfg.KeyWait > 0 { select { case <-time.After(cfg.KeyWait): ... } }。--key-wait 默认 35 s(FR-17),目的是让 manager 有时间重载密钥表,避免新起 manager 时首波出现 Status_Offline 级联。
  • Connecting → Connected:conn.Dial(15*time.Second) 建立到 remoted 的 TCP 连接,发送 #!-agent startup 控制消息(wire.BuildStartupControlMessage),然后 sleep 1 s 让 remoted 消化首帧,见 internal/agent/conn.go。随后 conn.StartReader(ctx) 启动每 Agent 一个的 reader goroutine。
  • Connected → IterationLoop:reader goroutine 就绪后进入 runIteration,将本 Agent 的所有 lane 并行跑一遍(每条 lane 一个 goroutine,见下文并发说明)。
  • IterationLoop → IterationLoop(下一轮):repeat_until 未到期的场景下,迭代完成后先 stopKeepalive()、发送 #!-agent shutdown (见第 3 节)、conn.Close() 关闭 socket,sleep 1 s 后重新 Dial 重连;若重连失败,该 Agent 剩余会话全部计为 failed 并退出 Agent 循环——对应文档中"count remaining sessions as failed, agent exits",也即 FR-15。
  • IterationLoop → Disconnecting → Done:repeat_until 到期或单遍(single-pass)场景下关闭 socket、join reader goroutine 后进入 Done。

2.2 并发说明(Concurrency notes)

  • 同一迭代内的多条 lane 并行运行(每条 lane 一个 goroutine);
  • 单条 lane 内的多个 step 串行运行;
  • 当 parallel_agents > 0 时,外层迁移 Created → Registering 受大小为 N 的信号量门控:Agent 槽位在 Agent 到达 Done 时才释放。

源码印证:runner.go 中用带缓冲的 chan struct{}(容量 scn.Behavior.ParallelAgents)实现信号量:Agent goroutine 进入时 sem <- struct{}{},退出时 defer func() { <-sem }() 释放;parallel_agents == 0 时所有 Agent 在屏障处同时启动(对应 07-concurrency-and-pacing.md 中的 sync.WaitGroup + chan struct{} 屏障)。lane 并行由 runIteration 内的 sync.WaitGroup 实现:先预增 siblingsActive 计数器(供 engine 型 step 的 run_while_siblings_active 观察),再为每条 lane 起 goroutine。按 07 文档的估算,2000 个 Agent × 4 条 lane 满载时约有 16000 个 goroutine 处于稳态。


三、Keepalive 与关闭:控制会话(Control Conversation)

与上述会话工作相互独立,每个 Agent 在其存活期内与 manager 维持一段小型旁路对话,以镜像真实 Wazuh Agent 的行为(对照 src/client-agent/src/notify.c):

  1. 进入 Connected 时:启动 StartKeepalive goroutine,以 --keepalive-interval(默认 20 s,与真实 Agent 的 NOTIFY_TIME 一致)为周期发送 #!-<JSON> 控制帧,载荷为最小化的 {"version":"1.0","agent":{"id,name,version,merged_sum,groups}}。首个 keepalive 携带 merged_sum="",促使 manager 通过 #!-up file <md5> merged.mg 推送共享文件 merged.mg。
  2. 收到 #!-up file 时:reader 在 FlatBuffer 解析之前先识别该前缀(实现在 internal/agent/conn.go),提取 MD5 缓存到 Conn.mergedSum,并触发可选的 MergedSumObserver 让 supervisor 递增 merged_sum_updates 计数器。后续 keepalive 会携带该哈希上报 → manager 将 Agent 标记为 synced,停止重复下发该文件。
  3. 进入 Disconnecting 时:先停掉 keepalive ticker,再发送一帧 #!-agent shutdown (无载荷),最后关闭 socket。这镜像了真实 Agent 的 send_agent_stopped_message(),让 manager 能立即将该 Agent 标记为断开,而不必等待不活动超时。

keepalive 与 shutdown 帧与 inventory_sync 写入共用同一条 Conn.SendText → sendMu 路径,因此与任何正在进行的会话工作原子交错,不会出现帧乱序。

源码印证:

  • keepalive ticker 实现在 internal/agent/keepalive.go:StartKeepalive 创建 ticker,每 tick 调用 buildKeepaliveJSON(opts.Groups) 构造 JSON 并以 SendText("#!-" + payload) 发送;Interval <= 0 时禁用 ticker。真实 Agent 的 keepalive 载荷比模拟器更完整(含 host/os/cluster),但这些字段对 manager 是可选的——secure.c 的 parse_json_keepalive 在缺失时用默认值填充。
  • merged_sum 的缓存使用 atomic.Pointer[string],使 keepalive goroutine 可以无锁读取;parseFileUpdate 会校验 MD5 是否为 32 位十六进制,文件正文直接丢弃。
  • 关闭时序在 runner.go 的 runAgent 中:stopKeepalive() → conn.SendShutdown()(成功则 shutdowns_sent++)→ conn.Close()。SendShutdown 本身只是 SendText("#!-agent shutdown "),见 conn.go。
  • 计数器:keepalives_sent、keepalive_errors、shutdowns_sent、merged_sum_updates 均为 --report-engine 开启时的可选计数(定义见 internal/metrics/counters.go)。单元测试见 internal/agent/keepalive_test.go。

四、内层状态机:按 session_type 区分的会话状态机

会话运行器驱动单个 inventory_sync 会话,共三种会话类型。它们仅在 AwaitStartAck 与 SendEnd 之间的主体部分不同。

4.1 通用前置段(所有会话类型共用)

   +--------------+    Build Message{type=Start}    +-----------+
   |  Build Start |--------------------------------> SendStart |
   +--------------+                                 +-----+-----+
                                                          |
                                                          v
                                                  +---------------+
                                                  | AwaitStartAck |
                                                  +-------+-------+
                                                          |
              +--------------+--------------+------+------+
              |              |              |      |      |
         Status_Ok      Status_Error  Status_Offline Status_  timeout
                                                  ChecksumMismatch
              |              |              |      |      |
              v              v              v      v      v
         <session-     ABORT runner    ABORT runner   special  ABORT runner
          specific     (count          (count         (handled (count failed)
          body>         failed)         offline)       below)

源码印证:Start 帧的构建与发送、StartAck 的超时/重试/离线策略集中在 internal/inventory/source.go 的 Source.Run:fbbuild.BuildStart(...) 构造一次 Start(跨重试尝试复用),conn.SendStart(s.moduleID, startBytes, cb) 发出,随后 select 在 ctx.Done()、startAckT 超时、ackC 之间三选一。StartAck 的分发采用 FIFO + tag 匹配:Conn.pendingStarts 是受 sendMu 保护的 container/list.List,每个 PendingStart 记录 tag(如 syscollector_sync)与 alive 标志;reader 收到 #!-<tag> <fb> 后,从队首开始跳过非存活条目,将 StartAck 匹配给第一个 tag 相同且存活的待决运行器(见 conn.go)。这一机制对应 FR-20,防止并发 fim_sync 与 syscollector_sync 的 Start 互相串号——否则后续 DataValue 会被 manager 以 "seq exceeds declared size" 拒绝;相关回归测试见 internal/agent/fifo_test.go。

4.2 delta 会话主体

适用 sync_mode = ModuleFull | ModuleDelta 或任何产生数据的模式:

  +-------------+
  | SendData*   |  one of:
  +------+------+    - N × DataValue (default)
         |           - groups of DataValue inside DataBatch (if use_databatch)
         |           - 1 × DataContext per metadata key (if applicable)
         |    EPS pacing enforced here
         v
  +-------------+
  |   SendEnd   |
  +------+------+
         |
         v
  +-------------+
  | AwaitEndAck |---- Status_Processing → keep waiting (record latency, do not exit)
  +-------+-----+---- Status_Ok → success
          |
   ReqRet received   ┐
          v          │   only if `retransmit=true`; up to 5 rounds
  +-------------+    │   compute set of missing seq IDs from ReqRet ranges
  | ResendMissing|---┘   resend the items, then keep awaiting EndAck
  +-------------+

要点:

  • ReqRet 可能先于或后于 End 到达;运行器在 AwaitEndAck 全程必须保持 reader 存活。
  • 5 轮 ReqRet 无进展后,会话标记为失败(sessions_failed++,messages_dropped += missing.size)。

源码印证:

  • EPS 限速在 SendData* 处强制执行:Source.Run 每次调用都重建一个 pacing.Limiter(漏桶),确保每个会话独立遵守 max_eps,避免跨会话的静默空闲累积令牌(见 internal/inventory/source.go 与 internal/pacing/limiter.go)。
  • use_databatch=true 时,DataValue 被分组进 DataBatch 信封(序列化后目标 ≤ 60 KB,FR-18);每条 DataBatch 中的每个条目单独计为 1 个 data_values_sent。
  • ReqRet 重传上限为 MaxRetransmitRounds = 5(定义于 source.go),与 Python 版 MAX_RETRANSMIT 一致;每次 ResendMissing 的条目同时计入 data_values_retransmitted 与 data_values_sent。
  • 两阶段 EndAck 的专门测试见 internal/inventory/end_ack_two_phase_test.go,超时重试策略测试见 timeout_retry_test.go,离线重试测试见 offline_retry_test.go。

4.3 modulecheck 会话主体

适用 sync_mode = ModuleCheck | MetadataCheck | GroupCheck:

  +-------------------+
  | SendChecksumModule|   one Message{type=ChecksumModule} with hash
  +---------+---------+
            |
            v
  +-------------+
  |   SendEnd   |
  +------+------+
         |
         v
  +-------------+
  | AwaitEndAck |
  +-------+-----+
          |
  +---+---+-------------------------+
  |       |                         |
Status   Status                Status_
_Ok     _ChecksumMismatch     Error/Offline/Processing
  |       |                         |
  v       v                         v
 done   auto_resync?               handle per common rules
         yes → enqueue a delta session for the same module
              with sync_mode=ModuleFull, same step otherwise.
         no  → count as completed-with-mismatch

要点:Status_ChecksumMismatch 仅出现在 modulecheck 中。若 step 设置了 auto_resync=true,则在 End 之后入队一个同模块的 delta 会话(sync_mode=ModuleFull,其余 step 配置不变);否则按"已完成但校验不匹配"计数。

场景配置佐证:03-scenario-schema.md 中,modulecheck 型 step 可以设置 modulecheck_checksum(40 位十六进制,故意失配)与 auto_resync(默认 false);加载器规则第 9 条要求:auto_resync 仅在 session_type == "modulecheck" 时有意义,其他组合应告警但不中止。

4.4 dataclean 会话主体

适用 sync_mode = ModuleDelta 且载荷为空,或显式 DataClean 操作:

  +-------------+
  | SendDataClean|   one Message{type=DataClean} carrying the per-index map
  +------+-------+
         |
         v
  +-------------+
  |   SendEnd   |
  +------+------+
         |
         v
  +-------------+
  | AwaitEndAck |
  +-------+-----+
          |
   Status_Ok / Status_Processing → success / continue
   Status_Error / Status_Offline → count failed/offline, abort runner

要点:dataclean 会话没有 ReqRet 重传路径,也没有 ChecksumMismatch 分支——收到 Status_Error/Status_Offline 即计数并中止运行器。


五、超时预算(Timeouts)

超时预算在场景 JSON 中按 step 配置(通过 start_ack_timeout、end_ack_processing_timeout、end_ack_timeout,或放在 defaults: 下作用于每个 step)。它们是场景专属配置,没有对应的 CLI 标志。未设置(零值)时回退到 inventory 包的默认值:Start 15 s、End 处理 5 s、End 最终 120 s。

关键语义——EndAck 等待是两阶段的:

  • SHORT 窗口:End 发出到首个 Status_Processing(manager 的队列确认)之间;
  • LONG 窗口:Status_Processing 到终态 Status_Ok 之间,覆盖 indexer flush 的延迟。

SHORT 窗口耗尽且未收到任何 Processing,说明 End 帧几乎肯定被 manager 的输入队列丢弃了——此时 ack_timeout_retry 会重发它。LONG 窗口在每次后续 Status_Processing 时重置。

Event Budget On expiry
StartAck 15 s (default) start_retries++ and resend Start if ack_timeout_retry budget allows; otherwise abort.
EndAck (Phase 1: End → first Status_Processing) 5 s (default) end_retries++ and resend End if ack_timeout_retry budget allows; otherwise session counted failed. The End frame was almost certainly dropped by the manager's input queue.
EndAck (Phase 2: Status_Processing → terminal Status_Ok) 120 s (default) end_retries++ and resend End if ack_timeout_retry budget allows; otherwise session counted failed. The indexer flush has stalled; manager handles duplicate End gracefully (re-emits Status_Processing).
EndAck (intermediate Status_Processing → next ack while in Phase 2) same as Phase 2 Same as Phase 2 (the timer restarts on each Processing).
ReqRet round (resend + await any Status update) 30 s Treat as a missed ack; counts against the 5-round budget. After ReqRet the EndAck wait drops back to Phase 1 because the manager must ack the new End from scratch.
Reconnect retry (per attempt) 1 s sleep, 3 attempts Mark agent failed.

ack_timeout_retry 旋钮(-1 = 不重试,0 = 无限重试,N>0 = 最多 N 次)与 ack_timeout_retry_delay(默认 1.0 s 停顿)对 Start 与 End 是独立预算——Start 超时耗尽重试不会消耗 End 的预算。这专门应对 manager 有界输入队列在压力下丢消息的场景。

源码印证:默认值常量为 DefaultStartAckTimeout = 15s、DefaultEndAckProcessingTimeout = 5s、DefaultEndAckTimeout = 120s、DefaultPostDataDelay = 1s(见 internal/inventory/source.go)。step 显式设置 > 0 时覆盖默认值;post_data_delay 使用哨兵值:-1 = 包默认 1 s、0 = 无停顿、N>0 = 等待 N 秒。manager 侧还有两个直接影响压测行为的内部选项(见 02-functional-requirements.md 第 0 节):inventory_sync_queue_size(默认 1000,输入路由队列满时丢包)与 inventory_sync_data_value_quota(默认 250000,活动会话累计 Start.size 上限,耗尽后新 Start 返回 Status_Offline 且 session=UINT64_MAX)。


六、状态码反应(Status Code Reaction Recap)

无论 StartAck 还是 EndAck,运行器对 5 种状态码的反应如下:

Status code (StartAck or EndAck) Counter incremented Runner reacts
Status_Ok (0) *_ack_ok Proceed
Status_Error (1) *_ack_error Abort runner immediately; no End is sent if it was a Start
Status_Offline (2) *_ack_offline StartAck: depends on the step's offline_retry policy — -1 (default) aborts the runner; 0 retries indefinitely; N>0 retries up to N total attempts (waiting offline_retry_delay between each). Each retry also bumps start_retries. EndAck: always aborts (no retry path for End).
Status_ChecksumMismatch (3) start_ack_checksum_mismatch Only in modulecheck. If auto_resync=true, enqueue a delta resync after End
Status_Processing (4) end_ack_processing Keep waiting for the next ack; record latency only on the first occurrence

补充说明(来自 FR 文档第 0 节):Status_Offline 是背压信号(如 inventory_sync_data_value_quota 耗尽、m_maxSessions 达上限、indexer 不可达),运行器内部不自行重试,由场景的 offline_retry 策略决定;Status_Error 是硬拒绝(如 Agent 被其他 Mode_Metadata*/Mode_Group* 会话锁定、Start 字段非法)。

源码印证:StartAck 的离线重试逻辑在 source.go 之后的 retryLoop 中:StatusOffline 时 offlineAttempt++,对照 maxOfflineAttempts(由 attemptsFromRetry(s.step.OfflineRetry) 换算,-1 视为无限)决定重试或放弃;每次重试都会递增 CStartRetries。超时路径同理,使用独立的 maxTimeoutAttempts 与 timeoutRetryDelay。


七、迁移的副作用:计数器与延迟直方图

每次状态迁移都会产生一类副作用:

  • 向 counters 数组写入一条记录(每条迁移恰好递增一次);
  • 或记录一条延迟观测(成对的 t0/t1 写入 latency_ms.{start_ack|end_ack|session_full} 直方图)。

迁移到计数器的完整映射:

Transition Counter
Build Start → SendStart start_sent
AwaitStartAck → success branch start_ack_ok
AwaitStartAck → Status_Error start_ack_error
AwaitStartAck → Status_Offline start_ack_offline
AwaitStartAck → Status_ChecksumMismatch start_ack_checksum_mismatch
AwaitStartAck → timeout start_ack_timeout
Each DataValue / Item in DataBatch data_values_sent
Each DataBatch envelope data_batches_sent
Each DataContext data_contexts_sent
Each DataClean data_cleans_sent
Each ChecksumModule checksum_modules_sent
SendEnd end_sent
AwaitEndAck → Status_Ok end_ack_ok, sessions_completed
AwaitEndAck → Status_Error end_ack_error, sessions_failed
AwaitEndAck → Status_Offline end_ack_offline
AwaitEndAck → Status_Processing end_ack_processing
AwaitEndAck → timeout end_ack_timeout, sessions_failed
ReqRet entered reqret, missing_ranges_total += len(ranges)
ResendMissing item data_values_retransmitted++
ReqRet budget exhausted messages_dropped += len(missing), sessions_failed

三条延迟序列的观测窗口(来自 08-metrics-and-output.md):

Series t0 recorded when t1 recorded when Excluded
start_ack Start message hits the wire (after encrypt) Matched StartAck is dispatched to the runner Sessions whose StartAck timed out
end_ack End message hits the wire Terminal EndAck arrives (NOT Status_Processing) Sessions whose EndAck timed out
session_full Start message hits the wire Terminal EndAck arrives Failed sessions

源码印证:计数器枚举与 CSV 列名在 internal/metrics/counters.go 中一一对应(CMessagesSent、CSessionsStarted、CStartAckOk、CEndAckProcessing、CReqRet、CMessagesDropped、CStartRetries、CEndRetries 等)。bench.csv 采用逐 tick 增量语义:统计收集器每秒调用 atomic.SwapInt64(&c, 0) 读零,sender_summary.json 的累计值则单独维护为增量之和;RecordLatency 只记录正值(负值丢弃,与 Python 版一致)。所有列名必须与 result_summary.py 的 aggregate_bench() 保持兼容(NFR-3/NFR-4),因此 Go 端口不得新增 CSV 列或 JSON 字段——引擎事件列(engine_events_sent 等)与 keepalive/shutdown 相关列(keepalives_sent、shutdowns_sent、merged_sum_updates、end_retries)均作为 --report-engine 可选追加列存在,result_summary.py 会忽略其不认识的列。


八、设计要点回顾与排障视角

  1. 双层状态机解耦:外层(Agent 生命周期)管理"连接生命周期",内层(会话状态机)管理"单次会话的协议握手",二者通过 Conn 的 sendMu(写序)与 reader 分发(StartAck FIFO + 按 session id 路由 EndAck/ReqRet)衔接,互不阻塞。
  2. 并发模型:1 个 Agent = 1 个 goroutine + 1 个 reader goroutine;lane 并行、step 串行;parallel_agents 信号量门控注册;2000 Agent × 4 lane 满载约 16000 goroutine 稳态(NFR-6 要求单 Agent 峰值内存 ≤ ~2 MB)。
  3. 容错哲学:超时与离线分别有独立重试预算(ack_timeout_retry 与 offline_retry),且 Start/End 预算互相隔离;manager 侧队列满丢帧通过重发 End/Start 优雅恢复;ReqRet 5 轮上限防止无限重传。
  4. 可观测性:每条迁移都有对应计数器或延迟观测,压测结束后 bench.csv(逐秒)+ sender_summary.json(累计与百分位)可供 result_summary.py 与图表生成器消费。

若要在实际压测中观察这些状态机的行为,可按 10-go-implementation-notes.md 的构建说明编译 cmd/benchmark_sender,再借助 run_benchmark.sh 以 scenarios/mega_burst.json(2000 Agent、repeat_until=180)等场景运行;运行前的 cleanup_agents.sh 负责通过 API 清理旧的 bench-* Agent。排障时重点关注 sessions_failed、end_ack_timeout、reqret、messages_dropped 与 start_retries 列,它们分别对应本文所述的超时、两阶段 EndAck、ReqRet 重传与 Start 重试路径。

完整计数器语义与输出格式以 08-metrics-and-output.md 为准;场景 JSON 中各超时/重试字段的完整取值说明见 03-scenario-schema.md。

登录后查看全文
wazuh