fluidattacks_core_logging 12.1.0__tar.gz → 12.2.0__tar.gz

{fluidattacks_core_logging-12.1.0 → fluidattacks_core_logging-12.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: fluidattacks_core_logging
-Version: 12.1.0
+Version: 12.2.0
 Summary: Fluid Attacks Core Logging Library
 Author-email: Development <development@fluidattacks.com>
 License: MPL-2.0

{fluidattacks_core_logging-12.1.0 → fluidattacks_core_logging-12.2.0}/fluidattacks_core/logging/handlers.py

@@ -1,9 +1,10 @@
 import copy
 import logging
 import sys
+import threading
 from logging.handlers import HTTPHandler, QueueHandler, QueueListener
-from queue import Queue
-from typing import TextIO
+from queue import Full, Queue
+from typing import TextIO, cast
 
 import simplejson as json
 
@@ -81,23 +82,46 @@ class ProductionSyncHandler(logging.StreamHandler[TextIO]):
         self.setFormatter(CustomJsonFormatter())
 
 
+class _DrainingStopListener(QueueListener):
+    """Listener that drains the queue before stopping, so a full one cannot reject it."""
+
+    def stop(self) -> None:
+        cast("Queue[object]", self.queue).join()
+        super().stop()
+
+
 class ProductionAsyncHandler(CustomQueueHandler):
     """Logging handler for production environments implemented with `QueueHandler`.
 
     Includes:
     - Filters: `NoBatchFilter`, `ProductionOnlyFilter`
     - Formatter: `CustomJsonFormatter`
+
+    A positive `max_queue_size` drops records once the queue is full.
     """
 
-    def __init__(self, stream: TextIO = sys.stderr) -> None:
+    def __init__(self, stream: TextIO = sys.stderr, max_queue_size: int = 0) -> None:
         handler = logging.StreamHandler(stream)
         handler.addFilter(ProductionOnlyFilter())
         handler.setFormatter(CustomJsonFormatter())
 
-        super().__init__(Queue())
+        super().__init__(Queue(maxsize=max_queue_size))
         self.shutting_down = False
+        self.dropped = 0
+        self._dropped_lock = threading.Lock()
 
-        self._attach_listener(QueueListener(self.queue, handler))
+        self._attach_listener(_DrainingStopListener(self.queue, handler))
+
+    def on_drop(self) -> None:
+        """Report a dropped record; it must neither log nor raise."""
+
+    def enqueue(self, record: logging.LogRecord) -> None:
+        try:
+            super().enqueue(record)
+        except Full:
+            with self._dropped_lock:
+                self.dropped += 1
+            self.on_drop()
 
     def emit(self, record: logging.LogRecord) -> None:
         if self.shutting_down:

{fluidattacks_core_logging-12.1.0 → fluidattacks_core_logging-12.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fluidattacks_core_logging"
-version = "12.1.0"
+version = "12.2.0"
 description = "Fluid Attacks Core Logging Library"
 authors = [{ name = "Development", email = "development@fluidattacks.com" }]
 license = { text = "MPL-2.0" }

{fluidattacks_core_logging-12.1.0 → fluidattacks_core_logging-12.2.0}/tests/test_logging.py

@@ -1,8 +1,10 @@
 import io
 import logging
 import sys
+import threading
 import time
 from queue import Queue
+from typing import cast
 
 import pytest
 import simplejson as json
@@ -406,3 +408,82 @@ def test_async_handler_init_leaves_a_closable_handler() -> None:
     handler.close()
 
     assert not _listener_consumes_new_records(handler)
+
+
+class _BlockedStream(io.StringIO):
+    """Stream whose writes wait for `release`, keeping the listener busy."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.release = threading.Event()
+
+    def write(self, s: str) -> int:
+        self.release.wait(timeout=5)
+        return super().write(s)
+
+
+def _queue_of(handler: ProductionAsyncHandler) -> Queue[logging.LogRecord]:
+    return cast("Queue[logging.LogRecord]", handler.queue)
+
+
+def _record(message: str) -> logging.LogRecord:
+    return logging.LogRecord("test", logging.INFO, __file__, 0, message, None, None)
+
+
+def test_production_async_handler_is_unbounded_by_default() -> None:
+    handler = ProductionAsyncHandler(io.StringIO())
+
+    assert _queue_of(handler).maxsize == 0
+    assert handler.dropped == 0
+
+    handler.close()
+
+
+def test_production_async_handler_drops_records_when_the_queue_is_full() -> None:
+    stream = _BlockedStream()
+    handler = ProductionAsyncHandler(stream, max_queue_size=2)
+    total = 10
+
+    for index in range(total):
+        handler.emit(_record(f"message {index}"))
+
+    # One record may be held by the busy listener, the rest wait in the queue.
+    assert _queue_of(handler).qsize() == 2
+    assert total - 3 <= handler.dropped <= total - 2
+
+    stream.release.set()
+    handler.close()
+
+
+def test_production_async_handler_calls_on_drop_once_per_dropped_record() -> None:
+    drops: list[int] = []
+
+    class _Reporting(ProductionAsyncHandler):
+        def on_drop(self) -> None:
+            drops.append(1)
+
+    stream = _BlockedStream()
+    handler = _Reporting(stream, max_queue_size=1)
+
+    for index in range(5):
+        handler.emit(_record(f"message {index}"))
+
+    assert len(drops) == handler.dropped
+    assert handler.dropped >= 3
+
+    stream.release.set()
+    handler.close()
+
+
+def test_production_async_handler_closes_with_a_full_queue() -> None:
+    stream = _BlockedStream()
+    handler = ProductionAsyncHandler(stream, max_queue_size=1)
+
+    for index in range(4):
+        handler.emit(_record(f"message {index}"))
+    stream.release.set()
+    handler.close()
+
+    assert handler.listener is not None
+    assert handler.shutting_down is True
+    assert not _listener_consumes_new_records(handler)

{fluidattacks_core_logging-12.1.0 → fluidattacks_core_logging-12.2.0}/uv.lock

@@ -148,7 +148,7 @@ wheels = [
 
 [[package]]
 name = "fluidattacks-core-logging"
-version = "12.1.0"
+version = "12.2.0"
 source = { editable = "." }
 dependencies = [
     { name = "python-json-logger" },