vortexpy 4.1.7__tar.gz → 4.2.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vortexpy
-Version: 4.1.7
+Version: 4.2.1
 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.7 → vortexpy-4.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "vortexpy"
-version = "4.1.7"
+version = "4.2.1"
 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.7 → vortexpy-4.2.1}/vortex/Jsonable.py

@@ -107,9 +107,11 @@ class Jsonable(object):
         try:
             valueType = V_NULL if value is None else toRapuiType(value)
         except KeyError as e:
+            unsupportedType = e.args[0] if e.args else value.__class__
             raise KeyError(
-                "%s field name is %s, type is %s", e, name, value.__class__
-            )
+                "%r field name is %r, type is %r"
+                % (unsupportedType, name, value.__class__)
+            ) from e
 
         # Payloads and Tuples
         if self.__isRawJsonableField(name):

{vortexpy-4.1.7 → vortexpy-4.2.1}/vortex/SerialiseUtil.py

@@ -268,11 +268,12 @@ def toRapuiType(value):
     if isinstance(value, PayloadEnvelope):
         return T_RAPUI_PAYLOAD_ENVELOPE
 
-    if isinstance(value, enum.StrEnum):
-        return T_STR
-
-    if isinstance(value, enum.IntEnum):
-        return T_INT
+    if isinstance(value, enum.Enum):
+        if isinstance(value, str):
+            return T_STR
+        if isinstance(value, int):
+            return T_INT
+        raise KeyError(value.__class__)
 
     valueClass = value.__class__
 

{vortexpy-4.1.7 → vortexpy-4.2.1}/vortex/SerialiseUtil_test.py

@@ -42,9 +42,11 @@ class SerialiseUtilTest(unittest.TestCase):
         self.assertEqual(toRapuiType(SampleIntEnumE.Two), T_INT)
 
     def testToRapuiTypePlainEnumMemberRaises(self) -> None:
-        with self.assertRaises(KeyError):
+        with self.assertRaises(KeyError) as errorInfo:
             toRapuiType(SamplePlainEnumE.Alpha)
 
+        self.assertEqual(errorInfo.exception.args, (SamplePlainEnumE,))
+
     def testToStrStrEnumMember(self) -> None:
         self.assertEqual(toStr(SampleStrEnumE.CrewDatum), "crew-datum")
 
@@ -104,3 +106,18 @@ class SerialiseUtilTest(unittest.TestCase):
         restored = TupleSelector.fromJsonStr(original.toJsonStr())
         self.assertEqual(restored.selector["priority"], 1)
         self.assertIsInstance(restored.selector["priority"], int)
+
+    def testTupleSelectorUnsupportedEnumFieldNameInError(self) -> None:
+        selector = TupleSelector(
+            "DashboardDataTimespanUpdatedTupleSelector",
+            dict(objectType=SamplePlainEnumE.Alpha),
+        )
+
+        with self.assertRaises(KeyError) as errorInfo:
+            selector.toJsonStr()
+
+        self.assertEqual(
+            errorInfo.exception.args[0],
+            "%r field name is %r, type is %r"
+            % (SamplePlainEnumE, "objectType", SamplePlainEnumE),
+        )

{vortexpy-4.1.7 → vortexpy-4.2.1}/vortex/TupleRestful.py

@@ -14,6 +14,7 @@ Implementation module; public interface remains on vortex.Tuple.
 
 from __future__ import annotations
 
+import enum
 import re
 from dataclasses import dataclass, field
 from datetime import datetime
@@ -263,6 +264,73 @@ class TupleRestfulConverter:
 
         return True
 
+    @classmethod
+    def _isStrEnumType(cls, enumType: type[enum.Enum]) -> bool:
+        return issubclass(enumType, str) and issubclass(enumType, enum.Enum)
+
+    @classmethod
+    def _isIntEnumType(cls, enumType: type[enum.Enum]) -> bool:
+        return (
+            issubclass(enumType, int)
+            and issubclass(enumType, enum.Enum)
+            and not issubclass(enumType, bool)
+        )
+
+    @classmethod
+    def _enumTypeFromHint(cls, typeHint: Any) -> type[enum.Enum] | None:
+        if isinstance(typeHint, type) and issubclass(typeHint, enum.Enum):
+            if cls._isStrEnumType(typeHint) or cls._isIntEnumType(typeHint):
+                return typeHint
+            return None
+
+        for unionArg in get_args(typeHint):
+            if unionArg is type(None):
+                continue
+            if isinstance(unionArg, type) and issubclass(unionArg, enum.Enum):
+                if cls._isStrEnumType(unionArg) or cls._isIntEnumType(unionArg):
+                    return unionArg
+
+        return None
+
+    @classmethod
+    def _tryCoerceEnumValue(
+        cls,
+        field_path: str,
+        fieldName: str,
+        TupleClass: Type[Tuple],
+        typeHint: Any,
+        value: Any,
+    ) -> tuple[Any, TupleValidationError | None]:
+        if value is None:
+            return value, None
+
+        enumType = cls._enumTypeFromHint(typeHint)
+        if enumType is None:
+            return value, None
+
+        if isinstance(value, enumType):
+            return value, None
+
+        try:
+            if cls._isStrEnumType(enumType) and isinstance(value, str):
+                return enumType(value), None
+
+            if (
+                cls._isIntEnumType(enumType)
+                and isinstance(value, int)
+                and not isinstance(value, bool)
+            ):
+                return enumType(value), None
+        except ValueError:
+            return value, cls._makeError(
+                field_path,
+                f"parsing {TupleClass}, field {fieldName}"
+                f" is not a valid {enumType.__name__} value, got {value!r}",
+                ValueError,
+            )
+
+        return value, None
+
     @classmethod
     def _nestedTupleTypeFromHint(cls, typeHint: Any) -> Any | None:
         """Return nested tuple class for a field hint, including ``X | None`` unions."""
@@ -373,6 +441,16 @@ class TupleRestfulConverter:
         else:
             for index, item in enumerate(value):
                 item_path = f"{field_path}[{index}]"
+                item, enumError = cls._tryCoerceEnumValue(
+                    item_path,
+                    fieldName,
+                    TupleClass,
+                    listItemTypeHint,
+                    item,
+                )
+                if enumError:
+                    errors.append(enumError)
+                    continue
                 itemError = cls._checkType(
                     TupleClass,
                     item_path,
@@ -532,6 +610,13 @@ class TupleRestfulConverter:
         ):
             value = datetime.strptime(value, ISO8601)
 
+        value, enumError = cls._tryCoerceEnumValue(
+            field_path, fieldName, TupleClass, typeHint, value
+        )
+        if enumError:
+            errors.append(enumError)
+            return _ConvertResult(_UNSET, errors)
+
         typeError = cls._checkType(
             TupleClass, field_path, fieldName, typeHint, value, validator
         )

vortexpy-4.1.7/vortex/TupleRestfulTest.py → vortexpy-4.2.1/vortex/TupleRestful_test.py

@@ -8,6 +8,7 @@
 
 import json
 from datetime import datetime
+from enum import IntEnum, StrEnum
 from typing import Dict, Annotated
 from typing import List
 from typing import Union
@@ -44,6 +45,23 @@ class RestfulTestTuple(Tuple):
     aDictOfSubTuples: Dict[str, "RestfulSubTestTuple"] = TupleField()
 
 
+class RestfulObjectTypeE(StrEnum):
+    EVENT = "event"
+
+
+class RestfulPriorityE(IntEnum):
+    HIGH = 1
+
+
+@addTupleType
+class RestfulEnumTestTuple(Tuple):
+    __tupleType__ = "flyingion.vortex.RestfulEnumTestTuple"
+    objectType: RestfulObjectTypeE = TupleField()
+    optionalObjectType: RestfulObjectTypeE | None = TupleField()
+    priority: RestfulPriorityE = TupleField()
+    priorities: List[RestfulPriorityE] = TupleField()
+
+
 @addTupleType
 class RestfulOptionalDatetimeTestTuple(Tuple):
     __tupleType__ = "flyingion.vortex.RestfulOptionalDatetimeTestTuple"
@@ -166,6 +184,26 @@ class TupleRestfulTest(unittest.TestCase):
         self.assertEqual(deserialisedTuple.requiredDate, origTuple.requiredDate)
         self.assertEqual(deserialisedTuple.optionalDate, origTuple.optionalDate)
 
+    def testStrEnumAndIntEnumRoundTrip(self):
+        origTuple = RestfulEnumTestTuple()
+        origTuple.objectType = RestfulObjectTypeE.EVENT
+        origTuple.optionalObjectType = RestfulObjectTypeE.EVENT
+        origTuple.priority = RestfulPriorityE.HIGH
+        origTuple.priorities = [RestfulPriorityE.HIGH]
+
+        jsonDict = origTuple.tupleToRestfulJsonDict()
+        jsonDict = json.loads(json.dumps(jsonDict))
+        deserialisedTuple = Tuple.restfulJsonDictToTupleWithValidation(
+            jsonDict, RestfulEnumTestTuple
+        )
+
+        self.assertEqual(deserialisedTuple.objectType, RestfulObjectTypeE.EVENT)
+        self.assertEqual(
+            deserialisedTuple.optionalObjectType, RestfulObjectTypeE.EVENT
+        )
+        self.assertEqual(deserialisedTuple.priority, RestfulPriorityE.HIGH)
+        self.assertEqual(deserialisedTuple.priorities, [RestfulPriorityE.HIGH])
+
     def testOptionalDatetimeNoneRoundTrip(self):
         origTuple = RestfulOptionalDatetimeTestTuple()
         origTuple.requiredDate = datetime(
@@ -258,6 +296,22 @@ class TupleRestfulCollectingTest(unittest.TestCase):
             result.errors[0].message.startswith("At aSubTuple.subInt:")
         )
 
+    def testInvalidStrEnumValueCollectsError(self):
+        jsonDict = {
+            "objectType": "not-a-valid-object-type",
+            "optionalObjectType": None,
+            "priority": 1,
+            "priorities": [],
+        }
+
+        result = Tuple.restfulJsonDictToTupleWithValidationResult(
+            jsonDict, RestfulEnumTestTuple
+        )
+
+        self.assertEqual(len(result.errors), 1)
+        self.assertEqual(result.errors[0].field_path, "objectType")
+        self.assertEqual(result.errors[0].exc_type, ValueError)
+
     def testStrictWrapperRaisesFirstCollectingError(self):
         jsonDict = _validRestfulJsonDict()
         jsonDict["aInt"] = "not-an-int"

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

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

vortexpy-4.2.1/vortex/twisted_runtime_metrics.py

@@ -0,0 +1,297 @@
+# Copyright (c) 2016-2026 Flying Ion Pty Ltd
+# See LICENSE for the full license text.
+
+"""Low-overhead Twisted reactor and thread-pool runtime metrics."""
+
+from __future__ import annotations
+
+import logging
+import os
+import sys
+import threading
+import time
+import traceback
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any, TypeVar, cast
+
+from twisted.internet.defer import Deferred
+
+from vortex.Tuple import Tuple, TupleField, addTupleType
+
+if TYPE_CHECKING:
+    from twisted.internet.task import LoopingCall
+
+logger = logging.getLogger(__name__)
+
+REACTOR_LAG_TICK_SECONDS = 0.05
+STACK_CAPTURE_THRESHOLD_MS = 50.0
+
+_TWISTED_RUNTIME_METRICS_TUPLE_PREFIX = "vortex.twisted_runtime_metrics."
+
+_F = TypeVar("_F", bound=Callable[..., Any])
+
+# TupleField defaults are typed as TupleField at class body; runtime values match annotations.
+# pyright: reportAssignmentType=false
+
+
+@addTupleType
+class TwistedRuntimeMetricsSnapshot(Tuple):
+    __tupleType__ = (
+        _TWISTED_RUNTIME_METRICS_TUPLE_PREFIX + "TwistedRuntimeMetricsSnapshot"
+    )
+
+    threadPoolBusy: int = TupleField()
+    threadPoolQueued: int = TupleField()
+    threadPoolMax: int = TupleField()
+    threadedCallCount: int = TupleField()
+    longestThreadedMethodName: str | None = TupleField(None)
+    longestThreadedMethodMs: float = TupleField()
+    longestThreadedMethodFrame: str | None = TupleField(None)
+    longestReactorBlockMs: float = TupleField()
+    longestReactorBlockFrame: str | None = TupleField(None)
+    loopingCallExceptionCount: int = TupleField()
+    loopingCallLongestExceptionMethod: str | None = TupleField(None)
+    loopingCallLastExceptionMethod: str | None = TupleField(None)
+    loopingCallLastExceptionFrame: str | None = TupleField(None)
+    windowSeconds: int = TupleField()
+
+
+class TwistedRuntimeMetrics:
+    _instance: TwistedRuntimeMetrics | None = None
+    _instanceLock = threading.Lock()
+
+    def __init__(self) -> None:
+        self._metricsLock = threading.Lock()
+        self._started = False
+        self._loop: LoopingCall | None = None
+        self._nextExpectedMonotonic = 0.0
+        self._threadedCallCount = 0
+        self._longestThreadedMethodName: str | None = None
+        self._longestThreadedMethodMs = 0.0
+        self._longestThreadedMethodFrame: str | None = None
+        self._longestReactorBlockMs = 0.0
+        self._longestReactorBlockFrame: str | None = None
+        self._loopingCallExceptionCount = 0
+        self._loopingCallExceptionCountByMethod: dict[str, int] = {}
+        self._loopingCallLongestExceptionMethod: str | None = None
+        self._loopingCallLastExceptionMethod: str | None = None
+        self._loopingCallLastExceptionFrame: str | None = None
+        self._windowStartedMonotonic = time.monotonic()
+
+    @classmethod
+    def _collector(cls) -> TwistedRuntimeMetrics:
+        if cls._instance is not None:
+            return cls._instance
+        with cls._instanceLock:
+            if cls._instance is None:
+                cls._instance = cls()
+            return cls._instance
+
+    @classmethod
+    def start(cls, reactorArg: Any) -> None:
+        cls._collector()._start(reactorArg)
+
+    @classmethod
+    def snapshotAndResetWindow(cls) -> TwistedRuntimeMetricsSnapshot:
+        return cls._collector()._snapshotAndResetWindow()
+
+    def _start(self, reactorArg: Any) -> None:
+        if self._started:
+            return
+        from twisted.internet.task import LoopingCall
+
+        self._windowStartedMonotonic = time.monotonic()
+        self._nextExpectedMonotonic = time.monotonic() + REACTOR_LAG_TICK_SECONDS
+        self._loop = LoopingCall(
+            vortexLoopingCallCatchWithMetrics(logger)(self._tickReactorLag)
+        )
+        self._loop.start(REACTOR_LAG_TICK_SECONDS, now=True)
+        self._started = True
+        logger.info(
+            "TwistedRuntimeMetrics started (lag tick=%ss)",
+            REACTOR_LAG_TICK_SECONDS,
+        )
+
+    def _recordThreadedCall(
+        self,
+        methodQualname: str,
+        durationMs: float,
+        methodFrame: str | None = None,
+    ) -> None:
+        with self._metricsLock:
+            self._threadedCallCount += 1
+            if durationMs <= self._longestThreadedMethodMs:
+                return
+            self._longestThreadedMethodMs = durationMs
+            self._longestThreadedMethodName = methodQualname
+            self._longestThreadedMethodFrame = methodFrame
+
+    def _recordLoopingCallException(
+        self,
+        methodQualname: str,
+        exceptionFrame: str | None = None,
+    ) -> None:
+        with self._metricsLock:
+            self._loopingCallExceptionCount += 1
+            methodCount = (
+                self._loopingCallExceptionCountByMethod.get(methodQualname, 0) + 1
+            )
+            self._loopingCallExceptionCountByMethod[methodQualname] = methodCount
+            self._loopingCallLastExceptionMethod = methodQualname
+            self._loopingCallLastExceptionFrame = exceptionFrame
+            longestCount = 0
+            if self._loopingCallLongestExceptionMethod is not None:
+                longestCount = self._loopingCallExceptionCountByMethod[
+                    self._loopingCallLongestExceptionMethod
+                ]
+            if (
+                self._loopingCallLongestExceptionMethod is None
+                or methodCount > longestCount
+            ):
+                self._loopingCallLongestExceptionMethod = methodQualname
+
+    def _snapshotAndResetWindow(self) -> TwistedRuntimeMetricsSnapshot:
+        from twisted.internet import reactor
+
+        pool = reactor.getThreadPool()  # type: ignore[attr-defined]  # pyright: ignore[reportAttributeAccessIssue]
+        threadPoolBusy = len(pool.working)
+        threadPoolQueued = len(pool.waiters)
+
+        with self._metricsLock:
+            elapsedSeconds = time.monotonic() - self._windowStartedMonotonic
+            windowSeconds = int(max(1, round(elapsedSeconds)))
+            snapshot = TwistedRuntimeMetricsSnapshot(
+                threadPoolBusy=threadPoolBusy,
+                threadPoolQueued=threadPoolQueued,
+                threadPoolMax=pool.max,
+                threadedCallCount=self._threadedCallCount,
+                longestThreadedMethodName=self._longestThreadedMethodName,
+                longestThreadedMethodMs=self._longestThreadedMethodMs,
+                longestThreadedMethodFrame=self._longestThreadedMethodFrame,
+                longestReactorBlockMs=self._longestReactorBlockMs,
+                longestReactorBlockFrame=self._longestReactorBlockFrame,
+                loopingCallExceptionCount=self._loopingCallExceptionCount,
+                loopingCallLongestExceptionMethod=(
+                    self._loopingCallLongestExceptionMethod
+                ),
+                loopingCallLastExceptionMethod=(self._loopingCallLastExceptionMethod),
+                loopingCallLastExceptionFrame=(self._loopingCallLastExceptionFrame),
+                windowSeconds=windowSeconds,
+            )
+            self._resetWindowCountersLocked()
+            return snapshot
+
+    def _tickReactorLag(self) -> None:
+        now = time.monotonic()
+        lagMs = (now - self._nextExpectedMonotonic) * 1000.0
+        self._nextExpectedMonotonic = now + REACTOR_LAG_TICK_SECONDS
+        if lagMs <= 0:
+            return
+        with self._metricsLock:
+            if lagMs <= self._longestReactorBlockMs:
+                return
+            self._longestReactorBlockMs = lagMs
+            if lagMs >= STACK_CAPTURE_THRESHOLD_MS:
+                self._longestReactorBlockFrame = self._captureMainThreadFrame()
+
+    def _resetWindowCountersLocked(self) -> None:
+        self._windowStartedMonotonic = time.monotonic()
+        self._threadedCallCount = 0
+        self._longestThreadedMethodName = None
+        self._longestThreadedMethodMs = 0.0
+        self._longestThreadedMethodFrame = None
+        self._longestReactorBlockMs = 0.0
+        self._longestReactorBlockFrame = None
+        self._loopingCallExceptionCount = 0
+        self._loopingCallExceptionCountByMethod = {}
+        self._loopingCallLongestExceptionMethod = None
+        self._loopingCallLastExceptionMethod = None
+        self._loopingCallLastExceptionFrame = None
+
+    @staticmethod
+    def _utilSkipInternalMetricsFrame(filename: str) -> bool:
+        basename = os.path.basename(filename)
+        return basename in ("twisted_runtime_metrics.py", "DeferUtil.py")
+
+    @staticmethod
+    def _captureMainThreadFrame() -> str | None:
+        mainThreadIdent = threading.main_thread().ident
+        if mainThreadIdent is None:
+            return None
+        frame = sys._current_frames().get(mainThreadIdent)
+        if frame is None:
+            return None
+        for summary in reversed(traceback.extract_stack(frame)):
+            if TwistedRuntimeMetrics._utilSkipInternalMetricsFrame(summary.filename):
+                continue
+            return f"{summary.filename}:{summary.name}:{summary.lineno}"
+        return None
+
+    @staticmethod
+    def _captureWorkerThreadFrame() -> str | None:
+        for summary in reversed(traceback.extract_stack()):
+            if TwistedRuntimeMetrics._utilSkipInternalMetricsFrame(summary.filename):
+                continue
+            return f"{summary.filename}:{summary.name}:{summary.lineno}"
+        return None
+
+    @staticmethod
+    def _captureExceptionFrame() -> str | None:
+        _excType, _excValue, excTraceback = sys.exc_info()
+        if excTraceback is None:
+            return None
+        for summary in reversed(traceback.extract_tb(excTraceback)):
+            if TwistedRuntimeMetrics._utilSkipInternalMetricsFrame(summary.filename):
+                continue
+            return f"{summary.filename}:{summary.name}:{summary.lineno}"
+        return None
+
+
+def vortexLoopingCallCatchWithMetrics(
+    loggerArg: logging.Logger,
+) -> Callable[[_F], _F]:
+    """LoopingCall safety wrapper: log, count, do not re-raise."""
+
+    def wrapper(funcToWrap: _F) -> _F:
+        methodQualname = funcToWrap.__qualname__
+
+        def func(*args: Any, **kwargs: Any) -> Any:
+            try:
+                result = funcToWrap(*args, **kwargs)
+            except Exception:
+                exceptionFrame = TwistedRuntimeMetrics._captureExceptionFrame()
+                loggerArg.exception(
+                    "LoopingCall method %s raised; continuing loop",
+                    methodQualname,
+                )
+                TwistedRuntimeMetrics._collector()._recordLoopingCallException(
+                    methodQualname,
+                    exceptionFrame,
+                )
+                return None
+
+            if isinstance(result, Deferred):
+                _ = result.addErrback(
+                    _logicLoopingCallDeferredFailure,
+                    loggerArg,
+                    methodQualname,
+                )
+            return result
+
+        return cast(_F, func)
+
+    return wrapper
+
+
+def _logicLoopingCallDeferredFailure(
+    failure: Any,
+    loggerArg: logging.Logger,
+    methodQualname: str,
+) -> None:
+    from vortex.DeferUtil import vortexLogFailure
+
+    _ = vortexLogFailure(failure, loggerArg, consumeError=True)
+    TwistedRuntimeMetrics._collector()._recordLoopingCallException(
+        methodQualname,
+        None,
+    )

vortexpy-4.2.1/vortex/twisted_runtime_metrics_test.py

@@ -0,0 +1,134 @@
+# Copyright (c) 2016-2026 Flying Ion Pty Ltd
+# See LICENSE for the full license text.
+
+from __future__ import annotations
+
+import logging
+from collections.abc import Generator
+from typing import Any
+
+import pytest
+from twisted.internet.defer import Deferred, fail
+
+from vortex.twisted_runtime_metrics import (
+    TwistedRuntimeMetrics,
+    vortexLoopingCallCatchWithMetrics,
+)
+
+logger = logging.getLogger(__name__)
+
+
+@vortexLoopingCallCatchWithMetrics(logger)
+def failingTick() -> None:
+    raise RuntimeError("tick failed")
+
+
+@vortexLoopingCallCatchWithMetrics(logger)
+def failingDeferredTick() -> Deferred[Any]:
+    return fail(RuntimeError("deferred tick failed"))
+
+
+def utilResetTwistedRuntimeMetricsSingletonForTests() -> None:
+    with TwistedRuntimeMetrics._instanceLock:
+        TwistedRuntimeMetrics._instance = None
+
+
+@pytest.fixture(autouse=True)
+def resetMetricsSingleton() -> Generator[None, None, None]:
+    utilResetTwistedRuntimeMetricsSingletonForTests()
+    yield
+    utilResetTwistedRuntimeMetricsSingletonForTests()
+
+
+def testRecordThreadedCallTracksCountAndLongestMethod() -> None:
+    collector = TwistedRuntimeMetrics._collector()
+    collector._recordThreadedCall("slow.Method", 100.0)
+    collector._recordThreadedCall("slower.Method", 250.5, "slow.py:run:10")
+    snapshot = TwistedRuntimeMetrics.snapshotAndResetWindow()
+    assert snapshot.threadedCallCount == 2, "both threaded calls must count in window"
+    assert snapshot.longestThreadedMethodName == "slower.Method", (
+        "longest name must be the slowest call"
+    )
+    assert snapshot.longestThreadedMethodMs == 250.5, (
+        "longest duration must match slowest call"
+    )
+    assert snapshot.longestThreadedMethodFrame == "slow.py:run:10", (
+        "slow-call frame must be preserved"
+    )
+    assert snapshot.windowSeconds >= 1, "snapshot must report elapsed window seconds"
+
+
+def testSnapshotResetsWindowCounters() -> None:
+    TwistedRuntimeMetrics._collector()._recordThreadedCall("one.Method", 50.0)
+    firstSnapshot = TwistedRuntimeMetrics.snapshotAndResetWindow()
+    secondSnapshot = TwistedRuntimeMetrics.snapshotAndResetWindow()
+    assert firstSnapshot.threadedCallCount == 1, "first snapshot includes recorded call"
+    assert firstSnapshot.longestThreadedMethodMs == 50.0, (
+        "first snapshot longest ms must match recorded call"
+    )
+    assert secondSnapshot.threadedCallCount == 0, "window counters reset after snapshot"
+    assert secondSnapshot.longestThreadedMethodMs == 0.0, (
+        "longest ms resets to zero after snapshot"
+    )
+
+
+def testLoopingCallCatchWithMetricsRecordsSyncException() -> None:
+    failingTick()
+    snapshot = TwistedRuntimeMetrics.snapshotAndResetWindow()
+    assert snapshot.loopingCallExceptionCount == 1, (
+        "sync tick exception must increment count"
+    )
+    assert snapshot.loopingCallLongestExceptionMethod == "failingTick", (
+        "longest exception method must be failing tick"
+    )
+    assert snapshot.loopingCallLastExceptionMethod == "failingTick", (
+        "last exception method must be failing tick"
+    )
+    assert snapshot.loopingCallLastExceptionFrame is not None, (
+        "sync exception must capture a frame"
+    )
+
+
+def testLoopingCallLongestExceptionMethodUsesHighestCount() -> None:
+    collector = TwistedRuntimeMetrics._collector()
+    collector._recordLoopingCallException("noisyTick", "a.py:1")
+    collector._recordLoopingCallException("noisyTick", "a.py:2")
+    collector._recordLoopingCallException("quietTick", "b.py:1")
+    snapshot = TwistedRuntimeMetrics.snapshotAndResetWindow()
+    assert snapshot.loopingCallExceptionCount == 3, "three exceptions must be counted"
+    assert snapshot.loopingCallLongestExceptionMethod == "noisyTick", (
+        "longest method is highest per-method exception count"
+    )
+    assert snapshot.loopingCallLastExceptionMethod == "quietTick", (
+        "last method is most recent exception"
+    )
+
+
+def testTickReactorLagRecordsLongestBlock() -> None:
+    collector = TwistedRuntimeMetrics._collector()
+    collector._nextExpectedMonotonic = 0.0
+    collector._tickReactorLag()
+    assert collector._longestReactorBlockMs > 0.0, (
+        "late lag tick must record longestReactorBlockMs"
+    )
+    snapshot = TwistedRuntimeMetrics.snapshotAndResetWindow()
+    assert snapshot.longestReactorBlockMs > 0.0, (
+        "snapshot must include recorded reactor block ms"
+    )
+
+
+def testLoopingCallCatchWithMetricsRecordsDeferredFailure() -> None:
+    _ = failingDeferredTick()
+    snapshot = TwistedRuntimeMetrics.snapshotAndResetWindow()
+    assert snapshot.loopingCallExceptionCount == 1, (
+        "deferred tick failure must increment exception count"
+    )
+    assert snapshot.loopingCallLongestExceptionMethod == "failingDeferredTick", (
+        "deferred failure must set longest exception method"
+    )
+    assert snapshot.loopingCallLastExceptionMethod == "failingDeferredTick", (
+        "deferred failure must set last exception method"
+    )
+    assert snapshot.loopingCallLastExceptionFrame is None, (
+        "deferred failures do not capture sync exception frames"
+    )

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vortexpy
-Version: 4.1.7
+Version: 4.2.1
 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.7 → vortexpy-4.2.1}/vortexpy.egg-info/SOURCES.txt

@@ -24,7 +24,7 @@ vortex/TupleDataForTest.py
 vortex/TuplePerfTest.py
 vortex/TuplePolymorphicTupleTypeFieldArgTest.py
 vortex/TupleRestful.py
-vortex/TupleRestfulTest.py
+vortex/TupleRestful_test.py
 vortex/TupleSelector.py
 vortex/TupleTest.py
 vortex/VortexABC.py
@@ -54,6 +54,8 @@ vortex/VortexWritePushProducer.py
 vortex/__init__.py
 vortex/mypy_plugin.py
 vortex/py.typed
+vortex/twisted_runtime_metrics.py
+vortex/twisted_runtime_metrics_test.py
 vortex/data_loader/TupleDataLiveLockManager.py
 vortex/data_loader/TupleDataLoader.py
 vortex/data_loader/TupleDataLoaderDelegate.py