trodo-python 3.0.0__tar.gz → 3.0.1__tar.gz

{trodo_python-3.0.0 → trodo_python-3.0.1}/PKG-INFO

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

{trodo_python-3.0.0 → trodo_python-3.0.1}/pyproject.toml

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

trodo_python-3.0.1/tests/test_long_runs.py

@@ -0,0 +1,34 @@
+"""A run with more spans than one buffer holds keeps every span (it used to
+drop everything after the 1,000th) and its totals still count all of them."""
+from __future__ import annotations
+
+from trodo.otel.processor import TrodoRun, TrodoSpan, TrodoSpanProcessor
+from trodo.otel.wrap_agent import _aggregate
+
+
+def span(i, run="r1"):
+    return TrodoSpan(span_id=f"s{i}", run_id=run, parent_span_id=None, kind="tool" if i % 2 else "llm",
+                     name="step", status="error" if i == 4 else "ok", input_tokens=10, output_tokens=1)
+
+
+def test_a_full_buffer_is_sent_ahead_and_nothing_is_dropped(http):
+    p = TrodoSpanProcessor(http, max_spans_per_run=3)
+    for i in range(8):
+        p.enqueue_span(span(i))
+    # Two full chunks went ahead through append; two spans wait for the run.
+    assert [(rid, [s["span_id"] for s in spans]) for rid, spans in http.spans_append] == [
+        ("r1", ["s0", "s1", "s2"]), ("r1", ["s3", "s4", "s5"])]
+    agg = _aggregate(p.get_pending("r1"))
+    assert agg["span_count"] == 8 and agg["total_tokens_in"] == 80 and agg["tool_count"] == 4 and agg["error_count"] == 1
+    p.ingest_run(TrodoRun(run_id="r1", agent_name="deep", **{k: v for k, v in agg.items() if k in ("span_count", "tool_count", "error_count")}))
+    sent = [s["span_id"] for _, spans in http.spans_append for s in spans] + [s["span_id"] for s in http.run_ingest[-1]["spans"]]
+    assert sorted(sent) == sorted(f"s{i}" for i in range(8))
+    assert len(sent) == len(set(sent)), "no span is sent twice"
+    assert p.get_pending("r1") == []
+
+
+def test_runs_do_not_share_buffers(http):
+    p = TrodoSpanProcessor(http, max_spans_per_run=2)
+    p.enqueue_span(span(1, "a")); p.enqueue_span(span(2, "b")); p.enqueue_span(span(3, "a"))
+    assert [rid for rid, _ in http.spans_append] == ["a"]
+    assert len(p.get_pending("b")) == 1

trodo_python-3.0.1/trodo/_version.py

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

{trodo_python-3.0.0 → trodo_python-3.0.1}/trodo/otel/processor.py

@@ -97,6 +97,19 @@ class TrodoSpan:
         return {k: v for k, v in asdict(self).items() if v is not None}
 
 
+class _SentSpan:
+    """What the run's totals need of a span already sent ahead: no payloads."""
+
+    __slots__ = ("input_tokens", "output_tokens", "cost", "kind", "status")
+
+    def __init__(self, span: TrodoSpan) -> None:
+        self.input_tokens = span.input_tokens
+        self.output_tokens = span.output_tokens
+        self.cost = span.cost
+        self.kind = span.kind
+        self.status = span.status
+
+
 class TrodoSpanProcessor:
     """Buffers spans per run_id; flushes to /runs/ingest when the run ends.
 
@@ -118,6 +131,10 @@ class TrodoSpanProcessor:
         self._flush_interval = flush_interval_s
         self._max_spans = max_spans_per_run
         self._pending: Dict[str, List[TrodoSpan]] = {}
+        # A run past max_spans_per_run sends each full chunk ahead (the server
+        # stores spans before their run arrives) and keeps only what its totals
+        # need. Before this, every span after the 1,000th was dropped.
+        self._sent_ahead: Dict[str, List[_SentSpan]] = {}
         self._lock = threading.Lock()
         self._shutdown = False
         # run_ids that are "joined" (owned by a remote service) — their spans
@@ -133,22 +150,27 @@ class TrodoSpanProcessor:
         with self._lock:
             self._joined_runs.discard(run_id)
             self._pending.pop(run_id, None)
+            self._sent_ahead.pop(run_id, None)
 
     def enqueue_span(self, span: TrodoSpan) -> None:
         """Buffer a completed span under its run_id.
 
         Joined runs flush immediately (append_spans) instead of batching.
         """
+        chunk: List[TrodoSpan] = []
         with self._lock:
             joined = span.run_id in self._joined_runs
-            if joined:
-                pass
-            else:
+            if not joined:
                 bucket = self._pending.setdefault(span.run_id, [])
-                if len(bucket) < self._max_spans:
-                    bucket.append(span)
+                bucket.append(span)
+                if len(bucket) >= self._max_spans:
+                    chunk = bucket
+                    self._pending[span.run_id] = []
+                    self._sent_ahead.setdefault(span.run_id, []).extend(_SentSpan(x) for x in chunk)
         if joined:
             self._send_spans(span.run_id, [span.to_dict()])
+        elif chunk:
+            self._send_spans(span.run_id, [x.to_dict() for x in chunk])
 
     def _send_spans(self, run_id: str, spans: List[Dict[str, Any]]) -> None:
         if self._sender is not None:
@@ -161,12 +183,14 @@ class TrodoSpanProcessor:
 
     def get_pending(self, run_id: str) -> List[TrodoSpan]:
         with self._lock:
-            return list(self._pending.get(run_id, []))
+            # The run's totals cover every span, including those sent ahead.
+            return [*self._sent_ahead.get(run_id, []), *self._pending.get(run_id, [])]
 
     def ingest_run(self, run: TrodoRun) -> None:
         """Flush a run + all its buffered spans in one call."""
         with self._lock:
             spans = self._pending.pop(run.run_id, [])
+            self._sent_ahead.pop(run.run_id, None)
         payload: Dict[str, Any] = {"run": run.to_dict()}
         if spans:
             payload["spans"] = [s.to_dict() for s in spans]
@@ -201,6 +225,7 @@ class TrodoSpanProcessor:
         try:
             with self._lock:
                 buffered = self._pending.pop(run_id, None) or []
+                self._sent_ahead.pop(run_id, None)
             if buffered:
                 self._send_spans(run_id, [s.to_dict() for s in buffered])
             if self._sender is not None:

{trodo_python-3.0.0 → trodo_python-3.0.1}/trodo_python.egg-info/PKG-INFO

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

{trodo_python-3.0.0 → trodo_python-3.0.1}/trodo_python.egg-info/SOURCES.txt

@@ -11,6 +11,7 @@ tests/test_framework_deference.py
 tests/test_get_prompt_version_types.py
 tests/test_instrumentor_resolution.py
 tests/test_llm_usage_cost.py
+tests/test_long_runs.py
 tests/test_multi_agent_shape.py
 tests/test_processor_methods.py
 tests/test_prompt_fingerprint.py

trodo_python-3.0.0/trodo/_version.py

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