GORM事务回滚不生效？检查这7个隐藏配置项：dialect、prepareStmt、default_transaction

第一章：GORM事务回滚失效的典型现象与诊断路径

当执行数据库写入操作后，即使显式调用 tx.Rollback()，数据仍被持久化到数据库中——这是 GORM 事务回滚失效最典型的表征。该问题常被误判为“GORM Bug”，实则多源于事务生命周期管理不当或底层驱动行为差异。

常见失效场景

事务对象未被正确传递：在嵌套函数调用中直接使用 db.Create() 而非 tx.Create()，导致操作脱离事务上下文
defer tx.Rollback() 未配合 if err != nil 条件判断，导致成功路径也触发回滚（实际无副作用但易掩盖逻辑错误）
使用 SQLite 等不支持 SAVEPOINT 的驱动时，嵌套事务调用 tx.Rollback() 会静默失败（GORM 不报错但不生效）
Go 协程中并发使用同一事务实例，引发状态竞争与上下文丢失

快速诊断步骤

在事务块起始处添加日志：fmt.Printf("tx ID: %p, DB: %v\n", tx, tx.Statement.ConnPool)，确认事务对象未被意外重赋值
检查事务是否已提交：if tx.Commit(); tx.Error == nil { /* 已提交 */ } —— 若 Commit() 成功，则后续 Rollback() 必然无效
启用 GORM 日志并过滤事务语句：db.Session(&gorm.Session{Logger: logger.Default.LogMode(logger.Info)}).Transaction(...)，观察是否出现 BEGIN 但缺失对应 ROLLBACK

验证回滚是否生效的最小代码

err := db.Transaction(func(tx *gorm.DB) error {
    // 插入测试记录
    if err := tx.Create(&User{Name: "test"}).Error; err != nil {
        return err
    }
    // 强制触发回滚
    return errors.New("intentional rollback trigger") // 此错误将使 GORM 自动 Rollback
})
// 检查数据是否真的被回滚
var count int64
db.Model(&User{}).Where("name = ?", "test").Count(&count)
fmt.Printf("残留记录数: %d\n", count) // 应输出 0

关键驱动兼容性对照

驱动	支持 SAVEPOINT	嵌套事务 `Rollback()` 行为	推荐处理方式
MySQL	✅	正常回滚至最近 SAVEPOINT	可安全使用嵌套事务
PostgreSQL	✅	同上	同上
SQLite	❌	`Rollback()` 对外层事务无效	避免嵌套，改用单层事务控制

第二章：数据库方言与驱动层配置陷阱

2.1 dialect配置对事务隔离级别的隐式覆盖

Spring Boot中spring.jpa.database-platform（即dialect）不仅决定SQL方言，还会静默覆盖显式声明的事务隔离级别。

隐式覆盖机制

不同数据库方言在初始化时会绑定默认隔离级别：

MySQL57Dialect → 默认REPEATABLE_READ
PostgreSQL95Dialect → 默认READ_COMMITTED
H2Dialect → 默认READ_UNCOMMITTED

配置冲突示例

# application.yml
spring:
  jpa:
    database-platform: org.hibernate.dialect.PostgreSQLDialect
    hibernate:
      ddl-auto: validate
  datasource:
    url: jdbc:postgresql://localhost/test
    # 未显式设置 isolation-level → 由 dialect 决定

⚠️ 即使@Transactional(isolation = Isolation.SERIALIZABLE)被声明，若底层JDBC连接不支持该级别（如PostgreSQL实际仅支持到READ_COMMITTED），Hibernate将降级并静默使用dialect默认值，不抛异常。

支持级别对照表

Dialect	默认隔离级别	是否支持 SERIALIZABLE	运行时行为
MySQL57Dialect	REPEATABLE_READ	✅	强制生效
PostgreSQL95Dialect	READ_COMMITTED	❌	降级为 READ_COMMITTED
H2Dialect	READ_UNCOMMITTED	✅（内存模式）	依连接参数动态调整

// 实际生效的隔离级别取决于 dialect + JDBC driver 能力
@Transactional(isolation = Isolation.SERIALIZABLE)
public void criticalOperation() {
    // 可能运行在 READ_COMMITTED 下，而非预期 SERIALIZABLE
}

Hibernate在ConnectionProvider.getConnection()后调用dialect.getDefaultIsolation()，覆盖@Transactional.isolation——这是非显式、不可绕过的覆盖链。

2.2 prepareStmt启用导致预编译语句绕过事务上下文

当 JDBC 连接参数 prepareStatement 启用（如 useServerPrepStmts=true&cachePrepStmts=true），MySQL 驱动会将 PreparedStatement 交由服务端预编译，但部分版本中该路径不绑定当前事务上下文。

事务隔离失效场景

应用层开启事务后执行 ps.execute()
服务端预编译语句在独立会话中执行，忽略 BEGIN/COMMIT 边界
导致 DML 操作提交不可控，破坏 ACID

关键参数对照表

参数	默认值	影响
`useServerPrepStmts`	false	true 时启用服务端预编译
`rewriteBatchedStatements`	false	与预编译叠加时加剧事务脱离

// 示例：看似在事务内，实则绕过
conn.setAutoCommit(false);
PreparedStatement ps = conn.prepareStatement("INSERT INTO t VALUES (?)");
ps.setInt(1, 100);
ps.execute(); // 若 useServerPrepStmts=true，此执行可能立即持久化
conn.commit(); // 此处 commit 对上述语句无效

逻辑分析：ps.execute() 在服务端预编译模式下，MySQL 将其视为独立语句执行，不参与客户端连接的事务状态机；conn 的 transaction_id 未透传至服务端预编译缓存句柄。

graph TD
    A[应用调用ps.execute] --> B{useServerPrepStmts=true?}
    B -->|是| C[服务端查预编译缓存]
    C --> D[直接执行，忽略客户端事务状态]
    B -->|否| E[客户端模拟预编译]
    E --> F[严格遵循conn事务上下文]

2.3 driver特定参数（如mysql.parseTime、postgres.sslmode）引发连接会话分裂

当数据库驱动启用 mysql.parseTime=true 或 postgres.sslmode=require 等会话级参数时，连接池会将参数组合视为独立会话上下文，导致物理连接无法复用。

参数敏感性机制

驱动在建立连接后读取并固化参数快照
连接池按参数哈希值分桶管理连接
不同参数组合 → 不同连接池子集 → 会话分裂

典型配置对比

驱动	参数示例	影响范围
MySQL JDBC	`parseTime=true`	`TIMESTAMP` 解析行为变更
PostgreSQL	`sslmode=verify-full`	TLS证书校验强度升级

// 连接URL中隐含会话分裂风险
String url1 = "jdbc:mysql://db/?parseTime=true&useSSL=false";
String url2 = "jdbc:mysql://db/?parseTime=false&useSSL=true";
// → 即使同一DB实例，驱动视为两个不兼容会话类型

该URL差异触发MySQL驱动生成不同ConnectionImpl初始化路径，底层TimeZone与SocketFactory绑定不可互换，强制新建连接。

graph TD
    A[应用请求连接] --> B{参数哈希匹配?}
    B -->|命中| C[复用现有连接]
    B -->|未命中| D[新建连接+参数固化]
    D --> E[加入对应参数桶]

2.4 连接池配置（MaxOpenConns/MaxIdleConns）与事务生命周期冲突分析

连接池参数的本质约束

MaxOpenConns 限制同时打开的物理连接总数，MaxIdleConns 控制空闲连接的最大缓存数。二者共同决定连接复用能力与资源上限。

事务未提交导致的连接滞留

当开启事务但未显式 Commit() 或 Rollback() 时，连接不会归还池中——即使事务逻辑已执行完毕：

tx, _ := db.Begin()
_, _ := tx.Exec("INSERT INTO users(name) VALUES(?)", "alice")
// 忘记 tx.Commit() → 此连接持续占用，计入 MaxOpenConns

⚠️ 分析：该连接将长期处于“已打开、未释放”状态，阻塞后续获取连接请求；若并发事务数 ≥ MaxOpenConns，新请求将阻塞或超时（取决于 ConnMaxLifetime 和 SetConnMaxIdleTime）。

冲突场景对比表

场景	MaxOpenConns=5	MaxIdleConns=3	后果
5个长事务未提交	✅ 全部占用	❌ 无空闲连接可用	新请求阻塞
3个短事务 + 2个泄漏事务	⚠️ 池满	⚠️ Idle=0	连接复用率归零

生命周期管理建议

始终使用 defer tx.Rollback() 配合 if err == nil { tx.Commit() }
设置 db.SetConnMaxIdleTime(30 * time.Second) 主动回收陈旧空闲连接
启用 sql.DB.Stats() 实时监控 OpenConnections 与 InUse 差值

graph TD
    A[事务开始] --> B{Commit/Rollback?}
    B -->|是| C[连接归还池]
    B -->|否| D[连接持续占用]
    D --> E[可能触发 MaxOpenConns 阻塞]

2.5 数据库服务端默认事务行为（autocommit=1）与GORM显式事务的对抗验证

autocommit=1 的底层语义

MySQL 默认开启 autocommit=1，即每条 DML 语句（INSERT/UPDATE/DELETE）均自动提交，无显式事务上下文。此时 START TRANSACTION 仅临时关闭 autocommit，直至 COMMIT 或 ROLLBACK 后恢复。

GORM 显式事务的覆盖机制

GORM 通过 db.Transaction() 创建独立事务会话，内部执行 SET autocommit = 0，并绑定连接生命周期。该设置不改变服务端全局配置，仅作用于当前连接会话。

对抗验证示例

// 验证：即使服务端 autocommit=1，GORM 事务仍可回滚
err := db.Transaction(func(tx *gorm.DB) error {
    tx.Create(&User{Name: "Alice"}) // 不提交到数据库
    return errors.New("force rollback") // 触发回滚
})
// 此时 User 记录不会写入

逻辑分析：db.Transaction() 获取新连接 → 执行 SET autocommit = 0 → 所有操作在该连接内累积 → 异常时发送 ROLLBACK → 连接归还池前恢复 autocommit = 1。

行为对比表

场景	autocommit=1（直连）	GORM Transaction()
单条 INSERT	立即持久化	仅内存暂存，需 COMMIT
错误发生	已提交不可逆	自动 ROLLBACK
连接复用	保持 autocommit=1	每次事务独占连接并重置状态

graph TD
    A[应用发起 Transaction] --> B[获取空闲连接]
    B --> C[执行 SET autocommit = 0]
    C --> D[执行业务 SQL]
    D --> E{是否出错？}
    E -->|是| F[ROLLBACK + SET autocommit = 1]
    E -->|否| G[COMMIT + SET autocommit = 1]
    F & G --> H[连接归还连接池]

第三章：GORM会话级事务控制配置深度解析

3.1 Session选项中TransactionMode与NewTx的语义差异与误用场景

核心语义对比

TransactionMode 控制 Session 是否参与当前事务上下文（如 Required、Never），而 NewTx 强制开启全新独立事务，无视外层事务边界。

典型误用场景

在嵌套调用中对只读操作误设 NewTx → 无谓开销 + 隔离级别冲突
将 TransactionMode.Never 用于需一致性校验的写操作 → 数据竞态

行为差异对照表

选项	外层有事务时行为	外层无事务时行为	是否可回滚
`TransactionMode.Required`	加入外层事务	自启新事务	是
`NewTx`	启动新事务（挂起外层）	启动新事务	是

# 错误示例：在已存在事务的 ServiceA 中调用 ServiceB 时强制 NewTx
session.execute("UPDATE balance SET amount = ? WHERE id = ?", 
                [new_amt, user_id], 
                options={"TransactionMode": "Required"})  # ✅ 应复用
# 而非 options={"NewTx": True}  # ❌ 破坏事务原子性

该配置导致外层事务无法感知 ServiceB 的变更，违反 ACID 的原子性约束。NewTx 仅适用于明确需隔离执行的补偿逻辑（如日志归档）。

3.2 Context超时传递对事务提交/回滚决策链的中断机制

当 context.WithTimeout 传播至事务边界时，超时信号会沿调用链逆向触发提前终止，覆盖默认的两阶段提交（2PC）决策逻辑。

超时中断的传播路径

ctx, cancel := context.WithTimeout(parentCtx, 500*time.Millisecond)
defer cancel()
tx, err := db.BeginTx(ctx, nil) // ctx 被注入事务上下文
if err != nil {
    // 若 ctx 已超时，此处立即返回 context.DeadlineExceeded
    return err
}

该代码中，BeginTx 内部监听 ctx.Done()；一旦超时，sql.Tx 构造失败，后续 Commit()/Rollback() 不会被调用——决策链在起点即被截断。

决策链状态转移表

当前状态	收到 ctx.Done()	结果行为
未开始执行	✅	`BeginTx` 返回超时错误
执行中（DML）	✅	驱动层主动发送 `ROLLBACK`
`Commit()` 调用中	✅	`Commit` 返回 `context.Canceled`

关键中断点示意图

graph TD
    A[HTTP Handler] --> B[Service Layer]
    B --> C[Repo BeginTx]
    C --> D[DB Driver Hook]
    D -->|ctx.Done()| E[Abort Decision]
    E --> F[Rollback Initiated]

3.3 DisableForeignKeyConstraintWhenMigrating对事务原子性的隐蔽破坏

当启用 DisableForeignKeyConstraintWhenMigrating = true 时，EF Core 在迁移执行前临时禁用外键约束，绕过数据库完整性校验。

迁移过程中的约束状态切换

// EF Core 7+ 中的典型迁移上下文配置
optionsBuilder.UseSqlServer(connectionString, 
    sqlServerOptions => sqlServerOptions
        .EnableRetryOnFailure()
        .DisableForeignKeyConstraintWhenMigrating(true)); // ⚠️ 静默跳过 FK 检查

该设置使 ALTER TABLE ... DROP CONSTRAINT 和 INSERT/UPDATE 操作脱离外键保护，导致数据不一致风险——即使迁移脚本包裹在 BEGIN TRANSACTION 中，约束缺失使事务无法保证逻辑完整性。

原子性失效场景对比

场景	约束启用时	约束禁用时
插入孤儿记录	抛出 `SqlException`，事务回滚	成功提交，违反业务语义

数据一致性破坏路径

graph TD
    A[Start Migration] --> B[DROP FK Constraint]
    B --> C[Run Data-Modifying Up Operation]
    C --> D[INSERT ReferencedId=NULL]
    D --> E[ADD FK Constraint]
    E --> F[Constraint Active BUT Data Invalid]

外键禁用后，事务仅保障语句执行成功，不保障业务规则；
约束重建不验证历史数据，脏数据永久滞留。

第四章：SQL标准与数据库特性相关事务配置项

4.1 default_transaction_isolation在PostgreSQL中的实际生效条件与GORM映射偏差

PostgreSQL 的 default_transaction_isolation 仅对未显式指定隔离级别的新事务生效，且不覆盖客户端驱动层的显式设置。

GORM 的默认行为陷阱

GORM v1.23+ 默认使用 ReadCommitted，但会忽略数据库侧 default_transaction_isolation 配置：

// GORM 连接初始化（强制覆盖隔离级别）
db, _ := gorm.Open(postgres.Open(dsn), &gorm.Config{
  PrepareStmt: true,
})
// 注意：GORM 不读取 pg_settings.default_transaction_isolation

⚠️ 逻辑分析：GORM 在 Begin() 时直接发送 BEGIN TRANSACTION ISOLATION LEVEL READ COMMITTED，绕过 PostgreSQL 全局配置。default_transaction_isolation 仅在 psql 或裸 lib/pq 执行 BEGIN 时生效。

生效条件对比表

场景	是否受 `default_transaction_isolation` 影响
psql 中执行 `BEGIN;`	✅ 是
GORM `db.Transaction(...)`	❌ 否（硬编码 `READ COMMITTED`）
lib/pq 手动 `tx, _ := db.Begin()`	❌ 否（需显式 `tx.Query("SET TRANSACTION ISOLATION LEVEL ...")`）

隔离级别映射偏差流程

graph TD
  A[GORM Transaction] --> B[生成 BEGIN语句]
  B --> C{是否指定 IsolationLevel?}
  C -->|否| D[固定为 READ COMMITTED]
  C -->|是| E[使用传入值]
  D --> F[忽略 postgresql.conf 中的 default_transaction_isolation]

4.2 sql_mode（MySQL）中STRICT_TRANS_TABLES对事务回滚触发时机的影响实验

实验环境准备

SET sql_mode = 'STRICT_TRANS_TABLES';
START TRANSACTION;
INSERT INTO users (id, name) VALUES (1, ''); -- name 为 NOT NULL VARCHAR(10)

该语句在 STRICT_TRANS_TABLES 下立即报错并中断当前语句，但事务未自动回滚——需显式 ROLLBACK 或由客户端处理异常。

触发时机对比表

sql_mode 设置	插入空字符串行为	事务状态是否自动回滚
`STRICT_TRANS_TABLES`	语句级失败，错误立即抛出	❌ 否
`STRICT_TRANS_TABLES,ERROR_FOR_DIVISION_BY_ZERO`	同上	❌ 否
空（默认宽松模式）	截断/警告，语句成功	—

回滚逻辑流程

graph TD
    A[执行 INSERT] --> B{STRICT_TRANS_TABLES 启用？}
    B -->|是| C[校验失败 → SQLSTATE 45000 抛出]
    B -->|否| D[警告 + 自动修正 → 成功提交]
    C --> E[事务仍 ACTIVE，需显式 ROLLBACK]

关键点：STRICT_TRANS_TABLES 提升数据一致性校验强度，但不改变事务边界语义——它影响的是单条语句的成败判定时机，而非自动事务控制。

4.3 SQLite WAL模式下journal_mode与事务持久化一致性校验

WAL（Write-Ahead Logging）模式通过分离写操作与读操作提升并发性能，但其持久化语义高度依赖 journal_mode 的协同配置。

WAL 模式下的 journal_mode 取值语义

WAL：启用 WAL 日志，主数据库文件可被并发读取；检查点（checkpoint）决定日志回放时机
DELETE / TRUNCATE：强制退回到传统 rollback journal，禁用 WAL
OFF：完全禁用日志，无崩溃恢复能力

事务持久化一致性关键路径

PRAGMA journal_mode = WAL;
PRAGMA synchronous = NORMAL; -- 注意：WAL 下 FULL 更安全，但影响吞吐
BEGIN IMMEDIATE;
INSERT INTO users(name) VALUES('alice');
COMMIT; -- 此刻仅保证写入 wal 文件，非 fsync 到磁盘

上述 COMMIT 在 synchronous = NORMAL 下不触发 fsync(wal)，仅刷写到 OS 缓存。若系统崩溃，未 checkpoint 的 WAL 记录可能丢失，破坏 ACID 中的 Durability。

WAL 持久性校验矩阵

journal_mode	synchronous	崩溃后数据一致性	适用场景
WAL	FULL	✅ 强一致	金融、审计系统
WAL	NORMAL	⚠️ 可能丢失最近事务	高吞吐低敏感场景

graph TD
    A[START COMMIT] --> B{sync=FULL?}
    B -->|Yes| C[fsync WAL + wal-header]
    B -->|No| D[OS cache only]
    C --> E[Checkpoint-safe]
    D --> F[Crash可能丢失]

校验逻辑需在应用层结合 PRAGMA wal_checkpoint(FULL) 与 PRAGMA journal_size_limit 进行动态一致性断言。

4.4 SQL Server中SET XACT_ABORT ON/OFF对GORM嵌套事务回滚传播的决定性作用

行为差异根源

SQL Server 的 SET XACT_ABORT 控制语句级错误是否终止整个事务批处理。ON 时，任何运行时错误（如主键冲突、类型转换失败）立即回滚整个事务；OFF 时仅回滚当前语句，外层事务可能继续执行——这直接破坏 GORM 嵌套事务的原子性预期。

GORM 嵌套事务的实际表现

-- 示例：在存储过程或显式批处理中启用不同模式
SET XACT_ABORT OFF;
BEGIN TRY
  BEGIN TRAN;
    INSERT INTO users (id) VALUES (1); -- 成功
    INSERT INTO users (id) VALUES (1); -- 主键冲突，仅此语句失败
  COMMIT TRAN; -- ⚠️ 实际提交！违反GORM嵌套事务语义
END TRY ...

此场景下，GORM 外层 tx.Commit() 将成功，但内层因错误应整体回滚——XACT_ABORT OFF 导致语义断裂。

关键配置对照表

设置	错误发生后行为	GORM 嵌套事务兼容性	推荐值
`ON`	整个批处理回滚，`@@TRANCOUNT` 归零	✅ 完全兼容	强制启用
`OFF`	仅错误语句回滚，事务状态保留	❌ 破坏嵌套传播	禁用

回滚传播流程

graph TD
  A[GORM BeginTx] --> B[SQL Server: SET XACT_ABORT ON]
  B --> C[执行INSERT/UPDATE]
  C --> D{发生约束错误？}
  D -->|是| E[SQL Server立即ROLLBACK BATCH]
  E --> F[GORM detect error → rollback outer tx]
  D -->|否| G[Commit success]

第五章：构建高可靠GORM事务防护体系的最佳实践清单

事务边界必须显式声明而非依赖隐式上下文

在微服务场景中，某电商订单履约服务曾因误用 db.WithContext(ctx).Create(&order) 导致事务未生效——GORM 的 WithContext 仅传递上下文，不开启事务。正确做法是始终使用 tx := db.Begin() 显式启动，并配合 defer func() { if r := recover(); r != nil { tx.Rollback() } }() 实现 panic 安全回滚。

嵌套事务需严格遵循 Savepoint 语义

当库存扣减与积分更新需原子执行但又允许局部失败时，应避免直接嵌套 Begin()。以下为生产环境验证过的 Savepoint 写法：

tx := db.Begin()
defer tx.Close()
if err := tx.SavePoint("stock_deduct").Error; err != nil {
    return err
}
if err := tx.Model(&Stock{}).Where("id = ?", skuID).Update("quantity", gorm.Expr("quantity - 1")).Error; err != nil {
    tx.RollbackTo("stock_deduct")
    // 记录局部失败日志，继续执行积分逻辑
}

并发冲突必须结合乐观锁与重试机制

某秒杀系统因并发超卖引入版本号字段 version uint32，并配置 GORM 的 OptimisticLock：

type Product struct {
    ID      uint   `gorm:"primaryKey"`
    Version uint32 `gorm:"column:version;default:0"`
    Stock   int    `gorm:"column:stock"`
}
// 启用自动乐观锁
db.Callback().Query().Before("gorm:query").Register("optimistic_lock:select", func(db *gorm.DB) {
    if db.Statement.Schema != nil && db.Statement.Schema.FieldsByName["Version"] != nil {
        db.Statement.AddClause(clause.Select{
            Columns: clause.Columns{clause.Column{Name: "*"}, clause.Column{Name: "version"}},
        })
    }
})

事务超时需分层设置且可动态调整

层级	推荐超时值	配置方式	监控指标
数据库连接	30s	`&timeout=30s` 在 DSN 中	`pg_stat_activity.state`
GORM 事务	15s	`db.Exec("SET LOCAL statement_timeout = '15s'")`	`pg_stat_statements.total_time`
应用层兜底	20s	`context.WithTimeout(ctx, 20*time.Second)`	自定义 Prometheus counter

错误分类必须驱动差异化事务策略

IsUniqueConstraintError(err) → 不回滚，记录业务告警并返回友好提示
IsForeignKeyViolation(err) → 回滚并触发数据一致性校验任务
IsNetworkError(err) → 执行指数退避重试（最多3次），失败后转入异步补偿队列

日志必须包含事务 ID 与 SQL 执行链路

启用 GORM 的 logger 并注入 traceID：

db = db.Session(&gorm.Session{
    Logger: logger.Default.LogMode(logger.Info).
        WithContext(context.WithValue(context.Background(), "trace_id", "req_abc123")),
})
// 输出示例：[2024-06-15 10:23:41] [req_abc123] [1.23ms] SELECT * FROM orders WHERE id = 123

迁移脚本必须通过事务化 SQL 验证

所有 db.Migrator().AutoMigrate() 操作封装为原子迁移单元：

BEGIN;
ALTER TABLE users ADD COLUMN phone VARCHAR(20);
UPDATE users SET phone = CONCAT('1', mobile) WHERE mobile IS NOT NULL;
COMMIT;
-- 若中途失败，整个迁移回滚，避免表结构与数据不一致

测试必须覆盖事务中断场景

使用 sqlmock 模拟网络中断：

mock.ExpectQuery("SELECT.*").WillReturnError(fmt.Errorf("i/o timeout"))
mock.ExpectExec("UPDATE.*").WillReturnError(fmt.Errorf("connection refused"))
// 验证事务是否正确回滚且无残留状态

监控必须暴露事务成功率与平均耗时

通过 Prometheus 暴露指标：

graph LR
A[应用代码] --> B[GORM Hook]
B --> C[记录 begin/commit/rollback 事件]
C --> D[聚合 metrics_transaction_duration_seconds_bucket]
D --> E[Alert on rate\\(metrics_transaction_failure_total\\[5m]\\) > 0.1]