diff --git a/.env.example b/.env.example index e3369d9..08c49c7 100644 --- a/.env.example +++ b/.env.example @@ -72,6 +72,17 @@ JANUS_VISIT_RETENTION=2160h JANUS_VISIT_CLEANUP_INTERVAL=24h # 访问记录清理的单批行数。不分批时一条 DELETE 会锁住全部过期行直到提交(长事务)。 JANUS_VISIT_CLEANUP_BATCH=10000 +# 访问明细异步写入队列:跳转只入队,后台 worker 批量落库;队列满时丢弃(计数+日志),不阻塞跳转 +JANUS_VISIT_QUEUE_SIZE=10000 +JANUS_VISIT_QUEUE_WORKERS=2 +JANUS_VISIT_QUEUE_BATCH=200 + +# ---------- 数据库连接池 / 跳转缓存 ---------- +# 业务连接池最大连接数(空闲连接上限取同值) +JANUS_DB_MAX_OPEN_CONNS=25 +# 301 短链的浏览器缓存时长(Cache-Control: private, max-age);0 = 不缓存。 +# 规则改写 / 多目标轮询 / 302 一律 no-store,不受此项影响 +JANUS_REDIRECT_301_MAX_AGE=5m # ---------- 落地页上传(压缩包托管) ---------- # 上传落地页(zip 解压后)的存放目录,生产部署挂持久卷(见 docker-compose.prod.yml) diff --git a/cmd/janus/main.go b/cmd/janus/main.go index 71d9274..d8e84ea 100644 --- a/cmd/janus/main.go +++ b/cmd/janus/main.go @@ -43,7 +43,7 @@ func main() { // 此后没有任何使用者,留到进程退出等于白占 10 个连接。 pool.Close() - gdb, err := db.OpenGORM(cfg.DatabaseURL) + gdb, err := db.OpenGORMWithPool(cfg.DatabaseURL, cfg.DBMaxOpenConns) if err != nil { log.Fatalf("open gorm: %v", err) } @@ -71,7 +71,12 @@ func main() { SMTP: smtpCfg, }, os.Stdout) - app := httpapi.New(httpapi.Deps{Store: st, Mailer: m, Cfg: cfg}) + // 访问明细异步队列:跳转请求只入队,批量落库在后台完成(见 httpapi/visit_queue.go)。 + // 必须在 srv.Shutdown 之后 Close,把已入队的明细排空,否则重启/发布会丢掉最后一批访问。 + visitQueue := httpapi.NewVisitQueue(st, httpapi.VisitQueueConfig{ + Size: cfg.VisitQueueSize, Workers: cfg.VisitQueueWorkers, BatchSize: cfg.VisitQueueBatch, + }) + app := httpapi.New(httpapi.Deps{Store: st, Mailer: m, Cfg: cfg, VisitQueue: visitQueue}) // 后台任务:DNS 重试、证书预签发探活、访问/会话清理。 // Shutdown 后显式 cancel 并等待 worker 退出,避免进程退出时后台任务仍在写库。 @@ -106,6 +111,15 @@ func main() { if err := srv.Shutdown(shutdownCtx); err != nil { log.Printf("http shutdown: %v", err) } + // HTTP 已停止接收请求,此后不会再有明细入队:排空队列(最多 5s)。 + drainCtx, drainCancel := context.WithTimeout(context.Background(), 5*time.Second) + if err := visitQueue.Close(drainCtx); err != nil { + log.Printf("visit queue drain: %v", err) + } + drainCancel() + if n := visitQueue.Dropped(); n > 0 { + log.Printf("visit queue: 运行期间因队列满共丢弃 %d 条访问明细", n) + } workerCancel() select { case <-workerDone: diff --git a/docker-compose.prod.yml b/docker-compose.prod.yml index 03a4ec6..ac2e34d 100644 --- a/docker-compose.prod.yml +++ b/docker-compose.prod.yml @@ -48,6 +48,12 @@ services: JANUS_DNS_MAX_AGE: "${JANUS_DNS_MAX_AGE:-72h}" JANUS_VISIT_RETENTION: "${JANUS_VISIT_RETENTION:-2160h}" JANUS_VISIT_CLEANUP_INTERVAL: "${JANUS_VISIT_CLEANUP_INTERVAL:-24h}" + # 访问记录异步写入队列 / 连接池 / 301 缓存(见 .env.example) + JANUS_VISIT_QUEUE_SIZE: "${JANUS_VISIT_QUEUE_SIZE:-10000}" + JANUS_VISIT_QUEUE_WORKERS: "${JANUS_VISIT_QUEUE_WORKERS:-2}" + JANUS_VISIT_QUEUE_BATCH: "${JANUS_VISIT_QUEUE_BATCH:-200}" + JANUS_DB_MAX_OPEN_CONNS: "${JANUS_DB_MAX_OPEN_CONNS:-25}" + JANUS_REDIRECT_301_MAX_AGE: "${JANUS_REDIRECT_301_MAX_AGE:-5m}" # 上传落地页:容器内固定目录,由 uploads 卷持久化 JANUS_LANDING_UPLOAD_DIR: "/app/uploads" JANUS_LANDING_MAX_ZIP_BYTES: "${JANUS_LANDING_MAX_ZIP_BYTES:-10485760}" diff --git a/internal/config/config.go b/internal/config/config.go index c1cb3dd..61fe643 100644 --- a/internal/config/config.go +++ b/internal/config/config.go @@ -65,6 +65,28 @@ type Config struct { MigrationsDir string `env:"JANUS_MIGRATIONS_DIR" envDefault:"migrations"` + // DBMaxOpenConns 业务连接池(GORM / database/sql)的最大连接数。 + // 原来写死 10:跳转热路径每次访问要 3~6 次 DB 往返,10 条连接在突发流量下 + // 很快排队,排队时长直接叠加到访客的跳转延迟上。空闲连接上限取同一个值, + // 避免 database/sql 默认只留 2 条空闲连接导致高峰期反复建连。 + // 0 = 使用 db.DefaultMaxOpenConns(嵌入方用 WithConfig 传零值配置时的兜底)。 + DBMaxOpenConns int `env:"JANUS_DB_MAX_OPEN_CONNS" envDefault:"25"` + + // Redirect301MaxAge 301 短链响应的 Cache-Control max-age。 + // 301 在浏览器里默认可被无限期缓存:租户改了目标、停用了短链,已经访问过的 + // 访客仍会被浏览器直接带走,服务端连请求都收不到(访问明细也就漏了)。 + // 给 301 一个有界的 private max-age,把"改配置后多久对老访客生效"钉在这个窗口内。 + // 0 = 301 也不缓存(no-store)。 + Redirect301MaxAge time.Duration `env:"JANUS_REDIRECT_301_MAX_AGE" envDefault:"5m"` + + // 访问明细异步写入队列(见 httpapi.VisitQueue)。 + // VisitQueueSize 队列容量(条):写满时新明细被丢弃并计数,绝不阻塞跳转。 + // VisitQueueWorkers 落库 worker 数;VisitQueueBatch 单次批量 INSERT 的最大行数。 + // 0 = 使用 httpapi 内置默认值。 + VisitQueueSize int `env:"JANUS_VISIT_QUEUE_SIZE" envDefault:"10000"` + VisitQueueWorkers int `env:"JANUS_VISIT_QUEUE_WORKERS" envDefault:"2"` + VisitQueueBatch int `env:"JANUS_VISIT_QUEUE_BATCH" envDefault:"200"` + // SMTP 邮件(可选):配置后启用真实邮件发送,否则控制台 mailer PublicBaseURL string `env:"JANUS_PUBLIC_BASE_URL" envDefault:"https://app.janus.test"` SMTPHost string `env:"JANUS_SMTP_HOST"` @@ -135,6 +157,25 @@ func (c Config) Validate() error { return fmt.Errorf("%s 必须为正数,当前为 %d", i.name, i.v) } } + // 这几项允许 0(表示"用内置默认值"/"不缓存"),只拒绝负数: + // 负的连接数/容量在下游会被静默当成"无限"或直接 panic(make(chan, -1))。 + nonNegativeInts := []struct { + name string + v int + }{ + {"JANUS_DB_MAX_OPEN_CONNS", c.DBMaxOpenConns}, + {"JANUS_VISIT_QUEUE_SIZE", c.VisitQueueSize}, + {"JANUS_VISIT_QUEUE_WORKERS", c.VisitQueueWorkers}, + {"JANUS_VISIT_QUEUE_BATCH", c.VisitQueueBatch}, + } + for _, i := range nonNegativeInts { + if i.v < 0 { + return fmt.Errorf("%s 不能为负数,当前为 %d", i.name, i.v) + } + } + if c.Redirect301MaxAge < 0 { + return fmt.Errorf("JANUS_REDIRECT_301_MAX_AGE 不能为负数,当前为 %v", c.Redirect301MaxAge) + } if _, err := c.TrustedProxyNets(); err != nil { return fmt.Errorf("JANUS_TRUSTED_PROXY_CIDRS: %w", err) } diff --git a/internal/db/db.go b/internal/db/db.go index be6adc1..4037ffc 100644 --- a/internal/db/db.go +++ b/internal/db/db.go @@ -38,8 +38,27 @@ func Connect(ctx context.Context, url string) (*pgxpool.Pool, error) { return nil, fmt.Errorf("database not reachable: %w", lastErr) } +// DefaultMaxOpenConns 业务连接池默认最大连接数(JANUS_DB_MAX_OPEN_CONNS 未配置或为 0 时)。 +// +// 原来写死 10:跳转热路径每次访问要 3~6 次 DB 往返,突发流量下 10 条连接很快排满, +// 排队时长直接叠加到访客的跳转延迟上。25 仍远低于 Postgres 默认 max_connections=100, +// 给迁移、后台 worker 与运维连接留足余量。 +const DefaultMaxOpenConns = 25 + // OpenGORM 建立 GORM ORM 连接(数据访问层使用;迁移与测试原生操作仍走 pgxpool)。 +// 连接池大小取 DefaultMaxOpenConns;需要按配置调整时用 OpenGORMWithPool。 func OpenGORM(url string) (*gorm.DB, error) { + return OpenGORMWithPool(url, DefaultMaxOpenConns) +} + +// OpenGORMWithPool 同 OpenGORM,连接池上限由调用方指定(<=0 时取 DefaultMaxOpenConns)。 +// +// 空闲连接上限与最大连接数取同一个值:database/sql 默认只保留 2 条空闲连接, +// 高峰期多出来的连接用完即关、下一个请求再重新握手,等于把建连成本摊进每次跳转。 +func OpenGORMWithPool(url string, maxOpenConns int) (*gorm.DB, error) { + if maxOpenConns <= 0 { + maxOpenConns = DefaultMaxOpenConns + } gdb, err := gorm.Open(postgres.Open(url), &gorm.Config{ Logger: logger.Default.LogMode(logger.Silent), }) @@ -50,6 +69,9 @@ func OpenGORM(url string) (*gorm.DB, error) { if err != nil { return nil, fmt.Errorf("gorm sql db: %w", err) } - sqlDB.SetMaxOpenConns(10) + sqlDB.SetMaxOpenConns(maxOpenConns) + sqlDB.SetMaxIdleConns(maxOpenConns) + // 空闲过久的连接回收掉:低峰期不白占 Postgres 连接槽,也避开中间件(NAT/LB)静默断链。 + sqlDB.SetConnMaxIdleTime(5 * time.Minute) return gdb, nil } diff --git a/internal/httpapi/landing.go b/internal/httpapi/landing.go index 5355aee..5774b1f 100644 --- a/internal/httpapi/landing.go +++ b/internal/httpapi/landing.go @@ -160,7 +160,7 @@ func (a *API) handleLandingClick(c *gin.Context, code string) { LinkID: link.ID, DomainID: d.ID, Action: store.VisitActionClick, Outcome: store.VisitOutcomeSuccess, TargetURL: targetURL, }) - c.Redirect(http.StatusFound, targetURL) // 点击跳转固定 302 + redirectTemporary(c, targetURL) // 点击跳转固定 302(轮询目标,no-store) } // resolveLandingLinkForVisit 按 Host+code 宽松命中短链(短码命中即返回), diff --git a/internal/httpapi/links_test.go b/internal/httpapi/links_test.go index 76a5c6c..8f11e0b 100644 --- a/internal/httpapi/links_test.go +++ b/internal/httpapi/links_test.go @@ -124,6 +124,45 @@ func TestCustomCodeAnd301(t *testing.T) { if loc := resp.Header.Get("Location"); loc != "https://example.com/permanent" { t.Errorf("Location = %q", loc) } + // 301 必须带有界缓存:默认浏览器会无限期缓存 301,改目标/停用后老访客永远收不到。 + // testutil 的配置没设 JANUS_REDIRECT_301_MAX_AGE(零值 = no-store);生产默认 5m 时为 + // "private, max-age=300"。两种都可接受,不可接受的是缺省(= 无限期缓存)。 + if cc := resp.Header.Get("Cache-Control"); cc != "no-store" && !strings.HasPrefix(cc, "private, max-age=") { + t.Errorf("301 Cache-Control = %q, want no-store 或 private, max-age=N", cc) + } +} + +// TestHeadRedirectMatchesGet HEAD /{code} 与 GET 同状态码/Location,且不记明细。 +// 原先 HEAD 落进 NoRoute 一律 404,链接预览器与监控探测会把健康短链当成坏链。 +func TestHeadRedirectMatchesGet(t *testing.T) { + env := testutil.Setup(t) + c := loggedInTenant(t, env, "alice") + addDomain(t, c, "localhost") + link := createLink(t, c, map[string]any{ + "code": "headok", + "targetUrls": []string{"https://example.com/head"}, + "domainIds": []int64{localhostDomainID(t, c)}, + }) + req, err := http.NewRequest(http.MethodHead, env.Server.URL+"/headok", nil) + if err != nil { + t.Fatal(err) + } + req.Host = "localhost" + resp, err := noFollowClient(env).Do(req) + if err != nil { + t.Fatal(err) + } + _ = resp.Body.Close() + assertStatus(t, resp, http.StatusFound) + if loc := resp.Header.Get("Location"); loc != "https://example.com/head" { + t.Fatalf("HEAD Location = %q", loc) + } + if cc := resp.Header.Get("Cache-Control"); cc != "no-store" { + t.Fatalf("HEAD 302 Cache-Control = %q, want no-store", cc) + } + if got := linkStats(t, c, link.ID)["visits"].(float64); got != 0 { + t.Fatalf("HEAD 不应计入访问量,link.visits = %v", got) + } } // TestSameCodeAcrossDomains 同一短码在不同域名下指向不同目标。 diff --git a/internal/httpapi/redirect.go b/internal/httpapi/redirect.go index 0700de2..a2f55ed 100644 --- a/internal/httpapi/redirect.go +++ b/internal/httpapi/redirect.go @@ -1,6 +1,7 @@ package httpapi -// 05 — 跳转路由:GET /{code},由 Host 决定域名;命中 → 记 Visit → 302/301(Location=轮询目标); +// 05 — 跳转路由:GET|HEAD /{code},由 Host 决定域名;命中 → 记 Visit → 302/301(Location=轮询目标; +// 缓存语义见 redirectToTarget); // 16 — 落地页型:记 Visit → 固定 302 → landingUrl 或 /{code}/。 // 未命中(域名不解析/短码不存在)→ 404 且不记;命中但不可用(停用/逻辑删除/无目标/落地页文件缺失) // → 404 并记一行 outcome=failed 的明细(可归属到该短链的失败不丢)。 @@ -14,7 +15,8 @@ package httpapi // 三条热路径上的硬约束: // 1. 零 DB 查询:规则集合来自按租户缓存的内存快照(Cache.Get 只读一次 map)。 // 多数租户没有规则,此时连访客画像都不构造。 -// 2. 零写放大:命中不 UPDATE 任何表,只多写本次访问那一行明细。 +// 2. 零写放大:命中不 UPDATE 任何表,只多写本次访问那一行明细(经异步队列批量落库, +// 不占用请求路径,见 visit_queue.go)。 // 「24h 命中」是列表接口从 visits 读时聚合出来的(spec D9)。 // 3. fail-open:快照加载失败/求值 panic 一律按"未命中"继续(spec 风险章节), // 风控规则不该把线上短链打成 500。 @@ -313,11 +315,19 @@ func (a *API) handleRedirect(c *gin.Context) { Action: action, Outcome: store.VisitOutcomeSuccess, TargetURL: landingDest, RuleID: ruleID, RuleAction: ruleAction, }) - c.Redirect(http.StatusFound, landingDest) + redirectTemporary(c, landingDest) return } - // 跳转型:先选目标(无目标即失败,落一行明细) - targetURL, err := a.store.PickTarget(c.Request.Context(), link.ID) + // 跳转型:先选目标(无目标即失败,落一行明细)。 + // 目标池复用 LookupLinkForVisit 已读到的 link.TargetURLs,不再查第二遍 link_targets。 + // HEAD 只是探测:返回池中第一个目标,不推进轮询指针(多目标本就是 302 + no-store, + // Location 具体指向哪一个对探测方没有意义)。 + var targetURL string + if c.Request.Method == http.MethodHead && len(link.TargetURLs) > 0 { + targetURL = link.TargetURLs[0] + } else { + targetURL, err = a.store.PickTargetFrom(c.Request.Context(), link.ID, link.TargetURLs) + } if err != nil { // 防御性分支:上面已按 len(TargetURLs)==0 判过一次,这里兜住并发改动 a.recordVisit(c, store.VisitRecord{ @@ -336,13 +346,36 @@ func (a *API) handleRedirect(c *gin.Context) { a.redirectToTarget(c, link, targetURL) } -// redirectToTarget 按短链配置的 301/302 重定向到目标(默认临时 302)。 +// redirectToTarget 按短链配置的 301/302 重定向到目标(默认临时 302),并给出明确的缓存语义。 +// +// 301 在浏览器里默认可被**无限期**缓存:一旦缓存,租户改目标、停用短链、加规则, +// 对已访问过的访客全都不再生效 —— 浏览器根本不会再来问服务端,访问明细也随之漏记。 +// 所以: +// - 只有"单目标 + 配置为 301"的短链才发 301,且带有界的 Cache-Control +// (private, max-age=JANUS_REDIRECT_301_MAX_AGE;配成 0 则 no-store)。 +// private 防止共享缓存(CDN / 公司代理)把一个访客的跳转发给所有人。 +// - 短链开启了规则时,301 改为 no-store:规则按访客画像裁决,结果因人而异, +// 缓存任何一次的结果都等于让这位访客此后绕过规则求值。仍保留 301 状态码(SEO 语义不变)。 +// - 多目标轮询的短链一律 302 + no-store:每次访问都该重新轮询, +// 缓存的 301 会把访客永久钉在第一次命中的目标上,轮询失去意义。 +// - 其余 302 同样带 no-store,避免中间缓存按启发式规则缓存跳转。 func (a *API) redirectToTarget(c *gin.Context, link *store.Link, targetURL string) { - status := http.StatusFound // 302 - if link.RedirectStatus == store.RedirectStatus301 { - status = http.StatusMovedPermanently + if link.RedirectStatus != store.RedirectStatus301 || len(link.TargetURLs) > 1 { + redirectTemporary(c, targetURL) + return + } + if maxAge := a.cfg.Redirect301MaxAge; maxAge > 0 && !link.RulesEnabled { + c.Header("Cache-Control", "private, max-age="+strconv.Itoa(int(maxAge/time.Second))) + } else { + c.Header("Cache-Control", "no-store") } - c.Redirect(status, targetURL) + c.Redirect(http.StatusMovedPermanently, targetURL) +} + +// redirectTemporary 302 且禁止缓存(规则改写、轮询、落地页等"每次都要重新决定"的跳转)。 +func redirectTemporary(c *gin.Context, targetURL string) { + c.Header("Cache-Control", "no-store") + c.Redirect(http.StatusFound, targetURL) } // ruleDecision 对本次访问求值该租户的规则快照(spec D4)。 @@ -447,7 +480,9 @@ func (a *API) applyRuleDecision(c *gin.Context, link *store.Link, d *store.Domai Outcome: store.VisitOutcomeSuccess, TargetURL: dec.Destination, RuleID: ruleID, RuleAction: ruleAction, }) - a.redirectToTarget(c, link, dec.Destination) + // 规则改写一律 302 + no-store,不沿用短链自身的 301:裁决因访客画像而异、 + // 规则随时可改,缓存住任何一次改写结果都会让该访客此后绕过规则求值。 + redirectTemporary(c, dec.Destination) return true } return false diff --git a/internal/httpapi/rules_redirect_test.go b/internal/httpapi/rules_redirect_test.go index 928c258..ed1b1d3 100644 --- a/internal/httpapi/rules_redirect_test.go +++ b/internal/httpapi/rules_redirect_test.go @@ -89,15 +89,19 @@ func TestRuleRedirectRewritesTarget(t *testing.T) { t.Fatalf("link.visits = %v, want 1", got) } - // 301 型短链:规则改写同样走 301 + // 301 型短链:规则改写**不**沿用 301,一律 302 + no-store —— + // 裁决因访客而异、规则随时可改,浏览器缓存住一次改写结果就等于让该访客此后绕过规则。 resp = c.patch("/api/links/"+strconv.FormatInt(link.ID, 10), map[string]any{"redirectStatus": 301}) assertStatus(t, resp, http.StatusOK) _ = resp.Body.Close() resp = redirectGet(t, env, "localhost", "/"+link.Code) - assertStatus(t, resp, http.StatusMovedPermanently) + assertStatus(t, resp, http.StatusFound) if loc := resp.Header.Get("Location"); loc != "https://campaign.example.com/promo" { - t.Fatalf("301 Location = %q", loc) + t.Fatalf("规则改写 Location = %q", loc) + } + if cc := resp.Header.Get("Cache-Control"); cc != "no-store" { + t.Fatalf("规则改写 Cache-Control = %q, want no-store", cc) } } diff --git a/internal/httpapi/server.go b/internal/httpapi/server.go index 1ea947b..153aa1a 100644 --- a/internal/httpapi/server.go +++ b/internal/httpapi/server.go @@ -46,6 +46,10 @@ type Deps struct { DomainOwnership OwnershipChecker // ProtectedRoutes 外部注入的受保护控制面路由注入回调 ProtectedRoutes []func(rg *gin.RouterGroup) + // VisitQueue 访问明细异步写入队列(见 visit_queue.go)。 + // nil 时访问明细在请求内同步落库:黑盒测试依赖"请求返回即可查到明细"。 + // 生产(cmd/janus、pkg/janus)总是传入,并负责在 http.Server.Shutdown 之后 Close 它。 + VisitQueue *VisitQueue } // OwnershipChecker 抽象域名归属校验(见 Deps.DomainOwnership)。 @@ -74,6 +78,7 @@ type API struct { jwtMgr *jwt.Manager // Bearer JWT 校验(authenticate 中间件使用) ruleCache *rules.Cache // 规则快照(跳转热路径求值;nil 时求值恒为"无规则") geo geo.Lookup // IP → 国家码(跳转热路径在构造 Fact 之前查,ADR 0009) + visitQueue *VisitQueue // 访问明细异步队列(nil = 同步落库,见 recordVisit) } // New 构建 Gin 引擎:全局中间件(panic 恢复+访问日志、后台域名 SPA 分流)+ 全部路由。 @@ -141,6 +146,7 @@ func New(d Deps) http.Handler { jwtMgr: jwtMgr, ruleCache: ruleCache, geo: geoLookup, + visitQueue: d.VisitQueue, } if a.dns == nil { a.dns = &domain.DNSChecker{ExpectedIP: d.Cfg.ServerPublicIP} @@ -236,6 +242,11 @@ func New(d Deps) http.Handler { // 点击回传还要额外做一次地理解析,无节制的脚本刷量会同时撑大 visits 表 // 与吃掉 CPU。阈值按"CGNAT/公司出口下正常用户感知不到"来定。 r.GET("/:code", a.visitorGuard(), a.handleRedirect) + // HEAD 与 GET 同响应(状态码 / Location / 缓存头):链接预览器、监控探测、 + // curl -I 都用 HEAD 判断短链是否可用。原先 HEAD 落进 NoRoute 被当成"短码/子路径" + // 解析失败,一律 404 —— 健康的短链在这些工具眼里是坏链。 + // HEAD 不记明细、不推进轮询指针(见 recordVisit / handleRedirect)。 + r.HEAD("/:code", a.visitorGuard(), a.handleRedirect) // 16:落地页型短链二级路径(点击端点/每短链 SDK/上传落地页静态服务)。 // gin 路由树不支持 /:code 与 /:code/... 子路由并存,统一由 NoRoute 兜底分发; // 关闭尾斜杠重定向,避免 gin 把 /{code}/ 重定向回 /{code} 造成环。 diff --git a/internal/httpapi/visit_queue.go b/internal/httpapi/visit_queue.go new file mode 100644 index 0000000..e1eb404 --- /dev/null +++ b/internal/httpapi/visit_queue.go @@ -0,0 +1,288 @@ +package httpapi + +// 访问明细异步写入队列。 +// +// 为什么要把 InsertVisit 挪出请求路径: +// +// 1. 延迟叠加。原先每次跳转在写完 Location 之前同步 INSERT 一行明细, +// 这一次往返(以及连接池排队)完整地叠加到访客的跳转延迟上,而访客根本不关心统计。 +// 2. 连接池放大。突发流量下每个跳转请求都要占一条连接去写明细, +// 明细写入与"查短链"抢同一个连接池,池满后查短链也开始排队 —— 统计把跳转拖慢了。 +// 3. 客户端断开即丢数据。INSERT 用的是请求 ctx,访客一关页面(或爬虫拿到 302 就断开) +// ctx 被 net/http 取消,INSERT 随之失败,明细静默丢失。 +// +// 现在:请求路径只做一次非阻塞入队(纳秒级);少量 worker 把队列里的明细攒成批, +// 用一条多行 INSERT 落库,ctx 与请求解耦(context.WithoutCancel + 独立超时)。 +// +// 背压策略是**丢弃而不是阻塞**:队列满说明数据库已经跟不上,此时阻塞只会把 +// 数据库的慢传导成跳转的慢(恰恰是本队列要消除的东西)。丢弃会计数并限频打日志, +// 运维能从日志/计数里看到"统计在丢",而短链本身始终可用。 +// +// 后置访问钩子(PostVisitHook)在明细**落库尝试之后**触发,保持钩子"访问日志持久化 +// 完成后的异步回调"的契约:钩子里回查 visits 能查到这一行(落库失败时与改造前一致, +// 钩子照常触发,不因统计故障丢掉下游通知)。被丢弃的明细不触发钩子 —— 队列满就是过载, +// 再为它起 goroutine 跑钩子只会加剧过载;丢弃计数是这类损失唯一的留痕。 +// +// 关闭:Close 停止接收新明细,等 worker 把队列里剩余的明细全部落库(受 ctx 约束)后返回。 +// 必须在 http.Server.Shutdown 之后调用 —— 那时已没有进行中的请求会再入队。 + +import ( + "context" + "errors" + "log/slog" + "net/http" + "sync" + "sync/atomic" + "time" + + "janus/internal/store" +) + +// 队列默认参数(VisitQueueConfig 对应字段 <=0 时生效)。 +const ( + DefaultVisitQueueSize = 10000 + DefaultVisitQueueWorkers = 2 + DefaultVisitQueueBatch = 200 + // DefaultVisitInsertTimeout 单批 INSERT 的超时。与请求解耦后必须有自己的上限, + // 否则数据库卡死时 worker 永远挂着,Close 也永远等不到。 + DefaultVisitInsertTimeout = 5 * time.Second +) + +// 入队失败的两种原因。 +var ( + // ErrVisitQueueFull 队列已满,本条明细被丢弃(已计数)。 + ErrVisitQueueFull = errors.New("visit queue full") + // ErrVisitQueueClosed 队列已关闭(进程正在退出)。调用方可退回同步写入。 + ErrVisitQueueClosed = errors.New("visit queue closed") +) + +// VisitQueueConfig 访问明细队列参数;零值字段取 Default* 常量。 +type VisitQueueConfig struct { + Size int // 队列容量(条) + Workers int // 落库 worker 数 + BatchSize int // 单批最大行数 + InsertTimeout time.Duration // 单批 INSERT 超时 +} + +func (c VisitQueueConfig) withDefaults() VisitQueueConfig { + if c.Size <= 0 { + c.Size = DefaultVisitQueueSize + } + if c.Workers <= 0 { + c.Workers = DefaultVisitQueueWorkers + } + if c.BatchSize <= 0 { + c.BatchSize = DefaultVisitQueueBatch + } + if c.InsertTimeout <= 0 { + c.InsertTimeout = DefaultVisitInsertTimeout + } + return c +} + +// visitJob 队列中的一条待落库明细,连同触发后置钩子所需的请求上下文。 +// ctx 已经过 context.WithoutCancel:保留请求里的值,但不随请求结束而取消。 +type visitJob struct { + ctx context.Context + r *http.Request + rec store.VisitRecord +} + +// VisitQueue 有界的访问明细异步写入队列(见文件头注释)。并发安全。 +type VisitQueue struct { + cfg VisitQueueConfig + ch chan visitJob + // insertBatch 批量落库;insertOne 批量失败后逐行重试(隔离单行坏数据,不让它拖垮整批)。 + insertBatch func(ctx context.Context, recs []store.VisitRecord) error + insertOne func(ctx context.Context, rec store.VisitRecord) error + // afterInsert 落库尝试之后对每条明细调用(生产为触发后置访问钩子)。 + afterInsert func(job visitJob) + log *slog.Logger + + // mu 保护 closed 与 ch 的关闭:Enqueue 持读锁做非阻塞发送,Close 持写锁关 channel, + // 从而不会出现"向已关闭的 channel 发送"的 panic。 + mu sync.RWMutex + closed bool + closeOnce sync.Once + wg sync.WaitGroup + + dropped atomic.Uint64 + inserted atomic.Uint64 + failed atomic.Uint64 +} + +// NewVisitQueue 构建并启动生产用的访问明细队列(落库走 st,落库后触发后置访问钩子)。 +func NewVisitQueue(st *store.Store, cfg VisitQueueConfig) *VisitQueue { + return newVisitQueue(cfg, st.InsertVisits, st.InsertVisit, func(job visitJob) { + TriggerPostVisitHooks(job.ctx, job.r, job.rec) + }) +} + +// newVisitQueue 可注入落库函数的构造(单测不依赖 Postgres)。 +func newVisitQueue( + cfg VisitQueueConfig, + insertBatch func(ctx context.Context, recs []store.VisitRecord) error, + insertOne func(ctx context.Context, rec store.VisitRecord) error, + afterInsert func(job visitJob), +) *VisitQueue { + cfg = cfg.withDefaults() + q := &VisitQueue{ + cfg: cfg, + ch: make(chan visitJob, cfg.Size), + insertBatch: insertBatch, + insertOne: insertOne, + afterInsert: afterInsert, + log: slog.Default(), + } + q.wg.Add(cfg.Workers) + for i := 0; i < cfg.Workers; i++ { + go q.worker() + } + return q +} + +// Enqueue 非阻塞入队一条明细。队列满返回 ErrVisitQueueFull(已计入丢弃数), +// 已关闭返回 ErrVisitQueueClosed。ctx 会被 context.WithoutCancel 处理后随明细保存。 +func (q *VisitQueue) Enqueue(ctx context.Context, r *http.Request, rec store.VisitRecord) error { + job := visitJob{ctx: context.WithoutCancel(ctx), r: r, rec: rec} + q.mu.RLock() + defer q.mu.RUnlock() + if q.closed { + return ErrVisitQueueClosed + } + select { + case q.ch <- job: + return nil + default: + n := q.dropped.Add(1) + // 限频:首次丢弃与此后每 1000 次打一条,避免过载时日志本身成为新的瓶颈。 + if n == 1 || n%1000 == 0 { + q.log.Warn("访问明细队列已满,丢弃明细(跳转不受影响)", + "dropped_total", n, "capacity", q.cfg.Size, "link", rec.LinkID) + } + return ErrVisitQueueFull + } +} + +// Dropped 因队列满而丢弃的明细累计条数。 +func (q *VisitQueue) Dropped() uint64 { return q.dropped.Load() } + +// Inserted 成功落库的明细累计条数。 +func (q *VisitQueue) Inserted() uint64 { return q.inserted.Load() } + +// Failed 落库失败(批量与逐行重试都失败)的明细累计条数。 +func (q *VisitQueue) Failed() uint64 { return q.failed.Load() } + +// Close 停止接收新明细并等待队列排空。可重复调用(之后的调用只等待)。 +// ctx 到期时立即返回 ctx.Err(),worker 仍会在后台把剩余明细写完或超时放弃。 +func (q *VisitQueue) Close(ctx context.Context) error { + q.closeOnce.Do(func() { + q.mu.Lock() + q.closed = true + close(q.ch) + q.mu.Unlock() + }) + done := make(chan struct{}) + go func() { + q.wg.Wait() + close(done) + }() + select { + case <-done: + return nil + case <-ctx.Done(): + q.log.Error("访问明细队列关闭超时,剩余明细可能丢失", "pending", len(q.ch)) + return ctx.Err() + } +} + +// worker 阻塞取第一条,再非阻塞地把已在队列里的明细捞满一批后落库。 +// +// 不设"攒够 N 条或等 T 毫秒"的定时器:低峰期每条明细立刻落库(不引入统计延迟), +// 高峰期队列里自然堆着多条,一次就能捞满一批 —— 批量大小随负载自适应。 +func (q *VisitQueue) worker() { + defer q.wg.Done() + batch := make([]visitJob, 0, q.cfg.BatchSize) + for job := range q.ch { + batch = append(batch[:0], job) + fill: + for len(batch) < q.cfg.BatchSize { + select { + case next, ok := <-q.ch: + if !ok { + break fill + } + batch = append(batch, next) + default: + break fill + } + } + q.flush(batch) + } +} + +// flush 落库一批明细,随后对每条触发 afterInsert。 +// 整批失败时逐行重试:一条坏数据(例如超长字段)不该连累同批的其他访客。 +func (q *VisitQueue) flush(batch []visitJob) { + recs := make([]store.VisitRecord, len(batch)) + for i, j := range batch { + recs[i] = j.rec + } + ctx, cancel := context.WithTimeout(context.Background(), q.cfg.InsertTimeout) + err := q.safeInsertBatch(ctx, recs) + cancel() + if err == nil { + q.inserted.Add(uint64(len(recs))) + } else { + q.log.Error("访问明细批量写入失败,改为逐行重试", "rows", len(recs), "err", err) + for _, rec := range recs { + ctx, cancel := context.WithTimeout(context.Background(), q.cfg.InsertTimeout) + if err := q.safeInsertOne(ctx, rec); err != nil { + q.failed.Add(1) + q.log.Error("访问明细写入失败,已丢弃", "link", rec.LinkID, "err", err) + } else { + q.inserted.Add(1) + } + cancel() + } + } + if q.afterInsert != nil { + for _, j := range batch { + q.safeAfter(j) + } + } +} + +// safeInsertBatch / safeInsertOne / safeAfter 兜住 panic:worker 跑在请求链之外, +// 一次 panic 会带走整个进程(连带所有正在跳转的访客)。 +func (q *VisitQueue) safeInsertBatch(ctx context.Context, recs []store.VisitRecord) (err error) { + defer func() { + if r := recover(); r != nil { + err = errors.New("insert batch panic") + q.log.Error("访问明细批量写入 panic", "panic", r) + } + }() + return q.insertBatch(ctx, recs) +} + +func (q *VisitQueue) safeInsertOne(ctx context.Context, rec store.VisitRecord) (err error) { + defer func() { + if r := recover(); r != nil { + err = errors.New("insert panic") + q.log.Error("访问明细写入 panic", "panic", r) + } + }() + if q.insertOne == nil { + return q.insertBatch(ctx, []store.VisitRecord{rec}) + } + return q.insertOne(ctx, rec) +} + +func (q *VisitQueue) safeAfter(j visitJob) { + defer func() { + if r := recover(); r != nil { + q.log.Error("访问明细落库后回调 panic,已忽略", "panic", r) + } + }() + q.afterInsert(j) +} diff --git a/internal/httpapi/visit_queue_test.go b/internal/httpapi/visit_queue_test.go new file mode 100644 index 0000000..ba66812 --- /dev/null +++ b/internal/httpapi/visit_queue_test.go @@ -0,0 +1,222 @@ +package httpapi + +// 访问明细异步队列的单测:不依赖 Postgres,落库函数用内存替身注入。 + +import ( + "context" + "errors" + "sync" + "sync/atomic" + "testing" + "time" + + "janus/internal/store" +) + +// fakeVisitSink 记录每次批量/逐行落库调用;block 非 nil 时落库阻塞到它被关闭。 +type fakeVisitSink struct { + mu sync.Mutex + batches [][]store.VisitRecord + singles []store.VisitRecord + block chan struct{} + failBatch atomic.Bool +} + +func (f *fakeVisitSink) insertBatch(ctx context.Context, recs []store.VisitRecord) error { + if f.block != nil { + select { + case <-f.block: + case <-ctx.Done(): + return ctx.Err() + } + } + if f.failBatch.Load() { + return errors.New("batch failed") + } + cp := append([]store.VisitRecord(nil), recs...) + f.mu.Lock() + f.batches = append(f.batches, cp) + f.mu.Unlock() + return nil +} + +func (f *fakeVisitSink) insertOne(_ context.Context, rec store.VisitRecord) error { + if rec.LinkID < 0 { + return errors.New("bad row") + } + f.mu.Lock() + f.singles = append(f.singles, rec) + f.mu.Unlock() + return nil +} + +func (f *fakeVisitSink) total() int { + f.mu.Lock() + defer f.mu.Unlock() + n := len(f.singles) + for _, b := range f.batches { + n += len(b) + } + return n +} + +func closeQueue(t *testing.T, q *VisitQueue) { + t.Helper() + ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) + defer cancel() + if err := q.Close(ctx); err != nil { + t.Fatalf("Close: %v", err) + } +} + +// TestVisitQueueBatches 积压的明细被攒成批落库,且单批不超过 BatchSize。 +func TestVisitQueueBatches(t *testing.T) { + sink := &fakeVisitSink{block: make(chan struct{})} + q := newVisitQueue(VisitQueueConfig{Size: 100, Workers: 1, BatchSize: 10}, + sink.insertBatch, sink.insertOne, nil) + // worker 取到第 1 条后卡在落库上,其余 25 条在队列里积压 + for i := 0; i < 26; i++ { + if err := q.Enqueue(context.Background(), nil, store.VisitRecord{LinkID: int64(i)}); err != nil { + t.Fatalf("Enqueue %d: %v", i, err) + } + } + close(sink.block) + closeQueue(t, q) + + if got := sink.total(); got != 26 { + t.Fatalf("落库总数 = %d, want 26", got) + } + sink.mu.Lock() + defer sink.mu.Unlock() + if len(sink.batches) >= 26 { + t.Fatalf("批次数 = %d,积压的明细没有被攒批", len(sink.batches)) + } + for i, b := range sink.batches { + if len(b) > 10 { + t.Fatalf("第 %d 批 %d 行,超过 BatchSize=10", i, len(b)) + } + } + if q.Inserted() != 26 || q.Dropped() != 0 || q.Failed() != 0 { + t.Fatalf("计数 inserted/dropped/failed = %d/%d/%d", q.Inserted(), q.Dropped(), q.Failed()) + } +} + +// TestVisitQueueDropsWhenFull 队列满时立即返回 ErrVisitQueueFull 并计数,绝不阻塞调用方。 +func TestVisitQueueDropsWhenFull(t *testing.T) { + sink := &fakeVisitSink{block: make(chan struct{})} + q := newVisitQueue(VisitQueueConfig{Size: 2, Workers: 1, BatchSize: 1}, + sink.insertBatch, sink.insertOne, nil) + + // 第 1 条被 worker 取走并卡住;等它离开 channel 再填满容量,保证计数确定 + if err := q.Enqueue(context.Background(), nil, store.VisitRecord{LinkID: 1}); err != nil { + t.Fatal(err) + } + deadline := time.Now().Add(2 * time.Second) + for len(q.ch) != 0 { + if time.Now().After(deadline) { + t.Fatal("worker 未取走第一条明细") + } + time.Sleep(time.Millisecond) + } + for i := 2; i <= 3; i++ { + if err := q.Enqueue(context.Background(), nil, store.VisitRecord{LinkID: int64(i)}); err != nil { + t.Fatalf("Enqueue %d: %v", i, err) + } + } + + start := time.Now() + var fullErrs int + for i := 0; i < 5; i++ { + if err := q.Enqueue(context.Background(), nil, store.VisitRecord{LinkID: 100}); errors.Is(err, ErrVisitQueueFull) { + fullErrs++ + } + } + if elapsed := time.Since(start); elapsed > 100*time.Millisecond { + t.Fatalf("队列满时 Enqueue 阻塞了 %v", elapsed) + } + if fullErrs != 5 || q.Dropped() != 5 { + t.Fatalf("满队列返回 Full %d 次 / Dropped=%d, want 5/5", fullErrs, q.Dropped()) + } + + close(sink.block) + closeQueue(t, q) + if got := sink.total(); got != 3 { + t.Fatalf("落库总数 = %d, want 3(被丢弃的不落库)", got) + } +} + +// TestVisitQueueDrainsOnClose Close 等队列里的全部明细落库(并触发回调)后才返回; +// 关闭后入队返回 ErrVisitQueueClosed,重复 Close 不 panic。 +func TestVisitQueueDrainsOnClose(t *testing.T) { + sink := &fakeVisitSink{} + var after atomic.Int64 + q := newVisitQueue(VisitQueueConfig{Size: 1000, Workers: 3, BatchSize: 7}, + func(ctx context.Context, recs []store.VisitRecord) error { + time.Sleep(time.Millisecond) // 模拟落库耗时,让 Close 时队列里确有积压 + return sink.insertBatch(ctx, recs) + }, sink.insertOne, func(visitJob) { after.Add(1) }) + + for i := 0; i < 500; i++ { + if err := q.Enqueue(context.Background(), nil, store.VisitRecord{LinkID: int64(i)}); err != nil { + t.Fatalf("Enqueue %d: %v", i, err) + } + } + closeQueue(t, q) + + if got := sink.total(); got != 500 { + t.Fatalf("Close 返回时落库 %d 条, want 500", got) + } + if got := after.Load(); got != 500 { + t.Fatalf("落库后回调 %d 次, want 500", got) + } + if err := q.Enqueue(context.Background(), nil, store.VisitRecord{}); !errors.Is(err, ErrVisitQueueClosed) { + t.Fatalf("关闭后 Enqueue = %v, want ErrVisitQueueClosed", err) + } + closeQueue(t, q) // 幂等 +} + +// TestVisitQueueRetriesRowsOnBatchFailure 整批失败后逐行重试,坏行只丢它自己。 +func TestVisitQueueRetriesRowsOnBatchFailure(t *testing.T) { + sink := &fakeVisitSink{} + sink.failBatch.Store(true) + sink.block = make(chan struct{}) + q := newVisitQueue(VisitQueueConfig{Size: 10, Workers: 1, BatchSize: 10}, + sink.insertBatch, sink.insertOne, nil) + for _, id := range []int64{1, -1, 2} { + if err := q.Enqueue(context.Background(), nil, store.VisitRecord{LinkID: id}); err != nil { + t.Fatal(err) + } + } + close(sink.block) + closeQueue(t, q) + if q.Inserted() != 2 || q.Failed() != 1 { + t.Fatalf("inserted/failed = %d/%d, want 2/1", q.Inserted(), q.Failed()) + } +} + +// TestVisitQueueDetachesRequestCancel 请求 ctx 被取消(访客断开)不影响落库; +// 落库用的是队列自己的超时 ctx。 +func TestVisitQueueDetachesRequestCancel(t *testing.T) { + var gotErr atomic.Value + done := make(chan struct{}) + q := newVisitQueue(VisitQueueConfig{Size: 1, Workers: 1, BatchSize: 1}, + func(ctx context.Context, _ []store.VisitRecord) error { + gotErr.Store(ctx.Err() == nil) + close(done) + return nil + }, nil, func(j visitJob) { + if j.ctx.Err() != nil { + t.Errorf("回调拿到的 ctx 已被取消: %v", j.ctx.Err()) + } + }) + reqCtx, cancel := context.WithCancel(context.Background()) + cancel() // 访客已断开 + if err := q.Enqueue(reqCtx, nil, store.VisitRecord{LinkID: 1}); err != nil { + t.Fatal(err) + } + <-done + closeQueue(t, q) + if ok, _ := gotErr.Load().(bool); !ok { + t.Fatal("落库 ctx 不应继承请求的取消") + } +} diff --git a/internal/httpapi/visits.go b/internal/httpapi/visits.go index 454f79a..09d18bf 100644 --- a/internal/httpapi/visits.go +++ b/internal/httpapi/visits.go @@ -8,6 +8,8 @@ package httpapi // 读:GET /api/visits/overview —— 总览页的一次性聚合端点(见 handleVisitsOverview)。 import ( + "context" + "errors" "net/http" "strings" @@ -80,16 +82,40 @@ const maxLangLen = 64 // recordVisit 记录一次访问/点击明细(IP、UA、来源页、语言、国家由请求补齐)。 // 统计失败只吞掉错误:短链是否跳转是访问者的事,不能被写入失败牵连。 // +// 落库方式: +// - 配了访问明细队列(生产,见 Deps.VisitQueue):非阻塞入队,由队列 worker 批量落库, +// 落库之后再触发后置访问钩子。队列满时丢弃(计数 + 限频日志),绝不阻塞跳转。 +// - 未配队列(黑盒测试 / 直接调用 New 的嵌入方),或队列已关闭(进程退出途中): +// 退回同步写入,保证"请求返回时明细已落库",测试可以紧接着断言明细。 +// +// 两条路径都与请求 ctx 的取消解耦:访客拿到 302 就断开连接是常态, +// 原先这会取消进行中的 INSERT,明细静默丢失。 +// +// HEAD 请求不记明细:HEAD 是链接预览器/健康探测/爬虫在"看一眼", +// 不是一次访问;计进去会虚增访问量,也会让轮询指针被探测流量推着走。 +// // asn / is_datacenter 不在这里填:当前没有数据源(ADR 0009),写进去的只会是空值与 false, // 与数据库默认值一样,反而像是"查到了但没值"。真要支持这两个值时,得先在 // store.VisitRecord 里加字段并在这里一并填。 func (a *API) recordVisit(c *gin.Context, rec store.VisitRecord) { + if c.Request.Method == http.MethodHead { + return + } rec.IP = a.clientIPForVisitor(c.Request) rec.UserAgent = c.Request.UserAgent() rec.Referer = c.Request.Referer() rec.Lang = clientLang(c.Request) rec.Country = a.visitGeo(c).Country - _ = a.store.InsertVisit(c.Request.Context(), rec) + if a.visitQueue != nil { + err := a.visitQueue.Enqueue(c.Request.Context(), c.Request, rec) + if !errors.Is(err, ErrVisitQueueClosed) { + // 入队成功:钩子由队列在落库后触发;队列满:已计数丢弃,不触发钩子。 + return + } + } + ctx, cancel := context.WithTimeout(context.WithoutCancel(c.Request.Context()), DefaultVisitInsertTimeout) + _ = a.store.InsertVisit(ctx, rec) + cancel() TriggerPostVisitHooks(c.Request.Context(), c.Request, rec) } diff --git a/internal/store/links.go b/internal/store/links.go index 7a9af74..64c4517 100644 --- a/internal/store/links.go +++ b/internal/store/links.go @@ -801,6 +801,16 @@ func (s *Store) PickTarget(ctx context.Context, linkID int64) (string, error) { if err != nil { return "", err } + return s.PickTargetFrom(ctx, linkID, targets) +} + +// PickTargetFrom 与 PickTarget 同语义,但目标池由调用方传入(不再查 link_targets)。 +// +// 跳转热路径上 LookupLinkForVisit 已经把目标池读进了 link.TargetURLs, +// 再走 PickTarget 等于同一次访问把同一张表查两遍。用本次请求已读到的那份快照选目标, +// 结果与"同一请求内先读后选"完全一致;并发改目标池时,本次访问用的是它命中短链那一刻的池, +// 这正是一次访问应有的语义。 +func (s *Store) PickTargetFrom(ctx context.Context, linkID int64, targets []string) (string, error) { if len(targets) == 0 { return "", ErrNotFound } diff --git a/internal/store/visits.go b/internal/store/visits.go index 072287c..686147d 100644 --- a/internal/store/visits.go +++ b/internal/store/visits.go @@ -132,10 +132,9 @@ type VisitRecord struct { RuleAction string } -// InsertVisit 记录一次访问/点击动作(含访问者 IP)。 -// 统计写入失败由调用方决定是否阻断跳转,本函数只返回 error。 -func (s *Store) InsertVisit(ctx context.Context, rec VisitRecord) error { - v := Visit{ +// toVisit VisitRecord → 入库行(InsertVisit 与 InsertVisits 共用,避免两份字段映射漂移)。 +func (rec VisitRecord) toVisit() Visit { + return Visit{ LinkID: rec.LinkID, DomainID: rec.DomainID, IP: rec.IP, UserAgent: rec.UserAgent, Referer: rec.Referer, Action: rec.Action, Outcome: rec.Outcome, Reason: rec.Reason, @@ -143,9 +142,31 @@ func (s *Store) InsertVisit(ctx context.Context, rec VisitRecord) error { Country: rec.Country, RuleID: rec.RuleID, RuleAction: rec.RuleAction, } +} + +// InsertVisit 记录一次访问/点击动作(含访问者 IP)。 +// 统计写入失败由调用方决定是否阻断跳转,本函数只返回 error。 +func (s *Store) InsertVisit(ctx context.Context, rec VisitRecord) error { + v := rec.toVisit() return s.db.WithContext(ctx).Create(&v).Error } +// InsertVisits 一条多行 INSERT 批量写入访问明细(访问明细异步队列的落库入口)。 +// +// 一批是一条语句、一次往返:跳转高峰时逐行 INSERT 的往返次数与连接占用 +// 才是瓶颈,而不是行数本身。整批要么全成要么全败(单语句天然原子), +// 失败后是否逐行重试由调用方决定(见 httpapi.VisitQueue)。 +func (s *Store) InsertVisits(ctx context.Context, recs []VisitRecord) error { + if len(recs) == 0 { + return nil + } + rows := make([]Visit, len(recs)) + for i, rec := range recs { + rows[i] = rec.toVisit() + } + return s.db.WithContext(ctx).Create(&rows).Error +} + // CountVisitsByLink 访问计数 = 成功的访问行(action IN ('redirect','landing_view') 且 outcome='success')。 // 两类行都不得灌水:click 是落地页按钮回传;outcome='failed' 是短链不可用导致的失败, // 租户看到"访问量"时应理解为真正被成功重定向出去的次数。 diff --git a/pkg/janus/janus.go b/pkg/janus/janus.go index 96023c6..c5fbed7 100644 --- a/pkg/janus/janus.go +++ b/pkg/janus/janus.go @@ -253,8 +253,11 @@ type App struct { workerDone chan struct{} cancelRun context.CancelFunc fallback atomic.Pointer[http.Handler] - mu sync.Mutex - running bool + // visitQueue 访问明细异步队列:每次组装完整业务路由(fullHandler)时创建, + // Shutdown 在 HTTP 停止后排空;Run 退出关闭自有数据库连接前也会再排空一次。受 mu 保护。 + visitQueue *httpapi.VisitQueue + mu sync.Mutex + running bool } // New 基于给定的选项构建并校验 App 实例 @@ -395,11 +398,23 @@ func (a *App) fullHandler() http.Handler { SMTP: smtpCfg, }, io.Discard) + // 每份完整业务路由配一条新的访问明细队列;替换下来的旧队列先排空再丢弃, + // 避免旧队列 worker 泄漏、已入队的明细丢失。 + q := httpapi.NewVisitQueue(a.store, httpapi.VisitQueueConfig{ + Size: a.cfg.VisitQueueSize, Workers: a.cfg.VisitQueueWorkers, BatchSize: a.cfg.VisitQueueBatch, + }) + a.mu.Lock() + old := a.visitQueue + a.visitQueue = q + a.mu.Unlock() + closeVisitQueue(context.Background(), old) + return httpapi.New(httpapi.Deps{ Store: a.store, Mailer: m, Cfg: a.cfg, ProtectedRoutes: a.protectedRouteInjects, + VisitQueue: q, }) } @@ -478,7 +493,7 @@ func (a *App) setupDB(ctx context.Context) (owned *gorm.DB, err error) { return nil, fmt.Errorf("migrate: %w", err) } - gdb, err := db.OpenGORM(a.cfg.DatabaseURL) + gdb, err := db.OpenGORMWithPool(a.cfg.DatabaseURL, a.cfg.DBMaxOpenConns) if err != nil { return nil, fmt.Errorf("open gorm: %w", err) } @@ -499,6 +514,16 @@ func (a *App) setupDB(ctx context.Context) (owned *gorm.DB, err error) { return gdb, nil } +// closeVisitQueue 排空并关闭访问明细队列(q 为 nil 时无操作;VisitQueue.Close 可重复调用)。 +func closeVisitQueue(ctx context.Context, q *httpapi.VisitQueue) { + if q == nil { + return + } + drainCtx, cancel := context.WithTimeout(ctx, 5*time.Second) + defer cancel() + _ = q.Close(drainCtx) +} + func closeGORM(gdb *gorm.DB) { if gdb == nil { return @@ -545,6 +570,11 @@ func (a *App) Run(ctx context.Context) error { case <-time.After(5 * time.Second): } } + // 关闭数据库前排空访问明细队列(Shutdown 通常已排空;监听失败等未经 Shutdown 的路径在此兜底) + a.mu.Lock() + q := a.visitQueue + a.mu.Unlock() + closeVisitQueue(context.Background(), q) a.mu.Lock() if owned != nil { closeGORM(owned) @@ -651,6 +681,13 @@ func (a *App) Shutdown(ctx context.Context) error { srvErr = srv.Shutdown(ctx) } + // HTTP 已停止接收请求,此后不会再有明细入队:排空访问明细队列。 + // 关闭后 recordVisit 退回同步写入(WithDB 注入的 Store 在再次 Run 时仍可用)。 + a.mu.Lock() + q := a.visitQueue + a.mu.Unlock() + closeVisitQueue(ctx, q) + if workerDone != nil { select { case <-workerDone: