889 lines
73 KiB
Java
889 lines
73 KiB
Java
package com.nanri.aiimage.config;
|
||
|
||
import com.nanri.aiimage.config.SilentCatchScanner.Kind;
|
||
import com.nanri.aiimage.config.SilentCatchScanner.Result;
|
||
import com.nanri.aiimage.config.SilentCatchScanner.Site;
|
||
import org.junit.jupiter.api.Test;
|
||
|
||
import java.io.IOException;
|
||
import java.io.UncheckedIOException;
|
||
import java.nio.charset.StandardCharsets;
|
||
import java.nio.file.Files;
|
||
import java.nio.file.Path;
|
||
import java.util.LinkedHashMap;
|
||
import java.util.List;
|
||
import java.util.Map;
|
||
|
||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||
import static org.junit.jupiter.api.Assertions.assertFalse;
|
||
import static org.junit.jupiter.api.Assertions.assertNotEquals;
|
||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||
|
||
/**
|
||
* catch 静默形状的**只许减**棘轮。
|
||
*
|
||
* <p>统计三件事(口径写死在这里,防止又变成"把文件数当处数"):
|
||
* <ul>
|
||
* <li>统计命令:{@code SilentCatchScanner.scanTree(src/main/java)}(本类的 {@link #TREE});</li>
|
||
* <li>分母是哪棵树:{@code crawler-plugin/backend-java/src/main/java} 工作树,只算 {@code *.java};</li>
|
||
* <li>单位:处(一个 catch 块 = 一处)。</li>
|
||
* </ul>
|
||
*
|
||
* <p>基线来源:2026-10-08 12:0x 实测(HEAD {@code 274ad017})total=1000 / 不重抛=559 /
|
||
* 只 log=249 / 空体=56。本轮改动往 main 里加了 **1 处** catch(拒起闸门读基线时的
|
||
* {@code catch (IOException e} ⇒ 重抛成 IllegalStateException),它是 RETHROW 形状、
|
||
* 不进气味三格,所以 total 基线随之从 1000 抬到 1001;那三格的基线一个字没动。
|
||
*
|
||
* <p>"只 log" 这一格本轮按严格口径重测得 <b>172</b>(块内每条顶层语句都是 log 调用才算),
|
||
* 低于用户给的 249——两边口径不同(宽松版把"log + 紧跟 return null"也算进去)。
|
||
* 这里两条都钉:≤249 是验收口径,≤172 是本轮严格口径的实测值,
|
||
* 免得日后有人拿"249 还没用完"当额度往里加只 log 的吞异常块。
|
||
*/
|
||
class CatchSilenceRatchetTest {
|
||
|
||
/** 分母树:main 源码树(不含测试树——测试里的 catch 是夹具,不是现网出口)。 */
|
||
private static final Path TREE = moduleRoot().resolve("src/main/java");
|
||
|
||
// ==== 验收基线(用户 2026-10-08 12:0x 实测,HEAD 274ad017,单位:处)====
|
||
// 10-17 心跳证据两处 fail-open 抬 559 -> 561,逐处出处见 STRICT_NOT_RETHROW 上方注释。
|
||
// 10-18 外观专利失败兜底自吞抬 561 -> 562,逐处出处同下。
|
||
// 10-24 损耗监控三处带锚点的 fail-open 抬 562 -> 564,逐处出处见 STRICT_NOT_RETHROW 上方注释。
|
||
// 10-25 B15 join 无界收口抬 564 -> 569,逐处出处见 STRICT_NOT_RETHROW 上方注释。
|
||
// 10-26 第二轮 CR-Fix 2 抬 569 -> 573,逐处出处见 STRICT_NOT_RETHROW 上方注释(4 处必要 fail-open)。
|
||
static final int GIVEN_TOTAL = 1000;
|
||
// 10-27 「整表都要跑完」专项抬 573 -> 577(2 枚新增不重抛 + 2 枚既有整批抛出改逐条跳过,逐处记名见 STRICT_TOTAL 上方)。
|
||
// 10-27 同日第二批抬 577 -> 579(批量入库逐批容错+folder 去重逐条目容错,两处都是 log.warn+计数+continue,
|
||
// 逐处记名见 STRICT_TOTAL 上方注释)。
|
||
// 10-28 V179 采集被过滤行追溯抬 579 -> 582(审计件三枚:逐批插入容错/回流簿记容错/尾 sheet 降级,
|
||
// 逐处记名见 STRICT_TOTAL 上方注释)。
|
||
// 10-28 Phase 3 抬 582 -> 585(心跳降级一枚 + 优雅停机两枚中断恢复,逐处记名见 STRICT_TOTAL 上方注释)。
|
||
// 10-29 Phase 4D 抬 585 -> 591(AC-17 分片通道六枚 LOG_ONLY:清理/收尾失败不得盖掉主错误,
|
||
// 逐处记名见 STRICT_TOTAL 上方注释;EMPTY 一格没涨)。
|
||
// 10-30 用户端代理白名单(极客/青果)抬 591 -> 598(7 处逐一记名见 STRICT_TOTAL 上方注释;
|
||
// 实测量到 599,多出的 1 格来自已提交的 79b04afd(AdminApiGuardFilter 编码绕过 catch),见同处说明)。
|
||
// 10-31 Phase 5.1:证据登记失败回收对象一枚(内层回收失败只 WARN),599 -> 600。
|
||
// 10-31 CR 消项:证据保留期清理失败 WARN 兜底 + 任务号溢出回落 task_no,新增 2 处非抛分支,600 -> 602。
|
||
// 11-01 失败任务原任务重试:TaskInPlaceRetryService 的 clearResultError / resetAssembleJob
|
||
// 两处 WARN 兜底,602 -> 604(logOnly 249 -> 251;严格格 STRICT_LOG_ONLY 190 -> 192)。
|
||
// 11-05 密钥余额三面(龙抬头 credits/后管实时查)抬 604 -> 608:五枚新增**全是 NOT_RETHROW**,
|
||
// LOG_ONLY 与 EMPTY 一格没涨(逐处记名见 STRICT_TOTAL 上方注释)——改的是"查不到"怎么表达,不是把它藏起来。
|
||
// 11-10 v1.3 外观专利无侵权同步链抬 608 -> 611:三枚不重抛(同步服务两枚+控制器内部令牌回退一枚),
|
||
// 逐处记名见 STRICT_TOTAL 上方注释;LOG_ONLY 宽口径格 251 没动(宽口径实测已落到 193,离上限很远)。
|
||
// 11-14 v1.4 京东数据库抬 611 -> 615:三枚不重抛(Phase 5 后管两处 resolveInternalOperator 返回 null
|
||
// + parseAttrGroups 的 attr_json 兜底;Phase 2/4 的 7 枚全是 RETHROW、Phase 2 的 scope 行
|
||
// DuplicateKeyException 是 LOG_ONLY,都不占本格),逐处记名见 STRICT_TOTAL 上方注释;
|
||
// LOG_ONLY 宽口径格 251 没动(宽口径实测 194,离上限很远)。
|
||
// 11-14 v1.5「获取店铺数据」进度条抬 615 -> 616:一枚不重抛(进度查询读 scope.state_json
|
||
// 失败 log.warn + 空对象),逐处记名与误差方向见 STRICT_TOTAL 上方注释;LOG_ONLY 一格没动。
|
||
// 11-15 京东 B101/B102 收口抬 616 -> 619:三枚不重抛含 log(JdProductQueryService SKU 组合解析
|
||
// 与 JdResultIngestService 单行 SKU 跳过两枚落 LOG_ONLY、JdProductSkuIngestService.writeJson
|
||
// 序列化是 log+return),出处与误差方向逐处见 STRICT_TOTAL 上方 11-15 段;EMPTY 一格没涨。
|
||
static final int GIVEN_NOT_RETHROW = 619;
|
||
static final int GIVEN_LOG_ONLY = 251;
|
||
static final int GIVEN_EMPTY = 56;
|
||
|
||
// ==== 本轮严格口径重测(SilentCatchScanner 在同一棵树上跑出来的四个数)====
|
||
// total 里含本轮拒起闸门新加的那 1 处:它是 RETHROW 形状(catch (IOException e) ⇒ 抛 IllegalState),
|
||
// 所以 rethrow 385→386、total 1000→1001,而气味三格一个都没动:
|
||
// notRethrow 559、empty 56 与验收基线**逐字相同**,这就是两套口径互为对账的证据。
|
||
/**
|
||
* 1000(验收基线)+ 拒起闸门那批新增的 1 处 + {@code BuildInfoLogger.read()} 的 1 处 = 1002。
|
||
* BuildInfoLogger 那一处不是吞掉:它打 {@code [build-info-missing]} 的 WARN 并返回可区分的
|
||
* "章存在但没盖住"状态,巡检按锚点数得到。抬这一格是为了把出处留在这份 diff 里,
|
||
* 而不是让后来人以为基线是自然涨上来的。
|
||
* 10-17 再 +2,逐处记名:{@code TaskHeartbeatLivenessService.stamp()}(心跳证据写失败只 WARN,
|
||
* 心跳接口不许因证据写不下去而 500)与同类 {@code lastHeartbeatMillis()}(读证据失败一律落到 0=
|
||
* 「没有证据」,判死线据此放宽)。两处都是 fail-open 且方向是「少杀一个任务」,与上面
|
||
* BuildInfoLogger 同形状;本仓实测基线由 1001 起(原记 1002 留有 1 格无人认领的额度),
|
||
* 加这 2 处后实测 1003。
|
||
* 10-18 再 +1:{@code AppearancePatentTaskService.fallbackAssembleResultFile()} 的兜底自吞
|
||
* (log.warn + return false)——{@code ResultFileJobHandler#fallbackAssembleOnFailure} 的接口
|
||
* 契约明确要求「实现应自吞异常(兜底失败只记日志,不影响 job 已终态失败的事实)」,与
|
||
* DeleteBrandRunService 同名兜底同形状;Worker 侧另有 catch 双保险,让判死作业的兜底每轮
|
||
* stuck 扫描幂等重入。实测 1004。
|
||
* 10-24 损耗监控(cost-guard)本笔新增 6 处,逐处点名(同批先写后摘、没留在树上的 6 处:
|
||
* SHA-256 指纹改走 {@code DigestUtil.sha256Hex}、env 读数改纯正则前置校验、共享密钥扫描的
|
||
* 自吞交给 {@code scan()} 已有的那枚、当日用量读数改成直接抛(客户端把轮询失败当
|
||
* 「维持上一次读数」处理,比伪造一组零值诚实)、{@code resume()} 的吞异常改成外抛——
|
||
* 它返回 false 时控制器仍回「已继续任务」,那是假成功):
|
||
* <ul>
|
||
* <li>{@code LlmKeyGate.Gate.acquire()} 两枚:{@code InterruptedException} ⇒ 复位中断位并重抛
|
||
* IllegalStateException;{@code RuntimeException} ⇒ 先 {@code permits.release()} 再原样重抛,
|
||
* 少了这一处排队令牌就永久漏一个(两枚都是 RETHROW 形状);</li>
|
||
* <li>{@code LlmKeyGate.Gate.waitForInterval()} 一枚:同为 InterruptedException 重抛形状;</li>
|
||
* <li>{@code CostGuardScheduler.scan()} 一枚:调度线程整轮异常只打 {@code [cost-guard]} WARN,
|
||
* 下一轮照跑——让它抛出等于这条监控自己变成噪声源;</li>
|
||
* <li>{@code UserTaskGuardService.pause()} 一枚:单个账号的暂停写失败不能中止整轮扫描
|
||
* (否则排在这之后的账号这轮全不被检查),下一轮还会再判一次;</li>
|
||
* <li>{@code UserTaskGuardService.load()} 一枚:读不到闸门状态按「未暂停」走——数据库抖动
|
||
* 不该把全体用户的合法任务一起冻住,真失控由下一轮重新置位。</li>
|
||
* </ul>
|
||
* 本格实测 1004:这 6 处落进的是 1004 之前已被更早删腾出、无人认领的额度里(上一笔整树实测
|
||
* 997,见 RETHROW_FLOOR 上方),所以基线不抬反而按实测收到 1003;**再 +1 是同一时段
|
||
* {@code ba20f5ed feat(workbench-client)} 那枚新增 catch,不属本批、也未由本批记名**,
|
||
* 该由那一笔自己把出处补进这份 diff。每一处本批的新增都在这里点名。
|
||
* 不重抛/只 log/空体三格上限一个字没动。
|
||
*
|
||
* <p>10-24 Phase 7 EasyExcel→POI 收口再 +4,逐处点名(全部是 RETHROW 形状,气味三格未动):
|
||
* <ul>
|
||
* <li>{@code ExcelStreamReader.readOoxml} 三枚:{@code OpenXML4JException}(坏包)、
|
||
* {@code SAXException}(sheet XML 坏了)、{@code RuntimeException}(POI 解析期异常)
|
||
* 全部经 {@code toContractException} 转成 IOException 或原样重抛,不吞;</li>
|
||
* <li>{@code ExcelStreamReader.readHssf} 一枚:{@code RuntimeException} 同上收口。</li>
|
||
* </ul>
|
||
* 这 4 处是替换 EasyExcel 监听器后的等价出口(原实现的 catch 只在 {@code runRead} 一处,
|
||
* 但监听器内部另有 POI 的异常分诊);实测 total 1008。
|
||
*
|
||
* <p>10-25 B15 任务活性收口再 +10(同时替换掉 2 处 join 侧的旧 catch,整树实测 1015),
|
||
* 逐处点名——{@code join()} 没有时间界,下面四类出口改成带截止的等待后,超时必须各有去处:
|
||
* <ul>
|
||
* <li>{@code FutureDeadline.await} 一枚:超时先 cancel 该 future,再重抛带标签的
|
||
* TimeoutException(RETHROW);</li>
|
||
* <li>{@code AppearancePatentLlmClient.runBatches} 两枚:超时/执行失败与中断都收口成该批
|
||
* {@code BatchOutcome} 失败(NOT_RETHROW,替换原来那一枚 {@code catch (Exception)});</li>
|
||
* <li>{@code BrandTaskService.buildAndUploadResult} 三枚:超时/中断/执行失败按 IOException
|
||
* 或原异常重抛(RETHROW,替换原来那一枚 {@code catch (CompletionException)});</li>
|
||
* <li>{@code SimilarAsinLlmService} 的类目与合规两个 prepass 各两枚:超时/执行失败只 WARN
|
||
* 并继续(LOG_ONLY),中断复位中断位后退出等待(NOT_RETHROW)。这两处预计算本就是
|
||
* 逐行链路的缓存,缺结果的行会走单行回退,所以等待侧超时不需要炸掉整条任务。</li>
|
||
* </ul>
|
||
* 同批实测 notRethrow 569、logOnly 176、empty 56;气味三格只按这三处实测值抬,形状未放宽。
|
||
*
|
||
* <p>10-26 抬 1015 -> 1024(第二轮 CR-Fix 2,共 9 处新增 catch,逐处记名):
|
||
* <ul>
|
||
* <li>{@code WorkbenchClientPackageService.confirmPackage} 一枚:{@code DuplicateKeyException}
|
||
* 并发冲突按 objectKey 幂等或转业务错误(RETHROW);</li>
|
||
* <li>{@code WorkbenchClientPackageService.rejectCredentialFiles} 两枚:{@code BusinessException}
|
||
* 原样重抛、{@code IOException} 清对象后转业务错误(RETHROW);</li>
|
||
* <li>{@code WorkbenchClientPackageService.removeRejectedObject} 一枚:{@code RuntimeException}
|
||
* 清理失败只 WARN,不让存储异常盖掉业务错误(LOG_ONLY);</li>
|
||
* <li>{@code WorkbenchClientPackageService.deleteTempQuietly} 一枚:{@code IOException}
|
||
* 删临时文件失败只 WARN(LOG_ONLY);</li>
|
||
* <li>{@code OssStorageService.downloadWorkbenchClientObjectToTempFile} 两枚:外层
|
||
* {@code Exception} 转 {@code storageFailure} 重抛(RETHROW),内层清理失败只 WARN(LOG_ONLY);</li>
|
||
* <li>{@code CostGuardScheduler} 一枚:平台自费告警推送失败只 WARN 并保留基线待下轮重试
|
||
* (NOT_RETHROW,log+return);</li>
|
||
* <li>{@code SimilarAsinLlmService} 一枚:{@code InterruptedException} 恢复中断位后上抛
|
||
* (RETHROW)。</li>
|
||
* </ul>
|
||
* 9 处均为 CR-02/05/10/20 的必要出口,不是把已有异常改回吞掉;同批实测 total 1024、
|
||
* notRethrow 573、logOnly 179、empty 56。
|
||
*
|
||
* <p>10-27 整表跑完专项抬 1024 -> 1026(用户口径:整表都要跑完,单项坏了跳过它继续下一项,
|
||
* 只有 LLM 密钥欠费/失效那一类才允许直接判任务失败),逐处记名:
|
||
* <ul>
|
||
* <li>{@code BrandTaskStorageService.rebuildAggregate} 一枚:单片载荷读不到时
|
||
* log.warn+记跳片号+{@code continue}(NOT_RETHROW)。此前一片抛就把整份聚合丢掉,
|
||
* 而三个调用方(finalizeTask/abort/tryRecoverCompletedRunningTask)都没有就地 try,
|
||
* 一个坏分片=整任务不产出;同批把 {@code completed} 的判据从 {@code chunks.size()}
|
||
* (DB 行数)改成「真正读到的片数」,缺数据不再被判成已收齐。</li>
|
||
* <li>{@code AppearancePatentLlmBatchPipeline.collectPendingLlmCandidates} 一枚:
|
||
* 同为 log.warn+计数+{@code continue}(NOT_RETHROW)。collect 跑在批循环<b>之前</b>,
|
||
* 一抛就走不到循环体内那道 {@code finally releaseRowInspection},本轮已申领的行要挂满
|
||
* 处理中 TTL(15 分钟),且 {@code terminalizeRoundExhaustedRows} 跟着一起不执行。</li>
|
||
* </ul>
|
||
* 另有两枚<b>既有</b> RETHROW 出口按同一口径改成「跳过该项」,形状从 RETHROW 迁入气味两格
|
||
* (total 不变、rethrow −2、notRethrow +2、logOnly +2):{@code BrandTaskStorageService.getParsedPayload}
|
||
* 与 {@code BrandTaskStorageService.getAllFileAggregates}——两处此前一个文件的缓存/聚合读不到
|
||
* 就整批抛,把已读到的其余文件一起抹掉;改后逐条 WARN 跳过,调用方按「尚未收齐」可重试。
|
||
* ⚠ 这两处不是把异常静默吞掉:跳过都带 {@code [brand-storage]} 锚点 WARN,且
|
||
* {@code BrandTaskStorageServiceFaultToleranceTest} 钉住「其余项照常出」与
|
||
* 「全项坏掉仍大声抛」两条,缺数据一律不得冒充已完成。
|
||
* 同批实测 total 1026、rethrow 393(仍高于下限 380,本格不动)、notRethrow 577、logOnly 181、empty 56。
|
||
*
|
||
* <p>10-27 同日第二批(B49 非 ★ 收尾)再抬 total 1026 -> 1028、notRethrow 577 -> 579,逐处记名:
|
||
* <ul>
|
||
* <li>{@code QueryAsinService.flushInsert} 一枚:ASIN 导入按批 try/catch,坏批点名后其余批照常入库
|
||
* (此前坏批直接冒到 {@code runImportTask},后面的批次一个都跑不到),log.warn+计数(NOT_RETHROW);
|
||
* 有坏批时任务落 failed——admin 页只在 failed 分支显示 errorMessage,留在 success 就是
|
||
* 把"没入库"说成"导入完成"。</li>
|
||
* <li>{@code DedupeRunService.packageFolderDedupeResultsAsZip} 一枚:folder 模式逐条目容错,
|
||
* 一个都没写进时拒绝交空包(NOT_RETHROW);aborted 仍落 FAILED,非 folder 分支零改动。</li>
|
||
* </ul>
|
||
* 第三处 {@code PublishTaskService} 只改文案、不加 catch;SUCCESS 的
|
||
* {@code file_task.error_message} 保持留空(缺口写 {@code biz_file_result.error_message}),
|
||
* 因为 {@code TaskRetryEligibility}/{@code SimilarAsinStaleReopenSupport} 会按 errorMessage
|
||
* 字面量分类,写进去等于替一条正常任务编一个失败理由。
|
||
* 同批实测 total 1028、rethrow 393(未动)、notRethrow 579、logOnly 181(未动)、empty 56(未动)。
|
||
*
|
||
* <p>10-28 采集「被过滤行」追溯(V179,结果 Excel 第 3 个 sheet)抬 total 1028 -> 1031,逐处记名。
|
||
* 三枚都是<b>审计件不得打掉交付</b>那一形,块体各只有一句带 {@code [collect-data]} 锚点的 WARN:
|
||
* <ul>
|
||
* <li>{@code CollectDataFilteredRowStore.writeBatch} 一枚:被过滤行按批 INSERT,坏批点名后
|
||
* 其余批照常落库(口径照 {@code CollectDataInvalidAsinBatchWriter})。这份明细不参与任何
|
||
* 判定,为它打掉用户已采回的数据是拿可追溯性换交付;跳过的批会从四类计数与已落库行数
|
||
* 的差里冒出来,sheet 上写「另有 N 行未逐条记录」,不是静默少给。</li>
|
||
* <li>{@code CollectDataFilteredRowStore.markResolved} 一枚:补测回流只盖时间戳+追加一句。
|
||
* 必要性是实测的——{@code CollectDataBrandRecheckScheduler} 抓住 {@code apply()} 的抛出后
|
||
* <b>整组留队重放</b>,这里若外抛,一次簿记失败会让已注入的任务永远重排。</li>
|
||
* <li>{@code CollectDataExcelAssemblyService.writeFilteredSheet} 一枚:尾 sheet 读不动就交付
|
||
* 前两表、缺这张审计表。同批我先写的第二枚("清单不完整"那行的内层 catch)已删掉:
|
||
* 那只是本地 POI 写,写不动说明整份 workbook 都写不动,该由
|
||
* {@code writeWorkbookStreaming} 的既有出口处理,与前两张 sheet 同姿势。</li>
|
||
* </ul>
|
||
*
|
||
* <p>10-28 Phase 3(v1.1 后端任务引擎稳定性)抬 total 1031 -> 1034,三处逐条记名:
|
||
* <ul>
|
||
* <li>{@code TaskHeartbeatService.touchFileTaskIfRunning} 一枚:模块进度写抛任何运行时异常
|
||
* (S1-B4 的 40902 就是这一类)都降级成 {@code progressDegraded=true},块体一条 WARN 带
|
||
* taskId/moduleType;不接住就等于心跳继续 500/40902,客户端会当"任务不在了"。</li>
|
||
* <li>{@code TaskFileJobConfig.taskQueueVirtualThreadExecutor} 的 {@code shutdown()} 一枚:
|
||
* await 期间被中断只恢复中断标记(S1-B6 优雅停机),不吞别的东西。</li>
|
||
* <li>{@code TaskFileJobConfig.videoQueueExecutor} 一枚:信号量 acquire 被中断只恢复中断标记
|
||
* (S1-B2 视频独立许可,照抄 taskQueueExecutor 的既有形状)。</li>
|
||
* </ul>
|
||
* <p>10-29 Phase 4D(AC-17/S1-F3 大文件分片通道)抬 total 1034 -> 1045,11 枚逐处记名。
|
||
* 这一批是"新增通道"而不是"给既有出口补兜":整条 {@code ChunkedUploadService} 与
|
||
* {@code WorkbenchClientPackageService} 的分片方法都是新落点,Java 的受检 {@code IOException}
|
||
* 使每一段磁盘动作都必须有自己的出口,形状与既有件同口径:
|
||
* <ul>
|
||
* <li>RETHROW 五枚——{@code ChunkedUploadService.init}(建会话目录失败:先 {@code deleteQuietly}
|
||
* 再抛 {@code BusinessException},不留半个会话)、{@code complete}(拼装中途失败:删掉半成品
|
||
* 后原样 {@code throw ex},绝不产出半个文件)、{@code readMeta}(元数据损坏直接抛,
|
||
* 让调用方重新 init 而不是按坏元数据继续拼)、{@code sha256Digest}(JVM 无 SHA-256 属环境级
|
||
* 不可能,抛 {@code IllegalStateException} 带 cause)、{@code WorkbenchClientPackageService
|
||
* .completeChunkedPackage}(拼装 IOException 翻成业务文案,500 变可读错误)。</li>
|
||
* <li>LOG_ONLY 六枚,块体各只有一句带锚点的 log,误差方向都是"清理/收尾失败不得盖掉主错误"——
|
||
* {@code ChunkedUploadService.cleanupStaleSessions} 内层(单条目时间戳读不出,本轮跳过该条)
|
||
* 与外层({@code Files.list} 失败,整轮清理放弃但不拦新会话)、
|
||
* {@code deleteQuietly} 的逐片删除与整体遍历两枚(残留交给过期回收),
|
||
* {@code WorkbenchClientPackageService.abortChunkedPackage} 的两枚(会话已不存在只 INFO;
|
||
* 未登记对象清理失败 WARN 带 objectKey,登记成功的对象后端会拒绝清理,不该在这里改口)。</li>
|
||
* <li>EMPTY 一格没涨:三处原本写成 {@code catch (IOException ignored) { /* 尽力清理 *\/ }} 的
|
||
* 空体已按 10-26 那批的先例改成 WARN 带 path——空体是三类高危出口里最贵的一种,
|
||
* 这里宁可让 {@code STRICT_LOG_ONLY} 涨六格,也不给"删除失败连日志都不留"开门。</li>
|
||
* </ul>
|
||
*
|
||
* <p>10-30 用户端代理白名单(极客/青果白名单 API)抬 total 1045 -> 1052,7 枚逐处记名。
|
||
* 全部是 NOT_RETHROW(log+return 或纯 return),RETHROW/LOG_ONLY/EMPTY 三格一枚未涨:
|
||
* <ul>
|
||
* <li>{@code JikipProxyClient.checkAndAddWhitelist} 添加一枚:网络/解析/上游非 0 code 统一折成
|
||
* {@code ProxyWhitelistOutcome(false, ...)} 交控制器转可读文案;异常只记类型——RestClient
|
||
* 异常消息可能带完整 URL(含套餐 key),禁止回传或落日志。</li>
|
||
* <li>{@code JikipProxyClient.checkWhitelist} 查询一枚:查不到(含网络失败)返回 null,
|
||
* 由调用方继续尝试添加——查询只是省一次写调用,不能变成添加的前置故障点。</li>
|
||
* <li>{@code QingguoProxyClient.checkAndAddWhitelist} 添加一枚与
|
||
* {@code QingguoProxyClient.queryContains} 查询一枚:与极客两枚同形状(同一套"先查后加"),
|
||
* 异常只记类型——查询串里带用户的青果 Key。</li>
|
||
* <li>{@code UserProxyPlanService.decryptQuietly} 一枚:已存套餐 key 解密失败按「未配置」处理
|
||
* (返回空串),只记异常类型,绝不把密文/明文写进日志;抛出去只会让整个代理配置页 500。</li>
|
||
* <li>{@code PublicIpValidator.normalize} 一枚(仅 return null):正则已拦字面量与段数,
|
||
* {@code InetAddress.getByName} 的 {@code UnknownHostException} 表示输入非法,
|
||
* 返回 null 让控制器给 400,不是吞供应商/DB 异常。</li>
|
||
* <li>{@code ProxyLinkKey.fromUrl} 一枚(仅 return null):提取链接里 {@code key} 的百分号编码
|
||
* 坏了就当作没带 key(后续按「未配置」提示重填),不把坏输入升级成整页失败。</li>
|
||
* </ul>
|
||
* 同批实测 total 1052、rethrow 398、notRethrow 598、logOnly 188(未动)、empty 56(未动)。
|
||
* ⚠ 本批提交时整树已是 1053/notRethrow 599:多出的 1 格不属本批——已提交的 79b04afd 在
|
||
* {@code AdminApiGuardFilter.decodePath} 增加了「畸形百分号编码保持原样、交给容器 400」的 catch
|
||
* (NOT_RETHROW 形状),该笔未抬本基线。这里按整树实测一并包住并在这一行记名。
|
||
*
|
||
* <p>10-31 v1.2 Phase 3 证据件落点抬 total 1053 -> 1055,两枚逐处记名(都在
|
||
* {@code TaskEvidenceService}):
|
||
* <ul>
|
||
* <li>{@code register} 一枚:{@code IOException | RuntimeException} 记 WARN 后转
|
||
* {@code BusinessException}(RETHROW 形状,同时进 rethrow 400);证据件写不进独立桶
|
||
* 必须让客户端拿到可读失败,不能登记一条指向空对象的行。</li>
|
||
* <li>{@code purgeExpired} 一枚:保留期回收逐行删除,单行删对象/删登记失败只记
|
||
* {@code [task-evidence]} WARN 并继续扫下一行(NOT_RETHROW+LOG_ONLY);一行坏数据
|
||
* 不该让整轮保留期回收停摆,下一轮还会重试。</li>
|
||
* </ul>
|
||
* 同批实测 total 1055、rethrow 400、notRethrow 599(未涨,register 是重抛形状)、
|
||
* logOnly 189、empty 56。
|
||
*
|
||
* <p>10-31 Phase 5.1 CR 消项再抬 1055 -> 1057,两枚逐处记名(都在
|
||
* {@code TaskEvidenceService.register} 的登记行写入失败兜底):外层 catch 回收已上传对象
|
||
* 后转业务错误(RETHROW+rethrow 401);内层 catch 是对象回收本身失败只 WARN
|
||
* (LOG_ONLY+logOnly 190)。两处误差方向都是「不让孤儿对象永久占桶」。
|
||
*/
|
||
// 10-31 CR 消项:版本包/教程包凭据扫描新增 6 处 catch(均转业务异常或带 WARN),1057 -> 1063。
|
||
// 11-01 失败任务原任务重试:`TaskInPlaceRetryService` 两处「尽力而为」兜底各记一枚,1063 -> 1065
|
||
// (两处都是 LOG_ONLY+notRethrow,所以 logOnly 同步 190 -> 192):
|
||
// ① clearResultError:结果行清错误文案失败只 WARN——它只影响界面旧文案,不能因此
|
||
// 把已经复位成 PENDING 的任务再打回失败;
|
||
// ② resetAssembleJob:复位组装作业失败只 WARN——同理,任务已复位,作业复位失败由
|
||
// stuck 扫描兜底,不该阻断用户点出来的这次重试。
|
||
// 反向对照:两处都不能改成「吞掉」——WARN 里带 taskId 与异常消息,出问题看得见。
|
||
// 11-05 密钥余额三面(龙抬头人民币余额 client/后管实时查余额)抬 1065 -> 1069,五枚全部 NOT_RETHROW,
|
||
// LOG_ONLY 与 EMPTY **一格没涨**——每一枚都把"这次没查到"换成界面读得出的状态,而不是只留一行日志:
|
||
// ① `LongtaitouBalanceClient.fetch`:网络/上游异常 ⇒ available=false +「余额查询失败」人话 + WARN。
|
||
// 反向对照:改成往外抛=一次余额查询把设置页打成 500;改成静默 return=界面显示 ¥0(假绿)。
|
||
// ② `LongtaitouBalanceClient.numberOrNull`:金额串(含 `$`/千分位)解析失败 ⇒ 返回 null ⇒
|
||
// 上游 credits 不可解析就当"查不到"。这一枚是"美元当人民币"的闸门:回落顶层数字才是真事故。
|
||
// ③ `LongtaitouBalanceClient.parseJson`:应答不是可解析 JSON ⇒ null,调用方给「返回的不是可解析的 JSON」。
|
||
// ④ `UserSecretBalanceAdminService` 行等待 `TimeoutException`:cancel 该行的 future、该行按
|
||
// 「上游未在本轮时间预算内应答」降级,并把 userId 记进 timedOutUserIds 如实上报(不得读成 0)。
|
||
// ⑤ 同处 `ExecutionException | InterruptedException`:先复位中断位,再同样按"未应答"降级+记账+WARN。
|
||
// 反向对照:④⑤ 若改成"超时给 0"或"catch 后什么都不记",后管那一列就会把"没问到"卖成"没钱"。
|
||
// 11-10 v1.3 外观专利无侵权同步链抬 1069 -> 1073(full 档格子,四枚逐处记名,全在本轮四个新文件里):
|
||
// ① `AppearancePatentCleanSyncService.syncFromResult`:`catch Exception` 只落一条带堆栈的
|
||
// WARN 后返回——AC-3 的核心语义:同步失败绝不反写任务/结果/作业(LOG_ONLY,logOnly 192 -> 193)。
|
||
// 反向对照:改成往外抛=一次同步抖动把已成功的出表打成失败(B77 语义敏感区,铁律 14/21 边界)。
|
||
// ② 同类 `loadNoInfringementConclusion`:`catch ReflectiveOperationException` ⇒ 返回 null ⇒
|
||
// 调用方每次落 error 并停摆——判定常量读不到必须显形停摆、绝不猜值(铁律 30 同形状)。
|
||
// ③ `AdminAppearancePatentCleanItemsController.resolveOperator`:`catch BusinessException` ⇒
|
||
// 先试内部令牌回退,回退失败把原鉴权异常原样重抛(块内含 throw ⇒ 进重抛格,不吞)。
|
||
// ④ 同类 `resolveInternalOperator`:`catch NumberFormatException | BusinessException` ⇒ 返回 null ⇒
|
||
// 上层把原 401/403 原样抛回(回退失败必须显形,不吞)。
|
||
// 本批复核办法:上限压 0/下限抬 99999 单跑一次,实测 total 1073、rethrow 406、
|
||
// notRethrow 611、logOnly 193、empty 56(EMPTY 一格没涨)。
|
||
// 11-11 外观专利数据库导出抬 1073 -> 1074,一枚逐处记名:
|
||
// `AppearancePatentCleanItemQueryService.writeExportWorkbook`:SXSSF 落盘 catch Exception
|
||
// → BusinessException「导出外观专利数据库失败,请稍后重试」(RETHROW 形状,rethrow 406 -> 407,
|
||
// 本格与 NOT_RETHROW/LOG_ONLY/EMPTY 都不动)。误差方向:导出请求的 IO 失败必须给用户
|
||
// 可读业务错误而不是 500 裸堆栈;反向对照——改成往外抛 IOException=前端拿到 Spring 兜底文案,
|
||
// 改成吞掉返回空字节=用户拿到 0 字节 xlsx 还以为导出成功(比报错更贵)。
|
||
// 11-14 v1.4 京东数据库抬 1074 -> 1090,十六枚逐处记名(Phase 2 采集域 7 枚与 Phase 4 通用化
|
||
// 3 枚随各自 commit 落码、当时未进点名册,Phase 5 收尾跑全量时由本棘轮一次性抓出,此处并册):
|
||
// 【Phase 4 通用化预签名,3 枚全 RETHROW】`OssStorageService.presignObjectUpload` /
|
||
// `objectSize`(ErrorResponseException 非 404 分支 + Exception 兜底,共 2 枚):全部转
|
||
// `storageFailure`——预签名/对撞失败必须给可读业务错误,静默 return null 会让客户端拿
|
||
// null uploadUrl 直传炸得更深。
|
||
// 【Phase 2 采集域,7 枚】`JdCollectTaskService`:① 建单载荷序列化 `catch Exception` →
|
||
// BusinessException(RETHROW);② scope 行 `catch DuplicateKeyException` → log.info 复用
|
||
// 先到行(LOG_ONLY +1,并发建单幂等语义,不吞成败);③④ `readCreateRequest` 的
|
||
// `catch BusinessException → throw ex` + `catch Exception → BusinessException`(RETHROW,
|
||
// 载荷损坏按异常拒绝回传不静默兜)。`JdResultIngestService`:⑤⑥ `parseState`/`writeJson`
|
||
// → BusinessException(RETHROW,台账损坏显形);⑦ `toSummary` `catch IllegalArgumentException`
|
||
// → BusinessException 带字段消息(RETHROW)。
|
||
// 【Phase 5 后管,6 枚】① `AdminJdProductController.resolveOperator` 与 ②
|
||
// `AdminJdProductGroupController.resolveOperator`:`catch BusinessException` ⇒ 先试内部令牌
|
||
// 回退,回退失败把原鉴权异常原样重抛(RETHROW +2)。③④ 同两文件的
|
||
// `resolveInternalOperator`:`catch NumberFormatException | BusinessException` ⇒ 返回 null ⇒
|
||
// 上层把原 401/403 原样抛回(NOT_RETHROW +2)。⑤ `JdProductQueryService.parseAttrGroups`:
|
||
// attr_json 解析 `catch Exception` ⇒ log.warn 带 productId + 空分组 + 原文透 attrJsonRaw
|
||
// 兜底(AC-7 未识别属性不丢弃;NOT_RETHROW +1)。反向对照:改成往外抛=一条脏 attr_json
|
||
// 让整行详情 500;改成静默空分组不带原文=用户看到的属性被悄悄吞掉。⑥
|
||
// `JdProductQueryService.writeExportWorkbook`:SXSSF 落盘 `catch Exception` →
|
||
// BusinessException「导出京东数据库失败,请稍后重试」(RETHROW +1,与 11-11 外观专利导出同款)。
|
||
// 本批复核办法:单跑实测 total 1090、notRethrow 614、logOnly 194、empty 56(EMPTY 一格没涨)。
|
||
// 11-14 Phase 6.1 CR 修复抬 1090 -> 1091,一枚逐处记名:
|
||
// `JdResultIngestService.parseJdTime`:DateTimeParseException → BusinessException
|
||
// 「京东时间格式不识别(应为 yyyy-MM-dd HH:mm:ss): <原文>」(RETHROW)。误差方向:
|
||
// 客户端回传脏时间戳之前直接 DateTimeParseException 裸抛 = 回传口 500 裸堆栈(P1-3);
|
||
// 改成吞掉置 null = 登记时间被悄悄抹掉。
|
||
// 11-14 v1.5「获取店铺数据」进度条抬 1091 -> 1092,一枚逐处记名:
|
||
// `JdCollectTaskService.parseScopeState`:进度查询读 scope.state_json 时
|
||
// `catch Exception` ⇒ log.warn 带原因 + 返回空对象(NOT_RETHROW)。误差方向:
|
||
// 改成往外抛 = 一行脏 JSON 把进度查询打成 500、进度条直接红条;改成静默返回空对象
|
||
// 不记日志 = 游标损坏永远没人知道。演示面只降级不抛错,但必须有那一行 WARN。
|
||
// (相邻的数值解析刻意不用 NumberFormatException 当控制流:改为 1~9 位十进制正则前置,
|
||
// 省掉两枚 catch,EMPTY 一格没涨。)
|
||
// 11-15 京东 B101/B102 收口(SKU 矩阵+删除链)抬 1092 -> 1097,五枚逐处记名(提交 402447af):
|
||
// ① `JdProductDeleteService` 删桶后库行删除失败:log.error 带 productIds(key 清单可从
|
||
// 图片登记行重建)后原样重抛(RETHROW)——"桶已删、库行回滚"的裂缝必须响亮显形;
|
||
// ② 同处对象删除失败:`throw new BusinessException("桶内对象删除失败,本次未删除任何数据…")`
|
||
// (RETHROW)——整批拒绝可安全重试,不做部分删除;
|
||
// ③ `JdProductQueryService` SKU saleAttrs JSON 解析失败:log.warn 带 skuId 后返回空 attrs
|
||
// (LOG_ONLY,块内仅一句 log)——一行脏组合不把详情页打成 500;
|
||
// ④ `JdProductSkuIngestService.writeJson`:组合维度序列化失败 log.warn 后该 SKU 不写组合
|
||
// (NOT_RETHROW,log+return,带 [silent-degrade] 锚点)——价格库存照落,不让一个坏维度拖垮整批回传;
|
||
// ⑤ `JdResultIngestService` 单行 SKU 形状不合法(price 非数字等):log.warn 后跳过该行
|
||
// (LOG_ONLY,块内仅一句 log)——与铁律 21 同形状,脏行不判死整批。
|
||
// 本批复核办法:上限压 0/下限抬 99999 单跑本类,实测 total 1097、rethrow 382、
|
||
// notRethrow(含 log) 619、logOnly 196(严格口径 +2:③⑤)、empty 56(未涨)。
|
||
static final int STRICT_TOTAL = 1097;
|
||
/**
|
||
* 重抛型 catch 的**下限**(不是上限):本轮把两处吞异常改成重抛之后实测 388。
|
||
* 这一格只能涨不能跌——它是"异常会往外走"的总量,把它钉成"只许减"就等于拦着别人修吞异常。
|
||
*/
|
||
// 10-09 下调 388 -> 387,出处点名:提交 b633bd48「摘 13 处零引用私有方法」删掉了
|
||
// DeleteBrandRunService 里一个无人调用的私有方法,它的 catch 体是
|
||
// `throw new BusinessException("生成删除品牌结果文件失败: " + ...)` —— 那是 RETHROW 形状,
|
||
// 随死代码一起离开树;实测重抛数 387、不重抛与只 log 两数未涨 ⇒ 没有任何一处"异常会往外走"
|
||
// 被改回吞掉。这一格的本意是"重抛只许涨不许跌",所以调基线必须带着这样的逐处出处;
|
||
// 拿"总数变小了"当理由不算——那种情况下真正要看的是不重抛那一侧有没有涨。
|
||
// 10-09 再下调 387 -> 386,出处点名:去重库按公司收口那一笔删掉了 DedupeTotalDataService.deleteFromExcel
|
||
// 的两个零调用者重载,其中 `throw new BusinessException("删除 Excel 匹配数据失败", e)` 是 RETHROW 形状,
|
||
// 随死代码一起离开树;实测重抛 386、不重抛与只 log 两数未涨(那两格仍绿)=> 没有任何一处「异常会往外走」被改回吞掉。
|
||
// 10-19 再下调 386 -> 385,出处点名(用户授权「逐处记名调这一格」):Phase 3 的 3B 迁移把
|
||
// ShopDataCrawlTaskService 的私有 `writeJson(Object, String)` 并进底座已有的
|
||
// `AbstractFileTaskPipeline.writeJson(ObjectMapper, Object, String)`——那一枚 catch 的体是
|
||
// `throw new BusinessException(message)`(RETHROW 形状、不带 cause),本支文案「序列化店铺数据抓取结果分片失败」
|
||
// 逐字带到调用点,失败形状与线协议一字未动(golden 的 submit-result 分片各例对撞相等)。
|
||
// 四份逐字同名件并成一份 ⇒ 树里少了一处「异常会往外走」的**实例**,不是少了一种会外走的异常;
|
||
// 本笔只从树上摘掉这一处 RETHROW 形状的 catch,不重抛侧一个字节没动:同批实测 notRethrow 562、
|
||
// logOnly 173、empty 55 三格仍在上限内(未涨)=> 没有任何一处出口被改回吞掉。
|
||
// 10-19 再下调 385 -> 383,出处点名(同一项用户授权「逐处记名调这一格」的第二笔,形状与上一笔逐字相同):
|
||
// Phase 3 的 3A 迁移把 AppearancePatentTaskService 的两处同名序列化 catch 并进底座
|
||
// `AbstractFileTaskPipeline.writeJson(ObjectMapper, Object, String)`——① 私有
|
||
// `writeJson(Object, String)`(体是 `throw new BusinessException(message)`,7 个调用点的文案逐字
|
||
// 带到调用点);② 建单里那段 `try { setRequestJson(writeValueAsString(request)) … } catch (Exception ex)
|
||
// { throw new BusinessException("序列化解析结果失败") }`,失败形状与线协议一字未动。
|
||
// 本笔另摘的三枚零调用私有件(abbreviate/resultLookupKeysForResultRows/isHistoryFileBuilding)
|
||
// 里没有 catch,所以 RETHROW 只降这两格;不重抛/只 log/空体三格同批复跑未涨(三格判据一条没放宽)。
|
||
// 10-19 再下调 383 -> 381,出处点名(同一项用户授权的第三笔,形状与上一笔逐字相同):
|
||
// Phase 3 的 3C 迁移把 CollectDataService 的两处序列化 catch 并进底座
|
||
// `AbstractFileTaskPipeline.writeJson(ObjectMapper, Object, String)`——① 私有
|
||
// `writeJson(Object, String)`(体是 `throw new BusinessException(message)`,唯一调用点的文案
|
||
// 「采集结果序列化失败」逐字带到调用点);② 建单 `persistParsedTask` 里那段
|
||
// `try { setRequestJson(writeValueAsString(…)) … setResultJson(writeValueAsString(…)) }
|
||
// catch (Exception ex) { throw new BusinessException("序列化任务信息失败") }`。
|
||
// 两支文案、异常类型、不带 cause 这三条线协议事实一字未动(golden 建单 4 段+回传 15 段逐字节相等)。
|
||
// ⚠ 本支还有第三处同形状(`persistStats` 的 try 包 15 行 put 加一次序列化),**这笔没并它**:
|
||
// 用户授权的范围是两处,第三处要再降一格须另行记名。不重抛/只 log/空体三格同批复跑未涨
|
||
// ——这三格是上限、且常量就等于上一次记下的实测值,所以「绿」本身就证成「未涨过那一数」。
|
||
// ⚠ 历史数不等于现状数(本笔踩过,记法留在这里给下一个读的人):total 是**上限**,
|
||
// 只在新增加时红,删掉 catch 从不回头核对 ⇒ 常量上方那些「实测 1003/1004」会与现实脱钩。
|
||
// 复现办法(本笔实测用过的):把 STRICT_TOTAL 与三格上限临时压到 0、把本格下限抬到 99999,
|
||
// 单跑本类一次,断言文案里就是当前整树实测值。本笔读到的数是 **total=998、rethrow=381**;
|
||
// 与 1004 差的那 6 格里本笔只占 2(另 4 处是更早几笔静默摘掉的,不在本笔账上、也无从追认)。
|
||
// 判据一格未放宽:本格仍按实测下限钉住,四格上限原样不动(要收紧得逐处记名另笔请示)。
|
||
// 10-19 再下调 381 -> 380,出处点名(同一项授权的续笔,用户 2026-10-19 拍板「按顺序」第①项):
|
||
// 3C 第五笔把 CollectDataService 的**第三处**同形状序列化 catch 并进同一枚底座件——
|
||
// `persistStats` 那段 `try { 15 行 payload.put(…) … task.setResultJson(writeValueAsString(payload)) }
|
||
// catch (Exception ex) { throw new BusinessException("保存采集统计失败") }`。文案、异常类型、
|
||
// 不带 cause 三条线协议事实逐字带到调用点(回传 15 段 golden 逐字节复现,那 15 段每段都过这一格)。
|
||
// 并档顺带把捕获面从「建 map +序列化」收回「序列化」:LinkedHashMap.put 对这些值不可能抛,
|
||
// 所以没有出口被改回吞掉;不重抛/只 log 两格的上限值恰等于上一次记录的实测值(562/173),
|
||
// 绿即证这两格未涨;⚠ empty 那格常量是 56 而上一次记录是 55,绿只证「≤56」、不证未涨——
|
||
// 别把这句读成三格都被重新证明过。
|
||
// 整树实测(复现办法同上:上限压 0、下限抬 99999 各单跑本类一次):**total=997、rethrow=380**
|
||
// (上一笔读的是 998/381,本笔各 −1,与本笔摘掉的那一处 RETHROW 形状对得上账)。
|
||
// 11-15 京东 B101/B102 收口上调 380 -> 382,出处见 STRICT_TOTAL 上方 11-15 段:新增 5 枚中
|
||
// 2 枚是 RETHROW(删除链的"桶已删、库行回滚"重抛 + 对象删除失败整批拒绝)。
|
||
// 这是下限不是上限:重抛枚数变多 = 又有两处异常被改成往外走,只许涨。
|
||
static final int RETHROW_FLOOR = 382;
|
||
/**
|
||
* 10-17 抬 559 -> 561,逐处记名(两处都是新增的 fail-open 证据读写,不是把已有出口改回吞掉):
|
||
* 1){@code TaskHeartbeatLivenessService.stamp()}:心跳证据写失败只 WARN——心跳接口不许因为
|
||
* 「记不下证据」而 500,那会让客户端整轮心跳线程崩掉,反而制造更多孤儿任务;
|
||
* 2){@code TaskHeartbeatLivenessService.lastHeartbeatMillis()}:读证据失败一律落到 0=「没有证据」,
|
||
* 判死线据此**放宽**(顶多让任务多活一会儿,最终仍由未启动宽限与 stale-repair 兜底)。
|
||
* 两处的误差方向都是「少杀一个任务」,与这一格想拦的「异常到此为止、外面看不见」不同性质;
|
||
* 抬格是为了把出处留在这份 diff 里,而不是让后来人以为基线自然涨上来的。
|
||
* 10-18 抬 561 -> 562,逐处记名:{@code AppearancePatentTaskService.fallbackAssembleResultFile()}——
|
||
* 失败兜底组装的自吞出口(接口契约要求,见 {@code ResultFileJobHandler#fallbackAssembleOnFailure}),
|
||
* 与 {@code DeleteBrandRunService.fallbackAssembleResultFile} 同形状、同性质:兜底失败不得掩盖
|
||
* 作业已终态失败的事实,也不得打断 stuck 扫描对终态失败作业的幂等重入。形状是 log+return false,
|
||
* 因此只进本格与 total,不进 STRICT_LOG_ONLY(严格口径不数 log 后接 return)。
|
||
* 10-24 抬 562 -> 564,逐处记名(损耗监控 cost-guard 的三处 fail-open,都带 {@code [cost-guard]}
|
||
* 日志锚点、巡检按锚点数得到,不是「异常到此为止外面看不见」那种无声出口):
|
||
* 1){@code CostGuardScheduler.scan()}:整轮扫描异常只 WARN——这条监控抛出就等于自己变成
|
||
* 现网噪声源,而下一轮 fixedDelay 照跑,暂停判定不会因此停摆;
|
||
* 2){@code UserTaskGuardService.pause()}:单个账号的暂停写失败若外抛,{@code runOnce} 的
|
||
* 逐账号循环就地中止,排在这之后的账号这一轮全部不被检查(最坏晚一个间隔才暂停=多烧钱);
|
||
* 3){@code UserTaskGuardService.load()}:读不到闸门状态按「未暂停」走——一次库抖动不该把
|
||
* 全体用户的合法任务一起冻住,真失控由下一轮扫描重新置位(方向是「少冻一个号」)。
|
||
* 其中 1)、2) 块体只有一句 log,故同时进 STRICT_LOG_ONLY;3) 是 log+return,不进。
|
||
* 同批先写后摘、没留在树上的 6 处静默出口见 total 那一格的点名。
|
||
* 10-25 抬 564 -> 569,逐处记名(B15 join 无界收口,共 6 处新增不重抛、替换掉 1 处旧的):
|
||
* {@code AppearancePatentLlmClient.runBatches} 两枚(超时/执行失败、中断各收口成该批失败),
|
||
* {@code SimilarAsinLlmService} 类目与合规两个 prepass 各两枚(超时/执行失败只 WARN,
|
||
* 中断复位中断位后退出等待)。两处预计算的缺行都会走单行回退,不是把已有出口改回吞掉。
|
||
* 10-26 抬 569 -> 573(第二轮 CR-Fix 2,4 处新增不重抛,逐处记名):
|
||
* {@code WorkbenchClientPackageService.removeRejectedObject}(清理失败只 WARN,不让存储异常
|
||
* 盖掉业务错误)、{@code deleteTempQuietly}(删临时文件失败只 WARN)、
|
||
* {@code OssStorageService.downloadWorkbenchClientObjectToTempFile} 内层清理(同上)、
|
||
* {@code CostGuardScheduler}(平台自费告警推送失败 log+return,保留基线待下轮重试)。
|
||
* 四处的误差方向都是「不让清理/告警失败掩盖主错误」,不是把异常静默吞掉。
|
||
* 10-27 抬 573 -> 577(「整表都要跑完」专项,4 处不重抛,逐处记名见 STRICT_TOTAL 上方注释):
|
||
* 新增 {@code BrandTaskStorageService.rebuildAggregate} 与
|
||
* {@code AppearancePatentLlmBatchPipeline.collectPendingLlmCandidates} 两枚逐片跳过;
|
||
* 另有 {@code BrandTaskStorageService.getParsedPayload}/{@code getAllFileAggregates} 两枚
|
||
* 既有「整批抛出」出口按同口径改成逐条跳过(自 RETHROW 迁入本格)。
|
||
* 10-27 同日第二批再抬 577 -> 579(2 枚逐批/逐条目容错:{@code QueryAsinService.flushInsert}
|
||
* 与 {@code DedupeRunService.packageFolderDedupeResultsAsZip},块体都是 log.warn+计数,
|
||
* 坏项点名、其余照常交付,逐处记名见 STRICT_TOTAL 上方注释)。
|
||
* 10-28 再抬 579 -> 582(V179 采集「被过滤行」三枚审计件容错:{@code CollectDataFilteredRowStore.writeBatch}
|
||
* 逐批插入、{@code CollectDataFilteredRowStore.markResolved} 回流簿记、
|
||
* {@code CollectDataExcelAssemblyService.writeFilteredSheet} 尾 sheet 降级;三处都是带
|
||
* {@code [collect-data]} 锚点的 log.warn+善后,块体除第一枚外各带一句状态置位/返回值,
|
||
* 逐处记名见 STRICT_TOTAL 上方注释)。
|
||
* 10-28 Phase 3 再抬 582 -> 585(后端任务引擎三枚,均为「异常到此为止」的必要形状):
|
||
* {@code TaskHeartbeatService.touchFileTaskIfRunning}(S1-B4 进度写降级成 progressDegraded,
|
||
* 块体 log.warn 带 taskId/moduleType)、{@code TaskFileJobConfig.taskQueueVirtualThreadExecutor}
|
||
* 的 {@code shutdown()} 与 {@code TaskFileJobConfig.videoQueueExecutor}(S1-B6/S1-B2,
|
||
* {@code InterruptedException} 只恢复中断标记),逐处记名见 STRICT_TOTAL 上方注释。
|
||
* 10-29 Phase 4D 再抬 585 -> 591(AC-17 分片通道六枚 LOG_ONLY,逐处记名见 STRICT_TOTAL 上方注释):
|
||
* {@code ChunkedUploadService.cleanupStaleSessions} 内外两枚、{@code deleteQuietly} 逐片与整体两枚、
|
||
* {@code WorkbenchClientPackageService.abortChunkedPackage} 的「会话已不存在」INFO 与
|
||
* 「未登记对象清理失败」WARN 两枚。六枚的误差方向都是「清理/收尾失败不得盖掉主错误」,
|
||
* 主错误由外层重抛;本批 EMPTY 一格没涨(原先三枚空体已按 10-26 先例改成带 path 的 WARN)。
|
||
* 10-30 再抬 591 -> 598(用户端代理白名单 7 枚,逐处记名见 STRICT_TOTAL 上方注释):
|
||
* 极客/青果各两枚(添加失败折成 {@code ProxyWhitelistOutcome}、查询失败返回 null 继续添加),
|
||
* 套餐 key 解密失败按「未配置」处理一枚,IP 校验与提取链接 key 解码各一枚纯 return null。
|
||
* 七枚全在用户端配置页的「手动加白名单」链路上,方向都是「选项未配置/输入非法就给可读提示」,
|
||
* 没有把服务端主链路异常静默吞掉的出口。
|
||
* 复测整树 599:多出的 1 格来自已提交的 79b04afd {@code AdminApiGuardFilter.decodePath}
|
||
* (畸形编码保持原样交给容器 400),非本批新增,说明见 STRICT_TOTAL 上方。
|
||
*/
|
||
// 10-31 Phase 5.1:同 GIVEN_NOT_RETHROW,证据登记补偿回收失败只 WARN,599 -> 600。
|
||
// 11-01 失败任务原任务重试:TaskInPlaceRetryService 两处 WARN 兜底(clearResultError /
|
||
// resetAssembleJob),严格口径实测 602 -> 604;出处见 STRICT_TOTAL 上方注释。
|
||
// 11-05 密钥余额三面:五枚 NOT_RETHROW(1065->1069 那批),严格口径实测 603 -> 608;
|
||
// 上一格 604 是**上限**而实测量一直低它一枚,这次新增把那一枚额度用掉又超上去——逐处见 STRICT_TOTAL 上方。
|
||
// 11-10 v1.3 同步链:严格口径实测 608 -> 611(三枚不重抛),出处见 STRICT_TOTAL 上方注释。
|
||
// 11-14 v1.4 京东数据库后管:严格口径实测 611 -> 614(三枚不重抛:两处 resolveInternalOperator
|
||
// 返回 null + parseAttrGroups 的 attr_json 兜底),出处见 STRICT_TOTAL 上方注释。
|
||
// 本格含 LOG_ONLY(incl 口径):同批 Phase 2 建单 scope 行那枚 DuplicateKeyException 复用
|
||
// 先到行把 LOG_ONLY 抬 193 -> 194 时连带占本格一枚额度 ⇒ 614 -> 615(出处同 STRICT_TOTAL
|
||
// 上方注释;这是本格**含 LOG_ONLY** 口径的连带,不是又一枚新的不重抛)。
|
||
// 11-14 v1.5「获取店铺数据」进度条:严格口径实测 615 -> 616(一枚不重抛:
|
||
// JdCollectTaskService.parseScopeState 读 scope.state_json 失败 log.warn + 空对象,
|
||
// 出处与误差方向见 STRICT_TOTAL 上方注释;logOnly 一格没动)。
|
||
// 11-15 京东 B101/B102 收口:严格口径实测 616 -> 619(三枚不重抛含 log:两枚落 LOG_ONLY、
|
||
// 一枚 log+return,出处见 STRICT_TOTAL 上方 11-15 段)。
|
||
static final int STRICT_NOT_RETHROW = 619;
|
||
/**
|
||
* 10-17 抬 172 -> 173,出处就是上面点名过的 {@code TaskHeartbeatLivenessService.stamp()}:
|
||
* 块体只有「取到 key 名 + log.warn」一句,写心跳证据失败时既不重试也不抛出——
|
||
* 心跳接口不许因为「记不下证据」而 500。同类的 {@code lastHeartbeatMillis()} 读失败还要
|
||
* 落 0 返回,形状是 log+return 默认值,因此不进这一格。
|
||
* 10-24 抬 173 -> 175,出处即上面 STRICT_NOT_RETHROW 里点名过的 cost-guard 两处:
|
||
* {@code CostGuardScheduler.scan()} 与 {@code UserTaskGuardService.pause()}——块体各只有一句
|
||
* {@code log.warn}/{@code log.error},都是带锚点的 fail-open,不是把已有出口改回吞掉。
|
||
* 10-25 抬 175 -> 176,出处即上面点名过的 {@code SimilarAsinLlmService} 类目/合规 prepass
|
||
* 两个超时出口之一(两处形状相同,其中一处按块内语句判定落进本格,另一处因复位中断位
|
||
* 多一条语句只进 NOT_RETHROW)。块体只有一句带 {@code [similar-asin][llm]} 锚点的 WARN,
|
||
* 缺结果的行走单行回退,不是无声吞掉。
|
||
* 10-26 抬 176 -> 179(第二轮 CR-Fix 2,3 处新增 log-only):{@code WorkbenchClientPackageService}
|
||
* 的 removeRejectedObject/deleteTempQuietly 与 {@code OssStorageService} 的临时文件清理内层,
|
||
* 三处都只 WARN 且带 path/objectKey 锚点;主错误由外层重抛,清理失败不得盖掉它。
|
||
* 10-27 抬 179 -> 181(「整表都要跑完」专项,2 处):{@code BrandTaskStorageService.getParsedPayload}
|
||
* 与 {@code getAllFileAggregates} 的逐条跳过出口——块体各只有一句带 {@code [brand-storage]}
|
||
* 锚点的 WARN。两处此前是「一个文件坏 ⇒ 整批抛出」,改后其余文件照常返回,坏的那条点名可查;
|
||
* 同批 {@code rebuildAggregate} 与外观专利候选收集因块内另有计数/continue 只进 NOT_RETHROW。
|
||
* 10-28 抬 181 -> 182(V179 采集「被过滤行」的 {@code CollectDataFilteredRowStore.writeBatch}):
|
||
* 块体只有一句带 {@code [collect-data]} 锚点的 WARN(taskId+chunk+err),坏批点名后其余批照常
|
||
* 落库。同批另两处({@code markResolved} 追加 return、{@code writeFilteredSheet} 置 incomplete 位)
|
||
* 因块内多一句只进 NOT_RETHROW。
|
||
* 10-29 Phase 4D 抬 182 -> 188(AC-17 分片通道六枚,逐处记名见 STRICT_TOTAL 上方注释):
|
||
* {@code ChunkedUploadService.cleanupStaleSessions} 内外两枚、{@code deleteQuietly} 逐片与整体两枚
|
||
* (这四枚原本是 {@code catch (IOException ignored)} 空体,按 10-26 那批先例改成带 path 的 WARN,
|
||
* 是「空体换 LOG_ONLY」的迁移而不是新增沉默),加上
|
||
* {@code WorkbenchClientPackageService.abortChunkedPackage} 的 INFO 与 WARN 两枚。
|
||
* 10-31 抬 188 -> 189:{@code TaskEvidenceService.purgeExpired} 的逐行保留期回收出口,
|
||
* 块体只有一句带 {@code [task-evidence]} 锚点的 WARN(id+reason),坏行跳过、其余照删。
|
||
* 同日 Phase 5.1 再抬 189 -> 190:登记行落库失败后的对象回收失败只 WARN(同上锚点),
|
||
* 主错误仍由外层转业务错误;不吞主错误。
|
||
*/
|
||
static final int STRICT_LOG_ONLY = 196; // 严格口径:块内每条顶层语句都是 log 调用才算(11-01 重试两处兜底 +2、11-10 v1.3 同步服务 syncFromResult +1、11-14 v1.4 建单 scope 行 DuplicateKeyException 复用先到行 +1,见 STRICT_TOTAL 上方)
|
||
static final int STRICT_EMPTY = 56;
|
||
|
||
/**
|
||
* 注释/字符串/文本块里的 {@code "catch ("} 字样条数。本轮实测 **0**——
|
||
* 于是"扫描器 total == grep 字面量口径"这条等式是**直接成立**的,不需要中间项。
|
||
* 把它单独钉死是因为:一旦有人往日志文案或注释里写 {@code catch (},
|
||
* 正确词法会不数它,两口径就此分家,而"≤ 基线"的棘轮对分母变小是沉默的。
|
||
*/
|
||
static final int BASELINE_DECOY = 0;
|
||
|
||
private static volatile Result cached;
|
||
|
||
private static Result tree() {
|
||
Result r = cached;
|
||
if (r == null) {
|
||
synchronized (CatchSilenceRatchetTest.class) {
|
||
r = cached;
|
||
if (r == null) {
|
||
r = SilentCatchScanner.scanTree(TREE);
|
||
cached = r;
|
||
}
|
||
}
|
||
}
|
||
return r;
|
||
}
|
||
|
||
/**
|
||
* 分母自证:扫描器数出的 total 与一份**独立**的简单口径(原始文件里字面量
|
||
* {@code "catch ("} 的出现次数,等价于 {@code grep -o "catch (" | wc -l})必须对得上账:
|
||
*
|
||
* <pre>naive == scanned + decoy</pre>
|
||
*
|
||
* <p>为什么不是直接 {@code naive == scanned}:字面量口径会把注释里、字符串里、文本块里的
|
||
* {@code catch (} 字样也数进去(本轮实测 7 处)。一个**正确**的词法必须不数它们,
|
||
* 所以两口径天然差这 7。把差值单独钉住({@link #BASELINE_DECOY})才是有用的断言:
|
||
* 词法若写坏、把真代码当字符串吃掉,total 会**变小**而"≤ 基线"照样绿,
|
||
* 但那些块会立刻变成 decoy ⇒ decoy 超基线 ⇒ 红。这正是 818 vs 1000 那版 bug 的显形方式。
|
||
*/
|
||
@Test
|
||
void scannerTotalAndDecoyAccountForTheIndependentNaiveCount() {
|
||
Map<String, String> raw = readTree();
|
||
int naive = SilentCatchScanner.countNaiveLiteral(raw);
|
||
List<SilentCatchScanner.Decoy> decoys = SilentCatchScanner.decoyOccurrences(raw);
|
||
int scanned = tree().total();
|
||
|
||
assertEquals(naive, scanned + decoys.size(),
|
||
() -> "对不上账:字面量口径 " + naive + " 处,扫描器 " + scanned
|
||
+ " 处,注释/字面量里的假 catch " + decoys.size() + " 处。"
|
||
+ "两口径的差只能是假 catch,多出来或少出来都说明有一边在漏数");
|
||
assertTrue(decoys.size() <= BASELINE_DECOY,
|
||
() -> "有 " + decoys.size() + " 处 \"catch (\" 字样落在注释或字符串里(基线 "
|
||
+ BASELINE_DECOY + ")。这一旦不为 0,下面那条『两口径直接相等』就得改成带中间项,"
|
||
+ "而分母变小对『≤ 基线』的棘轮是沉默的——所以宁可现在就来找一找是谁写的:" + decoys);
|
||
assertEquals(naive, scanned,
|
||
"扫描器数出的 total 必须等于独立简单口径(grep \"catch (\")的 total");
|
||
assertTrue(scanned > 900,
|
||
() -> "扫描器只数到 " + scanned + " 处,不像整棵 main 树(词法吃掉大段就会这样)");
|
||
assertTrue(naive > 950, () -> "字面量口径只有 " + naive + ",连独立分母都没站住");
|
||
}
|
||
|
||
/**
|
||
* 四个数各自 ≤ 基线(只许减)。两套基线一起钉:
|
||
* 验收口径(用户给的 1000/559/249/56)与本轮严格口径重测(994/554/170/55)。
|
||
* 只钉前者会留下 6/5/79/1 的额度被人当预算花掉,只钉后者则对不上验收数字,所以两把尺都摆在这儿。
|
||
*/
|
||
@Test
|
||
void fourNumbersMustNotGrow() {
|
||
Result r = tree();
|
||
assertTrue(r.total() <= STRICT_TOTAL,
|
||
() -> "catch 总数超过 " + STRICT_TOTAL + "(= 验收基线 " + GIVEN_TOTAL
|
||
+ " 再加上 STRICT_TOTAL 常量上方逐处记名的两处评审增量):现在是 " + r.total()
|
||
+ "。新增 catch 块要么别加,要么同批减掉一处同形状的");
|
||
assertTrue(r.count(Kind.RETHROW) >= RETHROW_FLOOR,
|
||
() -> "重抛型 catch 跌到 " + r.count(Kind.RETHROW) + ",低于下限 " + RETHROW_FLOOR
|
||
+ "。有人把一处『异常会往外走』的出口改回了吞掉——这一格只许涨不许跌");
|
||
assertTrue(r.notRethrowIncludingLogOnly() <= GIVEN_NOT_RETHROW,
|
||
() -> "不重抛(块体非空且不含 throw)超过验收基线 " + GIVEN_NOT_RETHROW + ":现在是 "
|
||
+ r.notRethrowIncludingLogOnly());
|
||
assertTrue(r.notRethrowIncludingLogOnly() <= STRICT_NOT_RETHROW,
|
||
() -> "不重抛超过本轮严格口径实测 " + STRICT_NOT_RETHROW + ":现在是 "
|
||
+ r.notRethrowIncludingLogOnly() + ",这一格就是「异常到此为止、外面看不见」的总数");
|
||
assertTrue(r.count(Kind.LOG_ONLY) <= GIVEN_LOG_ONLY,
|
||
() -> "只 log 的吞异常块超过验收基线 " + GIVEN_LOG_ONLY + ":现在是 " + r.count(Kind.LOG_ONLY));
|
||
assertTrue(r.count(Kind.LOG_ONLY) <= STRICT_LOG_ONLY,
|
||
() -> "只 log 的吞异常块超过本轮严格口径实测 " + STRICT_LOG_ONLY + ":现在是 "
|
||
+ r.count(Kind.LOG_ONLY) + "(严格口径=块内每条顶层语句都是 log 调用;"
|
||
+ "验收基线 249 那一版把『log 后紧跟 return』也算进来了,所以更宽)");
|
||
assertTrue(r.count(Kind.EMPTY) <= GIVEN_EMPTY,
|
||
() -> "空体 catch 超过验收基线 " + GIVEN_EMPTY + ":现在是 " + r.count(Kind.EMPTY));
|
||
assertTrue(r.count(Kind.EMPTY) <= STRICT_EMPTY,
|
||
() -> "空体 catch 超过本轮严格口径实测 " + STRICT_EMPTY + ":现在是 " + r.count(Kind.EMPTY)
|
||
+ ",空体是三类高危出口里最贵的一种(连日志都不留)");
|
||
}
|
||
|
||
/**
|
||
* 恒等式:total = rethrow + notRethrow(含只 log) + empty。
|
||
*
|
||
* <p>不这么钉的话,往分类器里加一个"新格子"就能把气味块从三格里悄悄搬走,
|
||
* 三个数字同时下降而总噪声一点没少——这正是"内部搬家"绕过棘轮的形状。
|
||
*/
|
||
@Test
|
||
void categoriesPartitionTheWholeDenominator() {
|
||
Result r = tree();
|
||
int rethrow = r.count(Kind.RETHROW);
|
||
int silent = r.notRethrowIncludingLogOnly();
|
||
int empty = r.count(Kind.EMPTY);
|
||
assertEquals(r.total(), rethrow + silent + empty,
|
||
() -> "分类没覆盖全部 catch:total=" + r.total() + " 而 rethrow+notRethrow+empty="
|
||
+ (rethrow + silent + empty) + ",有块掉在缝里了");
|
||
assertTrue(rethrow > 0 && silent > 0 && empty > 0,
|
||
() -> "某一格是 0,说明分类器根本没往那里判过:rethrow=" + rethrow
|
||
+ " notRethrow=" + silent + " empty=" + empty);
|
||
}
|
||
|
||
/** 每条气味块都要能定位到 文件:行号——只有标量的棘轮会被"这里加一条那里减一条"绕过去。 */
|
||
@Test
|
||
void everySilentSiteIsLocatable() {
|
||
List<Site> sites = tree().sites();
|
||
assertTrue(sites.stream().allMatch(s -> s.line() > 0), "有 catch 的定位行号是 0,清单没法用");
|
||
long distinctFiles = tree().byFile().keySet().size();
|
||
assertTrue(distinctFiles > 100,
|
||
() -> "只有 " + distinctFiles + " 个文件带 catch,分母不像整棵树");
|
||
// 单位自证:文件数 != 处数。若两者相等,说明我(或后人)把"每文件一处"当成了口径。
|
||
assertTrue(sites.size() != distinctFiles,
|
||
() -> "处数(" + sites.size() + ")恰好等于文件数(" + distinctFiles
|
||
+ ")——这几乎不可能是真的,倒像是把文件数当成了处数");
|
||
}
|
||
|
||
/**
|
||
* 注入自证(正例):内存里造四种形状的 catch,扫描器必须一种都不放过、且判对类。
|
||
*
|
||
* <p>没有这一条,"四个数都 ≤ 基线"完全可能是恒真的——分类器返回空清单时它照样绿。
|
||
*/
|
||
@Test
|
||
void injectedSitesAreCountedAndClassified() {
|
||
Map<String, String> injected = new LinkedHashMap<>();
|
||
injected.put("Harness.java", String.join("\n",
|
||
"class Harness {",
|
||
" void emptyBody() { try { work(); } catch (Exception e) { } }",
|
||
" void logOnly() { try { work(); } catch (Exception e) { log.warn(\"skip\"); } }",
|
||
" void swallowWithSideEffect() { try { work(); } catch (Exception e) { marks.add(1); } }",
|
||
" void rethrows() { try { work(); } catch (Exception e) { throw new IllegalStateException(e); } }",
|
||
" void logThenReturn() { try { work(); } catch (Exception e) { log.warn(\"x\"); return; } }",
|
||
"}",
|
||
""));
|
||
Result r = SilentCatchScanner.scanSources(injected);
|
||
assertEquals(5, r.total(), "注入的 5 处 catch 没全数出来");
|
||
assertEquals(1, r.count(Kind.EMPTY), "空体那处没判成 EMPTY");
|
||
assertEquals(1, r.count(Kind.LOG_ONLY), "只有 log 的那处没判成 LOG_ONLY");
|
||
assertEquals(2, r.count(Kind.NOT_RETHROW),
|
||
"带副作用的不重抛(marks.add / log+return)应是 2 处");
|
||
assertEquals(1, r.count(Kind.RETHROW), "重抛那处不该被算成静默");
|
||
assertEquals(3, r.notRethrowIncludingLogOnly(),
|
||
"不重抛这一格(含只 log)应是 3 处:marks.add 那处 + log 后接 return 那处 + 纯 log 那处"
|
||
+ "(空体单列一格,不在这格里)");
|
||
// 反证:同一份内容里如果一个字都不加,总数就是 0——证明上面的数字来自注入而非主树
|
||
assertEquals(0, SilentCatchScanner.scanSources(Map.of()).total());
|
||
}
|
||
|
||
/**
|
||
* 注入自证(词法陷阱):字符字面量与转义引号不许吃掉后半棵树。
|
||
*
|
||
* <p>这是用户点名的坑:{@code '\"'} 与 {@code '\''} 处理不对,后面的 {@code catch} 就整片消失
|
||
* (翻车版扫出 818 vs 真实 1000)。这里用一份小夹具把两种陷阱和真 catch 混在一起,
|
||
* 要求扫描器只数到真 catch,同时独立字面量口径必须数到更多——两口径的差值本身就是证据。
|
||
*/
|
||
@Test
|
||
void charLiteralsAndEscapedQuotesDoNotBlindTheLexer() {
|
||
// 文本块里的 \\ 会变成一个反斜杠,于是夹具里是货真价实的 \" 与 '\'' 与 '\\'
|
||
String trapSource = """
|
||
class Trap {
|
||
String decoy = "a decoy \\" catch ( inside a string";
|
||
char apostrophe = '\\'';
|
||
char backChar = '\\\\';
|
||
char quoteChar = '"';
|
||
String after = "still here";
|
||
void real() { try { work(); } catch (Exception e) { marks.add(1); } }
|
||
void alsoReal() { try { work(); } catch (IllegalStateException e) { } }
|
||
}
|
||
""";
|
||
Map<String, String> trap = Map.of("Trap.java", trapSource);
|
||
int naive = SilentCatchScanner.countNaiveLiteral(trap);
|
||
int scanned = SilentCatchScanner.scanSources(trap).total();
|
||
assertEquals(2, scanned,
|
||
() -> "真 catch 只有 2 处,扫描器数出 " + scanned
|
||
+ " 处——字面量一处理错,后面的代码就整段被吞(818 vs 1000 那个形状)");
|
||
assertNotEquals(naive, scanned,
|
||
"字符串里的 decoy catch 也被数进来了:说明扫描器根本没在剥字符串(两口径此刻必须不同)");
|
||
assertTrue(naive > scanned,
|
||
() -> "字面量口径(" + naive + ")应大于词法口径(" + scanned + "),因为夹具里埋了一条假 catch");
|
||
assertEquals(1, naive - scanned, "两口径的差应当正好是字符串里那一条 decoy");
|
||
}
|
||
|
||
/** 打当前四格计数与假 catch 清单(口径复核用,不产生断言)。 */
|
||
@Test
|
||
void printCurrentCounts() {
|
||
Result r = tree();
|
||
Map<String, String> raw = readTree();
|
||
System.out.println("CATCH total=" + r.total() + " rethrow=" + r.count(Kind.RETHROW)
|
||
+ " notRethrow(incl logOnly)=" + r.notRethrowIncludingLogOnly()
|
||
+ " logOnly=" + r.count(Kind.LOG_ONLY) + " empty=" + r.count(Kind.EMPTY)
|
||
+ " files=" + r.byFile().size()
|
||
+ " naive=" + SilentCatchScanner.countNaiveLiteral(raw)
|
||
+ " decoy=" + SilentCatchScanner.decoyOccurrences(raw).size());
|
||
System.out.println("DECOY_BEGIN");
|
||
SilentCatchScanner.decoyOccurrences(raw).forEach(d ->
|
||
System.out.println("DECOY " + d.file() + ":" + d.line() + " | " + d.context()));
|
||
System.out.println("DECOY_END");
|
||
}
|
||
|
||
// ==== §2 后端「静默出口成片」那行的**另一半**:三类出口必须含 throw 或显式锚点 ====
|
||
|
||
/**
|
||
* 任务书这一行写的是两件事:①扫描器进测试做只许减棘轮(上面那批用例);②回传/落库/扣次数
|
||
* 三类必须含 throw 或显式锚点。<b>②从来没被测过</b>——{@code Site.hasAnchor()} 在扫描器里
|
||
* 躺了几天、一个调用者都没有,而那行格子一直按"达标"计。现在把它做成真判据。
|
||
*
|
||
* <p>锚点约定是 ASCII 的 {@code [tag]}:扫描器的正则是
|
||
* {@code \[[A-Za-z0-9_.-]{3,}\]},中文方括号标签根本匹配不上。任务书里写的
|
||
* {@code [静默降级]} 属**命名与代码不一致**,这里按代码为准,锚点用 {@code [silent-degrade]}。
|
||
*
|
||
* <p>台账逐处按文件点名(只钉总数=允许"内部搬家"绕过,见本仓反复出现的那族错误)。
|
||
*/
|
||
@Test
|
||
void threeCategoriesMustRethrowOrCarryAnchor() {
|
||
Map<String, Integer> gap = gapLedger(tree().sites());
|
||
assertEquals(GAP_LEDGER, gap, () -> "三类静默出口台账变了:实测 " + gap
|
||
+ "(合计 " + gap.values().stream().mapToInt(Integer::intValue).sum() + ")"
|
||
+ "。新增要逐处记名,收掉要连这个常量一起降。");
|
||
assertFalse(gap.isEmpty(), "台账是空的 ⇒ 三类里一处静默出口都没扫到,这条判据恒真");
|
||
}
|
||
|
||
/**
|
||
* 注入自证:四种形状要判出三种结果——带 throw 放过、带锚点放过、两者都没有才记缺口,
|
||
* 无关类别连进名单都不许进。没有这条,上面那个 assertEquals 可能是"扫描器什么都不返回"的假绿。
|
||
*/
|
||
@Test
|
||
void anchorAndThrowBothCloseTheGapOnlyWhenActuallyPresent() {
|
||
Map<String, String> src = new LinkedHashMap<>();
|
||
src.put("Feed.java", "class T { void f() { try { report(feed); } "
|
||
+ "catch (Exception e) { log.warn(\"feed down\"); } } }");
|
||
src.put("Anchored.java", "class T { void f() { try { report(feed); } "
|
||
+ "catch (Exception e) { log.warn(\"[silent-degrade] feed down\"); } } }");
|
||
src.put("Throwing.java", "class T { void f() { try { report(feed); } "
|
||
+ "catch (Exception e) { throw new IllegalStateException(e); } } }");
|
||
src.put("Unrelated.java", "class T { void f() { try { socket.close(); } "
|
||
+ "catch (Exception e) { log.warn(\"x\"); } } }");
|
||
Map<String, Integer> gap = gapLedger(SilentCatchScanner.scanSources(src).sites());
|
||
assertEquals(Map.of("Feed.java", 1), gap,
|
||
() -> "只该抓到『既没 throw 也没锚点』的那一处,实抓 " + gap);
|
||
}
|
||
|
||
/**
|
||
* 三类判据:块体里出现这些字样才算回传/落库/扣次数的出口。
|
||
* 名单刻意窄——宁可少收,也不把无关 catch 卷进台账(卷进来会让"只许减"变成没人敢动的死数)。
|
||
*/
|
||
private static final Map<String, java.util.regex.Pattern> CATEGORY = Map.of(
|
||
"回传", java.util.regex.Pattern.compile("回传|report|feed|Result|notify|Notify"),
|
||
"落库", java.util.regex.Pattern.compile("\\.save\\(|\\.insert|\\.update|Mapper|Repository|updateById"),
|
||
"扣次数", java.util.regex.Pattern.compile("次数|deduct|Deduct|usage|Usage|refund|Refund|balance|Balance"));
|
||
|
||
/**
|
||
* 三类里"既没重抛也没锚点"的那些 catch,按文件计数。
|
||
*
|
||
* <p>RETHROW 直接排除(那正是我们要的形状);锚点判定走 {@link Site#hasAnchor()},
|
||
* 它看的是 rawBody——{@code body} 剥过注释,会把字符串里的 {@code [tag]} 一起剥掉,
|
||
* 于是"打了锚点"反而判成没锚点(扫描器 javadoc 里记着这条,别改回去)。
|
||
*/
|
||
private static Map<String, Integer> gapLedger(List<Site> sites) {
|
||
Map<String, Integer> out = new java.util.TreeMap<>();
|
||
for (Site s : sites) {
|
||
if (s.kind() == Kind.RETHROW) {
|
||
continue;
|
||
}
|
||
boolean hit = false;
|
||
for (java.util.regex.Pattern p : CATEGORY.values()) {
|
||
if (p.matcher(s.rawBody()).find()) {
|
||
hit = true;
|
||
break;
|
||
}
|
||
}
|
||
if (hit && !s.hasAnchor()) {
|
||
out.merge(s.file(), 1, Integer::sum);
|
||
}
|
||
}
|
||
return out;
|
||
}
|
||
|
||
/** 10-09 实测基线:三类里"吞掉且没有锚点"的 11 处(按文件点名)。收掉一处就往下改。 */
|
||
private static final Map<String, Integer> GAP_LEDGER = Map.ofEntries(
|
||
Map.entry("com/nanri/aiimage/modules/convert/service/ConvertRunService.java", 1),
|
||
Map.entry("com/nanri/aiimage/modules/dedupe/service/DedupeRunService.java", 2),
|
||
Map.entry("com/nanri/aiimage/modules/dedupe/service/DedupeTotalDataService.java", 1),
|
||
Map.entry("com/nanri/aiimage/modules/deletebrand/service/DeleteBrandRunService.java", 1),
|
||
Map.entry("com/nanri/aiimage/modules/deletebrand/service/DeleteBrandTaskStorageService.java", 1),
|
||
Map.entry("com/nanri/aiimage/modules/pricetrack/service/PriceTrackTaskService.java", 1),
|
||
Map.entry("com/nanri/aiimage/modules/shopmatch/service/ShopMatchTaskService.java", 1),
|
||
Map.entry("com/nanri/aiimage/modules/similarasin/service/SimilarAsinImagePrefetchService.java", 1),
|
||
Map.entry("com/nanri/aiimage/modules/similarasin/service/support/SimilarAsinPipelineSupport.java", 1),
|
||
Map.entry("com/nanri/aiimage/modules/split/service/SplitRunService.java", 1));
|
||
|
||
private static Map<String, String> readTree() {
|
||
Map<String, String> out = new LinkedHashMap<>();
|
||
try (var walk = Files.walk(TREE)) {
|
||
for (Path p : walk.filter(Files::isRegularFile)
|
||
.filter(p -> p.getFileName().toString().endsWith(".java")).sorted().toList()) {
|
||
out.put(TREE.relativize(p).toString().replace('\\', '/'),
|
||
new String(Files.readAllBytes(p), StandardCharsets.UTF_8));
|
||
}
|
||
} catch (IOException e) {
|
||
throw new UncheckedIOException(e);
|
||
}
|
||
return out;
|
||
}
|
||
|
||
private static Path moduleRoot() {
|
||
Path here = Path.of("").toAbsolutePath();
|
||
if (Files.isDirectory(here.resolve("src/main/java"))) {
|
||
return here;
|
||
}
|
||
Path nested = here.resolve("backend-java");
|
||
if (Files.isDirectory(nested.resolve("src/main/java"))) {
|
||
return nested;
|
||
}
|
||
throw new IllegalStateException("无法定位 backend-java 模块目录(cwd=" + here + ")");
|
||
}
|
||
}
|