elven-logs-interceptor-python 0.1.2__py3-none-any.whl

logs_interceptor/integrations/flask.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+import time
+from typing import Any
+
+from ..domain.interfaces import ILogger
+
+
+class FlaskExtension:
+    def __init__(self, logger: ILogger) -> None:
+        self.logger = logger
+
+    def init_app(self, app: Any) -> None:
+        @app.before_request
+        def _before_request() -> None:
+            from flask import g, request
+
+            g._logs_interceptor_start_time = time.time()
+            request_id = request.headers.get("X-Request-Id") or f"req-{int(time.time() * 1000)}"
+            g._logs_interceptor_request_id = request_id
+
+        @app.after_request
+        def _after_request(response: Any) -> Any:
+            from flask import g, request
+
+            start = getattr(g, "_logs_interceptor_start_time", time.time())
+            request_id = getattr(g, "_logs_interceptor_request_id", "")
+            duration_ms = int((time.time() - start) * 1000)
+            status_code = int(getattr(response, "status_code", 200))
+
+            level = "info"
+            if status_code >= 500:
+                level = "error"
+            elif status_code >= 400:
+                level = "warn"
+
+            self.logger.with_context(
+                {"request_id": request_id},
+                lambda: self.logger.log(
+                    level,  # type: ignore[arg-type]
+                    f"{request.method} {request.path}",
+                    {
+                        "source": "flask",
+                        "type": "http_request",
+                        "status_code": status_code,
+                        "duration_ms": duration_ms,
+                    },
+                ),
+            )
+            return response

logs_interceptor/integrations/logging_handler.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+import logging
+import traceback as traceback_module
+from typing import Any
+
+from ..domain.interfaces import ILogger
+from ..types import LogLevel
+
+
+class LoggingHandler(logging.Handler):
+    def __init__(self, logger: ILogger) -> None:
+        super().__init__()
+        self._logger = logger
+
+    def emit(self, record: logging.LogRecord) -> None:
+        try:
+            level = self._map_level(record.levelno)
+            message = record.getMessage()
+            context: dict[str, Any] = {
+                "source": "python-logging",
+                "logger_name": record.name,
+                "module": record.module,
+                "function": record.funcName,
+                "line": record.lineno,
+            }
+            if record.exc_info:
+                context["exception"] = "".join(traceback_module.format_exception(*record.exc_info))
+            self._logger.log(level, message, context)
+        except Exception:
+            return
+
+    @staticmethod
+    def _map_level(level_no: int) -> LogLevel:
+        if level_no >= logging.CRITICAL:
+            return "fatal"
+        if level_no >= logging.ERROR:
+            return "error"
+        if level_no >= logging.WARNING:
+            return "warn"
+        if level_no >= logging.INFO:
+            return "info"
+        return "debug"

logs_interceptor/integrations/loguru.py

@@ -0,0 +1,36 @@
+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"),
+            },
+        )

logs_interceptor/integrations/structlog.py

@@ -0,0 +1,21 @@
+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

logs_interceptor/preload.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+import atexit
+import os
+import signal
+import sys
+
+_LOGS_INTERCEPTOR_PRELOADED = False
+
+
+def _debug(*args: object) -> None:
+    if os.getenv("LOGS_DEBUG") == "true" and os.getenv("LOGS_SILENT_ERRORS") != "true":
+        print("[logs-interceptor:preload]", *args)
+
+
+def _error(*args: object) -> None:
+    if os.getenv("LOGS_SILENT_ERRORS") != "true":
+        print("[logs-interceptor:preload]", *args, file=sys.stderr)
+
+
+def _install() -> None:
+    global _LOGS_INTERCEPTOR_PRELOADED
+    if _LOGS_INTERCEPTOR_PRELOADED:
+        return
+
+    _LOGS_INTERCEPTOR_PRELOADED = True
+
+    if os.getenv("LOGS_ENABLED") == "false":
+        _debug("Disabled by LOGS_ENABLED=false")
+        return
+
+    try:
+        os.environ["LOGS_AUTO_INIT"] = "true"
+        from . import destroy, is_initialized
+
+        if is_initialized():
+            _debug("Initialized successfully via auto-init gate")
+        else:
+            _debug("Auto-init did not run (missing required LOGS_* variables)")
+
+        def _graceful_shutdown(signame: str) -> None:
+            _debug(f"Graceful shutdown triggered by {signame}")
+            try:
+                destroy()
+            except Exception as exc:
+                _error("Graceful shutdown failed:", exc)
+
+        def _sigterm_handler(_sig: int, _frame: object) -> None:
+            _graceful_shutdown("SIGTERM")
+
+        def _sigint_handler(_sig: int, _frame: object) -> None:
+            _graceful_shutdown("SIGINT")
+
+        signal.signal(signal.SIGTERM, _sigterm_handler)
+        signal.signal(signal.SIGINT, _sigint_handler)
+        atexit.register(lambda: _graceful_shutdown("atexit"))
+    except Exception as exc:
+        _error("Preload failed:", exc)
+
+
+_install()

logs_interceptor/presentation/__init__.py

@@ -0,0 +1,3 @@
+from .factory import LogsInterceptorFactory, RuntimeBundle
+
+__all__ = ["LogsInterceptorFactory", "RuntimeBundle"]

logs_interceptor/presentation/factory.py

@@ -0,0 +1,128 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any
+
+from ..application.log_service import LogService
+from ..config import ResolvedLogsInterceptorConfig
+from ..domain.interfaces import ILogger
+from ..infrastructure.buffer import MemoryBuffer
+from ..infrastructure.circuit_breaker import CircuitBreaker
+from ..infrastructure.context import ContextVarProvider
+from ..infrastructure.dlq import FileDeadLetterQueue, MemoryDeadLetterQueue
+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
+except Exception:  # pragma: no cover - optional dependency
+    pass
+
+
+@dataclass(slots=True)
+class RuntimeBundle:
+    logger: ILogger
+    runtime_interceptor: RuntimeInterceptor | None = None
+
+
+class LogsInterceptorFactory:
+    @staticmethod
+    def create(config: ResolvedLogsInterceptorConfig) -> RuntimeBundle:
+        context_provider = ContextVarProvider()
+
+        dynamic_labels: dict[str, Callable[[], str | int]] = {
+            "request_id": lambda: str(context_provider.get("request_id", "")),
+        }
+
+        if otel_trace is not None:
+            dynamic_labels["trace_id"] = lambda: LogsInterceptorFactory._trace_id()
+            dynamic_labels["span_id"] = lambda: LogsInterceptorFactory._span_id()
+
+        dynamic_labels.update(config.dynamic_labels)
+
+        circuit_breaker = CircuitBreaker(config.circuit_breaker)
+
+        dlq: FileDeadLetterQueue | MemoryDeadLetterQueue | None = None
+        dlq_cfg = config.dead_letter_queue
+        if dlq_cfg and dlq_cfg.enabled is not False:
+            dlq_type = dlq_cfg.type or "memory"
+            if dlq_type == "file":
+                dlq = FileDeadLetterQueue(
+                    base_path=dlq_cfg.base_path,
+                    max_size=dlq_cfg.max_size or 1000,
+                    max_retries=dlq_cfg.max_retries or 3,
+                    max_file_size_mb=dlq_cfg.max_file_size_mb or 10,
+                )
+            else:
+                dlq = MemoryDeadLetterQueue(dlq_cfg.max_size or 1000)
+
+        transport = TransportFactory.create(config, circuit_breaker, dlq)
+        buffer = MemoryBuffer(config.buffer)
+        filter_service = LogFilter(config.filter)
+
+        logger = LogService(
+            filter_service,
+            buffer,
+            transport,
+            context_provider,
+            {
+                "app_name": config.app_name,
+                "version": config.version,
+                "environment": config.environment,
+                "labels": config.labels,
+                "dynamic_labels": dynamic_labels,
+                "enable_metrics": config.enable_metrics,
+                "max_concurrent_flushes": config.performance.max_concurrent_flushes,
+            },
+        )
+
+        runtime_interceptor = None
+        if config.intercept_console:
+            runtime_interceptor = RuntimeInterceptor(logger, config.preserve_original_console)
+            runtime_interceptor.enable()
+
+        original_destroy = logger.destroy
+
+        def wrapped_destroy() -> None:
+            if runtime_interceptor is not None:
+                runtime_interceptor.restore()
+            original_destroy()
+
+        logger.destroy = wrapped_destroy  # type: ignore[method-assign]
+
+        return RuntimeBundle(logger=logger, runtime_interceptor=runtime_interceptor)
+
+    @staticmethod
+    def _trace_id() -> str:
+        if otel_trace is None:
+            return ""
+        try:
+            span = otel_trace.get_current_span()
+            if span is None:
+                return ""
+            ctx = span.get_span_context()
+            trace_id = getattr(ctx, "trace_id", None)
+            if isinstance(trace_id, int):
+                return f"{trace_id:032x}"
+            return str(trace_id or "")
+        except Exception:
+            return ""
+
+    @staticmethod
+    def _span_id() -> str:
+        if otel_trace is None:
+            return ""
+        try:
+            span = otel_trace.get_current_span()
+            if span is None:
+                return ""
+            ctx = span.get_span_context()
+            span_id = getattr(ctx, "span_id", None)
+            if isinstance(span_id, int):
+                return f"{span_id:016x}"
+            return str(span_id or "")
+        except Exception:
+            return ""

logs_interceptor/types.py

@@ -0,0 +1,89 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Literal, TypedDict
+
+LogLevel = Literal["debug", "info", "warn", "error", "fatal"]
+CircuitBreakerState = Literal["closed", "open", "half-open"]
+
+
+class LogEntry(TypedDict, total=False):
+    id: str
+    timestamp: str
+    level: LogLevel
+    message: str
+    context: dict[str, Any]
+    trace_id: str
+    span_id: str
+    request_id: str
+    labels: dict[str, str]
+    metadata: dict[str, Any]
+
+
+class TransportHealth(TypedDict, total=False):
+    healthy: bool
+    last_successful_send: float
+    consecutive_failures: int
+    error_message: str
+
+
+class TransportMetrics(TypedDict, total=False):
+    total_sends: int
+    successful_sends: int
+    failed_sends: int
+    avg_latency: float
+    avg_compression_time: float
+    avg_compression_ratio: float
+    total_bytes_sent: int
+    total_bytes_compressed: int
+    retry_attempts: int
+    retried_requests: int
+    dlq_dropped_entries: int
+
+
+class LatencyMetrics(TypedDict):
+    p50: float
+    p95: float
+    p99: float
+    avg: float
+
+
+class CompressionMetrics(TypedDict):
+    avg_ratio: float
+    avg_time: float
+    total_saved_bytes: int
+
+
+class LoggerMetrics(TypedDict, total=False):
+    logs_processed: int
+    logs_dropped: int
+    logs_sanitized: int
+    flush_count: int
+    error_count: int
+    buffer_size: int
+    avg_flush_time: float
+    last_flush_time: float
+    memory_usage: float
+    cpu_usage: float
+    circuit_breaker_trips: int
+    dropped_by_backpressure: int
+    dropped_by_dlq: int
+    latency: LatencyMetrics
+    compression: CompressionMetrics
+    throughput: float
+
+
+class HealthStatus(TypedDict, total=False):
+    healthy: bool
+    last_successful_flush: float
+    consecutive_errors: int
+    buffer_utilization: float
+    uptime: float
+    memory_usage_mb: float
+    circuit_breaker_state: CircuitBreakerState
+    last_error: str
+
+
+@dataclass(frozen=True)
+class RuntimeState:
+    initialized: bool