Skip to content

Commit a84e6c0

Browse files
committed
feat(cuda.core): add callback param to register_cuda_log_bridge
register_cuda_log_bridge() now accepts an optional callback(logger, level, message) that overrides the default "[CUDA Driver] %s" forwarding. Non-callable callbacks raise TypeError. Add tests for callback override, level filtering, and validation. Refs: NVIDIA#671
1 parent 916247d commit a84e6c0

2 files changed

Lines changed: 98 additions & 6 deletions

File tree

‎cuda_core/cuda/core/utils/_logging.py‎

Lines changed: 43 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -20,6 +20,7 @@
2020
import ctypes
2121
import logging
2222
import threading
23+
from typing import Callable, Optional
2324

2425
from cuda.bindings import driver as _driver
2526
from cuda.core._utils.cuda_utils import handle_return
@@ -42,6 +43,19 @@
4243
int(_driver.CUlogLevel.CU_LOG_LEVEL_WARNING): logging.WARNING,
4344
}
4445

46+
# User-supplied hook that customizes how each driver log message is
47+
# displayed/handled; see the ``callback`` parameter of
48+
# :func:`register_cuda_log_bridge`.
49+
#
50+
# callback(logger, level, message) -> None
51+
#
52+
# ``logger`` is the same :class:`logging.Logger` passed to (or defaulted by)
53+
# :func:`register_cuda_log_bridge`, ``level`` is the already-mapped
54+
# ``logging.ERROR`` / ``logging.WARNING`` level, and ``message`` is the
55+
# decoded driver log text (without the ``[CUDA Driver]`` prefix added by the
56+
# default formatter).
57+
LogCallback = Callable[[logging.Logger, int, str], None]
58+
4559
_lock = threading.Lock()
4660
# Must hold a reference to the ctypes callback for as long as it is
4761
# registered: once it is garbage collected, the driver would be left
@@ -51,10 +65,17 @@
5165
_callback_handle = None # CUlogsCallbackHandle, needed to unregister
5266

5367

54-
def _make_c_callback(logger: logging.Logger) -> ctypes._FuncPointer:
68+
def _default_callback(logger: logging.Logger, level: int, message: str) -> None:
69+
"""Default display/forwarding behavior: plain forward into ``logger``."""
70+
logger.log(level, "[CUDA Driver] %s", message)
71+
72+
73+
def _make_c_callback(logger: logging.Logger, callback: Optional[LogCallback]) -> ctypes._FuncPointer:
5574
"""Build a ctypes C function pointer that forwards each driver log
56-
record to ``logger``.
75+
record to ``logger``, optionally via a user-supplied ``callback`` that
76+
customizes how the message gets displayed.
5777
"""
78+
emit = callback if callback is not None else _default_callback
5879

5980
def _on_log(_user_data, log_level, message_ptr, length):
6081
# This runs inside a ctypes callback trampoline, potentially from a
@@ -63,30 +84,43 @@ def _on_log(_user_data, log_level, message_ptr, length):
6384
raw = ctypes.string_at(message_ptr, length) if message_ptr else b""
6485
msg = raw.decode("utf-8", errors="replace").rstrip("\n")
6586
py_level = _CUDA_LEVEL_TO_PY_LEVEL.get(log_level, logging.ERROR)
66-
logger.log(py_level, "[CUDA Driver] %s", msg)
87+
emit(logger, py_level, msg)
6788
except Exception:
6889
logger.exception("cuda_log_bridge: error while forwarding driver log")
6990

7091
return _CUlogsCallback_functype(_on_log)
7192

7293

73-
def register_cuda_log_bridge(logger: logging.Logger | None = None) -> None:
94+
def register_cuda_log_bridge(
95+
logger: logging.Logger | None = None,
96+
callback: Optional[LogCallback] = None,
97+
) -> None:
7498
"""Register a bridge that forwards CUDA driver ``cuLogs*`` messages to
7599
a Python :class:`logging.Logger`.
76100
77101
This is a process-wide, idempotent operation: the driver only supports
78102
a global log stream (not scoped to a context/stream/thread), so calling
79103
this again while a bridge is already registered is a no-op -- the
80-
logger passed to the first call remains in effect.
104+
logger (and callback) passed to the first call remain in effect.
81105
82106
Parameters
83107
----------
84108
logger : logging.Logger, optional
85109
The logger that driver messages should be forwarded to. Defaults
86110
to ``logging.getLogger("cuda.driver")``.
111+
callback : Callable[[logging.Logger, int, str], None], optional
112+
Customizes how each driver log message is displayed, instead of
113+
being limited to plain forwarding into ``logger``. Called as
114+
``callback(logger, level, message)`` for every driver log record,
115+
where ``level`` is the mapped ``logging.ERROR``/``logging.WARNING``
116+
level and ``message`` is the decoded driver log text. Defaults to
117+
``None``, which plainly forwards every message via
118+
``logger.log(level, "[CUDA Driver] %s", message)``.
87119
88120
Raises
89121
------
122+
TypeError
123+
If ``callback`` is not ``None`` and not callable.
90124
cuda.core._utils.cuda_utils.CUDAError
91125
If the underlying ``cuLogsRegisterCallback`` call fails, e.g.
92126
because the loaded CUDA driver predates the 12.9 cuLogs* API.
@@ -96,11 +130,14 @@ def register_cuda_log_bridge(logger: logging.Logger | None = None) -> None:
96130
if logger is None:
97131
logger = logging.getLogger("cuda.driver")
98132

133+
if callback is not None and not callable(callback):
134+
raise TypeError(f"callback must be callable or None, got {type(callback)!r}")
135+
99136
with _lock:
100137
if _callback_handle is not None:
101138
return # already registered; idempotent
102139

103-
c_callback = _make_c_callback(logger)
140+
c_callback = _make_c_callback(logger, callback)
104141
addr = ctypes.cast(c_callback, ctypes.c_void_p).value
105142

106143
handle = handle_return(_driver.cuLogsRegisterCallback(addr, None))

‎cuda_core/tests/test_cuda_log_bridge.py‎

Lines changed: 55 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -156,3 +156,58 @@ def emit(self, record):
156156
logger_obj.removeHandler(counter_handler)
157157

158158
assert counter_handler.count >= 1, "Expected at least one ERROR-level driver log to be counted"
159+
160+
161+
# 使用方式6: integrate driver logs into existing logger through callback
162+
def test_cuda_driver_log_custom_callback_overrides_default(caplog):
163+
driver.cuInit(0)
164+
165+
# (a) 创建一个叫做 "my_library.cuda-driver" 的 logger
166+
logger_name = "my_library.cuda-driver"
167+
logger_obj = logging.getLogger(logger_name)
168+
169+
# (b) 自定义 my_callback:不管驱动原始级别是 ERROR 还是 WARNING,
170+
# 统一记成 DEBUG;并在打印的消息前面加上 logger name 前缀
171+
def my_callback(logger, level, message):
172+
logger.debug("%s: %s", logger.name, message)
173+
174+
# (c) register 时传入 callback,覆盖掉内部默认的
175+
# logger.log(level, "[CUDA Driver] %s", message) 转发逻辑
176+
register_cuda_log_bridge(logger_obj, callback=my_callback)
177+
178+
# 1. logging 默认的 WARNING 级别阈值下,DEBUG 级别的驱动日志会被过滤掉,
179+
# caplog 收不到任何记录
180+
with caplog.at_level(logging.WARNING, logger=logger_name):
181+
driver.cuDeviceGet(9999)
182+
assert not any(r.name == logger_name for r in caplog.records), (
183+
"DEBUG-level driver log should be filtered out at the default WARNING level"
184+
)
185+
186+
caplog.clear()
187+
188+
# 2. 把 logger 的阈值调到 DEBUG,才能收到 my_callback 记录的驱动日志
189+
with caplog.at_level(logging.DEBUG, logger=logger_name):
190+
driver.cuDeviceGet(9999)
191+
192+
records = [r for r in caplog.records if r.name == logger_name]
193+
assert records, "Expected driver log records forwarded via my_callback once the threshold is DEBUG"
194+
195+
# 验证 my_callback 生效:级别被统一改写成了 DEBUG(而不是默认的 ERROR/WARNING)
196+
assert all(r.levelno == logging.DEBUG for r in records), (
197+
f"Expected every record logged as DEBUG via my_callback, got levels: {[r.levelname for r in records]}"
198+
)
199+
200+
# 验证消息前缀是 logger name(而不是 register_cuda_log_bridge 默认的 "[CUDA Driver] " 前缀)
201+
messages = [r.message for r in records]
202+
assert any(m.startswith(f"{logger_name}: ") for m in messages), (
203+
f"Expected messages prefixed with '{logger_name}: ', got:\n{messages}"
204+
)
205+
assert not any(m.startswith("[CUDA Driver] ") for m in messages), (
206+
f"Default '[CUDA Driver] ' forwarding should be overridden by my_callback, got:\n{messages}"
207+
)
208+
209+
210+
# callback 必须是可调用对象或 None,否则应尽早报错
211+
def test_cuda_driver_log_callback_must_be_callable_or_none():
212+
with pytest.raises(TypeError):
213+
register_cuda_log_bridge(logging.getLogger("cuda.driver.bad_callback_test"), callback="not-callable")

0 commit comments

Comments
 (0)