trodo-python 3.0.2__tar.gz → 3.0.3__tar.gz

{trodo_python-3.0.2 → trodo_python-3.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trodo-python
-Version: 3.0.2
+Version: 3.0.3
 Summary: Trodo Analytics SDK for Python — server-side event tracking
 License: ISC
 Keywords: analytics,tracking,trodo,server-side

{trodo_python-3.0.2 → trodo_python-3.0.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "trodo-python"
-version = "3.0.2"
+version = "3.0.3"
 description = "Trodo Analytics SDK for Python — server-side event tracking"
 readme = "README.md"
 license = { text = "ISC" }

{trodo_python-3.0.2 → trodo_python-3.0.3}/tests/test_sender.py

@@ -333,3 +333,58 @@ def test_exit_says_loudly_what_was_not_delivered(capsys):
     err = capsys.readouterr().err
     assert "1 trace item(s), 2 units, were NOT delivered" in err
     assert "Trodo said: this team's backlog is full" in err
+
+
+# ── Parallel requests (3.0.3) ─────────────────────────────────────────────────
+
+class Timed:
+    """A slow /batch that records when each request started and ended."""
+
+    def __init__(self, delay_s: float) -> None:
+        self.delay_s = delay_s
+        self.calls: List[Dict[str, Any]] = []
+        self.lock = threading.Lock()
+
+    def post_raw(self, path, body, timeout=0, gzip_body=True):
+        start = time.time()
+        time.sleep(self.delay_s)
+        with self.lock:
+            self.calls.append({"start": start, "end": time.time(), "items": body["items"]})
+        return 200, None, {"results": [{"status": 200} for _ in body["items"]]}
+
+
+def test_up_to_three_requests_are_in_flight_at_once():
+    s = Timed(0.3)
+    sender = Sender(s, **fast(flush_at=50))
+    for i in range(150):
+        sender.enqueue(run(f"r{i}"))
+    t0 = time.time()
+    sender.flush(timeout_s=3)
+    assert sender.stats()["sent"] == 150
+    assert len(s.calls) == 3
+    assert time.time() - t0 < 0.55                      # one at a time would take 0.9 s
+    starts = sorted(c["start"] for c in s.calls)
+    assert starts[-1] - starts[0] < 0.1
+
+
+def test_max_in_flight_1_sends_one_at_a_time():
+    s = Timed(0.1)
+    sender = Sender(s, **fast(flush_at=10, max_in_flight=1))
+    for i in range(30):
+        sender.enqueue(run(f"r{i}"))
+    sender.flush(timeout_s=3)
+    calls = sorted(s.calls, key=lambda c: c["start"])
+    assert all(b["start"] >= a["end"] for a, b in zip(calls, calls[1:]))
+
+
+def test_feedback_waits_while_its_run_is_in_flight_in_another_request():
+    s = Timed(0.3)
+    sender = Sender(s, **fast(flush_at=1))
+    sender.enqueue(run("a"))
+    assert wait_for(lambda: sender.stats()["in_flight"] == 1)
+    sender.enqueue({"run_id": "a", "feedback": {"rating": 5}})
+    sender.enqueue(run("b"))                            # behind the feedback, also waits: order is kept
+    sender.flush(timeout_s=3)
+    assert sender.stats()["sent"] == 3
+    by = {("fb" if "feedback" in c["items"][0] else c["items"][0]["run"]["run_id"]): c for c in s.calls}
+    assert by["fb"]["start"] >= by["a"]["end"]

{trodo_python-3.0.2 → trodo_python-3.0.3}/trodo/__init__.py

@@ -180,7 +180,7 @@ def init(
                      are present, otherwise 'background'. Default.
     ``delivery_options``: flush_interval_s (1), flush_at (50), max_batch_bytes
     (4 MB), max_queue_items (10,000), max_queue_bytes (64 MB), max_retry_s
-    (600), exit_flush_s (5).
+    (600), exit_flush_s (5), max_in_flight (3).
 
     ``disable_instrumentations`` turns OFF specific instrumentors by id
     (e.g. ``['openai']`` when LangChain is your primary framework, to avoid

trodo_python-3.0.3/trodo/_version.py

@@ -0,0 +1 @@
+SDK_VERSION = "3.0.3"

{trodo_python-3.0.2 → trodo_python-3.0.3}/trodo/delivery/sender.py

@@ -5,8 +5,12 @@ retry and Retry-After — on the caller's thread before handing the agent's
 result back: up to ~90 s added to one agent call when a team was over its
 rate ceiling, the event loop frozen in an asyncio app, and then the trace was
 dropped. Now a finished run (or a flush of spans) goes into this queue and
-the agent returns at once. A daemon thread drains the queue to
-``POST /api/sdk/batch`` every second or 50 items, gzipped.
+the agent returns at once. Daemon threads drain the queue to
+``POST /api/sdk/batch`` every second or 50 items, gzipped, up to
+``max_in_flight`` (3) requests at a time (3.0.3; one at a time before, which
+let a script that exits after a burst deliver only ~150 runs in its 5 s exit
+window). Feedback never travels while its run is in flight in another
+request: the server refuses feedback for a run it has not stored yet.
 
 The rules match what Langfuse, LangSmith, Braintrust, OpenTelemetry, Sentry
 and PostHog have converged on (1 Oct 2026 survey):
@@ -53,7 +57,7 @@ DEFAULTS = dict(
     flush_interval_s=1.0, flush_at=50, max_batch_bytes=4 * 1024 * 1024,
     max_queue_items=10_000, max_queue_bytes=64 * 1024 * 1024,
     max_retry_s=600.0, max_retry_after_s=600.0, immediate_retry_s=15.0,
-    exit_flush_s=5.0, request_timeout_s=20.0,
+    exit_flush_s=5.0, request_timeout_s=20.0, max_in_flight=3,
 )
 _MIN_BACKOFF_S = 1.0
 _MAX_BACKOFF_S = 60.0
@@ -133,7 +137,8 @@ class Sender:
         self._unit_cap: Optional[int] = None  # the team's ceiling, once a 429 names it
         self._last_rate: Optional[Dict[str, Any]] = None
         self._warned_paced_at = 0.0
-        self._thread: Optional[threading.Thread] = None
+        self._threads: List[threading.Thread] = []
+        self._runs_in_flight: Dict[str, int] = {}  # run_id -> requests carrying it
         if self.mode == "background" and register_atexit:
             atexit.register(self._atexit)
 
@@ -203,9 +208,11 @@ class Sender:
     # ── background thread ─────────────────────────────────────────────────────
 
     def _ensure_thread_locked(self) -> None:
-        if self._thread is None or not self._thread.is_alive():
-            self._thread = threading.Thread(target=self._run, name="trodo-sender", daemon=True)
-            self._thread.start()
+        self._threads = [t for t in self._threads if t.is_alive()]
+        while len(self._threads) < max(1, int(self._o["max_in_flight"])):
+            t = threading.Thread(target=self._run, name=f"trodo-sender-{len(self._threads) + 1}", daemon=True)
+            self._threads.append(t)
+            t.start()
 
     def _run(self) -> None:
         interval = self._o["flush_interval_s"]
@@ -229,12 +236,25 @@ class Sender:
                         break
                     self._wake.wait(timeout=interval - age)
                 batch = self._take_batch_locked()
+                if not batch:
+                    # The head is feedback whose run is in flight: wait for it.
+                    self._wake.wait(timeout=interval)
+                    continue
+                runs = _run_ids(batch)
+                for r in runs:
+                    self._runs_in_flight[r] = self._runs_in_flight.get(r, 0) + 1
                 self._in_flight += 1
             try:
                 self._send_batch(batch)
             finally:
                 with self._lock:
                     self._in_flight -= 1
+                    for r in runs:
+                        left = self._runs_in_flight.get(r, 1) - 1
+                        if left > 0:
+                            self._runs_in_flight[r] = left
+                        else:
+                            self._runs_in_flight.pop(r, None)
                     self._wake.notify_all()
 
     def _take_batch_locked(self) -> List[_Queued]:
@@ -249,6 +269,9 @@ class Sender:
             u = _units_of(nxt.item)
             if out and cap and units + u > cap:
                 break
+            fb = nxt.item.get("run_id") if isinstance(nxt.item, dict) and "feedback" in nxt.item else None
+            if fb and fb in self._runs_in_flight:
+                break
             out.append(self._queue.popleft())
             nbytes += nxt.nbytes
             units += u
@@ -580,6 +603,16 @@ def _legacy_route(item: Item):
     return endpoints.SPANS_APPEND, {"spans": item["spans"]}
 
 
+def _run_ids(batch: List[_Queued]) -> List[str]:
+    """The runs a request carries (the ``run`` items), so their feedback waits for them."""
+    out = []
+    for q in batch:
+        run = q.item.get("run") if isinstance(q.item, dict) else None
+        if isinstance(run, dict) and run.get("run_id"):
+            out.append(str(run["run_id"]))
+    return out
+
+
 def _units_of(item: Any) -> int:
     """What an item costs against the rate ceiling: one per span, one for the run."""
     if not isinstance(item, dict):

{trodo_python-3.0.2 → trodo_python-3.0.3}/trodo_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trodo-python
-Version: 3.0.2
+Version: 3.0.3
 Summary: Trodo Analytics SDK for Python — server-side event tracking
 License: ISC
 Keywords: analytics,tracking,trodo,server-side

trodo_python-3.0.2/trodo/_version.py

@@ -1 +0,0 @@
-SDK_VERSION = "3.0.2"