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

{elven_logs_interceptor_python-0.1.3 → 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.3
+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.3 → 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.3"
+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.3 → 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.3 → 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.3 → elven_logs_interceptor_python-0.1.5}/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.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.3 → elven_logs_interceptor_python-0.1.5}/src/logs_interceptor/infrastructure/interceptors/runtime_interceptor.py

@@ -10,15 +10,27 @@ from typing import Any
 from ...domain.interfaces import ILogger
 from ...types import LogLevel
 from ...utils import safe_stringify
+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 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)
             msg = record.getMessage()
             context = {
@@ -48,20 +60,31 @@ 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._bridge_handler = _BridgeLoggingHandler(logger)
+        self._original_root_level = self._root_logger.level
+        self._bridge_handler = _BridgeLoggingHandler(logger, self._exclude_prefixes)
         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 +103,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
 
@@ -91,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.3 → 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.3 → 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.3 → 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.5/src/logs_interceptor/integrations/loguru.py

@@ -0,0 +1,85 @@
+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 LoguruSink:
+    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, 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"})
+                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:
+        extra = record.get("extra")
+        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.3 → 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.3 → elven_logs_interceptor_python-0.1.5}/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)
@@ -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.3 → 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.3 → 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.3 → 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.3 → 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"]