fix: suppress IN_MEMORY_SORTING and ZERO_FILTER astrapy warnings on video listing

Adds `suppress_astrapy_warnings` context manager to `db_helpers.py` and
applies it around the `find()` call in `list_videos_with_query()` to silence
pre-existing performance-advisory warnings that astrapy emits when listing
all videos without a partition key filter. Documented in GitHub issue #21.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: pmcfadin

app/services/video_service.py

@@ -479,19 +479,23 @@ async def list_videos_with_query(
         span.set_attribute("page", page)
         span.set_attribute("page_size", page_size)
 
-        cursor = db_table.find(
-            filter=query_filter, skip=skip, limit=page_size, sort=sort_options
-        )
+        from app.utils.db_helpers import safe_count, suppress_astrapy_warnings
+
+        with suppress_astrapy_warnings(
+            "ZERO_FILTER_OPERATIONS",
+            "IN_MEMORY_SORTING",
+        ):
+            cursor = db_table.find(
+                filter=query_filter, skip=skip, limit=page_size, sort=sort_options
+            )
 
-        docs: List[Dict[str, Any]] = []
-        if hasattr(cursor, "to_list"):
-            docs = await cursor.to_list()
-        else:  # Stub collection path
-            docs = cursor  # type: ignore[assignment]
+            docs: List[Dict[str, Any]] = []
+            if hasattr(cursor, "to_list"):
+                docs = await cursor.to_list()
+            else:  # Stub collection path
+                docs = cursor  # type: ignore[assignment]
 
         # Use helper that gracefully degrades on tables
-        from app.utils.db_helpers import safe_count
-
         total_items = await safe_count(
             db_table,
             query_filter=query_filter,

app/utils/db_helpers.py

@@ -14,25 +14,32 @@
 """
 
 import logging
-from typing import Any, Dict
+from contextlib import contextmanager
+from typing import Any, Dict, Iterator
 
 from astrapy.exceptions.data_api_exceptions import DataAPIResponseException  # type: ignore
 
-__all__ = ["safe_count"]
+__all__ = ["safe_count", "suppress_astrapy_warnings"]
 
 _ASTRAPY_LOGGER = logging.getLogger("astrapy.utils.api_commander")
 
 
-class _SuppressUnsupportedTableCommand(logging.Filter):
-    """Drop UNSUPPORTED_TABLE_COMMAND WARNING records from the astrapy logger.
+class _SuppressAstrapyWarnings(logging.Filter):
+    """Drop WARNING records whose message contains any of the given substrings.
 
-    astrapy emits a WARNING before raising DataAPIResponseException.  For the
-    expected case of ``countDocuments`` on a CQL table we catch and handle the
-    exception ourselves, so the warning is noise rather than signal.
+    astrapy emits WARNINGs for certain operations that we handle or expect
+    (e.g. ``UNSUPPORTED_TABLE_COMMAND`` on tables, ``ZERO_FILTER_OPERATIONS``
+    for unfiltered queries).  This filter suppresses only the specified codes
+    so legitimate warnings still surface.
     """
 
+    def __init__(self, substrings: frozenset[str]) -> None:
+        super().__init__()
+        self._substrings = substrings
+
     def filter(self, record: logging.LogRecord) -> bool:
-        return "UNSUPPORTED_TABLE_COMMAND" not in record.getMessage()
+        msg = record.getMessage()
+        return not any(s in msg for s in self._substrings)
 
 
 async def safe_count(
@@ -48,7 +55,7 @@ async def safe_count(
     an exception.  The same applies to stub collections used in unit-tests.
     """
 
-    _filter = _SuppressUnsupportedTableCommand()
+    _filter = _SuppressAstrapyWarnings(frozenset({"UNSUPPORTED_TABLE_COMMAND"}))
     _ASTRAPY_LOGGER.addFilter(_filter)
     try:
         return await db_table.count_documents(filter=query_filter, upper_bound=10**9)
@@ -61,3 +68,21 @@ async def safe_count(
         return fallback_len
     finally:
         _ASTRAPY_LOGGER.removeFilter(_filter)
+
+
+@contextmanager
+def suppress_astrapy_warnings(*warning_codes: str) -> Iterator[None]:
+    """Temporarily suppress astrapy warnings matching any of *warning_codes*.
+
+    Usage::
+
+        with suppress_astrapy_warnings("ZERO_FILTER_OPERATIONS", "IN_MEMORY_SORTING"):
+            cursor = db_table.find(...)
+            docs = await cursor.to_list()
+    """
+    _filter = _SuppressAstrapyWarnings(frozenset(warning_codes))
+    _ASTRAPY_LOGGER.addFilter(_filter)
+    try:
+        yield
+    finally:
+        _ASTRAPY_LOGGER.removeFilter(_filter)

tests/utils/test_db_helpers.py

@@ -9,7 +9,7 @@
 
 from astrapy.exceptions.data_api_exceptions import DataAPIResponseException  # type: ignore[import]
 
-from app.utils.db_helpers import safe_count
+from app.utils.db_helpers import safe_count, suppress_astrapy_warnings
 
 _ASTRAPY_LOGGER = "astrapy.utils.api_commander"
 
@@ -96,3 +96,52 @@ async def _fake_count_documents(*args, **kwargs):
     assert unsupported_warnings == [], (
         "safe_count should suppress astrapy's UNSUPPORTED_TABLE_COMMAND warning"
     )
+
+
+# ---------------------------------------------------------------------------
+# suppress_astrapy_warnings context manager
+# ---------------------------------------------------------------------------
+
+
+def test_suppress_astrapy_warnings_suppresses_matching_codes(caplog):
+    """Warnings matching any of the specified codes are suppressed."""
+    astrapy_logger = logging.getLogger(_ASTRAPY_LOGGER)
+
+    with caplog.at_level(logging.WARNING, logger=_ASTRAPY_LOGGER):
+        with suppress_astrapy_warnings("ZERO_FILTER_OPERATIONS", "IN_MEMORY_SORTING"):
+            astrapy_logger.warning("ZERO_FILTER_OPERATIONS on table videos")
+            astrapy_logger.warning("IN_MEMORY_SORTING due to non-partition key")
+
+    matching = [
+        r for r in caplog.records
+        if ("ZERO_FILTER_OPERATIONS" in r.getMessage()
+            or "IN_MEMORY_SORTING" in r.getMessage())
+        and r.levelno >= logging.WARNING
+    ]
+    assert matching == [], "suppress_astrapy_warnings should suppress matching warnings"
+
+
+def test_suppress_astrapy_warnings_passes_unrelated_warnings(caplog):
+    """Warnings that don't match any specified code still appear."""
+    astrapy_logger = logging.getLogger(_ASTRAPY_LOGGER)
+
+    with caplog.at_level(logging.WARNING, logger=_ASTRAPY_LOGGER):
+        with suppress_astrapy_warnings("ZERO_FILTER_OPERATIONS"):
+            astrapy_logger.warning("SOMETHING_ELSE happened")
+
+    unrelated = [
+        r for r in caplog.records
+        if "SOMETHING_ELSE" in r.getMessage()
+    ]
+    assert len(unrelated) == 1, "Unrelated warnings must not be suppressed"
+
+
+def test_suppress_astrapy_warnings_removes_filter_after_exit():
+    """The filter is removed from the logger when the context exits."""
+    astrapy_logger = logging.getLogger(_ASTRAPY_LOGGER)
+    baseline = len(astrapy_logger.filters)
+
+    with suppress_astrapy_warnings("ZERO_FILTER_OPERATIONS"):
+        assert len(astrapy_logger.filters) == baseline + 1
+
+    assert len(astrapy_logger.filters) == baseline