sycommon-python-lib 0.2.10a11__tar.gz → 0.2.10a12__tar.gz

{sycommon_python_lib-0.2.10a11 → sycommon_python_lib-0.2.10a12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sycommon-python-lib
-Version: 0.2.10a11
+Version: 0.2.10a12
 Summary: Add your description here
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown

{sycommon_python_lib-0.2.10a11 → sycommon_python_lib-0.2.10a12}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sycommon-python-lib"
-version = "0.2.10a11"
+version = "0.2.10a12"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.11"

{sycommon_python_lib-0.2.10a11 → sycommon_python_lib-0.2.10a12}/src/sycommon/logging/kafka_log.py

@@ -220,6 +220,20 @@ class KafkaSink:
         bootstrap_timeout_ms=10000：
             api_version 默认为 None，__init__ 会 eager bootstrap 拉取版本信息，
             broker 不可达时默认 30s 才超时。重建/惰性补建路径下 30s 太长，收到 10s。
+        enable_idempotence=False 的理由（2026-10-14 netsearch 生产事故复盘）：
+            kafka-python 3.x 把 enable_idempotence 默认从 False 静默改为 True，
+            日志 producer 被动卷进 PID/序列号/muted 整套幂等机制，触发两个库缺陷：
+            1. retention 型 UnknownProducerIdError 活锁：broker 因 retention 清掉
+               producer state 后持续回 UPIE，客户端 KAFKA-5793 分支每次都重置序列号
+               重试（该分支在 _can_retry 之前、不受 retries 约束），且
+               reset_sequence_for_partition 把 last_acked 一并弹掉（此后永远 -1），
+               导致每次都判成 retention-based → 无限重试（现场转了 2 分钟）。
+            2. muted.remove KeyError：幂等下 guarantee_message_order=True，批次被
+               双重完成（本地 delivery timeout 一次 + broker 迟到响应一次）时
+               _dispatch_error 尾部裸 muted.remove(tp) 第二次抛 KeyError，直接炸
+               出 "Uncaught error in kafka producer I/O thread"。
+            日志管道不需要 exactly-once（可容忍重复/丢失），关掉幂等后 UPIE 走
+            非重试分支直接 fail 进 errback（自愈信号），muted 集合彻底不用。
         """
         return KafkaProducer(
             bootstrap_servers=self._bootstrap_servers,
@@ -229,6 +243,7 @@ class KafkaSink:
             max_block_ms=5000,
             retries=5,
             request_timeout_ms=30000,
+            enable_idempotence=False,
             # delivery_timeout 由默认 120s 收紧到 45s：断网时批次最多积压 45s 就过期并触发
             # errback（自愈信号），而不是静默积压 2 分钟后才批量报错。约束：必须大于
             # linger_ms + request_timeout_ms（5 + 30000），45s 满足。
@@ -575,11 +590,16 @@ class KafkaSink:
         引用，故全程用 _rebuild_lock 保护，并置 _rebuild_in_progress 让 write()
         在此期间跳过惰性建 producer，避免重复构造。
 
-        关键：close() 内部会 join sender 线程（sender.join(timeout)），而本方法
+        关键一：close() 内部会 join sender 线程（sender.join(timeout)），而本方法
         正是从 sender 线程的 errback 链调进来的——若在锁内直接 close 旧 producer
-        会触发“在自己线程里 join 自己”的死锁。所以 flush/close 必须放在锁外，
-        且把 _rebuild_in_progress 始终维持到新 producer 就位，避免 join 期间又有
-        write() 介入。绝不在锁内做 close 这种长阻塞。"""
+        会触发"在自己线程里 join 自己"的死锁。所以 flush/close 必须放在锁外。
+
+        关键二（2026-10-14 生产事故复盘）：只放锁外还不够——errback 同步执行
+        flush(5s)+close(10s) 会让 kafka 的 IO 线程卡 15s（现场 14.9s，selector
+        慢任务看门狗连报 blocking the event loop），期间网络收发全部停摆。因此
+        整个 关旧/建新 挪到独立 daemon 线程执行，errback 立即返回。_rebuild_
+        in_progress 维持到新 producer 就位，期间 write() 跳过（日志丢弃语义与
+        原重建窗口一致）。"""
         with self._rebuild_lock:
             if self._rebuild_in_progress:
                 return  # 已有重建在进行，不重入
@@ -588,7 +608,17 @@ class KafkaSink:
             # 摘引用：write() 见到 _producer is None 且 _rebuild_in_progress 会跳过
             self._producer = None
             self._producer_obj = None
-        # flush/close 放锁外：close() 会 join sender 线程，绝不能在 sender 线程里持锁做
+        # 关旧/建新全在独立线程：绝不阻塞 kafka IO 线程（errback 调用方）与 loguru 线程
+        threading.Thread(
+            target=self._rebuild_worker, args=(old,),
+            name="kafka-sink-rebuild", daemon=True).start()
+
+    def _rebuild_worker(self, old):
+        """重建工作体（独立 daemon 线程内执行）。
+
+        close() 会 join sender 线程，绝不能在 sender 线程里做；bootstrap 不可达
+        会抛，吞掉，下次失败计数还会再触发。"""
+        # flush/close 放锁外且放本线程：join sender 线程最长 ~15s，别拖任何人
         if old is not None:
             try:
                 old.flush(timeout=5)
@@ -735,6 +765,13 @@ class KafkaLogger(metaclass=SingletonMeta):
         intercept_handler = _InterceptHandler()
         logging.root.handlers = [intercept_handler]
         logging.root.setLevel(logging.WARNING)
+        # kafka-python 内部日志降噪兜底（正常由 services.setup_logger_levels()
+        # 在插件链更早处设置；此处幂等重申）：故障期间库的 WARNING 风暴
+        # （UnknownProducerIdError 重试/selector 慢任务/批次过期）经 root 桥接
+        # 回灌 loguru 后又要发往同一故障 topic，形成放大回路（2026-10-14 复盘）。
+        for _name in ("kafka", "kafka.net", "kafka.net.selector",
+                      "kafka.net.connection", "kafka.producer"):
+            logging.getLogger(_name).setLevel(logging.ERROR)
 
         sys.excepthook = KafkaLogger._handle_exception
         # sys.excepthook 只管主线程；工作线程的未捕获异常走 threading.excepthook

{sycommon_python_lib-0.2.10a11 → sycommon_python_lib-0.2.10a12}/src/sycommon/logging/logger_levels.py

@@ -6,9 +6,15 @@ def setup_logger_levels():
     # Nacos 客户端：仅输出WARNING及以上（屏蔽INFO级的心跳/注册日志）
     logging.getLogger("nacos.client").setLevel(logging.WARNING)
 
-    # Kafka Python客户端：屏蔽INFO级的连接/版本检测日志
-    logging.getLogger("kafka.net.connection").setLevel(logging.WARNING)
-    logging.getLogger("kafka.producer").setLevel(logging.WARNING)
+    # Kafka Python客户端：屏蔽INFO级的连接/版本检测日志。
+    # kafka.* 整族压到 ERROR（2026-10-14 生产事故复盘）：故障期间库自身持续打
+    # WARNING——retention 型 UnknownProducerIdError 风暴（每秒多条）、selector
+    # 慢任务看门狗（kafka.net.selector）、批次过期——经 stdlib root 桥接回灌
+    # loguru 后又要发往同一个正在故障的 topic，形成放大回路。这些 WARNING 的
+    # 价值在 ERR 都有（sender 线程崩溃/批次最终失败），全部静音。
+    for _name in ("kafka", "kafka.net", "kafka.net.selector",
+                  "kafka.net.connection", "kafka.producer"):
+        logging.getLogger(_name).setLevel(logging.ERROR)
 
     # Uvicorn/FastAPI：屏蔽启动/应用初始化的INFO日志（保留ERROR/WARNING）
     # logging.getLogger("uvicorn").setLevel(logging.WARNING)

{sycommon_python_lib-0.2.10a11 → sycommon_python_lib-0.2.10a12}/src/sycommon_python_lib.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sycommon-python-lib
-Version: 0.2.10a11
+Version: 0.2.10a12
 Summary: Add your description here
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown

{sycommon_python_lib-0.2.10a11 → sycommon_python_lib-0.2.10a12}/src/sycommon_python_lib.egg-info/SOURCES.txt

@@ -352,6 +352,7 @@ tests/test_acp_tool.py
 tests/test_asyncio_logging.py
 tests/test_config_change_notifier.py
 tests/test_hotreload_snapshot.py
+tests/test_kafka_upie_fix.py
 tests/test_llm_apikey_contextvar.py
 tests/test_log_masker.py
 tests/test_resilient_pg_saver.py

sycommon_python_lib-0.2.10a12/tests/test_kafka_upie_fix.py

@@ -0,0 +1,401 @@
+"""KafkaSink 幂等 producer 事故修复的模拟验证（无真实 broker）。
+
+复现 2026-10-14 netsearch 生产事故链，并验证三处修复：
+  事故链（修复前）：
+    a. retention 型 UnknownProducerIdError（UPIE）活锁：broker 持续回 UPIE，
+       KAFKA-5793 分支每次重置序列号重试，不受 retries 约束 → 无限循环
+    b. muted.remove KeyError：批次双重完成（本地过期 + broker 迟到响应）时
+       _dispatch_error 尾部裸 remove 第二次抛 KeyError → 炸 sender IO 线程
+    c. _rebuild_producer 在 IO 线程同步 flush+close → selector 看门狗报
+       "ran for 14.9s blocking the event loop"
+  修复：
+    1. enable_idempotence=False —— UPIE 走非重试分支直接 fail；muted 不再使用
+    2. _rebuild_producer 挪独立 daemon 线程 —— errback 立即返回
+    3. kafka.* logger 压 ERROR —— UPIE/慢任务 WARNING 风暴不再回灌放大
+
+验证手段：
+  - A/B 对照：同一套 Sender._dispatch_error 驱动逻辑，分别构造
+    幂等(tm)/非幂等 producer 配置，数重试次数与 muted 状态
+  - 双重完成复现：同一 batch 先 timeout-fail 再 broker-err，
+    断言幂等路径 KeyError、非幂等路径无异常
+  - 真实 KafkaSink._rebuild_producer：假 producer 的 flush 计 1.5s，
+    断言 errback 调用线程不再被阻塞
+  - logger 级别：setup 后 kafka.* 均为 ERROR
+"""
+
+import contextlib
+import io
+import logging
+import sys
+import threading
+import time
+
+sys.path.insert(0, "src")
+
+from kafka.errors import UnknownProducerIdError  # noqa: E402
+from kafka.protocol.producer import ProduceResponse  # noqa: E402
+from kafka.producer.record_accumulator import RecordAccumulator  # noqa: E402
+from kafka.producer.sender import Sender  # noqa: E402
+from kafka.structs import TopicPartition  # noqa: E402
+
+from sycommon.logging.kafka_log import KafkaSink, KafkaLogger  # noqa: E402
+from sycommon.logging.logger_levels import setup_logger_levels  # noqa: E402
+
+PASS, FAIL = [], []
+
+
+def check(name, cond, detail=""):
+    (PASS if cond else FAIL).append(name)
+    print(f"  {'✅' if cond else '❌'} {name}" + (f"  [{detail}]" if detail and not cond else ""))
+
+
+_PartitionProduceResponse = \
+    ProduceResponse.TopicProduceResponse.PartitionProduceResponse
+TP = TopicPartition("shengye-json-log", 2)
+
+
+# ─── 测试基建 ────────────────────────────────────────────────────────────
+class _NullClient:
+    """最小 client 替身：Sender 只用到 poll/in_flight_request_count 等。"""
+
+    class _Cluster:
+        pass
+
+    cluster = _Cluster()
+
+    def poll(self, timeout_ms=0):
+        return None
+
+    def in_flight_request_count(self):
+        return 0
+
+    def is_ready(self, node):
+        return False
+
+    def connection_delay(self, node):
+        return 1.0
+
+    def maybe_connect(self, node, wakeup=False):
+        pass
+
+    def close(self):
+        pass
+
+
+def _make_batch(accum):
+    """向 accumulator 塞一条记录，返回 (batch, future)。"""
+    future, _, _, _ = accum.append(
+        TP, 0, None, b"{}", [], now=time.monotonic())
+    dq = accum._batches[TP]
+    return dq[0], future
+
+
+def _make_sender(idempotent):
+    """构造 Sender + RecordAccumulator，模拟幂等/非幂等两种配置。"""
+    # 非幂等路径 transaction_manager 为 None（kafka.py 的真实行为：
+    # enable_idempotence=False 时不创建 TransactionManager）
+    tm = None if not idempotent else _make_tm()
+    accum = RecordAccumulator(
+        transaction_manager=tm,
+        message_version=2,
+        delivery_timeout_ms=45000,
+        request_timeout_ms=30000,
+        linger_ms=5,
+        batch_size=16384,
+        retry_backoff_ms=0,   # 消除重试退避，让活锁循环紧凑
+    )
+    sender = Sender(
+        _NullClient(), None, accum,
+        transaction_manager=tm,
+        guarantee_message_order=idempotent,  # kafka.py: 幂等 => True
+        retries=5,
+        acks=-1,
+    )
+    sender._metadata = _NullMetadata()
+    return sender, accum
+
+
+def _make_tm():
+    """构造最小可用 TransactionManager（绕过需要 metadata 的 __init__）。"""
+    from kafka.producer.transaction_manager import (
+        NO_PRODUCER_EPOCH, ProducerIdAndEpoch, TransactionManager,
+        TransactionState)
+    tm = TransactionManager.__new__(TransactionManager)
+    import collections as _c
+    tm._sequence_numbers = _c.defaultdict(lambda: 0)
+    tm._last_acked_offset = {}
+    tm.producer_id_and_epoch = ProducerIdAndEpoch(-1, NO_PRODUCER_EPOCH)
+    tm._current_state = TransactionState.READY  # 已拿到 PID 的运行态
+    tm._transaction_started = False
+    tm._partitions_in_transaction = set()
+    tm._new_partitions_in_transaction = set()
+    tm._pending_partitions_in_transaction = set()
+    tm._pending_requests_sort_id = 0
+    tm._in_flight_request_correlation_id = \
+        TransactionManager.NO_INFLIGHT_REQUEST_CORRELATION_ID
+    tm.transaction_timeout_ms = 60000
+    tm._last_error = None
+    tm.transactional_id = None
+    tm._pending_requests = []
+    tm.retry_backoff_ms = 0
+    import threading as _t
+    tm._lock = _t.Condition()
+    tm._api_version = (2, 8)  # 支持 epoch bump，对齐现代 broker
+    return tm
+
+
+class _NullMetadata:
+    """leader_for_partition 返回 1，让 ready() 认为分区可发。"""
+
+    def leader_for_partition(self, tp):
+        return 1
+
+    def partitions_for_broker(self, node_id):
+        return [TP]
+
+
+def _upie_response(log_start=2337150726):
+    # 现场：log_start_offset=2337150726, last_acked=-1
+    return _PartitionProduceResponse(
+        index=TP.partition, error_code=59,
+        base_offset=-1, log_append_time_ms=-1,
+        log_start_offset=log_start, record_errors=[], error_message=None)
+
+
+# ─── 1. UPIE 活锁 A/B 对照 ───────────────────────────────────────────────
+def test_upie_livelock_ab():
+    print("\n[1] retention 型 UPIE：幂等=无限重试 vs 非幂等=立即失败")
+
+    # — 幂等（旧行为）：每次 dispatch 都判 retention-based → reenqueue 无限转 —
+    sender, accum = _make_sender(idempotent=True)
+    tm = sender._transaction_manager
+    batch, fut = _make_batch(accum)
+    # 给 batch 打上与 tm 匹配的 producer state（drain 时由 accumulator 做，这里手动）
+    from kafka.producer.transaction_manager import ProducerIdAndEpoch
+    pid = ProducerIdAndEpoch(5000, 0)
+    tm.producer_id_and_epoch = pid
+    batch.records.set_producer_state(pid.producer_id, pid.epoch, 0, False)
+
+    resp = _upie_response()
+    retries = 0
+    t0 = time.monotonic()
+    while time.monotonic() - t0 < 1.0:  # 最多转 1s
+        retries += 1
+        accum.muted.add(TP)                # 模拟 drain：幂等路径会 muted.add
+        try:
+            sender._complete_batch(batch, resp)   # broker 又回 UPIE
+        except KeyError:
+            # retention 分支 reenqueue 后走尾部 unmute，第二次 drain->complete
+            # 时 muted 已被弹掉 → 这正是现场的 KeyError。这里吞掉以继续跑
+            # 活锁计数（生产路径它直接炸 IO 线程）。
+            pass
+        if batch.final_state is not None:
+            break                              # 终于 fail 了
+        # 模拟 drain 重新赋序列号（活锁下每轮如此）
+        if not batch.in_retry():
+            break
+        tm.set_sequence_number(TP, 0)
+        if retries > 500:
+            break
+    check("幂等路径 1s 内仍在重试（复现活锁）",
+          retries > 5 and batch.final_state is None,
+          f"retries={retries} final={batch.final_state}")
+
+    # — 非幂等（新行为 enable_idempotence=False）：UPIE 非重试 → 直接 fail —
+    sender2, accum2 = _make_sender(idempotent=False)
+    batch2, fut2 = _make_batch(accum2)
+    sender2._complete_batch(batch2, resp)
+    check("非幂等路径第一次 UPIE 即 fail",
+          batch2.final_state is not None and fut2.is_done and fut2.exception is not None,
+          f"final={batch2.final_state}")
+    check("errback 收到 UnknownProducerIdError（自愈信号可达）",
+          isinstance(fut2.exception, UnknownProducerIdError),
+          repr(fut2.exception))
+
+
+# ─── 2. muted KeyError 双重完成复现 ──────────────────────────────────────
+def test_double_completion_keyerror():
+    print("\n[2] 批次双重完成：幂等裸 muted.remove 抛 KeyError vs 非幂等无 muted")
+
+    # — 幂等：timeout 先 fail（unmute 一次）→ broker 迟到 UPIE 再走 error 尾部
+    #   muted.remove（第二次）→ KeyError 炸 IO 线程 —
+    sender, accum = _make_sender(idempotent=True)
+    tm = sender._transaction_manager
+    from kafka.producer.transaction_manager import ProducerIdAndEpoch
+    pid = ProducerIdAndEpoch(5000, 0)
+    tm.producer_id_and_epoch = pid
+    batch, fut = _make_batch(accum)
+    batch.records.set_producer_state(pid.producer_id, pid.epoch, 0, False)
+
+    accum.muted.add(TP)                        # drain 时幂等路径会 add
+    sender._dispatch_error(batch, UnknownProducerIdError("x"), _upie_response())
+    # retention 分支 reenqueue 并走尾部 unmute
+    key_error_raised = False
+    try:
+        # 模拟本地 delivery timeout 先把同一批次 fail 掉（第二次完成）
+        sender._dispatch_error(batch, UnknownProducerIdError("timeout"),
+                               partition_response=None)
+    except KeyError as e:
+        key_error_raised = True
+        detail = repr(e)
+    check("幂等路径双重完成复现 KeyError（库 bug 在案）", key_error_raised,
+          "" if key_error_raised else "未抛 KeyError")
+
+    # — 非幂等：guarantee_message_order=False → muted 分支根本不进 —
+    sender2, accum2 = _make_sender(idempotent=False)
+    batch2, fut2 = _make_batch(accum2)
+    sender2._dispatch_error(batch2, UnknownProducerIdError("x"), _upie_response())
+    no_exc = True
+    try:
+        sender2._dispatch_error(batch2, UnknownProducerIdError("timeout"),
+                                partition_response=None)
+    except KeyError:
+        no_exc = False
+    check("非幂等路径双重完成无 KeyError", no_exc)
+    check("非幂等 muted 集合未使用", TP not in accum2.muted)
+
+
+# ─── 3. 重建不阻塞调用线程 ───────────────────────────────────────────────
+class _SlowFakeProducer:
+    """flush 故意睡 1.5s，模拟旧 producer close 慢（现场 5+10s）。"""
+
+    def __init__(self):
+        self.flushed = threading.Event()
+
+    def flush(self, timeout=None):
+        time.sleep(1.5)
+        self.flushed.set()
+
+    def close(self, timeout=None):
+        pass
+
+
+class _FakeNacos:
+    def __init__(self, cfg):
+        pass
+    service_name = "test-svc"
+    share_configs = {"common.yml": {}}
+
+
+def test_rebuild_off_io_thread():
+    print("\n[3] _rebuild_producer 不再阻塞调用（kafka IO）线程")
+    import sycommon.synacos.nacos_service as ns
+    ns.NacosService = _FakeNacos
+
+    sink = KafkaSink.__new__(KafkaSink)       # 跳过 __init__（不建真 producer）
+    sink.service_id = "t"
+    sink._bootstrap_servers = "localhost:9092"
+    sink._closed = False
+    sink._enabled = True
+    sink._rebuild_lock = threading.Lock()
+    sink._consecutive_failures = 0
+    sink._last_rebuild_ts = 0.0
+    sink._rebuild_in_progress = False
+    old = _SlowFakeProducer()
+    sink._producer = old
+    sink._producer_obj = old
+    built = []
+    sink._build_producer = lambda: (built.append(1), _SlowFakeProducer())[1]
+
+    t0 = time.monotonic()
+    sink._rebuild_producer()                   # 旧实现这里会同步卡 1.5s+
+    elapsed_call = time.monotonic() - t0
+    check("调用线程立即返回（<0.5s，旧实现 ~1.5s）", elapsed_call < 0.5,
+          f"{elapsed_call:.3f}s")
+
+    done = threading.Event()
+
+    def _wait():
+        # 等新 producer 就位
+        for _ in range(100):
+            if sink._producer is not None and sink._producer is not old:
+                done.set()
+                return
+            time.sleep(0.05)
+    threading.Thread(target=_wait, daemon=True).start()
+    check("后台线程完成重建（flush+build）", done.wait(6.0),
+          "6s 内新 producer 未就位")
+    check("旧 producer flush 已在后台执行", old.flushed.wait(6.0))
+    check("重建后 _rebuild_in_progress 已复位", sink._rebuild_in_progress is False)
+    # 清理：等后台线程自然结束，避免 daemon 线程睡到测试尾
+    time.sleep(0.1)
+
+
+# ─── 4. kafka.* 日志静音 ──────────────────────────────────────────────────
+def test_kafka_loggers_muted():
+    print("\n[4] kafka.* 内部日志压到 ERROR（切断回灌放大）")
+    setup_logger_levels()
+    ok = True
+    names = ["kafka", "kafka.net", "kafka.net.selector",
+             "kafka.net.connection", "kafka.producer"]
+    for n in names:
+        lv = logging.getLogger(n).level
+        if lv != logging.ERROR:
+            ok = False
+            print(f"    {n} -> {logging.getLevelName(lv)}")
+    check("logger_levels.setup_logger_levels 后全部 ERROR", ok)
+
+    # setup_logger 里也重申（防止 services 未走 setup_logger_levels 的接入方）
+    buf = io.StringIO()
+    with contextlib.redirect_stdout(buf):
+        pass
+    for n in names:
+        logging.getLogger(n).setLevel(logging.WARNING)  # 先破坏
+    from sycommon.logging.kafka_log import KafkaSink as _KS
+    # setup_logger 真实跑一遍（_build_producer 打桩 + Config 单例打桩：
+    # setup 会经 _global_log_enabled/_safe_namespace_id 读 Config().config，
+    # 本地无 app.yaml，注入最小假配置）
+    orig_bp = _KS._build_producer
+    _KS._build_producer = lambda self: _SlowFakeProducer()
+    from sycommon.config.Config import Config as _Cfg
+    from sycommon.config.Config import SingletonMeta as _SM
+    class _FakeCfg:
+        config = {"common.yml": {}}
+        MaxBytes = 0
+        Timeout = 0
+        MaxRetries = 0
+
+        def get_namespace_id(self, _):
+            return ""
+
+    _orig_instances = dict(_SM._instances)
+    _SM._instances[_Cfg] = _FakeCfg()
+    try:
+        import sycommon.synacos.nacos_service as ns2
+        ns2.NacosService = _FakeNacos
+        with contextlib.redirect_stdout(io.StringIO()):
+            KafkaLogger.setup_logger({})
+        ok2 = all(logging.getLogger(n).level == logging.ERROR for n in names)
+        check("KafkaLogger.setup_logger 后全部 ERROR", ok2)
+    finally:
+        _SM._instances.clear()
+        _SM._instances.update(_orig_instances)
+        _KS._build_producer = orig_bp
+        with contextlib.suppress(Exception):
+            with contextlib.redirect_stdout(io.StringIO()):
+                KafkaLogger.close()
+
+
+# ─── 5. producer 配置回归：enable_idempotence=False 真正生效 ─────────────
+def test_producer_config():
+    print("\n[5] _build_producer 配置断言（构造参数级，不连 broker）")
+    src = io.StringIO()
+    import inspect
+    from sycommon.logging import kafka_log as kl
+    code = inspect.getsource(kl.KafkaSink._build_producer)
+    check("显式传入 enable_idempotence=False",
+          "enable_idempotence=False" in code)
+    check("delivery_timeout_ms=45000 仍在", "delivery_timeout_ms=45000" in code)
+
+
+if __name__ == "__main__":
+    test_upie_livelock_ab()
+    test_double_completion_keyerror()
+    test_rebuild_off_io_thread()
+    test_kafka_loggers_muted()
+    test_producer_config()
+    print(f"\n{'='*50}\n通过 {len(PASS)} / 失败 {len(FAIL)}")
+    if FAIL:
+        print("失败项:", FAIL)
+        sys.exit(1)
+    print("全部通过 ✅")