logxpy 0.1.0__py3-none-any.whl

logxpy/_async.py

@@ -0,0 +1,186 @@
+"""Async action and scope - integrates with eliot's context system."""
+
+from __future__ import annotations
+
+from collections.abc import AsyncIterator, Callable, Iterator
+from contextlib import asynccontextmanager, contextmanager
+from contextvars import ContextVar, Token
+from typing import Any
+
+# Reuse eliot's context var for compatibility
+from ._action import _ACTION_CONTEXT, current_action
+from ._base import now, uuid
+from ._types import Level, Record
+
+# Additional scope context (LoggerX feature - logxpy doesn't have this)
+_SCOPE: ContextVar[dict[str, Any]] = ContextVar("loggerx_scope", default={})
+
+
+def current_scope() -> dict[str, Any]:
+    return _SCOPE.get()
+
+
+def _get_parent_info() -> tuple[str, tuple[int, ...]]:
+    """Get task_uuid and next level from current logxpy action."""
+    parent = current_action()
+    if parent:
+        # eliot.Action has task_uuid property and _task_level (TaskLevel object)
+        task_uuid = parent.task_uuid
+        # Get current level and create child level
+        if hasattr(parent, "_task_level"):
+            level = tuple(parent._task_level.as_list()) + (1,)
+        else:
+            level = (1,)
+        return task_uuid, level
+    return uuid(), (1,)
+
+
+# === AsyncAction (works alongside eliot.Action for async contexts) ===
+class AsyncAction:
+    """Async-native action that integrates with eliot's context system."""
+
+    __slots__ = (
+        "_child_count",
+        "_start",
+        "_token",
+        "action_type",
+        "fields",
+        "level",
+        "task_level",
+        "task_uuid",
+    )
+
+    def __init__(
+        self,
+        action_type: str,
+        task_uuid: str,
+        task_level: tuple[int, ...],
+        level: Level = Level.INFO,
+        **fields: Any,
+    ):
+        self.task_uuid = task_uuid
+        self.task_level = task_level
+        self.action_type = action_type
+        self.fields = fields
+        self.level = level
+        self._start = now()
+        self._token: Token[Any] | None = None
+        self._child_count = 0
+
+    def child_level(self) -> tuple[int, ...]:
+        self._child_count += 1
+        return (*self.task_level, self._child_count)
+
+    def _enter(self) -> AsyncAction:
+        self._token = _ACTION_CONTEXT.set(self)
+        _emit(self._start_record())
+        return self
+
+    def _exit(self, exc: BaseException | None) -> None:
+        if self._token:
+            _ACTION_CONTEXT.reset(self._token)
+        _emit(self._end_record(exc))
+
+    def _start_record(self) -> Record:
+        return Record(
+            timestamp=self._start,
+            level=self.level,
+            message="",
+            fields=self.fields,
+            context=current_scope(),
+            task_uuid=self.task_uuid,
+            task_level=self.task_level,
+            action_type=self.action_type,
+            action_status="started",
+        )
+
+    def _end_record(self, exc: BaseException | None) -> Record:
+        status = "failed" if exc else "succeeded"
+        fields = {**self.fields, "eliot:duration": round(now() - self._start, 6)}
+        if exc:
+            fields["exception"] = f"{type(exc).__module__}.{type(exc).__name__}"
+            fields["reason"] = str(exc)
+        return Record(
+            timestamp=now(),
+            level=self.level,
+            message="",
+            fields=fields,
+            context=current_scope(),
+            task_uuid=self.task_uuid,
+            task_level=(*self.task_level, self._child_count + 1),
+            action_type=self.action_type,
+            action_status=status,
+        )
+
+    # Dual context manager support (sync + async)
+    def __enter__(self) -> AsyncAction:
+        return self._enter()
+
+    def __exit__(self, *exc) -> None:
+        self._exit(exc[1])
+
+    async def __aenter__(self) -> AsyncAction:
+        return self._enter()
+
+    async def __aexit__(self, *exc) -> None:
+        self._exit(exc[1])
+
+
+@contextmanager
+def action(action_type: str, level: str | Level = Level.INFO, **fields: Any) -> Iterator[AsyncAction]:
+    """Create action context (sync) - compatible with eliot's nesting."""
+    if isinstance(level, str):
+        level = Level[level.upper()]
+    task_uuid, t_level = _get_parent_info()
+    act = AsyncAction(action_type, task_uuid, t_level, level=level, **fields)
+    with act:
+        yield act
+
+
+@asynccontextmanager
+async def aaction(action_type: str, level: str | Level = Level.INFO, **fields: Any) -> AsyncIterator[AsyncAction]:
+    """Create action context (async)."""
+    if isinstance(level, str):
+        level = Level[level.upper()]
+    task_uuid, t_level = _get_parent_info()
+    act = AsyncAction(action_type, task_uuid, t_level, level=level, **fields)
+    async with act:
+        yield act
+
+
+# === Scope (LoggerX feature - not in eliot) ===
+@contextmanager
+def scope(**ctx: Any) -> Iterator[dict[str, Any]]:
+    """Create nested scope context for field inheritance."""
+    current = _SCOPE.get()
+    merged = {**current, **ctx}
+    token = _SCOPE.set(merged)
+    try:
+        yield merged
+    finally:
+        _SCOPE.reset(token)
+
+
+# === Emit (connects to eliot's destination system) ===
+_emit_handlers: list[Callable[[Record], None]] = []
+
+
+def _emit(record: Record) -> None:
+    """Emit to eliot's destinations + any registered handlers."""
+    from ._output import Logger
+    from .loggerx import get_global_masker
+
+    data = record.to_dict()
+
+    # Apply masking if configured
+    masker = get_global_masker()
+    if masker:
+        data = masker.mask(data)
+
+    Logger._destinations.send(data)  # Uses eliot's system
+    for fn in _emit_handlers:
+        fn(record)
+
+
+def register_emitter(fn: Callable[[Record], None]) -> None:
+    _emit_handlers.append(fn)

logxpy/_base.py

@@ -0,0 +1,80 @@
+"""Shared utilities to reduce code duplication."""
+
+from __future__ import annotations
+
+import asyncio
+import inspect
+import sys
+import time
+from collections.abc import Callable
+from functools import wraps
+from typing import Any, ParamSpec, TypeVar
+from uuid import uuid4
+
+P = ParamSpec("P")
+T = TypeVar("T")
+
+# === Time utilities ===
+now = time.time
+monotonic = time.monotonic
+
+
+def uuid() -> str:
+    return str(uuid4())
+
+
+# === Async/sync wrapper factory ===
+def dual_wrapper(
+    async_impl: Callable[..., Any],
+    sync_impl: Callable[..., Any] | None = None,
+) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
+    """Create wrapper that works for both async and sync functions."""
+
+    def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
+        is_async = inspect.iscoroutinefunction(func)
+
+        @wraps(func)
+        async def async_wrapper(*args: Any, **kwargs: Any) -> Any:
+            return await async_impl(func, *args, **kwargs)
+
+        @wraps(func)
+        def sync_wrapper(*args: Any, **kwargs: Any) -> Any:
+            impl = sync_impl or (lambda f, *a, **k: asyncio.run(async_impl(f, *a, **k)))  # type: ignore
+            return impl(func, *args, **kwargs)
+
+        return async_wrapper if is_async else sync_wrapper
+
+    return decorator
+
+
+# === Value truncation ===
+def truncate(obj: Any, max_depth: int = 3, max_len: int = 500) -> Any:
+    """Truncate nested objects for logging."""
+    if max_depth <= 0:
+        return f"<{type(obj).__name__}>"
+    match obj:
+        case None | bool() | int() | float():
+            return obj
+        case str() if len(obj) > max_len:
+            return obj[:max_len] + "..."
+        case str():
+            return obj
+        case bytes():
+            return f"<bytes:{len(obj)}>"
+        case dict():
+            return {str(k)[:50]: truncate(v, max_depth - 1, max_len) for k, v in list(obj.items())[:50]}
+        case list() | tuple():
+            items = [truncate(x, max_depth - 1, max_len) for x in obj[:100]]
+            return items + [f"...+{len(obj) - 100}"] if len(obj) > 100 else items
+        case _ if hasattr(obj, "__dataclass_fields__"):
+            return {
+                "_type": type(obj).__name__,
+                **{f: truncate(getattr(obj, f), max_depth - 1, max_len) for f in obj.__dataclass_fields__},
+            }
+        case _:
+            return {"_type": type(obj).__name__, "_repr": repr(obj)[:max_len]}
+
+
+# === Module lazy import ===
+def get_module(name: str) -> Any | None:
+    return sys.modules.get(name)

logxpy/_compat.py

@@ -0,0 +1,71 @@
+"""Eliot backward compatibility - re-export ALL logxpy APIs with deprecation notices."""
+
+from warnings import warn
+
+from ._action import (
+    log_call as _log_call,
+)
+from ._action import (
+    log_message as _log_message,
+)
+from ._action import (
+    start_action,
+    startTask,
+)
+
+# === Re-export ALL logxpy public APIs (from eliot/__init__.py __all__) ===
+from ._output import (
+    Logger,
+)
+from ._traceback import write_traceback, writeFailure
+
+# === Backward compat aliases (same as eliot/__init__.py) ===
+startAction = start_action
+start_task = startTask
+write_failure = writeFailure
+writeTraceback = write_traceback
+add_destinations = Logger._destinations.add
+remove_destination = Logger._destinations.remove
+add_global_fields = Logger._destinations.addGlobalFields
+
+
+# Deprecated
+def add_destination(dest):
+    warn("Use add_destinations()", DeprecationWarning, stacklevel=2)
+    Logger._destinations.add(dest)
+
+
+addDestination = add_destination
+removeDestination = remove_destination
+addGlobalFields = add_global_fields
+
+
+def use_asyncio_context():
+    warn("No longer needed as of Eliot 1.8.0", DeprecationWarning, stacklevel=2)
+
+
+# === New LoggerX API ===
+
+
+# === Deprecation wrappers for common patterns ===
+def _deprecated(old: str, new: str):
+    def wrapper(fn):
+        def inner(*a, **kw):
+            warn(f"{old} is deprecated, use {new}", DeprecationWarning, stacklevel=2)
+            return fn(*a, **kw)
+
+        return inner
+
+    return wrapper
+
+
+# Wrap log_call to suggest @log.logged
+@_deprecated("log_call", "@log.logged")
+def log_call(*a, **kw):
+    return _log_call(*a, **kw)
+
+
+# Wrap log_message to suggest log.info()
+@_deprecated("log_message", "log.info()")
+def log_message(*a, **kw):
+    return _log_message(*a, **kw)

logxpy/_config.py

@@ -0,0 +1,45 @@
+"""Configuration loading."""
+from __future__ import annotations
+import os
+import tomllib
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from ._types import Level
+
+@dataclass
+class Config:
+    level: Level = Level.INFO
+    format: str = "rich"
+    destinations: list[str] = field(default_factory=lambda: ["console"])
+    mask_fields: list[str] = field(default_factory=lambda: ["password", "token", "secret"])
+    mask_patterns: list[str] = field(default_factory=list)
+    context: dict[str, Any] = field(default_factory=dict)
+    file_path: str | None = None
+    
+    @classmethod
+    def load(cls) -> 'Config':
+        cfg = cls()
+        # 1. pyproject.toml
+        pyproject = Path.cwd() / 'pyproject.toml'
+        if pyproject.exists():
+            data = tomllib.loads(pyproject.read_text()).get('tool', {}).get('loggerx', {})
+            if 'level' in data: cfg.level = Level[data['level'].upper()]
+            if 'format' in data: cfg.format = data['format']
+            if 'destinations' in data: cfg.destinations = data['destinations']
+            if m := data.get('mask'):
+                cfg.mask_fields = m.get('fields', cfg.mask_fields)
+                cfg.mask_patterns = m.get('patterns', cfg.mask_patterns)
+        # 2. Environment (overrides)
+        if v := os.environ.get('LOGGERX_LEVEL'): cfg.level = Level[v.upper()]
+        if v := os.environ.get('LOGGERX_FORMAT'): cfg.format = v
+        if v := os.environ.get('LOGGERX_DESTINATIONS'): cfg.destinations = v.split(',')
+        return cfg
+
+_cfg: Config | None = None
+
+def get_config() -> Config:
+    global _cfg
+    if _cfg is None: _cfg = Config.load()
+    return _cfg

logxpy/_dest.py

@@ -0,0 +1,88 @@
+"""Output destinations."""
+
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+from typing import Any
+
+from ._types import Record
+
+
+class ConsoleDestination:
+    def __init__(self, rich: bool = True):
+        self._rich = rich
+        if rich:
+            from rich.console import Console
+
+            self._console = Console()
+
+    async def write(self, record: Record) -> None:
+        lvl = record.level.name.ljust(8)
+        line = f"[{lvl}] {record.message} {record.fields}"
+        if self._rich:
+            color = {"ERROR": "red", "WARNING": "yellow", "SUCCESS": "green"}.get(record.level.name, "")
+            self._console.print(f"[{color}]{line}[/{color}]" if color else line)
+        else:
+            print(line)
+
+    async def flush(self) -> None:
+        pass
+
+    async def close(self) -> None:
+        pass
+
+
+class FileDestination:
+    def __init__(self, path: str | Path, buffer: int = 100):
+        self._path = Path(path)
+        self._buf: list[str] = []
+        self._size = buffer
+        self._lock = asyncio.Lock()
+
+    async def write(self, record: Record) -> None:
+        import orjson
+
+        line = orjson.dumps(record.to_dict()).decode() + "\n"
+        async with self._lock:
+            self._buf.append(line)
+            if len(self._buf) >= self._size:
+                await self.flush()
+
+    async def flush(self) -> None:
+        if not self._buf:
+            return
+        async with self._lock:
+            with self._path.open("a") as f:
+                f.writelines(self._buf)
+            self._buf.clear()
+
+    async def close(self) -> None:
+        await self.flush()
+
+
+class OTelDestination:
+    def __init__(self, endpoint: str = "localhost:4317"):
+        self._endpoint = endpoint
+        self._tracer: Any | None = None
+
+    async def write(self, record: Record) -> None:
+        if not self._tracer:
+            try:
+                from opentelemetry import trace
+                from opentelemetry.sdk.trace import TracerProvider
+
+                trace.set_tracer_provider(TracerProvider())
+                self._tracer = trace.get_tracer(__name__)
+            except ImportError:
+                return
+        if self._tracer and record.action_type:
+            with self._tracer.start_as_current_span(record.action_type) as span:
+                for k, v in record.fields.items():
+                    span.set_attribute(k, str(v))
+
+    async def flush(self) -> None:
+        pass
+
+    async def close(self) -> None:
+        pass

logxpy/_errors.py

@@ -0,0 +1,58 @@
+"""
+Error-handling utility code.
+"""
+
+from inspect import getmro
+
+
+class ErrorExtraction(object):
+    """
+    Extract fields from exceptions for failed-action messages.
+
+    @ivar registry: Map exception class to function that extracts fields.
+    """
+
+    def __init__(self):
+        self.registry = {}
+
+    def register_exception_extractor(self, exception_class, extractor):
+        """
+        Register a function that converts exceptions to fields.
+
+        @param exception_class: Class to register for.
+
+        @param extractor: Single-argument callable that takes an exception
+            of the given class (or a subclass) and returns a dictionary,
+            fields to include in a failed action message.
+        """
+        self.registry[exception_class] = extractor
+
+    def get_fields_for_exception(self, logger, exception):
+        """
+        Given an exception instance, return fields to add to the failed action
+        message.
+
+        @param logger: ``ILogger`` currently being used.
+        @param exception: An exception instance.
+
+        @return: Dictionary with fields to include.
+        """
+        for klass in getmro(exception.__class__):
+            if klass in self.registry:
+                extractor = self.registry[klass]
+                try:
+                    return extractor(exception)
+                except:
+                    from ._traceback import write_traceback
+
+                    write_traceback(logger)
+                    return {}
+        return {}
+
+
+_error_extraction = ErrorExtraction()
+register_exception_extractor = _error_extraction.register_exception_extractor
+get_fields_for_exception = _error_extraction.get_fields_for_exception
+
+# Default handler for OSError and IOError by registered EnvironmentError:
+register_exception_extractor(EnvironmentError, lambda e: {"errno": e.errno})

logxpy/_fmt.py

@@ -0,0 +1,68 @@
+"""Type-specific formatters."""
+
+from __future__ import annotations
+
+from typing import Any, Protocol
+
+from ._base import get_module, truncate
+
+
+class Formatter(Protocol):
+    def supports(self, obj: Any) -> bool: ...
+    def format(self, obj: Any, **opts: Any) -> dict[str, Any]: ...
+
+
+class DFFormatter:
+    def supports(self, obj: Any) -> bool:
+        pd = get_module("pandas")
+        return pd is not None and isinstance(obj, pd.DataFrame)
+
+    def format(self, obj: Any, max_rows: int = 5, **_: Any) -> dict[str, Any]:
+        return {
+            "_type": "DataFrame",
+            "shape": list(obj.shape),
+            "columns": list(obj.columns)[:20],
+            "dtypes": {str(k): str(v) for k, v in list(obj.dtypes.items())[:20]},
+            "head": obj.head(max_rows).to_dict(orient="records"),
+        }
+
+
+class TensorFormatter:
+    def supports(self, obj: Any) -> bool:
+        return hasattr(obj, "shape") and hasattr(obj, "dtype")
+
+    def format(self, obj: Any, **_: Any) -> dict[str, Any]:
+        r: dict[str, Any] = {
+            "_type": type(obj).__name__,
+            "shape": list(getattr(obj.shape, "__iter__", lambda: [obj.shape])()),
+            "dtype": str(obj.dtype),
+        }
+        try:
+            r.update({"min": float(obj.min()), "max": float(obj.max()), "mean": float(obj.mean())})
+            if hasattr(obj, "std"):
+                r["std"] = float(obj.std())
+            if hasattr(obj, "device"):
+                r["device"] = str(obj.device)
+        except:
+            pass
+        return r
+
+
+class ImageFormatter:
+    def supports(self, obj: Any) -> bool:
+        PIL = get_module("PIL")
+        return PIL is not None and hasattr(PIL, "Image") and isinstance(obj, PIL.Image.Image)
+
+    def format(self, obj: Any, max_size: tuple[int, int] = (256, 256), **_: Any) -> dict[str, Any]:
+        return {"_type": "Image", "size": list(obj.size), "mode": obj.mode}
+
+
+# Combined formatter
+_FMT: list[Formatter] = [DFFormatter(), TensorFormatter(), ImageFormatter()]
+
+
+def format_value(obj: Any, **opts: Any) -> Any:
+    for f in _FMT:
+        if f.supports(obj):
+            return f.format(obj, **opts)
+    return truncate(obj, opts.get("max_depth", 3), opts.get("max_len", 500))