cfquant 0.2.0__py3-none-any.whl

cfquant/hub.py

@@ -0,0 +1,304 @@
+# -*- coding: utf-8 -*-
+import json
+import os
+import socket
+import struct
+import threading
+import time
+
+from .protocol import loads_message
+
+
+def default_status_file(filename):
+    runtime_dir = os.path.abspath(os.environ.get("CFQUANT_RUNTIME_DIR") or os.path.join(os.getcwd(), "runtime"))
+    return os.path.join(runtime_dir, "status", filename)
+
+
+class CfquantHub(object):
+    """
+    外部 Socket Hub。
+
+    - QMT 端作为 client 连接进来，首帧发送 role:qmt
+    - 外部 API client 直接发送 cfquant request
+    - Hub 将 request 转发给 QMT，并按 request id 把 response 转回对应 API client
+    """
+
+    def __init__(self, host="127.0.0.1", port=58668, show=True):
+        self.host = host
+        self.port = int(port)
+        self.show = show
+        self.running = False
+        self.server = None
+        self.qmt_sock = None
+        self.qmt_lock = threading.RLock()
+        self.send_locks = {}
+        self.send_locks_lock = threading.RLock()
+        self.pending = {}
+        self.client_by_id = {}
+        self.state_lock = threading.RLock()
+        self.status_file = os.path.abspath(
+            os.environ.get("CFQUANT_HUB_STATUS_FILE") or default_status_file("cfquant_hub_status.json")
+        )
+
+    def start(self):
+        if self.running:
+            return self
+        self.running = True
+        self.server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self.server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        self.server.bind((self.host, self.port))
+        self.server.listen(100)
+        self._log("cfquant Hub已启动:%s:%s" % (self.host, self.port))
+        self._write_status()
+        try:
+            while self.running:
+                client, address = self.server.accept()
+                self._log("Hub客户端已连接:%s" % (address,))
+                threading.Thread(target=self._client_loop, args=(client, address), daemon=True).start()
+        finally:
+            self.close()
+        return self
+
+    def close(self):
+        self.running = False
+        try:
+            self.server.close()
+        except Exception:
+            pass
+        with self.qmt_lock:
+            qmt_sock = self.qmt_sock
+            self.qmt_sock = None
+        self._close_socket(qmt_sock)
+
+    def _client_loop(self, sock, address):
+        role = "api"
+        try:
+            while self.running:
+                raw = self._recv_frame(sock)
+                if raw is None:
+                    break
+                if raw == "role:qmt":
+                    role = "qmt"
+                    with self.qmt_lock:
+                        old = self.qmt_sock
+                        self.qmt_sock = sock
+                    if old is not None and old is not sock:
+                        self._close_socket(old)
+                    self._log("QMT桥接端已注册:%s" % (address,))
+                    self._write_status()
+                    continue
+                if role == "qmt":
+                    self._handle_qmt_message(raw)
+                else:
+                    self._handle_api_message(sock, raw)
+        except Exception as e:
+            self._log("Hub客户端循环异常 address=%s role=%s error=%s" % (address, role, e))
+        finally:
+            if role == "qmt":
+                with self.qmt_lock:
+                    if self.qmt_sock is sock:
+                        self.qmt_sock = None
+                self._log("QMT桥接端已断开:%s" % (address,))
+                self._write_status()
+            else:
+                self._drop_api_client(sock)
+                self._log("API客户端已断开:%s" % (address,))
+                self._write_status()
+            self._close_socket(sock)
+
+    def _handle_api_message(self, sock, raw):
+        api_received_at = time.perf_counter()
+        msg = loads_message(raw)
+        if not msg:
+            return
+        if msg.get("type") != "request":
+            return
+        request_id = msg.get("id")
+        client_id = msg.get("client_id")
+        with self.state_lock:
+            if request_id:
+                self.pending[request_id] = {
+                    "sock": sock,
+                    "action": msg.get("action"),
+                    "api_received_at": api_received_at,
+                    "forward_done_at": None,
+                }
+            if client_id:
+                self.client_by_id[client_id] = sock
+        qmt_sock = self._get_qmt_sock()
+        if qmt_sock is None:
+            with self.state_lock:
+                self.pending.pop(request_id, None)
+            self._send_error(sock, request_id, "QMT桥接端未连接")
+            return
+        forward_start = time.perf_counter()
+        self._send_frame(qmt_sock, raw)
+        forward_done = time.perf_counter()
+        with self.state_lock:
+            pending = self.pending.get(request_id)
+            if pending:
+                pending["forward_done_at"] = forward_done
+        self._log(
+            "Hub已转发请求 action=%s id=%s api_to_forward_ms=%.2f send_ms=%.2f raw_len=%s"
+            % (
+                msg.get("action"),
+                request_id,
+                self._elapsed_ms(api_received_at, forward_done),
+                self._elapsed_ms(forward_start, forward_done),
+                len(raw),
+            )
+        )
+        self._write_status()
+
+    def _handle_qmt_message(self, raw):
+        qmt_received_at = time.perf_counter()
+        msg = loads_message(raw)
+        if not msg:
+            return
+        msg_type = msg.get("type")
+        target = None
+        if msg_type == "response":
+            request_id = msg.get("id")
+            pending = None
+            with self.state_lock:
+                pending = self.pending.pop(request_id, None)
+            if isinstance(pending, dict):
+                target = pending.get("sock")
+                api_received_at = pending.get("api_received_at") or qmt_received_at
+                forward_done_at = pending.get("forward_done_at") or api_received_at
+                self._log(
+                    "Hub收到QMT响应 action=%s id=%s target=%s qmt_roundtrip_ms=%.2f total_to_hub_ms=%.2f response_len=%s"
+                    % (
+                        pending.get("action"),
+                        request_id,
+                        bool(target),
+                        self._elapsed_ms(forward_done_at, qmt_received_at),
+                        self._elapsed_ms(api_received_at, qmt_received_at),
+                        len(raw),
+                    )
+                )
+            else:
+                target = pending
+                self._log("Hub收到QMT响应 id=%s target=%s response_len=%s" % (request_id, bool(target), len(raw)))
+            self._write_status()
+        elif msg_type == "event":
+            client_id = msg.get("client_id")
+            with self.state_lock:
+                target = self.client_by_id.get(client_id)
+            self._log("Hub收到QMT事件 event=%s client_id=%s target=%s" % (msg.get("event"), client_id, bool(target)))
+        if target is not None:
+            self._send_frame(target, raw)
+
+    def _send_error(self, sock, request_id, message):
+        from .protocol import pack_response
+
+        self._send_frame(sock, pack_response(request_id, ok=False, error={"type": "ConnectionError", "message": message}))
+
+    def _get_qmt_sock(self):
+        with self.qmt_lock:
+            return self.qmt_sock
+
+    def _drop_api_client(self, sock):
+        with self.state_lock:
+            for key, value in list(self.pending.items()):
+                pending_sock = value.get("sock") if isinstance(value, dict) else value
+                if pending_sock is sock:
+                    self.pending.pop(key, None)
+            for key, value in list(self.client_by_id.items()):
+                if value is sock:
+                    self.client_by_id.pop(key, None)
+
+    def _send_frame(self, sock, payload):
+        if isinstance(payload, str):
+            data = payload.encode("utf-8")
+        else:
+            data = payload
+        with self._get_send_lock(sock):
+            sock.sendall(struct.pack("!Q", len(data)) + data)
+
+    def _recv_frame(self, sock):
+        header = self._recv_exact(sock, 8)
+        if not header:
+            return None
+        size = struct.unpack("!Q", header)[0]
+        if size <= 0:
+            return ""
+        data = self._recv_exact(sock, size)
+        if data is None:
+            return None
+        return data.decode("utf-8", errors="replace")
+
+    def _recv_exact(self, sock, size):
+        chunks = []
+        remaining = size
+        while remaining > 0:
+            chunk = sock.recv(remaining)
+            if not chunk:
+                return None
+            chunks.append(chunk)
+            remaining -= len(chunk)
+        return b"".join(chunks)
+
+    def _get_send_lock(self, sock):
+        with self.send_locks_lock:
+            lock = self.send_locks.get(sock)
+            if lock is None:
+                lock = threading.RLock()
+                self.send_locks[sock] = lock
+            return lock
+
+    def _close_socket(self, sock):
+        if sock is None:
+            return
+        try:
+            sock.shutdown(socket.SHUT_RDWR)
+        except Exception:
+            pass
+        try:
+            sock.close()
+        except Exception:
+            pass
+        with self.send_locks_lock:
+            self.send_locks.pop(sock, None)
+
+    def _log(self, msg):
+        if self.show:
+            print("%s %s" % (self._timestamp_ms(), msg), flush=True)
+
+    def _timestamp_ms(self):
+        now = time.time()
+        local = time.localtime(now)
+        return "%s.%03d" % (time.strftime("%Y-%m-%d %H:%M:%S", local), int((now - int(now)) * 1000))
+
+    def _elapsed_ms(self, start, end=None):
+        if end is None:
+            end = time.perf_counter()
+        return (end - start) * 1000.0
+
+    def _write_status(self):
+        try:
+            with self.qmt_lock:
+                qmt_connected = self.qmt_sock is not None
+            with self.state_lock:
+                pending_ids = list(self.pending.keys())[-20:]
+                client_count = len(set(self.client_by_id.values()))
+            data = {
+                "ts": time.strftime("%Y-%m-%d %H:%M:%S"),
+                "host": self.host,
+                "port": self.port,
+                "qmt_connected": qmt_connected,
+                "pending_count": len(pending_ids),
+                "pending_ids": pending_ids,
+                "api_client_count": client_count,
+            }
+            status_dir = os.path.dirname(self.status_file)
+            if status_dir:
+                os.makedirs(status_dir, exist_ok=True)
+            with open(self.status_file, "w", encoding="utf-8") as f:
+                json.dump(data, f, ensure_ascii=False, indent=2)
+        except Exception:
+            pass
+
+
+def run_hub(host="127.0.0.1", port=58668, show=True):
+    return CfquantHub(host=host, port=port, show=show).start()

cfquant/logging_i18n.py

@@ -0,0 +1,348 @@
+# -*- coding: utf-8 -*-
+import os
+import re
+import threading
+
+
+_LANG_LOCK = threading.RLock()
+_LOG_LANGUAGE = ""
+_LOG_ENABLED = None
+
+
+_TRANSLATIONS = [
+    (r"^tx trade bridge reload failed:(?P<error>.+)$", "交易桥模块重载失败：{error}"),
+    (r"^normal bridge reload failed:(?P<error>.+)$", "普通桥模块重载失败：{error}"),
+    (r"^QMT log output enabled=(?P<enabled>.+)$", "QMT 日志输出已切换 enabled={enabled}"),
+    (r"^pipe transport reload failed:(?P<error>.+)$", "Pipe 传输模块重载失败：{error}"),
+    (r"^pipe bridge reload failed:(?P<error>.+)$", "Pipe 桥接模块重载失败：{error}"),
+    (r"^cfquant normal bridge module loaded$", "cfquant 普通桥模块已加载"),
+    (r"^cfquant entry version:(?P<version>.+)$", "cfquant 入口版本：{version}"),
+    (
+        r"^cfquant bridge id:(?P<bridge_id>[^ ]+) normal_channel:(?P<normal>[^ ]+) callback_channel:(?P<callback>.+)$",
+        "cfquant 桥接ID={bridge_id} 普通通道={normal} 回调通道={callback}",
+    ),
+    (
+        r"^cfquant normal bridge pump max_count:(?P<count>[^ ]+) max_ms:(?P<ms>.+)$",
+        "cfquant 普通桥泵处理上限 条数={count} 耗时={ms}ms",
+    ),
+    (
+        r"^cfquant normal bridge timer scheduled key:(?P<key>[^ ]+) interval_ms:(?P<interval>.+)$",
+        "cfquant 普通桥定时器已注册 key={key} 间隔={interval}ms",
+    ),
+    (
+        r"^cfquant normal bridge timer schedule failed:(?P<error>.+)$",
+        "cfquant 普通桥定时器注册失败：{error}",
+    ),
+    (
+        r"^cfquant normal bridge context ready version:(?P<version>.+)$",
+        "cfquant 普通桥 ContextInfo 已就绪 版本={version}",
+    ),
+    (
+        r"^cfquant normal bridge timer cancel failed:(?P<error>.+)$",
+        "cfquant 普通桥定时器取消失败：{error}",
+    ),
+    (r"^cfquant normal bridge stopped$", "cfquant 普通桥已停止"),
+    (
+        r"^cfquant callback publish failed event=(?P<event>[^ ]+) error=(?P<error>.+)$",
+        "cfquant 回调事件发布失败 event={event} 错误={error}",
+    ),
+    (r"^cfquant lowlat trade bridge module loaded$", "cfquant 极速交易桥模块已加载"),
+    (r"^cfquant lowlat entry version:(?P<version>.+)$", "cfquant 极速交易入口版本：{version}"),
+    (
+        r"^cfquant bridge id:(?P<bridge_id>[^ ]+) trade_channel:(?P<trade>.+)$",
+        "cfquant 桥接ID={bridge_id} 交易通道={trade}",
+    ),
+    (
+        r"^cfquant lowlat trade context ready version:(?P<version>.+)$",
+        "cfquant 极速交易桥 ContextInfo 已就绪 版本={version}",
+    ),
+    (r"^cfquant lowlat trade bridge stopped$", "cfquant 极速交易桥已停止"),
+    (r"^cfquant ctypes all-in-one lowlat bridge module loaded$", "cfquant ctypes 单文件低延迟桥模块已加载"),
+    (r"^cfquant ctypes all-in-one lowlat entry version:(?P<version>.+)$", "cfquant ctypes 单文件低延迟入口版本：{version}"),
+    (
+        r"^cfquant ctypes bridge id:(?P<bridge_id>[^ ]+) pipe:(?P<pipe>[^ ]+) normal_channel:(?P<normal>[^ ]+) trade_channel:(?P<trade>[^ ]+) callback_channel:(?P<callback>.+)$",
+        "cfquant ctypes 桥接ID={bridge_id} pipe={pipe} 普通通道={normal} 交易通道={trade} 回调通道={callback}",
+    ),
+    (
+        r"^cfquant ctypes trade loop in thread:(?P<thread>[^ ]+) sleep_seconds:(?P<sleep>.+)$",
+        "cfquant ctypes 交易循环后台线程={thread} 轮询间隔={sleep}秒",
+    ),
+    (
+        r"^cfquant ctypes lowlat trade loop error:(?P<error>.+)$",
+        "cfquant ctypes 低延迟交易循环异常：{error}",
+    ),
+    (r"^cfquant ctypes lowlat trade loop started in worker thread$", "cfquant ctypes 低延迟交易循环已在后台线程启动"),
+    (r"^cfquant ctypes lowlat trade loop entering current QMT thread$", "cfquant ctypes 低延迟交易循环进入当前 QMT 线程"),
+    (
+        r"^cfquant ctypes lowlat trade dispatch error source=(?P<source>[^ ]+) error=(?P<error>.+)$",
+        "cfquant ctypes 低延迟交易请求派发异常 来源={source} 错误={error}",
+    ),
+    (
+        r"^cfquant ctypes lowlat trade timer scheduled key:(?P<key>[^ ]+) interval_ms:(?P<interval>.+)$",
+        "cfquant ctypes 低延迟交易定时器已注册 key={key} 间隔={interval}ms",
+    ),
+    (
+        r"^cfquant ctypes lowlat trade timer schedule failed:(?P<error>.+)$",
+        "cfquant ctypes 低延迟交易定时器注册失败：{error}",
+    ),
+    (
+        r"^cfquant ctypes lowlat trade timer cancel failed:(?P<error>.+)$",
+        "cfquant ctypes 低延迟交易定时器取消失败：{error}",
+    ),
+    (
+        r"^cfquant ctypes normal context ready version:(?P<version>.+)$",
+        "cfquant ctypes 普通桥 ContextInfo 已就绪 版本={version}",
+    ),
+    (
+        r"^cfquant ctypes lowlat trade context ready version:(?P<version>.+)$",
+        "cfquant ctypes 低延迟交易桥 ContextInfo 已就绪 版本={version}",
+    ),
+    (r"^cfquant ctypes lowlat trade bridge stopped$", "cfquant ctypes 低延迟交易桥已停止"),
+    (r"^cfquant ctypes normal bridge stopped$", "cfquant ctypes 普通桥已停止"),
+    (
+        r"^cfquant ctypes lowlat callback publish failed event=(?P<event>[^ ]+) error=(?P<error>.+)$",
+        "cfquant ctypes 回调事件发布失败 event={event} 错误={error}",
+    ),
+    (
+        r"^stage=request_dequeued raw=(?P<raw>.+)$",
+        "阶段=请求出队 raw={raw}",
+    ),
+    (
+        r"^stage=parse_invalid parse_ms=(?P<parse_ms>[^ ]+) raw=(?P<raw>.+)$",
+        "阶段=解析失败 解析耗时={parse_ms}ms raw={raw}",
+    ),
+    (
+        r"^stage=request_enqueued_qmt_thread action=(?P<action>[^ ]+) id=(?P<id>.+)$",
+        "阶段=请求转入QMT线程 action={action} id={id}",
+    ),
+    (
+        r"^stage=request_received action=(?P<action>[^ ]+) id=(?P<id>[^ ]+) parse_ms=(?P<parse_ms>[^ ]+) params=(?P<params>.+)$",
+        "阶段=收到请求 action={action} id={id} 解析耗时={parse_ms}ms 参数={params}",
+    ),
+    (
+        r"^stage=response_ready action=(?P<action>[^ ]+) id=(?P<id>[^ ]+) dispatch_ms=(?P<dispatch_ms>[^ ]+) result=(?P<result>.+)$",
+        "阶段=响应已生成 action={action} id={id} 处理耗时={dispatch_ms}ms 结果={result}",
+    ),
+    (
+        r"^stage=response_sent action=(?P<action>[^ ]+) id=(?P<id>[^ ]+) client_id=(?P<client_id>[^ ]+) total_ms=(?P<ms>.+)$",
+        "阶段=响应已发送 action={action} id={id} 客户端={client_id} 总耗时={ms}ms",
+    ),
+    (r"^tx trade bridge context ready$", "交易桥 ContextInfo 已就绪"),
+    (r"^tx trade bridge stopped$", "交易桥已停止"),
+    (
+        r"^tx trade bridge started LTtx=(?P<endpoint>[^ ]+) request_channel=(?P<channel>.+)$",
+        "交易桥已启动 LTtx={endpoint} 请求通道={channel}",
+    ),
+    (
+        r"^tx trade response_ready action=(?P<action>[^ ]+) id=(?P<id>.+)$",
+        "交易请求已生成响应 action={action} id={id}",
+    ),
+    (
+        r"^tx trade request_error action=(?P<action>[^ ]+) id=(?P<id>[^ ]+) error=(?P<error>.+)$",
+        "交易请求处理失败 action={action} id={id} 错误={error}",
+    ),
+    (
+        r"^tx trade response_sent action=(?P<action>[^ ]+) id=(?P<id>[^ ]+) client_id=(?P<client_id>[^ ]+) total_ms=(?P<ms>.+)$",
+        "交易响应已发送 action={action} id={id} 客户端={client_id} 总耗时={ms}ms",
+    ),
+    (
+        r"^query_trade_detail start account=(?P<account>[^ ]+) account_type=(?P<account_type>[^ ]+) detail_type=(?P<detail_type>.+)$",
+        "交易明细查询开始 账号={account} 账号类型={account_type} 明细类型={detail_type}",
+    ),
+    (
+        r"^query_trade_detail call failed account=(?P<account>[^ ]+) detail_type=(?P<detail_type>[^ ]+) error=(?P<error>.+)$",
+        "交易明细查询调用失败 账号={account} 明细类型={detail_type} 错误={error}",
+    ),
+    (
+        r"^query_trade_detail format failed detail_type=(?P<detail_type>[^ ]+) index=(?P<index>[^ ]+) type=(?P<type>[^ ]+) error=(?P<error>.+)$",
+        "交易明细格式化失败 明细类型={detail_type} 序号={index} 数据类型={type} 错误={error}",
+    ),
+    (
+        r"^query_trade_detail done detail_type=(?P<detail_type>[^ ]+) count=(?P<count>.+)$",
+        "交易明细查询完成 明细类型={detail_type} 数量={count}",
+    ),
+    (
+        r"^trade detail getattr failed type=(?P<type>[^ ]+) field=(?P<field>[^ ]+) error=(?P<error>.+)$",
+        "交易明细读取属性失败 数据类型={type} 字段={field} 错误={error}",
+    ),
+    (
+        r"^trade detail get failed type=(?P<type>[^ ]+) field=(?P<field>[^ ]+) error=(?P<error>.+)$",
+        "交易明细 get 读取失败 数据类型={type} 字段={field} 错误={error}",
+    ),
+    (
+        r"^qmt userdata log cleanup log_dir=(?P<dir>.+) retention_days=(?P<days>[^ ]+) deleted=(?P<deleted>[^ ]+) failed=(?P<failed>[^ ]+) dry_run=(?P<dry_run>.+)$",
+        "QMT userdata 日志清理完成 目录={dir} 保留天数={days} 删除={deleted} 失败={failed} dry_run={dry_run}",
+    ),
+    (
+        r"^account subscribed account=(?P<account>[^ ]+) client_id=(?P<client_id>.+)$",
+        "账号回调已订阅 账号={account} 客户端={client_id}",
+    ),
+    (
+        r"^account unsubscribed account=(?P<account>[^ ]+) client_id=(?P<client_id>.+)$",
+        "账号回调已取消订阅 账号={account} 客户端={client_id}",
+    ),
+    (
+        r"^normal bridge started LTtx=(?P<endpoint>[^ ]+) request_channel=(?P<channel>.+)$",
+        "普通桥已启动 LTtx={endpoint} 请求通道={channel}",
+    ),
+    (r"^normal bridge worker is released by quote/timer/handlebar callbacks$", "普通桥 worker 由行情/定时器/handlebar 回调唤醒"),
+    (r"^normal bridge context ready$", "普通桥 ContextInfo 已就绪"),
+    (r"^normal bridge worker thread started in init context$", "普通桥 worker 线程已在 init context 中启动"),
+    (
+        r"^normal bridge recv error: (?P<error>.+)$",
+        "普通桥接收请求异常：{error}",
+    ),
+    (
+        r"^normal bridge request queued action=(?P<action>[^ ]+) id=(?P<id>[^ ]+) queue_size=(?P<size>[^ ]+) coalesced=(?P<coalesced>.+)$",
+        "普通桥请求已入队 action={action} id={id} 队列长度={size} 合并查询={coalesced}",
+    ),
+    (
+        r"^normal bridge request queued action=(?P<action>[^ ]+) id=(?P<id>[^ ]+) queue_size=(?P<size>.+)$",
+        "普通桥请求已入队 action={action} id={id} 队列长度={size}",
+    ),
+    (
+        r"^normal bridge request coalesced action=(?P<action>[^ ]+) id=(?P<id>[^ ]+) waiters=(?P<waiters>.+)$",
+        "普通桥请求已合并 action={action} id={id} 等待方={waiters}",
+    ),
+    (
+        r"^normal bridge quote subscribed id=(?P<id>[^ ]+) kind=(?P<kind>.+)$",
+        "行情订阅已建立 id={id} 类型={kind}",
+    ),
+    (
+        r"^normal bridge whole quote publish enabled id=(?P<id>[^ ]+) internal_id=(?P<internal>.+)$",
+        "全推行情发布已开启 id={id} 内部订阅={internal}",
+    ),
+    (
+        r"^normal bridge quote unsubscribed id=(?P<id>.+)$",
+        "行情订阅已取消 id={id}",
+    ),
+    (
+        r"^normal bridge worker error source=(?P<source>[^ ]+) error=(?P<error>.+)$",
+        "普通桥 worker 异常 来源={source} 错误={error}",
+    ),
+    (
+        r"^normal bridge worker response source=(?P<source>[^ ]+) action=(?P<action>[^ ]+) id=(?P<id>[^ ]+) total_ms=(?P<ms>.+)$",
+        "普通桥响应完成 来源={source} action={action} id={id} 总耗时={ms}ms",
+    ),
+    (
+        r"^normal bridge worker coalesced_response source=(?P<source>[^ ]+) action=(?P<action>[^ ]+) id=(?P<id>[^ ]+) waiters=(?P<waiters>[^ ]+) total_ms=(?P<ms>.+)$",
+        "普通桥合并响应完成 来源={source} action={action} id={id} 等待方={waiters} 总耗时={ms}ms",
+    ),
+    (
+        r"^normal bridge worker coalesced_error source=(?P<source>[^ ]+) action=(?P<action>[^ ]+) id=(?P<id>[^ ]+) waiters=(?P<waiters>[^ ]+) error=(?P<error>.+)$",
+        "普通桥合并请求处理失败 来源={source} action={action} id={id} 等待方={waiters} 错误={error}",
+    ),
+    (
+        r"^normal bridge worker request_error source=(?P<source>[^ ]+) action=(?P<action>[^ ]+) id=(?P<id>[^ ]+) error=(?P<error>.+)$",
+        "普通桥请求处理失败 来源={source} action={action} id={id} 错误={error}",
+    ),
+    (
+        r"^normal bridge internal whole quote subscribed id=(?P<id>.+)$",
+        "普通桥内部全推行情订阅成功 id={id}",
+    ),
+    (
+        r"^normal bridge internal whole quote subscribe failed: (?P<error>.+)$",
+        "普通桥内部全推行情订阅失败：{error}",
+    ),
+    (
+        r"^normal bridge timer scheduled key=(?P<key>.+)$",
+        "普通桥定时器已注册 key={key}",
+    ),
+    (
+        r"^normal bridge timer schedule failed: (?P<error>.+)$",
+        "普通桥定时器注册失败：{error}",
+    ),
+    (
+        r"^normal bridge send_error action=(?P<action>[^ ]+) id=(?P<id>[^ ]+) client_id=(?P<client_id>[^ ]+) error=(?P<error>.+)$",
+        "普通桥错误响应已发送 action={action} id={id} 客户端={client_id} 错误={error}",
+    ),
+    (
+        r"^normal bridge callback event sent event=(?P<event>[^ ]+) account=(?P<account>.+)$",
+        "普通桥交易回调事件已发送 event={event} 账号={account}",
+    ),
+    (
+        r"^pipe normal bridge started pipe=(?P<pipe>[^ ]+) request_channel=(?P<channel>.+)$",
+        "Pipe 普通桥已启动 pipe={pipe} 请求通道={channel}",
+    ),
+    (r"^pipe normal bridge stopped$", "Pipe 普通桥已停止"),
+    (
+        r"^pipe trade bridge started pipe=(?P<pipe>[^ ]+) request_channel=(?P<channel>.+)$",
+        "Pipe 交易桥已启动 pipe={pipe} 请求通道={channel}",
+    ),
+    (r"^pipe trade bridge stopped$", "Pipe 交易桥已停止"),
+    (
+        r"^pipe connected pipe=(?P<pipe>[^ ]+) request_channel=(?P<channel>[^ ]+) bridge_id=(?P<bridge_id>.+)$",
+        "Pipe 已连接 pipe={pipe} 请求通道={channel} 桥接ID={bridge_id}",
+    ),
+    (
+        r"^pipe connect/read failed: (?P<error>.+)$",
+        "Pipe 连接或读取失败：{error}",
+    ),
+    (
+        r"^pipe push failed: (?P<error>.+)$",
+        "Pipe 推送失败：{error}",
+    ),
+]
+
+
+def normalize_log_language(value=None):
+    value = str(value or "").strip().lower()
+    if value in ("en", "english"):
+        return "en"
+    return "zh"
+
+
+def normalize_log_enabled(value=None):
+    if isinstance(value, bool):
+        return value
+    if value is None:
+        return True
+    text = str(value).strip().lower()
+    if text in ("0", "false", "no", "off", "disable", "disabled", "closed", "close"):
+        return False
+    return True
+
+
+def get_log_language():
+    with _LANG_LOCK:
+        if _LOG_LANGUAGE:
+            return _LOG_LANGUAGE
+    return normalize_log_language(os.environ.get("CFQUANT_QMT_LOG_LANGUAGE") or os.environ.get("CFQUANT_LOG_LANGUAGE") or "zh")
+
+
+def set_log_language(value):
+    global _LOG_LANGUAGE
+    lang = normalize_log_language(value)
+    with _LANG_LOCK:
+        _LOG_LANGUAGE = lang
+    return lang
+
+
+def get_log_enabled():
+    with _LANG_LOCK:
+        if _LOG_ENABLED is not None:
+            return bool(_LOG_ENABLED)
+    return normalize_log_enabled(os.environ.get("CFQUANT_QMT_LOG_ENABLED") or os.environ.get("CFQUANT_LOG_ENABLED") or "1")
+
+
+def set_log_enabled(value):
+    global _LOG_ENABLED
+    enabled = normalize_log_enabled(value)
+    with _LANG_LOCK:
+        _LOG_ENABLED = enabled
+    return enabled
+
+
+def translate_log(message, language=None):
+    text = str(message)
+    if normalize_log_language(language or get_log_language()) == "en":
+        return text
+    for pattern, template in _TRANSLATIONS:
+        match = re.match(pattern, text)
+        if not match:
+            continue
+        try:
+            return template.format(**match.groupdict())
+        except Exception:
+            return text
+    return text