redis-message-queue 8.0.3__tar.gz → 8.1.0__tar.gz

{redis_message_queue-8.0.3 → redis_message_queue-8.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: redis-message-queue
-Version: 8.0.3
+Version: 8.1.0
 Summary: Python message queuing with Redis and message deduplication
 License: MIT
 License-File: LICENSE
@@ -392,6 +392,32 @@ while not interrupt.is_interrupted():
 > processes, or install one top-level signal owner that calls `queue.drain()`
 > / `queue.aclose()` or sets an application stop event.
 
+If another library owns SIGTERM/SIGINT in the same process, adapt its shutdown
+signal to rmq with a user-owned event instead of installing rmq signal handlers:
+
+```python
+import threading
+
+from redis_message_queue import EventDrivenInterruptHandler, RedisMessageQueue
+
+stop_event = threading.Event()
+interrupt = EventDrivenInterruptHandler(stop_event)
+queue = RedisMessageQueue("q", client=client, interrupt=interrupt)
+
+while not interrupt.is_interrupted():
+    with queue.process_message() as message:
+        if message is not None:
+            process(message)
+
+# In the sibling library's shutdown hook:
+stop_event.set()
+queue.drain(timeout=25)
+```
+
+The caller MUST set `stop_event` before exiting. rmq observes
+`is_interrupted()` and exits cooperatively; it does not call `sys.exit()` or
+otherwise force process shutdown.
+
 There are three distinct shutdown shapes; pick the one that matches your runtime:
 
 | Shape | Trigger | In-flight handler | Pending claim IDs |
@@ -589,6 +615,11 @@ using `":queue:"` with a queue name that overlaps RQ keys. rmq has no fixed
 library prefix; generated keys share the Redis DB namespace with every other
 Redis user.
 
+Set `strict_envelope_decoding=True` if this Redis is shared with sibling task
+libraries (Celery, RQ, Dramatiq) to fail-fast on foreign payloads. With the
+default `False`, non-rmq values that do not start with the rmq envelope prefix
+remain backward-compatible raw messages and are yielded to the handler.
+
 ## Production notes
 
 ### Fork safety and pre-fork servers

{redis_message_queue-8.0.3 → redis_message_queue-8.1.0}/README.md

@@ -366,6 +366,32 @@ while not interrupt.is_interrupted():
 > processes, or install one top-level signal owner that calls `queue.drain()`
 > / `queue.aclose()` or sets an application stop event.
 
+If another library owns SIGTERM/SIGINT in the same process, adapt its shutdown
+signal to rmq with a user-owned event instead of installing rmq signal handlers:
+
+```python
+import threading
+
+from redis_message_queue import EventDrivenInterruptHandler, RedisMessageQueue
+
+stop_event = threading.Event()
+interrupt = EventDrivenInterruptHandler(stop_event)
+queue = RedisMessageQueue("q", client=client, interrupt=interrupt)
+
+while not interrupt.is_interrupted():
+    with queue.process_message() as message:
+        if message is not None:
+            process(message)
+
+# In the sibling library's shutdown hook:
+stop_event.set()
+queue.drain(timeout=25)
+```
+
+The caller MUST set `stop_event` before exiting. rmq observes
+`is_interrupted()` and exits cooperatively; it does not call `sys.exit()` or
+otherwise force process shutdown.
+
 There are three distinct shutdown shapes; pick the one that matches your runtime:
 
 | Shape | Trigger | In-flight handler | Pending claim IDs |
@@ -563,6 +589,11 @@ using `":queue:"` with a queue name that overlaps RQ keys. rmq has no fixed
 library prefix; generated keys share the Redis DB namespace with every other
 Redis user.
 
+Set `strict_envelope_decoding=True` if this Redis is shared with sibling task
+libraries (Celery, RQ, Dramatiq) to fail-fast on foreign payloads. With the
+default `False`, non-rmq values that do not start with the rmq envelope prefix
+remain backward-compatible raw messages and are yielded to the handler.
+
 ## Production notes
 
 ### Fork safety and pre-fork servers

{redis_message_queue-8.0.3 → redis_message_queue-8.1.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "redis-message-queue"
-version = "8.0.3"
+version = "8.1.0"
 description = "Python message queuing with Redis and message deduplication"
 authors = ["Elijas <4084885+Elijas@users.noreply.github.com>"]
 readme = "README.md"

{redis_message_queue-8.0.3 → redis_message_queue-8.1.0}/redis_message_queue/__init__.py

@@ -3,6 +3,7 @@ from redis_message_queue._event import EventOperation, EventOutcome, QueueEvent
 from redis_message_queue._exceptions import (
     CleanupFailedError,
     ConfigurationError,
+    DrainFailedError,
     GatewayContractError,
     LuaScriptError,
     MalformedStoredMessageError,
@@ -15,6 +16,7 @@ from redis_message_queue._redis_gateway import RedisGateway
 from redis_message_queue._stored_message import ClaimedMessage, MessageData
 from redis_message_queue.interrupt_handler import (
     BaseGracefulInterruptHandler,
+    EventDrivenInterruptHandler,
     GracefulInterruptHandler,
 )
 from redis_message_queue.redis_message_queue import RedisMessageQueue
@@ -25,6 +27,7 @@ __all__ = [
     "AbstractRedisGateway",
     "ClaimedMessage",
     "MessageData",
+    "EventDrivenInterruptHandler",
     "GracefulInterruptHandler",
     "BaseGracefulInterruptHandler",
     "QueueEvent",
@@ -32,6 +35,7 @@ __all__ = [
     "EventOutcome",
     "RedisMessageQueueError",
     "ConfigurationError",
+    "DrainFailedError",
     "GatewayContractError",
     "LuaScriptError",
     "MalformedStoredMessageError",

{redis_message_queue-8.0.3 → redis_message_queue-8.1.0}/redis_message_queue/_event.py

@@ -24,6 +24,7 @@ class EventOperation(StrEnum):
     TRIM_FAILED = "trim_failed"
     RETRY_ATTEMPT = "retry_attempt"
     RETRY_EXHAUSTED = "retry_exhausted"
+    DRAIN = "drain"
 
 
 class EventOutcome(StrEnum):
@@ -32,6 +33,7 @@ class EventOutcome(StrEnum):
     SUCCESS = "success"
     FAILURE = "failure"
     SKIPPED = "skipped"
+    START = "start"
 
 
 @dataclass(frozen=True)
@@ -68,3 +70,7 @@ class QueueEvent:
     the actual exception object when one was raised; pass to OpenTelemetry
     `span.record_exception(...)` for full trace attribution
     """
+    timeout_seconds: float | None = None
+    """the caller-requested timeout for drain operations, when applicable"""
+    pending_claim_ids: int | None = None
+    """number of unresolved pending claim ids for drain operations, when applicable"""

redis_message_queue-8.1.0/redis_message_queue/_exceptions.py

@@ -0,0 +1,149 @@
+import redis.exceptions
+
+
+class RedisMessageQueueError(Exception):
+    """Base class for redis-message-queue specific errors."""
+
+    def __init__(
+        self,
+        *args: object,
+        queue: str | None = None,
+        message_id: str | None = None,
+        operation: str | None = None,
+    ) -> None:
+        super().__init__(*args)
+        self.queue = queue
+        self.message_id = message_id
+        self.operation = operation
+
+
+class ConfigurationError(RedisMessageQueueError, ValueError):
+    """Bad parameter values or combinations."""
+
+
+class GatewayContractError(RedisMessageQueueError, TypeError):
+    """Custom gateway returned wrong type or violated contract."""
+
+
+class LuaScriptError(redis.exceptions.ResponseError, RedisMessageQueueError):
+    """A Lua script returned an unexpected error_reply."""
+
+    def __init__(
+        self,
+        *args: object,
+        queue: str | None = None,
+        message_id: str | None = None,
+        operation: str | None = None,
+    ) -> None:
+        RedisMessageQueueError.__init__(
+            self,
+            *args,
+            queue=queue,
+            message_id=message_id,
+            operation=operation,
+        )
+
+
+class CleanupFailedError(RedisMessageQueueError):
+    """Cleanup after handler completion failed."""
+
+
+class DrainFailedError(RedisMessageQueueError):
+    """Wraps a non-RMQ exception caught during drain pending-claim recovery.
+
+    drain() returns False as the bool result; this exception carries
+    F7 context (queue, operation="drain") into the drain/failure event
+    payload so users diagnosing drain incidents via on_event see the
+    same structured attrs as elsewhere.
+    """
+
+
+class MalformedStoredMessageError(RedisMessageQueueError):
+    """Stored value is not a valid RMQ envelope for the configured decode mode."""
+
+
+class QueueBackpressureError(RedisMessageQueueError):
+    """Publish rejected because the pending queue is at its configured limit."""
+
+    _REMEDIATION = (
+        "consider increasing `max_pending_length`, switching to "
+        "`pending_overload_policy='block'`, or adding consumer capacity."
+    )
+
+    def __init__(
+        self,
+        *args: object,
+        queue: str | None = None,
+        message_id: str | None = None,
+        operation: str | None = None,
+    ) -> None:
+        message = "Pending queue reached its configured limit" if not args else args[0]
+        if not isinstance(message, str) or len(args) > 1:
+            super().__init__(*args, queue=queue, message_id=message_id, operation=operation)
+            return
+        if self._REMEDIATION not in message:
+            message = f"{message}; {self._REMEDIATION}"
+        super().__init__(message, queue=queue, message_id=message_id, operation=operation)
+
+
+class QueueDrainedError(RedisMessageQueueError):
+    """Raised when publish() is called after drain() or aclose()."""
+
+
+class RetryBudgetExhaustedError(redis.exceptions.RedisError, RedisMessageQueueError):
+    """Tenacity retry budget exhausted; underlying redis-py exception is .__cause__."""
+
+    _REMEDIATION = (
+        "verify Redis connectivity and consider increasing `retry_budget_seconds` if transient failures are expected."
+    )
+
+    def __init__(
+        self,
+        *args: object,
+        queue: str | None = None,
+        message_id: str | None = None,
+        operation: str | None = None,
+    ) -> None:
+        message = "Redis retry budget exhausted" if not args else args[0]
+        if not isinstance(message, str) or len(args) > 1:
+            RedisMessageQueueError.__init__(
+                self,
+                *args,
+                queue=queue,
+                message_id=message_id,
+                operation=operation,
+            )
+            return
+        if self._REMEDIATION not in message:
+            message = f"{message}; {self._REMEDIATION}"
+        RedisMessageQueueError.__init__(
+            self,
+            message,
+            queue=queue,
+            message_id=message_id,
+            operation=operation,
+        )
+
+
+def _set_exception_context(
+    exc: BaseException,
+    *,
+    queue: str | None = None,
+    message_id: str | None = None,
+    operation: str | None = None,
+) -> None:
+    if not isinstance(exc, RedisMessageQueueError):
+        return
+    if queue is not None:
+        exc.queue = queue
+    if message_id is not None:
+        exc.message_id = message_id
+    if operation is not None:
+        exc.operation = operation
+
+
+def wrap_lua_response_error(exc: redis.exceptions.ResponseError) -> LuaScriptError | None:
+    message = str(exc)
+    if message.startswith("WRONGTYPE ") or message.startswith("OOM during publish;"):
+        return LuaScriptError(message)
+    return None

{redis_message_queue-8.0.3 → redis_message_queue-8.1.0}/redis_message_queue/_redis_gateway.py

@@ -41,7 +41,9 @@ from redis_message_queue._event import EventOperation, EventOutcome
 from redis_message_queue._exceptions import (
     ConfigurationError,
     QueueBackpressureError,
+    RedisMessageQueueError,
     RetryBudgetExhaustedError,
+    _set_exception_context,
     wrap_lua_response_error,
 )
 from redis_message_queue._stored_message import (
@@ -49,6 +51,7 @@ from redis_message_queue._stored_message import (
     MessageData,
     decode_stored_message,
     encode_stored_message,
+    extract_stored_message_id,
 )
 from redis_message_queue.interrupt_handler._interface import (
     BaseGracefulInterruptHandler,
@@ -269,6 +272,7 @@ class RedisGateway(AbstractRedisGateway):
         self._recovering_claim_ids: dict[str, set[str]] = {}
         self._pending_claim_ids_lock = threading.Lock()
         self._drain_pending_claim_ids_lock = threading.Lock()
+        self._last_drain_error: BaseException | None = None
         self._event_queue_name: str | None = None
         self._event_emitter: Callable[..., None] | None = None
 
@@ -343,13 +347,17 @@ class RedisGateway(AbstractRedisGateway):
                 return result
             if self._pending_overload_policy != "block":
                 raise QueueBackpressureError(
-                    f"Pending queue {queue!r} reached max_pending_length={self._max_pending_length}"
+                    f"Pending queue {queue!r} reached max_pending_length={self._max_pending_length}",
+                    queue=queue,
+                    operation="publish",
                 )
             remaining = deadline - time.monotonic()
             if remaining <= 0:
                 raise QueueBackpressureError(
                     f"Pending queue {queue!r} stayed at max_pending_length={self._max_pending_length} "
-                    f"for {self._pending_overload_block_timeout_seconds} seconds"
+                    f"for {self._pending_overload_block_timeout_seconds} seconds",
+                    queue=queue,
+                    operation="publish",
                 )
             sleep_seconds = min(_jitter_pending_overload_backoff_seconds(backoff_seconds), remaining)
             time.sleep(sleep_seconds)
@@ -380,6 +388,7 @@ class RedisGateway(AbstractRedisGateway):
                 "an empty key would create a bare-prefix Redis marker that silently suppresses unrelated messages"
             )
         stored_message = encode_stored_message(message)
+        message_id = extract_stored_message_id(stored_message)
         operation_id = uuid.uuid4().hex
         operation_result_key = self._publish_operation_result_key(dedup_key, operation_id)
 
@@ -404,6 +413,9 @@ class RedisGateway(AbstractRedisGateway):
 
         try:
             return _publish()
+        except RedisMessageQueueError as exc:
+            _set_exception_context(exc, queue=queue, message_id=message_id, operation="publish")
+            raise
         finally:
             self._delete_operation_result_key(operation_result_key)
 
@@ -423,20 +435,29 @@ class RedisGateway(AbstractRedisGateway):
         retry budget on top of the client.
         """
         stored_message = encode_stored_message(message)
+        message_id = extract_stored_message_id(stored_message)
         if self._max_pending_length is not None:
-            self._run_pending_backpressure_operation(
-                queue,
-                lambda: self._eval(
-                    ADD_MESSAGE_LUA_SCRIPT,
-                    1,
+            try:
+                self._run_pending_backpressure_operation(
                     queue,
-                    stored_message,
-                    self._lua_max_pending_length(),
-                    self._pending_overload_policy,
-                ),
-            )
+                    lambda: self._eval(
+                        ADD_MESSAGE_LUA_SCRIPT,
+                        1,
+                        queue,
+                        stored_message,
+                        self._lua_max_pending_length(),
+                        self._pending_overload_policy,
+                    ),
+                )
+            except RedisMessageQueueError as exc:
+                _set_exception_context(exc, queue=queue, message_id=message_id, operation="publish")
+                raise
             return
-        self._redis_client.lpush(queue, stored_message)
+        try:
+            self._redis_client.lpush(queue, stored_message)
+        except RedisMessageQueueError as exc:
+            _set_exception_context(exc, queue=queue, message_id=message_id, operation="publish")
+            raise
 
     def move_message(
         self,
@@ -471,6 +492,14 @@ class RedisGateway(AbstractRedisGateway):
 
             try:
                 return _move()
+            except RedisMessageQueueError as exc:
+                _set_exception_context(
+                    exc,
+                    queue=from_queue,
+                    message_id=extract_stored_message_id(message),
+                    operation="ack",
+                )
+                raise
             finally:
                 self._delete_operation_result_key(operation_result_key)
 
@@ -501,6 +530,14 @@ class RedisGateway(AbstractRedisGateway):
 
         try:
             return _move_with_lease()
+        except RedisMessageQueueError as exc:
+            _set_exception_context(
+                exc,
+                queue=from_queue,
+                message_id=extract_stored_message_id(message),
+                operation="ack",
+            )
+            raise
         finally:
             self._delete_operation_result_key(operation_result_key)
 
@@ -526,6 +563,14 @@ class RedisGateway(AbstractRedisGateway):
 
             try:
                 return _remove()
+            except RedisMessageQueueError as exc:
+                _set_exception_context(
+                    exc,
+                    queue=queue,
+                    message_id=extract_stored_message_id(message),
+                    operation="ack",
+                )
+                raise
             finally:
                 self._delete_operation_result_key(operation_result_key)
 
@@ -554,6 +599,14 @@ class RedisGateway(AbstractRedisGateway):
 
         try:
             return _remove_with_lease()
+        except RedisMessageQueueError as exc:
+            _set_exception_context(
+                exc,
+                queue=queue,
+                message_id=extract_stored_message_id(message),
+                operation="ack",
+            )
+            raise
         finally:
             self._delete_operation_result_key(operation_result_key)
 
@@ -673,7 +726,9 @@ class RedisGateway(AbstractRedisGateway):
                             error=retry_exc,
                         )
                         raise RetryBudgetExhaustedError(
-                            "Redis retry budget exhausted during message claim"
+                            "Redis retry budget exhausted during message claim",
+                            queue=from_queue,
+                            operation="claim",
                         ) from retry_exc
                     except BaseException:
                         pending_claim_id_to_share = claim_id
@@ -746,7 +801,9 @@ class RedisGateway(AbstractRedisGateway):
                             error=last_retryable_exception,
                         )
                         raise RetryBudgetExhaustedError(
-                            "Redis retry budget exhausted during message claim"
+                            "Redis retry budget exhausted during message claim",
+                            queue=from_queue,
+                            operation="claim",
                         ) from last_retryable_exception
                     return None
                 time.sleep(min(_VISIBILITY_TIMEOUT_POLL_INTERVAL_SECONDS, remaining))
@@ -1159,6 +1216,7 @@ class RedisGateway(AbstractRedisGateway):
         the deadline fired or transient Redis errors prevented full drain.
         """
         with self._drain_pending_claim_ids_lock:
+            self._last_drain_error = None
             return self._drain_pending_claim_ids_unlocked(
                 processing_queue,
                 deadline_monotonic=deadline_monotonic,
@@ -1176,12 +1234,14 @@ class RedisGateway(AbstractRedisGateway):
         else:
             recover = self._recover_pending_non_visibility_timeout_claim
         skipped_transient: set[str] = set()
+        last_error: BaseException | None = None
         while True:
             # ``>=`` (not ``>``) makes ``timeout=0`` deterministically take
             # the no-recovery fast path: the deadline equals the call-time
             # ``monotonic()``, so the first iteration falls through to the
             # state-only check below.
             if deadline_monotonic is not None and time.monotonic() >= deadline_monotonic:
+                last_error = TimeoutError("drain pending-claim recovery deadline expired")
                 break
             with self._pending_claim_ids_lock:
                 pending = self._pending_claim_ids.get(processing_queue)
@@ -1201,10 +1261,12 @@ class RedisGateway(AbstractRedisGateway):
                     recover(processing_queue, claim_id, deadline_monotonic=deadline_monotonic)
                     clear = True
                 except _DrainDeadlineExceeded:
+                    last_error = TimeoutError("drain pending-claim recovery deadline expired")
                     break
                 except Exception as exc:
                     if not is_redis_retryable_exception(exc):
                         raise
+                    last_error = exc
                     logger.warning(
                         "Transient Redis error draining pending claim %s; will retry on next drain: %s",
                         claim_id,
@@ -1214,4 +1276,7 @@ class RedisGateway(AbstractRedisGateway):
             finally:
                 self._finish_pending_claim_recovery(processing_queue, claim_id, clear=clear)
         with self._pending_claim_ids_lock:
-            return not self._pending_claim_ids.get(processing_queue)
+            pending = self._pending_claim_ids.get(processing_queue)
+            if pending:
+                self._last_drain_error = last_error
+            return not pending

{redis_message_queue-8.0.3 → redis_message_queue-8.1.0}/redis_message_queue/_stored_message.py

@@ -8,6 +8,7 @@ MessageData = str | bytes
 
 _STORED_MESSAGE_PREFIX = "\x1eRMQ1:"
 _STORED_MESSAGE_PREFIX_BYTES = _STORED_MESSAGE_PREFIX.encode("utf-8")
+_NON_ENVELOPE_STRICT_ERROR = "value does not start with RMQ envelope prefix; expected an rmq-published message"
 
 
 @dataclass(frozen=True)
@@ -43,7 +44,7 @@ def encode_stored_message(message: str) -> str:
     return f"{_STORED_MESSAGE_PREFIX}{json.dumps(envelope, separators=(',', ':'))}"
 
 
-def decode_stored_message(message: MessageData) -> MessageData:
+def decode_stored_message(message: MessageData, *, strict_envelope_decoding: bool = False) -> MessageData:
     """Strip the stored-message envelope and return the original payload.
 
     Designed to consume values produced by ``encode_stored_message`` only.
@@ -55,9 +56,11 @@ def decode_stored_message(message: MessageData) -> MessageData:
     custom gateways feeding raw input must wrap before decoding.
 
     Raises ``MalformedStoredMessageError`` when the value starts with the RMQ
-    envelope prefix but is not a valid payload-bearing envelope.
+    envelope prefix but is not a valid payload-bearing envelope. When
+    ``strict_envelope_decoding=True``, also raises for values that do not start
+    with the RMQ envelope prefix.
     """
-    envelope = _decode_envelope(message)
+    envelope = _decode_envelope(message, strict_envelope_decoding=strict_envelope_decoding)
     if envelope is None:
         return message
     _message_id, payload = envelope
@@ -66,22 +69,26 @@ def decode_stored_message(message: MessageData) -> MessageData:
     return payload
 
 
-def extract_stored_message_id(message: MessageData) -> str | None:
+def extract_stored_message_id(message: MessageData, *, strict_envelope_decoding: bool = False) -> str | None:
     """Return the RMQ envelope id, or None for values that are not RMQ envelopes.
 
     Raises ``MalformedStoredMessageError`` when the value starts with the RMQ
-    envelope prefix but is not a valid payload-bearing envelope.
+    envelope prefix but is not a valid payload-bearing envelope. When
+    ``strict_envelope_decoding=True``, also raises for values that do not start
+    with the RMQ envelope prefix.
     """
-    envelope = _decode_envelope(message)
+    envelope = _decode_envelope(message, strict_envelope_decoding=strict_envelope_decoding)
     if envelope is None:
         return None
     message_id, _payload = envelope
     return message_id
 
 
-def _decode_envelope(message: MessageData) -> tuple[str, str] | None:
+def _decode_envelope(message: MessageData, *, strict_envelope_decoding: bool = False) -> tuple[str, str] | None:
     if isinstance(message, bytes):
         if not message.startswith(_STORED_MESSAGE_PREFIX_BYTES):
+            if strict_envelope_decoding:
+                raise MalformedStoredMessageError(_NON_ENVELOPE_STRICT_ERROR)
             return None
         try:
             message = message.decode("utf-8")
@@ -90,6 +97,8 @@ def _decode_envelope(message: MessageData) -> tuple[str, str] | None:
                 "Stored message starts with the RMQ envelope prefix but is not valid UTF-8"
             ) from exc
     elif not message.startswith(_STORED_MESSAGE_PREFIX):
+        if strict_envelope_decoding:
+            raise MalformedStoredMessageError(_NON_ENVELOPE_STRICT_ERROR)
         return None
 
     envelope_body = message[len(_STORED_MESSAGE_PREFIX) :]

{redis_message_queue-8.0.3 → redis_message_queue-8.1.0}/redis_message_queue/asyncio/__init__.py

@@ -2,6 +2,7 @@ from redis_message_queue._event import EventOperation, EventOutcome, QueueEvent
 from redis_message_queue._exceptions import (
     CleanupFailedError,
     ConfigurationError,
+    DrainFailedError,
     GatewayContractError,
     LuaScriptError,
     MalformedStoredMessageError,
@@ -14,7 +15,11 @@ from redis_message_queue._stored_message import ClaimedMessage, MessageData
 from redis_message_queue.asyncio._abstract_redis_gateway import AbstractRedisGateway
 from redis_message_queue.asyncio._redis_gateway import RedisGateway
 from redis_message_queue.asyncio.redis_message_queue import RedisMessageQueue
-from redis_message_queue.interrupt_handler import BaseGracefulInterruptHandler, GracefulInterruptHandler
+from redis_message_queue.interrupt_handler import (
+    BaseGracefulInterruptHandler,
+    EventDrivenInterruptHandler,
+    GracefulInterruptHandler,
+)
 
 __all__ = [
     "RedisMessageQueue",
@@ -22,6 +27,7 @@ __all__ = [
     "AbstractRedisGateway",
     "ClaimedMessage",
     "MessageData",
+    "EventDrivenInterruptHandler",
     "GracefulInterruptHandler",
     "BaseGracefulInterruptHandler",
     "QueueEvent",
@@ -29,6 +35,7 @@ __all__ = [
     "EventOutcome",
     "RedisMessageQueueError",
     "ConfigurationError",
+    "DrainFailedError",
     "GatewayContractError",
     "LuaScriptError",
     "MalformedStoredMessageError",