fixtureqa 0.4.23__tar.gz → 0.4.25__tar.gz

{fixtureqa-0.4.23/fixtureqa.egg-info → fixtureqa-0.4.25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fixtureqa
-Version: 0.4.23
+Version: 0.4.25
 Summary: FIXture — FIX Protocol Testing Tool
 Requires-Python: >=3.10
 License-File: LICENSE

{fixtureqa-0.4.23 → fixtureqa-0.4.25}/fixture/api/routers/perf.py

@@ -44,6 +44,32 @@ Admin = Annotated[User, Depends(require_platform_admin)]
 
 _TERMINAL = ("completed", "stopped", "error")
 
+# Per-message persistence — durable_seqnums (fsync per message) and log_messages
+# (a messages.db write per message) — happens inline on the event loop's
+# send/receive path. Measured sustainable rate is ~36 msg/s on a local disk and
+# materially worse on a Docker/WSL2 named volume; past that the loop stalls on
+# fsync and the whole server appears frozen. We hold a conservative ceiling so a
+# logged run at a low rate still works, while a high-rate logged run is refused
+# up front (before the run starts) rather than wedging the server.
+DURABLE_SAFE_MSG_RATE = 30  # messages/second a logged/durable session can sustain
+
+
+def _est_msgs_per_order(body: RunConfig) -> int:
+    """Rough peak FIX message count generated per order, for the durability rate
+    guard: 35=D out + 35=8 ack + fills, plus a request+reply pair for each of the
+    amend / cancel flavours when enabled. Deliberately an upper-ish bound."""
+    n = 2 + body.payload.fill.fills_per_order   # order + ack + fills
+    if body.amend.enabled:
+        n += 2                                  # 35=G + 35=8 replace
+    if body.cancel.enabled:
+        n += 2                                  # 35=F + 35=8/9 reply
+    return max(1, n)
+
+
+def _order_rate_per_s(body: RunConfig) -> float:
+    r = body.rate
+    return r.orders_per_window * 1000.0 / r.order_window_ms
+
 
 def _require_started(sm: SessionManager, sid: str, label: str):
     try:
@@ -68,10 +94,45 @@ async def create_run(body: RunConfig, sm: SM, reg: REG, ts: TS, admin: Admin):
     # (a sync def route runs in a threadpool with no running loop).
     need_client = body.mode in ("loopback", "manager", "client")
     need_venue = body.mode in ("loopback", "manager", "venue")
+    participating: list[tuple[str, object]] = []   # (label, config) for fixture legs
     if need_client:
-        _require_started(sm, body.client_session_id, "client")
+        participating.append(("client", _require_started(sm, body.client_session_id, "client").config))
     if need_venue:
-        _require_started(sm, body.venue_session_id, "venue")
+        participating.append(("venue", _require_started(sm, body.venue_session_id, "venue").config))
+
+    # Durability rate guard — BEFORE reg.create() (which starts the run). A
+    # session with durable_seqnums or log_messages persists every message inline
+    # on the event loop; above a low rate this stalls the loop and freezes the
+    # whole server. Allow a logged run at a safe low rate (useful to inspect the
+    # messages); refuse above it with the safe order rate spelled out.
+    logged = [(label, cfg) for label, cfg in participating
+              if cfg.durable_seqnums or cfg.log_messages]
+    durable_warnings: list[str] = []
+    if logged:
+        mpo = _est_msgs_per_order(body)
+        est_msg_rate = _order_rate_per_s(body) * mpo
+        safe_order_rate = DURABLE_SAFE_MSG_RATE / mpo
+
+        def _flags(cfg) -> str:
+            f = [n for n, on in (("durable_seqnums", cfg.durable_seqnums),
+                                 ("log_messages", cfg.log_messages)) if on]
+            return "+".join(f)
+        who = ", ".join(f"{label} ({_flags(cfg)})" for label, cfg in logged)
+
+        if est_msg_rate > DURABLE_SAFE_MSG_RATE:
+            raise HTTPException(status_code=409, detail=(
+                f"This run would generate ~{est_msg_rate:.0f} msg/s "
+                f"(~{mpo} msgs/order × {_order_rate_per_s(body):.0f} orders/s), but "
+                f"{who} persist every message inline on the event loop "
+                f"(fsync / messages.db write). Above ~{DURABLE_SAFE_MSG_RATE} msg/s "
+                f"this stalls the server. Either lower the order rate to "
+                f"≤ {safe_order_rate:.0f}/s to keep message logging, or convert the "
+                f"session(s) to a Performance session (durable_seqnums + log_messages "
+                f"off) for high-rate runs."))
+        durable_warnings.append(
+            f"message persistence is on for {who}; safe only up to "
+            f"~{safe_order_rate:.0f} orders/s (~{DURABLE_SAFE_MSG_RATE} msg/s) — at "
+            f"higher rates the event loop stalls on per-message fsync/DB writes")
 
     # CompIDs from the driving (client, else venue) session — for template tokens.
     drive_sid = body.client_session_id if need_client else body.venue_session_id
@@ -82,18 +143,7 @@ async def create_run(body: RunConfig, sm: SM, reg: REG, ts: TS, admin: Admin):
     except PerfConfigError as e:
         raise HTTPException(status_code=422, detail=str(e))
 
-    # Soft perf warnings — don't block, but flag footguns.
-    checked = []
-    if need_client:
-        checked.append((body.client_session_id, "client"))
-    if need_venue:
-        checked.append((body.venue_session_id, "venue"))
-    for sid, label in checked:
-        cfg = sm.get_state(sid).config
-        if cfg.durable_seqnums:
-            run.warnings.append(f"{label} session has durable_seqnums=True — fsync per message caps throughput")
-        if cfg.log_messages:
-            run.warnings.append(f"{label} session has log_messages=True — persistence churn adds loop latency")
+    run.warnings.extend(durable_warnings)
     return {"run_id": run.run_id}
 
 

{fixtureqa-0.4.23 → fixtureqa-0.4.25}/fixture/core/perf_payload.py

@@ -503,8 +503,13 @@ class PayloadFactory:
             order_qty = ctx["qty"]
             msg.set_field(38, str(order_qty))
         self._apply_expiry(msg, fields)
-        return msg, {"corr_id": corr, "clordid": clordid, "symbol": ctx["symbol"],
-                     "side": ctx["side"], "qty": ctx["qty"], "price": ctx["price"],
+        # Mirror the values that actually went on the wire (template-rendered when
+        # present, else the ctx defaults we just set) so amend/cancel 35=G/35=F
+        # echo the order's real Symbol(55)/Side(54), not the ORDER PAYLOAD section.
+        return msg, {"corr_id": corr, "clordid": clordid,
+                     "symbol": rendered.get(55, ctx["symbol"]),
+                     "side": rendered.get(54, ctx["side"]),
+                     "qty": ctx["qty"], "price": ctx["price"],
                      "order_qty": order_qty, "msg_type": mtype,
                      "mirror_tags": self._mirror_tags(msg)}