fixtureqa 0.8.3__tar.gz → 0.9.1__tar.gz

{fixtureqa-0.8.3/fixtureqa.egg-info → fixtureqa-0.9.1}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: fixtureqa
-Version: 0.8.3
+Version: 0.9.1
 Summary: FIXture — FIX Protocol Testing Tool
 Requires-Python: >=3.10
 License-File: LICENSE
-Requires-Dist: fixcore-engine==0.7.1
+Requires-Dist: fixcore-engine==0.8.1
 Requires-Dist: fastapi>=0.111.0
 Requires-Dist: uvicorn[standard]>=0.29.0
 Requires-Dist: websockets>=12.0

{fixtureqa-0.8.3 → fixtureqa-0.9.1}/fixture/api/routers/perf.py

@@ -53,6 +53,18 @@ _TERMINAL = ("completed", "stopped", "error")
 # up front (before the run starts) rather than wedging the server.
 DURABLE_SAFE_MSG_RATE = 30  # messages/second a logged/durable session can sustain
 
+# Session configs that add work to the per-message hot path on the event loop —
+# they distort (or, for check_latency, can outright reject messages and corrupt)
+# the very latency a perf run measures. Unlike durable persistence there is no
+# rate at which they're safe, so a run that drives a session with any of them on
+# is refused up front. (label, why) — the Performance-session toggle in the
+# session modal clears all of them.
+_PERF_HOSTILE_KEYS: tuple[tuple[str, str], ...] = (
+    ("validate_inbound", "validates every inbound message against the spec on the loop"),
+    ("check_latency", "parses SendingTime(52) and may reject messages on the loop"),
+    ("enable_last_msg_seq_num_processed", "stamps LastMsgSeqNumProcessed(369) on every outbound message"),
+)
+
 
 def _order_rate_per_s(body: RunConfig) -> float:
     r = body.rate
@@ -144,6 +156,25 @@ async def create_run(body: RunConfig, sm: SM, reg: REG, ts: TS, admin: Admin):
             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")
 
+    # Per-message latency guard — BEFORE reg.create(). Refuse outright if any
+    # driven session has a perf-hostile key on: these add work to the per-message
+    # hot path on the event loop (or reject messages outright) and distort the
+    # latency the run exists to measure. No safe rate, so unlike the durability
+    # guard this is a hard refusal rather than a throttle.
+    offenders = [
+        (label, attr, why)
+        for label, cfg in participating
+        for attr, why in _PERF_HOSTILE_KEYS
+        if getattr(cfg, attr, False)
+    ]
+    if offenders:
+        detail = "; ".join(f"{label} session has {attr} on ({why})"
+                           for label, attr, why in offenders)
+        raise HTTPException(status_code=409, detail=(
+            f"Refusing to start: {detail}. These add per-message work on the event "
+            f"loop and distort latency measurement — turn them off (or tick "
+            f"'Performance session' in the session modal) before running a perf test."))
+
     # 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
     dcfg = sm.get_state(drive_sid).config

{fixtureqa-0.8.3 → fixtureqa-0.9.1}/fixture/api/routers/sessions.py

@@ -68,6 +68,7 @@ def _session_response(sm: SessionManager, session_id: str, us: Optional[UserStor
         requires_orig_sending_time=cfg.requires_orig_sending_time,
         resend_request_chunk_size=cfg.resend_request_chunk_size,
         send_redundant_resend_requests=cfg.send_redundant_resend_requests,
+        enable_last_msg_seq_num_processed=cfg.enable_last_msg_seq_num_processed,
         use_file_log=cfg.use_file_log,
         start_time=cfg.start_time,
         end_time=cfg.end_time,

{fixtureqa-0.8.3 → fixtureqa-0.9.1}/fixture/api/schemas.py

@@ -21,6 +21,7 @@ class SessionConfigRequest(BaseModel):
     requires_orig_sending_time: bool = True       # RequiresOrigSendingTime
     resend_request_chunk_size: int = Field(default=0, ge=0)  # 0 = unlimited
     send_redundant_resend_requests: bool = False
+    enable_last_msg_seq_num_processed: bool = False  # stamp LastMsgSeqNumProcessed(369)
     data_dictionary_path: Optional[str] = None
     use_file_log: bool = True
     start_time: str = "00:00:00"
@@ -67,6 +68,7 @@ class SessionResponse(BaseModel):
     requires_orig_sending_time: bool
     resend_request_chunk_size: int
     send_redundant_resend_requests: bool
+    enable_last_msg_seq_num_processed: bool
     use_file_log: bool
     start_time: str
     end_time: str
@@ -118,6 +120,7 @@ class UpdateSessionRequest(BaseModel):
     requires_orig_sending_time: Optional[bool] = None
     resend_request_chunk_size: Optional[int] = Field(default=None, ge=0)
     send_redundant_resend_requests: Optional[bool] = None
+    enable_last_msg_seq_num_processed: Optional[bool] = None
     data_dictionary_path: Optional[str] = None
     use_file_log: Optional[bool] = None
     start_time: Optional[str] = None

{fixtureqa-0.8.3 → fixtureqa-0.9.1}/fixture/core/models.py

@@ -108,6 +108,12 @@ class SessionConfig:
     # outstanding (default N = re-request only when the gap advances).
     send_redundant_resend_requests: bool = False
 
+    # Message header (fixcore)
+    # Stamp LastMsgSeqNumProcessed(369) on every outbound message header, set to
+    # the seqnum of the last inbound message processed, so the peer can gauge how
+    # far behind we are (fixcore EnableLastMsgSeqNumProcessed). Off by default.
+    enable_last_msg_seq_num_processed: bool = False
+
     # Seqnum/message store durability. True (default) = fixcore FileStore, which
     # fsyncs per message (durable resend/recovery, but caps throughput at disk
     # speed). False = in-memory store: no per-message fsync, far higher

{fixtureqa-0.8.3 → fixtureqa-0.9.1}/fixture/core/session.py

@@ -382,6 +382,7 @@ class Session:
             f"RequiresOrigSendingTime={yn(self.config.requires_orig_sending_time)}",
             f"ResendRequestChunkSize={self.config.resend_request_chunk_size}",
             f"SendRedundantResendRequests={yn(self.config.send_redundant_resend_requests)}",
+            f"EnableLastMsgSeqNumProcessed={yn(self.config.enable_last_msg_seq_num_processed)}",
             *schedule_lines,
             f"DataDictionary={dd_path}",
             # Always load the dictionary so inbound repeating groups decode into