feat(phase-B75): 计次上报加 source 维度(V188)——「谁在烧」一列读数,归因不再扫设备日志

- V188:biz_user_secret_usage_daily 加 source varchar(24) NOT NULL DEFAULT 'legacy'(存量行诚实落 legacy 不回填),唯一键 uk_user_module_date 扩成四元组(user/module/date/source),加列与建索引均 information_schema 判存可重跑(列按 V157 款、索引按 V184 款),八段式含验证 SQL 与人工回滚
This commit is contained in:
2026-11-04 02:56:50 +08:00
parent e71fa7fa83
commit 00f45cc20f
11 changed files with 340 additions and 41 deletions
@@ -46,9 +46,9 @@ public class InternalUserSecretUsageController {
return ApiResponse.fail("上报参数不完整");
}
boolean accepted = userSecretUsageService.recordReported(
body.getUserId(), body.getModule(), body.getCount());
log.info("[internal-usage] 计次上报 userId={} module={} count={} accepted={}",
body.getUserId(), body.getModule(), body.getCount(), accepted);
body.getUserId(), body.getModule(), body.getCount(), body.getSource());
log.info("[internal-usage] 计次上报 userId={} module={} count={} source={} accepted={}",
body.getUserId(), body.getModule(), body.getCount(), body.getSource(), accepted);
if (!accepted) {
return ApiResponse.fail("模块或参数非法,未记录");
}
@@ -13,27 +13,34 @@ import java.util.List;
public interface UserSecretUsageMapper extends BaseMapper<UserSecretUsageEntity> {
/**
* 按唯一键 uk_user_module_date 原子累加计次:命中则 call_count 自增,否则插入。
* 并发下无需应用层加锁(引擎层唯一键冲突转更新)。
* 按唯一键 uk_user_module_date_source(V188:user_id+module_key+business_date+source)
* 原子累加计次:命中则 call_count 自增,否则插入。并发下无需应用层加锁
* (引擎层唯一键冲突转更新)。source=上报方自报身份(client/brand16890/brand15126/
* pt_worker),Java 自产行=backend,缺省/非法=legacy——同一天多路各占一行,
* 读侧按模块聚合对多出的行透明。
*/
int increment(@Param("userId") Long userId,
@Param("moduleKey") String moduleKey,
@Param("businessDate") LocalDate businessDate,
@Param("count") int count);
@Param("count") int count,
@Param("source") String source);
/**
* 按唯一键 uk_user_module_date 累加 token 读数。
* 按唯一键 uk_user_module_date_source 累加 token 读数。
*
* <p>刻意与 {@link #increment} 分成两条:计次发生在**发请求之前**(口径含重试,请求没回来也要算一次),
* 而 token 只有响应回来才知道。合并成一条 upsert 就会把"已发出但超时"的那些请求从计次里漏掉。
* <p>这里是 UPDATE 而不是 upsert:行由前一条 increment 保证存在;真不存在就是 0 行受影响,
* token 读数丢掉也不该反过来影响计次。
* <p>WHERE 必须带 source(V188):唯一键扩成四元组后,同一 (user, module, date) 可能
* 有 legacy 与 backend 多行,不带 source 会把 token 记到历史行上造成双计。
*/
int addTokens(@Param("userId") Long userId,
@Param("moduleKey") String moduleKey,
@Param("businessDate") LocalDate businessDate,
@Param("promptTokens") long promptTokens,
@Param("completionTokens") long completionTokens);
@Param("completionTokens") long completionTokens,
@Param("source") String source);
/**
* 当日用量按用户 × 模块聚合(损耗扫描每分钟读一次)。
@@ -16,4 +16,8 @@ public class UserSecretUsageReportRequest {
@Schema(description = "本次新增调用次数(真实对外请求)", requiredMode = Schema.RequiredMode.REQUIRED)
private Integer count;
@Schema(description = "上报方来源(V188):client/brand16890/brand15126/pt_worker;"
+ "缺省或非法落 legacy 桶。旧上报方不带该字段,兼容。", requiredMode = Schema.RequiredMode.NOT_REQUIRED)
private String source;
}
@@ -9,7 +9,7 @@ import java.math.BigDecimal;
import java.time.LocalDate;
import java.time.LocalDateTime;
/** 用户密钥调用计次(按天聚合,一行 = 用户 × 模块 × 日期)。 */
/** 用户密钥调用计次(按天聚合,一行 = 用户 × 模块 × 日期 × 来源(V188))。 */
@Data
@TableName("biz_user_secret_usage_daily")
public class UserSecretUsageEntity {
@@ -18,6 +18,8 @@ public class UserSecretUsageEntity {
private Long id;
private Long userId;
private String moduleKey;
/** 计次来源(V188):client/brand16890/brand15126/pt_worker/backend;存量行=legacy。 */
private String source;
private LocalDate businessDate;
private Integer callCount;
/** 输入 token 累计(网关 usage.prompt_tokens)。0 = 该天没有 token 证据,不等于没消耗。 */
@@ -49,6 +49,11 @@ public class UserSecretUsageService {
public static final long PLATFORM_USER_ID = 0L;
static final String PLATFORM_USER_LABEL = "平台自费";
/** 计次来源(V188):Java 自产行(LLM record/recordTokens)落 backend。 */
static final String SOURCE_BACKEND = "backend";
/** 存量行与缺省/非法报文的落桶:历史行无法追溯是哪一路报的,不猜测。 */
public static final String SOURCE_LEGACY = "legacy";
private final UserSecretUsageMapper usageMapper;
private final AdminUserMapper adminUserMapper;
private final AdminAuthSupport adminAuthSupport;
@@ -68,11 +73,16 @@ public class UserSecretUsageService {
log.warn("[user-secret-usage] 忽略未知模块计次 userId={} module={}", userId, moduleKey);
return;
}
recordModule(userId, module, count, 0L, 0L);
recordModule(userId, module, count, 0L, 0L, SOURCE_BACKEND);
}
/** 内部通道上报入口:模块非法返回 false(供接口回执),写库失败只告警。 */
/** 内部通道上报入口(3 参旧形状):source 缺省落 legacy 桶。模块非法返回 false。 */
public boolean recordReported(Long userId, String moduleKey, int count) {
return recordReported(userId, moduleKey, count, null);
}
/** 内部通道上报入口(V188 带 source):模块非法返回 false,写库失败只告警。 */
public boolean recordReported(Long userId, String moduleKey, int count, String source) {
if (userId == null || userId < 0 || count <= 0) {
return false;
}
@@ -85,7 +95,8 @@ public class UserSecretUsageService {
log.warn("[user-secret-usage] 平台自费桶只收 proxy 计次 userId=0 module={}", moduleKey);
return false;
}
return recordModule(userId, module, Math.min(count, MAX_REPORT_COUNT), 0L, 0L);
return recordModule(userId, module, Math.min(count, MAX_REPORT_COUNT), 0L, 0L,
normalizeSource(source));
}
/**
@@ -106,18 +117,36 @@ public class UserSecretUsageService {
if (module == null) {
return;
}
recordModule(userId, module, 0, promptTokens, completionTokens);
recordModule(userId, module, 0, promptTokens, completionTokens, SOURCE_BACKEND);
}
/**
* source 规整(V188):小写、^[a-z0-9][a-z0-9_-]{0,23}$ 以外的一律落 legacy——
* 上报方是可信内部调用方,但字符串仍可能写错;落 legacy 而不是拒收,
* 计次比归因更贵(宁可归因模糊也不丢账)。
*/
static String normalizeSource(String raw) {
if (raw == null) {
return SOURCE_LEGACY;
}
String trimmed = raw.trim().toLowerCase();
if (trimmed.isEmpty() || trimmed.length() > 24
|| !trimmed.matches("[a-z0-9][a-z0-9_-]*")) {
return SOURCE_LEGACY;
}
return trimmed;
}
private boolean recordModule(Long userId, UserSecretModule module, int count,
long promptTokens, long completionTokens) {
long promptTokens, long completionTokens, String source) {
LocalDate today = LocalDate.now();
try {
if (count > 0) {
usageMapper.increment(userId, module.key(), today, count);
usageMapper.increment(userId, module.key(), today, count, source);
}
if (promptTokens > 0 || completionTokens > 0) {
usageMapper.addTokens(userId, module.key(), today, promptTokens, completionTokens);
usageMapper.addTokens(userId, module.key(), today, promptTokens, completionTokens,
source);
}
return true;
} catch (Exception ex) {
@@ -0,0 +1,83 @@
-- V188: 给 `biz_user_secret_usage_daily` 加 `source` 列,并把唯一键扩到四元组
-- =============================================================
-- 1. 变更目的:把「谁在烧」从猜测变成一列读数。四路上报方(客户端 90s flush/16890
-- 30s 批量/15126 60s 周期/pt_worker 逐次)此前都只报 {userId, module, count},
-- 同一用户同一天被多个面消费时在表里揉成一行,归因只能去扫 MinIO 设备日志与两台
-- 机器(2026-11-04 客户反馈「代理IP用的很猛」的归因实测就是这么做的)。加 source
-- 后一条 `GROUP BY source` 直接出账。
--
-- 2. 前提取证(2026-11-04 只读探针):该表 7 天 proxy 19,040 次/95 用户,行数
-- =用户×模块×天 量级,加列存储代价可忽略;现键 `uk_user_module_date(user_id,
-- module_key, business_date)`(V117)是 increment 的 ON DUPLICATE KEY 幂等键。
--
-- 3. 形状与数据:`source varchar(24) NOT NULL DEFAULT 'legacy'`——存量行统一落
-- 'legacy'(历史行无法追溯是哪一路报的,不猜测);新行由四路上报方自报
-- (client/brand16890/brand15126/pt_worker),Java 自产 LLM 行=backend,缺省/非法
-- 报文=legacy。唯一键扩成 `(user_id, module_key, business_date, source)`:
-- 同一天多路各占一行,读侧 adminPage/SUM 按模块聚合,对多出的行天然透明。
--
-- 4. 锁表风险:极低。日聚合表、万行量级,MySQL 8 ADD COLUMN NOT NULL DEFAULT
-- 走 INSTANT;索引重建在当前行数下毫秒级。
--
-- 5. 验证 SQL(迁移后跑,不许只看启动日志的 Successfully applied):
-- SHOW COLUMNS FROM `biz_user_secret_usage_daily` LIKE 'source';
-- -> 期望 1 行:source,Type=varchar(24),Null=NO,Default=legacy
-- SHOW INDEX FROM `biz_user_secret_usage_daily` WHERE Key_name='uk_user_module_date_source';
-- -> 期望 4 行(user_id/module_key/business_date/source),Non_unique=0
-- 应用侧:UserSecretUsageServiceTest 全绿(increment/addTokens 带来源、
-- 缺省/非法报文落 legacy、Java 自产 LLM 行=backend)。
--
-- 6. 上线窗口:必须与读写的 jar 同版同窗——旧 jar 的 increment 不带 source,
-- INSERT 会落进 DEFAULT 'legacy'(幂等键还是旧三元组形状时列不参与键,行为不变);
-- 新 jar 写四元组前 Flyway 已保证新键存在。只发 jar 不发迁移会在第一次 upsert
-- 时撞 1054 Unknown column,只发迁移不发 jar 则所有行落 legacy(无损失但无归因)。
--
-- 7. 可重跑性:加列与建索引都先查 information_schema(列按 V157 款,索引按 V184 款)——
-- 迁移中途失败时 flyway repair + 重启会从第一条语句重跑整个文件,裸 ALTER 会撞
-- 1060/1061。
--
-- 8. 回滚(人工补丁,写成注释以免落在 Flyway 扫描路径里被当迁移执行):
-- 触发场景是"这列不该加"。顺序:停两台应用 → 跑下面三条 →
-- 删 flyway_schema_history 的 version='188' 行 → 回滚 jar → 起应用。
-- ALTER TABLE `biz_user_secret_usage_daily` DROP INDEX `uk_user_module_date_source`;
-- ALTER TABLE `biz_user_secret_usage_daily` ADD UNIQUE KEY `uk_user_module_date`
-- (`user_id`, `module_key`, `business_date`);
-- ALTER TABLE `biz_user_secret_usage_daily` DROP COLUMN `source`;
-- 注意回滚前须先把四元组里的重行并回(同键多行会让 ADD UNIQUE 失败):
-- (按 user_id+module_key+business_date 求 SUM 后重插——正常不会发生,
-- 除非回滚前已有多来源同行;真发生时按该日逐行手工核对再并。)
-- 仅回滚 jar(代码问题、与列无关)不需要 DROP:旧 jar 不写 source,行形状保持
-- DEFAULT 'legacy',读侧聚合不变。
-- =============================================================
SET @col := (
SELECT COUNT(*) FROM information_schema.COLUMNS
WHERE TABLE_SCHEMA = DATABASE()
AND TABLE_NAME = 'biz_user_secret_usage_daily'
AND COLUMN_NAME = 'source'
);
SET @ddl := IF(@col = 0,
'ALTER TABLE `biz_user_secret_usage_daily` ADD COLUMN `source` varchar(24) NOT NULL DEFAULT ''legacy'' COMMENT ''计次来源(client/brand16890/brand15126/pt_worker/backend;存量行=legacy)'' AFTER `module_key`',
'SELECT ''biz_user_secret_usage_daily.source already exists, skipped'' AS note');
PREPARE stmt FROM @ddl;
EXECUTE stmt;
DEALLOCATE PREPARE stmt;
SET @old_key := (
SELECT COUNT(DISTINCT INDEX_NAME) FROM information_schema.STATISTICS
WHERE TABLE_SCHEMA = DATABASE()
AND TABLE_NAME = 'biz_user_secret_usage_daily'
AND INDEX_NAME = 'uk_user_module_date'
);
SET @new_key := (
SELECT COUNT(DISTINCT INDEX_NAME) FROM information_schema.STATISTICS
WHERE TABLE_SCHEMA = DATABASE()
AND TABLE_NAME = 'biz_user_secret_usage_daily'
AND INDEX_NAME = 'uk_user_module_date_source'
);
SET @ddl2 := IF(@new_key = 0 AND @old_key > 0,
'ALTER TABLE `biz_user_secret_usage_daily` DROP INDEX `uk_user_module_date`, ADD UNIQUE KEY `uk_user_module_date_source` (`user_id`, `module_key`, `business_date`, `source`)',
'SELECT ''uk_user_module_date_source already exists (or old key missing), skipped'' AS note');
PREPARE stmt2 FROM @ddl2;
EXECUTE stmt2;
DEALLOCATE PREPARE stmt2;
@@ -9,18 +9,21 @@
LIMIT #{batchSize}
</delete>
<insert id="increment">
INSERT INTO biz_user_secret_usage_daily (user_id, module_key, business_date, call_count, created_at, updated_at)
VALUES (#{userId}, #{moduleKey}, #{businessDate}, #{count}, NOW(), NOW())
INSERT INTO biz_user_secret_usage_daily (user_id, module_key, business_date, source, call_count, created_at, updated_at)
VALUES (#{userId}, #{moduleKey}, #{businessDate}, #{source}, #{count}, NOW(), NOW())
ON DUPLICATE KEY UPDATE call_count = call_count + #{count}, updated_at = NOW()
</insert>
<!-- 不是「从注解搬过来」的语句:V157 加 token 两列时新写的,登记在 MigratedSqlEquivalenceTest.NOT_MIGRATED。
与上面的 increment 分两条是口径要求:计次先于响应,token 只在响应回来后有读数。 -->
与上面的 increment 分两条是口径要求:计次先于响应,token 只在响应回来后有读数。
WHERE 带 source(V188):唯一键四元组后同一 (user,module,date) 可能有多行,
不钉 source 会把 token 记到 legacy 历史行上造成双计。 -->
<update id="addTokens">
UPDATE biz_user_secret_usage_daily
SET prompt_tokens = prompt_tokens + #{promptTokens},
completion_tokens = completion_tokens + #{completionTokens},
updated_at = NOW()
WHERE user_id = #{userId} AND module_key = #{moduleKey} AND business_date = #{businessDate}
AND source = #{source}
</update>
<select id="sumByUserAndModule" resultType="com.nanri.aiimage.modules.usersecret.model.dto.UserSecretUsageAggregate">
SELECT user_id AS userId,
@@ -55,7 +55,7 @@ class MigratedSqlEquivalenceTest {
// 85 → 84:Phase 5(AC-19/P1-B1)有意把 {@code TaskCenterQueryMapper#selectTaskPage} 从
// OFFSET 改成 keyset 游标。账本记的是「注解时代原文」,改一行基准就等于让等价性测试照着
// 新 SQL 自证 ⇒ 把该行整条摘出账本、点名进下方 NOT_MIGRATED,让基准继续只描述真正未改动的迁移件。
private static final int LEDGER_ROWS = 84;
private static final int LEDGER_ROWS = 83;
// 60 → 59:摘出去那行是一条 select。
private static final int LEDGER_SELECTS = 59;
/** 全部 mapper XML 里的 select 总数:账本 60 + TaskImageCache 5 + AsinResultCache 1。 */
@@ -87,6 +87,11 @@ class MigratedSqlEquivalenceTest {
*/
private static final java.util.Set<String> NOT_MIGRATED =
java.util.Set.of("AdminUserMapper#countLiveWorkFor",
// V188(2026-11-04)给计次 upsert 加 source 列(唯一键四元组),SQL 文本
// 不再是注解时代的逐字原文:整行从 migrated-statements.tsv 摘掉、点名到
// 这里(与 selectTaskPage 改写时同款处理,LEDGER_ROWS 84→83);新形状
// 由 V188 迁移测试与 UserSecretUsageServiceTest 钉。
"UserSecretUsageMapper#increment",
// V157 加 token 两列时新写的累加语句;注解时代没有原文可对撞,等价性这支只能跳过它。
// 与 increment 分两条是口径要求(计次先于响应、token 只在响应后有读数),不是随手加的第二条 SQL。
"UserSecretUsageMapper#addTokens",
@@ -173,7 +178,7 @@ class MigratedSqlEquivalenceTest {
"fixture 里的 Select 条数与基线不符(读侧账本 = 59)");
assertEquals(LEDGER_ROWS - LEDGER_SELECTS,
rows.stream().filter(r -> !"Select".equals(r[2])).count(),
"写侧条数对不上(25 = Insert+Update+Delete)");
"写侧条数对不上(24 = Insert+Update+Delete)");
assertTrue(rows.stream().allMatch(r -> !r[1].isEmpty() && !r[BASELINE_COL].isEmpty()),
"fixture 有空方法名或空 SQL,说明抽取器漏了形状");
// 基准得是「整条注解串」:半截 <script> 外壳说明抽取被截断(上一轮就是把常量与标签吃了)
@@ -0,0 +1,117 @@
package com.nanri.aiimage.config;
import com.nanri.aiimage.modules.usersecret.model.entity.UserSecretUsageEntity;
import org.junit.jupiter.api.Test;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
/**
* V188 给 {@code biz_user_secret_usage_daily} 加 {@code source} 列并把唯一键扩成四元组,
* 本类钉它的形状(Expand 半边,2026-11-04 客户反馈「代理IP用的很猛」的归因前置)。
*
* <p>四件事各守一个炸法:
* <ol>
* <li><b>NOT NULL + DEFAULT 'legacy' 且不回填</b>:存量行无法追溯是哪一路报的,
* 统一落 legacy(诚实的"不知道"),不按今天的上报方名单猜历史。</li>
* <li><b>唯一键必须扩成四元组</b>:不扩键的话同一天多路的上报会在旧三元组上互相
* ON DUPLICATE(source 记成"最后写入者"),按来源归因直接失真;只加列不扩键
* 等于白加。</li>
* <li><b>可重跑</b>:加列与建索引都先查 information_schema(列按 V157 款、索引按
* V184 款),迁移中途失败重跑不许撞 1060/1061。</li>
* <li><b>列名与实体字段对齐</b>:MyBatis-Plus 驼峰↔下划线,对不上写入会静默不落库。</li>
* </ol>
*/
class UserSecretUsageSourceMigrationV188Test {
private static final Path SQL = Path.of(System.getProperty("user.dir"),
"src/main/resources/db/V188__user_secret_usage_source.sql");
private static String sql() throws IOException {
assertTrue(Files.exists(SQL), "V188 迁移脚本不在:" + SQL);
return Files.readString(SQL);
}
@Test
void 列是not_null的窄列且默认落legacy() throws IOException {
String text = sql();
assertTrue(text.contains("ALTER TABLE `biz_user_secret_usage_daily`"), "迁移对象必须是本表");
// DDL 藏在 SET @ddl 的字符串字面量里,引号按 SQL 规则写成两个单引号(''legacy'')
assertTrue(text.contains("ADD COLUMN `source` varchar(24) NOT NULL DEFAULT ''legacy''"),
"NOT NULL + DEFAULT 'legacy':存量行诚实落 legacy,NULL 会让 GROUP BY 多出一种真空来源");
assertTrue(text.contains("AFTER `module_key`"),
"紧跟 module_key:来源是模块的下一级维度,读的人要能一眼成对");
assertFalse(text.toUpperCase().contains("UPDATE `BIZ_USER_SECRET_USAGE_DAILY` SET `SOURCE`"),
"Expand 阶段不回填:历史行的来源不能按今天的上报方名单猜");
assertTrue(text.contains("DROP COLUMN `source`"),
"回滚语句必须写在脚本注释里(与 V157 同一口径)");
}
@Test
void 唯一键必须扩成四元组() throws IOException {
String text = sql();
assertTrue(text.contains("DROP INDEX `uk_user_module_date`"),
"旧三元组键必须摘除:留着它与新键并存,旧形状的 upsert 会绕过 source 维度");
assertTrue(text.contains("ADD UNIQUE KEY `uk_user_module_date_source` "
+ "(`user_id`, `module_key`, `business_date`, `source`)"),
"新键必须含 source:同一天多路各占一行,读侧 SUM 对多出的行透明");
}
@Test
void 加列与建索引都必须判存可重跑() throws IOException {
String text = sql();
assertTrue(text.contains("information_schema.COLUMNS"),
"加列前必须查列存在(V157 款)");
assertTrue(text.contains("information_schema.STATISTICS"),
"建索引前必须查索引存在(V184 款)");
assertEquals(2, countMatches(text, "EXECUTE stmt"),
"两条 DDL 各自走 PREPARE/EXECUTE 判存重跑(DEALLOCATE 不计)");
}
@Test
void 头注释版本号与文件名一致() throws IOException {
String first = sql().lines().findFirst().orElse("");
assertTrue(first.startsWith("-- V188:"), "头注释必须写 V188,实际是:" + first);
}
@Test
void 实体字段与列名按驼峰下划线一一对应() throws Exception {
assertNotNull(UserSecretUsageEntity.class.getDeclaredField("source"),
"实体缺 source 字段 ⇒ 列永远不会被写");
assertEquals("source", camelToSnake("source"),
"单词列名没有驼峰转换空间,这一格防的是字段名拼错(如 soource)");
assertTrue(sql().contains("`source`"));
}
private static int countMatches(String text, String needle) {
Matcher matcher = Pattern.compile(needle, Pattern.LITERAL).matcher(text);
int count = 0;
while (matcher.find()) {
count++;
}
return count;
}
private static String camelToSnake(String name) {
StringBuilder out = new StringBuilder();
for (char c : name.toCharArray()) {
if (Character.isUpperCase(c)) {
out.append('_').append(Character.toLowerCase(c));
} else {
out.append(c);
}
}
return out.toString();
}
}
@@ -35,6 +35,7 @@ import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
@@ -67,11 +68,13 @@ class UserSecretUsageServiceTest {
@Test
void recordIncrementsByModuleWithTodayDate() {
UserSecretUsageService service = newService();
when(usageMapper.increment(any(), any(), any(), eq(1))).thenReturn(1);
when(usageMapper.increment(any(), any(), any(), eq(1), any())).thenReturn(1);
service.record(7L, "similar-asin", 1);
verify(usageMapper).increment(eq(7L), eq("similar-asin"), eq(LocalDate.now()), eq(1));
// Java 自产 LLM 行落 backend 来源(V188)
verify(usageMapper).increment(eq(7L), eq("similar-asin"), eq(LocalDate.now()), eq(1),
eq("backend"));
}
@Test
@@ -83,44 +86,47 @@ class UserSecretUsageServiceTest {
service.record(7L, "not-a-module", 1);
service.record(7L, "similar-asin", 0);
verify(usageMapper, never()).increment(any(), any(), any(), any(Integer.class));
verify(usageMapper, never()).increment(any(), any(), any(), any(Integer.class), any());
}
@Test
void recordSwallowsMapperFailure() {
UserSecretUsageService service = newService();
when(usageMapper.increment(any(), any(), any(), eq(1)))
when(usageMapper.increment(any(), any(), any(), eq(1), any()))
.thenThrow(new IllegalStateException("db down"));
// 计次失败绝不影响任务主流程
service.record(7L, "proxy", 1);
verify(usageMapper).increment(eq(7L), eq("proxy"), eq(LocalDate.now()), eq(1));
verify(usageMapper).increment(eq(7L), eq("proxy"), eq(LocalDate.now()), eq(1),
eq("backend"));
}
@Test
void recordReportedCapsCountAndRejectsUnknownModule() {
UserSecretUsageService service = newService();
when(usageMapper.increment(any(), any(), any(), any(Integer.class))).thenReturn(1);
when(usageMapper.increment(any(), any(), any(), any(Integer.class), any())).thenReturn(1);
assertThat(service.recordReported(7L, "proxy", 50_000)).isTrue();
assertThat(service.recordReported(7L, "not-a-module", 3)).isFalse();
assertThat(service.recordReported(7L, "proxy", 0)).isFalse();
// 超出上限按 10000 截断,防止异常客户端写爆计数
verify(usageMapper).increment(eq(7L), eq("proxy"), eq(LocalDate.now()), eq(10_000));
// 超出上限按 10000 截断,防止异常客户端写爆计数;3 参旧形状缺省落 legacy
verify(usageMapper).increment(eq(7L), eq("proxy"), eq(LocalDate.now()), eq(10_000),
eq("legacy"));
}
@Test
void recordReportedAllowsPlatformBucketOnlyForProxy() {
UserSecretUsageService service = newService();
when(usageMapper.increment(any(), any(), any(), any(Integer.class))).thenReturn(1);
when(usageMapper.increment(any(), any(), any(), any(Integer.class), any())).thenReturn(1);
assertThat(service.recordReported(0L, "proxy", 3)).isTrue();
assertThat(service.recordReported(0L, "appearance-patent", 3)).isFalse();
assertThat(service.recordReported(-1L, "proxy", 3)).isFalse();
verify(usageMapper).increment(eq(0L), eq("proxy"), eq(LocalDate.now()), eq(3));
verify(usageMapper).increment(eq(0L), eq("proxy"), eq(LocalDate.now()), eq(3),
eq("legacy"));
}
@Test
@@ -404,8 +410,9 @@ class UserSecretUsageServiceTest {
service.recordTokens(7L, "appearance-patent", 1234L, 56L);
verify(usageMapper).addTokens(eq(7L), eq("appearance-patent"), eq(LocalDate.now()), eq(1234L), eq(56L));
verify(usageMapper, never()).increment(any(), any(), any(), any(Integer.class));
verify(usageMapper).addTokens(eq(7L), eq("appearance-patent"), eq(LocalDate.now()),
eq(1234L), eq(56L), eq("backend"));
verify(usageMapper, never()).increment(any(), any(), any(), any(Integer.class), any());
}
@Test
@@ -416,7 +423,7 @@ class UserSecretUsageServiceTest {
service.recordTokens(7L, "appearance-patent", 0L, 0L);
service.recordTokens(7L, "appearance-patent", -5L, 0L);
verify(usageMapper, never()).addTokens(any(), any(), any(), anyLong(), anyLong());
verify(usageMapper, never()).addTokens(any(), any(), any(), anyLong(), anyLong(), any());
}
@Test
@@ -426,7 +433,8 @@ class UserSecretUsageServiceTest {
service.recordTokens(7L, "similar-asin", 900L, 0L);
verify(usageMapper).addTokens(eq(7L), eq("similar-asin"), eq(LocalDate.now()), eq(900L), eq(0L));
verify(usageMapper).addTokens(eq(7L), eq("similar-asin"), eq(LocalDate.now()), eq(900L),
eq(0L), eq("backend"));
}
@Test
@@ -438,31 +446,73 @@ class UserSecretUsageServiceTest {
service.recordTokens(0L, "proxy", 10L, 10L);
service.recordTokens(7L, "not-a-module", 10L, 10L);
verify(usageMapper, never()).addTokens(any(), any(), any(), anyLong(), anyLong());
verify(usageMapper, never()).addTokens(any(), any(), any(), anyLong(), anyLong(), any());
}
@Test
@DisplayName("recordTokens:写库失败只告警,绝不把任务带崩")
void recordTokensSwallowsMapperFailure() {
UserSecretUsageService service = newService();
when(usageMapper.addTokens(any(), any(), any(), anyLong(), anyLong()))
when(usageMapper.addTokens(any(), any(), any(), anyLong(), anyLong(), any()))
.thenThrow(new IllegalStateException("db down"));
service.recordTokens(7L, "proxy", 10L, 2L);
verify(usageMapper).addTokens(eq(7L), eq("proxy"), eq(LocalDate.now()), eq(10L), eq(2L));
verify(usageMapper).addTokens(eq(7L), eq("proxy"), eq(LocalDate.now()), eq(10L), eq(2L),
eq("backend"));
}
@Test
@DisplayName("计次那一路不许顺手写 token:两条语句分开是口径要求(计次先于响应)")
void countPathNeverWritesTokens() {
UserSecretUsageService service = newService();
when(usageMapper.increment(any(), any(), any(), eq(1))).thenReturn(1);
when(usageMapper.increment(any(), any(), any(), eq(1), any())).thenReturn(1);
service.record(7L, "appearance-patent", 1);
service.recordReported(7L, "proxy", 3);
verify(usageMapper, never()).addTokens(any(), any(), any(), anyLong(), anyLong());
verify(usageMapper, never()).addTokens(any(), any(), any(), anyLong(), anyLong(), any());
}
// --- source 维度(V188):「谁在烧」是一列读数,不再靠扫设备日志归因 ---
@Test
@DisplayName("recordReported:上报方自报的 source 规整后落库(trim+小写)")
void recordReportedCarriesReportedSource() {
UserSecretUsageService service = newService();
when(usageMapper.increment(any(), any(), any(), any(Integer.class), any())).thenReturn(1);
assertThat(service.recordReported(7L, "proxy", 3, "Client")).isTrue();
verify(usageMapper).increment(eq(7L), eq("proxy"), eq(LocalDate.now()), eq(3),
eq("client"));
}
@Test
@DisplayName("recordReported:source 缺省/空/脏值一律落 legacy,不拒收不猜身份")
void recordReportedFallsBackToLegacyOnDirtySource() {
UserSecretUsageService service = newService();
when(usageMapper.increment(any(), any(), any(), any(Integer.class), any())).thenReturn(1);
assertThat(service.recordReported(7L, "proxy", 1, null)).isTrue();
assertThat(service.recordReported(7L, "proxy", 1, " ")).isTrue();
assertThat(service.recordReported(7L, "proxy", 1, "dirty; DROP TABLE x")).isTrue();
assertThat(service.recordReported(7L, "proxy", 1, "x".repeat(25))).isTrue();
// 计次比归因更贵:宁可归因模糊(legacy)也不丢账
verify(usageMapper, times(4)).increment(eq(7L), eq("proxy"), eq(LocalDate.now()),
any(Integer.class), eq("legacy"));
}
@Test
@DisplayName("recordTokens 必须钉在 backend 来源上:唯一键四元组后不钉 source 会把 token 记到 legacy 历史行造成双计")
void recordTokensPinsBackendSource() {
UserSecretUsageService service = newService();
service.recordTokens(7L, "appearance-patent", 1234L, 56L);
verify(usageMapper).addTokens(eq(7L), eq("appearance-patent"), eq(LocalDate.now()),
eq(1234L), eq(56L), eq("backend"));
}
}
@@ -81,4 +81,3 @@ UserColumnPermissionMapper selectByUserId Select PURE SELECT user_id, column_id
UserNotificationMapper deleteReadBeforeBatch Delete PURE DELETE FROM biz_user_notification\nWHERE read_at IS NOT NULL AND created_at < #{cutoff}\nLIMIT #{batchSize}
UserNotificationMapper deleteUnreadBeforeBatch Delete PURE DELETE FROM biz_user_notification\nWHERE read_at IS NULL AND created_at < #{cutoff}\nLIMIT #{batchSize}
UserSecretUsageMapper deleteBefore Delete PURE DELETE FROM biz_user_secret_usage_daily\nWHERE business_date < #{cutoff}\nLIMIT #{batchSize}
UserSecretUsageMapper increment Insert PURE INSERT INTO biz_user_secret_usage_daily (user_id, module_key, business_date, call_count, created_at, updated_at)\nVALUES (#{userId}, #{moduleKey}, #{businessDate}, #{count}, NOW(), NOW())\nON DUPLICATE KEY UPDATE call_count = call_count + #{count}, updated_at = NOW()
Can't render this file because it contains an unexpected character in line 1 and column 222.