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 全仓测试通过。
458 lines
17 KiB
Go
458 lines
17 KiB
Go
// 织忆 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...)
|
||
} |