fix(collect-data): 进度节流不再借道 updated_at 计时,终态用 summaries 校正

心跳层的 updated_at 检查点在本模块 SPI 之前就把该字段刷成 now,而节流窗口
又拿它当锚点——每条心跳都被自己刚写下去的时间戳合并掉。现网 task 32573:
7 个关键词全部跑完、61 个分片全部回传,processedRows 恒 0,用户端卡片于是
写着「关键词缺口:任务提前结束于 0/7,还有 7 个关键词未采集」,把已完成的任务
报成漏采。节流锚点改为服务内按 taskId 键控的上一次进度落库时刻,只在 UPDATE
成功后推进、任务离 RUNNING 时回收;不塞进 result_json,否则那份 JSON 含墙上
时钟就永久不可复现(快照测试 submit_result_snapshot_is_reproducible 钉的就是它)。

客户端 post_result 不带 current/total,旁路心跳一旦整轮不落地就没有终态进度可用。
summaries 与 processed_items 在客户端成对推进(search_task.py:660-661),条数即
真实已处理关键词数,据此在收尾时校正 processedRows:只抬不砍、不越过 totalRows,
task 31253 那种「8 行只跑 2 个关键词」必须继续显示 2/8。

同一张卡片上 invalidFilteredCount 一会儿叫「不符合 ASIN 过滤」一会儿叫「无效品牌」,
而它是品牌黑名单命中的行数,与用户的 ASIN 筛选条件无关,统一为「无效品牌过滤」。

6 条旧节流用例靠手工摆 updated_at 让窗口到期,锚点一换必然失效,改为
expireProgressWindow(service, task)。它们在 setUp 里把节流设成 0,从未覆盖过
生产默认 15000——这也是这个 bug 能藏到现网的原因之一。
This commit is contained in:
2026-10-28 15:29:06 +08:00
parent 632efa6a8e
commit b3d90d2161
4 changed files with 177 additions and 20 deletions
@@ -36,8 +36,11 @@ import static org.mockito.Mockito.when;
* 强制执行一次持久化,最终进度不丢失。persistStats 内容感知:
* 序列化结果与既有 result_json 逐字节一致时不重写,重复心跳零 UPDATE。
*
* 节流计时一律按任务自身(updated_at),不再共享服务上的全局时间戳——全局计时会被并发
* 任务互相重置,把内容不变的心跳饿死成永不落库,进而被陈旧巡检误杀(见并发回归用例)。
* 节流计时按**任务自身**键控(服务里以 taskId 为键的"上一次进度落库时刻"),既不用服务级
* 单时间戳——那会被并发任务互相重置,把内容不变的心跳饿死成永不落库,进而被陈旧巡检误杀
* (见并发回归用例);也不用 updated_at——它由 TaskHeartbeatService 的检查点在本模块 SPI
* **之前**写掉,拿它当锚点会让每条心跳都被自己刚写的时间戳合并掉(现网 task 32573,
* processedRows 恒 0,见 test_心跳层把updated_at顶到now时_changed心跳仍必须落库)。
*/
@ExtendWith(MockitoExtension.class)
class CollectDataProgressThrottleTest {
@@ -101,7 +104,7 @@ class CollectDataProgressThrottleTest {
assertThat(task.getResultJson()).contains("\"processedRows\":1");
// 窗口到期后的心跳再次持久化(该任务自身计时到期)。
task.setUpdatedAt(LocalDateTime.now().minusSeconds(61));
expireProgressWindow(service, task);
TaskHeartbeatRequest third = new TaskHeartbeatRequest();
third.setCurrent(2);
third.setTotal(10);
@@ -136,13 +139,13 @@ class CollectDataProgressThrottleTest {
assertThat(taskB.getResultJson()).contains("\"processedRows\":1");
// A 自身窗口到期后补写最新值;B 仍在自己窗口内,继续被合并。
taskA.setUpdatedAt(LocalDateTime.now().minusSeconds(61));
expireProgressWindow(service, taskA);
heartbeat(service, 11L, 3, 10);
verify(fileTaskMapper, times(3)).updateById(any(FileTaskEntity.class));
assertThat(taskA.getResultJson()).contains("\"processedRows\":3");
// B 自身窗口到期后同样补写,两任务最终进度均为最新值。
taskB.setUpdatedAt(LocalDateTime.now().minusSeconds(61));
expireProgressWindow(service, taskB);
heartbeat(service, 12L, 3, 10);
verify(fileTaskMapper, times(4)).updateById(any(FileTaskEntity.class));
assertThat(taskB.getResultJson()).contains("\"processedRows\":3");
@@ -168,7 +171,7 @@ class CollectDataProgressThrottleTest {
// 邻居任务连续刷了 5 次,把「全局窗口」反复重置——旧实现正是死在这里。
for (int i = 1; i <= 5; i++) {
busy.setUpdatedAt(LocalDateTime.now().minusSeconds(61)); // 让它每次都够格落库
expireProgressWindow(service, busy); // 让它每次都够格落库
heartbeat(service, 71L, i, 10);
}
assertThat(busy.getUpdatedAt()).isAfter(LocalDateTime.now().minusSeconds(5));
@@ -228,7 +231,7 @@ class CollectDataProgressThrottleTest {
verify(fileTaskMapper, times(1)).updateById(any(FileTaskEntity.class));
// 窗口到期后补写最新值(processedRows=4),不丢失。
task.setUpdatedAt(LocalDateTime.now().minusSeconds(61));
expireProgressWindow(service, task);
heartbeat(service, 31L, 4, 21);
verify(fileTaskMapper, times(2)).updateById(any(FileTaskEntity.class));
assertThat(task.getResultJson()).contains("\"processedRows\":4");
@@ -252,7 +255,7 @@ class CollectDataProgressThrottleTest {
// 窗口内 100 次心跳只落库 1 次,无无界 UPDATE 累积;窗口到期后补写最新值。
verify(fileTaskMapper, times(1)).updateById(any(FileTaskEntity.class));
assertThat(task.getResultJson()).contains("\"processedRows\":1");
task.setUpdatedAt(LocalDateTime.now().minusSeconds(61));
expireProgressWindow(service, task);
heartbeat(service, 41L, 100, 100);
verify(fileTaskMapper, times(2)).updateById(any(FileTaskEntity.class));
assertThat(task.getResultJson()).contains("\"processedRows\":100");
@@ -305,9 +308,10 @@ class CollectDataProgressThrottleTest {
verify(lockHandle, times(1)).close();
// 恢复后心跳重试:落库一次成功,进度持久化。
// 写失败时库里的 updated_at 并未前进,真实链路每条心跳都在 :479 重新 selectById,
// 读到的仍是旧值 ⇒ 会立刻补刷。本用例的 mock 复用同一个实体实例,故先把它退回
// 「库里那一版」——否则测的是对象别名,不是这条重读语义。
// 节流时钟只在 updateById 返回后才推进,所以那次失败的写没有留下窗口;updated_at 同理
// 停在库里那一版。真实链路每条心跳都在 :530 重新 selectById ⇒ 会立刻补刷。本用例的
// mock 复用同一个实体实例,故把 updated_at 退回「库里那一版」——否则测的是对象别名,
// 不是这条重读语义。
task.setUpdatedAt(null);
heartbeat(service, 61L, 2, 10);
verify(fileTaskMapper, times(2)).updateById(any(FileTaskEntity.class));
@@ -316,6 +320,38 @@ class CollectDataProgressThrottleTest {
verify(lockHandle, times(2)).close();
}
@Test
void test_心跳层把updated_at顶到now时_changed心跳仍必须落库() {
// 现网 task 32573 的形状。TaskHeartbeatService 在调用 COLLECT_DATA 的 SPI **之前**就
// 无条件把 updated_at 刷成 now(本模块未覆写 checkpointInterval ⇒ isCheckpointDue 恒真),
// 旧实现拿 updated_at 当节流锚点,于是每条心跳都被自己刚写下去的时间戳合并掉:
// 7 个关键词全部跑完、61 个分片全部回传,processedRows 恒 0,
// 前端把已完成的任务渲染成「关键词缺口:任务提前结束于 0/7,还有 7 个关键词未采集」。
ReflectionTestUtils.setField(service, "progressThrottleMillis", 15_000L);
ReflectionTestUtils.setField(service, "progressDirtyWindowMillis", 30_000L);
FileTaskEntity task = runningTask(81L);
when(fileTaskMapper.selectById(81L)).thenReturn(task);
when(taskDistributedLockService.acquire(CollectDataService.MODULE_TYPE, 81L, 5_000L))
.thenReturn(lockHandle);
// 决定性的一步:updated_at 就是 now,旧实现在这里直接 return,进度永远停在 0。
task.setUpdatedAt(LocalDateTime.now());
heartbeat(service, 81L, 1, 7);
verify(fileTaskMapper, times(1)).updateById(any(FileTaskEntity.class));
assertThat(task.getResultJson()).contains("\"processedRows\":1");
// 客户端按 60s 一跳,逐关键词推进:每跳进来时 updated_at 都已被心跳层顶到 now,
// 距**上一次进度落库**已超过节流窗口 ⇒ 七个关键词的进度必须逐个落地。
for (int keyword = 2; keyword <= 7; keyword++) {
task.setUpdatedAt(LocalDateTime.now());
expireProgressWindow(service, task);
heartbeat(service, 81L, keyword, 7);
}
verify(fileTaskMapper, times(7)).updateById(any(FileTaskEntity.class));
assertThat(task.getResultJson()).contains("\"processedRows\":7");
assertThat(task.getResultJson()).contains("\"totalRows\":7");
}
private static FileTaskEntity runningTask(long taskId) {
FileTaskEntity task = new FileTaskEntity();
task.setId(taskId);
@@ -332,4 +368,15 @@ class CollectDataProgressThrottleTest {
request.setTotal(total);
service.updateProgress(taskId, request);
}
/**
* 让该任务的节流窗口到期。锚点是服务里按 taskId 键控的"上一次进度落库时刻",
* 不是 updated_at —— 后者在真实链路上由 TaskHeartbeatService 在调用本模块 SPI 之前
* 就被刷成 now,拿它当窗口锚点会让每条心跳都被自己刚写的时间戳合并掉(现网 task 32573)。
*/
@SuppressWarnings("unchecked")
private static void expireProgressWindow(CollectDataService service, FileTaskEntity task) {
((java.util.concurrent.ConcurrentHashMap<Long, Long>)
ReflectionTestUtils.getField(service, "lastProgressFlushMillis")).remove(task.getId());
}
}
@@ -0,0 +1,61 @@
package com.nanri.aiimage.modules.collectdata.service;
import com.nanri.aiimage.modules.collectdata.model.dto.CollectDataSummaryRowDto;
import org.junit.jupiter.api.Test;
import java.util.ArrayList;
import java.util.List;
import static org.assertj.core.api.Assertions.assertThat;
/**
* 终态进度读数:processedRows 必须等于「实际跑完的关键词数」。
*
* <p>现网 task 32573:7 个关键词全部跑完、61 个分片全部回传,processedRows 却恒为 0,
* 用户端卡片于是写着「关键词缺口:任务提前结束于 0/7,还有 7 个关键词未采集」——
* 一个已完成的任务被报成漏采 7 个关键词。客户端的 post_result 不带 current/total,
* 终态进度只能由服务端从 summaries 推:它与 processed_items 在客户端成对推进
* (app_client/amazon/search_task.py:660-661),条数就是真实的已处理关键词数。
*/
class CollectDataTerminalProgressTest {
private static List<CollectDataSummaryRowDto> summaries(int count) {
List<CollectDataSummaryRowDto> rows = new ArrayList<>();
for (int i = 0; i < count; i++) {
CollectDataSummaryRowDto row = new CollectDataSummaryRowDto();
row.setKeyword("kw-" + i);
rows.add(row);
}
return rows;
}
@Test
void test_32573_跑满七个关键词时不再报缺口() {
assertThat(CollectDataService.terminalProcessedRows(0, summaries(7), 7)).isEqualTo(7);
}
@Test
void test_31253_真缺口不得被抹平() {
// 8 行只跑了 2 个关键词:这条读数是它唯一还在说话的地方,
// 不许因为状态是 SUCCESS 就把没跑完的关键词抹成 100%。
assertThat(CollectDataService.terminalProcessedRows(0, summaries(2), 8)).isEqualTo(2);
}
@Test
void test_只抬不砍_心跳已推进得更远时不回退() {
assertThat(CollectDataService.terminalProcessedRows(5, summaries(3), 8)).isEqualTo(5);
}
@Test
void test_不越过分母_summaries多于totalRows时钳住() {
assertThat(CollectDataService.terminalProcessedRows(0, summaries(9), 7)).isEqualTo(7);
}
@Test
void test_没有summaries时不猜_维持原值() {
// 聚合没回传、或分母缺失:宁可不写也不臆造进度。
assertThat(CollectDataService.terminalProcessedRows(0, List.of(), 7)).isZero();
assertThat(CollectDataService.terminalProcessedRows(0, null, 7)).isZero();
assertThat(CollectDataService.terminalProcessedRows(0, summaries(3), 0)).isZero();
}
}