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

synapse/util/caches/lrucache.py

@@ -45,14 +45,10 @@ from typing import (
     overload,
 )
 
-from twisted.internet import defer, reactor
+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.metrics.jemalloc import get_jemalloc_stats
-from synapse.types import ISynapseThreadlessReactor
 from synapse.util import caches
 from synapse.util.caches import CacheMetric, EvictionReason, register_cache
 from synapse.util.caches.treecache import (
@@ -123,6 +119,7 @@ GLOBAL_ROOT = ListNode["_Node"].create_root_node()
 
 def _expire_old_entries(
     server_name: str,
+    hs: "HomeServer",
     clock: Clock,
     expiry_seconds: float,
     autotune_config: Optional[dict],
@@ -228,9 +225,8 @@ def _expire_old_entries(
 
         logger.info("Dropped %d items from caches", i)
 
-    return run_as_background_process(
+    return hs.run_as_background_process(
         "LruCache._expire_old_entries",
-        server_name,
         _internal_expire_old_entries,
         clock,
         expiry_seconds,
@@ -261,6 +257,7 @@ def setup_expire_lru_cache_entries(hs: "HomeServer") -> None:
         _expire_old_entries,
         30 * 1000,
         server_name,
+        hs,
         clock,
         expiry_time,
         hs.config.caches.cache_autotuning,
@@ -404,13 +401,13 @@ class LruCache(Generic[KT, VT]):
         self,
         *,
         max_size: int,
+        clock: Clock,
         server_name: str,
         cache_name: str,
         cache_type: Type[Union[dict, TreeCache]] = dict,
         size_callback: Optional[Callable[[VT], int]] = None,
         metrics_collection_callback: Optional[Callable[[], None]] = None,
         apply_cache_factor_from_config: bool = True,
-        clock: Optional[Clock] = None,
         prune_unread_entries: bool = True,
         extra_index_cb: Optional[Callable[[KT, VT], KT]] = None,
     ): ...
@@ -420,13 +417,13 @@ class LruCache(Generic[KT, VT]):
         self,
         *,
         max_size: int,
-        server_name: Literal[None] = None,
+        clock: Clock,
+        server_name: str,
         cache_name: Literal[None] = None,
         cache_type: Type[Union[dict, TreeCache]] = dict,
         size_callback: Optional[Callable[[VT], int]] = None,
         metrics_collection_callback: Optional[Callable[[], None]] = None,
         apply_cache_factor_from_config: bool = True,
-        clock: Optional[Clock] = None,
         prune_unread_entries: bool = True,
         extra_index_cb: Optional[Callable[[KT, VT], KT]] = None,
     ): ...
@@ -435,13 +432,13 @@ class LruCache(Generic[KT, VT]):
         self,
         *,
         max_size: int,
-        server_name: Optional[str] = None,
+        clock: Clock,
+        server_name: str,
         cache_name: Optional[str] = None,
         cache_type: Type[Union[dict, TreeCache]] = dict,
         size_callback: Optional[Callable[[VT], int]] = None,
         metrics_collection_callback: Optional[Callable[[], None]] = None,
         apply_cache_factor_from_config: bool = True,
-        clock: Optional[Clock] = None,
         prune_unread_entries: bool = True,
         extra_index_cb: Optional[Callable[[KT, VT], KT]] = None,
     ):
@@ -450,12 +447,10 @@ class LruCache(Generic[KT, VT]):
             max_size: The maximum amount of entries the cache can hold
 
             server_name: The homeserver name that this cache is associated with
-                (used to label the metric) (`hs.hostname`). Must be set if `cache_name` is
-                set. If unset, no metrics will be reported on this cache.
+                (used to label the metric) (`hs.hostname`).
 
-            cache_name: The name of this cache, for the prometheus metrics. Must be set
-                if `server_name` is set. If unset, no metrics will be reported on this
-                cache.
+            cache_name: The name of this cache, for the prometheus metrics. If unset, no
+                metrics will be reported on this cache.
 
             cache_type:
                 type of underlying cache to be used. Typically one of dict
@@ -494,13 +489,6 @@ class LruCache(Generic[KT, VT]):
 
                 Note: The new key does not have to be unique.
         """
-        # Default `clock` to something sensible. Note that we rename it to
-        # `real_clock` so that mypy doesn't think its still `Optional`.
-        if clock is None:
-            real_clock = Clock(cast(ISynapseThreadlessReactor, reactor))
-        else:
-            real_clock = clock
-
         cache: Union[Dict[KT, _Node[KT, VT]], TreeCache] = cache_type()
         self.cache = cache  # Used for introspection.
         self.apply_cache_factor_from_config = apply_cache_factor_from_config
@@ -592,7 +580,7 @@ class LruCache(Generic[KT, VT]):
                 key,
                 value,
                 weak_ref_to_self,
-                real_clock,
+                clock,
                 callbacks,
                 prune_unread_entries,
             )
@@ -610,7 +598,7 @@ class LruCache(Generic[KT, VT]):
                 metrics.inc_memory_usage(node.memory)
 
         def move_node_to_front(node: _Node[KT, VT]) -> None:
-            node.move_to_front(real_clock, list_root)
+            node.move_to_front(clock, list_root)
 
         def delete_node(node: _Node[KT, VT]) -> int:
             node.drop_from_lists()

synapse/util/caches/response_cache.py

@@ -198,7 +198,17 @@ class ResponseCache(Generic[KV]):
             # the should_cache bit, we leave it in the cache for now and schedule
             # its removal later.
             if self.timeout_sec and context.should_cache:
-                self.clock.call_later(self.timeout_sec, self._entry_timeout, key)
+                self.clock.call_later(
+                    self.timeout_sec,
+                    self._entry_timeout,
+                    key,
+                    # We don't need to track these calls since they don't hold any strong
+                    # references which would keep the `HomeServer` in memory after shutdown.
+                    # We don't want to track these because they can get cancelled really
+                    # quickly and thrash the tracking mechanism, ie. during repeated calls
+                    # to /sync.
+                    call_later_cancel_on_shutdown=False,
+                )
             else:
                 # otherwise, remove the result immediately.
                 self.unset(key)

synapse/util/clock.py

@@ -17,10 +17,12 @@
 from typing import (
     Any,
     Callable,
+    Dict,
+    List,
 )
 
-import attr
 from typing_extensions import ParamSpec
+from zope.interface import implementer
 
 from twisted.internet import defer, task
 from twisted.internet.defer import Deferred
@@ -34,23 +36,54 @@ from synapse.util import log_failure
 P = ParamSpec("P")
 
 
-@attr.s(slots=True)
 class Clock:
     """
     A Clock wraps a Twisted reactor and provides utilities on top of it.
 
+    This clock should be used in place of calls to the base reactor wherever `LoopingCall`
+    or `DelayedCall` are made (such as when calling `reactor.callLater`. This is to
+    ensure the calls made by this `HomeServer` instance are tracked and can be cleaned
+    up during `HomeServer.shutdown()`.
+
+    We enforce usage of this clock instead of using the reactor directly via lints in
+    `scripts-dev/mypy_synapse_plugin.py`.
+
+
     Args:
         reactor: The Twisted reactor to use.
     """
 
-    _reactor: ISynapseThreadlessReactor = attr.ib()
+    _reactor: ISynapseThreadlessReactor
+
+    def __init__(self, reactor: ISynapseThreadlessReactor, server_name: str) -> None:
+        self._reactor = reactor
+        self._server_name = server_name
+
+        self._delayed_call_id: int = 0
+        """Unique ID used to track delayed calls"""
+
+        self._looping_calls: List[LoopingCall] = []
+        """List of active looping calls"""
+
+        self._call_id_to_delayed_call: Dict[int, IDelayedCall] = {}
+        """Mapping from unique call ID to delayed call"""
+
+        self._is_shutdown = False
+        """Whether shutdown has been requested by the HomeServer"""
+
+    def shutdown(self) -> None:
+        self._is_shutdown = True
+        self.cancel_all_looping_calls()
+        self.cancel_all_delayed_calls()
 
     async def sleep(self, seconds: float) -> None:
         d: defer.Deferred[float] = defer.Deferred()
         # Start task in the `sentinel` logcontext, to avoid leaking the current context
         # into the reactor once it finishes.
         with context.PreserveLoggingContext():
-            self._reactor.callLater(seconds, d.callback, seconds)
+            # We can ignore the lint here since this class is the one location callLater should
+            # be called.
+            self._reactor.callLater(seconds, d.callback, seconds)  # type: ignore[call-later-not-tracked]
             await d
 
     def time(self) -> float:
@@ -123,6 +156,9 @@ class Clock:
     ) -> LoopingCall:
         """Common functionality for `looping_call` and `looping_call_now`"""
 
+        if self._is_shutdown:
+            raise Exception("Cannot start looping call. Clock has been shutdown")
+
         def wrapped_f(*args: P.args, **kwargs: P.kwargs) -> Deferred:
             assert context.current_context() is context.SENTINEL_CONTEXT, (
                 "Expected `looping_call` callback from the reactor to start with the sentinel logcontext "
@@ -144,13 +180,19 @@ class Clock:
             # this function and yield control back to the reactor to avoid leaking the
             # current logcontext to the reactor (which would then get picked up and
             # associated with the next thing the reactor does)
-            with context.PreserveLoggingContext(context.LoggingContext("looping_call")):
+            with context.PreserveLoggingContext(
+                context.LoggingContext(
+                    name="looping_call", server_name=self._server_name
+                )
+            ):
                 # We use `run_in_background` to reset the logcontext after `f` (or the
                 # awaitable returned by `f`) completes to avoid leaking the current
                 # logcontext to the reactor
                 return context.run_in_background(f, *args, **kwargs)
 
-        call = task.LoopingCall(wrapped_f, *args, **kwargs)
+        # We can ignore the lint here since this is the one location LoopingCall's
+        # should be created.
+        call = task.LoopingCall(wrapped_f, *args, **kwargs)  # type: ignore[prefer-synapse-clock-looping-call]
         call.clock = self._reactor
         # If `now=true`, the function will be called here immediately so we need to be
         # in the sentinel context now.
@@ -160,10 +202,32 @@ class Clock:
         with context.PreserveLoggingContext():
             d = call.start(msec / 1000.0, now=now)
         d.addErrback(log_failure, "Looping call died", consumeErrors=False)
+        self._looping_calls.append(call)
         return call
 
+    def cancel_all_looping_calls(self, consumeErrors: bool = True) -> None:
+        """
+        Stop all running looping calls.
+
+        Args:
+            consumeErrors: Whether to re-raise errors encountered when cancelling the
+            scheduled call.
+        """
+        for call in self._looping_calls:
+            try:
+                call.stop()
+            except Exception:
+                if not consumeErrors:
+                    raise
+        self._looping_calls.clear()
+
     def call_later(
-        self, delay: float, callback: Callable, *args: Any, **kwargs: Any
+        self,
+        delay: float,
+        callback: Callable,
+        *args: Any,
+        call_later_cancel_on_shutdown: bool = True,
+        **kwargs: Any,
     ) -> IDelayedCall:
         """Call something later
 
@@ -175,37 +239,78 @@ class Clock:
             delay: How long to wait in seconds.
             callback: Function to call
             *args: Postional arguments to pass to function.
+            call_later_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.
             **kwargs: Key arguments to pass to function.
         """
 
-        def wrapped_callback(*args: Any, **kwargs: Any) -> None:
-            assert context.current_context() is context.SENTINEL_CONTEXT, (
-                "Expected `call_later` callback from the reactor to start with the sentinel logcontext "
-                f"but saw {context.current_context()}. In other words, another task shouldn't have "
-                "leaked their logcontext to us."
-            )
-
-            # Because this is a callback from the reactor, we will be using the
-            # `sentinel` log context at this point. We want the function to log with
-            # some logcontext as we want to know which server the logs came from.
-            #
-            # We use `PreserveLoggingContext` to prevent our new `call_later`
-            # logcontext from finishing as soon as we exit this function, in case `f`
-            # returns an awaitable/deferred which would continue running and may try to
-            # restore the `loop_call` context when it's done (because it's trying to
-            # adhere to the Synapse logcontext rules.)
-            #
-            # This also ensures that we return to the `sentinel` context when we exit
-            # this function and yield control back to the reactor to avoid leaking the
-            # current logcontext to the reactor (which would then get picked up and
-            # associated with the next thing the reactor does)
-            with context.PreserveLoggingContext(context.LoggingContext("call_later")):
-                # We use `run_in_background` to reset the logcontext after `f` (or the
-                # awaitable returned by `f`) completes to avoid leaking the current
-                # logcontext to the reactor
-                context.run_in_background(callback, *args, **kwargs)
-
-        return self._reactor.callLater(delay, wrapped_callback, *args, **kwargs)
+        if self._is_shutdown:
+            raise Exception("Cannot start delayed call. Clock has been shutdown")
+
+        def create_wrapped_callback(
+            track_for_shutdown_cancellation: bool,
+        ) -> Callable[P, None]:
+            def wrapped_callback(*args: Any, **kwargs: Any) -> None:
+                assert context.current_context() is context.SENTINEL_CONTEXT, (
+                    "Expected `call_later` callback from the reactor to start with the sentinel logcontext "
+                    f"but saw {context.current_context()}. In other words, another task shouldn't have "
+                    "leaked their logcontext to us."
+                )
+
+                # Because this is a callback from the reactor, we will be using the
+                # `sentinel` log context at this point. We want the function to log with
+                # some logcontext as we want to know which server the logs came from.
+                #
+                # We use `PreserveLoggingContext` to prevent our new `call_later`
+                # logcontext from finishing as soon as we exit this function, in case `f`
+                # returns an awaitable/deferred which would continue running and may try to
+                # restore the `loop_call` context when it's done (because it's trying to
+                # adhere to the Synapse logcontext rules.)
+                #
+                # This also ensures that we return to the `sentinel` context when we exit
+                # this function and yield control back to the reactor to avoid leaking the
+                # current logcontext to the reactor (which would then get picked up and
+                # associated with the next thing the reactor does)
+                try:
+                    with context.PreserveLoggingContext(
+                        context.LoggingContext(
+                            name="call_later", server_name=self._server_name
+                        )
+                    ):
+                        # We use `run_in_background` to reset the logcontext after `f` (or the
+                        # awaitable returned by `f`) completes to avoid leaking the current
+                        # logcontext to the reactor
+                        context.run_in_background(callback, *args, **kwargs)
+                finally:
+                    if track_for_shutdown_cancellation:
+                        # We still want to remove the call from the tracking map. Even if
+                        # the callback raises an exception.
+                        self._call_id_to_delayed_call.pop(call_id)
+
+            return wrapped_callback
+
+        if call_later_cancel_on_shutdown:
+            call_id = self._delayed_call_id
+            self._delayed_call_id = self._delayed_call_id + 1
+
+            # We can ignore the lint here since this class is the one location callLater
+            # should be called.
+            call = self._reactor.callLater(
+                delay, create_wrapped_callback(True), *args, **kwargs
+            )  # type: ignore[call-later-not-tracked]
+            call = DelayedCallWrapper(call, call_id, self)
+            self._call_id_to_delayed_call[call_id] = call
+            return call
+        else:
+            # We can ignore the lint here since this class is the one location callLater should
+            # be called.
+            return self._reactor.callLater(
+                delay, create_wrapped_callback(False), *args, **kwargs
+            )  # type: ignore[call-later-not-tracked]
 
     def cancel_call_later(self, timer: IDelayedCall, ignore_errs: bool = False) -> None:
         try:
@@ -214,6 +319,24 @@ class Clock:
             if not ignore_errs:
                 raise
 
+    def cancel_all_delayed_calls(self, ignore_errs: bool = True) -> None:
+        """
+        Stop all scheduled calls that were marked with `cancel_on_shutdown` when they were created.
+
+        Args:
+            ignore_errs: Whether to re-raise errors encountered when cancelling the
+            scheduled call.
+        """
+        # We make a copy here since calling `cancel()` on a delayed_call
+        # will result in the call removing itself from the map mid-iteration.
+        for call in list(self._call_id_to_delayed_call.values()):
+            try:
+                call.cancel()
+            except Exception:
+                if not ignore_errs:
+                    raise
+        self._call_id_to_delayed_call.clear()
+
     def call_when_running(
         self,
         callback: Callable[P, object],
@@ -258,7 +381,9 @@ class Clock:
             # current logcontext to the reactor (which would then get picked up and
             # associated with the next thing the reactor does)
             with context.PreserveLoggingContext(
-                context.LoggingContext("call_when_running")
+                context.LoggingContext(
+                    name="call_when_running", server_name=self._server_name
+                )
             ):
                 # We use `run_in_background` to reset the logcontext after `f` (or the
                 # awaitable returned by `f`) completes to avoid leaking the current
@@ -276,7 +401,7 @@ class Clock:
         callback: Callable[P, object],
         *args: P.args,
         **kwargs: P.kwargs,
-    ) -> None:
+    ) -> Any:
         """
         Add a function to be called when a system event occurs.
 
@@ -290,6 +415,9 @@ class Clock:
             callback: Function to call
             *args: Postional arguments to pass to function.
             **kwargs: Key arguments to pass to function.
+
+        Returns:
+            an ID that can be used to remove this call with `reactor.removeSystemEventTrigger`.
         """
 
         def wrapped_callback(*args: Any, **kwargs: Any) -> None:
@@ -313,7 +441,11 @@ class Clock:
             # this function and yield control back to the reactor to avoid leaking the
             # current logcontext to the reactor (which would then get picked up and
             # associated with the next thing the reactor does)
-            with context.PreserveLoggingContext(context.LoggingContext("system_event")):
+            with context.PreserveLoggingContext(
+                context.LoggingContext(
+                    name="system_event", server_name=self._server_name
+                )
+            ):
                 # We use `run_in_background` to reset the logcontext after `f` (or the
                 # awaitable returned by `f`) completes to avoid leaking the current
                 # logcontext to the reactor
@@ -321,6 +453,50 @@ class Clock:
 
         # We can ignore the lint here since this class is the one location
         # `addSystemEventTrigger` should be called.
-        self._reactor.addSystemEventTrigger(
+        return self._reactor.addSystemEventTrigger(
             phase, event_type, wrapped_callback, *args, **kwargs
         )  # type: ignore[prefer-synapse-clock-add-system-event-trigger]
+
+
+@implementer(IDelayedCall)
+class DelayedCallWrapper:
+    """Wraps an `IDelayedCall` so that we can intercept the call to `cancel()` and
+    properly cleanup the delayed call from the tracking map of the `Clock`.
+
+    args:
+        delayed_call: The actual `IDelayedCall`
+        call_id: Unique identifier for this delayed call
+        clock: The clock instance tracking this call
+    """
+
+    def __init__(self, delayed_call: IDelayedCall, call_id: int, clock: Clock):
+        self.delayed_call = delayed_call
+        self.call_id = call_id
+        self.clock = clock
+
+    def cancel(self) -> None:
+        """Remove the call from the tracking map and propagate the call to the
+        underlying delayed_call.
+        """
+        self.delayed_call.cancel()
+        try:
+            self.clock._call_id_to_delayed_call.pop(self.call_id)
+        except KeyError:
+            # If the delayed call isn't being tracked anymore we can just move on.
+            pass
+
+    def getTime(self) -> float:
+        """Propagate the call to the underlying delayed_call."""
+        return self.delayed_call.getTime()
+
+    def delay(self, secondsLater: float) -> None:
+        """Propagate the call to the underlying delayed_call."""
+        self.delayed_call.delay(secondsLater)
+
+    def reset(self, secondsFromNow: float) -> None:
+        """Propagate the call to the underlying delayed_call."""
+        self.delayed_call.reset(secondsFromNow)
+
+    def active(self) -> bool:
+        """Propagate the call to the underlying delayed_call."""
+        return self.delayed_call.active()

synapse/util/constants.py

@@ -18,3 +18,5 @@
 # readability and catching bugs.
 ONE_MINUTE_SECONDS = 60
 ONE_HOUR_SECONDS = 60 * ONE_MINUTE_SECONDS
+
+MILLISECONDS_PER_SECOND = 1000

synapse/util/daemonize.py

@@ -32,6 +32,7 @@ from typing import NoReturn, Optional, Type
 from synapse.logging.context import (
     LoggingContext,
     PreserveLoggingContext,
+    current_context,
 )
 
 
@@ -149,9 +150,12 @@ def daemonize_process(pid_file: str, logger: logging.Logger, chdir: str = "/") -
 
     signal.signal(signal.SIGTERM, sigterm)
 
+    # Copy the `server_name` from the current logcontext
+    server_name = current_context().server_name
+
     # Cleanup pid file at exit.
     def exit() -> None:
-        with LoggingContext("atexit"):
+        with LoggingContext(name="atexit", server_name=server_name):
             logger.warning("Stopping daemon.")
             os.remove(pid_file)
             sys.exit(0)

synapse/util/distributor.py

@@ -20,6 +20,7 @@
 #
 import logging
 from typing import (
+    TYPE_CHECKING,
     Any,
     Awaitable,
     Callable,
@@ -36,10 +37,13 @@ from typing_extensions import ParamSpec
 from twisted.internet import defer
 
 from synapse.logging.context import make_deferred_yieldable, run_in_background
-from synapse.metrics.background_process_metrics import run_as_background_process
 from synapse.types import UserID
 from synapse.util.async_helpers import maybe_awaitable
 
+if TYPE_CHECKING:
+    from synapse.server import HomeServer
+
+
 logger = logging.getLogger(__name__)
 
 
@@ -58,13 +62,13 @@ class Distributor:
       model will do for today.
     """
 
-    def __init__(self, server_name: str) -> None:
+    def __init__(self, hs: "HomeServer") -> None:
         """
         Args:
             server_name: The homeserver name of the server (used to label metrics)
                 (this should be `hs.hostname`).
         """
-        self.server_name = server_name
+        self.hs = hs
         self.signals: Dict[str, Signal] = {}
         self.pre_registration: Dict[str, List[Callable]] = {}
 
@@ -97,8 +101,8 @@ class Distributor:
         if name not in self.signals:
             raise KeyError("%r does not have a signal named %s" % (self, name))
 
-        run_as_background_process(
-            name, self.server_name, self.signals[name].fire, *args, **kwargs
+        self.hs.run_as_background_process(
+            name, self.signals[name].fire, *args, **kwargs
         )
 
 

synapse/util/metrics.py

@@ -217,7 +217,11 @@ class Measure:
         else:
             assert isinstance(curr_context, LoggingContext)
             parent_context = curr_context
-        self._logging_context = LoggingContext(str(curr_context), parent_context)
+        self._logging_context = LoggingContext(
+            name=str(curr_context),
+            server_name=self.server_name,
+            parent_context=parent_context,
+        )
         self.start: Optional[float] = None
 
     def __enter__(self) -> "Measure":
@@ -289,21 +293,46 @@ class DynamicCollectorRegistry(CollectorRegistry):
 
     def __init__(self) -> None:
         super().__init__()
-        self._pre_update_hooks: Dict[str, Callable[[], None]] = {}
+        self._server_name_to_pre_update_hooks: Dict[
+            str, Dict[str, Callable[[], None]]
+        ] = {}
+        """
+        Mapping of server name to a mapping of metric name to metric pre-update
+        hook
+        """
 
     def collect(self) -> Generator[Metric, None, None]:
         """
         Collects metrics, calling pre-update hooks first.
         """
 
-        for pre_update_hook in self._pre_update_hooks.values():
-            pre_update_hook()
+        for pre_update_hooks in self._server_name_to_pre_update_hooks.values():
+            for pre_update_hook in pre_update_hooks.values():
+                pre_update_hook()
 
         yield from super().collect()
 
-    def register_hook(self, metric_name: str, hook: Callable[[], None]) -> None:
+    def register_hook(
+        self, server_name: str, metric_name: str, hook: Callable[[], None]
+    ) -> None:
         """
         Registers a hook that is called before metric collection.
         """
 
-        self._pre_update_hooks[metric_name] = hook
+        server_hooks = self._server_name_to_pre_update_hooks.setdefault(server_name, {})
+        if server_hooks.get(metric_name) is not None:
+            # TODO: This should be an `assert` since registering the same metric name
+            # multiple times will clobber the old metric.
+            # We currently rely on this behaviour as we instantiate multiple
+            # `SyncRestServlet`, one per listener, and in the `__init__` we setup a new
+            # LruCache.
+            # Once the above behaviour is changed, this should be changed to an `assert`.
+            logger.error(
+                "Metric named %s already registered for server %s",
+                metric_name,
+                server_name,
+            )
+        server_hooks[metric_name] = hook
+
+    def unregister_hooks_for_homeserver(self, server_name: str) -> None:
+        self._server_name_to_pre_update_hooks.pop(server_name, None)

synapse/util/ratelimitutils.py

@@ -419,4 +419,7 @@ class _PerHostRatelimiter:
             except KeyError:
                 pass
 
-        self.clock.call_later(0.0, start_next_request)
+        self.clock.call_later(
+            0.0,
+            start_next_request,
+        )