hivemind-websocket-protocol 0.2.8a2__tar.gz → 0.2.8a4__tar.gz

{hivemind_websocket_protocol-0.2.8a2 → hivemind_websocket_protocol-0.2.8a4}/PKG-INFO

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

{hivemind_websocket_protocol-0.2.8a2 → hivemind_websocket_protocol-0.2.8a4}/hivemind_websocket_protocol/__init__.py

@@ -106,6 +106,51 @@ def _password_handshake(password: str,
 
     # 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, ...]:
@@ -374,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:
@@ -414,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():
@@ -508,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
@@ -524,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.8a2 → hivemind_websocket_protocol-0.2.8a4}/hivemind_websocket_protocol/version.py

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

{hivemind_websocket_protocol-0.2.8a2 → hivemind_websocket_protocol-0.2.8a4}/hivemind_websocket_protocol.egg-info/PKG-INFO

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

{hivemind_websocket_protocol-0.2.8a2 → hivemind_websocket_protocol-0.2.8a4}/hivemind_websocket_protocol.egg-info/SOURCES.txt

@@ -17,4 +17,5 @@ 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.8a2 → hivemind_websocket_protocol-0.2.8a4}/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.8a4/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