diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/service/AppearancePatentTaskService.java b/backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/service/AppearancePatentTaskService.java index 8b2c60b3b..c76fdd793 100644 --- a/backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/service/AppearancePatentTaskService.java +++ b/backend-java/src/main/java/com/nanri/aiimage/modules/appearancepatent/service/AppearancePatentTaskService.java @@ -746,7 +746,9 @@ public class AppearancePatentTaskService { * 每分钟刷新——主线程卡死时心跳线程照发,任务永远不 stale(与生产 28131 同型缺口)。 * 本线改看 biz_task_scope_state.last_chunk_at(仅在 persistSubmittedChunk 上传分片时刷新), * 命中后走既有 finalizeStaleTask(封口上传 + LLM 收尾,不粗暴杀任务)。 - * 从未上报(无 scope 行或全 NULL)的任务跳过,避免误杀首批较慢的正常任务。 + * 从未上报(无 scope 行或全 NULL)的任务不再无条件跳过,改按「处理位置是否仍在推进」区分: + * 位置在变=首批较慢,跳过;位置长时间不变=判死并写清停在哪;无位置信息(老客户端)=证据不足, + * 保守跳过但留 WARN —— 2026-10-06 品牌任务 2626 正是靠无条件跳过挂到 9 小时。 */ private void finalizeNoUploadStaleTasks() { long minutes = properties.getNoResultUploadTimeoutMinutes(); @@ -774,7 +776,35 @@ public class AppearancePatentTaskService { continue; } LocalDateTime lastResultAt = lastResultAtByTaskId.get(task.getId()); - if (lastResultAt == null || lastResultAt.isAfter(cutoff)) { + if (lastResultAt == null) { + // 从未上报任何结果分片:原先与「上报仍新鲜」合并成一句静默 continue, + // 与 2026-10-06 品牌任务 2626 挂 9 小时是同一出口(本模块同样心跳照打)。 + // 现按「处理位置是否仍在推进」三分:在推进=首批较慢,跳过;位置久未变=判死并写清卡在哪; + // 无位置信息(老客户端 / 条目被 prune)=证据不足,保守跳过但留 WARN。 + String neverReportedPosition = taskHeartbeatPositionService.describe(task.getId()); + if (taskHeartbeatPositionService.isClientAdvancing(task.getId(), minutes)) { + log.info("[appearance-patent] 从未上报但客户端仍在推进,本轮不封口 taskId={} position={} minutes={}", + task.getId(), neverReportedPosition, minutes); + continue; + } + if (neverReportedPosition == null || neverReportedPosition.isBlank()) { + log.warn("[appearance-patent] 从未上报且无位置信息,证据不足暂不封口 taskId={} createdAt={} minutes={}", + task.getId(), task.getCreatedAt(), minutes); + continue; + } + TaskDistributedLockService.LockHandle neverReportedLock = acquireTaskLock(task.getId(), 0L); + if (neverReportedLock == null) { + continue; + } + try (neverReportedLock) { + log.warn("[appearance-patent] 从未上报任何结果分片且处理位置长时间停在「{}」未推进,按卡死收尾 taskId={} minutes={}", + neverReportedPosition, task.getId(), minutes); + finalizeStaleTask(task.getId(), "超过 " + minutes + " 分钟无任何结果分片上报,处理位置长时间停在「" + + neverReportedPosition + "」未推进,疑似客户端任务卡死,任务已自动失败"); + } + continue; + } + if (lastResultAt.isAfter(cutoff)) { continue; } // 「客户端仍在推进」豁免:心跳位置文本还在变,说明采集主线程在干活,只是分片攒着没回传。 diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/collectdata/service/CollectDataService.java b/backend-java/src/main/java/com/nanri/aiimage/modules/collectdata/service/CollectDataService.java index 2a6cd8574..ffc943dfb 100644 --- a/backend-java/src/main/java/com/nanri/aiimage/modules/collectdata/service/CollectDataService.java +++ b/backend-java/src/main/java/com/nanri/aiimage/modules/collectdata/service/CollectDataService.java @@ -634,7 +634,27 @@ public class CollectDataService { } for (FileTaskEntity task : candidates) { LocalDateTime lastResultAt = lastResultAtByTaskId.get(task.getId()); - if (lastResultAt == null || lastResultAt.isAfter(cutoff)) { + if (lastResultAt == null) { + // 从未上报任何结果分片:原先与「上报仍新鲜」合并成静默 continue,是 2626 那型出口。 + // 现按「处理位置是否仍在推进」三分:在推进=首批较慢,跳过;位置久未变=判死并写清卡在哪; + // 无位置信息(老客户端 / 条目被 prune)=证据不足,保守跳过但留 WARN。 + String neverReportedPosition = taskHeartbeatPositionService.describe(task.getId()); + if (taskHeartbeatPositionService.isClientAdvancing(task.getId(), minutes)) { + log.info("[collect-data] never-reported skip because client still advancing taskId={} position={} minutes={}", + task.getId(), neverReportedPosition, minutes); + continue; + } + if (neverReportedPosition == null || neverReportedPosition.isBlank()) { + log.warn("[collect-data] never-reported skip without position evidence taskId={} createdAt={} minutes={}", + task.getId(), task.getCreatedAt(), minutes); + continue; + } + log.warn("[collect-data] never-reported but position stuck, failing taskId={} position={} minutes={}", + task.getId(), neverReportedPosition, minutes); + finalizeNoUploadStaleTask(task.getId(), null, neverReportedPosition, minutes); + continue; + } + if (lastResultAt.isAfter(cutoff)) { continue; } // 「客户端仍在推进」豁免:心跳位置文本还在变,说明采集主线程在干活,只是分片攒着没回传。 @@ -645,12 +665,12 @@ public class CollectDataService { task.getId(), lastResultAt, taskHeartbeatPositionService.describe(task.getId())); continue; } - finalizeNoUploadStaleTask(task.getId(), lastResultAt, minutes); + finalizeNoUploadStaleTask(task.getId(), lastResultAt, null, minutes); } } /** 单个任务的二次判死收尾:锁内复查心跳后,有分片→组装部分工作簿;无分片→标失败。 */ - private void finalizeNoUploadStaleTask(Long taskId, LocalDateTime lastResultAt, long minutes) { + private void finalizeNoUploadStaleTask(Long taskId, LocalDateTime lastResultAt, String position, long minutes) { try (TaskDistributedLockService.LockHandle lock = taskDistributedLockService.acquire(MODULE_TYPE, taskId, 0L)) { if (lock == null) { @@ -677,9 +697,7 @@ public class CollectDataService { taskId, lastResultAt, minutes, stats.finalRowCount); return; } - markTaskFailed(task, result, - "连续 " + minutes + " 分钟无结果回传,疑似客户端任务卡死,任务已自动失败(最后结果上报 " + lastResultAt + ")", - stats); + markTaskFailed(task, result, noUploadFailReason(minutes, lastResultAt, position), stats); log.warn("[collect-data] no-upload stale task failed without chunks taskId={} lastResultAt={} timeoutMinutes={}", taskId, lastResultAt, minutes); } catch (Exception ex) { @@ -688,6 +706,17 @@ public class CollectDataService { } } + /** 二次判死原因文案;从未上报与已有上报分开写(后者不能只说「最后结果上报 null」)。 */ + private String noUploadFailReason(long minutes, LocalDateTime lastResultAt, String position) { + if (lastResultAt == null) { + String where = position == null || position.isBlank() + ? "" : ",处理位置长时间停在「" + position + "」未推进"; + return "任务创建至今超过 " + minutes + " 分钟无任何结果回传" + where + + ",疑似客户端任务卡死,任务已自动失败"; + } + return "连续 " + minutes + " 分钟无结果回传,疑似客户端任务卡死,任务已自动失败(最后结果上报 " + lastResultAt + ")"; + } + public CollectDataDashboardVo dashboard(Long userId) { CollectDataDashboardVo vo = new CollectDataDashboardVo(); vo.setPendingTaskCount(countActiveTasks(userId)); diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/deletebrand/service/DeleteBrandStaleTaskService.java b/backend-java/src/main/java/com/nanri/aiimage/modules/deletebrand/service/DeleteBrandStaleTaskService.java index 5653eada6..6654f8a6e 100644 --- a/backend-java/src/main/java/com/nanri/aiimage/modules/deletebrand/service/DeleteBrandStaleTaskService.java +++ b/backend-java/src/main/java/com/nanri/aiimage/modules/deletebrand/service/DeleteBrandStaleTaskService.java @@ -760,7 +760,9 @@ public class DeleteBrandStaleTaskService { *
既有各模块心跳线的候选条件都是 updated_at 陈旧,而客户端心跳会持续刷新 updated_at——
* 主线程卡死(浏览器自动化等待/异常)时心跳线程照发,任务永远命不中(生产 28131 卡死 12h+ 仍 RUNNING)。
* 本线改用 biz_task_scope_state.last_chunk_at(只随结果分片上报刷新)作判据;
- * 无 scope 行或 last_chunk_at 全 NULL(从未上报)的任务跳过,避免误杀首批较慢的正常任务。
+ * 从未上报(无 scope 行或 last_chunk_at 全 NULL)不再无条件跳过——与上报停摆同样按处理位置三分:
+ * 仍在推进=首批较慢跳过、位置久未变=判死、无位置信息=证据不足保守跳过但留 WARN
+ * (原先的无条件跳过是 2026-10-06 品牌任务 2626 挂 9 小时的同类出口)。
*/
private NoResultUploadStaleCheckStats failNoResultUploadTasks() {
NoResultUploadStaleCheckStats stats = new NoResultUploadStaleCheckStats();
@@ -788,11 +790,32 @@ public class DeleteBrandStaleTaskService {
.collect(Collectors.toMap(TaskScopeLastChunkDto::taskId, TaskScopeLastChunkDto::lastChunkAt, (a, b) -> a));
for (FileTaskEntity task : candidates) {
LocalDateTime lastResultAt = lastResultAtByTaskId.get(task.getId());
- // 从未上报(无 scope 行或全 NULL)或上报仍新鲜:正常推进,不必处理
- if (lastResultAt == null || lastResultAt.isAfter(cutoff)) {
+ if (lastResultAt != null && lastResultAt.isAfter(cutoff)) {
+ // 上报仍新鲜:正常推进,不必处理
continue;
}
String moduleType = task.getModuleType();
+ if (lastResultAt == null) {
+ // 从未上报任何结果分片:原先与「上报仍新鲜」合并成一句静默 continue(零日志),
+ // 与 2026-10-06 品牌任务 2626 挂 9 小时是同一出口(本模块心跳同样照打)。
+ // 现按处理位置三分:在推进=首批较慢,跳过;位置久未变=判死并写清卡在哪;
+ // 无位置信息(老客户端 / 条目被 prune)=证据不足,保守跳过但留 WARN。
+ String neverReportedPosition = taskHeartbeatPositionService.describe(task.getId());
+ if (taskHeartbeatPositionService.isClientAdvancing(task.getId(), minutes)) {
+ stats.skippedTaskCount++;
+ log.info("[stale-check] no-upload never-reported skip because client still advancing taskId={} moduleType={} position={}",
+ task.getId(), moduleType, neverReportedPosition);
+ continue;
+ }
+ if (neverReportedPosition == null || neverReportedPosition.isBlank()) {
+ stats.skippedTaskCount++;
+ log.warn("[stale-check] no-upload never-reported skip without position evidence taskId={} moduleType={} createdAt={} timeoutMinutes={}",
+ task.getId(), moduleType, task.getCreatedAt(), minutes);
+ continue;
+ }
+ failNoResultUploadTask(moduleType, task, null, minutes, stats);
+ continue;
+ }
// 「客户端仍在推进」豁免:心跳位置文本还在变,说明采集主线程在干活,只是分片攒着没回传。
// 此时判死会把后续回传全部拒收、数据丢失(similar-asin 生产 28919:905 行丢失)。
// 位置长时间不变(真卡死)或无位置信息(老客户端)才继续走原判据。
@@ -802,47 +825,53 @@ public class DeleteBrandStaleTaskService {
task.getId(), moduleType, lastResultAt, taskHeartbeatPositionService.describe(task.getId()));
continue;
}
- if (hasPendingAssembleJobs(task.getId(), moduleType)) {
- stats.skippedTaskCount++;
- log.info("[stale-check] no-upload skip pending-assemble-jobs taskId={} moduleType={}", task.getId(), moduleType);
- continue;
- }
- TaskDistributedLockService.LockHandle taskLockHandle = acquireTaskLock(moduleType, task.getId());
- if (taskLockHandle == null) {
- stats.skippedTaskCount++;
- continue;
- }
- try (taskLockHandle) {
- try {
- tryFinalizeNoResultUploadTask(moduleType, task.getId());
- } catch (Exception ex) {
- // finalize 抛异常(组装失败等)不代表任务活着:继续走 CAS 判死
- log.warn("[stale-check] no-upload finalize threw taskId={} moduleType={} msg={}", task.getId(), moduleType, ex.getMessage());
- }
- // finalize 已终结的任务 CAS 自然不命中(状态不再是 RUNNING),无需回读
- String lastPosition = taskHeartbeatPositionService.describe(task.getId());
- int updated = fileTaskMapper.update(null, new LambdaUpdateWrapper 既有心跳线候选条件是 updated_at 陈旧,而客户端心跳会持续刷新 updated_at——
* 主线程卡死时心跳线程照发,任务永远命不中(与生产 28131 同型缺口)。
* owner 过滤与 A 线保持一致(避免双节点同时处理非本实例任务);
- * 判据用 biz_task_scope_state.last_chunk_at(仅分片上传时刷新);从未上报跳过,避免误杀首批较慢的正常任务。
+ * 判据用 biz_task_scope_state.last_chunk_at(仅分片上传时刷新);从未上报不再无条件跳过——
+ * 与上报停摆同样按处理位置三分:仍在推进=首批较慢跳过、位置久未变=判死、无位置信息=证据不足保守跳过但留 WARN
+ * (原先的无条件跳过是 2026-10-06 品牌任务 2626 挂 9 小时的同类出口)。
*/
private void failNoUploadStaleTasks() {
long minutes = noResultUploadTimeoutMinutes;
@@ -910,33 +914,66 @@ public class PublishTaskService {
}
for (FileTaskEntity candidate : candidates) {
LocalDateTime lastResultAt = lastResultAtByTaskId.get(candidate.getId());
- if (lastResultAt == null || lastResultAt.isAfter(cutoff)) {
+ if (lastResultAt != null && lastResultAt.isAfter(cutoff)) {
+ // 上报仍新鲜:正常推进,不必处理
continue;
}
- if (taskFileJobService.countUnfinishedAssembleJobs(candidate.getId(), MODULE_TYPE) > 0L) {
- continue;
- }
- try (TaskDistributedLockService.LockHandle lock =
- taskDistributedLockService.acquire(MODULE_TYPE, candidate.getId(), 0L)) {
- if (lock == null) {
+ if (lastResultAt == null) {
+ // 从未上报任何结果分片:原先与「上报仍新鲜」合并成一句静默 continue(零日志),
+ // 与 2026-10-06 品牌任务 2626 挂 9 小时是同一出口(本模块心跳同样照打)。
+ // 现按处理位置三分:在推进=首批较慢,跳过;位置久未变=判死并写清卡在哪;
+ // 无位置信息(老客户端 / 条目被 prune)=证据不足,保守跳过但留 WARN。
+ String neverReportedPosition = taskHeartbeatPositionService.describe(candidate.getId());
+ if (taskHeartbeatPositionService.isClientAdvancing(candidate.getId(), minutes)) {
+ log.info("[publish] 从未上报但客户端仍在推进,本轮不判死 taskId={} position={} minutes={}",
+ candidate.getId(), neverReportedPosition, minutes);
continue;
}
- String error = "连续 " + minutes + " 分钟无结果回传,疑似客户端任务卡死,任务已自动失败(最后结果上报 " + lastResultAt + ")";
- transactionTemplate.executeWithoutResult(status -> failStaleTaskLockedInternal(
- candidate.getId(),
+ if (neverReportedPosition == null || neverReportedPosition.isBlank()) {
+ log.warn("[publish] 从未上报且无位置信息,证据不足暂不判死 taskId={} createdAt={} minutes={}",
+ candidate.getId(), candidate.getCreatedAt(), minutes);
+ continue;
+ }
+ failNoUploadStaleTask(candidate,
+ "任务创建至今超过 " + minutes + " 分钟无任何结果回传,处理位置长时间停在「"
+ + neverReportedPosition + "」未推进,疑似客户端任务卡死,任务已自动失败",
task -> {
- // 排队期间复查:心跳回落陈旧 → 交回 A 线;出现新结果上报 → 任务已恢复
+ // 排队期间复查:心跳回落陈旧 → 交回 A 线;出现任一结果上报 → 已恢复回传,交回原线评估
if (task.getUpdatedAt() == null || task.getUpdatedAt().isBefore(heartbeatThreshold)) {
return false;
}
- LocalDateTime freshLastChunk = queryLastChunkAt(task.getId());
- return freshLastChunk != null && !freshLastChunk.isAfter(cutoff);
- },
- error));
- } catch (Exception ex) {
- log.warn("[publish] no-upload stale task cleanup failed taskId={} msg={}",
- candidate.getId(), ex.getMessage());
+ return queryLastChunkAt(task.getId()) == null;
+ });
+ continue;
}
+ failNoUploadStaleTask(candidate,
+ "连续 " + minutes + " 分钟无结果回传,疑似客户端任务卡死,任务已自动失败(最后结果上报 " + lastResultAt + ")",
+ task -> {
+ // 排队期间复查:心跳回落陈旧 → 交回 A 线;出现新结果上报 → 任务已恢复
+ if (task.getUpdatedAt() == null || task.getUpdatedAt().isBefore(heartbeatThreshold)) {
+ return false;
+ }
+ LocalDateTime freshLastChunk = queryLastChunkAt(task.getId());
+ return freshLastChunk != null && !freshLastChunk.isAfter(cutoff);
+ });
+ }
+ }
+
+ /** 二次判死共同尾部:待组装检查 → 任务锁 → 收尾;error 与复查谓词由两条路各自提供。 */
+ private void failNoUploadStaleTask(FileTaskEntity candidate, String error, Predicate 既有心跳线候选条件是心跳/updated_at 陈旧,而 Python 的 HTTP 心跳线程在任务主线程
* 卡死时照常发送——心跳永远新鲜,任务永远命不中(与生产 28131 同型缺口)。
* 本线候选取「心跳新鲜 + 创建超过 N 分钟」,判据用 biz_task_scope_state.last_chunk_at
- * (仅分片上传时刷新);从未上报(无 scope 行或全 NULL)的任务跳过,避免误杀首批较慢的正常任务。
+ * (仅分片上传时刷新);从未上报(无 scope 行或全 NULL)不再无条件跳过——与上报停摆同样
+ * 按处理位置三分:仍在推进=首批较慢跳过、位置久未变=判死、无位置信息=证据不足保守跳过但留 WARN
+ * (原先的无条件跳过是 2026-10-06 品牌任务 2626 挂 9 小时的同类出口)。
*/
private void finalizeNoUploadStaleTasks() {
long minutes = noResultUploadTimeoutMinutes;
@@ -264,30 +268,67 @@ public class ShopDataCrawlTaskService {
continue;
}
LocalDateTime lastResultAt = lastResultAtByTaskId.get(task.getId());
- if (lastResultAt == null || lastResultAt.isAfter(cutoff)) {
+ if (lastResultAt != null && lastResultAt.isAfter(cutoff)) {
+ // 上报仍新鲜:正常推进,不必处理
continue;
}
- TaskDistributedLockService.LockHandle taskLock = acquireTaskLock(task.getId(), 0L);
- if (taskLock == null) {
- log.info("[shop-data-crawl] no-upload stale task skipped because task lock is busy taskId={}", task.getId());
- continue;
- }
- try (taskLock) {
- if (taskFileJobService.countUnfinishedAssembleJobs(task.getId(), MODULE_TYPE) > 0L) continue;
- if (!tryFinalizeTask(task.getId(), true, true)) {
- markTaskFailedIfStillRunning(task.getId(),
- "连续 " + minutes + " 分钟无结果回传,疑似客户端任务卡死,任务已自动失败(最后结果上报 " + lastResultAt + ")");
+ if (lastResultAt == null) {
+ // 从未上报任何结果分片:原先与「上报仍新鲜」合并成一句静默 continue(零日志),
+ // 与 2026-10-06 品牌任务 2626 挂 9 小时是同一出口(本模块心跳同样照打)。
+ // 现按处理位置三分:在推进=首批较慢,跳过;位置久未变=判死并写清卡在哪;
+ // 无位置信息(老客户端 / 条目被 prune)=证据不足,保守跳过但留 WARN。
+ String neverReportedPosition = taskHeartbeatPositionService.describe(task.getId());
+ if (taskHeartbeatPositionService.isClientAdvancing(task.getId(), minutes)) {
+ log.info("[shop-data-crawl] 从未上报但客户端仍在推进,本轮不判死 taskId={} position={} minutes={}",
+ task.getId(), neverReportedPosition, minutes);
+ continue;
}
- log.warn("[shop-data-crawl] no-upload stale task finalized taskId={} lastResultAt={} timeoutMinutes={}",
- task.getId(), lastResultAt, minutes);
- } catch (TaskOwnerMismatchException ignored) {
- // The owner may change between the scan and finalization.
- } catch (Exception ex) {
- log.warn("[shop-data-crawl] no-upload stale task finalization failed taskId={} msg={}", task.getId(), ex.getMessage());
+ if (neverReportedPosition == null || neverReportedPosition.isBlank()) {
+ log.warn("[shop-data-crawl] 从未上报且无位置信息,证据不足暂不判死 taskId={} createdAt={} minutes={}",
+ task.getId(), task.getCreatedAt(), minutes);
+ continue;
+ }
+ failNoResultUploadTask(task, minutes, null, neverReportedPosition);
+ continue;
}
+ failNoResultUploadTask(task, minutes, lastResultAt, null);
}
}
+ /** 二次判死的共同尾部:任务锁 → 待组装检查 → 收尾;上报停摆与从未上报两条路共用。 */
+ private void failNoResultUploadTask(FileTaskEntity task, long minutes,
+ LocalDateTime lastResultAt, String neverReportedPosition) {
+ TaskDistributedLockService.LockHandle taskLock = acquireTaskLock(task.getId(), 0L);
+ if (taskLock == null) {
+ log.info("[shop-data-crawl] no-upload stale task skipped because task lock is busy taskId={}", task.getId());
+ return;
+ }
+ try (taskLock) {
+ if (taskFileJobService.countUnfinishedAssembleJobs(task.getId(), MODULE_TYPE) > 0L) return;
+ if (!tryFinalizeTask(task.getId(), true, true)) {
+ markTaskFailedIfStillRunning(task.getId(),
+ noUploadFailReason(minutes, lastResultAt, neverReportedPosition));
+ }
+ log.warn("[shop-data-crawl] no-upload stale task finalized taskId={} lastResultAt={} timeoutMinutes={}",
+ task.getId(), lastResultAt, minutes);
+ } catch (TaskOwnerMismatchException ignored) {
+ // The owner may change between the scan and finalization.
+ } catch (Exception ex) {
+ log.warn("[shop-data-crawl] no-upload stale task finalization failed taskId={} msg={}", task.getId(), ex.getMessage());
+ }
+ }
+
+ /** 二次判死原因文案;从未上报与已有上报分开写(后者不能只说「最后结果上报 null」)。 */
+ private String noUploadFailReason(long minutes, LocalDateTime lastResultAt, String neverReportedPosition) {
+ if (lastResultAt == null) {
+ String where = neverReportedPosition == null || neverReportedPosition.isBlank()
+ ? "" : ",处理位置长时间停在「" + neverReportedPosition + "」未推进";
+ return "任务创建至今超过 " + minutes + " 分钟无任何结果回传" + where
+ + ",疑似客户端任务卡死,任务已自动失败";
+ }
+ return "连续 " + minutes + " 分钟无结果回传,疑似客户端任务卡死,任务已自动失败(最后结果上报 " + lastResultAt + ")";
+ }
+
private FileTaskEntity loadTaskForExecution(Long taskId) {
return TaskFinalizeSupport.loadTaskForExecution(fileTaskMapper, taskCacheService, MODULE_TYPE, taskId);
}
diff --git a/backend-java/src/main/java/com/nanri/aiimage/modules/similarasin/service/SimilarAsinTaskService.java b/backend-java/src/main/java/com/nanri/aiimage/modules/similarasin/service/SimilarAsinTaskService.java
index 03a504d1b..600d80f7a 100644
--- a/backend-java/src/main/java/com/nanri/aiimage/modules/similarasin/service/SimilarAsinTaskService.java
+++ b/backend-java/src/main/java/com/nanri/aiimage/modules/similarasin/service/SimilarAsinTaskService.java
@@ -972,7 +972,9 @@ public class SimilarAsinTaskService implements SimilarAsinPipelineHost {
* 每分钟刷新——主线程卡死时心跳线程照发,任务永远不 stale(与生产 28131 同型缺口)。
* 本线改看 biz_task_scope_state.last_chunk_at(仅在 persistSubmittedChunk 上传分片时刷新),
* 命中后走既有 finalizeStaleTask(封口上传 + LLM 收尾,不粗暴杀任务)。
- * 从未上报(无 scope 行或全 NULL)的任务跳过,避免误杀首批较慢的正常任务。
+ * 从未上报(无 scope 行或全 NULL)不再无条件跳过——与上报停摆同样按处理位置三分:
+ * 仍在推进=首批较慢跳过、位置久未变=判死、无位置信息=证据不足保守跳过但留 WARN
+ * (原先的无条件跳过是 2026-10-06 品牌任务 2626 挂 9 小时的同类出口)。
*/
private void finalizeNoUploadStaleTasks() {
long minutes = properties.getNoResultUploadTimeoutMinutes();
@@ -1000,7 +1002,39 @@ public class SimilarAsinTaskService implements SimilarAsinPipelineHost {
continue;
}
LocalDateTime lastResultAt = lastResultAtByTaskId.get(task.getId());
- if (lastResultAt == null || lastResultAt.isAfter(cutoff)) {
+ if (lastResultAt == null) {
+ // 从未上报任何结果分片:原先与「上报仍新鲜」合并成一句静默 continue(零日志),
+ // 与 2026-10-06 品牌任务 2626 挂 9 小时是同一出口(本模块心跳同样照打)。
+ // 现按处理位置三分:在推进=首批较慢,跳过;位置久未变=判死并写清卡在哪;
+ // 无位置信息(老客户端 / 条目被 prune)=证据不足,保守跳过但留 WARN。
+ String neverReportedPosition = taskHeartbeatPositionService.describe(task.getId());
+ TaskHeartbeatPositionService.StallState neverReportedStall =
+ taskHeartbeatPositionService.evaluateStall(task.getId(), minutes);
+ if (neverReportedStall == TaskHeartbeatPositionService.StallState.ADVANCING) {
+ log.info("[similar-asin] 从未上报但客户端仍在推进,本轮不封口 taskId={} position={} minutes={}",
+ task.getId(), neverReportedPosition, minutes);
+ continue;
+ }
+ if (neverReportedPosition == null || neverReportedPosition.isBlank()) {
+ log.warn("[similar-asin] 从未上报且无位置信息,证据不足暂不封口 taskId={} createdAt={} minutes={}",
+ task.getId(), task.getCreatedAt(), minutes);
+ continue;
+ }
+ TaskDistributedLockService.LockHandle neverReportedLock =
+ ownershipSupport().acquireTaskLock(task.getId(), 0L);
+ if (neverReportedLock == null) {
+ continue;
+ }
+ try (neverReportedLock) {
+ log.warn("[similar-asin] 从未上报任何结果分片且处理位置长时间停在「{}」未推进,按卡死收尾 taskId={} minutes={}",
+ neverReportedPosition, task.getId(), minutes);
+ finalizeStaleTask(task.getId(),
+ "任务创建至今超过 " + minutes + " 分钟无任何结果回传,处理位置长时间停在「"
+ + neverReportedPosition + "」未推进,疑似客户端任务卡死,任务已自动失败");
+ }
+ continue;
+ }
+ if (lastResultAt.isAfter(cutoff)) {
continue;
}
// 「客户端仍在推进」豁免:位置文本还在变说明采集主线程在干活,只是分片攒着没回传
diff --git a/backend-java/src/test/java/com/nanri/aiimage/modules/appearancepatent/service/AppearancePatentNoUploadStaleTest.java b/backend-java/src/test/java/com/nanri/aiimage/modules/appearancepatent/service/AppearancePatentNoUploadStaleTest.java
new file mode 100644
index 000000000..50751e833
--- /dev/null
+++ b/backend-java/src/test/java/com/nanri/aiimage/modules/appearancepatent/service/AppearancePatentNoUploadStaleTest.java
@@ -0,0 +1,124 @@
+package com.nanri.aiimage.modules.appearancepatent.service;
+
+import com.baomidou.mybatisplus.core.MybatisConfiguration;
+import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
+import com.nanri.aiimage.config.AppearancePatentProperties;
+import com.nanri.aiimage.modules.task.mapper.FileTaskMapper;
+import com.nanri.aiimage.modules.task.mapper.TaskScopeStateMapper;
+import com.nanri.aiimage.modules.task.model.entity.FileTaskEntity;
+import com.nanri.aiimage.modules.task.service.TaskDistributedLockService;
+import com.nanri.aiimage.modules.task.service.TaskHeartbeatPositionService;
+import org.apache.ibatis.builder.MapperBuilderAssistant;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.test.util.ReflectionTestUtils;
+
+import java.time.Duration;
+import java.time.LocalDateTime;
+import java.util.List;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyLong;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+/**
+ * appearance-patent 二次判死线「从未上报」出口的三分行为(2026-10-06 品牌任务 2626 同型缺口)。
+ *
+ * 原先「从未上报任何结果分片」与「上报仍新鲜」合并成一句静默 continue(零日志),
+ * 心跳照打的任务可以无限期挂着。现按处理位置三分:仍在推进=跳过、位置久未变=判死、
+ * 无位置信息=证据不足保守跳过但留 WARN。判死细节(封口文案等)由 finalizeStaleTask 既有链路承接,
+ * 本测试以「是否进入抢锁判死」为界。
+ */
+@ExtendWith(MockitoExtension.class)
+class AppearancePatentNoUploadStaleTest {
+
+ private static final long TASK_ID = 91001L;
+
+ @Mock private FileTaskMapper fileTaskMapper;
+ @Mock private TaskScopeStateMapper taskScopeStateMapper;
+ @Mock private AppearancePatentTaskCacheService taskCacheService;
+ @Mock private AppearancePatentProperties properties;
+ @Mock private TaskDistributedLockService taskDistributedLockService;
+ @Mock private TaskHeartbeatPositionService taskHeartbeatPositionService;
+
+ @InjectMocks private AppearancePatentTaskService service;
+
+ @BeforeAll
+ static void initializeTableInfo() {
+ TableInfoHelper.initTableInfo(
+ new MapperBuilderAssistant(new MybatisConfiguration(), ""),
+ FileTaskEntity.class);
+ }
+
+ @BeforeEach
+ void setUp() {
+ when(properties.getNoResultUploadTimeoutMinutes()).thenReturn(180);
+ when(properties.getStaleTimeoutMinutes()).thenReturn(30);
+ }
+
+ private FileTaskEntity runningTask() {
+ FileTaskEntity task = new FileTaskEntity();
+ task.setId(TASK_ID);
+ task.setModuleType(AppearancePatentTaskService.MODULE_TYPE);
+ task.setStatus("RUNNING");
+ task.setCreatedAt(LocalDateTime.now().minusDays(1));
+ task.setUpdatedAt(LocalDateTime.now().minusMinutes(1));
+ return task;
+ }
+
+ /** 心跳新鲜 + 无任何结果分片上报(scope 行为空)= 「从未上报」候选。 */
+ private void givenNeverReported() {
+ when(fileTaskMapper.selectList(any())).thenReturn(List.of(runningTask()));
+ when(taskCacheService.getTaskHeartbeatMillis(TASK_ID)).thenReturn(System.currentTimeMillis());
+ when(taskScopeStateMapper.selectLastChunkAtByTaskIds(any())).thenReturn(List.of());
+ }
+
+ private void invokeNoUploadCheck() {
+ ReflectionTestUtils.invokeMethod(service, "finalizeNoUploadStaleTasks");
+ }
+
+ /** 从未上报 + 位置久未推进 = 2626 同型真卡死,进入抢锁判死流程。 */
+ @Test
+ void 从未上报但位置停滞时按卡死收尾() {
+ givenNeverReported();
+ when(taskHeartbeatPositionService.describe(TASK_ID)).thenReturn("ASIN B01A / 美国");
+ when(taskHeartbeatPositionService.isClientAdvancing(TASK_ID, 180L)).thenReturn(false);
+ when(taskDistributedLockService.acquire(anyString(), anyLong(), any(Duration.class), anyLong()))
+ .thenReturn(null);
+
+ invokeNoUploadCheck();
+
+ // 已进入判死流程(开始抢锁);锁被占则本轮放弃
+ verify(taskDistributedLockService).acquire(anyString(), anyLong(), any(Duration.class), anyLong());
+ }
+
+ /** 从未上报 + 位置仍在推进 = 首批较慢,不封口(否则拒收后续分片丢数据)。 */
+ @Test
+ void 从未上报但客户端仍在推进时不封口() {
+ givenNeverReported();
+ when(taskHeartbeatPositionService.describe(TASK_ID)).thenReturn("ASIN B01A / 美国");
+ when(taskHeartbeatPositionService.isClientAdvancing(TASK_ID, 180L)).thenReturn(true);
+
+ invokeNoUploadCheck();
+
+ verify(taskDistributedLockService, never()).acquire(anyString(), anyLong(), any(Duration.class), anyLong());
+ }
+
+ /** 从未上报 + 无位置信息(老客户端/条目被 prune)= 证据不足,保守跳过但留 WARN。 */
+ @Test
+ void 从未上报且无位置信息时保守跳过() {
+ givenNeverReported();
+
+ invokeNoUploadCheck();
+
+ verify(taskDistributedLockService, never()).acquire(anyString(), anyLong(), any(Duration.class), anyLong());
+ }
+}
diff --git a/backend-java/src/test/java/com/nanri/aiimage/modules/collectdata/service/CollectDataNoUploadStaleTest.java b/backend-java/src/test/java/com/nanri/aiimage/modules/collectdata/service/CollectDataNoUploadStaleTest.java
index f59bc9dba..9b8aac55c 100644
--- a/backend-java/src/test/java/com/nanri/aiimage/modules/collectdata/service/CollectDataNoUploadStaleTest.java
+++ b/backend-java/src/test/java/com/nanri/aiimage/modules/collectdata/service/CollectDataNoUploadStaleTest.java
@@ -92,7 +92,7 @@ class CollectDataNoUploadStaleTest {
}
@Test
- void 从未上报时跳过() {
+ void 从未上报且无位置信息时保守跳过() {
when(fileTaskMapper.selectList(any())).thenReturn(List.of(runningTask(2L)));
when(taskScopeStateMapper.selectLastChunkAtByTaskIds(any())).thenReturn(List.of());
@@ -143,4 +143,42 @@ class CollectDataNoUploadStaleTest {
assertTrue(taskCaptor.getValue().getErrorMessage().contains("无结果回传"),
taskCaptor.getValue().getErrorMessage());
}
+
+ /** 从未上报(无 scope 行)+ 位置久未推进 = 2626 同型真卡死,判死并在文案里写清卡在哪。 */
+ @Test
+ void 从未上报但位置久未推进时判死() {
+ FileTaskEntity task = runningTask(4L);
+ when(fileTaskMapper.selectList(any())).thenReturn(List.of(task));
+ when(taskScopeStateMapper.selectLastChunkAtByTaskIds(any())).thenReturn(List.of());
+ when(taskHeartbeatPositionService.describe(4L)).thenReturn("分页 3/10(共 10 页)");
+ when(taskHeartbeatPositionService.isClientAdvancing(4L, 180L)).thenReturn(false);
+ when(taskDistributedLockService.acquire(any(), anyLong(), anyLong())).thenReturn(lockHandle);
+ when(fileTaskMapper.selectById(4L)).thenReturn(task);
+ when(taskFileJobService.countUnfinishedAssembleJobs(4L, "COLLECT_DATA")).thenReturn(0L);
+ when(taskChunkMapper.selectCount(any())).thenReturn(0L);
+ when(fileResultMapper.selectOne(any())).thenReturn(null);
+
+ invokeNoUpload();
+
+ ArgumentCaptor 原先「从未上报任何结果分片」与「上报仍新鲜」合并成一句静默 continue(零日志),
+ * 心跳照打的任务可以无限期挂着。现按处理位置三分:仍在推进=跳过、位置久未变=判死、
+ * 无位置信息=证据不足保守跳过但留 WARN。
+ */
+@ExtendWith(MockitoExtension.class)
+class PublishNoUploadStaleTest {
+
+ private static final long TASK_ID = 2601L;
+
+ @BeforeAll
+ static void initializeMybatisMetadata() {
+ MapperBuilderAssistant assistant = new MapperBuilderAssistant(new MybatisConfiguration(), "");
+ TableInfoHelper.initTableInfo(assistant, FileTaskEntity.class);
+ TableInfoHelper.initTableInfo(assistant, FileResultEntity.class);
+ TableInfoHelper.initTableInfo(assistant, PublishFileEntity.class);
+ TableInfoHelper.initTableInfo(assistant, PublishItemEntity.class);
+ TableInfoHelper.initTableInfo(assistant, TaskChunkEntity.class);
+ TableInfoHelper.initTableInfo(assistant, TaskScopeStateEntity.class);
+ }
+
+ @Mock private LocalFileStorageService localFileStorageService;
+ @Mock private ZiniaoShopSwitchService ziniaoShopSwitchService;
+ @Mock private PublishWorkbookService workbookService;
+ @Mock private PublishFileMapper publishFileMapper;
+ @Mock private PublishItemMapper publishItemMapper;
+ @Mock private FileTaskMapper fileTaskMapper;
+ @Mock private FileResultMapper fileResultMapper;
+ @Mock private TaskChunkMapper taskChunkMapper;
+ @Mock private TaskScopeStateMapper taskScopeStateMapper;
+ @Mock private TaskFileJobService taskFileJobService;
+ @Mock private TaskDistributedLockService taskDistributedLockService;
+ @Mock private DistributedJobLockService distributedJobLockService;
+ @Mock private TransientPayloadStorageService transientPayloadStorageService;
+ @Mock private OssStorageService ossStorageService;
+ @Spy private ObjectMapper objectMapper = new ObjectMapper();
+ @Mock private TransactionTemplate transactionTemplate;
+ @Mock private InstanceMetadata instanceMetadata;
+ @Mock private com.nanri.aiimage.modules.task.service.TaskProgressLightAssembler taskProgressLightAssembler;
+ @Mock private TaskHeartbeatPositionService taskHeartbeatPositionService;
+
+ @InjectMocks private PublishTaskService service;
+
+ @BeforeEach
+ void setUp() {
+ ReflectionTestUtils.setField(service, "noResultUploadTimeoutMinutes", 180);
+ ReflectionTestUtils.setField(service, "staleTimeoutMinutes", 30);
+ lenient().when(instanceMetadata.getInstanceId()).thenReturn("instance-a");
+ lenient().doAnswer(invocation -> {
+ Consumer 原先「从未上报任何结果分片」与「上报仍新鲜」合并成一句静默 continue(零日志),
+ * 与 2026-10-06 品牌任务 2626 挂 9 小时是同一出口。现按处理位置三分:仍在推进=跳过、
+ * 位置久未变=判死(CAS 翻转并在文案里写清卡在哪)、无位置信息=证据不足保守跳过但留 WARN。
+ */
+@ExtendWith(MockitoExtension.class)
+class ShopDataCrawlNoUploadStaleTest {
+
+ private static final long TASK_ID = 88001L;
+
+ @Mock private FileTaskMapper fileTaskMapper;
+ @Mock private FileResultMapper fileResultMapper;
+ @Mock private TaskChunkMapper taskChunkMapper;
+ @Mock private TaskScopeStateMapper taskScopeStateMapper;
+ @Mock private ShopDataCrawlTaskCacheService taskCacheService;
+ @Mock private TaskFileJobService taskFileJobService;
+ @Mock private TaskDistributedLockService taskDistributedLockService;
+ @Mock private TaskHeartbeatPositionService taskHeartbeatPositionService;
+
+ @InjectMocks private ShopDataCrawlTaskService service;
+
+ @BeforeAll
+ static void initializeTableInfo() {
+ MapperBuilderAssistant assistant = new MapperBuilderAssistant(new MybatisConfiguration(), "");
+ TableInfoHelper.initTableInfo(assistant, FileTaskEntity.class);
+ TableInfoHelper.initTableInfo(assistant, FileResultEntity.class);
+ TableInfoHelper.initTableInfo(assistant, TaskChunkEntity.class);
+ TableInfoHelper.initTableInfo(assistant, TaskScopeStateEntity.class);
+ }
+
+ @BeforeEach
+ void setUp() {
+ ReflectionTestUtils.setField(service, "noResultUploadTimeoutMinutes", 180L);
+ ReflectionTestUtils.setField(service, "staleTimeoutMinutes", 30L);
+ }
+
+ private FileTaskEntity runningTask() {
+ FileTaskEntity task = new FileTaskEntity();
+ task.setId(TASK_ID);
+ task.setModuleType("SHOP_DATA_CRAWL");
+ task.setStatus("RUNNING");
+ task.setCreatedAt(LocalDateTime.now().minusDays(1));
+ task.setUpdatedAt(LocalDateTime.now().minusMinutes(1));
+ return task;
+ }
+
+ /** 心跳新鲜 + 无任何结果分片上报(scope 行为空)= 「从未上报」候选。 */
+ private void givenNeverReported() {
+ when(fileTaskMapper.selectList(any())).thenReturn(List.of(runningTask()));
+ when(taskCacheService.getTaskHeartbeatMillisBatch(any()))
+ .thenReturn(Map.of(TASK_ID, System.currentTimeMillis()));
+ when(taskScopeStateMapper.selectLastChunkAtByTaskIds(any())).thenReturn(List.of());
+ }
+
+ private void invokeNoUploadCheck() {
+ ReflectionTestUtils.invokeMethod(service, "finalizeNoUploadStaleTasks");
+ }
+
+ /** 从未上报 + 位置久未推进 = 2626 同型真卡死,CAS 翻转并在文案里写清卡在哪。 */
+ @Test
+ void 从未上报且位置停滞时判死并写清卡住位置() {
+ givenNeverReported();
+ when(taskHeartbeatPositionService.describe(TASK_ID)).thenReturn("分页 3/10(共 10 页)");
+ when(taskHeartbeatPositionService.isClientAdvancing(TASK_ID, 180L)).thenReturn(false);
+ when(taskDistributedLockService.acquire(anyString(), anyLong(), anyLong()))
+ .thenReturn(mock(TaskDistributedLockService.LockHandle.class));
+ when(taskFileJobService.countUnfinishedAssembleJobs(TASK_ID, "SHOP_DATA_CRAWL")).thenReturn(0L);
+ // tryFinalizeTask 内部:缓存命中 RUNNING 任务,但无结果行 → 返回 false(走 CAS 判死)
+ when(taskCacheService.getTaskCacheBatch(List.of(TASK_ID))).thenReturn(Map.of(TASK_ID, runningTask()));
+ when(fileResultMapper.selectList(any())).thenReturn(List.of());
+ when(fileTaskMapper.update(isNull(), any(LambdaUpdateWrapper.class))).thenReturn(1);
+ when(taskChunkMapper.selectList(any())).thenReturn(List.of());
+
+ invokeNoUploadCheck();
+
+ @SuppressWarnings({"rawtypes", "unchecked"})
+ ArgumentCaptor