log-foundry 0.10.2.dev8__tar.gz → 0.10.2.dev10__tar.gz

{log_foundry-0.10.2.dev8 → log_foundry-0.10.2.dev10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: log-foundry
-Version: 0.10.2.dev8
+Version: 0.10.2.dev10
 Summary: Generate logs for your console and JSON events for downstream consumption.
 License-Expression: MIT
 License-File: LICENSE

{log_foundry-0.10.2.dev8 → log_foundry-0.10.2.dev10}/pyproject.toml

@@ -20,7 +20,7 @@ dependencies = [
 ]
 
 # Optional features. Install with: pip install log-foundry[aws]
-version = "0.10.2.dev8"
+version = "0.10.2.dev10"
 
 [project.optional-dependencies]
 aws = ["boto3>=1.43.61"]              # SQSSink, SNSSink, KinesisSink, FirehoseSink

{log_foundry-0.10.2.dev8 → log_foundry-0.10.2.dev10}/src/log_foundry/_diag.py

@@ -19,6 +19,12 @@ Two rules, both load-bearing:
   as everywhere else in this library: a ``KeyboardInterrupt`` landing mid-write is the operator's
   intent, not a stream fault to swallow.
 
+**This module must import nothing from its own package.** ``decorator``, ``api`` and ``worker``
+all reach it with ``from log_foundry import _diag`` at module scope, which executes while the
+package is still partially initialised and resolves only because ``_diag`` is a leaf — it needs
+``sys`` and nothing else. Give it an intra-package import and every module that is imported
+*first* in a fresh interpreter starts failing.
+
 SPEC-029 takes ownership of this module and moves the ``repr(exception)`` sink sites onto it.
 """
 

{log_foundry-0.10.2.dev8 → log_foundry-0.10.2.dev10}/src/log_foundry/api.py

@@ -12,7 +12,7 @@ the sink via the normal path.
 
 from __future__ import annotations
 
-from log_foundry import context
+from log_foundry import _diag, context
 from log_foundry.config import _ensure_sink
 from log_foundry.console import ConsoleWriter
 from log_foundry.context import set_baggage
@@ -40,9 +40,16 @@ def _log(level: str, message: str, echo: bool, fields: dict[str, object]) -> Non
     With no active span (orphan) it becomes a standalone one-event span — fresh ``trace_id``,
     ``parent_span_id=None`` — flushed directly so nothing is dropped (FR-004). ``echo`` writes
     the same event as a human-readable console line, additively.
+
+    The orphan branch is the one that reaches the sink **on the caller's own thread**, with no
+    worker between them to absorb a failure, so it is guarded end to end (SPEC-025 FR-003): a
+    bare ``log_foundry.info(...)`` must not hand the application a ``ConnectionError`` from a
+    destination the application never chose to talk to. The in-span branch is deliberately left
+    untouched — it only appends to a list, and FR-003 requires no behaviour change there.
     """
     baggage = context.get_baggage()
     span = context.current_span()
+    event: dict[str, object] | None = None
     if span is not None:
         event = build_event(span, level, message, fields=fields, baggage=baggage)
         span.events.append(event)
@@ -51,17 +58,29 @@ def _log(level: str, message: str, echo: bool, fields: dict[str, object]) -> Non
         # log is recorded, not silently dropped. Resolve the sink via _ensure_sink (as the
         # decorator does) so a zero-config orphan log falls back to StdoutSink instead of
         # crashing. SPEC-004's worker will later own this direct handoff.
-        orphan = Span(
-            trace_id=new_trace_id(),
-            span_id=new_span_id(),
-            parent_span_id=None,
-            name=message,
-            start_ts=0.0,
-        )
-        event = build_event(orphan, level, message, fields=fields, baggage=baggage)
-        _ensure_sink().emit([event])
-    if echo:
-        _console.write(event)
+        try:
+            orphan = Span(
+                trace_id=new_trace_id(),
+                span_id=new_span_id(),
+                parent_span_id=None,
+                name=message,
+                start_ts=0.0,
+            )
+            event = build_event(orphan, level, message, fields=fields, baggage=baggage)
+            _ensure_sink().emit([event])
+        except Exception as exc:
+            # The whole branch, not just `emit`: `_ensure_sink` constructs the sink on first
+            # use, so a sink that fails to *build* raises here too — and that is the shape the
+            # spec's own motivating case takes.
+            _diag.absorbed("emitting an orphan log", exc, "the event was lost")
+    if echo and event is not None:
+        try:
+            _console.write(event)
+        except Exception as exc:
+            # An echo is a diagnostic convenience and must not outrank the caller: the stream
+            # may be closed, redirected, or gone at interpreter shutdown. It runs *after* the
+            # emit, so a broken console never costs the event itself.
+            _diag.absorbed("echoing to the console", exc)
 
 
 def debug(message: str, *, echo: bool = False, **fields: object) -> None:

{log_foundry-0.10.2.dev8 → log_foundry-0.10.2.dev10}/src/log_foundry/worker.py

@@ -25,6 +25,8 @@ import threading
 import time
 from typing import TYPE_CHECKING, NamedTuple, cast
 
+from log_foundry import _diag
+
 if TYPE_CHECKING:
     from log_foundry.sinks.base import Sink
 
@@ -244,6 +246,17 @@ class Worker:
 
         Idempotent: a second call is a no-op (FR-005). Registered via ``atexit`` by the
         decorator's lazy worker so a program that logs and exits immediately still flushes.
+
+        **Total** (SPEC-025 FR-004). The close was unguarded, so a sink whose ``close()`` failed
+        raised out of ``shutdown()`` — and out of the ``atexit`` handler, where CPython printed
+        "Exception ignored in atexit callback" with a full traceback carrying the exception's
+        message, which arch §6 keeps out of anything the library says about itself.
+
+        The once-only flag deliberately stays *ahead* of the close rather than moving after it.
+        Re-running a drain is not safe, and a second ``shutdown()`` retrying a close that already
+        failed would call ``close()`` twice on a sink that may have partially released its
+        resources. Idempotence is preserved; what changes is that the failure is announced rather
+        than swallowed by the flag.
         """
         with self._lock:
             if self._shutdown_done:
@@ -255,7 +268,12 @@ class Worker:
         except queue.Full:
             pass
         self._thread.join()
-        self.sink.close()
+        try:
+            self.sink.close()
+        except Exception as exc:
+            # After the join, so everything queued has already been drained and emitted: what is
+            # lost here is the sink's own cleanup, not events.
+            _diag.absorbed("closing the sink", exc, "it may still hold its resources")
 
     # -- worker thread ------------------------------------------------------------------