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

{elven_logs_interceptor_python-0.1.2 → 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.2
+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.2 → 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.2"
+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.2 → 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
+otel_trace: Any | None
 try:
     from opentelemetry import trace as otel_trace
 except Exception:  # pragma: no cover - optional dependency
-    pass
+    otel_trace = None
 
 
 @dataclass(slots=True)

{elven_logs_interceptor_python-0.1.2 → elven_logs_interceptor_python-0.1.4}/src/logs_interceptor/infrastructure/buffer/memory_buffer.py

@@ -165,12 +165,16 @@ class MemoryBuffer:
             return
 
         def _on_timer() -> None:
+            callback: Callable[[], None] | None = None
             with self._lock:
                 self._flush_timer = None
                 if self._destroyed:
                     return
                 if self._flush_callback and self._entries:
-                    self._flush_callback()
+                    callback = self._flush_callback
+
+            if callback is not None:
+                callback()
 
         self._flush_timer = threading.Timer(self._config.flush_interval / 1000, _on_timer)
         self._flush_timer.daemon = True

{elven_logs_interceptor_python-0.1.2 → 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.2 → elven_logs_interceptor_python-0.1.4}/src/logs_interceptor/infrastructure/transport/loki_json_transport.py

@@ -88,7 +88,7 @@ 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.2",
+                "User-Agent": "elven-logs-interceptor-python/0.1.3",
                 **self._extra_headers,
             }
             if self._config.auth_token:

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

@@ -94,7 +94,7 @@ 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.2",
+                "User-Agent": "elven-logs-interceptor-python/0.1.3",
                 **self._extra_headers,
             }
             if self._config.auth_token:

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.2 → 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
+otel_trace: Any | None
 try:
     from opentelemetry import trace as otel_trace
 except Exception:  # pragma: no cover - optional dependency
-    pass
+    otel_trace = None
 
 
 @dataclass(slots=True)

elven_logs_interceptor_python-0.1.4/test-apps/elven-live-demo/.env.example

@@ -0,0 +1,49 @@
+LOGS_URL=https://loki.elvenobservability.com/loki/api/v1/push
+LOGS_TENANT=elven
+LOGS_TOKEN=replace-with-your-token
+LOGS_APP_NAME=elven-live-demo
+LOGS_APP_VERSION=1.0.0
+LOGS_ENVIRONMENT=local
+
+LOGS_COMPRESSION=gzip
+LOGS_COMPRESSION_LEVEL=4
+LOGS_COMPRESSION_THRESHOLD=1024
+LOGS_CONNECTION_POOLING=true
+LOGS_MAX_SOCKETS=50
+LOGS_TIMEOUT=10000
+LOGS_MAX_RETRIES=3
+LOGS_RETRY_DELAY=1000
+
+LOGS_BUFFER_MAX_SIZE=25
+LOGS_BUFFER_FLUSH_INTERVAL=1500
+LOGS_BUFFER_MAX_MEMORY_MB=128
+LOGS_BUFFER_MAX_AGE=30000
+LOGS_BUFFER_AUTO_FLUSH=true
+
+LOGS_FILTER_LEVELS=debug,info,warn,error,fatal
+LOGS_FILTER_SAMPLING_RATE=1.0
+LOGS_FILTER_SANITIZE=true
+LOGS_FILTER_MAX_MESSAGE_LENGTH=8192
+
+LOGS_CIRCUIT_BREAKER_ENABLED=true
+LOGS_CIRCUIT_BREAKER_FAILURE_THRESHOLD=20
+LOGS_CIRCUIT_BREAKER_RESET_TIMEOUT=15000
+LOGS_CIRCUIT_BREAKER_HALF_OPEN_REQUESTS=3
+
+LOGS_DLQ_ENABLED=true
+LOGS_DLQ_TYPE=file
+LOGS_DLQ_MAX_SIZE=1000
+LOGS_DLQ_MAX_RETRIES=3
+LOGS_DLQ_BASE_PATH=./.logs-dlq
+
+LOGS_MAX_CONCURRENT_FLUSHES=5
+LOGS_INTERCEPT_CONSOLE=true
+LOGS_PRESERVE_ORIGINAL_CONSOLE=true
+LOGS_ENABLE_METRICS=true
+LOGS_ENABLE_HEALTH_CHECK=true
+LOGS_DEBUG=false
+LOGS_SILENT_ERRORS=false
+LOGS_ENABLED=true
+
+LOGS_LABEL_SERVICE=elven-live-demo
+LOGS_LABEL_ENVIRONMENT=local

elven_logs_interceptor_python-0.1.4/test-apps/elven-live-demo/README.md

@@ -0,0 +1,17 @@
+# Elven Live Demo
+
+Local Python app to exercise `elven-logs-interceptor-python` against the Elven Loki endpoint.
+
+## Run
+
+```bash
+cd /Users/leonardozwirtes/Documents/Projects/logs-interceptor-python
+chmod +x test-apps/elven-live-demo/run.sh
+./test-apps/elven-live-demo/run.sh
+```
+
+## Notes
+
+- The tracked config template is `.env.example`.
+- The real token lives only in local `.env`, which is ignored by Git.
+- The package import remains `logs_interceptor`.

elven_logs_interceptor_python-0.1.4/test-apps/elven-live-demo/app.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+import asyncio
+import random
+import time
+
+from logs_interceptor import destroy, init, logger
+
+
+def emit_startup_logs() -> None:
+    logger.info("demo app started", {"component": "startup"})
+    logger.track_event("demo_started", {"source": "local-run", "at": time.time()})
+
+
+def emit_business_logs() -> None:
+    for idx in range(10):
+        logger.info(
+            "processing item",
+            {
+                "idx": idx,
+                "value": random.randint(100, 999),
+                "duration_ms": round(random.uniform(5, 30), 2),
+            },
+        )
+
+    logger.warn("slow dependency detected", {"dependency": "inventory-service", "latency_ms": 187})
+
+    try:
+        raise RuntimeError("simulated business exception")
+    except RuntimeError as exc:
+        logger.error(
+            "handled domain error",
+            {
+                "error": str(exc),
+                "kind": "business",
+            },
+        )
+
+
+def emit_sync_context_logs() -> None:
+    def _run() -> None:
+        logger.info("sync request started", {"method": "GET", "path": "/products"})
+        print("plain print still works and is intercepted")
+
+    logger.with_context(
+        {
+            "request_id": "demo-sync-request-1",
+            "trace_id": "demo-sync-trace-1",
+            "span_id": "demo-sync-span-1",
+        },
+        _run,
+    )
+
+
+async def emit_async_context_logs() -> None:
+    async def _run() -> None:
+        logger.info("async job started", {"job": "catalog-refresh"})
+        await asyncio.sleep(0.05)
+        logger.track_event("catalog_refresh_finished", {"ok": True})
+
+    await logger.with_context_async(
+        {
+            "request_id": "demo-async-request-1",
+            "trace_id": "demo-async-trace-1",
+            "span_id": "demo-async-span-1",
+        },
+        _run,
+    )
+
+
+def print_runtime_summary() -> None:
+    metrics = logger.get_metrics()
+    health = logger.get_health()
+    print(
+        {
+            "processed": metrics.get("logs_processed"),
+            "dropped": metrics.get("logs_dropped"),
+            "flush_count": metrics.get("flush_count"),
+            "error_count": metrics.get("error_count"),
+        }
+    )
+    print({"health": health})
+
+
+def main() -> None:
+    init()
+    emit_startup_logs()
+    emit_business_logs()
+    emit_sync_context_logs()
+    asyncio.run(emit_async_context_logs())
+    logger.flush()
+    print_runtime_summary()
+    destroy()
+
+
+if __name__ == "__main__":
+    main()

elven_logs_interceptor_python-0.1.4/test-apps/elven-observability-smoke/run.sh

@@ -0,0 +1,21 @@
+#!/usr/bin/env bash
+set -Eeuo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+ROOT_DIR="$(cd "${SCRIPT_DIR}/../.." && pwd)"
+
+if [[ ! -f "${SCRIPT_DIR}/.env" ]]; then
+  echo "Missing .env at ${SCRIPT_DIR}/.env" >&2
+  if [[ -f "${SCRIPT_DIR}/.env.example" ]]; then
+    echo "Create it with: cp ${SCRIPT_DIR}/.env.example ${SCRIPT_DIR}/.env" >&2
+  fi
+  exit 1
+fi
+
+set -a
+source "${SCRIPT_DIR}/.env"
+set +a
+
+export PYTHONPATH="${ROOT_DIR}/src:${PYTHONPATH:-}"
+
+python3 "${SCRIPT_DIR}/app.py"

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.2 → elven_logs_interceptor_python-0.1.4}/tests/unit/test_memory_buffer_extra.py

@@ -106,6 +106,33 @@ def test_schedule_flush_callback_runs_with_entries() -> None:
     buffer.destroy()
 
 
+def test_schedule_flush_callback_does_not_hold_buffer_lock() -> None:
+    callback_started = threading.Event()
+    release_callback = threading.Event()
+    add_completed = threading.Event()
+    buffer = _buffer(flush_interval=5, auto_flush=True)
+
+    def flush_callback() -> None:
+        callback_started.set()
+        release_callback.wait(timeout=1)
+
+    buffer.set_flush_callback(flush_callback)
+    buffer.add(_entry("1", "2026-01-01T00:00:00+00:00"))
+    assert callback_started.wait(timeout=1)
+
+    def add_entry() -> None:
+        buffer.add(_entry("2", "2026-01-01T00:00:01+00:00"))
+        add_completed.set()
+
+    add_thread = threading.Thread(target=add_entry)
+    add_thread.start()
+    assert add_completed.wait(timeout=0.2)
+
+    release_callback.set()
+    add_thread.join(timeout=1)
+    buffer.destroy()
+
+
 def test_schedule_flush_destroyed_guard_inside_timer() -> None:
     event = threading.Event()
     buffer = _buffer(flush_interval=40, auto_flush=False)

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.2/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"),
-            },
-        )