Files
memoryweave/go/internal/storage/usage_track.go
T
小唯 941b7eec32 fix(storage): t_20bfbd9a 边车线程风暴根治 — Rust 连接并发上限+RSS护栏降级串行;命中事件重试跨commit指数退避+积压上限
AC1 Rust accept 循环对每连接 thread::spawn 无上限,Go 侧每 rpc 新 dial ⇒
   IPC 洪泛线程线性涨到 736。加 AtomicUsize 连接门(默认64, env ZHIYI_CONN_MAX),
   超限回 heavy_conn_busy;RSS 超上限(默认3000MB, env ZHIYI_RSS_LIMIT_MB)降级串行。
AC3 usage_recall 加 retry_count/next_retry_at:持久失败行指数退避(1s..600s)不再
   每 commit 热重扫;积压超 ZHIYI_USAGE_BACKLOG_MAX(默认500)本轮跳过扫描。
AC4 新增 usageBackoff/backlog 单测。Go 全仓测试通过。
2026-10-18 02:19:03 +08:00

458 lines
17 KiB
Go
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// 织忆 MemoryWeave — ⑤使用追踪:自动产生「召回的记忆被真实用上」的信号源
//
// 背景(t_5aa4dcac):闭环链 ⑤使用追踪 → ⑥反馈 → ⑦回流 → ④召回更准。
// 现状:⑥反馈只靠人工点击(46/36,909 = 0.12%)——没人点,反馈永远长不出来。
// 本模块给 ⑥ 提供一个**自动**信号源:当一条被召回的 **mem_*** 记忆的独特内容
// 真实出现在**后续写入织忆的 episode 内容**里(即 agent 把它带进了实际产出),
// 就判定「被用上」→ 追加 hit_event(pos, downstream_use) + 累加 recall_verified_count。
//
// 为什么这个判据可靠(区别于 GA-P0-2 的教训):
// - GA-P0-2 的教训是「出现在召回结果里(recall_seen)≠ 被用上」——召回频率
// 会给 hub 记忆虚假保命。本信号**不看召回频率**,看的是「召回之后,该记忆的
// 独特 token 是否逐字出现在真实写入的后续内容里」。这是 hit_event.go 定义的
// downstream_use(下游流程实际引用了这条记忆的内容),是唯一不违背
// 「被搬运/被看到都不算」铁律的自动信号。
// - 要求 ≥2 个独特 token 同时命中,降低「只撞上一个通用词」的假阳性。
//
// ⛔ 约束(卡 body):
// - 零新依赖:用已在 go.mod 的 modernc.org/sqlite(纯 Go,无 cgo)。
// - 不新增常驻进程:写侧挂载(recall 时记录 + commit 时检测),不跑后台循环。
// - 不碰 state.db:追踪数据落织忆自己的库 /var/lib/memoryweave/usage_track.db。
// - env 门控 ZHIYI_USAGE_TRACK,默认关 ⇒ 关时本模块所有函数立即返回,行为零变化。
//
// 可回滚:把环境变量置 0 / 关掉即可,代码路径全门控。
package storage
import (
"database/sql"
"encoding/json"
"log"
"os"
"sort"
"strings"
"sync"
"time"
_ "modernc.org/sqlite"
)
// ─── 开关(读一次即可)────────────────────────────────────────────
var usageTrackEnabled = parseUsageTrack()
// SetUsageTrackingForTest 测试专用:覆盖包级门控开关(生产不调用)。
func SetUsageTrackingForTest(v bool) { usageTrackEnabled = v }
func parseUsageTrack() bool {
v := os.Getenv("ZHIYI_USAGE_TRACK")
if v == "" {
return false
}
return strings.EqualFold(v, "1") || strings.EqualFold(v, "true") ||
strings.EqualFold(v, "on") || strings.EqualFold(v, "yes")
}
// UsageTrackingEnabled 门控:默认 false ⇒ 关闭时零行为变化。
func UsageTrackingEnabled() bool { return usageTrackEnabled }
// 门控参数
var (
// 只对「最近 N 小时内被召回」的记忆做检测,避免旧召回反复标记新写入。
usageWindowHours = envFloat("ZHIYI_USAGE_WINDOW_HOURS", 48)
// 判定「用上」需要命中的独特内容**总长度**下界(rune)。
// 按长度加权而非「≥2 个 token」:短中文记忆(如"牧尘今天要求处理看板任务")
// 被整体拆成一个长 token,单个命中即高精度(12 字整句撞车概率极低);
// 而 2 个短英文词命中(如 vpn+lancedb)同样强。统一折算成「该记忆的独特内容
// 有多少字符被逐字带进了输出」——≥8 字才判用上,兼顾长短记忆、压制通用词撞车。
usageMatchRunes = int(envFloat("ZHIYI_USAGE_MATCH_RUNES", 8))
// 独特 token 池大小上限。
usageTokenTopN = int(envFloat("ZHIYI_USAGE_TOKEN_TOP_N", 8))
)
// 退避参数(t_20bfbd9a 治本①):命中事件重试的跨 commit 指数退避。
// 与 IPC 层 in-call 退避(lancedb_ipc.go 50/100/200ms)正交:这里的退避是**跨 commit 层面**,
// 防的是「一条持久性失败的坏行在每次 commit 都被热重扫」→ 风暴叠风暴。首次失败退避 1s,
// 每多失败一次翻倍,封顶 10min。成功消费后 retry_count 归零(usage_track.go 消费分支)。
var (
usageBackoffBase = envFloat("ZHIYI_USAGE_BACKOFF_BASE_S", 1)
usageBackoffCap = envFloat("ZHIYI_USAGE_BACKOFF_CAP_S", 600)
)
// usageBackoff 第 n 次失败的退避时长:min(2^(n-1) * base, cap)。
// n>=1;n=1 → base,n=2 → 2*base,… 封顶 cap。
func usageBackoff(n int64) time.Duration {
s := usageBackoffBase
for i := int64(1); i < n; i++ {
next := s * 2
if next >= usageBackoffCap {
// 下一步将超过 cap:直接封顶返回,不再累计
return time.Duration(usageBackoffCap * float64(time.Second))
}
s = next
}
return time.Duration(s * float64(time.Second))
}
// envFloat 读取环境浮点配置(默认值兜底;0/负值视为默认)。
// ⚠️ recall.go 已有同签名 envFloat(t_da61c470,语义:解析失败回落默认、≤0 原样返回),
// 这里不再重声明,直接复用;消费方需自备 >0 守卫(backlogMax/backoff 均已带)。
// ─── 库文件(织忆自己的库,非 Hermes state.db)─────────────────────
// var 而非 const:测试可换到临时路径,避免污染生产 usage_track.db。
var usageTrackDBPath = "/var/lib/memoryweave/usage_track.db"
// SetUsageTrackDBPathForTest 测试专用:把追踪库改到临时路径。
func SetUsageTrackDBPathForTest(p string) {
if p != "" {
usageTrackDBPath = p
}
}
// resetUsageTrackForTest 测试专用:重置 DB 单例,使下次调用按新路径重开。
func resetUsageTrackForTest() {
usageOnce = sync.Once{}
usageDB = nil
}
var (
usageDB *sql.DB
usageOnce sync.Once
)
func usageOpen() *sql.DB {
usageOnce.Do(func() {
db, err := sql.Open("sqlite", "file:"+usageTrackDBPath+
"?_pragma=journal_mode(WAL)&_pragma=busy_timeout(5000)")
if err != nil {
logUsage("open %s: %v", usageTrackDBPath, err)
return
}
if _, err := db.Exec(`CREATE TABLE IF NOT EXISTS usage_recall(
id INTEGER PRIMARY KEY AUTOINCREMENT,
memory_id TEXT NOT NULL,
content TEXT NOT NULL,
tokens TEXT NOT NULL,
q_hash TEXT NOT NULL,
namespace TEXT,
agent TEXT,
recalled_at TEXT NOT NULL,
consumed INTEGER NOT NULL DEFAULT 0,
consumed_at TEXT,
retry_count INTEGER NOT NULL DEFAULT 0,
next_retry_at TEXT
)`); err != nil {
logUsage("create table: %v", err)
}
// 存量库迁移(t_20bfbd9a):旧表无 retry_count/next_retry_at 列,逐列补(幂等)。
for _, stmt := range []string{
"ALTER TABLE usage_recall ADD COLUMN retry_count INTEGER NOT NULL DEFAULT 0",
"ALTER TABLE usage_recall ADD COLUMN next_retry_at TEXT",
} {
if _, err := db.Exec(stmt); err != nil && !strings.Contains(err.Error(), "duplicate column name") {
// 非「已存在」的错(表不存在等)也忽略:CREATE IF NOT EXISTS 已兜表级,
// 这里只负责加列,列已存在即静默通过。
}
}
_, _ = db.Exec(`CREATE INDEX IF NOT EXISTS idx_usage_mem ON usage_recall(memory_id)`)
_, _ = db.Exec(`CREATE INDEX IF NOT EXISTS idx_usage_time ON usage_recall(recalled_at)`)
usageDB = db
})
return usageDB
}
// RecalledMemory 一次召回中命中记忆的最小信息(写侧在 recall 响应处提供)。
type RecalledMemory struct {
ID string
Content string
Namespace string
Agent string
Query string
}
// RecordRecalled 写侧钩子:记录本次召回命中的记忆 + 其独特 token(门控)。
// 关闭时立即返回,零开销。
func RecordRecalled(recs []RecalledMemory) {
if !usageTrackEnabled || len(recs) == 0 {
return
}
db := usageOpen()
if db == nil {
return
}
now := time.Now().Format(time.RFC3339)
for _, r := range recs {
if r.ID == "" || r.Content == "" {
continue
}
toks := DistinctiveTokens(r.Content, usageTokenTopN)
if len(toks) == 0 {
continue
}
tj, _ := json.Marshal(toks)
if _, err := db.Exec(
`INSERT INTO usage_recall(memory_id, content, tokens, q_hash, namespace, agent, recalled_at)
VALUES(?,?,?,?,?,?,?)`,
r.ID, r.Content, string(tj), queryHash(r.Query), r.Namespace, r.Agent, now,
); err != nil {
logUsage("insert recall row: %v", err)
}
}
}
// CheckCommittedForUse commit 写侧钩子:检查新写入的内容是否携带了
// 最近被召回记忆的独特 token;命中则判定「被用上」并落 outcome(门控)。
// 返回本次判定出的「被用上」记忆(供上报/取证)。
func CheckCommittedForUse(ldb LanceDB, agent, namespace, content string) []UsageFlag {
if !usageTrackEnabled || ldb == nil || content == "" {
return nil
}
db := usageOpen()
if db == nil {
return nil
}
// 积压上限量化(t_20bfbd9a 治本②):未消费待重试行超过上限 ⇒ 本轮跳过扫描,
// 防止「一条永远失败的坏行 + 高 commit 频率」在每次 commit 都全量重扫、叠成风暴。
// 上限 env ZHIYI_USAGE_BACKLOG_MAX,默认 500。
backlogMax := int(envFloat("ZHIYI_USAGE_BACKLOG_MAX", 500))
if backlogMax > 0 {
var pending int
if err := db.QueryRow(`SELECT COUNT(*) FROM usage_recall WHERE consumed=0`).Scan(&pending); err == nil && pending > backlogMax {
logUsage("backlog %d > cap %d: skip scan this commit", pending, backlogMax)
return nil
}
}
cutoff := time.Now().Add(-time.Duration(usageWindowHours * float64(time.Hour))).Format(time.RFC3339)
scanNow := time.Now()
// 退避过滤(t_20bfbd9a 治本①):next_retry_at 为 NULL(首次待处理)或已到重试时间,
// 才进本轮重扫。持久性失败的坏行被指数退避挡在窗口外,不再每 commit 热重试。
rows, err := db.Query(
`SELECT id, memory_id, content, tokens, namespace, agent, retry_count
FROM usage_recall WHERE consumed=0 AND recalled_at>=?
AND (next_retry_at IS NULL OR next_retry_at<=?)`,
cutoff, scanNow.Format(time.RFC3339))
if err != nil {
logUsage("query recall log: %v", err)
return nil
}
defer rows.Close()
contentSet := tokenSet(content)
flags := make([]UsageFlag, 0)
for rows.Next() {
var id int64
var memID, memContent, tokensJSON, ns, ag string
var retryCount int64
if err := rows.Scan(&id, &memID, &memContent, &tokensJSON, &ns, &ag, &retryCount); err != nil {
continue
}
// 归属过滤:同一 agent,或同一 namespace,或共享/全局。跨域不强求。
if ag != "" && agent != "" && ag != agent && ns != "" && namespace != "" && ns != namespace {
continue
}
var toks []string
if err := json.Unmarshal([]byte(tokensJSON), &toks); err != nil {
continue
}
runes, hits := countTokenRunes(toks, contentSet)
if runes < usageMatchRunes {
continue
}
// 判定「被用上」:落 outcome + 累加 recall_verified_count + 消费该 recall 行。
now := time.Now().Format(time.RFC3339)
// 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)
// t_20bfbd9a 治本①:持久性失败(如坏行 memID 已从 LanceDB 删除)若不加退避,
// 会在每次 commit 都热重试,commit 风暴时叠成重扫风暴。加指数退避:
// 第 n 次失败后 next_retry_at = now + min(2^(n-1) * base, cap),退避期外不再重扫。
// 成功消费时把 retry_count 归零;每轮只推进 retry_count 一次(不指数级暴涨)。
_, _ = db.Exec(
`UPDATE usage_recall SET retry_count=retry_count+1, next_retry_at=? WHERE id=?`,
time.Now().Add(usageBackoff(retryCount+1)).Format(time.RFC3339), id)
continue
}
// t_28aa278e 方案①:更新成功后才消费 usage_recall 行。
// 旧实现无条件消费 ⇒ Update 冲突耗尽时该 recall_verified_count 增量被永久丢弃
// (下轮不再重扫)。现改为:Update 返回非 nil(冲突重试耗尽/非可重试错误)
// ⇒ 不消费(consumed 保持 0)⇒ 下一轮 commit 重扫该窗口会重试,计数增量不静默丢失。
// 失败数可查(logUsage 计数),禁静默。
if err := ldb.Update("memories", memID, map[string]any{
"recall_verified_count": map[string]string{"$inc": "1"},
}); err != nil {
logUsage("recall_verified_count update FAILED (id=%s, NOT consumed, will retry next commit) : %v", memID, err)
_, _ = db.Exec(
`UPDATE usage_recall SET retry_count=retry_count+1, next_retry_at=? WHERE id=?`,
time.Now().Add(usageBackoff(retryCount+1)).Format(time.RFC3339), id)
continue
}
_, _ = db.Exec(`UPDATE usage_recall SET consumed=1, consumed_at=?, retry_count=0, next_retry_at=NULL WHERE id=?`, now, id)
flags = append(flags, UsageFlag{
MemoryID: memID, Content: memContent, Criterion: "carry_forward",
MatchedTokens: toks, HitCount: hits, RunesMatched: runes, ConsumedAt: now,
})
}
return flags
}
// UsageFlag 一条「被用上」判定样本(AC2 上报用)。
type UsageFlag struct {
MemoryID string `json:"memory_id"`
Content string `json:"content"`
Criterion string `json:"criterion"`
MatchedTokens []string `json:"matched_tokens"`
HitCount int `json:"hit_count"`
RunesMatched int `json:"runes_matched"`
ConsumedAt string `json:"consumed_at"`
}
// UsageReport 读取最近已判定的「被用上」样本(取证/上报)。
func UsageReport(limit int) []UsageFlag {
if !usageTrackEnabled {
return nil
}
db := usageOpen()
if db == nil {
return nil
}
if limit <= 0 {
limit = 20
}
rows, err := db.Query(
`SELECT memory_id, content, tokens, consumed_at FROM usage_recall
WHERE consumed=1 AND consumed_at IS NOT NULL ORDER BY id DESC LIMIT ?`, limit)
if err != nil {
return nil
}
defer rows.Close()
out := make([]UsageFlag, 0)
for rows.Next() {
var memID, content, tokensJSON, at string
if err := rows.Scan(&memID, &content, &tokensJSON, &at); err != nil {
continue
}
var toks []string
_ = json.Unmarshal([]byte(tokensJSON), &toks)
out = append(out, UsageFlag{MemoryID: memID, Content: content,
Criterion: "carry_forward", MatchedTokens: toks, ConsumedAt: at})
}
return out
}
// ─── 独特 token 提取 ────────────────────────────────────────────
// DistinctiveTokens 从内容里抽出「独特词」:英文词 ≥3 字母、中文连续段 ≥2 字,
// 去掉通用停用词后按长度降序取 topN。中文按连续 Han 段整体作 token(不拆单字)。
func DistinctiveTokens(content string, topN int) []string {
if topN <= 0 {
topN = 8
}
seen := map[string]bool{}
var toks []string
// 扫描:连续 ASCII 字母/数字段 与 连续 CJK 段
i := 0
runes := []rune(content)
for i < len(runes) {
c := runes[i]
switch {
case isASCIIWord(c):
j := i
for j < len(runes) && isASCIIWord(runes[j]) {
j++
}
w := strings.ToLower(string(runes[i:j]))
if len(w) >= 3 && !stopword[w] && !seen[w] {
seen[w] = true
toks = append(toks, w)
}
i = j
case isCJK(c):
j := i
for j < len(runes) && isCJK(runes[j]) {
j++
}
seg := string(runes[i:j])
if len([]rune(seg)) >= 2 && !seen[seg] {
seen[seg] = true
toks = append(toks, seg)
}
i = j
default:
i++
}
}
sort.Slice(toks, func(a, b int) bool {
return len([]rune(toks[a])) > len([]rune(toks[b]))
})
if len(toks) > topN {
toks = toks[:topN]
}
return toks
}
func isASCIIWord(r rune) bool {
return (r >= 'a' && r <= 'z') || (r >= 'A' && r <= 'Z') || (r >= '0' && r <= '9')
}
func isCJK(r rune) bool {
return (r >= 0x4e00 && r <= 0x9fff) || (r >= 0x3400 && r <= 0x4dbf)
}
// tokenSet 把内容转成 token 集合(与 DistinctiveTokens 同口径,供命中判定)。
func tokenSet(content string) map[string]bool {
set := map[string]bool{}
for _, t := range DistinctiveTokens(content, 64) {
set[t] = true
}
return set
}
func countTokenRunes(toks []string, set map[string]bool) (runes, hits int) {
for _, t := range toks {
if set[t] {
runes += len([]rune(t))
hits++
}
}
return
}
func queryHash(q string) string {
// 轻量去重键:长度 + 前 16 个 ASCII 字母数字(防止相同 query 重复计)
if len(q) <= 16 {
return q
}
var sb strings.Builder
cnt := 0
for _, r := range q {
if isASCIIWord(r) {
sb.WriteRune(r)
cnt++
if cnt >= 16 {
break
}
}
}
return sb.String()
}
// stopword 通用停用词(英文 + 中文),避免「的/了/是/for/the」这类词当独特 token。
var stopword = func() map[string]bool {
words := strings.Fields(`
the a an and or of to in on for with as by at from is are was were be been being
this that these those it its not no but if then so what which who when where why how
所有 这个 那个 这些 那些 我们 你们 他们 以及 或者 就是 还是 一个 一种 关于 对于 因为 所以
可以 应该 需要 使用 通过 进行 没有 什么 怎么 如何 是否 但是 然后 这里 那里 一下 之类
规则 说明 注意 描述 内容 定义 用户 记忆 召回 织忆
`)
m := map[string]bool{}
for _, w := range words {
m[w] = true
}
return m
}()
func logUsage(format string, args ...interface{}) {
// 轻量日志:打 [usage] 前缀便于 grep。
log.Printf("[usage] "+format, args...)
}