vortexpy 4.1.5__tar.gz → 4.1.7__tar.gz

{vortexpy-4.1.5 → vortexpy-4.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vortexpy
-Version: 4.1.5
+Version: 4.1.7
 Summary: Flying Ion's observable, routable, data serialisation and transport code.
 Author-email: Flying Ion Pty Ltd <contact@flyingion.com>
 License: MIT

{vortexpy-4.1.5 → vortexpy-4.1.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "vortexpy"
-version = "4.1.5"
+version = "4.1.7"
 license = {text = "MIT"}
 authors = [{name = "Flying Ion Pty Ltd", email = "contact@flyingion.com"}]
 description = "Flying Ion's observable, routable, data serialisation and transport code."

{vortexpy-4.1.5 → vortexpy-4.1.7}/vortex/PayloadEndpoint.py

@@ -71,6 +71,7 @@ class PayloadEndpoint:
         acceptOnlyFromVortex: Optional[Union[str, tuple]] = None,
         ignoreFromVortex: Optional[Union[str, tuple]] = None,
         requiredPermissions: Optional[PermissionsType] = None,
+        logProcessException: bool = True,
     ) -> None:
         """
         :param filt: The filter to match against payloads
@@ -82,10 +83,13 @@ class PayloadEndpoint:
             the caller's session must hold.  Pass an empty frozenset to
             explicitly declare "no permissions required".  Omitting the
             parameter (``None``) emits a deprecation warning.
+        :param logProcessException: When True, handler exceptions log at ERROR.
+            When False, the same events log at DEBUG with neutral wording.
         """
         self._requiredPermissions: Optional[PermissionsType] = (
             requiredPermissions
         )
+        self._logProcessException = logProcessException
 
         if requiredPermissions is None:
             logger.warning(self._NO_PERMISSIONS_WARNING, filt)

{vortexpy-4.1.5 → vortexpy-4.1.7}/vortex/PayloadIO.py

@@ -115,8 +115,15 @@ class PayloadIO(object):
             except Exception as e:
                 logger.exception(e)
 
-            vortexLogFailure(failure, logger)
-            logger.error(payloadEnvelope.filt)
+            if endpoint._logProcessException:
+                vortexLogFailure(failure, logger)
+                logger.error(payloadEnvelope.filt)
+            else:
+                logger.debug(
+                    "Payload handler response for filt=%s: %s",
+                    payloadEnvelope.filt,
+                    failure.getErrorMessage(),
+                )
 
         def callback(value, blocking=False):
             # A blocking call taking more than 100ms is BAD

{vortexpy-4.1.5 → vortexpy-4.1.7}/vortex/PayloadResponse.py

@@ -67,7 +67,7 @@ class PayloadResponse(Deferred):
         destVortexUuid: Optional[str] = None,
         timeout: Optional[float] = None,
         resultCheck=True,
-        logTimeoutError=True,
+        logTimeoutException=True,
     ) -> None:
         """Constructor
 
@@ -81,6 +81,8 @@ class PayloadResponse(Deferred):
         :param timeout The timeout to wait for a response
         :param resultCheck Should the response payload.result be checked, if it fails
                     it errback will be called.
+        :param logTimeoutException: When True, payload timeouts log at ERROR.
+                    When False, timeouts log at DEBUG with neutral wording.
         """
         Deferred.__init__(self)
 
@@ -88,7 +90,7 @@ class PayloadResponse(Deferred):
             timeout = self.TIMEOUT
 
         self._resultCheck = resultCheck
-        self._logTimeoutError = logTimeoutError
+        self._logTimeoutException = logTimeoutException
 
         # uuid4 can have collisions
         self._messageId = str(uuid4()) + str(PayloadResponse.__SEQ)
@@ -142,8 +144,10 @@ class PayloadResponse(Deferred):
             self._endpoint.shutdown()
             self._endpoint = None
 
-        if self._logTimeoutError:
+        if self._logTimeoutException:
             logger.error("Timed out for payload %s", self._filt)
+        else:
+            logger.debug("Payload response timed out for %s", self._filt)
         self._status = self.TIMED_OUT
         return failure
 

vortexpy-4.1.7/vortex/PayloadResponse_test.py

@@ -0,0 +1,42 @@
+import unittest
+from unittest.mock import MagicMock, patch
+
+from twisted.internet.defer import TimeoutError
+from twisted.python.failure import Failure
+
+from vortex.PayloadEnvelope import PayloadEnvelope
+from vortex.PayloadResponse import PayloadResponse
+
+
+class PayloadResponseLoggingTest(unittest.TestCase):
+    @patch("vortex.PayloadResponse.VortexFactory.sendVortexMsg")
+    @patch("vortex.PayloadResponse.logger")
+    def testTimeoutLogsDebugWhenLogTimeoutExceptionFalse(
+        self, mockLogger: MagicMock, _mockSend: MagicMock
+    ) -> None:
+        pr = PayloadResponse(
+            PayloadEnvelope(filt={"key": "example"}),
+            timeout=30.0,
+            logTimeoutException=False,
+        )
+        pr._timedOut(Failure(TimeoutError("timed out")))
+        mockLogger.error.assert_not_called()
+        mockLogger.debug.assert_called_once()
+
+    @patch("vortex.PayloadResponse.VortexFactory.sendVortexMsg")
+    @patch("vortex.PayloadResponse.logger")
+    def testTimeoutLogsErrorWhenLogTimeoutExceptionTrue(
+        self, mockLogger: MagicMock, _mockSend: MagicMock
+    ) -> None:
+        pr = PayloadResponse(
+            PayloadEnvelope(filt={"key": "example"}),
+            timeout=30.0,
+            logTimeoutException=True,
+        )
+        pr._timedOut(Failure(TimeoutError("timed out")))
+        mockLogger.debug.assert_not_called()
+        mockLogger.error.assert_called_once()
+
+
+if __name__ == "__main__":
+    unittest.main()

{vortexpy-4.1.5 → vortexpy-4.1.7}/vortex/__init__.py

@@ -6,4 +6,4 @@
 # Website : https://flyingion.com
 # Support : contact@flyingion.com
 
-__version__ = '4.1.5'
+__version__ = '4.1.7'

{vortexpy-4.1.5 → vortexpy-4.1.7}/vortex/handler/TupleActionProcessorProxy.py

@@ -167,7 +167,7 @@ class TupleActionProcessorProxy:
             payloadEnvelope,
             timeout=PayloadResponse.TIMEOUT - 5,  # 5 seconds less
             resultCheck=False,
-            logTimeoutError=False,
+            logTimeoutException=False,
         )
 
         # This is not a lambda, so that it can have a breakpoint

{vortexpy-4.1.5 → vortexpy-4.1.7}/vortex/handler/TupleDataObservableProxyHandler.py

@@ -355,7 +355,7 @@ class TupleDataObservableProxyHandler(TupleDataObservableCache):
         pr = PayloadResponse(
             payloadEnvelope,
             timeout=PayloadResponse.TIMEOUT - 5,  # 5 seconds less
-            logTimeoutError=False,
+            logTimeoutException=False,
         )
 
         pr.addErrback(self._handlePrFailure, tupleSelector)

{vortexpy-4.1.5 → vortexpy-4.1.7}/vortex/handler/TupleDataObserverClient.py

@@ -83,7 +83,7 @@ class TupleDataObserverClient(TupleDataObservableCache):
         TupleDataObservableCache.shutdown(self)
 
     def pollForTuples(
-        self, tupleSelector: TupleSelector, logTimeoutError: bool = True
+        self, tupleSelector: TupleSelector, logTimeoutException: bool = True
     ) -> Deferred:
         startFilt = copy(self._sendFilt)
         startFilt.update({"subscribe": False, "tupleSelector": tupleSelector})
@@ -97,7 +97,7 @@ class TupleDataObserverClient(TupleDataObservableCache):
         pr = PayloadResponse(
             payloadEnvelope=PayloadEnvelope(startFilt),
             destVortexName=self._destVortexName,
-            logTimeoutError=logTimeoutError,
+            logTimeoutException=logTimeoutException,
         )
         pr.addCallback(updateCacheCallback)
         pr.addCallback(

{vortexpy-4.1.5 → vortexpy-4.1.7}/vortex/rpc/RPC.py

@@ -21,7 +21,7 @@ from twisted.internet.defer import (
 from twisted.internet.threads import deferToThread
 from twisted.python.failure import Failure
 
-from vortex.DeferUtil import yesMainThread
+from vortex.DeferUtil import yesMainThread, vortexLogFailure
 from vortex.Payload import Payload
 from vortex.PayloadEndpoint import PayloadEndpoint
 from vortex.PayloadEnvelope import PayloadEnvelope
@@ -103,6 +103,8 @@ class _VortexRPC:
         deferToThread: bool,
         inlineCallbacks: bool,
         requiredPermissions: Optional[PermissionsType] = None,
+        logTimeoutException: bool = True,
+        logRpcException: bool = True,
     ) -> None:
         """
 
@@ -124,6 +126,15 @@ class _VortexRPC:
         :param inlineCallbacks: Should the function be wrapped in the twisted
                 @inlinecallbacks decorator before it's called?.
 
+        :param logTimeoutException: When True, RPC timeouts log at ERROR in
+                PayloadResponse. When False, timeouts log at DEBUG with neutral
+                wording. Callers that expect timeouts (e.g. backend readiness
+                probes) should leave this False.
+
+        :param logRpcException: When True, RPC handler and caller paths log
+                exceptions at ERROR. When False, the same events log at DEBUG
+                with neutral wording so log analysers are not triggered.
+
         """
 
         self.__func = func
@@ -138,6 +149,8 @@ class _VortexRPC:
         self.__requiredPermissions: Optional[PermissionsType] = (
             requiredPermissions
         )
+        self.__logTimeoutException = logTimeoutException
+        self.__logRpcException = logRpcException
 
         self.__funcAcceptsAccessControlContext = (
             checkAccessControlContextSignature(func)
@@ -176,6 +189,7 @@ class _VortexRPC:
                 self._filt,
                 self._processCall,
                 requiredPermissions=self.__requiredPermissions,
+                logProcessException=self.__logRpcException,
             )
             logger.debug("RPC %s listening", self.__funcName)
 
@@ -315,7 +329,9 @@ class _VortexRPC:
             payloadEnvelope,
             timeout=self.__timeoutSeconds,
             resultCheck=False,
-            logTimeoutError=False,
+            logTimeoutException=(
+                self.__logRpcException and self.__logTimeoutException
+            ),
             destVortexName=vortexName,
             destVortexUuid=vortexUuid,
         )
@@ -340,6 +356,18 @@ class _VortexRPC:
         """
 
         if not payloadEnvelope.result in (None, True):
+            if self.__logRpcException:
+                logger.error(
+                    "Received RPC failure for %s: %s",
+                    self.__funcName,
+                    payloadEnvelope.result,
+                )
+            else:
+                logger.debug(
+                    "RPC response for %s: %s",
+                    self.__funcName,
+                    payloadEnvelope.result,
+                )
             return Failure(
                 Exception(payloadEnvelope.result).with_traceback(stack),
                 exc_tb=stack,
@@ -366,8 +394,6 @@ class _VortexRPC:
         """
 
         if failure.check(TimeoutError):
-            logger.error("Received RPC timeout for %s", self.__funcName)
-
             return Failure(
                 Exception(
                     "RPC call timed out for %s", self.__funcName
@@ -375,6 +401,15 @@ class _VortexRPC:
                 exc_tb=stack,
             )
 
+        if not failure.check(TimeoutError) and self.__logRpcException:
+            vortexLogFailure(failure, logger)
+        elif not failure.check(TimeoutError):
+            logger.debug(
+                "RPC response for %s: %s",
+                self.__funcName,
+                failure.getErrorMessage(),
+            )
+
         return failure
 
     def callLocally(
@@ -423,6 +458,8 @@ def vortexRPC(
     deferToThread: bool = False,
     inlineCallbacks: bool = False,
     requiredPermissions: Optional[PermissionsType] = None,
+    logTimeoutException: bool = False,
+    logRpcException: bool = True,
 ):
     """Vortex RPC Decorator
 
@@ -444,6 +481,13 @@ def vortexRPC(
     :param inlineCallbacks: Should the function be wrapped in the twisted
             @inlinecallbacks decorator before it's called?.
 
+    :param logTimeoutException: When True, RPC timeouts log at ERROR.
+            When False, timeouts log at DEBUG with neutral wording.
+
+    :param logRpcException: When True, RPC handler and caller paths log at
+            ERROR. When False, the same events log at DEBUG with neutral
+            wording.
+
     :return A wrapped function, that will now work as an RPC call.
 
 
@@ -485,6 +529,8 @@ def vortexRPC(
             deferToThread,
             inlineCallbacks,
             requiredPermissions=requiredPermissions,
+            logTimeoutException=logTimeoutException,
+            logRpcException=logRpcException,
         )
 
     return decorator

vortexpy-4.1.7/vortex/rpc/RPC_test.py

@@ -0,0 +1,114 @@
+import unittest
+from types import SimpleNamespace
+from unittest.mock import ANY, MagicMock, patch
+
+from twisted.internet.defer import TimeoutError
+from twisted.python.failure import Failure
+
+from vortex.PayloadEndpoint import PayloadEndpoint
+from vortex.PayloadEnvelope import PayloadEnvelope
+from vortex.rpc.RPC import _VortexRPC
+
+
+def _makeFunc(qualname: str = "testFunc") -> MagicMock:
+    func = MagicMock()
+    func.__qualname__ = qualname
+    func.__globals__ = {"__spec__": SimpleNamespace(name="vortex.rpc.RPC_test")}
+    return func
+
+
+class RpcLoggingTest(unittest.TestCase):
+    def setUp(self) -> None:
+        _VortexRPC._VortexRPC__registeredFuncNames.clear()
+
+    def _makeRpc(
+        self,
+        *,
+        logRpcException: bool = True,
+        logTimeoutException: bool = False,
+        qualname: str = "testFunc",
+    ) -> _VortexRPC:
+        return _VortexRPC(
+            _makeFunc(qualname),
+            "listenVortexName",
+            5.0,
+            None,
+            {},
+            False,
+            False,
+            logTimeoutException=logTimeoutException,
+            logRpcException=logRpcException,
+        )
+
+    @patch("vortex.rpc.RPC.logger")
+    def testRemoteResultLogsDebugWhenLogRpcExceptionFalse(
+        self, mockLogger: MagicMock
+    ) -> None:
+        rpc = self._makeRpc(logRpcException=False, qualname="testFuncRemote")
+        payloadEnvelope = PayloadEnvelope(filt={}, result="probe not ready")
+
+        rpc._processResponseCallback(payloadEnvelope, None)
+
+        mockLogger.error.assert_not_called()
+        mockLogger.debug.assert_called_once_with(
+            "RPC response for %s: %s",
+            rpc._VortexRPC__funcName,
+            "probe not ready",
+        )
+
+    @patch("vortex.rpc.RPC.logger")
+    def testRemoteResultLogsErrorWhenLogRpcExceptionTrue(
+        self, mockLogger: MagicMock
+    ) -> None:
+        rpc = self._makeRpc(logRpcException=True, qualname="testFuncRemote2")
+        payloadEnvelope = PayloadEnvelope(filt={}, result="probe not ready")
+
+        rpc._processResponseCallback(payloadEnvelope, None)
+
+        mockLogger.debug.assert_not_called()
+        mockLogger.error.assert_called_once()
+
+    @patch("vortex.rpc.RPC.logger")
+    def testTimeoutErrbackDoesNotLogWhenPayloadResponseAlreadyDid(
+        self, mockLogger: MagicMock
+    ) -> None:
+        rpc = self._makeRpc(logRpcException=False, logTimeoutException=True)
+        rpc._processResponseErrback(Failure(TimeoutError("timed out")), None)
+        mockLogger.error.assert_not_called()
+        mockLogger.debug.assert_not_called()
+
+    @patch("vortex.rpc.RPC.vortexLogFailure")
+    @patch("vortex.rpc.RPC.logger")
+    def testCallerExceptionLogsDebugWhenLogRpcExceptionFalse(
+        self, mockLogger: MagicMock, mockLogFailure: MagicMock
+    ) -> None:
+        rpc = self._makeRpc(logRpcException=False, qualname="testFunc2")
+        rpc._processResponseErrback(Failure(ValueError("boom")), None)
+        mockLogFailure.assert_not_called()
+        mockLogger.error.assert_not_called()
+        mockLogger.debug.assert_called_once_with(
+            "RPC response for %s: %s",
+            rpc._VortexRPC__funcName,
+            "boom",
+        )
+
+    @patch("vortex.rpc.RPC.vortexLogFailure")
+    def testCallerExceptionLoggedWhenLogRpcExceptionTrue(
+        self, mockLogFailure: MagicMock
+    ) -> None:
+        rpc = self._makeRpc(logRpcException=True, qualname="testFunc3")
+        failure = Failure(ValueError("boom"))
+        rpc._processResponseErrback(failure, None)
+        mockLogFailure.assert_called_once_with(failure, ANY)
+
+    def testPayloadEndpointStoresLogProcessException(self) -> None:
+        endpoint = PayloadEndpoint(
+            dict(key="example"),
+            lambda **kwargs: None,
+            logProcessException=False,
+        )
+        self.assertFalse(endpoint._logProcessException)
+
+
+if __name__ == "__main__":
+    unittest.main()

{vortexpy-4.1.5 → vortexpy-4.1.7}/vortexpy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vortexpy
-Version: 4.1.5
+Version: 4.1.7
 Summary: Flying Ion's observable, routable, data serialisation and transport code.
 Author-email: Flying Ion Pty Ltd <contact@flyingion.com>
 License: MIT

{vortexpy-4.1.5 → vortexpy-4.1.7}/vortexpy.egg-info/SOURCES.txt

@@ -12,6 +12,7 @@ vortex/PayloadIO.py
 vortex/PayloadPriority.py
 vortex/PayloadResponse.py
 vortex/PayloadResponseTest.py
+vortex/PayloadResponse_test.py
 vortex/PayloadTest.py
 vortex/PerformTestActionTuple.py
 vortex/SerialiseUtil.py
@@ -86,6 +87,7 @@ vortex/restful/RestfulResourceTest.py
 vortex/restful/__init__.py
 vortex/rpc/RPC.py
 vortex/rpc/RPCTest.py
+vortex/rpc/RPC_test.py
 vortex/rpc/__init__.py
 vortex/sqla_orm/OrmCrudHandler.py
 vortex/sqla_orm/TupleProviderForDb.py