fixtureqa 0.4.18__tar.gz → 0.4.19__tar.gz

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

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

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

@@ -228,12 +228,19 @@ async def run_chart(run_id: str, reg: REG, _admin: Admin,
     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)")
+    # Single-leg runs (client/venue) derive one-way from the wire send time;
+    # label it so the chart can't be misread as the single-clock measurement.
+    st = reg.get_status(run_id)
+    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"
     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}")
+                metric=metric, agg=agg, 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.18 → fixtureqa-0.4.19}/fixture/core/exec_csv_writer.py

@@ -32,15 +32,15 @@ EXEC_COLS = (
                      #   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)
+    "direction",     # c2v (client→hub→venue) | v2c (venue→hub→client)
     "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
+    "one_way_us",    # this message's one-way transit. manager/loopback: recv − send on
+                     #   one monotonic clock. client/venue-only: recv − the wire send time
+                     #   (TransactTime 60 / SendingTime 52), needs a synced clock.
+    "round_trip_us",  # v2c only: recv − the originating request's send (our clock); empty for c2v
     "exec_type", "ord_status", "cum_qty", "leaves_qty",  # tags 150 / 39 / 14 / 151 (forensics)
 )
 

{fixtureqa-0.4.18 → fixtureqa-0.4.19}/fixture/core/perf_charts.py

@@ -115,7 +115,7 @@ def _draw(ax, by_kind, agg: str, bucket_s: float, logy: bool, ylabel: str, 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:
+                         title: Optional[str] = None, one_way_label: 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
@@ -146,7 +146,7 @@ def render_latency_chart(csv_gz_path: str, out_path: str, *, metric: str = "one_
     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]
+        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}",
               base if len(panels) == 1 else f"{base} — {label}")
     fig.tight_layout()

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

@@ -26,6 +26,7 @@ import random
 import time
 import uuid
 from collections import deque
+from datetime import datetime, timezone
 from typing import Optional
 
 from fixcore.message.message import Message
@@ -96,6 +97,29 @@ def _to_float(v) -> Optional[float]:
         return None
 
 
+# Wire send-time tags for the tag-60 latency path (client/venue-only modes):
+# TransactTime(60), falling back to the session SendingTime(52) which every
+# message carries (e.g. 35=9 has no TransactTime).
+_LAT_TS_TAGS = (60, 52)
+
+
+def _parse_fix_ts(fields: dict) -> Optional[float]:
+    """The counterparty's wall-clock send time (epoch seconds, UTC) from
+    TransactTime(60) → SendingTime(52). Returns None if absent/unparseable.
+    Used only when FIXture sees one leg, so the send timestamp must come off the
+    wire — accuracy then depends on the two hosts' clocks being NTP/PTP-synced."""
+    for tag in _LAT_TS_TAGS:
+        val = fields.get(tag)
+        if not val:
+            continue
+        for fmt in ("%Y%m%d-%H:%M:%S.%f", "%Y%m%d-%H:%M:%S"):
+            try:
+                return datetime.strptime(val, fmt).replace(tzinfo=timezone.utc).timestamp()
+            except ValueError:
+                continue
+    return None
+
+
 class PerfRun:
     def __init__(self, run_id: str, config: RunConfig, sm: SessionManager, writer: PerfWriter,
                  template_store=None, owner_uid: str = "",
@@ -181,16 +205,23 @@ class PerfRun:
         self.status = "running"
         self.started_at = time.time()
         self._start_ns = time.perf_counter_ns()
+        # Wall-clock anchored to the same instant as _start_ns, so an inbound
+        # message's monotonic recv_perf_ns can be expressed as a UTC wall time
+        # (for the tag-60 latency path) without a second clock read per message.
+        self._start_wall = time.time()
         if self.config.test.record_execs:
-            # Per-exec capture happens in the client-leg correlator; venue-only
-            # runs have nothing to record.
-            if not self._has_client:
-                self.warnings.append("record_execs has no effect in venue mode (no client leg)")
+            if not (self._has_client or self._has_venue):
+                self.warnings.append("record_execs has no effect with no client or venue leg")
             elif not self._execs_dir:
                 self.warnings.append("record_execs unavailable (no exec CSV directory configured)")
             else:
                 self._exec_csv = ExecCsvWriter(
                     os.path.join(self._execs_dir, f"{self.run_id}.csv.gz"))
+                if not self._one_way:
+                    self.warnings.append(
+                        "single-leg run: per-message one-way latency uses the wire "
+                        "send time (TransactTime 60 / SendingTime 52) — accurate only "
+                        "if this host and the counterparty share a synced clock")
         if self.config.amend.enabled and not self._has_client:
             self.warnings.append(
                 "amend injection has no effect in venue mode (no client leg); "
@@ -817,38 +848,58 @@ class PerfRun:
         sends[eid] = {"kind": kind, "send_ns": send_ns, "send_wall": time.time(),
                       "corr": corr, "clordid": clordid}
 
+    def _recv_wall(self, recv_ns: int) -> float:
+        """Wall-clock (epoch secs) of an inbound message, anchored to the same
+        instant as its monotonic recv_perf_ns — for the tag-60 latency path."""
+        return self._start_wall + (recv_ns - self._start_ns) / 1e9
+
     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:
+        inbound side. Manager/loopback: one-way = venue recv − the client's send
+        (from _pending, one clock). Venue-only: one-way = our recv − the
+        counterparty's wire send time (tag-60), needing a synced clock."""
+        if self._exec_csv is None:
             return
-        send_at = entry.get(ns_key[:-2] + "at")   # *_sent_ns → *_sent_at
+        if self._one_way:
+            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
+            one_way_us = (recv_ns - send_ns) / 1000.0
+        else:
+            ts = _parse_fix_ts(of)
+            if ts is None:
+                return
+            send_at = ts
+            one_way_us = (self._recv_wall(recv_ns) - ts) * 1e6
         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)
+            req_send_at=send_at, one_way_us=one_way_us, 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'."""
+        """Record a venue→client crossing at the client inbound side. one-way:
+        from the venue send registry (manager/loopback) or the counterparty's
+        wire send time (tag-60, client-only — synced clock needed). round-trip:
+        from the originating request's send in _pending (always our own clock)."""
         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
+        if vs:
+            one_way_us = (now_ns - vs["send_ns"]) / 1000.0
+            send_at = vs["send_wall"]
+        elif not self._one_way:
+            ts = _parse_fix_ts(f)
+            one_way_us = ((self._recv_wall(now_ns) - ts) * 1e6) if ts is not None else None
+            send_at = ts
+        else:
+            one_way_us = send_at = None
         rt_us = req_send_at = None
         ns_key = _KIND_REQ_NS.get(kind)
         if entry is not None and ns_key:
@@ -858,8 +909,7 @@ class PerfRun:
                 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",
+            corr=corr, clordid=clordid, exec_id=exec_id, kind=kind, direction="v2c",
             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, ""),

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

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

{fixtureqa-0.4.18 → fixtureqa-0.4.19}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "fixtureqa"
-version = "0.4.18"
+version = "0.4.19"
 description = "FIXture — FIX Protocol Testing Tool"
 requires-python = ">=3.10"
 dependencies = [

{fixtureqa-0.4.18 → fixtureqa-0.4.19}/tests/test_perf_engine.py

@@ -497,9 +497,9 @@ def test_record_c2v_one_way(tmp_path):
     assert r["round_trip_us"] == ""                     # c2v has no round-trip
 
 
-def test_record_v2c_round_trip_only_in_client_mode(tmp_path):
-    # client-only mode: no venue send registry → one-way empty, round-trip recorded,
-    # direction 'rt'.
+def test_record_v2c_round_trip_without_wire_ts_in_client_mode(tmp_path):
+    # client-only mode, reply has no TransactTime/SendingTime → one-way empty,
+    # round-trip (our own clock) still recorded.
     from fixture.core.exec_csv_writer import ExecCsvWriter
     run = _run(_cfg(mode="client"))
     assert run._one_way is False
@@ -509,12 +509,50 @@ def test_record_v2c_round_trip_only_in_client_mode(tmp_path):
     run._record_v2c({150: "2", 39: "2", 14: "100", 151: "0"}, "X", "E1",
                     base + 5_000_000, "fill", entry)
     run._exec_csv.close()
-    rows = _read_gz(tmp_path / "cm.csv.gz")
-    assert len(rows) == 1
-    r = rows[0]
-    assert r["direction"] == "rt"
-    assert r["one_way_us"] == ""                         # no far-leg send time
-    assert 4900 <= float(r["round_trip_us"]) <= 5100     # ~5 ms
+    r = _read_gz(tmp_path / "cm.csv.gz")[0]
+    assert r["direction"] == "v2c"
+    assert r["one_way_us"] == ""                         # no wire send time to compare
+    assert 4900 <= float(r["round_trip_us"]) <= 5100     # ~5 ms, our clock
+
+
+def _fix_ts(epoch: float) -> str:
+    from datetime import datetime, timezone
+    return datetime.fromtimestamp(epoch, tz=timezone.utc).strftime("%Y%m%d-%H:%M:%S.%f")[:-3]
+
+
+def test_record_v2c_tag60_one_way_in_client_mode(tmp_path):
+    # client-only mode: one-way derived from the reply's TransactTime(60) vs our recv.
+    from fixture.core.exec_csv_writer import ExecCsvWriter
+    run = _run(_cfg(mode="client"))
+    run._start_ns = time.perf_counter_ns()
+    run._start_wall = time.time()
+    run._exec_csv = ExecCsvWriter(str(tmp_path / "t60.csv.gz"))
+    # venue stamped tag 60 eight ms before our (anchored) receive
+    recv_ns = run._start_ns + 1_000_000
+    tag60 = _fix_ts(run._recv_wall(recv_ns) - 0.008)
+    run._record_v2c({60: tag60, 150: "2", 39: "2"}, "X", "E1", recv_ns, "fill", None)
+    run._exec_csv.close()
+    r = _read_gz(tmp_path / "t60.csv.gz")[0]
+    assert r["direction"] == "v2c"
+    assert 7000 <= float(r["one_way_us"]) <= 9000        # ~8 ms from tag 60
+
+
+def test_record_c2v_tag60_one_way_in_venue_mode(tmp_path):
+    # venue-only mode: inbound order one-way from its TransactTime(60) vs our recv.
+    from fixture.core.exec_csv_writer import ExecCsvWriter
+    run = _run(_cfg(mode="venue"))
+    assert run._one_way is False
+    run._start_ns = time.perf_counter_ns()
+    run._start_wall = time.time()
+    run._exec_csv = ExecCsvWriter(str(tmp_path / "v60.csv.gz"))
+    recv_ns = run._start_ns + 500_000
+    tag60 = _fix_ts(run._recv_wall(recv_ns) - 0.012)
+    run._record_c2v({11: "O1", 60: tag60}, "X", recv_ns, "order")
+    run._exec_csv.close()
+    r = _read_gz(tmp_path / "v60.csv.gz")[0]
+    assert r["kind"] == "order" and r["direction"] == "c2v"
+    assert 11000 <= float(r["one_way_us"]) <= 13000      # ~12 ms from tag 60
+    assert r["round_trip_us"] == ""
 
 
 def test_render_latency_chart_metrics(tmp_path):