debugbundle-python 1.4.0__tar.gz → 1.4.1__tar.gz

{debugbundle_python-1.4.0 → debugbundle_python-1.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: debugbundle-python
-Version: 1.4.0
+Version: 1.4.1
 Summary: DebugBundle SDK for Python
 Author: DebugBundle
 License-Expression: Apache-2.0
@@ -49,6 +49,10 @@ Use this package to capture Python backend exceptions, request metadata, structu
 
 Requires Python 3.10 or newer.
 
+## Automatic capture and application filtering
+
+`capture_logging()` attaches the stdlib logging handler and detects installed structlog/loguru integrations. Obtain structlog loggers after attachment. Structlog level filters and `DropEvent` processors run before capture; stdlib-backed structlog loggers also honor logger filters, disabled state and `logging.disable()`. Bound context and async logging are supported. SDK disposal stops capture through cached proxies. DebugBundle has its own minimum capture level; destination-specific filters on other handlers or Loguru sinks do not configure the DebugBundle handler.
+
 ## Installation
 
 ```bash

{debugbundle_python-1.4.0 → debugbundle_python-1.4.1}/README.md

@@ -10,6 +10,10 @@ Use this package to capture Python backend exceptions, request metadata, structu
 
 Requires Python 3.10 or newer.
 
+## Automatic capture and application filtering
+
+`capture_logging()` attaches the stdlib logging handler and detects installed structlog/loguru integrations. Obtain structlog loggers after attachment. Structlog level filters and `DropEvent` processors run before capture; stdlib-backed structlog loggers also honor logger filters, disabled state and `logging.disable()`. Bound context and async logging are supported. SDK disposal stops capture through cached proxies. DebugBundle has its own minimum capture level; destination-specific filters on other handlers or Loguru sinks do not configure the DebugBundle handler.
+
 ## Installation
 
 ```bash

{debugbundle_python-1.4.0 → debugbundle_python-1.4.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "debugbundle-python"
-version = "1.4.0"
+version = "1.4.1"
 description = "DebugBundle SDK for Python"
 readme = "README.md"
 requires-python = ">=3.10"

{debugbundle_python-1.4.0 → debugbundle_python-1.4.1}/src/debugbundle/event_support.py

@@ -264,7 +264,7 @@ def sdk_version() -> str:
     try:
         return metadata.version("debugbundle-python")
     except metadata.PackageNotFoundError:
-        return "1.4.0"
+        return "1.4.1"
 
 
 def sdk_config_endpoint(events_endpoint: str) -> str:

{debugbundle_python-1.4.0 → debugbundle_python-1.4.1}/src/debugbundle/logger_integrations.py

@@ -3,6 +3,8 @@ from __future__ import annotations
 from collections.abc import Callable
 from typing import Any, Protocol
 
+from .structlog_integration import StructlogLoggerProxy as _StructlogLoggerProxy
+
 
 class LogCaptureApi(Protocol):
     def capture_log(
@@ -44,14 +46,18 @@ def _attach_structlog(
         if getattr(original_get_logger, "__debugbundle_structlog_wrapper__", False):
             return None
 
+        active = [True]
+
         def get_logger(*args: Any, **kwargs: Any) -> Any:
-            return _StructlogLoggerProxy(original_get_logger(*args, **kwargs), sdk)
+            return _StructlogLoggerProxy(original_get_logger(*args, **kwargs), sdk, active)
 
         setattr(get_logger, "__debugbundle_structlog_wrapper__", True)
         structlog.get_logger = get_logger
 
         def restore() -> None:
-            structlog.get_logger = original_get_logger
+            active[0] = False
+            if structlog.get_logger is get_logger:
+                structlog.get_logger = original_get_logger
 
         return restore
     except Exception as error:
@@ -100,40 +106,6 @@ def _normalize_level(level: str) -> str:
     return normalized
 
 
-class _StructlogLoggerProxy:
-    def __init__(self, logger: Any, sdk: LogCaptureApi) -> None:
-        self._logger = logger
-        self._sdk = sdk
-
-    def bind(self, *args: Any, **kwargs: Any) -> _StructlogLoggerProxy:
-        return _StructlogLoggerProxy(self._logger.bind(*args, **kwargs), self._sdk)
-
-    def new(self, *args: Any, **kwargs: Any) -> _StructlogLoggerProxy:
-        return _StructlogLoggerProxy(self._logger.new(*args, **kwargs), self._sdk)
-
-    def __getattr__(self, name: str) -> Any:
-        attribute = getattr(self._logger, name)
-        if name not in {
-            "debug",
-            "info",
-            "warning",
-            "warn",
-            "error",
-            "critical",
-            "exception",
-        } or not callable(attribute):
-            return attribute
-
-        def wrapped(event: Any = None, *args: Any, **kwargs: Any) -> Any:
-            context = dict(kwargs)
-            for index, value in enumerate(args):
-                context[f"arg_{index}"] = value
-            self._sdk.capture_log(str(event or ""), level=_normalize_level(name), context=context or None)
-            return attribute(event, *args, **kwargs)
-
-        return wrapped
-
-
 def _emit_diagnostic(
     on_diagnostic: Callable[[dict[str, object]], None] | None,
     error: Exception,
@@ -151,4 +123,4 @@ def _emit_diagnostic(
                 }
             },
         }
-    )
+    )

debugbundle_python-1.4.1/src/debugbundle/structlog_integration.py

@@ -0,0 +1,136 @@
+from __future__ import annotations
+
+import copy
+import inspect
+import logging
+from contextvars import ContextVar
+from typing import Any
+
+_CAPTURING: ContextVar[bool] = ContextVar("debugbundle_structlog_capture", default=False)
+_LOG_METHODS = {"debug", "info", "warning", "warn", "error", "critical", "fatal", "exception", "log"}
+_BIND_METHODS = {"bind", "new", "unbind", "try_unbind"}
+
+
+def _capture(sdk: Any, active: list[bool], name: str, record: dict[str, Any]) -> None:
+    if not active[0] or _CAPTURING.get():
+        return
+    token = _CAPTURING.set(True)
+    try:
+        context = dict(record)
+        message = str(context.pop("event", ""))
+        level = {"warn": "warning", "exception": "error", "fatal": "critical"}.get(name, name)
+        sdk.capture_log(message, level=level, context=context or None)
+    except Exception:
+        # A logger adapter must not throw into the application's logging path.
+        pass
+    finally:
+        _CAPTURING.reset(token)
+
+
+class _SinkProxy:
+    def __init__(self, sink: Any, sdk: Any, active: list[bool], record: dict[str, Any]) -> None:
+        self._sink = sink
+        self._sdk = sdk
+        self._active = active
+        self._record = record
+
+    def __getattr__(self, name: str) -> Any:
+        method = getattr(self._sink, name)
+        if name not in _LOG_METHODS or not callable(method):
+            return method
+
+        def emit(*args: Any, **kwargs: Any) -> Any:
+            result = method(*args, **kwargs)
+            # stdlib records go through the existing SDK logging.Handler, after
+            # Logger.disabled, logging.disable(), levels and logger filters.
+            if not isinstance(self._sink, (logging.Logger, logging.LoggerAdapter)):
+                _capture(self._sdk, self._active, name, self._record)
+            return result
+
+        return emit
+
+
+class StructlogLoggerProxy:
+    def __init__(self, logger: Any, sdk: Any, active: list[bool] | None = None) -> None:
+        self._logger = logger
+        self._sdk = sdk
+        self._active = active if active is not None else [True]
+
+    def __getattr__(self, name: str) -> Any:
+        attribute = getattr(self._logger, name)
+        if not callable(attribute):
+            return attribute
+        if name in _BIND_METHODS:
+            def bind(*args: Any, **kwargs: Any) -> StructlogLoggerProxy:
+                return StructlogLoggerProxy(attribute(*args, **kwargs), self._sdk, self._active)
+            return bind
+        method_name = name[1:] if name.startswith("a") else name
+        if method_name not in _LOG_METHODS:
+            return attribute
+
+        def prepare(args: tuple[Any, ...], kwargs: dict[str, Any]) -> Any:
+            if not self._active[0] or _CAPTURING.get():
+                return attribute
+            try:
+                bound = self._logger.bind() if hasattr(self._logger, "bind") else self._logger
+                if not hasattr(bound, "_processors") or not hasattr(bound, "_logger"):
+                    return self._legacy_method(attribute, method_name)
+                # Keep the application's bound logger and processor list intact.
+                # The per-call clone also isolates concurrent/async log records.
+                clone = copy.copy(bound)
+                self._ensure_stdlib_handler(bound._logger)
+                record = dict(bound._context)
+                record.update(kwargs)
+                if args:
+                    record["event"] = args[1] if method_name == "log" and len(args) > 1 else args[0]
+                processors = list(bound._processors)
+                if processors:
+                    last = processors[-1]
+
+                    def observe(logger: Any, level: str, event: Any) -> Any:
+                        result = last(logger, level, event)
+                        snapshot = result if isinstance(result, dict) else event
+                        if isinstance(snapshot, dict):
+                            record.clear()
+                            record.update(snapshot)
+                        return result
+
+                    processors[-1] = observe
+                clone._processors = processors
+                clone._logger = _SinkProxy(bound._logger, self._sdk, self._active, record)
+                return getattr(clone, name)
+            except Exception:
+                # Preparation can fail for a custom logger; call it exactly once.
+                return attribute
+
+        if inspect.iscoroutinefunction(attribute):
+            async def async_log(*args: Any, **kwargs: Any) -> Any:
+                return await prepare(args, kwargs)(*args, **kwargs)
+            return async_log
+
+        def log(*args: Any, **kwargs: Any) -> Any:
+            return prepare(args, kwargs)(*args, **kwargs)
+        return log
+
+    def _ensure_stdlib_handler(self, sink: Any) -> None:
+        logger = sink.logger if isinstance(sink, logging.LoggerAdapter) else sink
+        if not isinstance(logger, logging.Logger):
+            return
+        current: logging.Logger | None = logger
+        while current is not None:
+            if any(getattr(handler, "_sdk", None) is self._sdk for handler in current.handlers):
+                return
+            if not current.propagate:
+                break
+            current = current.parent
+        attach = getattr(self._sdk, "capture_logging", None)
+        if callable(attach):
+            attach(logger=logger)
+
+    def _legacy_method(self, attribute: Any, name: str) -> Any:
+        def log(event: Any = None, *args: Any, **kwargs: Any) -> Any:
+            result = attribute(event, *args, **kwargs)
+            record = {**kwargs, **{f"arg_{i}": value for i, value in enumerate(args)}, "event": event or ""}
+            _capture(self._sdk, self._active, name, record)
+            return result
+        return log

{debugbundle_python-1.4.0 → debugbundle_python-1.4.1}/src/debugbundle_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: debugbundle-python
-Version: 1.4.0
+Version: 1.4.1
 Summary: DebugBundle SDK for Python
 Author: DebugBundle
 License-Expression: Apache-2.0
@@ -49,6 +49,10 @@ Use this package to capture Python backend exceptions, request metadata, structu
 
 Requires Python 3.10 or newer.
 
+## Automatic capture and application filtering
+
+`capture_logging()` attaches the stdlib logging handler and detects installed structlog/loguru integrations. Obtain structlog loggers after attachment. Structlog level filters and `DropEvent` processors run before capture; stdlib-backed structlog loggers also honor logger filters, disabled state and `logging.disable()`. Bound context and async logging are supported. SDK disposal stops capture through cached proxies. DebugBundle has its own minimum capture level; destination-specific filters on other handlers or Loguru sinks do not configure the DebugBundle handler.
+
 ## Installation
 
 ```bash

{debugbundle_python-1.4.0 → debugbundle_python-1.4.1}/src/debugbundle_python.egg-info/SOURCES.txt

@@ -12,6 +12,7 @@ src/debugbundle/py.typed
 src/debugbundle/redaction.py
 src/debugbundle/relay.py
 src/debugbundle/relay_delivery.py
+src/debugbundle/structlog_integration.py
 src/debugbundle/suppression.py
 src/debugbundle/transport.py
 src/debugbundle/trigger_token.py
@@ -41,4 +42,5 @@ tests/test_repository_metadata.py
 tests/test_schema_validation.py
 tests/test_sdk.py
 tests/test_smoke_script.py
+tests/test_structlog_filtering.py
 tests/test_trigger_token.py

debugbundle_python-1.4.1/tests/test_structlog_filtering.py

@@ -0,0 +1,171 @@
+from __future__ import annotations
+
+import asyncio
+import io
+import json
+import logging
+
+import pytest
+import structlog
+
+from debugbundle.core import DebugBundleSdk
+from debugbundle.logger_integrations import _attach_structlog
+
+_ORIGINAL_GET_LOGGER = structlog.get_logger
+
+
+class Capture:
+    def __init__(self):
+        self.events = []
+
+    def capture_log(self, message, level="warning", context=None):
+        self.events.append((message, level, context))
+
+
+@pytest.fixture(autouse=True)
+def reset_structlog(monkeypatch):
+    previous = structlog.get_config()
+    monkeypatch.setattr(structlog, "get_logger", _ORIGINAL_GET_LOGGER)
+    yield
+    structlog.configure(**previous)
+
+
+@pytest.mark.parametrize("mode", ["level", "processor"])
+def test_native_structlog_filters_run_before_capture(mode):
+    output = io.StringIO()
+    sdk = Capture()
+
+    def drop(_logger, _name, event):
+        if event["event"] == "suppressed":
+            raise structlog.DropEvent
+        return event
+
+    structlog.configure(
+        wrapper_class=structlog.make_filtering_bound_logger(logging.ERROR if mode == "level" else logging.DEBUG),
+        logger_factory=structlog.PrintLoggerFactory(file=output),
+        processors=([drop] if mode == "processor" else []) + [structlog.processors.JSONRenderer()],
+    )
+    restore = _attach_structlog(sdk)
+    try:
+        logger = structlog.get_logger().bind(tenant="example")
+        logger.warning("suppressed")
+        logger.error("accepted", request_id="req-1")
+        assert [event[0] for event in sdk.events] == ["accepted"]
+        assert [json.loads(line)["event"] for line in output.getvalue().splitlines()] == ["accepted"]
+        assert sdk.events[0][2] == {"tenant": "example", "request_id": "req-1"}
+        restore()
+        logger.error("after detach")
+        assert len(sdk.events) == 1
+    finally:
+        restore()
+
+
+def test_structlog_async_and_context_operations_preserve_filters():
+    sdk = Capture()
+    structlog.configure(
+        wrapper_class=structlog.make_filtering_bound_logger(logging.ERROR),
+        logger_factory=structlog.ReturnLoggerFactory(),
+        processors=[],
+    )
+    restore = _attach_structlog(sdk)
+    try:
+        logger = structlog.get_logger().bind(old="gone").unbind("old").bind(retained=True)
+        asyncio.run(logger.awarning("suppressed"))
+        asyncio.run(logger.aerror("accepted"))
+        assert sdk.events == [("accepted", "error", {"retained": True})]
+    finally:
+        restore()
+
+
+def test_structlog_capture_failures_do_not_change_native_result_or_repeat_processors():
+    sdk = Capture()
+    calls = []
+
+    def processor(_logger, _name, event):
+        calls.append(event["event"])
+        return event
+
+    def fail(*_args, **_kwargs):
+        raise RuntimeError("SDK failed")
+
+    sdk.capture_log = fail
+    structlog.configure(logger_factory=structlog.ReturnLoggerFactory(), processors=[processor])
+    restore = _attach_structlog(sdk)
+    try:
+        result = structlog.get_logger().error("accepted", value=1)
+        assert result == ((), {"value": 1, "event": "accepted"})
+        assert calls == ["accepted"]
+    finally:
+        restore()
+
+
+def test_structlog_numeric_log_is_filtered():
+    sdk = Capture()
+    structlog.configure(
+        wrapper_class=structlog.make_filtering_bound_logger(logging.WARNING),
+        logger_factory=structlog.ReturnLoggerFactory(), processors=[],
+    )
+    restore = _attach_structlog(sdk)
+    try:
+        logger = structlog.get_logger()
+        logger.log(logging.DEBUG, "suppressed")
+        logger.log(logging.ERROR, "accepted")
+        assert [event[:2] for event in sdk.events] == [("accepted", "error")]
+    finally:
+        restore()
+
+
+def test_structlog_stdlib_filters_and_non_propagating_loggers_capture_once():
+    sdk = DebugBundleSdk(transport=lambda _request: {"status": 202})
+    native = logging.getLogger("debugbundle-stdlib-suppression-test")
+    previous = (native.level, native.propagate, native.disabled)
+    native.setLevel(logging.ERROR)
+    native.propagate = False
+    reject = logging.Filter()
+    reject.filter = lambda record: record.getMessage() != "drop"
+    native.addFilter(reject)
+    structlog.configure(
+        wrapper_class=structlog.stdlib.BoundLogger,
+        logger_factory=lambda: native,
+        processors=[structlog.processors.EventRenamer("msg"), lambda _log, _name, event: ((event.pop("msg"),), event)],
+    )
+    sdk.init(project_token="dbundle_proj_test", service="logger-test", environment="production")
+    try:
+        sdk.capture_logging()
+        logger = structlog.get_logger()
+        logger.warning("below level")
+        logger.error("drop")
+        native.disabled = True
+        logger.error("disabled")
+        native.disabled = False
+        logging.disable(logging.CRITICAL)
+        logger.error("globally disabled")
+        logging.disable(logging.NOTSET)
+        logger.error("accepted")
+        assert [event["payload"]["message"] for event in sdk._buffer] == ["accepted"]
+    finally:
+        logging.disable(logging.NOTSET)
+        sdk.dispose()
+        native.removeFilter(reject)
+        native.setLevel(previous[0])
+        native.propagate = previous[1]
+        native.disabled = previous[2]
+
+
+def test_structlog_native_exceptions_are_not_retried():
+    sdk = Capture()
+    calls = []
+
+    def fail_processor(_logger, _method, _event):
+        calls.append(_event)
+        raise ValueError("application processor failed")
+
+    structlog.configure(processors=[fail_processor])
+    restore = _attach_structlog(sdk)
+    try:
+        with pytest.raises(ValueError, match="application processor failed"):
+            structlog.get_logger().error("do not retry")
+        assert sdk.events == []
+        assert len(calls) == 1
+    finally:
+        restore()