yapl-kit 0.2.0__tar.gz → 0.2.1__tar.gz

{yapl_kit-0.2.0 → yapl_kit-0.2.1}/PKG-INFO

@@ -1,15 +1,10 @@
 Metadata-Version: 2.3
 Name: yapl-kit
-Version: 0.2.0
+Version: 0.2.1
 Summary: YetAnotherPythonLogger - a minimal, extensible logging toolkit built on top of Python's standard logging module.
 Author: SirKaiMartin
-Requires-Dist: httpx>=0.28.1 ; extra == 'webhook'
+Requires-Dist: httpx>=0.28.1
 Requires-Python: >=3.13
-Provides-Extra: buffering
-Provides-Extra: coloring
-Provides-Extra: formatting
-Provides-Extra: queueing
-Provides-Extra: webhook
 Description-Content-Type: text/markdown
 
 # YAPL Kit
@@ -18,9 +13,10 @@ Description-Content-Type: text/markdown
 
 > A modern, minimal, and extensible logging toolkit built on top of Python's standard `logging` module.
 
-YAPL keeps the stdlib logging ecosystem intact while adding structured logging, queue-backed delivery, formatting, coloring, buffering, stack helpers, and optional webhook support.
+YAPL keeps the stdlib logging ecosystem intact while adding structured logging, queue-backed delivery, formatting, coloring, buffering, stack helpers, and webhook support.
 
-The core stays dependency-free. Optional integrations are installed only when you need them.
+All YAPL feature families ship in the single `yapl-kit` distribution. Webhook
+support uses `httpx`, which is installed automatically.
 
 ## Installation
 
@@ -38,18 +34,6 @@ With `pip`:
 pip install yapl-kit
 ```
 
-Install all optional features:
-
-```bash
-uv add "yapl-kit[formatting,coloring,buffering,queueing,webhook]"
-```
-
-or:
-
-```bash
-pip install "yapl-kit[formatting,coloring,buffering,queueing,webhook]"
-```
-
 The canonical import namespace is `yapl`:
 
 ```python
@@ -119,7 +103,7 @@ YAPL does not replace Python logging. It builds on stdlib handlers, formatters,
 
 The main design goals are:
 
-- keep the core small and dependency-free
+- keep the distribution small and focused
 - preserve compatibility with Python's logging ecosystem
 - keep expensive formatting and I/O off the application hot path
 - make queueing, retries, and shutdown behavior bounded
@@ -225,13 +209,7 @@ Queue capacity limits the number of retained records, not their total byte size.
 
 ## Webhooks
 
-Webhook delivery is optional and uses `httpx`.
-
-Install it with:
-
-```bash
-uv add "yapl-kit[webhook]"
-```
+Webhook delivery uses `httpx`, included automatically with `yapl-kit`.
 
 Configure a webhook:
 
@@ -339,9 +317,9 @@ Python cannot safely terminate arbitrary user handler code. Keep custom handlers
 
 `queue_enabled=False` runs normal stdlib handlers directly, so file, console, or custom sink work may occur on the caller thread.
 
-## Optional Modules
+## Extension Modules
 
-YAPL keeps concrete optional features under explicit modules:
+YAPL keeps feature families under explicit modules within the main distribution:
 
 ```python
 from yapl.stack import FunctionCallTracer, get_callsite
@@ -352,7 +330,7 @@ from yapl.extensions.queueing import QueueingConfig
 from yapl.extensions.webhook import WebhookConfig
 ```
 
-The `yapl.extensions` package is a namespace; concrete features live in its submodules.
+The `yapl.extensions` package contains the concrete feature implementations.
 
 ## Package Philosophy
 

{yapl_kit-0.2.0 → yapl_kit-0.2.1}/PUBLIC.md

@@ -4,9 +4,10 @@
 
 > A modern, minimal, and extensible logging toolkit built on top of Python's standard `logging` module.
 
-YAPL keeps the stdlib logging ecosystem intact while adding structured logging, queue-backed delivery, formatting, coloring, buffering, stack helpers, and optional webhook support.
+YAPL keeps the stdlib logging ecosystem intact while adding structured logging, queue-backed delivery, formatting, coloring, buffering, stack helpers, and webhook support.
 
-The core stays dependency-free. Optional integrations are installed only when you need them.
+All YAPL feature families ship in the single `yapl-kit` distribution. Webhook
+support uses `httpx`, which is installed automatically.
 
 ## Installation
 
@@ -24,18 +25,6 @@ With `pip`:
 pip install yapl-kit
 ```
 
-Install all optional features:
-
-```bash
-uv add "yapl-kit[formatting,coloring,buffering,queueing,webhook]"
-```
-
-or:
-
-```bash
-pip install "yapl-kit[formatting,coloring,buffering,queueing,webhook]"
-```
-
 The canonical import namespace is `yapl`:
 
 ```python
@@ -105,7 +94,7 @@ YAPL does not replace Python logging. It builds on stdlib handlers, formatters,
 
 The main design goals are:
 
-- keep the core small and dependency-free
+- keep the distribution small and focused
 - preserve compatibility with Python's logging ecosystem
 - keep expensive formatting and I/O off the application hot path
 - make queueing, retries, and shutdown behavior bounded
@@ -211,13 +200,7 @@ Queue capacity limits the number of retained records, not their total byte size.
 
 ## Webhooks
 
-Webhook delivery is optional and uses `httpx`.
-
-Install it with:
-
-```bash
-uv add "yapl-kit[webhook]"
-```
+Webhook delivery uses `httpx`, included automatically with `yapl-kit`.
 
 Configure a webhook:
 
@@ -325,9 +308,9 @@ Python cannot safely terminate arbitrary user handler code. Keep custom handlers
 
 `queue_enabled=False` runs normal stdlib handlers directly, so file, console, or custom sink work may occur on the caller thread.
 
-## Optional Modules
+## Extension Modules
 
-YAPL keeps concrete optional features under explicit modules:
+YAPL keeps feature families under explicit modules within the main distribution:
 
 ```python
 from yapl.stack import FunctionCallTracer, get_callsite
@@ -338,7 +321,7 @@ from yapl.extensions.queueing import QueueingConfig
 from yapl.extensions.webhook import WebhookConfig
 ```
 
-The `yapl.extensions` package is a namespace; concrete features live in its submodules.
+The `yapl.extensions` package contains the concrete feature implementations.
 
 ## Package Philosophy
 

{yapl_kit-0.2.0 → yapl_kit-0.2.1}/pyproject.toml

@@ -1,21 +1,14 @@
 [project]
 name = "yapl-kit"
-version = "0.2.0"
+version = "0.2.1"
 description = "YetAnotherPythonLogger - a minimal, extensible logging toolkit built on top of Python's standard logging module."
 readme = "PUBLIC.md"
 requires-python = ">=3.13"
-dependencies = []
+dependencies = ["httpx>=0.28.1"]
 
 [[project.authors]]
 name = "SirKaiMartin"
 
-[project.optional-dependencies]
-formatting = []
-coloring = []
-buffering = []
-queueing = []
-webhook = ["httpx>=0.28.1"]
-
 [build-system]
 requires = ["uv_build>=0.12.16,<0.13.0"]
 build-backend = "uv_build"
@@ -71,6 +64,9 @@ section-order = [
     "local-folder",
 ]
 
+[tool.ty.src]
+include = ["src"]
+
 [dependency-groups]
 dev = [
     "pytest>=9.1.1",

{yapl_kit-0.2.0 → yapl_kit-0.2.1}/pyproject.toml.orig

@@ -1,13 +1,15 @@
 [project]
 name = "yapl-kit"
-version = "0.2.0"
+version = "0.2.1"
 description = "YetAnotherPythonLogger - a minimal, extensible logging toolkit built on top of Python's standard logging module."
 readme = "PUBLIC.md"
 authors = [
     { name = "SirKaiMartin" }
 ]
 requires-python = ">=3.13"
-dependencies = []
+dependencies = [
+    "httpx>=0.28.1",
+]
 
 [build-system]
 requires = ["uv_build>=0.12.16,<0.13.0"]
@@ -30,15 +32,6 @@ markers = [
     "performance: caller-latency, throughput, and backpressure regression coverage",
 ]
 
-[project.optional-dependencies]
-formatting = []
-coloring = []
-buffering = []
-queueing = []
-webhook = [
-    "httpx>=0.28.1",
-]
-
 [tool.ruff]
 target-version = "py313"
 line-length = 100
@@ -78,3 +71,6 @@ section-order = [
     "first-party",
     "local-folder",
 ]
+
+[tool.ty.src]
+include = ["src"]

{yapl_kit-0.2.0 → yapl_kit-0.2.1}/src/yapl/config.py

@@ -18,6 +18,7 @@ from .types import (
 
 if TYPE_CHECKING:
     from .extensions.formatting.processors import LogEventProcessor
+    from .extensions.queueing.models import QueueErrorCallback
     from .extensions.webhook.models import WebhookConfig
 
 
@@ -216,6 +217,7 @@ class YaplConfig:
         file_path: File used by shorthand ``"file"`` output.
         overrides: Per-logger level overrides.
         suppression: Rules applied to configured handlers.
+        queue_error_callback: Optional callback for isolated target-handler failures.
     """
 
     level: int = 20
@@ -236,6 +238,7 @@ class YaplConfig:
     overrides: LoggerOverrides = field(default_factory=LoggerOverrides)
     suppression: SuppressionRules = field(default_factory=SuppressionRules)
     shutdown_timeout_seconds: float = 5.0
+    queue_error_callback: QueueErrorCallback | None = None
 
     def with_level(self, level: LevelLike) -> YaplConfig:
         """Set the root level and return this configuration.

{yapl_kit-0.2.0 → yapl_kit-0.2.1}/src/yapl/extensions/buffering/capture.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import asyncio
 from contextvars import ContextVar, Token
 from copy import copy
 import logging
@@ -18,6 +19,23 @@ _capture_enabled: ContextVar[bool] = ContextVar(
 )
 
 
+def current_buffer_owner() -> object | None:
+    """Return the current async task, or ``None`` outside an event loop."""
+    try:
+        return asyncio.current_task()
+    except RuntimeError:
+        return None
+
+
+def owns_buffer_state(state: BufferingState) -> bool:
+    """Return whether ``state`` belongs to this synchronous context or task.
+
+    Context variables already isolate ordinary threads. Only task-owned states
+    need an asyncio lookup because child tasks inherit their parent's context.
+    """
+    return state.owner_task is None or state.owner_task is current_buffer_owner()
+
+
 def get_active_buffer_state() -> BufferingState | None:
     return _active_buffer_state.get()
 
@@ -54,7 +72,7 @@ class BufferCaptureFilter(logging.Filter):
             return True
 
         state = get_active_buffer_state()
-        if state is None:
+        if state is None or not owns_buffer_state(state):
             return True
 
         buffered_record = copy(record)

{yapl_kit-0.2.0 → yapl_kit-0.2.1}/src/yapl/extensions/buffering/context.py

@@ -7,8 +7,10 @@ from typing import Self
 
 from .capture import (
     BufferCaptureFilter,
+    current_buffer_owner,
     get_active_buffer_state,
     is_capture_enabled,
+    owns_buffer_state,
     reset_active_buffer_state,
     reset_capture_enabled,
     set_active_buffer_state,
@@ -87,8 +89,13 @@ class BufferedLogs:
 
     def _enter(self) -> Self:
         self._previous_state = get_active_buffer_state()
+        owner_task = current_buffer_owner()
 
-        if self._previous_state is not None and self._cfg.include_nested_contexts:
+        if (
+            self._previous_state is not None
+            and self._cfg.include_nested_contexts
+            and self._previous_state.owner_task is owner_task
+        ):
             self._state = self._previous_state
             self._store = self._state.store
             self._cfg = self._state.config
@@ -96,6 +103,11 @@ class BufferedLogs:
             self._owns_state = False
             return self
 
+        self._state = BufferingState(
+            store=self._store,
+            config=self._cfg,
+            owner_task=owner_task,
+        )
         self._token = set_active_buffer_state(self._state)
         self._owns_state = True
         return self
@@ -134,7 +146,8 @@ class BufferingFilter(logging.Filter):
 
     def filter(self, record: logging.LogRecord) -> bool:
         """Allow records only when capture is inactive for this context."""
-        return (not is_capture_enabled()) or get_active_buffer_state() is None
+        state = get_active_buffer_state()
+        return (not is_capture_enabled()) or state is None or not owns_buffer_state(state)
 
 
 def install_buffering(*, stream_handlers_only: bool = False) -> int:

{yapl_kit-0.2.0 → yapl_kit-0.2.1}/src/yapl/extensions/buffering/models.py

@@ -63,3 +63,4 @@ class BufferingState:
 
     store: BufferedLogStore
     config: BufferingConfig
+    owner_task: object | None = field(default=None, repr=False, compare=False)

{yapl_kit-0.2.0 → yapl_kit-0.2.1}/src/yapl/extensions/coloring/models.py

@@ -10,7 +10,7 @@ LEVEL_COLOR_TOKEN = "level_color"
 
 
 def _resolve_dict_color(value: Mapping[str, str]) -> dict[str, str]:
-    return {key: resolve_color(color) for key, color in value.items()}
+    return {key.upper(): resolve_color(color) for key, color in value.items()}
 
 
 def _resolve_style_color(value: str) -> str:

{yapl_kit-0.2.0 → yapl_kit-0.2.1}/src/yapl/extensions/coloring/plain.py

@@ -29,6 +29,7 @@ class ColorPlainFormatter(logging.Formatter):
 
         message = record.getMessage()
         level_name = record.levelname
+        level_color = theme.color_for_level(level_name)
 
         parts: list[str] = []
 
@@ -43,7 +44,7 @@ class ColorPlainFormatter(logging.Formatter):
             parts.append(self._color_field("logger", record.name, theme))
 
         if self._config.include_message:
-            parts.append(self._color_field("message", message, theme))
+            parts.append(self._color_field("message", message, theme, level_color=level_color))
 
         rendered = self._config.separator.join(parts)
 
@@ -83,9 +84,19 @@ class ColorPlainFormatter(logging.Formatter):
             return text
         return f"{color}{text}{reset}"
 
-    def _color_field(self, field_name: str, value: Any, theme: Any) -> str:
+    def _color_field(
+        self,
+        field_name: str,
+        value: Any,
+        theme: Any,
+        *,
+        level_color: str | None = None,
+    ) -> str:
         style = theme.style_for_field(field_name)
-        return self._wrap(str(value), style.value_color, theme.reset)
+        color = style.value_color
+        if color == "level_color":
+            color = level_color or ""
+        return self._wrap(str(value), color, theme.reset)
 
     def _color_level(self, level_name: str, theme: Any) -> str:
         style = theme.style_for_field("level")

{yapl_kit-0.2.0 → yapl_kit-0.2.1}/src/yapl/extensions/formatting/processors.py

@@ -302,8 +302,13 @@ class ParseMessageFields:
         if not isinstance(message, str) or "=" not in message:
             return event
 
+        try:
+            tokens = shlex.split(message)
+        except ValueError:
+            return event
+
         parsed: dict[str, Any] = {}
-        for token in shlex.split(message):
+        for token in tokens:
             if "=" not in token:
                 continue
             key, value = token.split("=", 1)

{yapl_kit-0.2.0 → yapl_kit-0.2.1}/src/yapl/extensions/queueing/__init__.py

@@ -3,6 +3,7 @@ from .models import (
     QueueBatch,
     QueueDiagnostics,
     QueuedLogItem,
+    QueueErrorCallback,
     QueueingConfig,
     QueueOverflowPolicy,
 )
@@ -14,6 +15,7 @@ __all__ = [
     "LogQueue",
     "QueueBatch",
     "QueueDiagnostics",
+    "QueueErrorCallback",
     "QueueOverflowPolicy",
     "QueueWorker",
     "QueuedLogItem",

{yapl_kit-0.2.0 → yapl_kit-0.2.1}/src/yapl/extensions/queueing/handler.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import contextlib
+from dataclasses import dataclass
 import logging
 from logging.handlers import QueueHandler
 from queue import Empty, Full, Queue
@@ -11,6 +12,12 @@ from .models import QueueDiagnostics, QueueingConfig
 from .policy import should_fallback_to_file
 
 
+@dataclass(slots=True)
+class _TargetFlushState:
+    completed: threading.Event
+    failed: bool = False
+
+
 class QueueingHandler(QueueHandler):
     """Move handler work off the logging thread with bounded shutdown waits.
 
@@ -35,6 +42,7 @@ class QueueingHandler(QueueHandler):
         self._cfg = config or QueueingConfig()
         self._diagnostics = QueueDiagnostics()
         self._target_handlers = tuple(handler for handler in target_handlers if handler is not self)
+        self._target_labels = self._build_target_labels()
         self._queue: Queue[logging.LogRecord] = Queue(maxsize=self._cfg.max_queue_size)
         super().__init__(self._queue)
         self._fallback_handler = self._find_fallback_handler()
@@ -48,12 +56,14 @@ class QueueingHandler(QueueHandler):
         self._accepting = True
         self._stop_event = threading.Event()
         self._state_lock = threading.Lock()
+        self._target_flush_lock = threading.Lock()
+        self._target_flush_states: dict[int, _TargetFlushState] = {}
         self._active_blocking_enqueues = 0
         self._targets_closed = False
         self._workers_remaining = 1 + (self._fallback_queue is not None)
         self._worker = threading.Thread(
             target=self._run,
-            args=(self._queue, self._target_handlers),
+            args=(self._queue, self._target_handlers, self._target_labels),
             name=self._cfg.worker_name,
             daemon=True,
         )
@@ -62,7 +72,11 @@ class QueueingHandler(QueueHandler):
         if self._fallback_queue is not None and self._fallback_handler is not None:
             self._fallback_worker = threading.Thread(
                 target=self._run,
-                args=(self._fallback_queue, (self._fallback_handler,)),
+                args=(
+                    self._fallback_queue,
+                    (self._fallback_handler,),
+                    (self._target_labels[self._target_handlers.index(self._fallback_handler)],),
+                ),
                 name=f"{self._cfg.worker_name}-fallback",
                 daemon=True,
             )
@@ -90,7 +104,7 @@ class QueueingHandler(QueueHandler):
             self._fallback_worker is not None and self._fallback_worker.is_alive()
         )
 
-    def diagnostics_snapshot(self) -> dict[str, int]:
+    def diagnostics_snapshot(self) -> dict[str, object]:
         """Return queue counters and the current combined queued-record count."""
         queue_size = self._queue.qsize()
         if self._fallback_queue is not None:
@@ -125,6 +139,8 @@ class QueueingHandler(QueueHandler):
         try:
             with self._state_lock:
                 if not self._accepting:
+                    self._diagnostics.dropped += 1
+                    self._diagnostics.dropped_shutdown += 1
                     return
                 self._queue.put_nowait(record)
         except Full:
@@ -136,6 +152,8 @@ class QueueingHandler(QueueHandler):
     def _enqueue_blocking(self, record: logging.LogRecord) -> None:
         with self._state_lock:
             if not self._accepting:
+                self._diagnostics.dropped += 1
+                self._diagnostics.dropped_shutdown += 1
                 return
             self._active_blocking_enqueues += 1
 
@@ -180,7 +198,9 @@ class QueueingHandler(QueueHandler):
                     if timed_flush(remaining) is False:
                         drained = False
                 else:
-                    handler.flush()
+                    remaining = max(0.0, deadline - time.monotonic())
+                    if not self._flush_target_with_timeout(handler, remaining):
+                        drained = False
             except Exception:
                 drained = False
         if drained:
@@ -227,6 +247,7 @@ class QueueingHandler(QueueHandler):
         self,
         queue: Queue[logging.LogRecord],
         handlers: tuple[logging.Handler, ...],
+        labels: tuple[str, ...],
     ) -> None:
         try:
             while True:
@@ -242,7 +263,7 @@ class QueueingHandler(QueueHandler):
                         self._diagnostics.dropped += 1
                         self._diagnostics.dropped_shutdown += 1
                     else:
-                        self._dispatch(record, handlers)
+                        self._dispatch(record, handlers, labels)
                 finally:
                     queue.task_done()
         finally:
@@ -258,16 +279,34 @@ class QueueingHandler(QueueHandler):
             # until it resolves so a late record is discarded instead of stranded.
             return self._active_blocking_enqueues == 0
 
-    def _dispatch(self, record: logging.LogRecord, handlers: tuple[logging.Handler, ...]) -> None:
-        for handler in handlers:
+    def _dispatch(
+        self,
+        record: logging.LogRecord,
+        handlers: tuple[logging.Handler, ...],
+        labels: tuple[str, ...],
+    ) -> None:
+        for handler, label in zip(handlers, labels, strict=True):
             if self._cfg.respect_handler_level and record.levelno < handler.level:
                 continue
             try:
                 handler.handle(record)
-            except Exception:
+            except Exception as error:
+                self._diagnostics.record_handler_failure(label)
+                if self._cfg.error_callback is not None:
+                    with contextlib.suppress(Exception):
+                        self._cfg.error_callback(handler, record, error)
                 # Isolate one target failure so it cannot stop shared delivery.
                 continue
 
+    def _build_target_labels(self) -> tuple[str, ...]:
+        counts: dict[str, int] = {}
+        labels: list[str] = []
+        for handler in self._target_handlers:
+            name = handler.get_name() or type(handler).__name__
+            counts[name] = counts.get(name, 0) + 1
+            labels.append(name if counts[name] == 1 else f"{name}#{counts[name]}")
+        return tuple(labels)
+
     def _close_targets_if_finished(self) -> None:
         with self._state_lock:
             if self._workers_remaining or self._targets_closed:
@@ -275,7 +314,7 @@ class QueueingHandler(QueueHandler):
             self._targets_closed = True
         for handler in self._target_handlers:
             with contextlib.suppress(Exception):
-                handler.flush()
+                self._flush_target_with_timeout(handler, None)
             with contextlib.suppress(Exception):
                 handler.close()
 
@@ -302,6 +341,46 @@ class QueueingHandler(QueueHandler):
             None,
         )
 
+    def _flush_target_with_timeout(
+        self,
+        handler: logging.Handler,
+        timeout_seconds: float | None,
+    ) -> bool:
+        """Flush one target with one reusable in-flight timeout operation."""
+        handler_key = id(handler)
+        with self._target_flush_lock:
+            state = self._target_flush_states.get(handler_key)
+            if state is None:
+                state = _TargetFlushState(completed=threading.Event())
+                self._target_flush_states[handler_key] = state
+                threading.Thread(
+                    target=self._run_target_flush,
+                    args=(handler, state),
+                    name="yapl-queue-target-flush",
+                    daemon=True,
+                ).start()
+
+        if not state.completed.wait(timeout_seconds):
+            return False
+
+        return not state.failed
+
+    def _run_target_flush(
+        self,
+        handler: logging.Handler,
+        state: _TargetFlushState,
+    ) -> None:
+        try:
+            handler.flush()
+        except Exception:
+            state.failed = True
+        finally:
+            state.completed.set()
+            with self._target_flush_lock:
+                handler_key = id(handler)
+                if self._target_flush_states.get(handler_key) is state:
+                    del self._target_flush_states[handler_key]
+
 
 def enable_queueing(
     config: QueueingConfig | None = None,