trodo-python 2.10.8__tar.gz → 2.10.10__tar.gz

{trodo_python-2.10.8 → trodo_python-2.10.10}/PKG-INFO

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

{trodo_python-2.10.8 → trodo_python-2.10.10}/pyproject.toml

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

trodo_python-2.10.10/tests/test_auto_instrument_fixes.py

@@ -0,0 +1,217 @@
+"""Mirror of trodo-node 2.4.3 bridge fixes for the Python SDK.
+
+Covers:
+  1. duration_ms is rounded to an integer.
+  2. Active run is recovered from on_start-stamped attributes when
+     contextvars are empty at on_end (httpx async-context loss).
+  3. Internal trodo.* attributes are stripped from the persisted span.
+"""
+
+from types import SimpleNamespace
+from unittest.mock import MagicMock
+
+import pytest
+
+from trodo.otel.auto_instrument import _OtelAdapter, otel_span_to_trodo_span
+from trodo.otel.context import (
+    ActiveSpanContext,
+    get_active_context,
+    run_with_context,
+)
+
+
+RUN_ID = "11111111-1111-1111-1111-111111111111"
+ROOT_SPAN_ID = "22222222-2222-2222-2222-222222222222"
+
+
+def _fake_otel_span(start_ns=None, end_ns=None, attrs=None, span_id_int=0xABCD1234ABCD1234, parent_span_id_int=None):
+    span_context = SimpleNamespace(span_id=span_id_int)
+    parent = SimpleNamespace(span_id=parent_span_id_int) if parent_span_id_int else None
+    return SimpleNamespace(
+        name="anthropic.messages.create",
+        get_span_context=lambda: span_context,
+        attributes=attrs or {},
+        start_time=start_ns,
+        end_time=end_ns,
+        status=None,
+        parent=parent,
+    )
+
+
+def _ctx():
+    return ActiveSpanContext(
+        run_id=RUN_ID,
+        span_id=ROOT_SPAN_ID,
+        parent_span_id=None,
+        team_site_id="site-1",
+        processor=None,  # type: ignore[arg-type]
+    )
+
+
+class TestDurationRounding:
+    def test_fractional_ns_delta_rounds_to_integer(self):
+        # 1000ms + 0.999888 fractional ms via nanos delta
+        otel = _fake_otel_span(start_ns=1_000_000_000, end_ns=2_000_999_888)
+        with run_with_context(_ctx()):
+            span = otel_span_to_trodo_span(otel)
+        assert span is not None
+        assert isinstance(span.duration_ms, int)
+        assert span.duration_ms == 1001
+
+    def test_missing_times_leaves_duration_none(self):
+        otel = _fake_otel_span(start_ns=None, end_ns=None)
+        with run_with_context(_ctx()):
+            span = otel_span_to_trodo_span(otel)
+        assert span.duration_ms is None
+
+
+class TestOnStartStamping:
+    def test_on_start_stamps_run_id_when_context_is_alive(self):
+        adapter = _OtelAdapter(processor=MagicMock())
+        live_span = MagicMock()
+        with run_with_context(_ctx()):
+            adapter.on_start(live_span, None)
+        live_span.set_attribute.assert_any_call("trodo.run_id", RUN_ID)
+        live_span.set_attribute.assert_any_call("trodo.parent_span_id", ROOT_SPAN_ID)
+
+    def test_recovers_run_from_stamped_attrs_when_contextvars_empty(self):
+        # Simulate the failure mode: span fires on_end outside any wrap_agent.
+        assert get_active_context() is None
+        otel = _fake_otel_span(
+            start_ns=1_000_000_000,
+            end_ns=2_000_000_000,
+            attrs={
+                "trodo.run_id": RUN_ID,
+                "trodo.parent_span_id": ROOT_SPAN_ID,
+                "gen_ai.request.model": "claude-3-7",
+            },
+        )
+        span = otel_span_to_trodo_span(otel)
+        assert span is not None
+        assert span.run_id == RUN_ID
+        assert span.parent_span_id == ROOT_SPAN_ID
+
+    def test_strips_trodo_attrs_from_persisted_span(self):
+        otel = _fake_otel_span(
+            start_ns=1_000_000_000,
+            end_ns=2_000_000_000,
+            attrs={
+                "trodo.run_id": RUN_ID,
+                "trodo.parent_span_id": ROOT_SPAN_ID,
+                "gen_ai.request.model": "gpt-4",
+            },
+        )
+        span = otel_span_to_trodo_span(otel)
+        assert "trodo.run_id" not in (span.attributes or {})
+        assert "trodo.parent_span_id" not in (span.attributes or {})
+        assert (span.attributes or {}).get("gen_ai.request.model") == "gpt-4"
+
+    def test_drops_span_when_no_run_id_anywhere(self):
+        otel = _fake_otel_span(start_ns=1, end_ns=2, attrs={})
+        assert otel_span_to_trodo_span(otel) is None
+
+
+class TestVercelAiContentMapping:
+    """Regression: the bridge read input/output only from gen_ai.*/llm.*, so
+    Vercel AI SDK spans (ai.* convention) landed with input/output = None and
+    the prompt/response stranded in attributes -> nothing embedded or scored."""
+
+    def _span(self, name, attrs):
+        s = _fake_otel_span(start_ns=1_000_000_000, end_ns=2_000_000_000, attrs=attrs)
+        s.name = name
+        return s
+
+    def test_maps_ai_prompt_messages_and_response_text(self):
+        otel = self._span(
+            "ai.streamText.doStream",
+            {
+                "trodo.run_id": RUN_ID,
+                "gen_ai.system": "openrouter",
+                "ai.model.id": "gemini-2.5-flash-lite",
+                "ai.usage.promptTokens": 766,
+                "ai.usage.completionTokens": 5,
+                "ai.prompt.messages": '[{"role":"user","content":"gaming monitor specs"}]',
+                "ai.response.text": "Here are some gaming monitors...",
+            },
+        )
+        span = otel_span_to_trodo_span(otel)
+        assert span is not None
+        assert span.kind == "llm"
+        assert "gaming monitor specs" in span.input
+        assert "gaming monitors" in span.output
+        assert span.model == "gemini-2.5-flash-lite"
+        assert span.input_tokens == 766
+        assert span.output_tokens == 5
+
+    def test_maps_ai_toolcall_args_and_result(self):
+        otel = self._span(
+            "ai.toolCall",
+            {
+                "trodo.run_id": RUN_ID,
+                "ai.toolCall.name": "create_object",
+                "ai.toolCall.args": '{"isValid":true}',
+                "ai.toolCall.result": '{"ok":1}',
+            },
+        )
+        span = otel_span_to_trodo_span(otel)
+        assert span is not None
+        assert span.kind == "tool"
+        assert span.tool_name == "create_object"
+        assert span.input == '{"isValid":true}'
+        assert span.output == '{"ok":1}'
+
+
+class TestCrossConventionContent:
+    """Convention-agnostic capture: OpenLLMetry (raw Anthropic/OpenAI/LangChain)
+    and OpenInference use indexed attrs; earlier only single-value keys were read
+    so those spans landed with empty input/output."""
+
+    def _span(self, attrs):
+        s = _fake_otel_span(start_ns=1_000_000_000, end_ns=2_000_000_000, attrs={"trodo.run_id": RUN_ID, **attrs})
+        s.name = "llm"
+        return s
+
+    def test_openllmetry_indexed(self):
+        s = otel_span_to_trodo_span(self._span({
+            "gen_ai.prompt.0.role": "system", "gen_ai.prompt.0.content": "be nice",
+            "gen_ai.prompt.1.role": "user", "gen_ai.prompt.1.content": "hi",
+            "gen_ai.completion.0.role": "assistant", "gen_ai.completion.0.content": "hello",
+        }))
+        assert "be nice" in s.input and "hi" in s.input
+        assert "hello" in s.output
+
+    def test_openinference_indexed(self):
+        s = otel_span_to_trodo_span(self._span({
+            "llm.input_messages.0.message.role": "user",
+            "llm.input_messages.0.message.content": "question",
+            "llm.output_messages.0.message.content": "reply",
+        }))
+        assert "question" in s.input
+        assert "reply" in s.output
+
+    def test_openinference_value_keys(self):
+        s = otel_span_to_trodo_span(self._span({"input.value": "the input", "output.value": "the output"}))
+        assert s.input == "the input"
+        assert s.output == "the output"
+
+    def test_otel_current_messages(self):
+        s = otel_span_to_trodo_span(self._span({
+            "gen_ai.input.messages": '[{"role":"user","parts":[{"content":"q"}]}]',
+            "gen_ai.output.messages": '[{"role":"assistant","parts":[{"content":"a"}]}]',
+        }))
+        assert '"q"' in s.input and '"a"' in s.output
+
+    def test_vercel_toolcalls_output(self):
+        s = otel_span_to_trodo_span(self._span({
+            "ai.prompt.messages": '[{"role":"user","content":"eval"}]',
+            "ai.response.toolCalls": '[{"toolName":"create_object"}]',
+        }))
+        assert "create_object" in s.output
+
+    def test_langfuse_traceloop_single(self):
+        s = otel_span_to_trodo_span(self._span({
+            "langfuse.observation.input": "user asked X",
+            "traceloop.entity.output": '{"result":"Y"}',
+        }))
+        assert s.input == "user asked X"
+        assert "Y" in s.output

{trodo_python-2.10.8 → trodo_python-2.10.10}/trodo/__init__.py

@@ -40,7 +40,7 @@ Downstream microservice (join the caller's run instead of making a new one):
 
 from __future__ import annotations
 
-__version__ = "2.10.8"
+__version__ = "2.10.10"
 
 from typing import Any, Callable, Dict, List, Optional, Union
 

{trodo_python-2.10.8 → trodo_python-2.10.10}/trodo/otel/auto_instrument.py

@@ -45,9 +45,19 @@ def _trunc(s: Any, max_len: int) -> Optional[str]:
 def _infer_kind(attrs: Dict[str, Any]) -> str:
     if not attrs:
         return "generic"
-    if attrs.get("gen_ai.tool.name"):
+    # Vercel AI SDK tool spans (`ai.toolCall`) carry ai.toolCall.name, not
+    # gen_ai.tool.name — without this they landed as 'generic'.
+    if attrs.get("gen_ai.tool.name") or attrs.get("ai.toolCall.name") or attrs.get("ai.functionCall.name"):
         return "tool"
-    if attrs.get("gen_ai.operation.name") or attrs.get("gen_ai.request.model"):
+    if (
+        attrs.get("gen_ai.operation.name")
+        or attrs.get("gen_ai.request.model")
+        or attrs.get("gen_ai.response.model")
+        or attrs.get("ai.model.id")
+        or attrs.get("ai.response.model")
+        or attrs.get("gen_ai.usage.input_tokens") is not None
+        or attrs.get("ai.usage.promptTokens") is not None
+    ):
         return "llm"
     if attrs.get("db.system") or attrs.get("retrieval.query"):
         return "retrieval"
@@ -57,6 +67,99 @@ def _infer_kind(attrs: Dict[str, Any]) -> str:
 _ATTR_TRODO_RUN_ID = "trodo.run_id"
 _ATTR_TRODO_PARENT_SPAN_ID = "trodo.parent_span_id"
 
+# ---------------------------------------------------------------------------
+# Convention-agnostic input/output extraction — covers every common LLM
+# instrumentor convention, not just Vercel AI. Mirrors the backend's
+# services/ingest/spanContent.js.
+#   - Vercel AI ...... ai.prompt(.messages) / ai.response.text|object|toolCalls,
+#                      ai.toolCall.args / ai.toolCall.result
+#   - OTel GenAI ..... gen_ai.input.messages / gen_ai.output.messages (current);
+#                      gen_ai.prompt / gen_ai.completion (legacy single value)
+#   - OpenLLMetry .... INDEXED gen_ai.prompt.{i}.role/content, gen_ai.completion.{i}.*
+#   - OpenInference .. input.value / output.value + INDEXED llm.input_messages.{i}.message.*
+#   - Traceloop/Langfuse/MLflow, plus generic llm.prompts / input / prompt
+# ---------------------------------------------------------------------------
+_INPUT_SINGLE_KEYS = [
+    "gen_ai.input.messages", "ai.prompt.messages", "ai.prompt", "gen_ai.prompt",
+    "input.value", "traceloop.entity.input", "langfuse.observation.input", "mlflow.spanInputs",
+    "llm.input_messages", "llm.prompts", "gen_ai.tool.input", "ai.toolCall.args", "input", "prompt",
+]
+_OUTPUT_SINGLE_KEYS = [
+    "gen_ai.output.messages", "ai.response.text", "ai.response.object", "ai.response.toolCalls",
+    "gen_ai.completion", "output.value", "traceloop.entity.output", "langfuse.observation.output",
+    "mlflow.spanOutputs", "llm.output_messages", "llm.completions", "gen_ai.tool.output",
+    "ai.toolCall.result", "output", "completion",
+]
+_INPUT_INDEXED_BASES = ["gen_ai.prompt", "llm.input_messages"]
+_OUTPUT_INDEXED_BASES = ["gen_ai.completion", "llm.output_messages"]
+
+
+def _first_single(attrs: Dict[str, Any], keys) -> Optional[Any]:
+    for k in keys:
+        v = attrs.get(k)
+        if v is None:
+            continue
+        if isinstance(v, str):
+            if v:
+                return v
+            continue
+        return v  # dict/list — keep structure
+    return None
+
+
+def _set_nested(obj: Dict[str, Any], path: str, val: Any) -> None:
+    parts = path.split(".")
+    cur = obj
+    for p in parts[:-1]:
+        nxt = cur.get(p)
+        if not isinstance(nxt, dict):
+            nxt = {}
+            cur[p] = nxt
+        cur = nxt
+    cur[parts[-1]] = val
+
+
+def _reconstruct_indexed(attrs: Dict[str, Any], bases) -> Optional[str]:
+    import json as _json
+    for base in bases:
+        prefix = base + "."
+        by_index: Dict[int, Dict[str, Any]] = {}
+        for key, val in attrs.items():
+            if not key.startswith(prefix):
+                continue
+            rest = key[len(prefix):]
+            dot = rest.find(".")
+            if dot < 0:
+                continue
+            idx_str = rest[:dot]
+            if not idx_str.isdigit():
+                continue
+            idx = int(idx_str)
+            by_index.setdefault(idx, {})
+            _set_nested(by_index[idx], rest[dot + 1:], val)
+        if by_index:
+            arr = [by_index[i] for i in sorted(by_index)]
+            return _json.dumps(arr)
+    return None
+
+
+def _extract_input(attrs: Dict[str, Any]) -> Optional[Any]:
+    if not isinstance(attrs, dict):
+        return None
+    single = _first_single(attrs, _INPUT_SINGLE_KEYS)
+    if single is not None:
+        return single
+    return _reconstruct_indexed(attrs, _INPUT_INDEXED_BASES)
+
+
+def _extract_output(attrs: Dict[str, Any]) -> Optional[Any]:
+    if not isinstance(attrs, dict):
+        return None
+    single = _first_single(attrs, _OUTPUT_SINGLE_KEYS)
+    if single is not None:
+        return single
+    return _reconstruct_indexed(attrs, _OUTPUT_INDEXED_BASES)
+
 
 def _span_id_to_uuid(span_id: Optional[str]) -> Optional[str]:
     """Convert an OTel hex span id into UUID format. Mirrors trodo-node's
@@ -178,20 +281,35 @@ def otel_span_to_trodo_span(otel_span: Any) -> Optional[TrodoSpan]:
         attrs.get("gen_ai.usage.input_tokens")
         or attrs.get("gen_ai.usage.prompt_tokens")
         or attrs.get("llm.usage.prompt_tokens")
+        or attrs.get("ai.usage.promptTokens")
+        or attrs.get("ai.usage.inputTokens")
     )
     out_toks = (
         attrs.get("gen_ai.usage.output_tokens")
         or attrs.get("gen_ai.usage.completion_tokens")
         or attrs.get("llm.usage.completion_tokens")
+        or attrs.get("ai.usage.completionTokens")
+        or attrs.get("ai.usage.outputTokens")
     )
     model = (
         attrs.get("gen_ai.request.model")
         or attrs.get("gen_ai.response.model")
         or attrs.get("llm.request.model")
+        or attrs.get("ai.model.id")
+        or attrs.get("ai.response.model")
+    )
+    provider = attrs.get("gen_ai.system") or attrs.get("llm.vendor") or attrs.get("ai.model.provider")
+    # Convention-agnostic — see _extract_input/_extract_output above.
+    prompt = _extract_input(attrs)
+    completion = _extract_output(attrs)
+    tool_name = (
+        attrs.get("gen_ai.tool.name")
+        or attrs.get("ai.toolCall.name")
+        or attrs.get("ai.functionCall.name")
     )
-    provider = attrs.get("gen_ai.system") or attrs.get("llm.vendor")
-    prompt = attrs.get("gen_ai.prompt") or attrs.get("llm.prompts")
-    completion = attrs.get("gen_ai.completion") or attrs.get("llm.completion")
+    temperature = attrs.get("gen_ai.request.temperature")
+    if temperature is None:
+        temperature = attrs.get("ai.settings.temperature")
 
     return TrodoSpan(
         span_id=span_id,
@@ -212,8 +330,8 @@ def otel_span_to_trodo_span(otel_span: Any) -> Optional[TrodoSpan]:
         provider=provider,
         input_tokens=int(in_toks) if in_toks is not None else None,
         output_tokens=int(out_toks) if out_toks is not None else None,
-        temperature=attrs.get("gen_ai.request.temperature"),
-        tool_name=attrs.get("gen_ai.tool.name"),
+        temperature=temperature,
+        tool_name=tool_name,
         input=prompt,
         output=completion,
         attributes=attrs or None,

{trodo_python-2.10.8 → trodo_python-2.10.10}/trodo_python.egg-info/PKG-INFO

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

trodo_python-2.10.8/tests/test_auto_instrument_fixes.py

@@ -1,111 +0,0 @@
-"""Mirror of trodo-node 2.4.3 bridge fixes for the Python SDK.
-
-Covers:
-  1. duration_ms is rounded to an integer.
-  2. Active run is recovered from on_start-stamped attributes when
-     contextvars are empty at on_end (httpx async-context loss).
-  3. Internal trodo.* attributes are stripped from the persisted span.
-"""
-
-from types import SimpleNamespace
-from unittest.mock import MagicMock
-
-import pytest
-
-from trodo.otel.auto_instrument import _OtelAdapter, otel_span_to_trodo_span
-from trodo.otel.context import (
-    ActiveSpanContext,
-    get_active_context,
-    run_with_context,
-)
-
-
-RUN_ID = "11111111-1111-1111-1111-111111111111"
-ROOT_SPAN_ID = "22222222-2222-2222-2222-222222222222"
-
-
-def _fake_otel_span(start_ns=None, end_ns=None, attrs=None, span_id_int=0xABCD1234ABCD1234, parent_span_id_int=None):
-    span_context = SimpleNamespace(span_id=span_id_int)
-    parent = SimpleNamespace(span_id=parent_span_id_int) if parent_span_id_int else None
-    return SimpleNamespace(
-        name="anthropic.messages.create",
-        get_span_context=lambda: span_context,
-        attributes=attrs or {},
-        start_time=start_ns,
-        end_time=end_ns,
-        status=None,
-        parent=parent,
-    )
-
-
-def _ctx():
-    return ActiveSpanContext(
-        run_id=RUN_ID,
-        span_id=ROOT_SPAN_ID,
-        parent_span_id=None,
-        team_site_id="site-1",
-        processor=None,  # type: ignore[arg-type]
-    )
-
-
-class TestDurationRounding:
-    def test_fractional_ns_delta_rounds_to_integer(self):
-        # 1000ms + 0.999888 fractional ms via nanos delta
-        otel = _fake_otel_span(start_ns=1_000_000_000, end_ns=2_000_999_888)
-        with run_with_context(_ctx()):
-            span = otel_span_to_trodo_span(otel)
-        assert span is not None
-        assert isinstance(span.duration_ms, int)
-        assert span.duration_ms == 1001
-
-    def test_missing_times_leaves_duration_none(self):
-        otel = _fake_otel_span(start_ns=None, end_ns=None)
-        with run_with_context(_ctx()):
-            span = otel_span_to_trodo_span(otel)
-        assert span.duration_ms is None
-
-
-class TestOnStartStamping:
-    def test_on_start_stamps_run_id_when_context_is_alive(self):
-        adapter = _OtelAdapter(processor=MagicMock())
-        live_span = MagicMock()
-        with run_with_context(_ctx()):
-            adapter.on_start(live_span, None)
-        live_span.set_attribute.assert_any_call("trodo.run_id", RUN_ID)
-        live_span.set_attribute.assert_any_call("trodo.parent_span_id", ROOT_SPAN_ID)
-
-    def test_recovers_run_from_stamped_attrs_when_contextvars_empty(self):
-        # Simulate the failure mode: span fires on_end outside any wrap_agent.
-        assert get_active_context() is None
-        otel = _fake_otel_span(
-            start_ns=1_000_000_000,
-            end_ns=2_000_000_000,
-            attrs={
-                "trodo.run_id": RUN_ID,
-                "trodo.parent_span_id": ROOT_SPAN_ID,
-                "gen_ai.request.model": "claude-3-7",
-            },
-        )
-        span = otel_span_to_trodo_span(otel)
-        assert span is not None
-        assert span.run_id == RUN_ID
-        assert span.parent_span_id == ROOT_SPAN_ID
-
-    def test_strips_trodo_attrs_from_persisted_span(self):
-        otel = _fake_otel_span(
-            start_ns=1_000_000_000,
-            end_ns=2_000_000_000,
-            attrs={
-                "trodo.run_id": RUN_ID,
-                "trodo.parent_span_id": ROOT_SPAN_ID,
-                "gen_ai.request.model": "gpt-4",
-            },
-        )
-        span = otel_span_to_trodo_span(otel)
-        assert "trodo.run_id" not in (span.attributes or {})
-        assert "trodo.parent_span_id" not in (span.attributes or {})
-        assert (span.attributes or {}).get("gen_ai.request.model") == "gpt-4"
-
-    def test_drops_span_when_no_run_id_anywhere(self):
-        otel = _fake_otel_span(start_ns=1, end_ns=2, attrs={})
-        assert otel_span_to_trodo_span(otel) is None