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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trodo-python
-Version: 2.10.9
+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.9 → trodo_python-2.10.10}/pyproject.toml

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

{trodo_python-2.10.9 → trodo_python-2.10.10}/tests/test_auto_instrument_fixes.py

@@ -159,3 +159,59 @@ class TestVercelAiContentMapping:
         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.9 → 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.9"
+__version__ = "2.10.10"
 
 from typing import Any, Callable, Dict, List, Optional, Union
 

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

@@ -67,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
@@ -206,26 +299,9 @@ def otel_span_to_trodo_span(otel_span: Any) -> Optional[TrodoSpan]:
         or attrs.get("ai.response.model")
     )
     provider = attrs.get("gen_ai.system") or attrs.get("llm.vendor") or attrs.get("ai.model.provider")
-    # Vercel AI SDK uses the `ai.*` convention, NOT gen_ai.prompt/completion:
-    # ai.prompt.messages / ai.prompt (input), ai.response.text / ai.response.object
-    # (output), ai.toolCall.args / ai.toolCall.result (tool spans). Omitting these
-    # left input/output empty -> NULL in the DB -> nothing embedded or scored.
-    prompt = (
-        attrs.get("gen_ai.prompt")
-        or attrs.get("llm.prompts")
-        or attrs.get("ai.prompt")
-        or attrs.get("ai.prompt.messages")
-        or attrs.get("ai.toolCall.args")
-        or attrs.get("input.value")
-    )
-    completion = (
-        attrs.get("gen_ai.completion")
-        or attrs.get("llm.completion")
-        or attrs.get("ai.response.text")
-        or attrs.get("ai.response.object")
-        or attrs.get("ai.toolCall.result")
-        or attrs.get("output.value")
-    )
+    # 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")

{trodo_python-2.10.9 → 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.9
+Version: 2.10.10
 Summary: Trodo Analytics SDK for Python — server-side event tracking
 License: ISC
 Keywords: analytics,tracking,trodo,server-side