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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: elven-logs-interceptor-python
-Version: 0.1.4
+Version: 0.1.5
 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.4 → elven_logs_interceptor_python-0.1.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "elven-logs-interceptor-python"
-version = "0.1.4"
+version = "0.1.5"
 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.4 → elven_logs_interceptor_python-0.1.5}/src/logs_interceptor/__init__.py

@@ -133,6 +133,11 @@ def _coerce_config(user_config: LogsInterceptorConfig | dict[str, Any] | None) -
                 max_message_length=_pick(filter_raw, "max_message_length", "maxMessageLength"),
                 sanitize=_pick(filter_raw, "sanitize", "sanitize"),
                 sensitive_patterns=_pick(filter_raw, "sensitive_patterns", "sensitivePatterns"),
+                exclude_logger_prefixes=_pick(
+                    filter_raw,
+                    "exclude_logger_prefixes",
+                    "excludeLoggerPrefixes",
+                ),
             )
             if filter_raw
             else None

{elven_logs_interceptor_python-0.1.4 → elven_logs_interceptor_python-0.1.5}/src/logs_interceptor/application/config_service.py

@@ -17,6 +17,7 @@ from ..config import (
     ResolvedTransportConfig,
     TransportConfig,
 )
+from ..infrastructure.log_noise_filter import normalize_excluded_logger_prefixes
 from ..types import LogLevel
 
 DEFAULT_LEVELS: list[LogLevel] = ["debug", "info", "warn", "error", "fatal"]
@@ -194,6 +195,9 @@ class ConfigService:
             else source.max_message_length,
             sanitize=True if source.sanitize is None else source.sanitize,
             sensitive_patterns=source.sensitive_patterns or DEFAULT_SENSITIVE_PATTERNS,
+            exclude_logger_prefixes=list(
+                normalize_excluded_logger_prefixes(source.exclude_logger_prefixes)
+            ),
         )
 
     @staticmethod

{elven_logs_interceptor_python-0.1.4 → elven_logs_interceptor_python-0.1.5}/src/logs_interceptor/config.py

@@ -45,6 +45,7 @@ class FilterConfig:
     max_message_length: int | None = None
     sanitize: bool | None = None
     sensitive_patterns: list[str] | None = None
+    exclude_logger_prefixes: list[str] | None = None
 
 
 @dataclass(slots=True)
@@ -149,6 +150,7 @@ class ResolvedFilterConfig:
     max_message_length: int
     sanitize: bool
     sensitive_patterns: list[str]
+    exclude_logger_prefixes: list[str] = field(default_factory=list)
 
 
 @dataclass(slots=True)

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

@@ -10,28 +10,25 @@ from typing import Any
 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",
-)
+from ..internal_capture_guard import is_internal_log_capture_suppressed
+from ..log_noise_filter import normalize_excluded_logger_prefixes, should_drop_log_record
 
 
 class _BridgeLoggingHandler(logging.Handler):
-    def __init__(self, logger: ILogger) -> None:
+    def __init__(self, logger: ILogger, exclude_prefixes: list[str] | None = None) -> None:
         super().__init__()
         self._logger = logger
+        self._exclude_prefixes = normalize_excluded_logger_prefixes(exclude_prefixes)
 
     def emit(self, record: logging.LogRecord) -> None:
         try:
-            if record.name.startswith(_IGNORED_LOGGER_PREFIXES):
+            if is_internal_log_capture_suppressed():
+                return
+            if should_drop_log_record(
+                logger_name=record.name,
+                module_name=record.module,
+                exclude_prefixes=self._exclude_prefixes,
+            ):
                 return
 
             level = self._map_level(record.levelno)
@@ -63,16 +60,22 @@ class _BridgeLoggingHandler(logging.Handler):
 
 
 class RuntimeInterceptor:
-    def __init__(self, logger: ILogger, preserve_original: bool = True) -> None:
+    def __init__(
+        self,
+        logger: ILogger,
+        preserve_original: bool = True,
+        exclude_prefixes: list[str] | None = None,
+    ) -> None:
         self._logger = logger
         self._preserve_original = preserve_original
         self._enabled = False
+        self._exclude_prefixes = list(normalize_excluded_logger_prefixes(exclude_prefixes))
 
         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._bridge_handler = _BridgeLoggingHandler(logger, self._exclude_prefixes)
         self._original_handlers: list[logging.Handler] = []
 
     def enable(self) -> None:
@@ -113,10 +116,11 @@ class RuntimeInterceptor:
     def _patch_print(self) -> None:
         def intercepted_print(*args: Any, **kwargs: Any) -> None:
             try:
-                message = " ".join(
-                    [arg if isinstance(arg, str) else safe_stringify(arg) for arg in args]
-                )
-                self._logger.info(message, {"source": "print"})
+                if not is_internal_log_capture_suppressed():
+                    message = " ".join(
+                        [arg if isinstance(arg, str) else safe_stringify(arg) for arg in args]
+                    )
+                    self._logger.info(message, {"source": "print"})
             except Exception:
                 pass
 

elven_logs_interceptor_python-0.1.5/src/logs_interceptor/infrastructure/internal_capture_guard.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from collections.abc import Iterator
+from contextlib import contextmanager
+from contextvars import ContextVar
+
+_SUPPRESSION_DEPTH: ContextVar[int] = ContextVar(
+    "logs_interceptor_internal_capture_suppression_depth",
+    default=0,
+)
+
+
+@contextmanager
+def suppress_internal_log_capture() -> Iterator[None]:
+    token = _SUPPRESSION_DEPTH.set(_SUPPRESSION_DEPTH.get() + 1)
+    try:
+        yield
+    finally:
+        _SUPPRESSION_DEPTH.reset(token)
+
+
+def is_internal_log_capture_suppressed() -> bool:
+    return _SUPPRESSION_DEPTH.get() > 0

elven_logs_interceptor_python-0.1.5/src/logs_interceptor/infrastructure/log_noise_filter.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from collections.abc import Iterable, Mapping
+from typing import Any
+
+DEFAULT_EXCLUDED_LOGGER_PREFIXES = (
+    "httpcore",
+    "httpx",
+    "urllib3",
+    "hpack",
+    "h2",
+    "h11",
+    "opentelemetry",
+    "logs_interceptor",
+    "elven_unified_observability",
+)
+
+
+def normalize_excluded_logger_prefixes(prefixes: Iterable[str] | None = None) -> tuple[str, ...]:
+    values = list(prefixes) if prefixes is not None else list(DEFAULT_EXCLUDED_LOGGER_PREFIXES)
+    normalized: list[str] = []
+    seen: set[str] = set()
+    for item in values:
+        value = str(item).strip().lower()
+        if not value or value in seen:
+            continue
+        seen.add(value)
+        normalized.append(value)
+    return tuple(normalized)
+
+
+def should_drop_log_record(
+    *,
+    logger_name: str | None = None,
+    module_name: str | None = None,
+    extra: Mapping[str, Any] | None = None,
+    exclude_prefixes: Iterable[str] | None = None,
+) -> bool:
+    prefixes = normalize_excluded_logger_prefixes(exclude_prefixes)
+    if not prefixes:
+        return False
+
+    normalized_logger_name = str(logger_name or "").strip().lower()
+    normalized_module_name = str(module_name or "").strip().lower()
+    normalized_extra_logger_name = ""
+    if isinstance(extra, Mapping):
+        normalized_extra_logger_name = str(extra.get("logger_name") or "").strip().lower()
+
+    for prefix in prefixes:
+        if (
+            normalized_logger_name.startswith(prefix)
+            or normalized_module_name.startswith(prefix)
+            or normalized_extra_logger_name.startswith(prefix)
+        ):
+            return True
+    return False

{elven_logs_interceptor_python-0.1.4 → elven_logs_interceptor_python-0.1.5}/src/logs_interceptor/infrastructure/transport/loki_json_transport.py

@@ -12,7 +12,9 @@ import httpx
 from ...config import ResolvedTransportConfig
 from ...domain.entities import LogEntryEntity
 from ...types import TransportHealth, TransportMetrics
+from ...utils import get_distribution_version
 from ..compression import CompressorConfig, CompressorFactory
+from ..internal_capture_guard import suppress_internal_log_capture
 
 try:
     import orjson  # type: ignore[import-not-found]
@@ -88,7 +90,10 @@ class LokiJsonTransport:
             headers: dict[str, str] = {
                 "Content-Type": "application/json",
                 "X-Scope-OrgID": self._config.tenant_id,
-                "User-Agent": "elven-logs-interceptor-python/0.1.3",
+                "User-Agent": (
+                    "elven-logs-interceptor-python/"
+                    f"{get_distribution_version('elven-logs-interceptor-python')}"
+                ),
                 **self._extra_headers,
             }
             if self._config.auth_token:
@@ -98,7 +103,8 @@ class LokiJsonTransport:
                 if encoding:
                     headers["Content-Encoding"] = encoding
 
-            response = self._request(headers, body)
+            with suppress_internal_log_capture():
+                response = self._request(headers, body)
 
             if response.status_code >= 300:
                 raise RetryableTransportError(

{elven_logs_interceptor_python-0.1.4 → elven_logs_interceptor_python-0.1.5}/src/logs_interceptor/infrastructure/transport/loki_protobuf_transport.py

@@ -11,6 +11,8 @@ import httpx
 from ...config import ResolvedTransportConfig
 from ...domain.entities import LogEntryEntity
 from ...types import TransportHealth, TransportMetrics
+from ...utils import get_distribution_version
+from ..internal_capture_guard import suppress_internal_log_capture
 
 try:
     import snappy  # type: ignore[import-not-found]
@@ -94,13 +96,17 @@ class LokiProtobufTransport:
                 "Content-Type": "application/x-protobuf",
                 "Content-Encoding": "snappy",
                 "X-Scope-OrgID": self._config.tenant_id,
-                "User-Agent": "elven-logs-interceptor-python/0.1.3",
+                "User-Agent": (
+                    "elven-logs-interceptor-python/"
+                    f"{get_distribution_version('elven-logs-interceptor-python')}"
+                ),
                 **self._extra_headers,
             }
             if self._config.auth_token:
                 headers["Authorization"] = f"Bearer {self._config.auth_token}"
 
-            response = self._request(headers, compressed)
+            with suppress_internal_log_capture():
+                response = self._request(headers, compressed)
             if response.status_code >= 300:
                 raise RetryableTransportError(
                     message=f"Loki responded with {response.status_code}: {response.text}",

{elven_logs_interceptor_python-0.1.4 → elven_logs_interceptor_python-0.1.5}/src/logs_interceptor/integrations/logging_handler.py

@@ -5,16 +5,30 @@ import traceback as traceback_module
 from typing import Any
 
 from ..domain.interfaces import ILogger
+from ..infrastructure.internal_capture_guard import is_internal_log_capture_suppressed
+from ..infrastructure.log_noise_filter import (
+    normalize_excluded_logger_prefixes,
+    should_drop_log_record,
+)
 from ..types import LogLevel
 
 
 class LoggingHandler(logging.Handler):
-    def __init__(self, logger: ILogger) -> None:
+    def __init__(self, logger: ILogger, exclude_prefixes: list[str] | None = None) -> None:
         super().__init__()
         self._logger = logger
+        self._exclude_prefixes = normalize_excluded_logger_prefixes(exclude_prefixes)
 
     def emit(self, record: logging.LogRecord) -> None:
         try:
+            if is_internal_log_capture_suppressed():
+                return
+            if should_drop_log_record(
+                logger_name=record.name,
+                module_name=record.module,
+                exclude_prefixes=self._exclude_prefixes,
+            ):
+                return
             level = self._map_level(record.levelno)
             message = record.getMessage()
             context: dict[str, Any] = {

{elven_logs_interceptor_python-0.1.4 → elven_logs_interceptor_python-0.1.5}/src/logs_interceptor/integrations/loguru.py

@@ -4,19 +4,22 @@ from collections.abc import Mapping
 from typing import Any
 
 from ..domain.interfaces import ILogger
+from ..infrastructure.internal_capture_guard import is_internal_log_capture_suppressed
+from ..infrastructure.log_noise_filter import (
+    normalize_excluded_logger_prefixes,
+    should_drop_log_record,
+)
 
 
 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()
-        )
+        self._exclude_prefixes = normalize_excluded_logger_prefixes(exclude_prefixes)
 
     def __call__(self, message: Any) -> None:
         try:
+            if is_internal_log_capture_suppressed():
+                return
             record = getattr(message, "record", None)
             if not isinstance(record, Mapping):
                 self.logger.info(str(message), {"source": "loguru"})
@@ -73,21 +76,10 @@ class LoguruSink:
         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
+        return should_drop_log_record(
+            logger_name=str(record.get("name") or ""),
+            module_name=str(record.get("module") or ""),
+            extra=extra if isinstance(extra, Mapping) else None,
+            exclude_prefixes=self._exclude_prefixes,
+        )

elven_logs_interceptor_python-0.1.5/src/logs_interceptor/integrations/structlog.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any
+
+from ..domain.interfaces import ILogger
+from ..infrastructure.internal_capture_guard import is_internal_log_capture_suppressed
+from ..infrastructure.log_noise_filter import (
+    normalize_excluded_logger_prefixes,
+    should_drop_log_record,
+)
+
+
+class StructlogProcessor:
+    def __init__(self, logger: ILogger, exclude_prefixes: list[str] | None = None) -> None:
+        self.logger = logger
+        self._exclude_prefixes = normalize_excluded_logger_prefixes(exclude_prefixes)
+
+    def __call__(self, _logger: Any, method_name: str, event_dict: dict[str, Any]) -> dict[str, Any]:
+        if is_internal_log_capture_suppressed():
+            return event_dict
+        if should_drop_log_record(
+            logger_name=event_dict.get("logger_name"),
+            module_name=event_dict.get("module"),
+            extra=event_dict.get("extra") if isinstance(event_dict.get("extra"), Mapping) else None,
+            exclude_prefixes=self._exclude_prefixes,
+        ):
+            return event_dict
+
+        message = str(event_dict.get("event", method_name))
+        level = method_name.lower()
+        if level not in {"debug", "info", "warn", "error", "fatal"}:
+            level = "info"
+
+        context = dict(event_dict)
+        context.pop("event", None)
+        self.logger.log(level, message, {"source": "structlog", **context})  # type: ignore[arg-type]
+        return event_dict

{elven_logs_interceptor_python-0.1.4 → elven_logs_interceptor_python-0.1.5}/src/logs_interceptor/preload.py

@@ -8,14 +8,25 @@ import sys
 _LOGS_INTERCEPTOR_PRELOADED = False
 
 
+def _write(stream: object, prefix: str, *args: object) -> None:
+    message = " ".join(str(arg) for arg in args)
+    text = f"{prefix} {message}\n"
+    writer = getattr(stream, "write", None)
+    flusher = getattr(stream, "flush", None)
+    if callable(writer):
+        writer(text)
+    if callable(flusher):
+        flusher()
+
+
 def _debug(*args: object) -> None:
     if os.getenv("LOGS_DEBUG") == "true" and os.getenv("LOGS_SILENT_ERRORS") != "true":
-        print("[logs-interceptor:preload]", *args)
+        _write(sys.stdout, "[logs-interceptor:preload]", *args)
 
 
 def _error(*args: object) -> None:
     if os.getenv("LOGS_SILENT_ERRORS") != "true":
-        print("[logs-interceptor:preload]", *args, file=sys.stderr)
+        _write(sys.stderr, "[logs-interceptor:preload]", *args)
 
 
 def _install() -> None:

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

@@ -81,7 +81,11 @@ class LogsInterceptorFactory:
 
         runtime_interceptor = None
         if config.intercept_console:
-            runtime_interceptor = RuntimeInterceptor(logger, config.preserve_original_console)
+            runtime_interceptor = RuntimeInterceptor(
+                logger,
+                config.preserve_original_console,
+                exclude_prefixes=config.filter.exclude_logger_prefixes,
+            )
             runtime_interceptor.enable()
 
         original_destroy = logger.destroy

{elven_logs_interceptor_python-0.1.4 → elven_logs_interceptor_python-0.1.5}/src/logs_interceptor/utils.py

@@ -10,6 +10,7 @@ import sys
 from collections.abc import Iterable
 from dataclasses import asdict, fields, is_dataclass
 from datetime import datetime
+from functools import cache
 from typing import Any, cast
 
 from .config import (
@@ -80,6 +81,19 @@ def is_silent_errors_enabled() -> bool:
     return parse_bool(os.getenv("LOGS_SILENT_ERRORS"), False)
 
 
+@cache
+def get_distribution_version(distribution_name: str) -> str:
+    try:
+        from importlib.metadata import PackageNotFoundError, version
+    except ImportError:  # pragma: no cover - Python 3.10+ should not hit this
+        return "unknown"
+
+    try:
+        return version(distribution_name)
+    except PackageNotFoundError:
+        return "unknown"
+
+
 def _internal_log(level: str, message: str, context: Any | None = None) -> None:
     if level == "debug" and not is_debug_enabled():
         return
@@ -396,6 +410,12 @@ def load_config_from_env() -> LogsInterceptorConfig:
             max_message_length=parse_int_range(
                 env.get("LOGS_FILTER_MAX_MESSAGE_LENGTH"), 8192, 64, 1_000_000
             ),
+            exclude_logger_prefixes=[
+                item.strip()
+                for item in (env.get("LOGS_FILTER_EXCLUDE_LOGGER_PREFIXES") or "").split(",")
+                if item.strip()
+            ]
+            or None,
         ),
         circuit_breaker=CircuitBreakerConfig(
             enabled=parse_bool(env.get("LOGS_CIRCUIT_BREAKER_ENABLED"), True),

{elven_logs_interceptor_python-0.1.4 → elven_logs_interceptor_python-0.1.5}/tests/integration/test_api.py

@@ -100,3 +100,23 @@ def test_flush_propagates_transport_errors() -> None:
 
     with pytest.raises(httpx.ConnectError):
         instance.flush()
+
+
+def test_runtime_uses_configured_excluded_logger_prefixes() -> None:
+    instance = init(
+        {
+            **_valid_config(),
+            "interceptConsole": True,
+            "filter": {"excludeLoggerPrefixes": ["botocore"]},
+        }
+    )
+    assert instance is get_logger()
+
+    import logging
+
+    logging.getLogger("botocore.endpoint").warning("should be ignored")
+    logging.getLogger("service.app").warning("should be captured")
+
+    metrics = instance.get_metrics()
+    assert metrics["logs_processed"] >= 1
+    assert metrics["logs_processed"] < 3

{elven_logs_interceptor_python-0.1.4 → elven_logs_interceptor_python-0.1.5}/tests/unit/test_config_service.py

@@ -49,6 +49,8 @@ def test_resolve_applies_defaults() -> None:
     assert resolved.transport.max_retries == 3
     assert resolved.buffer.max_size == 100
     assert resolved.filter.sampling_rate == 1.0
+    assert "httpx" in resolved.filter.exclude_logger_prefixes
+    assert "logs_interceptor" in resolved.filter.exclude_logger_prefixes
     assert resolved.circuit_breaker.failure_threshold == 50
     assert resolved.performance.max_concurrent_flushes == 3
 
@@ -112,3 +114,15 @@ def test_resolve_transport_compression_variants() -> None:
         )
     )
     assert snappy_cfg.transport.compression == "snappy"
+
+
+def test_resolve_filter_normalizes_custom_excluded_prefixes() -> None:
+    resolved = ConfigService.resolve(
+        LogsInterceptorConfig(
+            transport=TransportConfig(url="https://loki.example.com/loki/api/v1/push", tenant_id="tenant"),
+            app_name="app",
+            filter=FilterConfig(exclude_logger_prefixes=["HTTPX", " httpx ", "custom_stack"]),
+        )
+    )
+
+    assert resolved.filter.exclude_logger_prefixes == ["httpx", "custom_stack"]

{elven_logs_interceptor_python-0.1.4 → elven_logs_interceptor_python-0.1.5}/tests/unit/test_env_config.py

@@ -45,3 +45,15 @@ def test_load_labels_from_prefix(monkeypatch) -> None:
     config = load_config_from_env()
 
     assert config.labels == {"service": "busca-prd", "environment": "prd"}
+
+
+def test_load_excluded_logger_prefixes_from_env(monkeypatch) -> None:
+    monkeypatch.setenv("LOGS_URL", "https://loki.example.com/loki/api/v1/push")
+    monkeypatch.setenv("LOGS_TENANT", "tenant-a")
+    monkeypatch.setenv("LOGS_APP_NAME", "app-a")
+    monkeypatch.setenv("LOGS_FILTER_EXCLUDE_LOGGER_PREFIXES", "httpx, httpcore ,custom_stack")
+
+    config = load_config_from_env()
+
+    assert config.filter is not None
+    assert config.filter.exclude_logger_prefixes == ["httpx", "httpcore", "custom_stack"]

elven_logs_interceptor_python-0.1.5/tests/unit/test_integration_filters.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+import logging
+
+from logs_interceptor.infrastructure.internal_capture_guard import suppress_internal_log_capture
+from logs_interceptor.integrations.logging_handler import LoggingHandler
+from logs_interceptor.integrations.structlog import StructlogProcessor
+
+
+class _Logger:
+    def __init__(self) -> None:
+        self.calls: list[tuple[str, str, dict[str, object] | None]] = []
+
+    def log(self, level, message, context=None):
+        self.calls.append((level, message, context))
+
+
+def test_logging_handler_ignores_records_during_internal_suppression() -> None:
+    logger = _Logger()
+    handler = LoggingHandler(logger)
+    record = logging.LogRecord(
+        name="service.api",
+        level=logging.INFO,
+        pathname=__file__,
+        lineno=10,
+        msg="hello",
+        args=(),
+        exc_info=None,
+    )
+
+    with suppress_internal_log_capture():
+        handler.emit(record)
+
+    assert logger.calls == []
+
+
+def test_structlog_processor_ignores_records_during_internal_suppression() -> None:
+    logger = _Logger()
+    processor = StructlogProcessor(logger)
+
+    with suppress_internal_log_capture():
+        result = processor(None, "info", {"event": "hello", "request_id": "req-1"})
+
+    assert result == {"event": "hello", "request_id": "req-1"}
+    assert logger.calls == []
+
+
+def test_logging_handler_ignores_configured_noisy_prefixes() -> None:
+    logger = _Logger()
+    handler = LoggingHandler(logger, exclude_prefixes=["botocore"])
+
+    noisy_record = logging.LogRecord(
+        name="botocore.endpoint",
+        level=logging.INFO,
+        pathname=__file__,
+        lineno=10,
+        msg="noise",
+        args=(),
+        exc_info=None,
+    )
+    app_record = logging.LogRecord(
+        name="service.api",
+        level=logging.INFO,
+        pathname=__file__,
+        lineno=20,
+        msg="hello",
+        args=(),
+        exc_info=None,
+    )
+
+    handler.emit(noisy_record)
+    handler.emit(app_record)
+
+    assert logger.calls == [
+        (
+            "info",
+            "hello",
+            {
+                "source": "python-logging",
+                "logger_name": "service.api",
+                "module": "test_integration_filters",
+                "function": None,
+                "line": 20,
+            },
+        )
+    ]

{elven_logs_interceptor_python-0.1.4 → elven_logs_interceptor_python-0.1.5}/tests/unit/test_loguru_sink.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from logs_interceptor.infrastructure.internal_capture_guard import suppress_internal_log_capture
 from logs_interceptor.integrations.loguru import LoguruSink
 
 
@@ -112,3 +113,25 @@ def test_loguru_sink_supports_loguru_record_level_objects() -> None:
             },
         )
     ]
+
+
+def test_loguru_sink_ignores_records_during_internal_suppression() -> None:
+    logger = _Logger()
+    sink = LoguruSink(logger)
+
+    with suppress_internal_log_capture():
+        sink(
+            _Message(
+                {
+                    "name": "service.api",
+                    "module": "app",
+                    "function": "handler",
+                    "line": 42,
+                    "message": "hello",
+                    "level": {"name": "INFO"},
+                    "extra": {"request_id": "req-1"},
+                }
+            )
+        )
+
+    assert logger.calls == []

{elven_logs_interceptor_python-0.1.4 → elven_logs_interceptor_python-0.1.5}/tests/unit/test_loki_json_transport.py

@@ -7,6 +7,9 @@ import pytest
 
 from logs_interceptor.config import ResolvedTransportConfig
 from logs_interceptor.domain.entities import LogEntryEntity
+from logs_interceptor.infrastructure.internal_capture_guard import (
+    is_internal_log_capture_suppressed,
+)
 from logs_interceptor.infrastructure.transport.loki_json_transport import LokiJsonTransport, RetryableTransportError
 
 
@@ -70,6 +73,24 @@ def test_loki_json_transport_http_error(monkeypatch: pytest.MonkeyPatch) -> None
     assert transport.get_health()["healthy"] is False
 
 
+def test_loki_json_transport_suppresses_internal_capture_during_request(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    transport = LokiJsonTransport(_config())
+    observed: list[bool] = []
+
+    def fake_request(headers, body):
+        del headers, body
+        observed.append(is_internal_log_capture_suppressed())
+        return _Response(status_code=204)
+
+    monkeypatch.setattr(transport, "_request", fake_request)
+
+    transport.send(_entries())
+
+    assert observed == [True]
+
+
 def test_timestamp_to_ns_uses_timezone_correctly() -> None:
     iso = "2026-02-20T19:39:14.123456+00:00"
     expected = int(datetime(2026, 2, 20, 19, 39, 14, 123456, tzinfo=timezone.utc).timestamp() * 1_000_000_000)

{elven_logs_interceptor_python-0.1.4 → elven_logs_interceptor_python-0.1.5}/tests/unit/test_protobuf_transport_safety.py

@@ -11,6 +11,10 @@ from logs_interceptor.config import (
     ResolvedPerformanceConfig,
     ResolvedTransportConfig,
 )
+from logs_interceptor.domain.entities import LogEntryEntity
+from logs_interceptor.infrastructure.internal_capture_guard import (
+    is_internal_log_capture_suppressed,
+)
 from logs_interceptor.infrastructure.transport.loki_protobuf_transport import LokiProtobufTransport
 from logs_interceptor.infrastructure.transport.resilient_transport import ResilientTransport
 from logs_interceptor.infrastructure.transport.transport_factory import TransportFactory
@@ -91,3 +95,47 @@ def test_transport_factory_falls_back_to_json_for_snappy_without_opt_in(monkeypa
     transport = TransportFactory.create(config)
     assert isinstance(transport, ResilientTransport)
     assert transport._transport.__class__.__name__ == "LokiJsonTransport"  # noqa: SLF001
+
+
+def test_protobuf_transport_suppresses_internal_capture_during_request(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    class _Snappy:
+        @staticmethod
+        def compress(raw: bytes) -> bytes:
+            return raw[::-1]
+
+    class _Response:
+        status_code = 204
+        text = ""
+
+    monkeypatch.setenv("LOGS_ENABLE_EXPERIMENTAL_PROTOBUF", "true")
+    monkeypatch.setattr(
+        "logs_interceptor.infrastructure.transport.loki_protobuf_transport.snappy",
+        _Snappy(),
+    )
+
+    transport = LokiProtobufTransport(_config().transport)
+    observed: list[bool] = []
+
+    def fake_request(headers, body):
+        del headers, body
+        observed.append(is_internal_log_capture_suppressed())
+        return _Response()
+
+    monkeypatch.setattr(transport, "_request", fake_request)
+
+    transport.send(
+        [
+            LogEntryEntity(
+                id="1",
+                timestamp="2026-01-01T00:00:00.000000+00:00",
+                level="info",
+                message="hello",
+                labels={"service": "billing"},
+                context={"a": 1},
+            )
+        ]
+    )
+
+    assert observed == [True]

{elven_logs_interceptor_python-0.1.4 → elven_logs_interceptor_python-0.1.5}/tests/unit/test_runtime_interceptor.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import logging
 
 from logs_interceptor.infrastructure.interceptors.runtime_interceptor import RuntimeInterceptor
+from logs_interceptor.infrastructure.internal_capture_guard import suppress_internal_log_capture
 
 
 class _Logger:
@@ -51,3 +52,16 @@ def test_runtime_interceptor_ignores_known_noisy_logger_prefixes() -> None:
     assert logger.records == []
 
     interceptor.restore()
+
+
+def test_runtime_interceptor_ignores_records_during_internal_suppression() -> None:
+    logger = _Logger()
+    interceptor = RuntimeInterceptor(logger)
+    interceptor.enable()
+
+    with suppress_internal_log_capture():
+        logging.getLogger("service.api").warning("internal transport noise")
+
+    assert logger.records == []
+
+    interceptor.restore()

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

@@ -1,21 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-
-from ..domain.interfaces import ILogger
-
-
-class StructlogProcessor:
-    def __init__(self, logger: ILogger) -> None:
-        self.logger = logger
-
-    def __call__(self, _logger: Any, method_name: str, event_dict: dict[str, Any]) -> dict[str, Any]:
-        message = str(event_dict.get("event", method_name))
-        level = method_name.lower()
-        if level not in {"debug", "info", "warn", "error", "fatal"}:
-            level = "info"
-
-        context = dict(event_dict)
-        context.pop("event", None)
-        self.logger.log(level, message, {"source": "structlog", **context})  # type: ignore[arg-type]
-        return event_dict