elven-logs-interceptor-python 0.1.3__tar.gz → 0.1.4__tar.gz

{elven_logs_interceptor_python-0.1.3 → elven_logs_interceptor_python-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: elven-logs-interceptor-python
-Version: 0.1.3
+Version: 0.1.4
 Summary: Production-grade logs interceptor for Python with Loki transport, resilience, batching, and framework integrations.
 Author: Elven Observability
 License: MIT

{elven_logs_interceptor_python-0.1.3 → elven_logs_interceptor_python-0.1.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "elven-logs-interceptor-python"
-version = "0.1.3"
+version = "0.1.4"
 description = "Production-grade logs interceptor for Python with Loki transport, resilience, batching, and framework integrations."
 readme = "README.md"
 requires-python = ">=3.10"

{elven_logs_interceptor_python-0.1.3 → elven_logs_interceptor_python-0.1.4}/src/logs_interceptor/application/log_service.py

@@ -22,11 +22,11 @@ try:
 except Exception:  # pragma: no cover
     pass
 
+otel_trace: Any | None
 try:
-    from opentelemetry import trace as _otel_trace  # type: ignore[import-not-found]
+    from opentelemetry import trace as otel_trace
 except Exception:  # pragma: no cover - optional dependency
-    _otel_trace = None
-otel_trace: Any = _otel_trace
+    otel_trace = None
 
 
 @dataclass(slots=True)

{elven_logs_interceptor_python-0.1.3 → elven_logs_interceptor_python-0.1.4}/src/logs_interceptor/infrastructure/interceptors/runtime_interceptor.py

@@ -11,6 +11,18 @@ from ...domain.interfaces import ILogger
 from ...types import LogLevel
 from ...utils import safe_stringify
 
+_IGNORED_LOGGER_PREFIXES = (
+    "httpcore",
+    "httpx",
+    "urllib3",
+    "hpack",
+    "h2",
+    "h11",
+    "opentelemetry",
+    "logs_interceptor",
+    "elven_unified_observability",
+)
+
 
 class _BridgeLoggingHandler(logging.Handler):
     def __init__(self, logger: ILogger) -> None:
@@ -19,6 +31,9 @@ class _BridgeLoggingHandler(logging.Handler):
 
     def emit(self, record: logging.LogRecord) -> None:
         try:
+            if record.name.startswith(_IGNORED_LOGGER_PREFIXES):
+                return
+
             level = self._map_level(record.levelno)
             msg = record.getMessage()
             context = {
@@ -56,12 +71,17 @@ class RuntimeInterceptor:
         self._original_print = builtins.print
         self._original_excepthook = sys.excepthook
         self._root_logger = logging.getLogger()
+        self._original_root_level = self._root_logger.level
         self._bridge_handler = _BridgeLoggingHandler(logger)
         self._original_handlers: list[logging.Handler] = []
 
     def enable(self) -> None:
         if self._enabled:
             return
+
+        self._original_print = builtins.print
+        self._original_excepthook = sys.excepthook
+        self._original_root_level = self._root_logger.level
         self._enabled = True
 
         self._patch_print()
@@ -80,6 +100,8 @@ class RuntimeInterceptor:
         except ValueError:
             pass
 
+        self._root_logger.setLevel(self._original_root_level)
+
         if not self._preserve_original:
             self._root_logger.handlers = self._original_handlers
 

elven_logs_interceptor_python-0.1.4/src/logs_interceptor/integrations/loguru.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any
+
+from ..domain.interfaces import ILogger
+
+
+class LoguruSink:
+    def __init__(self, logger: ILogger, exclude_prefixes: list[str] | None = None) -> None:
+        self.logger = logger
+        self._exclude_prefixes = tuple(
+            prefix.lower().strip()
+            for prefix in (exclude_prefixes or [])
+            if prefix and prefix.strip()
+        )
+
+    def __call__(self, message: Any) -> None:
+        try:
+            record = getattr(message, "record", None)
+            if not isinstance(record, Mapping):
+                self.logger.info(str(message), {"source": "loguru"})
+                return
+
+            if self._should_ignore(record):
+                return
+
+            level = self._resolve_level(record)
+            extra = record.get("extra")
+            normalized_extra = dict(extra) if isinstance(extra, Mapping) else extra
+
+            self.logger.log(
+                level,  # type: ignore[arg-type]
+                str(record.get("message", "")),
+                {
+                    "source": "loguru",
+                    "logger_name": record.get("name"),
+                    "module": record.get("module"),
+                    "function": record.get("function"),
+                    "line": record.get("line"),
+                    "extra": normalized_extra,
+                },
+            )
+        except Exception:
+            return
+
+    @staticmethod
+    def _resolve_level(record: Mapping[str, Any]) -> str:
+        raw_level = record.get("level")
+        if isinstance(raw_level, Mapping):
+            level = str(raw_level.get("name", "INFO")).lower()
+            level_number = raw_level.get("no")
+        else:
+            level = str(getattr(raw_level, "name", "INFO")).lower()
+            level_number = getattr(raw_level, "no", None)
+
+        if level == "warning":
+            return "warn"
+        if level == "critical":
+            return "fatal"
+        if level not in {"debug", "info", "warn", "error", "fatal"}:
+            if not level and isinstance(level_number, (int, float)):
+                if level_number >= 50:
+                    return "fatal"
+                if level_number >= 40:
+                    return "error"
+                if level_number >= 30:
+                    return "warn"
+                if level_number >= 20:
+                    return "info"
+                return "debug"
+            return "info"
+        return level
+
+    def _should_ignore(self, record: Mapping[str, Any]) -> bool:
+        if not self._exclude_prefixes:
+            return False
+
+        name = str(record.get("name") or "").lower()
+        module = str(record.get("module") or "").lower()
+        extra = record.get("extra")
+        extra_logger_name = ""
+        if isinstance(extra, Mapping):
+            extra_logger_name = str(extra.get("logger_name") or "").lower()
+
+        for prefix in self._exclude_prefixes:
+            if (
+                name.startswith(prefix)
+                or module.startswith(prefix)
+                or extra_logger_name.startswith(prefix)
+            ):
+                return True
+        return False

{elven_logs_interceptor_python-0.1.3 → elven_logs_interceptor_python-0.1.4}/src/logs_interceptor/presentation/factory.py

@@ -15,11 +15,11 @@ from ..infrastructure.filter import LogFilter
 from ..infrastructure.interceptors import RuntimeInterceptor
 from ..infrastructure.transport import TransportFactory
 
+otel_trace: Any | None
 try:
-    from opentelemetry import trace as _otel_trace  # type: ignore[import-not-found]
+    from opentelemetry import trace as otel_trace
 except Exception:  # pragma: no cover - optional dependency
-    _otel_trace = None
-otel_trace: Any = _otel_trace
+    otel_trace = None
 
 
 @dataclass(slots=True)

elven_logs_interceptor_python-0.1.4/tests/unit/test_loguru_sink.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+from logs_interceptor.integrations.loguru import LoguruSink
+
+
+class _Logger:
+    def __init__(self) -> None:
+        self.calls: list[tuple[str, str, dict[str, object] | None]] = []
+
+    def info(self, message, context=None):
+        self.calls.append(("info", message, context))
+
+    def log(self, level, message, context=None):
+        self.calls.append((level, message, context))
+
+
+class _Message:
+    def __init__(self, record):
+        self.record = record
+
+
+class _Level:
+    def __init__(self, name: str, no: int) -> None:
+        self.name = name
+        self.no = no
+
+
+def test_loguru_sink_records_logger_name_and_metadata() -> None:
+    logger = _Logger()
+    sink = LoguruSink(logger)
+
+    sink(
+        _Message(
+            {
+                "name": "service.api",
+                "module": "app",
+                "function": "handler",
+                "line": 42,
+                "message": "hello",
+                "level": {"name": "INFO"},
+                "extra": {"request_id": "req-1"},
+            }
+        )
+    )
+
+    assert logger.calls == [
+        (
+            "info",
+            "hello",
+            {
+                "source": "loguru",
+                "logger_name": "service.api",
+                "module": "app",
+                "function": "handler",
+                "line": 42,
+                "extra": {"request_id": "req-1"},
+            },
+        )
+    ]
+
+
+def test_loguru_sink_excludes_configured_prefixes() -> None:
+    logger = _Logger()
+    sink = LoguruSink(logger, exclude_prefixes=["httpx", "httpcore"])
+
+    sink(
+        _Message(
+            {
+                "name": "httpx",
+                "module": "client",
+                "function": "send",
+                "line": 1,
+                "message": "request",
+                "level": {"name": "DEBUG"},
+                "extra": {},
+            }
+        )
+    )
+
+    assert logger.calls == []
+
+
+def test_loguru_sink_supports_loguru_record_level_objects() -> None:
+    logger = _Logger()
+    sink = LoguruSink(logger)
+
+    sink(
+        _Message(
+            {
+                "name": "service.api",
+                "module": "app",
+                "function": "handler",
+                "line": 42,
+                "message": "hello",
+                "level": _Level("WARNING", 30),
+                "extra": {"request_id": "req-1"},
+            }
+        )
+    )
+
+    assert logger.calls == [
+        (
+            "warn",
+            "hello",
+            {
+                "source": "loguru",
+                "logger_name": "service.api",
+                "module": "app",
+                "function": "handler",
+                "line": 42,
+                "extra": {"request_id": "req-1"},
+            },
+        )
+    ]

elven_logs_interceptor_python-0.1.4/tests/unit/test_runtime_interceptor.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+import logging
+
+from logs_interceptor.infrastructure.interceptors.runtime_interceptor import RuntimeInterceptor
+
+
+class _Logger:
+    def __init__(self) -> None:
+        self.records: list[tuple[str, str, dict[str, object] | None]] = []
+
+    def log(self, level, message, context=None):
+        self.records.append((level, message, context))
+
+    def info(self, message, context=None):
+        self.records.append(("info", message, context))
+
+    def fatal(self, message, context=None):
+        self.records.append(("fatal", message, context))
+
+    def flush(self):
+        return None
+
+
+def test_runtime_interceptor_restores_root_logger_level() -> None:
+    root = logging.getLogger()
+    original_level = root.level
+    root.setLevel(logging.WARNING)
+
+    interceptor = RuntimeInterceptor(_Logger())
+    interceptor.enable()
+
+    assert root.level == logging.DEBUG
+
+    interceptor.restore()
+
+    assert root.level == logging.WARNING
+    root.setLevel(original_level)
+
+
+def test_runtime_interceptor_ignores_known_noisy_logger_prefixes() -> None:
+    logger = _Logger()
+    interceptor = RuntimeInterceptor(logger)
+    interceptor.enable()
+
+    noisy_logger = logging.getLogger("elven_unified_observability.runtime")
+    noisy_logger.warning("internal warning")
+    noisy_otel_logger = logging.getLogger("opentelemetry.sdk.trace")
+    noisy_otel_logger.info("trace noise")
+
+    assert logger.records == []
+
+    interceptor.restore()

elven_logs_interceptor_python-0.1.3/src/logs_interceptor/integrations/loguru.py

@@ -1,36 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-
-from ..domain.interfaces import ILogger
-
-
-class LoguruSink:
-    def __init__(self, logger: ILogger) -> None:
-        self.logger = logger
-
-    def __call__(self, message: Any) -> None:
-        record = getattr(message, "record", None)
-        if record is None:
-            self.logger.info(str(message), {"source": "loguru"})
-            return
-
-        level = str(record.get("level", {}).get("name", "INFO")).lower()
-        if level == "warning":
-            level = "warn"
-        if level == "critical":
-            level = "fatal"
-        if level not in {"debug", "info", "warn", "error", "fatal"}:
-            level = "info"
-
-        self.logger.log(
-            level,  # type: ignore[arg-type]
-            str(record.get("message", "")),
-            {
-                "source": "loguru",
-                "module": record.get("module"),
-                "function": record.get("function"),
-                "line": record.get("line"),
-                "extra": record.get("extra"),
-            },
-        )