matrix-synapse 1.139.0rc2__cp39-abi3-musllinux_1_2_aarch64.whl → 1.140.0rc1__cp39-abi3-musllinux_1_2_aarch64.whl

synapse/storage/databases/main/registration.py

@@ -212,7 +212,7 @@ class RegistrationWorkerStore(StatsStore, CacheInvalidationWorkerStore):
             )
 
             if hs.config.worker.run_background_tasks:
-                self._clock.call_later(
+                self.clock.call_later(
                     0.0,
                     self._set_expiration_date_when_missing,
                 )
@@ -226,7 +226,7 @@ class RegistrationWorkerStore(StatsStore, CacheInvalidationWorkerStore):
 
         # Create a background job for culling expired 3PID validity tokens
         if hs.config.worker.run_background_tasks:
-            self._clock.looping_call(
+            self.clock.looping_call(
                 self.cull_expired_threepid_validation_tokens, THIRTY_MINUTES_IN_MS
             )
 
@@ -298,7 +298,7 @@ class RegistrationWorkerStore(StatsStore, CacheInvalidationWorkerStore):
     ) -> None:
         user_id_obj = UserID.from_string(user_id)
 
-        now = int(self._clock.time())
+        now = int(self.clock.time())
 
         user_approved = approved or not self._require_approval
 
@@ -457,7 +457,7 @@ class RegistrationWorkerStore(StatsStore, CacheInvalidationWorkerStore):
         if not info:
             return False
 
-        now = self._clock.time_msec()
+        now = self.clock.time_msec()
         days = self.config.server.mau_appservice_trial_days.get(
             info.appservice_id, self.config.server.mau_trial_days
         )
@@ -640,7 +640,7 @@ class RegistrationWorkerStore(StatsStore, CacheInvalidationWorkerStore):
         return await self.db_pool.runInteraction(
             "get_users_expiring_soon",
             select_users_txn,
-            self._clock.time_msec(),
+            self.clock.time_msec(),
             self.config.account_validity.account_validity_renew_at,
         )
 
@@ -1084,7 +1084,7 @@ class RegistrationWorkerStore(StatsStore, CacheInvalidationWorkerStore):
         """
 
         def _count_daily_user_type(txn: LoggingTransaction) -> Dict[str, int]:
-            yesterday = int(self._clock.time()) - (60 * 60 * 24)
+            yesterday = int(self.clock.time()) - (60 * 60 * 24)
 
             sql = """
                 SELECT user_type, COUNT(*) AS count FROM (
@@ -1496,7 +1496,7 @@ class RegistrationWorkerStore(StatsStore, CacheInvalidationWorkerStore):
         await self.db_pool.runInteraction(
             "cull_expired_threepid_validation_tokens",
             cull_expired_threepid_validation_tokens_txn,
-            self._clock.time_msec(),
+            self.clock.time_msec(),
         )
 
     @wrap_as_background_process("account_validity_set_expiration_dates")
@@ -1537,7 +1537,7 @@ class RegistrationWorkerStore(StatsStore, CacheInvalidationWorkerStore):
                 random value in the [now + period - d ; now + period] range, d being a
                 delta equal to 10% of the validity period.
         """
-        now_ms = self._clock.time_msec()
+        now_ms = self.clock.time_msec()
         assert self._account_validity_period is not None
         expiration_ts = now_ms + self._account_validity_period
 
@@ -1608,7 +1608,7 @@ class RegistrationWorkerStore(StatsStore, CacheInvalidationWorkerStore):
         Raises:
             StoreError if there was a problem updating this.
         """
-        now = self._clock.time_msec()
+        now = self.clock.time_msec()
 
         await self.db_pool.simple_update_one(
             "access_tokens",
@@ -1639,7 +1639,7 @@ class RegistrationWorkerStore(StatsStore, CacheInvalidationWorkerStore):
         uses_allowed, pending, completed, expiry_time = res
 
         # Check if the token has expired
-        now = self._clock.time_msec()
+        now = self.clock.time_msec()
         if expiry_time and expiry_time < now:
             return False
 
@@ -1771,7 +1771,7 @@ class RegistrationWorkerStore(StatsStore, CacheInvalidationWorkerStore):
         return await self.db_pool.runInteraction(
             "select_registration_tokens",
             select_registration_tokens_txn,
-            self._clock.time_msec(),
+            self.clock.time_msec(),
             valid,
         )
 
@@ -2251,7 +2251,7 @@ class RegistrationWorkerStore(StatsStore, CacheInvalidationWorkerStore):
             "consume_login_token",
             self._consume_login_token,
             token,
-            self._clock.time_msec(),
+            self.clock.time_msec(),
         )
 
     async def invalidate_login_tokens_by_session_id(
@@ -2271,7 +2271,7 @@ class RegistrationWorkerStore(StatsStore, CacheInvalidationWorkerStore):
                 "auth_provider_id": auth_provider_id,
                 "auth_provider_session_id": auth_provider_session_id,
             },
-            updatevalues={"used_ts": self._clock.time_msec()},
+            updatevalues={"used_ts": self.clock.time_msec()},
             desc="invalidate_login_tokens_by_session_id",
         )
 
@@ -2640,7 +2640,6 @@ class RegistrationBackgroundUpdateStore(RegistrationWorkerStore):
     ):
         super().__init__(database, db_conn, hs)
 
-        self._clock = hs.get_clock()
         self.config = hs.config
 
         self.db_pool.updates.register_background_index_update(
@@ -2761,7 +2760,7 @@ class RegistrationStore(RegistrationBackgroundUpdateStore):
 
         # Create a background job for removing expired login tokens
         if hs.config.worker.run_background_tasks:
-            self._clock.looping_call(
+            self.clock.looping_call(
                 self._delete_expired_login_tokens, THIRTY_MINUTES_IN_MS
             )
 
@@ -2790,7 +2789,7 @@ class RegistrationStore(RegistrationBackgroundUpdateStore):
             The token ID
         """
         next_id = self._access_tokens_id_gen.get_next()
-        now = self._clock.time_msec()
+        now = self.clock.time_msec()
 
         await self.db_pool.simple_insert(
             "access_tokens",
@@ -2874,7 +2873,7 @@ class RegistrationStore(RegistrationBackgroundUpdateStore):
                 keyvalues={"name": user_id},
                 updatevalues={
                     "consent_version": consent_version,
-                    "consent_ts": self._clock.time_msec(),
+                    "consent_ts": self.clock.time_msec(),
                 },
             )
             self._invalidate_cache_and_stream(txn, self.get_user_by_id, (user_id,))
@@ -2986,7 +2985,7 @@ class RegistrationStore(RegistrationBackgroundUpdateStore):
                 txn,
                 table="threepid_validation_session",
                 keyvalues={"session_id": session_id},
-                updatevalues={"validated_at": self._clock.time_msec()},
+                updatevalues={"validated_at": self.clock.time_msec()},
             )
 
             return next_link
@@ -3064,7 +3063,7 @@ class RegistrationStore(RegistrationBackgroundUpdateStore):
 
         # We keep the expired tokens for an extra 5 minutes so we can measure how many
         # times a token is being used after its expiry
-        now = self._clock.time_msec()
+        now = self.clock.time_msec()
         await self.db_pool.runInteraction(
             "delete_expired_login_tokens",
             _delete_expired_login_tokens_txn,

synapse/storage/databases/main/roommember.py

@@ -1002,7 +1002,7 @@ class RoomMemberWorkerStore(EventsWorkerStore, CacheInvalidationWorkerStore):
         """
 
         with Measure(
-            self._clock,
+            self.clock,
             name="get_joined_user_ids_from_state",
             server_name=self.server_name,
         ):

synapse/storage/databases/main/session.py

@@ -55,7 +55,7 @@ class SessionStore(SQLBaseStore):
 
         # Create a background job for culling expired sessions.
         if hs.config.worker.run_background_tasks:
-            self._clock.looping_call(self._delete_expired_sessions, 30 * 60 * 1000)
+            self.clock.looping_call(self._delete_expired_sessions, 30 * 60 * 1000)
 
     async def create_session(
         self, session_type: str, value: JsonDict, expiry_ms: int
@@ -133,7 +133,7 @@ class SessionStore(SQLBaseStore):
             _get_session,
             session_type,
             session_id,
-            self._clock.time_msec(),
+            self.clock.time_msec(),
         )
 
     @wrap_as_background_process("delete_expired_sessions")
@@ -147,5 +147,5 @@ class SessionStore(SQLBaseStore):
         await self.db_pool.runInteraction(
             "delete_expired_sessions",
             _delete_expired_sessions_txn,
-            self._clock.time_msec(),
+            self.clock.time_msec(),
         )

synapse/storage/databases/main/sliding_sync.py

@@ -201,7 +201,7 @@ class SlidingSyncStore(SQLBaseStore):
                     "user_id": user_id,
                     "effective_device_id": device_id,
                     "conn_id": conn_id,
-                    "created_ts": self._clock.time_msec(),
+                    "created_ts": self.clock.time_msec(),
                 },
                 returning=("connection_key",),
             )
@@ -212,7 +212,7 @@ class SlidingSyncStore(SQLBaseStore):
             table="sliding_sync_connection_positions",
             values={
                 "connection_key": connection_key,
-                "created_ts": self._clock.time_msec(),
+                "created_ts": self.clock.time_msec(),
             },
             returning=("connection_position",),
         )

synapse/storage/databases/main/transactions.py

@@ -81,11 +81,11 @@ class TransactionWorkerStore(CacheInvalidationWorkerStore):
         super().__init__(database, db_conn, hs)
 
         if hs.config.worker.run_background_tasks:
-            self._clock.looping_call(self._cleanup_transactions, 30 * 60 * 1000)
+            self.clock.looping_call(self._cleanup_transactions, 30 * 60 * 1000)
 
     @wrap_as_background_process("cleanup_transactions")
     async def _cleanup_transactions(self) -> None:
-        now = self._clock.time_msec()
+        now = self.clock.time_msec()
         day_ago = now - 24 * 60 * 60 * 1000
 
         def _cleanup_transactions_txn(txn: LoggingTransaction) -> None:
@@ -160,7 +160,7 @@ class TransactionWorkerStore(CacheInvalidationWorkerStore):
             insertion_values={
                 "response_code": code,
                 "response_json": db_binary_type(encode_canonical_json(response_dict)),
-                "ts": self._clock.time_msec(),
+                "ts": self.clock.time_msec(),
             },
             desc="set_received_txn_response",
         )

synapse/storage/databases/state/store.py

@@ -125,6 +125,7 @@ class StateGroupDataStore(StateBackgroundUpdateStore, SQLBaseStore):
 
         self._state_group_cache: DictionaryCache[int, StateKey, str] = DictionaryCache(
             name="*stateGroupCache*",
+            clock=hs.get_clock(),
             server_name=self.server_name,
             # TODO: this hasn't been tuned yet
             max_entries=50000,
@@ -132,6 +133,7 @@ class StateGroupDataStore(StateBackgroundUpdateStore, SQLBaseStore):
         self._state_group_members_cache: DictionaryCache[int, StateKey, str] = (
             DictionaryCache(
                 name="*stateGroupMembersCache*",
+                clock=hs.get_clock(),
                 server_name=self.server_name,
                 max_entries=500000,
             )

synapse/synapse_rust/http_client.pyi

@@ -17,6 +17,10 @@ from twisted.internet.defer import Deferred
 from synapse.types import ISynapseReactor
 
 class HttpClient:
+    """
+    The returned deferreds follow Synapse logcontext rules.
+    """
+
     def __init__(self, reactor: ISynapseReactor, user_agent: str) -> None: ...
     def get(self, url: str, response_limit: int) -> Deferred[bytes]: ...
     def post(

synapse/util/async_helpers.py

@@ -47,7 +47,6 @@ from typing import (
     Tuple,
     TypeVar,
     Union,
-    cast,
     overload,
 )
 
@@ -56,7 +55,6 @@ from typing_extensions import Concatenate, ParamSpec, Unpack
 
 from twisted.internet import defer
 from twisted.internet.defer import CancelledError
-from twisted.internet.interfaces import IReactorTime
 from twisted.python.failure import Failure
 
 from synapse.logging.context import (
@@ -65,7 +63,6 @@ from synapse.logging.context import (
     run_coroutine_in_background,
     run_in_background,
 )
-from synapse.types import ISynapseThreadlessReactor
 from synapse.util.clock import Clock
 
 logger = logging.getLogger(__name__)
@@ -551,25 +548,19 @@ class Linearizer:
 
     def __init__(
         self,
-        name: Optional[str] = None,
+        name: str,
+        clock: Clock,
         max_count: int = 1,
-        clock: Optional[Clock] = None,
     ):
         """
         Args:
+            name: TODO
             max_count: The maximum number of concurrent accesses
+            clock: (ideally, the homeserver clock `hs.get_clock()`)
         """
-        if name is None:
-            self.name: Union[str, int] = id(self)
-        else:
-            self.name = name
-
-        if not clock:
-            from twisted.internet import reactor
-
-            clock = Clock(cast(ISynapseThreadlessReactor, reactor))
-        self._clock = clock
+        self.name = name
         self.max_count = max_count
+        self._clock = clock
 
         # key_to_defer is a map from the key to a _LinearizerEntry.
         self.key_to_defer: Dict[Hashable, _LinearizerEntry] = {}
@@ -779,7 +770,11 @@ class ReadWriteLock:
 
 
 def timeout_deferred(
-    deferred: "defer.Deferred[_T]", timeout: float, reactor: IReactorTime
+    *,
+    deferred: "defer.Deferred[_T]",
+    timeout: float,
+    cancel_on_shutdown: bool = True,
+    clock: Clock,
 ) -> "defer.Deferred[_T]":
     """The in built twisted `Deferred.addTimeout` fails to time out deferreds
     that have a canceller that throws exceptions. This method creates a new
@@ -797,7 +792,13 @@ def timeout_deferred(
     Args:
         deferred: The Deferred to potentially timeout.
         timeout: Timeout in seconds
-        reactor: The twisted reactor to use
+        cancel_on_shutdown: Whether this call should be tracked for cleanup during
+            shutdown. In general, all calls should be tracked. There may be a use case
+            not to track calls with a `timeout` of 0 (or similarly short) since tracking
+            them may result in rapid insertions and removals of tracked calls
+            unnecessarily. But unless a specific instance of tracking proves to be an
+            issue, we can just track all delayed calls.
+        clock: The `Clock` instance used to track delayed calls.
 
 
     Returns:
@@ -821,7 +822,10 @@ def timeout_deferred(
         if not new_d.called:
             new_d.errback(defer.TimeoutError("Timed out after %gs" % (timeout,)))
 
-    delayed_call = reactor.callLater(timeout, time_it_out)
+    # We don't track these calls since they are short.
+    delayed_call = clock.call_later(
+        timeout, time_it_out, call_later_cancel_on_shutdown=cancel_on_shutdown
+    )
 
     def convert_cancelled(value: Failure) -> Failure:
         # if the original deferred was cancelled, and our timeout has fired, then
@@ -963,9 +967,9 @@ class AwakenableSleeper:
     currently sleeping.
     """
 
-    def __init__(self, reactor: IReactorTime) -> None:
+    def __init__(self, clock: Clock) -> None:
         self._streams: Dict[str, Set[defer.Deferred[None]]] = {}
-        self._reactor = reactor
+        self._clock = clock
 
     def wake(self, name: str) -> None:
         """Wake everything related to `name` that is currently sleeping."""
@@ -984,7 +988,11 @@ class AwakenableSleeper:
 
         # Create a deferred that gets called in N seconds
         sleep_deferred: "defer.Deferred[None]" = defer.Deferred()
-        call = self._reactor.callLater(delay_ms / 1000, sleep_deferred.callback, None)
+        call = self._clock.call_later(
+            delay_ms / 1000,
+            sleep_deferred.callback,
+            None,
+        )
 
         # Create a deferred that will get called if `wake` is called with
         # the same `name`.
@@ -1018,8 +1026,8 @@ class AwakenableSleeper:
 class DeferredEvent:
     """Like threading.Event but for async code"""
 
-    def __init__(self, reactor: IReactorTime) -> None:
-        self._reactor = reactor
+    def __init__(self, clock: Clock) -> None:
+        self._clock = clock
         self._deferred: "defer.Deferred[None]" = defer.Deferred()
 
     def set(self) -> None:
@@ -1039,7 +1047,11 @@ class DeferredEvent:
 
         # Create a deferred that gets called in N seconds
         sleep_deferred: "defer.Deferred[None]" = defer.Deferred()
-        call = self._reactor.callLater(timeout_seconds, sleep_deferred.callback, None)
+        call = self._clock.call_later(
+            timeout_seconds,
+            sleep_deferred.callback,
+            None,
+        )
 
         try:
             await make_deferred_yieldable(

synapse/util/batching_queue.py

@@ -21,6 +21,7 @@
 
 import logging
 from typing import (
+    TYPE_CHECKING,
     Awaitable,
     Callable,
     Dict,
@@ -38,9 +39,11 @@ from twisted.internet import defer
 
 from synapse.logging.context import PreserveLoggingContext, make_deferred_yieldable
 from synapse.metrics import SERVER_NAME_LABEL
-from synapse.metrics.background_process_metrics import run_as_background_process
 from synapse.util.clock import Clock
 
+if TYPE_CHECKING:
+    from synapse.server import HomeServer
+
 logger = logging.getLogger(__name__)
 
 
@@ -97,12 +100,13 @@ class BatchingQueue(Generic[V, R]):
         self,
         *,
         name: str,
-        server_name: str,
+        hs: "HomeServer",
         clock: Clock,
         process_batch_callback: Callable[[List[V]], Awaitable[R]],
     ):
         self._name = name
-        self.server_name = server_name
+        self.hs = hs
+        self.server_name = hs.hostname
         self._clock = clock
 
         # The set of keys currently being processed.
@@ -127,6 +131,14 @@ class BatchingQueue(Generic[V, R]):
             name=self._name, **{SERVER_NAME_LABEL: self.server_name}
         )
 
+    def shutdown(self) -> None:
+        """
+        Prepares the object for garbage collection by removing any handed out
+        references.
+        """
+        number_queued.remove(self._name, self.server_name)
+        number_of_keys.remove(self._name, self.server_name)
+
     async def add_to_queue(self, value: V, key: Hashable = ()) -> R:
         """Adds the value to the queue with the given key, returning the result
         of the processing function for the batch that included the given value.
@@ -145,9 +157,7 @@ class BatchingQueue(Generic[V, R]):
         # If we're not currently processing the key fire off a background
         # process to start processing.
         if key not in self._processing_keys:
-            run_as_background_process(
-                self._name, self.server_name, self._process_queue, key
-            )
+            self.hs.run_as_background_process(self._name, self._process_queue, key)
 
         with self._number_in_flight_metric.track_inprogress():
             return await make_deferred_yieldable(d)

synapse/util/caches/__init__.py

@@ -244,7 +244,7 @@ def register_cache(
         collect_callback=collect_callback,
     )
     metric_name = "cache_%s_%s_%s" % (cache_type, cache_name, server_name)
-    CACHE_METRIC_REGISTRY.register_hook(metric_name, metric.collect)
+    CACHE_METRIC_REGISTRY.register_hook(server_name, metric_name, metric.collect)
     return metric
 
 

synapse/util/caches/deferred_cache.py

@@ -47,6 +47,7 @@ from synapse.metrics import SERVER_NAME_LABEL
 from synapse.util.async_helpers import ObservableDeferred
 from synapse.util.caches.lrucache import LruCache
 from synapse.util.caches.treecache import TreeCache, iterate_tree_cache_entry
+from synapse.util.clock import Clock
 
 cache_pending_metric = Gauge(
     "synapse_util_caches_cache_pending",
@@ -82,6 +83,7 @@ class DeferredCache(Generic[KT, VT]):
         self,
         *,
         name: str,
+        clock: Clock,
         server_name: str,
         max_entries: int = 1000,
         tree: bool = False,
@@ -103,6 +105,7 @@ class DeferredCache(Generic[KT, VT]):
             prune_unread_entries: If True, cache entries that haven't been read recently
                 will be evicted from the cache in the background. Set to False to
                 opt-out of this behaviour.
+            clock: The homeserver `Clock` instance
         """
         cache_type = TreeCache if tree else dict
 
@@ -120,6 +123,7 @@ class DeferredCache(Generic[KT, VT]):
         # a Deferred.
         self.cache: LruCache[KT, VT] = LruCache(
             max_size=max_entries,
+            clock=clock,
             server_name=server_name,
             cache_name=name,
             cache_type=cache_type,

synapse/util/caches/descriptors.py

@@ -53,6 +53,7 @@ from synapse.util import unwrapFirstError
 from synapse.util.async_helpers import delay_cancellation
 from synapse.util.caches.deferred_cache import DeferredCache
 from synapse.util.caches.lrucache import LruCache
+from synapse.util.clock import Clock
 
 logger = logging.getLogger(__name__)
 
@@ -154,13 +155,20 @@ class _CacheDescriptorBase:
         )
 
 
-class HasServerName(Protocol):
+class HasServerNameAndClock(Protocol):
     server_name: str
     """
     The homeserver name that this cache is associated with (used to label the metric)
     (`hs.hostname`).
     """
 
+    clock: Clock
+    """
+    The homeserver clock instance used to track delayed and looping calls. Important to
+    be able to fully cleanup the homeserver instance on server shutdown.
+    (`hs.get_clock()`).
+    """
+
 
 class DeferredCacheDescriptor(_CacheDescriptorBase):
     """A method decorator that applies a memoizing cache around the function.
@@ -239,7 +247,7 @@ class DeferredCacheDescriptor(_CacheDescriptorBase):
         self.prune_unread_entries = prune_unread_entries
 
     def __get__(
-        self, obj: Optional[HasServerName], owner: Optional[Type]
+        self, obj: Optional[HasServerNameAndClock], owner: Optional[Type]
     ) -> Callable[..., "defer.Deferred[Any]"]:
         # We need access to instance-level `obj.server_name` attribute
         assert obj is not None, (
@@ -249,9 +257,13 @@ class DeferredCacheDescriptor(_CacheDescriptorBase):
         assert obj.server_name is not None, (
             "The `server_name` attribute must be set on the object where `@cached` decorator is used."
         )
+        assert obj.clock is not None, (
+            "The `clock` attribute must be set on the object where `@cached` decorator is used."
+        )
 
         cache: DeferredCache[CacheKey, Any] = DeferredCache(
             name=self.name,
+            clock=obj.clock,
             server_name=obj.server_name,
             max_entries=self.max_entries,
             tree=self.tree,

synapse/util/caches/dictionary_cache.py

@@ -37,6 +37,7 @@ import attr
 
 from synapse.util.caches.lrucache import LruCache
 from synapse.util.caches.treecache import TreeCache
+from synapse.util.clock import Clock
 
 logger = logging.getLogger(__name__)
 
@@ -127,10 +128,13 @@ class DictionaryCache(Generic[KT, DKT, DV]):
     for the '2' dict key.
     """
 
-    def __init__(self, *, name: str, server_name: str, max_entries: int = 1000):
+    def __init__(
+        self, *, name: str, clock: Clock, server_name: str, max_entries: int = 1000
+    ):
         """
         Args:
             name
+            clock: The homeserver `Clock` instance
             server_name: The homeserver name that this cache is associated with
                 (used to label the metric) (`hs.hostname`).
             max_entries
@@ -160,6 +164,7 @@ class DictionaryCache(Generic[KT, DKT, DV]):
             Union[_PerKeyValue, Dict[DKT, DV]],
         ] = LruCache(
             max_size=max_entries,
+            clock=clock,
             server_name=server_name,
             cache_name=name,
             cache_type=TreeCache,

synapse/util/caches/expiringcache.py

@@ -21,17 +21,29 @@
 
 import logging
 from collections import OrderedDict
-from typing import Any, Generic, Iterable, Literal, Optional, TypeVar, Union, overload
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Generic,
+    Iterable,
+    Literal,
+    Optional,
+    TypeVar,
+    Union,
+    overload,
+)
 
 import attr
 
 from twisted.internet import defer
 
 from synapse.config import cache as cache_config
-from synapse.metrics.background_process_metrics import run_as_background_process
 from synapse.util.caches import EvictionReason, register_cache
 from synapse.util.clock import Clock
 
+if TYPE_CHECKING:
+    from synapse.server import HomeServer
+
 logger = logging.getLogger(__name__)
 
 
@@ -49,6 +61,7 @@ class ExpiringCache(Generic[KT, VT]):
         *,
         cache_name: str,
         server_name: str,
+        hs: "HomeServer",
         clock: Clock,
         max_len: int = 0,
         expiry_ms: int = 0,
@@ -99,9 +112,7 @@ class ExpiringCache(Generic[KT, VT]):
             return
 
         def f() -> "defer.Deferred[None]":
-            return run_as_background_process(
-                "prune_cache", server_name, self._prune_cache
-            )
+            return hs.run_as_background_process("prune_cache", self._prune_cache)
 
         self._clock.looping_call(f, self._expiry_ms / 2)