diff --git a/go/internal/metrics/metrics.go b/go/internal/metrics/metrics.go index 9f29dc6..86b1941 100644 --- a/go/internal/metrics/metrics.go +++ b/go/internal/metrics/metrics.go @@ -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, diff --git a/go/internal/storage/concurrent_commit_conflict_test.go b/go/internal/storage/concurrent_commit_conflict_test.go index ac9c4ff..0c6295e 100644 --- a/go/internal/storage/concurrent_commit_conflict_test.go +++ b/go/internal/storage/concurrent_commit_conflict_test.go @@ -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 永久丢失)") } \ No newline at end of file diff --git a/go/internal/storage/hit_event_retry_test.go b/go/internal/storage/hit_event_retry_test.go new file mode 100644 index 0000000..08b7676 --- /dev/null +++ b/go/internal/storage/hit_event_retry_test.go @@ -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) +} diff --git a/go/internal/storage/lancedb_ipc.go b/go/internal/storage/lancedb_ipc.go index c118a41..e5e4a32 100644 --- a/go/internal/storage/lancedb_ipc.go +++ b/go/internal/storage/lancedb_ipc.go @@ -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 自适应阈值用)。 diff --git a/go/internal/storage/usage_track.go b/go/internal/storage/usage_track.go index 9295b80..1abb93d 100644 --- a/go/internal/storage/usage_track.go +++ b/go/internal/storage/usage_track.go @@ -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(冲突重试耗尽/非可重试错误)