hivemind-websocket-protocol 0.2.8a1__tar.gz → 0.2.8a3__tar.gz

{hivemind_websocket_protocol-0.2.8a1 → hivemind_websocket_protocol-0.2.8a3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hivemind-websocket-protocol
-Version: 0.2.8a1
+Version: 0.2.8a3
 Summary: websocket network protocol for hivemind-core
 Author-email: jarbasAi <jarbasai@mailfence.com>
 License-Expression: Apache-2.0

{hivemind_websocket_protocol-0.2.8a1 → hivemind_websocket_protocol-0.2.8a3}/hivemind_websocket_protocol/__init__.py

@@ -1,11 +1,13 @@
 import asyncio
 import dataclasses
+import hashlib
 import math
 import os
 import os.path
 import random
 import threading
 import time
+from collections import OrderedDict
 from os import makedirs
 from os.path import exists, join
 from socket import gethostname
@@ -18,7 +20,7 @@ from OpenSSL import crypto
 from ovos_bus_client.session import Session
 from ovos_utils.log import LOG
 from ovos_utils.xdg_utils import xdg_data_home
-from poorman_handshake import PasswordHandShake
+from poorman_handshake import PasswordHandShake, check_password_strength
 from tornado import ioloop
 from tornado import web
 from tornado.platform.asyncio import AnyThreadEventLoopPolicy
@@ -56,6 +58,101 @@ DEFAULT_WEBSOCKET_PING_INTERVAL = 30.0
 DEFAULT_WEBSOCKET_PING_TIMEOUT = 20.0
 
 
+#: Passwords already checked against a given policy, most recent last.
+#:
+#: ``PasswordHandShake(password, min_bits=N)`` runs the credential through
+#: zxcvbn on construction. That is the right thing to do, but it is ~2.2 ms
+#: and Core builds one per admission on the single Tornado IOLoop, so a fleet
+#: reconnecting at once serialises behind it: 400 satellites is ~0.87 s of
+#: event loop spent re-deciding that the same handful of passwords are still
+#: strong.
+#:
+#: Entries are keyed on a *keyed* blake2s digest and the policy that accepted
+#: it. The key is per-process and never persisted, so this is an LRU lookup
+#: key, not a stored password hash; rotating a password or tightening
+#: ``min_bits`` misses the cache and re-validates.
+_PASSWORD_STRENGTH_LOCK = threading.Lock()
+_PASSWORD_STRENGTH_CACHE: "OrderedDict[Tuple[bytes, float], None]" = OrderedDict()
+_PASSWORD_STRENGTH_CACHE_KEY = os.urandom(32)
+_PASSWORD_STRENGTH_CACHE_SIZE = 4096
+
+
+def _password_handshake(password: str,
+                        min_bits: Optional[float] = None) -> PasswordHandShake:
+    """Build a PasswordHandShake, validating each password once per policy.
+
+    Raises ``WeakPasswordError`` exactly as the plain constructor does -- a
+    weak password is never cached, so it is rejected on every attempt.
+    """
+    if min_bits is None:
+        min_bits = runtime_password_min_bits()
+
+    if min_bits > 0:
+        digest = hashlib.blake2s(
+            password.encode("utf-8"),
+            key=_PASSWORD_STRENGTH_CACHE_KEY,
+        ).digest()
+        cache_key = (digest, min_bits)
+        with _PASSWORD_STRENGTH_LOCK:
+            if cache_key in _PASSWORD_STRENGTH_CACHE:
+                _PASSWORD_STRENGTH_CACHE.move_to_end(cache_key)
+            else:
+                # Outside the cache-hit branch on purpose: a rejection must
+                # propagate and must not be remembered as a pass.
+                check_password_strength(password, min_bits=min_bits)
+                _PASSWORD_STRENGTH_CACHE[cache_key] = None
+                while len(_PASSWORD_STRENGTH_CACHE) > _PASSWORD_STRENGTH_CACHE_SIZE:
+                    _PASSWORD_STRENGTH_CACHE.popitem(last=False)
+
+    # Already validated above; min_bits=0 skips the duplicate zxcvbn run.
+    return PasswordHandShake(password, min_bits=0)
+#: Connection hot-path logger, resolved once.
+#:
+#: ``LOG.debug``/``LOG.info`` resolve the calling module, function and line
+#: with ``inspect.stack()`` on *every* call, before the level is checked, so a
+#: discarded DEBUG record costs the same as an emitted one. Admission, receive
+#: and disconnect all run on Tornado's single IOLoop that serves every
+#: connected satellite, so that cost is paid per connection and per inbound
+#: frame, and delays every other peer on the node.
+#:
+#: ``LOG.create_logger`` returns the same OVOS-configured logger those calls
+#: would have used -- same formatter, stdout and rotating-file handlers -- and
+#: registers it in ``LOG._loggers``, so a later ``LOG.init``/``LOG.set_level``
+#: still retargets its level. Only the per-call stack walk is dropped. It is
+#: resolved lazily because ``LOG.init`` usually runs after this import.
+_RECEIVE_LOGGER = None
+_RECEIVE_LOGGER_KEY = None
+_RECEIVE_LOGGER_LOCK = threading.Lock()
+
+
+def _receive_logger():
+    """Return the cached hot-path logger, rebuilding when LOG rewires.
+
+    Cached against ``(LOG.name, LOG.base_path)``: ``LOG.init()`` normally runs
+    after import, and a logger created before it would carry only the stdout
+    handler -- configured file logging would silently vanish from this path,
+    because init does not rebuild handlers on existing loggers. When the
+    fingerprint changes, the stale entry and its handlers are dropped so
+    ``create_logger`` rebuilds against the live config. The lock keeps two
+    racing first frames from attaching duplicate handlers to the same
+    process-wide ``logging.getLogger`` name.
+    """
+    global _RECEIVE_LOGGER, _RECEIVE_LOGGER_KEY
+    key = (LOG.name, LOG.base_path)
+    if _RECEIVE_LOGGER is None or _RECEIVE_LOGGER_KEY != key:
+        with _RECEIVE_LOGGER_LOCK:
+            if _RECEIVE_LOGGER is None or _RECEIVE_LOGGER_KEY != key:
+                name = f"{LOG.name} - {__name__}"
+                stale = LOG._loggers.pop(name, None)
+                if stale is not None:
+                    for handler in list(stale.handlers):
+                        stale.removeHandler(handler)
+                        handler.close()
+                _RECEIVE_LOGGER = LOG.create_logger(name)
+                _RECEIVE_LOGGER_KEY = key
+    return _RECEIVE_LOGGER
+
+
 def _split_csv(value: Any) -> Tuple[str, ...]:
     if not value:
         return ()
@@ -322,14 +419,18 @@ class HiveMindTornadoWebSocket(WebSocketHandler):
     def _handle_inbound_message(self, message: str) -> None:
         message = self.client.decode(message)
         peer = self._peer_label(self.client.peer)
+        log = _receive_logger()
         if (
                 message.msg_type == HiveMessageType.BUS
                 and message.payload.msg_type == "recognizer_loop:b64_audio"
         ):
-            LOG.debug(f"Received {peer} sent base64 audio for STT")
+            log.debug("Received %s sent base64 audio for STT", peer)
         else:
-            LOG.info("Received %s message: %s", peer, message.msg_type)
-            LOG.debug(f"Received {peer} message: {message}")
+            log.info("Received %s message: %s", peer, message.msg_type)
+            # Lazy args, never an f-string: ``HiveMessage.__str__`` serializes
+            # the whole envelope to JSON, and that must not run when DEBUG is
+            # off. It also keeps a user's transcribed speech out of the cost.
+            log.debug("Received %s message: %s", peer, message)
         self.hm_protocol.handle_message(message, self.client)
 
     def _peer_label(self, peer: str) -> str:
@@ -362,7 +463,8 @@ class HiveMindTornadoWebSocket(WebSocketHandler):
             )
             self.close(code=1008, reason="invalid authorization")
             return
-        LOG.debug(f"Authorizing client from {self.source_ip or 'unknown'} - {useragent}")
+        _receive_logger().debug("Authorizing client from %s - %s",
+                                self.source_ip or "unknown", useragent)
 
         def do_send(payload: str, is_bin: bool):
             def _write():
@@ -430,7 +532,7 @@ class HiveMindTornadoWebSocket(WebSocketHandler):
         self.client.is_admin = user.is_admin
         if user.password:
             # pre-shared password to derive aes_key
-            self.client.pswd_handshake = PasswordHandShake(user.password, min_bits=runtime_password_min_bits())
+            self.client.pswd_handshake = _password_handshake(user.password)
 
         self.client.node_type = HiveMindNodeType.NODE  # TODO . placeholder
 
@@ -456,9 +558,9 @@ class HiveMindTornadoWebSocket(WebSocketHandler):
     def on_close(self):
         client = getattr(self, "client", None)
         if client is None:
-            LOG.debug(
-                f"closing unauthenticated websocket from {self.request.remote_ip} "
-                f"(no client was ever attached)"
+            _receive_logger().debug(
+                "closing unauthenticated websocket from %s "
+                "(no client was ever attached)", self.request.remote_ip
             )
             return
         # The age of the last pong cannot tell a ping timeout apart from a
@@ -472,13 +574,14 @@ class HiveMindTornadoWebSocket(WebSocketHandler):
         since_pong = (
             time.monotonic() - self.last_pong if self.last_pong is not None else None
         )
-        LOG.info(
+        log = _receive_logger()
+        log.info(
             "disconnecting client: %s (close_code=%s, close_reason=%s, "
             "seconds_since_last_pong=%s)",
             self._peer_label(client.peer), self.close_code, self.close_reason,
             f"{since_pong:.1f}" if since_pong is not None else "unknown",
         )
-        LOG.debug(f"disconnecting client: {self._peer_label(client.peer)}")
+        log.debug("disconnecting client: %s", self._peer_label(client.peer))
         self.hm_protocol.handle_client_disconnected(client)
 
     def check_origin(self, origin) -> bool:

{hivemind_websocket_protocol-0.2.8a1 → hivemind_websocket_protocol-0.2.8a3}/hivemind_websocket_protocol/version.py

@@ -2,7 +2,7 @@
 VERSION_MAJOR = 0
 VERSION_MINOR = 2
 VERSION_BUILD = 8
-VERSION_ALPHA = 1
+VERSION_ALPHA = 3
 # END_VERSION_BLOCK
 
 __version__ = f"{VERSION_MAJOR}.{VERSION_MINOR}.{VERSION_BUILD}" + (f"a{VERSION_ALPHA}" if VERSION_ALPHA else "")

{hivemind_websocket_protocol-0.2.8a1 → hivemind_websocket_protocol-0.2.8a3}/hivemind_websocket_protocol.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hivemind-websocket-protocol
-Version: 0.2.8a1
+Version: 0.2.8a3
 Summary: websocket network protocol for hivemind-core
 Author-email: jarbasAi <jarbasai@mailfence.com>
 License-Expression: Apache-2.0

{hivemind_websocket_protocol-0.2.8a1 → hivemind_websocket_protocol-0.2.8a3}/hivemind_websocket_protocol.egg-info/SOURCES.txt

@@ -15,5 +15,7 @@ tests/test_client_ip.py
 tests/test_close_diagnostics.py
 tests/test_decode_auth.py
 tests/test_health.py
+tests/test_password_strength_cache.py
 tests/test_protocol_unit.py
+tests/test_receive_logging.py
 tests/test_trusted_proxy_config.py

{hivemind_websocket_protocol-0.2.8a1 → hivemind_websocket_protocol-0.2.8a3}/tests/test_close_diagnostics.py

@@ -12,12 +12,16 @@ a peer that timed out echoes nothing.
 
 `ovos_utils.log.LOG` sets `propagate = False` on its underlying logger, so
 `caplog`'s root-logger capture can silently miss records depending on test
-order. These tests instead patch `hivemind_websocket_protocol.LOG` directly
-and assert on the calls it receives.
+order. These tests instead patch the module's cached hot-path logger
+(`_RECEIVE_LOGGER`, returned by `_receive_logger()`) and assert on the calls
+it receives.
 """
+import re
 import time
 from unittest.mock import MagicMock
 
+import pytest
+
 from hivemind_core.protocol import HiveMindClientConnection
 from hivemind_websocket_protocol import (
     DEFAULT_WEBSOCKET_PING_INTERVAL,
@@ -64,6 +68,13 @@ def _logged(log):
     return log.info.call_args[0][0] % log.info.call_args[0][1:]
 
 
+def _pong_age(message):
+    """The `seconds_since_last_pong=` value logged, as a float."""
+    match = re.search(r"seconds_since_last_pong=([\d.]+)", message)
+    assert match, message
+    return float(match.group(1))
+
+
 def test_on_pong_stamps_last_pong():
     handler = object.__new__(HiveMindTornadoWebSocket)
     handler.last_pong = None
@@ -75,7 +86,9 @@ def test_on_pong_stamps_last_pong():
 
 def test_close_reports_code_reason_and_pong_age(monkeypatch):
     log = MagicMock()
-    monkeypatch.setattr(hwp, "LOG", log)
+    monkeypatch.setattr(hwp, "_RECEIVE_LOGGER", log)
+    monkeypatch.setattr(hwp, "_RECEIVE_LOGGER_KEY",
+                        (hwp.LOG.name, hwp.LOG.base_path))
     handler = _handler(
         last_pong=time.monotonic() - 12,
         close_code=1006,
@@ -98,7 +111,9 @@ def test_a_real_ping_timeout_is_reported_with_its_pong_age(monkeypatch):
     is what the log must report - no threshold separates it from an ordinary
     disconnect."""
     log = MagicMock()
-    monkeypatch.setattr(hwp, "LOG", log)
+    monkeypatch.setattr(hwp, "_RECEIVE_LOGGER", log)
+    monkeypatch.setattr(hwp, "_RECEIVE_LOGGER_KEY",
+                        (hwp.LOG.name, hwp.LOG.base_path))
     round_trip = 0.3
     age = DEFAULT_WEBSOCKET_PING_INTERVAL + DEFAULT_WEBSOCKET_PING_TIMEOUT - round_trip
     handler = _handler(last_pong=time.monotonic() - age)
@@ -113,17 +128,25 @@ def test_no_pong_age_ever_triggers_a_verdict(monkeypatch):
     one factual line, never a guess about the cause."""
     for age in (0.5, 25, 49.7, 50, 120, 3600):
         log = MagicMock()
-        monkeypatch.setattr(hwp, "LOG", log)
+        monkeypatch.setattr(hwp, "_RECEIVE_LOGGER", log)
+        monkeypatch.setattr(hwp, "_RECEIVE_LOGGER_KEY",
+                            (hwp.LOG.name, hwp.LOG.base_path))
         handler = _handler(last_pong=time.monotonic() - age)
 
         handler.on_close()
 
-        assert f"seconds_since_last_pong={age:.1f}" in _logged(log)
+        # The exact decimal is timing-dependent (wall-clock elapses between
+        # `_handler()` stamping `last_pong` and `on_close()` reading it), so
+        # only the reported age's ballpark - not its literal formatting - is
+        # asserted here.
+        assert _pong_age(_logged(log)) == pytest.approx(age, abs=1.0)
 
 
 def test_client_that_never_ponged_reports_unknown_age(monkeypatch):
     log = MagicMock()
-    monkeypatch.setattr(hwp, "LOG", log)
+    monkeypatch.setattr(hwp, "_RECEIVE_LOGGER", log)
+    monkeypatch.setattr(hwp, "_RECEIVE_LOGGER_KEY",
+                        (hwp.LOG.name, hwp.LOG.base_path))
     handler = _handler(last_pong=None)
 
     handler.on_close()
@@ -133,7 +156,9 @@ def test_client_that_never_ponged_reports_unknown_age(monkeypatch):
 
 def test_on_close_never_logs_payload_or_access_key(monkeypatch):
     log = MagicMock()
-    monkeypatch.setattr(hwp, "LOG", log)
+    monkeypatch.setattr(hwp, "_RECEIVE_LOGGER", log)
+    monkeypatch.setattr(hwp, "_RECEIVE_LOGGER_KEY",
+                        (hwp.LOG.name, hwp.LOG.base_path))
     for last_pong in (time.monotonic() - 1, time.monotonic() - 3600):
         handler = _handler(last_pong=last_pong)
         handler.on_close()

hivemind_websocket_protocol-0.2.8a3/tests/test_password_strength_cache.py

@@ -0,0 +1,105 @@
+"""Admission must not re-run zxcvbn for every connecting satellite.
+
+``PasswordHandShake`` validates the credential on construction, and Core builds
+one per admission on the single Tornado IOLoop. Validating the same password
+400 times costs ~0.87 s of event loop that no satellite can use.
+"""
+import threading
+from unittest.mock import patch
+
+import pytest
+from poorman_handshake import WeakPasswordError
+
+import hivemind_websocket_protocol as hwp
+
+STRONG = "correct-horse-battery-staple-9271"
+
+
+@pytest.fixture(autouse=True)
+def _clear_cache():
+    hwp._PASSWORD_STRENGTH_CACHE.clear()
+    yield
+    hwp._PASSWORD_STRENGTH_CACHE.clear()
+
+
+def test_repeated_admissions_validate_once():
+    with patch.object(hwp, "check_password_strength") as check:
+        for _ in range(400):
+            hwp._password_handshake(STRONG, min_bits=64)
+
+    assert check.call_count == 1, (
+        "each admission re-ran the strength check; a reconnecting fleet pays "
+        "this on the IOLoop"
+    )
+
+
+def test_handshake_is_not_shared_between_connections():
+    """Only the verdict is cached — handshake state is per connection."""
+    first = hwp._password_handshake(STRONG, min_bits=64)
+    second = hwp._password_handshake(STRONG, min_bits=64)
+
+    assert first is not second
+
+
+def test_weak_password_is_rejected_every_time():
+    """A rejection must never be remembered as a pass."""
+    for _ in range(3):
+        with pytest.raises(WeakPasswordError):
+            hwp._password_handshake("123456", min_bits=64)
+
+    assert len(hwp._PASSWORD_STRENGTH_CACHE) == 0
+
+
+def test_a_tightened_policy_revalidates():
+    hwp._password_handshake(STRONG, min_bits=40)
+
+    with patch.object(hwp, "check_password_strength") as check:
+        hwp._password_handshake(STRONG, min_bits=64)
+
+    assert check.call_count == 1, "min_bits is part of the cache key"
+
+
+def test_a_rotated_password_revalidates():
+    hwp._password_handshake(STRONG, min_bits=64)
+
+    with patch.object(hwp, "check_password_strength") as check:
+        hwp._password_handshake(STRONG + "-rotated", min_bits=64)
+
+    assert check.call_count == 1
+
+
+def test_disabled_policy_does_not_validate_or_cache():
+    with patch.object(hwp, "check_password_strength") as check:
+        hwp._password_handshake(STRONG, min_bits=0)
+
+    assert check.call_count == 0
+    assert len(hwp._PASSWORD_STRENGTH_CACHE) == 0
+
+
+def test_cache_is_bounded():
+    limit = hwp._PASSWORD_STRENGTH_CACHE_SIZE
+    with patch.object(hwp, "check_password_strength"):
+        for i in range(limit + 50):
+            hwp._password_handshake(f"{STRONG}-{i}", min_bits=64)
+
+    assert len(hwp._PASSWORD_STRENGTH_CACHE) <= limit
+
+
+def test_concurrent_admissions_are_safe():
+    """Admission runs from Tornado's loop and executor threads alike."""
+    errors = []
+
+    def admit():
+        try:
+            for _ in range(50):
+                hwp._password_handshake(STRONG, min_bits=64)
+        except Exception as e:  # noqa: BLE001
+            errors.append(e)
+
+    threads = [threading.Thread(target=admit) for _ in range(8)]
+    for t in threads:
+        t.start()
+    for t in threads:
+        t.join()
+
+    assert errors == []

hivemind_websocket_protocol-0.2.8a3/tests/test_receive_logging.py

@@ -0,0 +1,149 @@
+"""The websocket receive path must not pay for logging it discards.
+
+``LOG.debug``/``LOG.info`` walk ``inspect.stack()`` on every call to label the
+record with the caller, *before* the level is consulted, so a dropped DEBUG
+record costs as much as an emitted one. ``_handle_inbound_message`` runs on the
+single Tornado IOLoop that serves every connected satellite, so anything it
+pays there is paid again by every other peer on the node.
+"""
+import logging
+from types import SimpleNamespace
+
+import pytest
+from ovos_utils.log import LOG
+
+import hivemind_websocket_protocol as hwp
+from hivemind_websocket_protocol import HiveMindTornadoWebSocket
+
+
+class _CountingMessage:
+    """Stands in for a HiveMessage, whose ``__str__`` serializes to JSON."""
+
+    def __init__(self):
+        self.msg_type = "bus"
+        self.payload = SimpleNamespace(msg_type="recognizer_loop:utterance")
+        self.renders = 0
+
+    def __str__(self):
+        self.renders += 1
+        return '{"msg_type": "bus", "payload": "secret utterance"}'
+
+
+@pytest.fixture
+def handler():
+    """A handler wired up just enough to run ``_handle_inbound_message``."""
+    h = HiveMindTornadoWebSocket.__new__(HiveMindTornadoWebSocket)
+    h.source_ip = "127.0.0.1"
+    h.hm_protocol = SimpleNamespace(handle_message=lambda msg, client: None)
+    return h
+
+
+@pytest.fixture(autouse=True)
+def _reset_receive_logger():
+    """Drop the cache and the logging singleton's handlers between tests."""
+    def reset():
+        name = f"{LOG.name} - {hwp.__name__}"
+        stale = logging.getLogger(name)
+        for handler in list(stale.handlers):
+            stale.removeHandler(handler)
+            handler.close()
+        LOG._loggers.pop(name, None)
+        hwp._RECEIVE_LOGGER = None
+        hwp._RECEIVE_LOGGER_KEY = None
+    reset()
+    yield
+    reset()
+
+
+def _deliver(handler, message):
+    handler.client = SimpleNamespace(decode=lambda raw: message, peer="tcp4:peer")
+    handler._handle_inbound_message("raw-frame")
+
+
+def test_payload_not_rendered_when_debug_is_disabled(handler):
+    """At INFO the envelope is never serialized — that is the whole point."""
+    hwp._receive_logger().setLevel(logging.INFO)
+    message = _CountingMessage()
+
+    _deliver(handler, message)
+
+    assert message.renders == 0, (
+        "the inbound envelope was serialized for a DEBUG record that was "
+        "discarded; pass it as a lazy argument instead of formatting it"
+    )
+
+
+def test_payload_is_still_rendered_when_debug_is_enabled(handler):
+    """Laziness must not cost the operator the debug output itself."""
+    hwp._receive_logger().setLevel(logging.DEBUG)
+    message = _CountingMessage()
+
+    _deliver(handler, message)
+
+    # ">= 1" not "== 1": every attached handler formats the record, and pytest
+    # adds its own capture handlers on top of the stdout one.
+    assert message.renders >= 1
+
+
+def test_b64_audio_frames_are_not_rendered(handler):
+    """Audio frames are already special-cased; keep them that way."""
+    hwp._receive_logger().setLevel(logging.DEBUG)
+    message = _CountingMessage()
+    message.payload = SimpleNamespace(msg_type="recognizer_loop:b64_audio")
+
+    _deliver(handler, message)
+
+    assert message.renders == 0
+
+
+def test_receive_logger_is_resolved_once(handler):
+    """One stack walk per process, not one per inbound frame."""
+    assert hwp._receive_logger() is hwp._receive_logger()
+
+
+def test_receive_logger_follows_log_set_level():
+    """Caching must not pin the level: LOG.init/set_level still retargets it."""
+    log = hwp._receive_logger()
+    assert log.name in LOG._loggers, (
+        "the receive logger must be registered with LOG so set_level reaches it"
+    )
+    previous = LOG.level
+    try:
+        LOG.set_level("DEBUG")
+        assert log.level == logging.DEBUG
+        LOG.set_level("WARNING")
+        assert log.level == logging.WARNING
+    finally:
+        LOG.set_level(previous)
+
+
+def test_logger_rewires_after_log_init_changes_base_path(tmp_path):
+    """init after first use must not strand this path on stdout-only."""
+    hwp._receive_logger()
+    previous = LOG.base_path
+    try:
+        LOG.base_path = str(tmp_path)
+        kinds = {type(h).__name__ for h in hwp._receive_logger().handlers}
+        assert "RotatingFileHandler" in kinds
+    finally:
+        LOG.base_path = previous
+
+
+def test_concurrent_first_use_attaches_handlers_once():
+    import threading
+    gate = threading.Event()
+
+    def resolve():
+        gate.wait()
+        hwp._receive_logger()
+
+    threads = [threading.Thread(target=resolve) for _ in range(8)]
+    for t in threads:
+        t.start()
+    gate.set()
+    for t in threads:
+        t.join(timeout=10)
+
+    streams = [h for h in hwp._receive_logger().handlers
+               if type(h).__name__ == "StreamHandler"]
+    assert len(streams) <= 1