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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: log-foundry
-Version: 0.10.2.dev9
+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.dev9 → 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.dev9"
+version = "0.10.2.dev10"
 
 [project.optional-dependencies]
 aws = ["boto3>=1.43.61"]              # SQSSink, SNSSink, KinesisSink, FirehoseSink

{log_foundry-0.10.2.dev9 → 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.dev9 → 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 ------------------------------------------------------------------