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

logs_interceptor/infrastructure/circuit_breaker/circuit_breaker.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+import threading
+import time
+from collections.abc import Callable
+from typing import TypeVar
+
+from ...config import ResolvedCircuitBreakerConfig
+
+T = TypeVar("T")
+
+
+class CircuitBreaker:
+    def __init__(self, config: ResolvedCircuitBreakerConfig) -> None:
+        self._config = config
+        self._state: str = "closed"
+        self._failures = 0
+        self._success_count = 0
+        self._half_open_in_flight = 0
+        self._last_failure: float | None = None
+        self._next_attempt: float | None = None
+        self._last_error: str | None = None
+        self._lock = threading.Lock()
+
+    def execute(self, operation: Callable[[], T]) -> T:
+        if not self._config.enabled:
+            return operation()
+
+        with self._lock:
+            if self._is_open_locked():
+                raise RuntimeError("Circuit breaker is open")
+            counted_as_probe = self._state == "half-open"
+            if counted_as_probe and self._half_open_in_flight >= self._config.half_open_requests:
+                raise RuntimeError("Circuit breaker half-open probe limit reached")
+            if counted_as_probe:
+                self._half_open_in_flight += 1
+
+        try:
+            result = operation()
+            self.record_success()
+            return result
+        except Exception as exc:
+            self.record_failure(exc)
+            raise
+        finally:
+            if self._state == "half-open":
+                with self._lock:
+                    self._half_open_in_flight = max(0, self._half_open_in_flight - 1)
+
+    def record_success(self) -> None:
+        with self._lock:
+            if self._state == "half-open":
+                self._success_count += 1
+                if self._success_count >= self._config.half_open_requests:
+                    self._state = "closed"
+                    self._failures = 0
+                    self._success_count = 0
+                    self._half_open_in_flight = 0
+                    self._last_error = None
+                return
+
+            if self._state == "closed":
+                self._failures = 0
+                self._last_error = None
+
+    def record_failure(self, error: Exception | None = None) -> None:
+        with self._lock:
+            self._failures += 1
+            self._last_failure = time.time()
+            if error is not None:
+                self._last_error = str(error)
+
+            if self._failures >= self._config.failure_threshold or self._state == "half-open":
+                self._state = "open"
+                self._success_count = 0
+                self._half_open_in_flight = 0
+                self._next_attempt = time.time() + (self._config.reset_timeout / 1000)
+
+    def get_state(self) -> dict[str, float | int | str | None]:
+        with self._lock:
+            return {
+                "state": self._state,
+                "failures": self._failures,
+                "success_count": self._success_count,
+                "half_open_in_flight": self._half_open_in_flight,
+                "last_failure": self._last_failure,
+                "next_attempt": self._next_attempt,
+                "last_error": self._last_error,
+            }
+
+    def reset(self) -> None:
+        with self._lock:
+            self._state = "closed"
+            self._failures = 0
+            self._success_count = 0
+            self._half_open_in_flight = 0
+            self._last_failure = None
+            self._next_attempt = None
+            self._last_error = None
+
+    def _is_open_locked(self) -> bool:
+        if self._state != "open":
+            return False
+        now = time.time()
+        if self._next_attempt and now >= self._next_attempt:
+            self._state = "half-open"
+            self._success_count = 0
+            self._half_open_in_flight = 0
+            return False
+        return True

logs_interceptor/infrastructure/compression/__init__.py

@@ -0,0 +1,14 @@
+from .base import Compressor, CompressorConfig
+from .brotli_compressor import BrotliCompressor
+from .factory import CompressorFactory
+from .gzip_compressor import GzipCompressor
+from .noop_compressor import NoOpCompressor
+
+__all__ = [
+    "Compressor",
+    "CompressorConfig",
+    "CompressorFactory",
+    "GzipCompressor",
+    "BrotliCompressor",
+    "NoOpCompressor",
+]

logs_interceptor/infrastructure/compression/base.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(slots=True)
+class CompressorConfig:
+    level: int | None = None
+    threshold: int | None = None
+
+
+class Compressor:
+    def compress(self, data: bytes) -> bytes:
+        raise NotImplementedError
+
+    def get_content_encoding(self) -> str:
+        raise NotImplementedError
+
+    def get_name(self) -> str:
+        raise NotImplementedError

logs_interceptor/infrastructure/compression/brotli_compressor.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from typing import cast
+
+from .base import Compressor, CompressorConfig
+
+try:
+    import brotli  # type: ignore[import-not-found]
+except Exception:  # pragma: no cover - optional dependency
+    brotli = None
+
+
+class BrotliCompressor(Compressor):
+    def __init__(self, config: CompressorConfig | None = None) -> None:
+        self._config = config or CompressorConfig()
+        self._level = 4 if self._config.level is None else self._config.level
+
+    def compress(self, data: bytes) -> bytes:
+        if brotli is None:
+            raise RuntimeError("brotli extra is not installed")
+        return cast(bytes, brotli.compress(data, quality=self._level))
+
+    def get_content_encoding(self) -> str:
+        return "br"
+
+    def get_name(self) -> str:
+        return "brotli"

logs_interceptor/infrastructure/compression/factory.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from .base import Compressor, CompressorConfig
+from .brotli_compressor import BrotliCompressor
+from .gzip_compressor import GzipCompressor
+from .noop_compressor import NoOpCompressor
+
+
+class CompressorFactory:
+    @staticmethod
+    def create(type_name: str | bool | None, config: CompressorConfig | None = None) -> Compressor:
+        if type_name in (False, "none"):
+            return NoOpCompressor()
+        if type_name in (True, None, "gzip"):
+            return GzipCompressor(config)
+        if type_name == "brotli":
+            return BrotliCompressor(config)
+        return GzipCompressor(config)

logs_interceptor/infrastructure/compression/gzip_compressor.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+import gzip
+
+from .base import Compressor, CompressorConfig
+
+
+class GzipCompressor(Compressor):
+    def __init__(self, config: CompressorConfig | None = None) -> None:
+        self._config = config or CompressorConfig()
+        self._level = 6 if self._config.level is None else self._config.level
+
+    def compress(self, data: bytes) -> bytes:
+        return gzip.compress(data, compresslevel=self._level)
+
+    def get_content_encoding(self) -> str:
+        return "gzip"
+
+    def get_name(self) -> str:
+        return "gzip"

logs_interceptor/infrastructure/compression/noop_compressor.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+from .base import Compressor
+
+
+class NoOpCompressor(Compressor):
+    def compress(self, data: bytes) -> bytes:
+        return data
+
+    def get_content_encoding(self) -> str:
+        return ""
+
+    def get_name(self) -> str:
+        return "none"

logs_interceptor/infrastructure/context/__init__.py

@@ -0,0 +1,3 @@
+from .context_provider import ContextVarProvider
+
+__all__ = ["ContextVarProvider"]

logs_interceptor/infrastructure/context/context_provider.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from contextvars import ContextVar
+from typing import Any
+
+
+class ContextVarProvider:
+    def __init__(self) -> None:
+        self._context: ContextVar[dict[str, Any] | None] = ContextVar(
+            "logs_interceptor_context", default=None
+        )
+
+    def get_context(self) -> dict[str, Any]:
+        return dict(self._context.get() or {})
+
+    def run_with_context(self, context: dict[str, Any], fn: Any) -> Any:
+        merged = {**(self._context.get() or {}), **context}
+        token = self._context.set(merged)
+        try:
+            return fn()
+        finally:
+            self._context.reset(token)
+
+    async def run_with_context_async(self, context: dict[str, Any], fn: Any) -> Any:
+        merged = {**(self._context.get() or {}), **context}
+        token = self._context.set(merged)
+        try:
+            result = fn()
+            if hasattr(result, "__await__"):
+                return await result
+            return result
+        finally:
+            self._context.reset(token)
+
+    def set(self, key: str, value: Any) -> None:
+        merged = self.get_context()
+        merged[key] = value
+        self._context.set(merged)
+
+    def get(self, key: str, default: Any = None) -> Any:
+        return (self._context.get() or {}).get(key, default)
+
+    def clear(self) -> None:
+        self._context.set({})

logs_interceptor/infrastructure/dlq/__init__.py

@@ -0,0 +1,4 @@
+from .file_dlq import FileDeadLetterQueue
+from .memory_dlq import MemoryDeadLetterQueue
+
+__all__ = ["MemoryDeadLetterQueue", "FileDeadLetterQueue"]

logs_interceptor/infrastructure/dlq/file_dlq.py

@@ -0,0 +1,170 @@
+from __future__ import annotations
+
+import json
+import os
+import threading
+import time
+from dataclasses import dataclass
+from pathlib import Path
+
+from ...domain.entities import LogEntryEntity
+from ...utils import internal_warn
+
+
+@dataclass(slots=True)
+class _DLQEntry:
+    entry: LogEntryEntity
+    reason: str
+    timestamp: float
+    retry_count: int
+
+
+class FileDeadLetterQueue:
+    def __init__(
+        self,
+        base_path: str | None = None,
+        max_size: int = 1000,
+        max_file_size_mb: int = 10,
+        max_retries: int = 3,
+    ) -> None:
+        path = Path(base_path or os.getcwd())
+        self._dlq_dir = path / ".logs-interceptor-dlq"
+        self._dlq_dir.mkdir(parents=True, exist_ok=True)
+
+        self._file_path = self._dlq_dir / "dlq-current.jsonl"
+        self._max_size = max_size
+        self._max_file_size_mb = max_file_size_mb
+        self._max_retries = max_retries
+        self._dropped_entries = 0
+        self._queue: list[_DLQEntry] = []
+        self._lock = threading.RLock()
+
+        self.load_from_disk()
+
+    def add(self, entry: LogEntryEntity, reason: str) -> dict[str, int]:
+        return self.add_batch([entry], reason)
+
+    def add_batch(self, entries: list[LogEntryEntity], reason: str) -> dict[str, int]:
+        if not entries:
+            return {"added": 0, "dropped": 0}
+
+        with self._lock:
+            dropped = 0
+            ts = time.time()
+            for entry in entries:
+                if len(self._queue) >= self._max_size:
+                    self._queue.pop(0)
+                    self._dropped_entries += 1
+                    dropped += 1
+                self._queue.append(_DLQEntry(entry=entry, reason=reason, timestamp=ts, retry_count=0))
+
+            self._persist_queue_to_disk()
+            return {"added": len(entries), "dropped": dropped}
+
+    def flush(self) -> int:
+        return 0
+
+    def size(self) -> int:
+        with self._lock:
+            return len(self._queue)
+
+    def clear(self) -> None:
+        with self._lock:
+            self._queue.clear()
+            try:
+                if self._file_path.exists():
+                    self._file_path.unlink()
+            except OSError as exc:
+                internal_warn("[FileDLQ] Failed to clear file", exc)
+
+    def get_entries(self, limit: int = 100) -> list[dict[str, object]]:
+        with self._lock:
+            return [
+                {
+                    "entry": item.entry,
+                    "reason": item.reason,
+                    "timestamp": item.timestamp,
+                }
+                for item in self._queue[:limit]
+            ]
+
+    def get_stats(self) -> dict[str, int]:
+        with self._lock:
+            return {"size": len(self._queue), "dropped_entries": self._dropped_entries}
+
+    def load_from_disk(self) -> int:
+        if not self._file_path.exists():
+            return 0
+
+        with self._lock:
+            try:
+                lines = self._file_path.read_text(encoding="utf-8").splitlines()
+                loaded: list[_DLQEntry] = []
+                for line in lines:
+                    if not line.strip():
+                        continue
+                    try:
+                        item = json.loads(line)
+                        retry_count = int(item.get("retry_count", 0))
+                        if retry_count > self._max_retries:
+                            continue
+                        entry_payload = item.get("entry", {})
+                        if not isinstance(entry_payload, dict):
+                            continue
+                        loaded.append(
+                            _DLQEntry(
+                                entry=LogEntryEntity(
+                                    id=str(entry_payload.get("id", "")),
+                                    timestamp=str(entry_payload.get("timestamp", "")),
+                                    level=str(entry_payload.get("level", "info")),  # type: ignore[arg-type]
+                                    message=str(entry_payload.get("message", "")),
+                                    context=entry_payload.get("context"),
+                                    trace_id=entry_payload.get("trace_id"),
+                                    span_id=entry_payload.get("span_id"),
+                                    request_id=entry_payload.get("request_id"),
+                                    labels=entry_payload.get("labels"),
+                                    metadata=entry_payload.get("metadata"),
+                                ),
+                                reason=str(item.get("reason", "unknown")),
+                                timestamp=float(item.get("timestamp", time.time())),
+                                retry_count=retry_count,
+                            )
+                        )
+                    except Exception:
+                        continue
+
+                if len(loaded) > self._max_size:
+                    self._dropped_entries += len(loaded) - self._max_size
+                self._queue = loaded[-self._max_size :]
+                return len(self._queue)
+            except OSError as exc:
+                internal_warn("[FileDLQ] Failed to load from disk", exc)
+                return 0
+
+    def _persist_queue_to_disk(self) -> None:
+        lines = [
+            json.dumps(
+                {
+                    "entry": item.entry.to_dict(),
+                    "reason": item.reason,
+                    "timestamp": item.timestamp,
+                    "retry_count": item.retry_count,
+                },
+                ensure_ascii=False,
+                separators=(",", ":"),
+            )
+            for item in self._queue
+        ]
+        content = "\n".join(lines)
+        if content:
+            content += "\n"
+
+        max_bytes = self._max_file_size_mb * 1024 * 1024
+        if len(content.encode("utf-8")) > max_bytes and self._queue:
+            half = max(1, len(self._queue) // 2)
+            dropped = len(self._queue) - half
+            self._queue = self._queue[-half:]
+            self._dropped_entries += dropped
+            return self._persist_queue_to_disk()
+
+        self._file_path.write_text(content, encoding="utf-8")

logs_interceptor/infrastructure/dlq/memory_dlq.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass
+
+from ...domain.entities import LogEntryEntity
+
+
+@dataclass(slots=True)
+class _DLQEntry:
+    entry: LogEntryEntity
+    reason: str
+    timestamp: float
+    retry_count: int
+
+
+class MemoryDeadLetterQueue:
+    def __init__(self, max_size: int = 1000) -> None:
+        self._queue: list[_DLQEntry] = []
+        self._max_size = max_size
+        self._dropped_entries = 0
+
+    def add(self, entry: LogEntryEntity, reason: str) -> dict[str, int]:
+        return self.add_batch([entry], reason)
+
+    def add_batch(self, entries: list[LogEntryEntity], reason: str) -> dict[str, int]:
+        dropped = 0
+        timestamp = time.time()
+        for entry in entries:
+            if len(self._queue) >= self._max_size:
+                self._queue.pop(0)
+                self._dropped_entries += 1
+                dropped += 1
+            self._queue.append(_DLQEntry(entry=entry, reason=reason, timestamp=timestamp, retry_count=0))
+        return {"added": len(entries), "dropped": dropped}
+
+    def flush(self) -> int:
+        count = len(self._queue)
+        self._queue.clear()
+        return count
+
+    def size(self) -> int:
+        return len(self._queue)
+
+    def clear(self) -> None:
+        self._queue.clear()
+
+    def get_entries(self, limit: int = 100) -> list[dict[str, object]]:
+        return [
+            {
+                "entry": item.entry,
+                "reason": item.reason,
+                "timestamp": item.timestamp,
+            }
+            for item in self._queue[:limit]
+        ]
+
+    def get_stats(self) -> dict[str, int]:
+        return {"size": len(self._queue), "dropped_entries": self._dropped_entries}

logs_interceptor/infrastructure/filter/__init__.py

@@ -0,0 +1,3 @@
+from .log_filter import LogFilter
+
+__all__ = ["LogFilter"]

logs_interceptor/infrastructure/filter/log_filter.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+import re
+
+from ...config import ResolvedFilterConfig
+from ...domain.entities import LogEntryEntity
+from ...types import LogLevel
+from ...utils import detect_sensitive_data, sanitize_data, should_sample
+
+
+class LogFilter:
+    def __init__(self, config: ResolvedFilterConfig) -> None:
+        self._config = config
+        self._patterns = [re.compile(pattern) for pattern in config.patterns]
+
+    def should_process(self, entry: LogEntryEntity) -> bool:
+        if not self.is_level_enabled(entry.level):
+            return False
+
+        if self._patterns:
+            if not any(pattern.search(entry.message) for pattern in self._patterns):
+                return False
+
+        if not should_sample(self._config.sampling_rate):
+            return False
+
+        return True
+
+    def filter(self, entry: LogEntryEntity) -> LogEntryEntity:
+        message = entry.message
+        if len(message) > self._config.max_message_length:
+            message = message[: self._config.max_message_length] + "...[truncated]"
+
+        context = entry.context
+        if self._config.sanitize and context is not None:
+            context = sanitize_data(context, self._config.sensitive_patterns)
+
+        if self._config.sanitize and detect_sensitive_data(message, self._config.sensitive_patterns):
+            message = "[REDACTED]"
+
+        return LogEntryEntity(
+            id=entry.id,
+            timestamp=entry.timestamp,
+            level=entry.level,
+            message=message,
+            context=context,
+            trace_id=entry.trace_id,
+            span_id=entry.span_id,
+            request_id=entry.request_id,
+            labels=entry.labels,
+            metadata=entry.metadata,
+        )
+
+    def is_level_enabled(self, level: LogLevel) -> bool:
+        return level in self._config.levels

logs_interceptor/infrastructure/interceptors/__init__.py

@@ -0,0 +1,3 @@
+from .runtime_interceptor import RuntimeInterceptor
+
+__all__ = ["RuntimeInterceptor"]