fix(storage): t_7793a484 命中事件写路径缺口 — AppendHitEvent 冲突即终态丢(当天 42 条)⇒ 加与 Update 同规格有界重试

- lancedb_ipc.go: AppendHitEvent 原单次 lancedb_append_hit_event(Rust 内部 20 次
  commit 重试耗尽后不重发)⇒ 冲突即终态丢。现加 retryAppendHitEventRPC(同
  t_28aa278e 规格:3 次重试 + 50/100/200ms 指数退避;仅可重试 MVCC 冲突;
  非可重试立即返回)。幂等安全:hit_events 是 append-only INSERT,行 id =
  memory_id+unix微秒 唯一,MVCC commit conflict 时整个提交原子不生效(不产版本),
  重放不产生重复行(与 update col+1 重算同语义,官方 rerun-the-operation)。
- usage_track.go CheckCommittedForUse: 修复前 _ = 吞 AppendHitEvent 错误(10-16
  42 条丢失的主来源);现终态失败 ⇒ 打 [usage] hit event append FAILED 行 +
  不消费 usage_recall(consumed=0 下轮 commit 重扫重试),与 t_28aa278e
  「更新成功后才消费」同构。
- metrics.go: 新增计数器 zhiyi_hit_event_append_failed_total(/metrics 暴露,
  AC3 异源口径:日志 AppendHitEvent FAILED 行 ⇔ 计数器值)。
- IncrementUseful 无需加重试(AC1 代码依据):它走 rc.Update → retryUpdateRPC
  (t_28aa278e 已含 3 次重试);当天 2 条 'IncrementUseful failed' 实测是
  'retry exhausted after 3 retries'(风暴内 4 次尝试全冲突的终态耗尽),
  非「一次冲突即放弃」。残留:feedback 人工路径无 rescan 兜底(同 Update 现状)。
- 测试 hit_event_retry_test.go(复用序列式 fakeServer,全程临时目录+fake socket,
  绝不打开 /var/lib/memoryweave):冲突 3 次→第 4 次成功(重试行 1/3,2/3,3/3 +
  retried OK after 3 + 终态失败归零)/ 恒冲突 4 次有界 + 计数器 +1 / 无冲突恰 1
  次 rpc 0 退避(AC4 逐位等价)/ 非可重试不重试 / 修复前后数值对比(终态失败 1→0)。
  更新 TestCheckCommittedForUse_NotConsumedOnExhaustion 断言(恒冲突总 rpc 5→4:
  AHE 先行耗尽即 continue)。
- 纯 Go 改动,无 Rust/无 schema/不部署(AC5:部署另提卡经牧尘放行,prod-write-gate 会拦)。
  回滚一行:git revert <本提交>。
This commit is contained in:
小唯
2026-10-16 22:46:03 +08:00
parent a2f355a994
commit a214cf4a0e
5 changed files with 294 additions and 12 deletions
+11
View File
@@ -51,6 +51,16 @@ var (
},
)
// ─── 命中事件写终态失败(t_7793a484 缺口:命中事件写路径无重试 ⇒ 冲突即终态丢)──
// 每累计一次 AppendHitEvent 终态失败(重试耗尽 / 非可重试错误)+1。
// 双口径对齐(AC3):日志 grep "AppendHitEvent FAILED" 行数 ⇔ 本计数器值。
HitEventAppendFailedTotal = prometheus.NewCounter(
prometheus.CounterOpts{
Name: "zhiyi_hit_event_append_failed_total",
Help: "AppendHitEvent(hit_events outcome 事件)终态失败累计次数(重试耗尽/非可重试;与日志 AppendHitEvent FAILED 行对齐)",
},
)
// ─── 内存 RSS ──────────────────────────────
MemoryRSSBytes = prometheus.NewGauge(
prometheus.GaugeOpts{
@@ -122,6 +132,7 @@ func init() {
ConflictsPending,
DistillLLMCallsToday,
ConsolidateFailuresTotal,
HitEventAppendFailedTotal,
MemoryRSSBytes,
SQLiteDBSizeBytes,
RecallUsefulnessRate,
@@ -243,10 +243,14 @@ func TestCheckCommittedForUse_NotConsumedOnExhaustion(t *testing.T) {
if consumed != 0 {
t.Fatalf("Update 冲突耗尽后 usage_recall 行应 consumed=0(下轮重试),实际 %d", consumed)
}
// 冲突路径确实走满重试(1 首次 + updateMaxRetries 重试 = updateMaxRetries+1 次 lancedb_update)
// fk.calls 还含 AppendHitEvent 的 1 次,故 lancedb_update 尝试数 = calls - 1
if got := fk.callCount(); got != updateMaxRetries+2 {
t.Fatalf("恒冲突应触发 1 次 AppendHitEvent + (首次+3 重试)=4 次 Update,总 rpc=%d, want %d", got, updateMaxRetries+2)
// 冲突路径确实走满重试(t_7793a484 起 AppendHitEvent 也内置同规格重试):
// 恒冲突时 AHE 先行耗尽(1 首次 + appendHitEventMaxRetries 重试 = appendHitEventMaxRetries+1 次
// lancedb_append_hit_event)⇒ 该行即被 continue 挡住(Update 0 次尝试)⇒ 总 rpc = appendHitEventMaxRetries+1。
// 修复前(t_28aa278e 时代)此断言为 1 次 AHE + 4 次 Update = updateMaxRetries+2 = 5 ——
// AHE 单次失败被 `_ =` 静默吞、行仍走到 Update;t_7793a484 后失败可查 + 更早挡住(两写全成才消费)。
if got := fk.callCount(); got != appendHitEventMaxRetries+1 {
t.Fatalf("恒冲突应触发 (1首次+3重试)=4 次 AppendHitEvent、Update 0 次(AHE 终态失败即 continue),总 rpc=%d, want %d",
got, appendHitEventMaxRetries+1)
}
t.Log("方案①:Update 冲突耗尽后 usage_recall 行 consumed=0(下轮可重试)⇒ 计数增量不静默丢失(修复前 consumed=1 永久丢失)")
t.Log("方案①+t_7793a484:AHE/Update 冲突耗尽后 usage_recall 行 consumed=0(下轮可重试)⇒ 计数增量与事件都不静默丢失(修复前 AHE 失败被 `_ =` 吞、Update 冲突 consumed=1 永久丢失)")
}
+193
View File
@@ -0,0 +1,193 @@
// 织忆 MemoryWeave — t_7793a484 命中事件写路径缺口:AppendHitEvent 冲突即终态丢
//
// 背景:t_28aa278e 给 Update 加了冲突自动重试,但 AppendHitEvent(lancedb_append_hit_event,
// hit_events 表 append-only INSERT)走的是「Rust 内部 20 次 commit 重试耗尽 ⇒ 终态丢、
// 无 Go 侧重试」路径 ⇒ 10-16 当日 42 条 outcome 事件(V 轴信号)终态丢失。
// 本文件确定性证明三条 AC(复用 retry_conflict_test.go 的序列式 fakeServer):
// ① 冲突后重试最终成功 ⇒ outcome 事件**不丢**(前 N 次冲突、N≤3 都落在重试预算内);
// ② 重试耗尽 ⇒ 返回含次数的明确错误(不静默)+ Prometheus 计数器 +1;
// ③ 正常路径(无冲突)⇒ 恰好 1 次 rpc、0 退避,行为与修复前逐位等价(AC4)。
// 全程临时目录 + fake socket,**绝不打开生产 /var/lib/memoryweave**(AC5 红线)。
package storage
import (
"bytes"
"fmt"
"log"
"net/http/httptest"
"strings"
"testing"
"time"
"github.com/xiaoxue/memoryweave/internal/metrics"
)
// captureLogs 截取标准 log 输出(测试结束恢复),供 AC2「贴 before/after 原始日志行」。
func captureLogs(t *testing.T) *bytes.Buffer {
t.Helper()
buf := &bytes.Buffer{}
old := log.Writer()
log.SetOutput(buf)
t.Cleanup(func() { log.SetOutput(old) })
return buf
}
// metricsHitEventAppendFailedTotal 读回计数器当前值(AC3 异源口径:日志行 ⇔ 计数器)。
// prometheus counter 值经 metrics.Handler()(包内独立 registry)采集,用 httptest 走
// 真实 HTTP 读路径,与 /metrics 端点同一口径。
func metricsHitEventAppendFailedTotal() int64 {
rec := httptest.NewRecorder()
metrics.Handler().ServeHTTP(rec, httptest.NewRequest("GET", "/metrics", nil))
for _, line := range strings.Split(rec.Body.String(), "\n") {
if strings.HasPrefix(line, "zhiyi_hit_event_append_failed_total ") {
var v int64
_, _ = fmt.Sscanf(line, "zhiyi_hit_event_append_failed_total %d", &v)
return v
}
}
return -1
}
// ─── AC1① 冲突重试最终成功:前 3 次冲突、第 4 次成功(恰落在 1+3 预算内)⇒ 终态失败归零 ──
func TestAppendHitEvent_ConflictRetry_Succeeds(t *testing.T) {
fk := newFakeServer(t, 3, "") // 前 3 次冲突,第 4 次成功
defer fk.close()
cap := captureLogs(t)
rc := fk.client()
err := rc.AppendHitEvent("mem_retry_ok", HitOutcomePos, HitReasonDownstreamUse)
if err != nil {
t.Fatalf("冲突重试后应成功返回 nil,实际 %v", err)
}
if got := fk.callCount(); got != 4 {
t.Fatalf("总 rpc 尝试 = %d, want 4(1 首次 + 3 重试)", got)
}
// AC2 机械验收:重试行真实出现 + 终态失败归零
out := cap.String()
for _, want := range []string{
"AppendHitEvent retry attempt 1/3",
"AppendHitEvent retry attempt 2/3",
"AppendHitEvent retry attempt 3/3",
"AppendHitEvent retried OK after 3",
} {
if !strings.Contains(out, want) {
t.Fatalf("日志缺 %q\n--- 捕获日志全文 ---\n%s", want, out)
}
}
if strings.Contains(out, "AppendHitEvent FAILED") {
t.Fatalf("重试成功场景不应有终态失败行\n--- 捕获日志全文 ---\n%s", out)
}
t.Log("=== AC2 after(冲突 3 次→第 4 次成功,原始日志行)===")
t.Log(out)
}
// ─── AC1② 重试耗尽:恒冲突 ⇒ 恰 4 次尝试后返回含次数明确错误 + 计数器 +1 ──
func TestAppendHitEvent_AlwaysConflict_ExhaustsBounded(t *testing.T) {
fk := newFakeServer(t, -1, "")
defer fk.close()
cap := captureLogs(t)
rc := fk.client()
before := metricsHitEventAppendFailedTotal()
start := time.Now()
err := rc.AppendHitEvent("mem_retry_never", HitOutcomePos, HitReasonDownstreamUse)
elapsed := time.Since(start)
if err == nil {
t.Fatalf("恒冲突应返回错误,却返回 nil")
}
if !strings.Contains(err.Error(), "retry exhausted after 3 retries") {
t.Fatalf("错误应含 'retry exhausted after 3 retries',实际=%v", err)
}
if !strings.Contains(err.Error(), "mem_retry_never") {
t.Fatalf("错误应含 id,实际=%v", err)
}
if got := fk.callCount(); got != appendHitEventMaxRetries+1 {
t.Fatalf("总 rpc 尝试 = %d, want %d(有界不卡死)", got, appendHitEventMaxRetries+1)
}
if elapsed < 300*time.Millisecond {
t.Fatalf("退避未生效:elapsed=%v, want ≥300ms", elapsed)
}
// AC3 异源口径:Prometheus 计数器与日志终态行同源递增(用增量,计数器进程全局)
if got := metricsHitEventAppendFailedTotal(); got != before+1 {
t.Fatalf("计数器 zhiyi_hit_event_append_failed_total 应 +1,before=%d 实际=%d", before, got)
}
out := cap.String()
if !strings.Contains(out, "AppendHitEvent FAILED (retry exhausted 3)") {
t.Fatalf("缺终态失败日志行\n--- 捕获日志全文 ---\n%s", out)
}
t.Logf("=== AC2 after(恒冲突→终态失败,原始日志行)===\n%s", out)
}
// ─── AC4 无冲突路径逐位等价:恰好 1 次 rpc、0 退避延迟、无重试行 ──
func TestAppendHitEvent_NoConflict_ExactlyOnce_NoBackoff(t *testing.T) {
fk := newFakeServer(t, 0, "") // 首次即成功
defer fk.close()
cap := captureLogs(t)
rc := fk.client()
start := time.Now()
err := rc.AppendHitEvent("mem_no_conflict", HitOutcomePos, HitReasonDownstreamUse)
elapsed := time.Since(start)
if err != nil {
t.Fatalf("无冲突应成功: %v", err)
}
if got := fk.callCount(); got != 1 {
t.Fatalf("无冲突路径 rpc 尝试 = %d, want 恰好 1(无额外开销)", got)
}
if elapsed > 250*time.Millisecond {
t.Fatalf("无冲突路径不应有退避延迟,elapsed=%v", elapsed)
}
out := cap.String()
if strings.Contains(out, "retry attempt") {
t.Fatalf("无冲突路径不应出现重试行\n--- 捕获日志全文 ---\n%s", out)
}
t.Logf("AC4:无冲突路径 1 次 rpc、耗时 %v(0 退避,行为与修复前等价)", elapsed)
}
// ─── 非可重试错误立即返回、不重试(复用 isRetryableLanceConflict 分类)──
func TestAppendHitEvent_NonRetryableError_NoRetry(t *testing.T) {
fk := newFakeServer(t, -1, "lance error: Schema Mismatch: unexpected column")
defer fk.close()
cap := captureLogs(t)
rc := fk.client()
before := metricsHitEventAppendFailedTotal()
err := rc.AppendHitEvent("mem_schema_err", HitOutcomePos, HitReasonDownstreamUse)
if err == nil {
t.Fatalf("schema 错应返回错误")
}
if strings.Contains(err.Error(), "retry exhausted") {
t.Fatalf("不可重试错误不应进重试耗尽分支,实际=%v", err)
}
if got := fk.callCount(); got != 1 {
t.Fatalf("不可重试错误 rpc 尝试 = %d, want 恰好 1(不重试)", got)
}
if strings.Contains(cap.String(), "retry attempt") {
t.Fatalf("不可重试错误不应出现重试行")
}
if got := metricsHitEventAppendFailedTotal(); got != before+1 {
t.Fatalf("不可重试终态失败计数器应 +1,before=%d 实际=%d", before, got)
}
}
// ─── AC2 · 修复前 vs 修复后 数值对比(同一「冲突 3 次后恢复」场景)────────
// 修复前(单次 rpc 无重试):冲突 ⇒ 终态失败 1(事件永久丢);
// 修复后(有界重试到成功):终态失败 0(事件落库)。
func TestAppendHitEvent_RetryFix_BeforeVsAfterComparison(t *testing.T) {
after := newFakeServer(t, 3, "")
defer after.close()
aerr := after.client().AppendHitEvent("mem_n", HitOutcomePos, HitReasonDownstreamUse)
afterTerminalFailures := 0 // 修复后:重试到成功,终态失败归零
if aerr != nil {
afterTerminalFailures = 1
}
// 修复前等价语义:单次 rpc 冲突即放弃 ⇒ 终态失败 1(当天 42 条丢失的成因)
const beforeTerminalFailures = 1
if afterTerminalFailures != 0 {
t.Fatalf("修复后冲突 3 次(≤重试预算)应终态失败=0,实际 err=%v", aerr)
}
t.Logf("AC2 数值对比:修复前 终态失败=%d(冲突即终态丢) vs 修复后 终态失败=%d(重试到成功)",
beforeTerminalFailures, afterTerminalFailures)
}
+72 -6
View File
@@ -14,6 +14,7 @@ import (
"sync"
"time"
"github.com/xiaoxue/memoryweave/internal/metrics"
"github.com/xiaoxue/memoryweave/internal/models"
)
@@ -945,6 +946,73 @@ func (rc *RustLanceDBClient) retryUpdateRPC(table, id, fields string) error {
id, updateMaxRetries, lastErr)
}
// ─── AppendHitEvent 冲突有界重试(t_7793a484 残差缺口:命中事件写路径)─────
//
// 修复前:AppendHitEvent 一次发 `lancedb_append_hit_event`,冲突(Rust 内部 20 次
// commit 重试耗尽)⇒ 终态丢 ⇒ outcome 事件(V 轴信号:hits+/hits−)永久丢失。
// 10-16 实测当日 42 条 `AppendHitEvent failed` 全为终态丢(均 "Commit conflict ...
// after 20 retries"),来源 = usage_track 下游使用判定(usage_track.go 旧 `_ =` 吞错)
// + 人工 feedback 端点。
//
// 重试安全性(幂等):Rust 侧 append_hit_event 是 append-only INSERT(hit_events 表
// tbl.add,行 id = memory_id+"-"+unix微秒,每次调用唯一)——MVCC commit conflict 时
// **整个提交原子不生效**(不产生版本,数据文件成孤儿),重放追加**不产生重复行**
// (与 t_28aa278e update col+1「对最新已提交版本重算」同语义,官方 "rerun the operation")。
// 规格与 Update 同(t_28aa278e):N=3 次重试 + 50/100/200ms 指数退避;耗尽/非可重试
// ⇒ 返回明确错误(可查、禁静默);无冲突路径恰好 1 次 rpc、0 退避(AC4 行为等价)。
const (
appendHitEventMaxRetries = 3
appendHitEventBackoffBase = 50 * time.Millisecond
appendHitEventBackoffCap = 200 * time.Millisecond
)
// retryAppendHitEventRPC 对 lancedb_append_hit_event 调用做有界指数退避重试(仅可重试
// MVCC 冲突,t_7793a484)。与 retryUpdateRPC 同语义,区别:append_hit_event 参数化
// (id/outcome/reason/source 整 req 重放,Rust 侧 ts 未传时按当前时间重算——同逻辑事件、
// 不同行 id,重试不重复)。
// 返回:首次成功或重试后成功 = nil;耗尽 = 含尝试次数的明确错误;非可重试错误 = 原样立即返回。
// 可观测性:终态失败打 "AppendHitEvent FAILED"(独立日志计数 + Prometheus 计数器
// zhiyi_hit_event_append_failed_total,AC3 双口径对齐)。
func (rc *RustLanceDBClient) retryAppendHitEventRPC(req ipcReq) error {
backoff := appendHitEventBackoffBase
var lastErr error
for attempt := 0; attempt <= appendHitEventMaxRetries; attempt++ {
if attempt > 0 {
// 第 attempt 次重试(1-based):attempt=1→50ms, 2→100ms, 3→200ms
log.Printf("[ipc] AppendHitEvent retry attempt %d/%d id=%s outcome=%s reason=%s error=%v",
attempt, appendHitEventMaxRetries, req.ID, req.Outcome, req.Reason, lastErr)
time.Sleep(backoff)
if backoff < appendHitEventBackoffCap {
backoff *= 2
if backoff > appendHitEventBackoffCap {
backoff = appendHitEventBackoffCap
}
}
}
_, err := rc.rpc(req)
if err == nil {
if attempt > 0 {
log.Printf("[ipc] AppendHitEvent retried OK after %d id=%s outcome=%s reason=%s",
attempt, req.ID, req.Outcome, req.Reason)
} else {
log.Printf("[ipc] AppendHitEvent OK id=%s outcome=%s reason=%s", req.ID, req.Outcome, req.Reason)
}
return nil
}
if !isRetryableLanceConflict(err) {
log.Printf("[ipc] AppendHitEvent FAILED: id=%s outcome=%s error=%v", req.ID, req.Outcome, err)
metrics.HitEventAppendFailedTotal.Inc()
return err // 非可重试错误:立即返回,不重试
}
lastErr = err
}
log.Printf("[ipc] AppendHitEvent FAILED (retry exhausted %d): id=%s outcome=%s last_error=%v",
appendHitEventMaxRetries, req.ID, req.Outcome, lastErr)
metrics.HitEventAppendFailedTotal.Inc()
return fmt.Errorf("lancedb append_hit_event (id=%s): retry exhausted after %d retries: %w",
req.ID, appendHitEventMaxRetries, lastErr)
}
func (rc *RustLanceDBClient) SoftDelete(id, reason string) error {
// 🔴 2026-10-06 防御:空 id 会被 Rust IPC 直接拒绝("id required"),
// 而调用方曾忽略错误照样计数(admin.go forgotten++),造成「遗忘计数虚高 + 每轮刷错误日志」。
@@ -1453,18 +1521,16 @@ func (rc *RustLanceDBClient) AppendHitEvent(memoryID, outcome, reason string) er
return fmt.Errorf("AppendHitEvent: invalid outcome %q (must be pos/neg); dedup-demote/recall-appearance are NOT outcomes", outcome)
}
reason = NormalizeHitReason(reason)
_, err := rc.rpc(ipcReq{
// t_7793a484:冲突有界退避重试(与 Update 同规格:3 次 + 50/100/200ms)。
// 修复前单次即终态丢(Rust 内部 20 次 commit 重试耗尽后不重发);无冲突路径不变(1 次 rpc、0 退避)。
req := ipcReq{
Type: "lancedb_append_hit_event",
ID: memoryID,
Outcome: outcome,
Reason: reason,
Source: "append_hit_event",
})
if err != nil {
log.Printf("[ipc] AppendHitEvent failed id=%s: %v", memoryID, err)
return err
}
return nil
return rc.retryAppendHitEventRPC(req)
}
// CountHitEvents 统计某 memory 在某窗口起点的 outcome 事件数(周窗口聚合,P2 自适应阈值用)。
+9 -1
View File
@@ -200,7 +200,15 @@ func CheckCommittedForUse(ldb LanceDB, agent, namespace, content string) []Usage
}
// 判定「被用上」:落 outcome + 累加 recall_verified_count + 消费该 recall 行。
now := time.Now().Format(time.RFC3339)
_ = ldb.AppendHitEvent(memID, HitOutcomePos, HitReasonDownstreamUse)
// t_7793a484:outcome 事件失败不再静默吞(修复前 `_ =` 丢错 + 单次 rpc 无重试 ⇒
// 一次冲突即终态丢,10-16 实测 42 条丢失走此路径)。现:AppendHitEvent 内置
// 有界重试(同 Update 规格);终态失败(耗尽/非可重试)⇒ 不消费(consumed 保持 0)
// ⇒ 下一轮 commit 重扫重试,事件不静默丢。失败可查(logUsage 计数 + 计数器
// zhiyi_hit_event_append_failed_total),禁静默。
if err := ldb.AppendHitEvent(memID, HitOutcomePos, HitReasonDownstreamUse); err != nil {
logUsage("hit event append FAILED (id=%s, NOT consumed, will retry next commit) : %v", memID, err)
continue
}
// t_28aa278e 方案①:更新成功后才消费 usage_recall 行。
// 旧实现无条件消费 ⇒ Update 冲突耗尽时该 recall_verified_count 增量被永久丢弃
// (下轮不再重扫)。现改为:Update 返回非 nil(冲突重试耗尽/非可重试错误)