fixtureqa 0.4.20__tar.gz → 0.4.22__tar.gz

{fixtureqa-0.4.20/fixtureqa.egg-info → fixtureqa-0.4.22}/PKG-INFO

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

{fixtureqa-0.4.20 → fixtureqa-0.4.22}/fixture/api/routers/perf.py

@@ -212,13 +212,18 @@ def run_export(run_id: str, reg: REG, pw: PW, _admin: Admin,
 
 @router.get("/runs/{run_id}/chart")
 async def run_chart(run_id: str, reg: REG, _admin: Admin,
-                    metric: str = Query("one_way"), agg: str = Query("both")):
+                    metric: str = Query("one_way"), agg: str = Query("both"),
+                    scale: str = Query("log")):
     """Per-message latency chart (PNG) from the run's recorded csv.gz. Rendered
-    off-loop on first request and cached per (metric, agg) — the CSV is immutable
-    once the run finishes. Needs record_latency; 404 otherwise, 409 while live."""
-    if metric not in ("one_way", "round_trip", "both") or agg not in ("scatter", "percentile", "both"):
+    off-loop on first request and cached per (metric, agg, scale) — the CSV is
+    immutable once the run finishes. Needs record_latency; 404 otherwise, 409
+    while live."""
+    if (metric not in ("one_way", "round_trip", "both")
+            or agg not in ("scatter", "percentile", "both")
+            or scale not in ("log", "linear")):
         raise HTTPException(status_code=422,
-                            detail="metric must be one_way|round_trip|both; agg must be scatter|percentile|both")
+                            detail="metric must be one_way|round_trip|both; "
+                                   "agg must be scatter|percentile|both; scale must be log|linear")
     if not reg.exists(run_id):
         raise HTTPException(status_code=404, detail="Run not found")
     if _run_is_live(reg, run_id):
@@ -234,13 +239,13 @@ async def run_chart(run_id: str, reg: REG, _admin: Admin,
     one_way_label = None
     if st is not None and st.mode not in ("loopback", "manager"):
         one_way_label = "one-way (tag-60 wire send → recv; needs synced clocks)"
-    out_path = f"{csv_path[:-len('.csv.gz')]}_{metric}_{agg}.png"
+    out_path = f"{csv_path[:-len('.csv.gz')]}_{metric}_{agg}_{scale}.png"
     if not os.path.exists(out_path):
         try:
             await asyncio.to_thread(
                 render_latency_chart, csv_path, out_path,
-                metric=metric, agg=agg, title=f"Per-message latency — {run_id}",
-                one_way_label=one_way_label)
+                metric=metric, agg=agg, logy=(scale == "log"),
+                title=f"Per-message latency — {run_id}", one_way_label=one_way_label)
         except ValueError as e:
             # No chartable points (e.g. recording produced only un-latencied rows).
             raise HTTPException(status_code=404, detail=str(e))

{fixtureqa-0.4.20 → fixtureqa-0.4.22}/fixture/core/perf_charts.py

@@ -53,10 +53,25 @@ def _pctl(sorted_vals: list[float], q: float) -> float:
     return sorted_vals[i]
 
 
+def _humanize_us(v, _pos=None) -> str:
+    """Format a microsecond value as a self-describing tick label, picking the
+    unit per tick so a log axis spanning µs→s reads '500µs / 1ms / 10ms / 1s'
+    instead of 10^1 / 10^2. Handles negatives (tag-60 clock skew)."""
+    if v == 0:
+        return "0"
+    sign, a = ("-" if v < 0 else ""), abs(v)
+    if a < 1_000:
+        return f"{sign}{a:g}µs"
+    if a < 1_000_000:
+        return f"{sign}{a / 1_000:g}ms"
+    return f"{sign}{a / 1_000_000:g}s"
+
+
 def _read_points(csv_gz_path: str, metric: str):
-    """Group (x_seconds_since_start, y_ms) points by kind from the gz CSV for one
-    metric ('one_way' or 'round_trip'): y = that latency column, x = its send
-    column rebased to seconds since the first send."""
+    """Group (x_seconds_since_start, y_microseconds) points by kind from the gz
+    CSV for one metric ('one_way' or 'round_trip'): y = that latency column (raw
+    µs — the axis humanizes per tick), x = its send column rebased to seconds
+    since the first send."""
     y_col, x_col, _ = _METRIC[metric]
     by_kind: dict[str, list[tuple[float, float]]] = defaultdict(list)
     t0: Optional[float] = None
@@ -68,11 +83,11 @@ def _read_points(csv_gz_path: str, metric: str):
                 continue
             try:
                 x = float(xraw)
-                y_ms = float(yraw) / 1000.0
+                y_us = float(yraw)
             except ValueError:
                 continue
             t0 = x if t0 is None else min(t0, x)
-            by_kind[r.get("kind") or "unknown"].append((x, y_ms))
+            by_kind[r.get("kind") or "unknown"].append((x, y_us))
     if t0 is not None:
         for pts in by_kind.values():
             pts[:] = [(x - t0, y) for (x, y) in pts]
@@ -98,15 +113,25 @@ def _draw(ax, by_kind, agg: str, bucket_s: float, logy: bool, ylabel: str, title
                        color=color, label=None if agg == "both" else kind,
                        edgecolors="none")
         if agg in ("percentile", "both"):
-            bx, p50, p99 = _bucketed(pts, bucket_s)
+            bx, p50, p99, pmax = _bucketed(pts, bucket_s)
             if bx:
                 ax.plot(bx, p50, color=color, lw=1.6, label=f"{kind} p50")
                 ax.plot(bx, p99, color=color, lw=1.0, ls="--", alpha=0.7,
                         label=f"{kind} p99")
+                # p100 / worst-case per bucket — the outlier envelope (faint dots)
+                ax.plot(bx, pmax, color=color, lw=0.8, ls=":", alpha=0.55,
+                        label=f"{kind} max")
+    from matplotlib.ticker import FuncFormatter, LogLocator, NullFormatter
     ax.set_xlabel("run time (s, from first send)")
     ax.set_ylabel(ylabel + ("  [log]" if logy else ""))
     if logy:
         ax.set_yscale("log")
+        # 1-2-5 per decade as labelled ticks (so narrow ranges still get several
+        # labels); finer minors as unlabelled gridlines.
+        ax.yaxis.set_major_locator(LogLocator(base=10, subs=(1.0, 2.0, 5.0)))
+        ax.yaxis.set_minor_locator(LogLocator(base=10, subs=tuple(x / 10 for x in range(10, 100))))
+        ax.yaxis.set_minor_formatter(NullFormatter())
+    ax.yaxis.set_major_formatter(FuncFormatter(_humanize_us))
     ax.grid(True, which="both", ls=":", alpha=0.4)
     ax.legend(loc="upper left", fontsize=8, ncol=2, framealpha=0.85)
     ax.set_title(title)
@@ -147,7 +172,7 @@ def render_latency_chart(csv_gz_path: str, out_path: str, *, metric: str = "one_
     base = title or "Per-message latency"
     for ax, (m, by_kind) in zip(axes, panels):
         label = one_way_label if (m == "one_way" and one_way_label) else _METRIC[m][2]
-        _draw(ax, by_kind, agg, bucket_s, logy, f"latency (ms) — {label}",
+        _draw(ax, by_kind, agg, bucket_s, logy, f"latency — {label}",
               base if len(panels) == 1 else f"{base} — {label}")
     fig.tight_layout()
     fig.savefig(out_path)
@@ -155,16 +180,18 @@ def render_latency_chart(csv_gz_path: str, out_path: str, *, metric: str = "one_
 
 
 def _bucketed(sorted_pts: list[tuple[float, float]], bucket_s: float):
-    """Per-bucket (center_x, p50, p99) over fixed-width time buckets."""
+    """Per-bucket (center_x, p50, p99, max) over fixed-width time buckets
+    (max = p100, the worst-case latency in the bucket)."""
     if bucket_s <= 0:
         bucket_s = 1.0
     buckets: dict[int, list[float]] = defaultdict(list)
     for x, y in sorted_pts:
         buckets[int(x // bucket_s)].append(y)
-    bx, p50, p99 = [], [], []
+    bx, p50, p99, pmax = [], [], [], []
     for b in sorted(buckets):
         ys = sorted(buckets[b])
         bx.append((b + 0.5) * bucket_s)
         p50.append(_pctl(ys, 0.50))
         p99.append(_pctl(ys, 0.99))
-    return bx, p50, p99
+        pmax.append(ys[-1])
+    return bx, p50, p99, pmax

{fixtureqa-0.4.20 → fixtureqa-0.4.22}/fixture/core/perf_engine.py

@@ -397,8 +397,19 @@ class PerfRun:
         self._finalize(entry, "dropped")
         return True
 
+    async def _send(self, session_id: str, msg: Message) -> bool:
+        """Single send path — tallies every outbound app message per leg
+        (type-agnostic) for the messages-per-second chart, then delegates."""
+        ok = await self._sm.send_message(session_id, msg)
+        if ok:
+            if session_id == self.config.client_session_id:
+                self.stats.msgs_sent_client += 1
+            else:
+                self.stats.msgs_sent_venue += 1
+        return ok
+
     async def _send_order(self, corr: str, msg: Message) -> bool:
-        ok = await self._sm.send_message(self.config.client_session_id, msg)
+        ok = await self._send(self.config.client_session_id, msg)
         if ok:
             self.stats.orders_sent += 1
         else:
@@ -493,6 +504,8 @@ class PerfRun:
         sub = self._venue_sub
         while True:
             inb = await sub.get()
+            if not inb.admin:
+                self.stats.msgs_recv_venue += 1
             recv_ns = inb.recv_perf_ns or time.perf_counter_ns()
             if inb.msg_type == "G":
                 await self._handle_amend(inb.fields, recv_ns)
@@ -517,7 +530,7 @@ class PerfRun:
                                  last_qty=0, cum_qty=0, leaves_qty=order_qty, px="0")
                 if ack is not None:
                     send_ns = time.perf_counter_ns()
-                    if await self._sm.send_message(cfg.venue_session_id, ack):
+                    if await self._send(cfg.venue_session_id, ack):
                         self.stats.acks_sent += 1
                         self._register_venue_send(ack, "ack", corr, of.get(T_CLORDID), send_ns)
 
@@ -573,7 +586,7 @@ class PerfRun:
                             cum_qty=cum_qty, leaves_qty=leaves_qty, px=entry["px"])
             if er is not None:
                 send_ns = time.perf_counter_ns()
-                if await self._sm.send_message(cfg.venue_session_id, er):
+                if await self._send(cfg.venue_session_id, er):
                     self.stats.fills_sent += 1
                     self._register_venue_send(er, "fill", corr,
                                               entry["of"].get(T_CLORDID), send_ns)
@@ -647,14 +660,14 @@ class PerfRun:
                                   orig_clordid=orig)
             if er is not None:
                 send_ns = time.perf_counter_ns()
-                if await self._sm.send_message(cfg.venue_session_id, er):
+                if await self._send(cfg.venue_session_id, er):
                     self._register_venue_send(er, "pending-replace", corr, clordid, send_ns)
         er = self._build_exec(of, exec_type="5", ord_status="5", last_qty=0,
                               cum_qty=cum, leaves_qty=leaves, px=px,
                               orig_clordid=orig)
         if er is not None:
             send_ns = time.perf_counter_ns()
-            if await self._sm.send_message(cfg.venue_session_id, er):
+            if await self._send(cfg.venue_session_id, er):
                 self._register_venue_send(er, "replace", corr, clordid, send_ns)
 
     async def _handle_cancel(self, of: dict, recv_ns: int = 0) -> None:
@@ -691,12 +704,12 @@ class PerfRun:
                                   orig_clordid=of.get(T_ORIGCLORDID))
             if er is not None:
                 send_ns = time.perf_counter_ns()
-                if await self._sm.send_message(cfg.venue_session_id, er):
+                if await self._send(cfg.venue_session_id, er):
                     self._register_venue_send(er, "canceled", corr, clordid, send_ns)
             return
         msg = self._build_cancel_reject(of, entry)
         send_ns = time.perf_counter_ns()
-        if await self._sm.send_message(cfg.venue_session_id, msg):
+        if await self._send(cfg.venue_session_id, msg):
             self._register_venue_send(msg, "cancel-reject", corr, clordid, send_ns)
 
     def _build_cancel_reject(self, of: dict, entry: Optional[dict]) -> Message:
@@ -811,6 +824,8 @@ class PerfRun:
         sub = self._client_sub
         while True:
             inb = await sub.get()
+            if not inb.admin:
+                self.stats.msgs_recv_client += 1
             if inb.msg_type == "9":
                 self._on_cancel_reject(inb.fields, inb.recv_perf_ns or time.perf_counter_ns())
                 continue
@@ -998,7 +1013,7 @@ class PerfRun:
         entry["cancel_clordid"] = new_clordid
         entry["cancel_sent_ns"] = time.perf_counter_ns()
         entry["cancel_sent_at"] = time.time()
-        if await self._sm.send_message(self.config.client_session_id, msg):
+        if await self._send(self.config.client_session_id, msg):
             self.stats.cancels_sent += 1
         else:
             entry["cancel_inflight"] = False
@@ -1129,7 +1144,7 @@ class PerfRun:
         entry["amends_sent"] = n + 1
         entry["amend_sent_ns"] = time.perf_counter_ns()
         entry["amend_sent_at"] = time.time()
-        if await self._sm.send_message(self.config.client_session_id, msg):
+        if await self._send(self.config.client_session_id, msg):
             self.stats.amends_sent += 1
         else:
             entry["amend_inflight"] = False
@@ -1219,6 +1234,8 @@ class PerfRun:
                 cps_live=round(r.cps, 1),
                 crps_live=round(r.crps, 1),
                 ccps_live=round(r.ccps, 1),
+                msgs_out_live=round(r.mco, 1),
+                msgs_in_live=round(r.mci, 1),
                 scenarios_dispatched=self.stats.scenarios_dispatched,
                 scenarios_per_sec=round(r.sps, 1),
                 scenarios_completed=self.stats.scenarios_completed,
@@ -1235,7 +1252,9 @@ class PerfRun:
                 amends_uncorrelated=self.stats.amends_uncorrelated,
                 amend_waits_expired=self.stats.amend_waits_expired,
                 cancels_received=self.stats.cancels_received,
-                cancels_uncorrelated=self.stats.cancels_uncorrelated)
+                cancels_uncorrelated=self.stats.cancels_uncorrelated,
+                msgs_out_live=round(r.mvo, 1),
+                msgs_in_live=round(r.mvi, 1))
         snap = LiveSnapshot(
             run_id=self.run_id, status=self.status, mode=self.config.mode,
             elapsed_s=round(self._elapsed_s(), 1), duration_s=self.config.test.duration,

{fixtureqa-0.4.20 → fixtureqa-0.4.22}/fixture/core/perf_models.py

@@ -252,6 +252,8 @@ class ClientLeg(BaseModel):
     cps_live: float = 0.0
     crps_live: float = 0.0
     ccps_live: float = 0.0
+    msgs_out_live: float = 0.0   # all app messages this leg sent/s (MPS chart)
+    msgs_in_live: float = 0.0    # all app messages this leg received/s
     scenarios_dispatched: int = 0
     scenarios_per_sec: float = 0.0
     scenarios_completed: int = 0
@@ -271,6 +273,8 @@ class VenueLeg(BaseModel):
     amend_waits_expired: int = 0
     cancels_received: int = 0
     cancels_uncorrelated: int = 0
+    msgs_out_live: float = 0.0   # all app messages this leg sent/s (MPS chart)
+    msgs_in_live: float = 0.0    # all app messages this leg received/s
 
 
 class SnapshotErrors(BaseModel):

{fixtureqa-0.4.20 → fixtureqa-0.4.22}/fixture/core/perf_stats.py

@@ -25,6 +25,12 @@ class Rates(NamedTuple):
     cps: float    # cancels sent/s (35=F)
     crps: float   # cancel-rejects received/s (35=9)
     ccps: float   # canceled received/s (150=4)
+    # Type-agnostic message rates (every app message sent/received per leg) for
+    # the messages-per-second chart — counts all kinds, so it can't drift.
+    mco: float    # client leg messages sent/s   (orders + amends + cancels …)
+    mci: float    # client leg messages received/s (acks + fills + replies …)
+    mvo: float    # venue leg messages sent/s    (acks + fills + replies …)
+    mvi: float    # venue leg messages received/s (orders + amends + cancels …)
 
 
 class TokenBucket:
@@ -147,6 +153,11 @@ class PerfStats:
         self.cancels_received = 0    # venue saw an inbound 35=F
         self.cancels_uncorrelated = 0  # inbound 35=F lacked the correlation tag (no reply)
         self.venue_sends_unmatched = 0  # one-way send records evicted w/o a matching recv
+        # Type-agnostic per-leg message tallies (every app message), for the MPS chart.
+        self.msgs_sent_client = 0
+        self.msgs_recv_client = 0
+        self.msgs_sent_venue = 0
+        self.msgs_recv_venue = 0
         self.lost_timeout = 0
         self.dropped = 0
         self.rejected = 0
@@ -170,6 +181,10 @@ class PerfStats:
         self._last_cancels = 0
         self._last_cancel_rejects = 0
         self._last_canceled = 0
+        self._last_msc = 0
+        self._last_mrc = 0
+        self._last_msv = 0
+        self._last_mrv = 0
 
     def rates(self) -> Rates:
         """Per-second deltas since the last call. Stateful — call exactly once
@@ -177,7 +192,7 @@ class PerfStats:
         now = time.monotonic()
         dt = now - self._last_t
         if dt <= 0:
-            return Rates(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0)
+            return Rates(*([0.0] * 11))
         r = Rates(
             ops=(self.orders_sent - self._last_orders) / dt,
             fps=(self.fills_sent - self._last_fills) / dt,
@@ -186,6 +201,10 @@ class PerfStats:
             cps=(self.cancels_sent - self._last_cancels) / dt,
             crps=(self.cancel_rejects - self._last_cancel_rejects) / dt,
             ccps=(self.cancels_canceled - self._last_canceled) / dt,
+            mco=(self.msgs_sent_client - self._last_msc) / dt,
+            mci=(self.msgs_recv_client - self._last_mrc) / dt,
+            mvo=(self.msgs_sent_venue - self._last_msv) / dt,
+            mvi=(self.msgs_recv_venue - self._last_mrv) / dt,
         )
         self._last_t = now
         self._last_orders = self.orders_sent
@@ -195,6 +214,10 @@ class PerfStats:
         self._last_cancels = self.cancels_sent
         self._last_cancel_rejects = self.cancel_rejects
         self._last_canceled = self.cancels_canceled
+        self._last_msc = self.msgs_sent_client
+        self._last_mrc = self.msgs_recv_client
+        self._last_msv = self.msgs_sent_venue
+        self._last_mrv = self.msgs_recv_venue
         return r
 
     def fill_ratio(self) -> float: