rillkit 0.1.0__tar.gz → 0.1.1__tar.gz

{rillkit-0.1.0 → rillkit-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: rillkit
-Version: 0.1.0
+Version: 0.1.1
 Summary: Simple publish and consume for Redis Streams: consumer groups, retries, DLQ, ack policies and middleware.
 Project-URL: Homepage, https://nimzymaina.github.io/rillkit/
 Project-URL: Documentation, https://nimzymaina.github.io/rillkit/

{rillkit-0.1.0 → rillkit-0.1.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "rillkit"
-version = "0.1.0"
+version = "0.1.1"
 description = "Simple publish and consume for Redis Streams: consumer groups, retries, DLQ, ack policies and middleware."
 readme = "README.md"
 requires-python = ">=3.9"

{rillkit-0.1.0 → rillkit-0.1.1}/src/rillkit/__init__.py

@@ -16,7 +16,7 @@ from .middleware import BaseMiddleware, Idempotent, PublishCommand
 from .settings import Settings
 from .stream import Stream
 
-__version__ = "0.1.0"
+__version__ = "0.1.1"
 
 __all__ = [
     "AckMessage", "AckPolicy", "BaseMiddleware", "Broker", "Codec", "DecodeError", "Idempotent",

{rillkit-0.1.0 → rillkit-0.1.1}/src/rillkit/consumer.py

@@ -39,6 +39,21 @@ def _fields(raw: dict[Any, Any]) -> dict[str, str]:
     return {_text(k): _text(v) for k, v in raw.items()}
 
 
+def _socket_timeout(client: Any) -> Optional[float]:
+    """The read timeout a connection from this client will use, or None for no timeout."""
+    try:
+        conn = client.connection_pool.make_connection()
+    except Exception:
+        return None
+    try:
+        return getattr(conn, "socket_timeout", None) or getattr(conn, "_socket_timeout", None)
+    finally:
+        try:
+            conn.disconnect()
+        except Exception:
+            pass
+
+
 def _is_model(annotation: Any) -> bool:
     return inspect.isclass(annotation) and hasattr(annotation, "model_validate")
 
@@ -102,6 +117,7 @@ class Subscriber:
         self.backoff = backoff
         self.max_backoff_ms = max_backoff_ms
         self.block_ms = block_ms
+        self._block_ms = block_ms  # what is actually used, see setup()
         self.count = count
         self.own_middlewares = list(middlewares)
         self.consumer = consumer or f"{stream.group}-{socket.gethostname()}-{os.getpid()}"
@@ -128,6 +144,15 @@ class Subscriber:
     # lifecycle
 
     def setup(self) -> None:
+        # A blocking read that outlasts the client's socket timeout fails and is retried by
+        # redis-py, so keep the block time a second under the timeout.
+        timeout = _socket_timeout(self.client)
+        if timeout is not None and self.block_ms / 1000 > timeout - 1:
+            self._block_ms = max(100, int((timeout - 1) * 1000))
+            log.warning(
+                "client socket_timeout is %.1f s, shorter than block_ms=%d; using %d ms",
+                timeout, self.block_ms, self._block_ms,
+            )
         try:
             self.client.xgroup_create(
                 self.stream.name, self.group, id=self.group_start_id, mkstream=True
@@ -204,7 +229,7 @@ class Subscriber:
     def _read(self) -> list[Message]:
         result: Any = self.client.xreadgroup(
             self.group, self.consumer, {self.stream.name: ">"},
-            count=self.count, block=self.block_ms,
+            count=self.count, block=self._block_ms,
         )
         return [self._message(i, f, 1) for _, entries in result or [] for i, f in entries]
 

rillkit-0.1.1/src/rillkit/settings.py

@@ -0,0 +1,57 @@
+import os
+from dataclasses import dataclass
+from typing import Optional
+
+import redis
+
+
+def _seconds(value: Optional[str], default: Optional[float]) -> Optional[float]:
+    if value is None or value == "":
+        return default
+    return None if value.strip().lower() in ("none", "off", "0") else float(value)
+
+
+@dataclass
+class Settings:
+    """Connection settings.
+
+    ``Settings.from_env()`` reads REDIS_URL, or REDIS_HOST/PORT/DB/PASSWORD/SSL, plus
+    REDIS_SOCKET_TIMEOUT (seconds, or ``none``).
+
+    ``socket_timeout`` is set explicitly because consumers block in ``XREADGROUP`` for up to
+    ``block_ms`` and the client must wait longer than that. redis-py 8 changed its own default to
+    5 s, which is shorter than rillkit's default block time.
+    """
+
+    url: Optional[str] = None
+    host: str = "localhost"
+    port: int = 6379
+    db: int = 0
+    password: Optional[str] = None
+    ssl: bool = False
+    socket_timeout: Optional[float] = 15.0
+
+    @classmethod
+    def from_env(cls, prefix: str = "REDIS_") -> "Settings":
+        env = os.environ
+        return cls(
+            url=env.get(f"{prefix}URL"),
+            host=env.get(f"{prefix}HOST", "localhost"),
+            port=int(env.get(f"{prefix}PORT", 6379)),
+            db=int(env.get(f"{prefix}DB", 0)),
+            password=env.get(f"{prefix}PASSWORD"),
+            ssl=env.get(f"{prefix}SSL", "").lower() in ("1", "true", "yes"),
+            socket_timeout=_seconds(env.get(f"{prefix}SOCKET_TIMEOUT"), 15.0),
+        )
+
+    def client(self) -> "redis.Redis":
+        if self.url:
+            return redis.Redis.from_url(self.url, socket_timeout=self.socket_timeout)
+        return redis.Redis(
+            host=self.host,
+            port=self.port,
+            db=self.db,
+            password=self.password,
+            ssl=self.ssl,
+            socket_timeout=self.socket_timeout,
+        )

{rillkit-0.1.0 → rillkit-0.1.1}/tests/helpers.py

@@ -1,4 +1,7 @@
+import contextlib
+import threading
 import time
+from collections.abc import Iterator
 from typing import Any, Callable
 
 import redis
@@ -21,6 +24,34 @@ def fast(**overrides: Any) -> dict[str, Any]:
     return opts
 
 
+@contextlib.contextmanager
+def keep_server_awake(url: str, interval: float = 0.05) -> Iterator[None]:
+    """Send a cheap PING every ``interval`` seconds from another client.
+
+    Harmless against a real Redis. Some sandboxed local servers only fire blocking-command
+    timeouts when other traffic wakes their event loop, which makes idle-consumer tests hang.
+    """
+    stop = threading.Event()
+    client = redis.Redis.from_url(url)
+
+    def ping() -> None:
+        while not stop.is_set():
+            try:
+                client.ping()
+            except redis.RedisError:
+                pass
+            stop.wait(interval)
+
+    thread = threading.Thread(target=ping, daemon=True)
+    thread.start()
+    try:
+        yield
+    finally:
+        stop.set()
+        thread.join(2)
+        client.close()
+
+
 def pending(r: "redis.Redis", stream: str, group: str = "g") -> int:
     return int(r.xpending(stream, group)["pending"])
 

rillkit-0.1.1/tests/test_blocking_timeout.py

@@ -0,0 +1,56 @@
+"""The default blocking read (5 s) must not collide with the Redis client's socket timeout.
+
+redis-py 8 changed the default socket_timeout from "none" to 5 s, which equals rillkit's default
+block_ms, so an idle consumer's read timed out right as the server would have replied.
+"""
+
+import logging
+import time
+
+import redis
+
+from helpers import keep_server_awake, wait_until
+from rillkit import Broker, Settings, Stream
+
+
+def _run_idle_then_publish(
+    broker: Broker, stream: Stream, caplog, idle_seconds: float, url: str
+) -> list:
+    got: list = []
+
+    @broker.subscribe(stream)  # library defaults: block_ms=5000, heartbeat on
+    def handle(body: dict):
+        got.append(body)
+
+    with keep_server_awake(url), caplog.at_level(logging.ERROR, logger="rillkit"):
+        broker.start()
+        time.sleep(idle_seconds)
+        broker.publish(stream, {"n": 1})
+        assert wait_until(lambda: got, timeout=8)
+        broker.stop()
+    errors = [r.getMessage() for r in caplog.records if r.levelno >= logging.ERROR]
+    assert errors == []
+    return got
+
+
+def test_default_block_with_short_client_timeout(redis_url, name, caplog):
+    """A caller-supplied client with a 2 s socket timeout and the default 5 s block."""
+    client = redis.Redis.from_url(redis_url, socket_timeout=2)
+    broker = Broker(client=client)
+    stream = Stream(name, group="g")
+    _run_idle_then_publish(broker, stream, caplog, idle_seconds=4, url=redis_url)
+    assert broker.subscribers[0]._block_ms < 2000  # clamped below the socket timeout
+
+
+def test_default_settings_survive_an_idle_period(redis_url, name, caplog):
+    """The client rillkit builds itself works with the defaults across more than one idle pass."""
+    broker = Broker(settings=Settings(url=redis_url))
+    stream = Stream(name, group="g")
+    _run_idle_then_publish(broker, stream, caplog, idle_seconds=6, url=redis_url)
+
+
+def test_settings_socket_timeout_comes_from_env(monkeypatch):
+    monkeypatch.setenv("REDIS_SOCKET_TIMEOUT", "30")
+    assert Settings.from_env().socket_timeout == 30.0
+    monkeypatch.setenv("REDIS_SOCKET_TIMEOUT", "none")
+    assert Settings.from_env().socket_timeout is None

rillkit-0.1.0/src/rillkit/settings.py

@@ -1,39 +0,0 @@
-import os
-from dataclasses import dataclass
-from typing import Optional
-
-import redis
-
-
-@dataclass
-class Settings:
-    """Connection settings.
-
-    ``Settings.from_env()`` reads REDIS_URL, or REDIS_HOST/PORT/DB/PASSWORD/SSL.
-    """
-
-    url: Optional[str] = None
-    host: str = "localhost"
-    port: int = 6379
-    db: int = 0
-    password: Optional[str] = None
-    ssl: bool = False
-
-    @classmethod
-    def from_env(cls, prefix: str = "REDIS_") -> "Settings":
-        env = os.environ
-        return cls(
-            url=env.get(f"{prefix}URL"),
-            host=env.get(f"{prefix}HOST", "localhost"),
-            port=int(env.get(f"{prefix}PORT", 6379)),
-            db=int(env.get(f"{prefix}DB", 0)),
-            password=env.get(f"{prefix}PASSWORD"),
-            ssl=env.get(f"{prefix}SSL", "").lower() in ("1", "true", "yes"),
-        )
-
-    def client(self) -> "redis.Redis":
-        if self.url:
-            return redis.Redis.from_url(self.url)
-        return redis.Redis(
-            host=self.host, port=self.port, db=self.db, password=self.password, ssl=self.ssl
-        )