without-logging 0.0.1__tar.gz → 0.0.2__tar.gz

{without_logging-0.0.1 → without_logging-0.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: without-logging
-Version: 0.0.1
+Version: 0.0.2
 Summary: A without pipeline for logs: stdlib log records parsed into immutable values, filtered and enriched as processors, drained to a sink.
 Author: Josh Karpel
 Author-email: Josh Karpel <josh.karpel@gmail.com>
@@ -15,7 +15,7 @@ Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development :: Libraries
 Classifier: Topic :: System :: Logging
 Classifier: Typing :: Typed
-Requires-Dist: without-core==0.0.1
+Requires-Dist: without-core==0.0.2
 Requires-Python: >=3.14
 Description-Content-Type: text/markdown
 
@@ -77,7 +77,7 @@ async with offload(writer) as sink:
 ```
 
 See the
-[`without-logging` guide](https://without.help/guides/without-logging/)
+[`without-logging` guide](https://without.help/without-logging/)
 (with the [API reference](https://without.help/reference/without_logging/))
 for the design narrative: why stdlib becomes a one-way source, why filtering is
 just the core `from_selector` builder, and where fan-out to multiple sinks slots

{without_logging-0.0.1 → without_logging-0.0.2}/README.md

@@ -56,7 +56,7 @@ async with offload(writer) as sink:
 ```
 
 See the
-[`without-logging` guide](https://without.help/guides/without-logging/)
+[`without-logging` guide](https://without.help/without-logging/)
 (with the [API reference](https://without.help/reference/without_logging/))
 for the design narrative: why stdlib becomes a one-way source, why filtering is
 just the core `from_selector` builder, and where fan-out to multiple sinks slots

without_logging-0.0.2/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["uv_build>=0.11.32,<0.12"]
+build-backend = "uv_build"
+
+[project]
+name = "without-logging"
+version = "0.0.2"
+description = "A without pipeline for logs: stdlib log records parsed into immutable values, filtered and enriched as processors, drained to a sink."
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.14"
+classifiers = [
+    "Development Status :: 2 - Pre-Alpha",
+    "Framework :: AsyncIO",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Software Development :: Libraries",
+    "Topic :: System :: Logging",
+    "Typing :: Typed",
+]
+dependencies = ["without-core==0.0.2"]
+
+[[project.authors]]
+name = "Josh Karpel"
+email = "josh.karpel@gmail.com"
+
+[tool.uv.sources.without-core]
+workspace = true

without_logging-0.0.1/pyproject.toml → without_logging-0.0.2/pyproject.toml.orig

@@ -1,10 +1,10 @@
 [build-system]
-requires = ["uv_build>=0.11.25,<0.12"]
+requires = ["uv_build>=0.11.32,<0.12"]
 build-backend = "uv_build"
 
 [project]
 name = "without-logging"
-version = "0.0.1"
+version = "0.0.2"
 description = "A without pipeline for logs: stdlib log records parsed into immutable values, filtered and enriched as processors, drained to a sink."
 readme = "README.md"
 license = "MIT"
@@ -25,7 +25,7 @@ classifiers = [
     "Typing :: Typed",
 ]
 dependencies = [
-    "without-core==0.0.1",
+    "without-core==0.0.2",
 ]
 
 [tool.uv.sources]

{without_logging-0.0.1 → without_logging-0.0.2}/src/without_logging/capture.py

@@ -2,11 +2,12 @@ from __future__ import annotations
 
 import asyncio
 import logging
+import threading
 from collections.abc import AsyncIterator
 from collections.abc import Callable
 from contextlib import asynccontextmanager
 
-from without.contracts import Sink
+from without.interfaces import Sink
 from without.wiring import stream_from_queue
 
 from without_logging.context import merge_context
@@ -31,7 +32,11 @@ class CaptureHandler(logging.Handler):
     Control only ever flows outward from stdlib into `without`, never back.
 
     A log call MAY happen off the event loop thread, so the parsed value is handed
-    to the loop with `call_soon_threadsafe`. The queue is bounded, so a burst that
+    to the loop with `call_soon_threadsafe`, which writes the loop's self-pipe to
+    wake it. A log call *on* the loop thread (an async handler logging) does not
+    need that wakeup, so those take the cheaper `call_soon`; the construction thread
+    is the loop thread (`capture` builds this right after `get_running_loop`), so its
+    id captured here identifies loop-thread emits. The queue is bounded, so a burst that
     outruns the sink is dropped rather than growing memory without limit;
     `dropped` counts how many so an operator can see it. The overflow policy is a
     boundary decision the app owns: raise `capacity`, or pass `capacity=None` for
@@ -46,13 +51,17 @@ class CaptureHandler(logging.Handler):
     ) -> None:
         super().__init__()
         self._loop = loop
+        self._loop_thread_id = threading.get_ident()
         self._queue = queue
         self._parse = parse
         self.dropped = 0
 
     def emit(self, log_record: logging.LogRecord) -> None:
         record = self._parse(log_record)
-        self._loop.call_soon_threadsafe(self._offer, record)
+        if threading.get_ident() == self._loop_thread_id:
+            self._loop.call_soon(self._offer, record)
+        else:
+            self._loop.call_soon_threadsafe(self._offer, record)
 
     def _offer(self, record: Record) -> None:
         try:

{without_logging-0.0.1 → without_logging-0.0.2}/src/without_logging/processors.py

@@ -3,8 +3,8 @@ from __future__ import annotations
 from collections.abc import Awaitable
 from collections.abc import Callable
 
-from without.contracts import Processor
-from without.contracts import from_map
+from without.interfaces import Processor
+from without.interfaces import from_map
 
 from without_logging.record import Record
 

{without_logging-0.0.1 → without_logging-0.0.2}/src/without_logging/record.py

@@ -39,7 +39,7 @@ class Level(IntEnum):
 # that is deliberately dropped: it is gated by module flags (`logThreads`,
 # `logProcesses`, `logAsyncioTasks`) and a swappable factory, so it may be `None` or
 # absent, and it exists for stdlib's formatter `%(...)s` placeholders rather than as
-# a stable per-event contract. A caller who wants some of it lifts it into `fields`
+# a stable per-event guarantee. A caller who wants some of it lifts it into `fields`
 # with a custom `parse=` on `capture`.
 RESERVED: frozenset[str] = frozenset(
     {

{without_logging-0.0.1 → without_logging-0.0.2}/src/without_logging/renderers.py

@@ -5,8 +5,8 @@ from collections.abc import Callable
 from datetime import datetime
 from traceback import TracebackException
 
-from without.contracts import Processor
-from without.contracts import from_map
+from without.interfaces import Processor
+from without.interfaces import from_map
 
 from without_logging.record import Record
 
@@ -111,21 +111,25 @@ def render_console(
     `TIMESTAMP LEVEL logger "message" {key=value, ...}`: the message is quoted and
     the fields grouped in braces (each value `repr`'d), so the free-text message and
     the structured fields never blur into each other or the leading metadata. The
-    braces are omitted when there are no fields. An exception is appended as its full
-    traceback text (`exception_to_text`, cause chain and all), indented, on following
-    lines. `timestamp` chooses the time format (default `iso_timestamp`). No coloring:
-    wrap the line, or write your own `from_map(Record -> str)`, if you want ANSI.
+    message is quoted with `json.dumps` and each field value is `repr`'d, so a control
+    character in either (a newline from a decoded request path, say) is escaped rather
+    than forging a new log line. The braces are omitted when there are no
+    fields. An exception is appended as its full traceback text (`exception_to_text`,
+    cause chain and all), indented, on following lines. `timestamp` chooses the time
+    format (default `iso_timestamp`). No coloring: wrap the line, or write your own
+    `from_map(Record -> str)`, if you want ANSI.
 
     Optional and opt-in, like `render_json`: `compose(render_console(),
     offload(to_stream(sys.stderr)))`.
     """
 
     async def render(record: Record) -> str:
+        quoted = json.dumps(record.message, ensure_ascii=False)  # pragma: no mutate - None acts as False here
         parts = [
             timestamp(record.timestamp),
             record.level_name,
             record.logger,
-            f'"{record.message}"',
+            quoted,
         ]
         if record.fields:
             fields = ", ".join(f"{key}={value!r}" for key, value in record.fields.items())

{without_logging-0.0.1 → without_logging-0.0.2}/src/without_logging/sinks.py

@@ -15,8 +15,8 @@ from datetime import tzinfo
 from pathlib import Path
 from typing import TextIO
 
-from without.contracts import Sink
-from without.contracts import Stream
+from without.interfaces import Sink
+from without.interfaces import Stream
 
 
 @asynccontextmanager