fixtureqa 0.4.17__tar.gz → 0.4.18__tar.gz

{fixtureqa-0.4.17/fixtureqa.egg-info → fixtureqa-0.4.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fixtureqa
-Version: 0.4.17
+Version: 0.4.18
 Summary: FIXture — FIX Protocol Testing Tool
 Requires-Python: >=3.10
 License-File: LICENSE
@@ -10,6 +10,7 @@ Requires-Dist: uvicorn[standard]>=0.29.0
 Requires-Dist: websockets>=12.0
 Requires-Dist: python-jose[cryptography]>=3.3.0
 Requires-Dist: passlib[bcrypt]>=1.7.4
+Requires-Dist: matplotlib>=3.7
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0; extra == "dev"
 Requires-Dist: pytest-asyncio>=0.23; extra == "dev"

{fixtureqa-0.4.17 → fixtureqa-0.4.18}/fixture/api/routers/perf.py

@@ -5,9 +5,11 @@ Stage 1a: run lifecycle (start/list/get/stop) + live snapshot WS. The WS uses a
 short-TTL single-use ticket (JWT never in the URL); the rest of the contract
 (messages/scenarios/export/configs) lands in later stages.
 """
+import asyncio
 import csv
 import io
 import logging
+import os
 import zipfile
 from typing import Annotated, Optional
 
@@ -16,6 +18,7 @@ from fastapi.responses import FileResponse, Response, StreamingResponse
 
 from ...core.models import SessionStatus
 from ...core.perf_models import RunConfig, RunStatus
+from ...core.perf_charts import render_latency_chart
 from ...core.perf_engine import RunRegistry
 from ...core.perf_payload import PerfConfigError
 from ...core.perf_store import PerfStore
@@ -207,6 +210,37 @@ def run_export(run_id: str, reg: REG, pw: PW, _admin: Admin,
     raise HTTPException(status_code=422, detail="kind must be messages|scenarios|execs|both")
 
 
+@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")):
+    """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_execs; 404 otherwise, 409 while live."""
+    if metric not in ("one_way", "round_trip", "both") or agg not in ("scatter", "percentile", "both"):
+        raise HTTPException(status_code=422,
+                            detail="metric must be one_way|round_trip|both; agg must be scatter|percentile|both")
+    if not reg.exists(run_id):
+        raise HTTPException(status_code=404, detail="Run not found")
+    if _run_is_live(reg, run_id):
+        raise HTTPException(status_code=409,
+                            detail="Run still active — the latency chart is rendered when the run finishes")
+    csv_path = reg.exec_csv_path(run_id)
+    if csv_path is None or not os.path.exists(csv_path):
+        raise HTTPException(status_code=404,
+                            detail="No per-message recording for this run (enable record_execs before starting)")
+    out_path = f"{csv_path[:-len('.csv.gz')]}_{metric}_{agg}.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}")
+        except ValueError as e:
+            # No chartable points (e.g. recording produced only un-latencied rows).
+            raise HTTPException(status_code=404, detail=str(e))
+    return FileResponse(out_path, media_type="image/png",
+                        filename=f"{run_id}_latency.png")
+
+
 # --- saved configs --------------------------------------------------------
 
 @router.get("/configs")

{fixtureqa-0.4.17 → fixtureqa-0.4.18}/fixture/core/exec_csv_writer.py

@@ -1,6 +1,7 @@
 """
-Per-run gzipped CSV recorder for individual ExecutionReports (opt-in via
-test.record_execs).
+Per-run gzipped CSV recorder for individual inbound correlated messages —
+every ExecutionReport (ack, fill, amend/cancel reply) plus OrderCancelReject
+(35=9), opt-in via test.record_execs.
 
 CSV-direct: there is no database staging — rows stream straight to
 data/perf_execs/<run_id>.csv.gz and export serves the finished file as-is.
@@ -10,6 +11,7 @@ gzip/disk work happens on one daemon writer thread, so recording cannot add
 latency to the measured inbound path.
 
 One instance per recording run; it owns its file exclusively for its lifetime.
+Drives scripts/perf_latency_chart.py (per-`kind` latency plots).
 """
 from __future__ import annotations
 
@@ -26,14 +28,20 @@ DEFAULT_MAX_QUEUE = 200_000
 
 EXEC_COLS = (
     "run_id", "corr_id", "clordid", "exec_id",
-    "exec_type", "ord_status",                      # tags 150 / 39
-    "last_qty", "last_px", "cum_qty", "leaves_qty",  # tags 32 / 31 / 14 / 151
-    "exec_seq",      # 1-based report index within the order
-    "sent_at",       # wall clock of the order send (same for all the order's rows)
-    "recv_at",       # wall clock of this report's receive
-    "latency_us",    # client receive − order send (one monotonic clock — authoritative;
-                     # recv_at − sent_at is wall clock, for cross-referencing only)
-    "gap_us",        # since the previous report for this order; empty on the first
+    "kind",          # message kind / chart series key (engine-assigned):
+                     #   client→venue: order / amend / cancel
+                     #   venue→client: ack / fill / pending-replace / replace /
+                     #                 pending-cancel / canceled / cancel-reject / amend-reject
+    "direction",     # c2v (client→hub→venue) | v2c (venue→hub→client) | rt
+                     #   (rt = round-trip-only fallback, client/venue-only modes)
+    "send_at",       # wall clock of THIS message's send on the near leg (one-way x-axis)
+    "recv_at",       # wall clock of THIS message's receive on the far leg
+    "req_send_at",   # wall clock of the originating request's send (order/amend/cancel
+                     #   send; == send_at for c2v rows) — the round-trip x-axis
+    "one_way_us",    # recv_ns − send_ns: this message's transit through the hub, one
+                     #   monotonic clock (empty in client/venue-only modes — no far leg)
+    "round_trip_us",  # v2c only: recv_ns − the originating request's send_ns; empty for c2v
+    "exec_type", "ord_status", "cum_qty", "leaves_qty",  # tags 150 / 39 / 14 / 151 (forensics)
 )
 
 

fixtureqa-0.4.18/fixture/core/perf_charts.py

@@ -0,0 +1,170 @@
+"""
+Post-run per-message latency charts from a recorded run's csv.gz
+(test.record_execs). One plot line/series per message `kind` (ack / fill /
+replace / canceled / cancel-reject / …): x = order send time (run progression),
+y = per-message latency.
+
+Single implementation, two callers: scripts/perf_latency_chart.py (offline CLI)
+and the FastAPI /perf/runs/{id}/chart endpoint (rendered off-loop and cached).
+
+matplotlib is imported lazily inside render_latency_chart so importing this
+module (and starting the server) never pays the matplotlib import cost; the
+render uses the Agg backend via the object-oriented Figure API, which is
+safe to run on a worker thread (no pyplot global state, no GUI backend).
+"""
+from __future__ import annotations
+
+import csv
+import gzip
+from collections import defaultdict
+from typing import Optional
+
+# Stable colour per kind so charts are comparable across runs (mirrors the live
+# dashboard hues). Unknown kinds fall back to the mpl cycle.
+_KIND_COLOR = {
+    "order": "#38bdf8",            # client→venue
+    "ack": "#00b4c8",
+    "fill": "#a78bfa",
+    "amend": "#f59e0b",            # client→venue
+    "pending-replace": "#c084fc",
+    "replace": "#7c3aed",
+    "cancel": "#fb7185",           # client→venue
+    "pending-cancel": "#fb923c",
+    "canceled": "#2dd4bf",
+    "cancel-reject": "#f43f5e",
+    "amend-reject": "#ef4444",
+}
+# Drawing order: order lifecycle, then amend, then cancel (request before reply).
+_KIND_ORDER = ["order", "ack", "fill", "amend", "pending-replace", "replace",
+               "cancel", "pending-cancel", "canceled", "cancel-reject", "amend-reject"]
+
+# Per metric: (latency column, x-axis column, axis label).
+_METRIC = {
+    "one_way":   ("one_way_us",   "send_at",     "one-way hub transit"),
+    "round_trip": ("round_trip_us", "req_send_at", "round-trip"),
+}
+
+
+def _pctl(sorted_vals: list[float], q: float) -> float:
+    """Nearest-rank percentile of an already-sorted list (q in 0..1)."""
+    if not sorted_vals:
+        return 0.0
+    i = min(len(sorted_vals) - 1, max(0, int(round(q * (len(sorted_vals) - 1)))))
+    return sorted_vals[i]
+
+
+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."""
+    y_col, x_col, _ = _METRIC[metric]
+    by_kind: dict[str, list[tuple[float, float]]] = defaultdict(list)
+    t0: Optional[float] = None
+    with gzip.open(csv_gz_path, "rt", newline="") as fh:
+        for r in csv.DictReader(fh):
+            yraw = r.get(y_col) or ""
+            xraw = r.get(x_col) or ""
+            if yraw == "" or xraw == "":
+                continue
+            try:
+                x = float(xraw)
+                y_ms = float(yraw) / 1000.0
+            except ValueError:
+                continue
+            t0 = x if t0 is None else min(t0, x)
+            by_kind[r.get("kind") or "unknown"].append((x, y_ms))
+    if t0 is not None:
+        for pts in by_kind.values():
+            pts[:] = [(x - t0, y) for (x, y) in pts]
+    return by_kind
+
+
+def _ordered_kinds(by_kind) -> list[str]:
+    known = [k for k in _KIND_ORDER if k in by_kind]
+    extra = sorted(k for k in by_kind if k not in _KIND_COLOR)
+    return known + extra
+
+
+def _draw(ax, by_kind, agg: str, bucket_s: float, logy: bool, ylabel: str, title: str):
+    for kind in _ordered_kinds(by_kind):
+        pts = sorted(by_kind[kind])
+        if not pts:
+            continue
+        color = _KIND_COLOR.get(kind)
+        xs = [p[0] for p in pts]
+        ys = [p[1] for p in pts]
+        if agg in ("scatter", "both"):
+            ax.scatter(xs, ys, s=6, alpha=0.25 if agg == "both" else 0.5,
+                       color=color, label=None if agg == "both" else kind,
+                       edgecolors="none")
+        if agg in ("percentile", "both"):
+            bx, p50, p99 = _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")
+    ax.set_xlabel("run time (s, from first send)")
+    ax.set_ylabel(ylabel + ("  [log]" if logy else ""))
+    if logy:
+        ax.set_yscale("log")
+    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)
+
+
+def render_latency_chart(csv_gz_path: str, out_path: str, *, metric: str = "one_way",
+                         agg: str = "both", bucket_s: float = 2.0,
+                         logy: bool = True, kinds: Optional[list[str]] = None,
+                         title: Optional[str] = None) -> str:
+    """Render a per-kind latency chart from a recorded run CSV to out_path (PNG).
+
+    metric: 'one_way' (recv − send, this message's hub transit; x = its own send
+    time) | 'round_trip' (recv − the originating request's send; x = request send)
+    | 'both' (two stacked panels, one-way above round-trip).
+    agg: 'scatter' = one point per message; 'percentile' = per-kind p50 & p99 over
+    `bucket_s`-second buckets (exposes backlog); 'both' overlays them.
+
+    Blocking + CPU-bound (matplotlib) — call off the event loop. Returns out_path.
+    Raises ValueError if the CSV has no usable points for the metric.
+    """
+    import matplotlib
+    matplotlib.use("Agg")
+    from matplotlib.figure import Figure
+
+    metrics = ["one_way", "round_trip"] if metric == "both" else [metric]
+    panels = []
+    for m in metrics:
+        by_kind = _read_points(csv_gz_path, m)
+        if kinds:
+            by_kind = {k: v for k, v in by_kind.items() if k in set(kinds)}
+        if any(by_kind.values()):
+            panels.append((m, by_kind))
+    if not panels:
+        raise ValueError(f"no chartable {metric!r} latency points in {csv_gz_path}")
+
+    fig = Figure(figsize=(12, 6.5 * len(panels)), dpi=120)
+    axes = fig.subplots(len(panels), 1, squeeze=False)[:, 0]
+    base = title or "Per-message latency"
+    for ax, (m, by_kind) in zip(axes, panels):
+        label = _METRIC[m][2]
+        _draw(ax, by_kind, agg, bucket_s, logy, f"latency (ms) — {label}",
+              base if len(panels) == 1 else f"{base} — {label}")
+    fig.tight_layout()
+    fig.savefig(out_path)
+    return out_path
+
+
+def _bucketed(sorted_pts: list[tuple[float, float]], bucket_s: float):
+    """Per-bucket (center_x, p50, p99) over fixed-width time buckets."""
+    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 = [], [], []
+    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

{fixtureqa-0.4.17 → fixtureqa-0.4.18}/fixture/core/perf_engine.py

@@ -48,8 +48,24 @@ T_ORDERQTY, T_ORDTYPE, T_PRICE, T_TIF, T_TRANSACTTIME = 38, 40, 44, 59, 60
 T_ORDERID, T_EXECID, T_EXECTRANSTYPE, T_EXECTYPE, T_ORDSTATUS = 37, 17, 20, 150, 39
 T_LASTQTY, T_LASTPX, T_CUMQTY, T_LEAVESQTY, T_AVGPX = 32, 31, 14, 151, 6
 
+# ExecType(150) → per-message latency-chart series label (see ExecCsvWriter).
+_EXEC_KIND = {
+    "0": "ack", "1": "fill", "2": "fill", "F": "fill",
+    "E": "pending-replace", "5": "replace",
+    "6": "pending-cancel", "4": "canceled",
+}
+
+# venue→client kind → the originating client request whose send time gives the
+# round-trip baseline (the wall-clock key is the same with "_ns"→"_at").
+_KIND_REQ_NS = {
+    "ack": "sent_ns", "fill": "sent_ns",
+    "pending-replace": "amend_sent_ns", "replace": "amend_sent_ns", "amend-reject": "amend_sent_ns",
+    "pending-cancel": "cancel_sent_ns", "canceled": "cancel_sent_ns", "cancel-reject": "cancel_sent_ns",
+}
+
 _GRACE_DRAIN_S = 0.5
 _SNAPSHOT_INTERVAL_S = 0.5
+_VENUE_SENDS_CAP = 500_000   # hard cap on the one-way send registry (drop-oldest)
 
 
 def _utc_ms() -> str:
@@ -103,10 +119,19 @@ class PerfRun:
 
         self._has_client = config.mode in ("loopback", "manager", "client")
         self._has_venue = config.mode in ("loopback", "manager", "venue")
+        # One-way per-message latency (recv at far leg − send at near leg) needs
+        # both legs in this process on one clock — i.e. loopback/manager. In
+        # client/venue mode we only see one leg, so the recorder falls back to
+        # round-trip (see _emit_crossing / _record_rt).
+        self._one_way = self._has_client and self._has_venue
 
         self.stats = PerfStats()
         self._pending: dict[str, dict] = {}
         self._order_seq = 0
+        # venue→client send-time registry for one-way latency: exec_id → send
+        # record, populated by the venue send sites and popped by the client
+        # correlator. Bounded by pop-on-match + age/cap sweep in _timeout_sweeper.
+        self._venue_sends: dict[str, dict] = {}
 
         # Amend injection is fill-triggered on the client leg (35=D orders only);
         # cancel injection is ack- or fill-triggered. Both park their send tasks
@@ -237,6 +262,7 @@ class PerfRun:
         self._pending.clear()
         self._venue_orders.clear()
         self._fill_runnable.clear()
+        self._venue_sends.clear()
         if self._client_sub:
             self._client_sub.close()
         if self._venue_sub:
@@ -436,11 +462,12 @@ class PerfRun:
         sub = self._venue_sub
         while True:
             inb = await sub.get()
+            recv_ns = inb.recv_perf_ns or time.perf_counter_ns()
             if inb.msg_type == "G":
-                await self._handle_amend(inb.fields)
+                await self._handle_amend(inb.fields, recv_ns)
                 continue
             if inb.msg_type == "F":
-                await self._handle_cancel(inb.fields)
+                await self._handle_cancel(inb.fields, recv_ns)
                 continue
             if inb.msg_type != "D":
                 continue
@@ -450,13 +477,18 @@ class PerfRun:
             corr = of.get(cfg.correlation_tag)
             if corr is None or order_qty <= 0:
                 continue
+            # Order crossing client→hub→venue: one-way latency vs the client send.
+            self._record_c2v(of, corr, recv_ns, "order")
 
             # 1. Ack the order first (New) — immediate, not rate-limited.
             if f.send_ack:
                 ack = self._exec(of, exec_type="0", ord_status="0",
                                  last_qty=0, cum_qty=0, leaves_qty=order_qty, px="0")
-                if ack is not None and await self._sm.send_message(cfg.venue_session_id, ack):
-                    self.stats.acks_sent += 1
+                if ack is not None:
+                    send_ns = time.perf_counter_ns()
+                    if await self._sm.send_message(cfg.venue_session_id, ack):
+                        self.stats.acks_sent += 1
+                        self._register_venue_send(ack, "ack", corr, of.get(T_CLORDID), send_ns)
 
             # 2. Book the fills — gated by fill_ratio (a skipped order stays
             #    acked/open and is never booked).
@@ -508,8 +540,12 @@ class PerfRun:
             et, ost, last_qty, cum_qty, leaves_qty = entry["schedule"][entry["idx"]]
             er = self._exec(entry["of"], exec_type=et, ord_status=ost, last_qty=last_qty,
                             cum_qty=cum_qty, leaves_qty=leaves_qty, px=entry["px"])
-            if er is not None and await self._sm.send_message(cfg.venue_session_id, er):
-                self.stats.fills_sent += 1
+            if er is not None:
+                send_ns = time.perf_counter_ns()
+                if await self._sm.send_message(cfg.venue_session_id, er):
+                    self.stats.fills_sent += 1
+                    self._register_venue_send(er, "fill", corr,
+                                              entry["of"].get(T_CLORDID), send_ns)
             entry["idx"] += 1
             entry["cum"] = cum_qty
             if entry["idx"] >= len(entry["schedule"]):
@@ -532,7 +568,7 @@ class PerfRun:
                 self.stats.amend_waits_expired += 1
                 self._fill_runnable.append(corr)
 
-    async def _handle_amend(self, of: dict) -> None:
+    async def _handle_amend(self, of: dict, recv_ns: int = 0) -> None:
         """Venue side of 35=G: reply Replaced (150=5/39=5), optionally preceded
         by Pending Replace (150=E/39=E). With the order in the book the reply
         carries the REAL CumQty/LeavesQty, the order's price is updated so the
@@ -554,8 +590,11 @@ class PerfRun:
                     f"{cfg.correlation_tag} — no replace ack sent; check the "
                     f"counterparty passes the tag through on amends")
             return
+        # Amend crossing client→hub→venue: one-way latency vs the client amend send.
+        self._record_c2v(of, corr, recv_ns, "amend")
         order_qty = _to_int(of.get(T_ORDERQTY), 0)
         orig = of.get(T_ORIGCLORDID)
+        clordid = of.get(T_CLORDID)
         entry = self._venue_orders.get(corr)
         if entry is not None:
             new_px = of.get(T_PRICE)
@@ -576,14 +615,18 @@ class PerfRun:
                                   cum_qty=cum, leaves_qty=leaves, px=px,
                                   orig_clordid=orig)
             if er is not None:
-                await self._sm.send_message(cfg.venue_session_id, er)
+                send_ns = time.perf_counter_ns()
+                if await self._sm.send_message(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:
-            await self._sm.send_message(cfg.venue_session_id, er)
+            send_ns = time.perf_counter_ns()
+            if await self._sm.send_message(cfg.venue_session_id, er):
+                self._register_venue_send(er, "replace", corr, clordid, send_ns)
 
-    async def _handle_cancel(self, of: dict) -> None:
+    async def _handle_cancel(self, of: dict, recv_ns: int = 0) -> None:
         """Venue side of 35=F, per config.cancel.venue_response: "reject"
         answers 35=9 OrderCancelReject (CxlRejReason from config, correlation
         tag echoed) and the order keeps working — the cancel-reject flavour;
@@ -602,6 +645,9 @@ class PerfRun:
                     f"{cfg.correlation_tag} — no reply sent; check the "
                     f"counterparty passes the tag through on cancels")
             return
+        # Cancel crossing client→hub→venue: one-way latency vs the client cancel send.
+        self._record_c2v(of, corr, recv_ns, "cancel")
+        clordid = of.get(T_CLORDID)
         entry = self._venue_orders.get(corr)
         if cfg.cancel.venue_response == "cancel":
             if entry is not None:
@@ -613,10 +659,14 @@ class PerfRun:
                                   cum_qty=cum, leaves_qty=0, px=px,
                                   orig_clordid=of.get(T_ORIGCLORDID))
             if er is not None:
-                await self._sm.send_message(cfg.venue_session_id, er)
+                send_ns = time.perf_counter_ns()
+                if await self._sm.send_message(cfg.venue_session_id, er):
+                    self._register_venue_send(er, "canceled", corr, clordid, send_ns)
             return
         msg = self._build_cancel_reject(of, entry)
-        await self._sm.send_message(cfg.venue_session_id, msg)
+        send_ns = time.perf_counter_ns()
+        if await self._sm.send_message(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:
         """35=9 OrderCancelReject answering a 35=F: CxlRejResponseTo(434)=1,
@@ -634,6 +684,10 @@ class PerfRun:
         msg.set_field(T_ORDSTATUS, "1" if cum > 0 else "0")
         msg.set_field(102, str(cfg.cancel.cxl_rej_reason))
         msg.set_field(434, "1")
+        # Unique id so the client can match this reply for one-way latency
+        # (35=9 is not an ExecReport, but we reuse the exec id tags as the key).
+        msg.set_field(cfg.exec_id_tag, _uuid())
+        msg.set_field(T_EXECID, "R" + _guid()[:8].upper())
         corr = of.get(cfg.correlation_tag)
         if corr:
             msg.set_field(cfg.correlation_tag, corr)
@@ -733,17 +787,98 @@ class PerfRun:
                 continue
             self._on_exec_report(inb.fields, inb.recv_perf_ns or time.perf_counter_ns())
 
+    def _emit_crossing(self, *, corr, clordid, exec_id, kind, direction,
+                       send_at, recv_at, req_send_at, one_way_us, round_trip_us,
+                       exec_type="", ord_status="", cum_qty=None, leaves_qty=None) -> None:
+        """Append one message-crossing row to the per-message latency CSV
+        (opt-in via record_execs). Column order must match EXEC_COLS."""
+        if self._exec_csv is None:
+            return
+        self._exec_csv.enqueue((
+            self.run_id, corr, clordid, exec_id, kind, direction,
+            send_at, recv_at, req_send_at, one_way_us, round_trip_us,
+            exec_type, ord_status, cum_qty, leaves_qty,
+        ))
+
+    def _register_venue_send(self, msg: Message, kind: str, corr, clordid,
+                             send_ns: int) -> None:
+        """Stamp a venue→client message's send time keyed by its ExecID, so the
+        client correlator can compute one-way hub latency on receipt. No-op when
+        not recording. Bounded: drop-oldest past the cap (age-swept too)."""
+        if self._exec_csv is None:
+            return
+        eid = msg.get_field_or(self.config.exec_id_tag, "") or msg.get_field_or(T_EXECID, "")
+        if not eid:
+            return
+        sends = self._venue_sends
+        if len(sends) >= _VENUE_SENDS_CAP:
+            sends.pop(next(iter(sends)), None)
+            self.stats.venue_sends_unmatched += 1
+        sends[eid] = {"kind": kind, "send_ns": send_ns, "send_wall": time.time(),
+                      "corr": corr, "clordid": clordid}
+
+    def _record_c2v(self, of: dict, corr: str, recv_ns: int, kind: str) -> None:
+        """Record a client→venue crossing (order/amend/cancel) at the venue
+        inbound side: one-way latency = venue recv − the client's send (looked up
+        in _pending). Only when we drive both legs on one clock (manager/loopback)."""
+        if self._exec_csv is None or not self._one_way:
+            return
+        entry = self._pending.get(corr)
+        if entry is None:
+            return
+        ns_key = {"order": "sent_ns", "amend": "amend_sent_ns",
+                  "cancel": "cancel_sent_ns"}[kind]
+        send_ns = entry.get(ns_key)
+        if not send_ns:
+            return
+        send_at = entry.get(ns_key[:-2] + "at")   # *_sent_ns → *_sent_at
+        self._emit_crossing(
+            corr=corr, clordid=of.get(T_CLORDID), exec_id=None, kind=kind,
+            direction="c2v", send_at=send_at, recv_at=time.time(),
+            req_send_at=send_at, one_way_us=(recv_ns - send_ns) / 1000.0,
+            round_trip_us=None)
+
+    def _record_v2c(self, f: dict, corr, exec_id, now_ns: int, kind: str,
+                    entry: Optional[dict]) -> None:
+        """Record a venue→client crossing at the client inbound side: one-way
+        latency from the venue send registry (manager/loopback), and round-trip
+        from the originating request's send time in _pending. Client-only mode
+        has no registry hit → round-trip only, direction 'rt'."""
+        if self._exec_csv is None:
+            return
+        vs = self._venue_sends.pop(exec_id, None) if exec_id else None
+        one_way_us = ((now_ns - vs["send_ns"]) / 1000.0) if vs else None
+        send_at = vs["send_wall"] if vs else None
+        rt_us = req_send_at = None
+        ns_key = _KIND_REQ_NS.get(kind)
+        if entry is not None and ns_key:
+            base_ns = entry.get(ns_key)
+            if base_ns:
+                rt_us = (now_ns - base_ns) / 1000.0
+                req_send_at = entry.get(ns_key[:-2] + "at")   # *_sent_ns → *_sent_at
+        clordid = (entry.get("clordid") if entry else None) or (vs["clordid"] if vs else None)
+        self._emit_crossing(
+            corr=corr, clordid=clordid, exec_id=exec_id, kind=kind,
+            direction="v2c" if self._one_way else "rt",
+            send_at=send_at, recv_at=time.time(), req_send_at=req_send_at,
+            one_way_us=one_way_us, round_trip_us=rt_us,
+            exec_type=f.get(T_EXECTYPE, ""), ord_status=f.get(T_ORDSTATUS, ""),
+            cum_qty=_to_float(f.get(T_CUMQTY)), leaves_qty=_to_float(f.get(T_LEAVESQTY)))
+
     def _on_cancel_reject(self, f: dict, now_ns: int) -> None:
         """OrderCancelReject (35=9): answers either a 35=F (CxlRejResponseTo
         434=1 — the cancel-reject flavour's expected reply) or a 35=G (434=2 —
         an amend the counterparty refused). Dispatch on 434; when it's absent,
         infer from which request is in flight on the correlated entry."""
-        corr = f.get(self.config.correlation_tag)
+        cfg = self.config
+        corr = f.get(cfg.correlation_tag)
         entry = self._pending.get(corr) if corr is not None else None
+        exec_id = f.get(cfg.exec_id_tag) or f.get(T_EXECID)
         resp_to = f.get(434)
         if resp_to == "1" or (resp_to is None and entry is not None
                               and entry.get("cancel_inflight")
                               and not entry.get("amend_inflight")):
+            self._record_v2c(f, corr, exec_id, now_ns, "cancel-reject", entry)
             self._on_cancel_rejected(corr, entry, now_ns)
             return
         self.stats.amend_rejects += 1
@@ -751,6 +886,7 @@ class PerfRun:
             self.warnings.append(
                 "counterparty rejected an amend (35=9 OrderCancelReject) — "
                 "it may not match OrigClOrdID(41) against its own order chain")
+        self._record_v2c(f, corr, exec_id, now_ns, "amend-reject", entry)
         if entry is None or not entry.get("amend_inflight"):
             return
         entry["amend_inflight"] = False
@@ -811,6 +947,7 @@ class PerfRun:
         msg, new_clordid = self._factory.build_cancel(entry)
         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):
             self.stats.cancels_sent += 1
         else:
@@ -820,32 +957,23 @@ class PerfRun:
         cfg = self.config
         corr = f.get(cfg.correlation_tag)
         entry = self._pending.get(corr) if corr is not None else None
-        if entry is None:
-            return
         exec_id = f.get(cfg.exec_id_tag) or f.get(T_EXECID)
-        if exec_id is not None:
+        exec_type = f.get(T_EXECTYPE)
+        # Dedupe only when we have the order entry; record the crossing before the
+        # entry-None return so a late reply for a finalized order still gets its
+        # one-way latency (round-trip needs the entry and is skipped if gone).
+        if entry is not None and exec_id is not None:
             if exec_id in entry["seen_exec"]:
                 return
             entry["seen_exec"].add(exec_id)
-
-        if self._exec_csv is not None:
-            seq = entry["exec_seq"] = entry.get("exec_seq", 0) + 1
-            prev_ns = entry.get("last_recv_ns")
-            entry["last_recv_ns"] = now_ns
-            self._exec_csv.enqueue((
-                self.run_id, corr, entry.get("clordid"), exec_id,
-                f.get(T_EXECTYPE), f.get(T_ORDSTATUS),
-                _to_float(f.get(T_LASTQTY)), _to_float(f.get(T_LASTPX)),
-                _to_float(f.get(T_CUMQTY)), _to_float(f.get(T_LEAVESQTY)),
-                seq, entry.get("sent_at"), time.time(),
-                (now_ns - entry["sent_ns"]) / 1000.0,
-                ((now_ns - prev_ns) / 1000.0) if prev_ns is not None else None,
-            ))
+        self._record_v2c(f, corr, exec_id, now_ns,
+                         _EXEC_KIND.get(exec_type, f"exec:{exec_type}"), entry)
+        if entry is None:
+            return
 
         # Amend/cancel responses (Pending Replace / Replaced / Pending Cancel /
         # Canceled) are not order responses: they must not count as first
         # response, a fill, or a completion.
-        exec_type = f.get(T_EXECTYPE)
         if exec_type in ("E", "5", "6", "4"):
             if exec_type == "5":
                 self._on_replaced(corr, entry, now_ns)
@@ -950,6 +1078,7 @@ class PerfRun:
         entry["pending_clordid"] = new_clordid
         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):
             self.stats.amends_sent += 1
         else:
@@ -985,6 +1114,14 @@ class PerfRun:
                 else:
                     self.stats.lost_timeout += 1
                     self._finalize(entry, "lost")
+            # Evict one-way send records whose reply never came back (dropped at
+            # the hub) so the registry can't grow unbounded across a long run.
+            if self._venue_sends:
+                stale = [eid for eid, v in self._venue_sends.items()
+                         if now - v["send_ns"] > timeout_ns]
+                for eid in stale:
+                    if self._venue_sends.pop(eid, None) is not None:
+                        self.stats.venue_sends_unmatched += 1
 
     # ------------------------------------------------------------------
     # Persistence + snapshots

{fixtureqa-0.4.17 → fixtureqa-0.4.18}/fixture/core/perf_stats.py

@@ -146,6 +146,7 @@ class PerfStats:
         self.cancels_lost = 0        # cancel in flight when its order was reaped
         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
         self.lost_timeout = 0
         self.dropped = 0
         self.rejected = 0