trodo-python 2.8.0__py3-none-any.whl → 2.10.0__py3-none-any.whl

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.8.0"
+__version__ = "2.10.0"
 
 from typing import Any, Callable, Dict, List, Optional, Union
 

trodo/otel/auto_instrument.py

@@ -22,6 +22,13 @@ def _hr_to_iso(nanos: Optional[int]) -> Optional[str]:
     return datetime.fromtimestamp(nanos / 1e9, tz=timezone.utc).isoformat().replace("+00:00", "Z")
 
 
+def _trunc(s: Any, max_len: int) -> Optional[str]:
+    if s is None:
+        return None
+    s = str(s)
+    return s[:max_len] if len(s) > max_len else s
+
+
 def _infer_kind(attrs: Dict[str, Any]) -> str:
     if not attrs:
         return "generic"
@@ -111,6 +118,29 @@ def otel_span_to_trodo_span(otel_span: Any) -> Optional[TrodoSpan]:
     except Exception:
         ok = "error" if (status_code and str(status_code).endswith("ERROR")) else "ok"
 
+    # Rich error detail. The real exception class + stacktrace live in the OTel
+    # `exception` event (record_exception — emitted by the Anthropic/OpenAI/
+    # LangChain instrumentors), NOT span.status. The old bridge read only the
+    # status code and dropped all of it.
+    status_desc = getattr(status, "description", None)
+    exc_attrs: Dict[str, Any] = {}
+    for ev in (getattr(otel_span, "events", None) or []):
+        if getattr(ev, "name", None) == "exception":
+            exc_attrs = dict(getattr(ev, "attributes", {}) or {})
+            break
+    err_type = exc_attrs.get("exception.type") or attrs.get("exception.type") or attrs.get("error.type")
+    err_msg = exc_attrs.get("exception.message") or attrs.get("exception.message") or status_desc
+    err_stack = exc_attrs.get("exception.stacktrace") or attrs.get("exception.stacktrace")
+    status_code_val = (
+        attrs.get("http.response.status_code")
+        or attrs.get("http.status_code")
+        or attrs.get("gen_ai.response.status_code")
+        or attrs.get("error.code")
+    )
+    has_error = ok == "error" or err_type is not None
+    ok = "error" if has_error else "ok"
+    level = "error" if has_error else "default"
+
     # Accept both stable and experimental GenAI semconv keys.
     in_toks = (
         attrs.get("gen_ai.usage.input_tokens")
@@ -138,6 +168,11 @@ def otel_span_to_trodo_span(otel_span: Any) -> Optional[TrodoSpan]:
         kind=kind,
         name=getattr(otel_span, "name", kind),
         status=ok,
+        level=level,
+        error_type=_trunc(err_type, 128) if err_type else None,
+        error_message=_trunc(err_msg, 4_000) if err_msg else None,
+        status_code=_trunc(status_code_val, 32) if status_code_val is not None else None,
+        stack_trace=_trunc(err_stack, 20_000) if err_stack else None,
         started_at=started_at,
         ended_at=ended_at,
         duration_ms=duration_ms,

trodo/otel/helpers.py

@@ -413,6 +413,7 @@ def track_mcp(
         "kind": "tool",
         "name": f"tool.{tool}",
         "status": status,
+        "level": "error" if error else "default",
         "input": _stringify({"tool": tool, "params": input}) if input is not None else None,
         "output": _stringify(output_to_record),
         "tool_name": tool,

trodo/otel/processor.py

@@ -20,12 +20,18 @@ class TrodoRun:
     conversation_id: Optional[str] = None
     parent_run_id: Optional[str] = None
     status: str = "ok"  # 'running' | 'ok' | 'error'
+    # Severity (Langfuse parity): 'debug' | 'default' | 'warning' | 'error'.
+    # Optional — backend derives it from status when omitted.
+    level: Optional[str] = None
     input: Optional[Union[str, Dict[str, Any]]] = None
     output: Optional[Union[str, Dict[str, Any]]] = None
     started_at: Optional[str] = None
     ended_at: Optional[str] = None
     duration_ms: Optional[int] = None
     error_summary: Optional[str] = None
+    # Exception class of the run-level failure (runs previously only had the
+    # free-text error_summary).
+    error_type: Optional[str] = None
     metadata: Optional[Dict[str, Any]] = None
     # Aggregates summed from child spans at finalisation.
     total_tokens_in: Optional[int] = None
@@ -47,6 +53,8 @@ class TrodoSpan:
     kind: str = "generic"  # 'llm' | 'tool' | 'agent' | 'retrieval' | 'generic'
     name: str = ""
     status: str = "ok"
+    # Severity (Langfuse parity): 'debug' | 'default' | 'warning' | 'error'.
+    level: Optional[str] = None
     started_at: Optional[str] = None
     ended_at: Optional[str] = None
     duration_ms: Optional[int] = None
@@ -54,6 +62,10 @@ class TrodoSpan:
     output: Optional[Union[str, Dict[str, Any]]] = None
     error_type: Optional[str] = None
     error_message: Optional[str] = None
+    # HTTP/provider status code (e.g. '429', 'rate_limit_exceeded').
+    status_code: Optional[str] = None
+    # Truncated exception stacktrace.
+    stack_trace: Optional[str] = None
     model: Optional[str] = None
     provider: Optional[str] = None
     input_tokens: Optional[int] = None

trodo/otel/wrap_agent.py

@@ -26,6 +26,7 @@ from __future__ import annotations
 
 import json
 import time
+import traceback
 import uuid
 from datetime import datetime, timezone
 from typing import Any, Callable, Dict, Optional, Union
@@ -79,6 +80,75 @@ def _truncate(value: Any, max_len: int = _MAX_VALUE_LEN) -> Optional[str]:
     return s[:max_len] if len(s) > max_len else s
 
 
+def describe_error(exc_type, exc, tb=None) -> Dict[str, Optional[str]]:
+    """Extract rich error detail from a caught exception so spans carry error
+    TYPE, HTTP/provider STATUS CODE, and STACK TRACE — not just a message.
+
+    Works generically across provider SDKs: OpenAI (``exc.status`` /
+    ``exc.code``), Anthropic (``exc.status``), httpx/requests
+    (``exc.response.status_code``), and stdlib errors (``exc.errno``). Never
+    raises. Returns keys: error_type, error_message, status_code, stack_trace,
+    level.
+    """
+    if exc is None:
+        return {"error_type": None, "error_message": None, "status_code": None,
+                "stack_trace": None, "level": "error"}
+    error_type = getattr(exc_type, "__name__", None) or type(exc).__name__
+    error_message = _truncate(str(exc), 4_000)
+
+    status_code: Optional[str] = None
+    # HTTP status first (numeric), then a provider/system error code.
+    for attr in ("status", "status_code"):
+        v = getattr(exc, attr, None)
+        if v is not None:
+            status_code = str(v)[:32]
+            break
+    if status_code is None:
+        resp = getattr(exc, "response", None)
+        rc = getattr(resp, "status_code", None) if resp is not None else None
+        if rc is not None:
+            status_code = str(rc)[:32]
+    if status_code is None:
+        code = getattr(exc, "code", None) or getattr(exc, "errno", None)
+        if code is not None:
+            status_code = str(code)[:32]
+
+    stack_trace: Optional[str] = None
+    try:
+        stack_trace = _truncate("".join(traceback.format_exception(exc_type, exc, tb)), 20_000)
+    except Exception:
+        stack_trace = None
+
+    return {
+        "error_type": (error_type or "Error")[:128],
+        "error_message": error_message,
+        "status_code": status_code,
+        "stack_trace": stack_trace,
+        "level": "error",
+    }
+
+
+def _resolve_error(handle, exc_type, exc, tb) -> Dict[str, Optional[str]]:
+    """Resolve a span's final error state from either a raised exception (wins)
+    or a manual ``handle.set_error(...)``. Returns describe_error's keys plus a
+    ``status`` of 'ok'|'error'."""
+    if exc is not None:
+        info = describe_error(exc_type, exc, tb)
+        info["status"] = "error"
+        return info
+    if handle is not None and getattr(handle, "has_error", False):
+        return {
+            "status": "error",
+            "error_type": handle.error_type,
+            "error_message": handle.error_message,
+            "status_code": handle.status_code,
+            "stack_trace": handle.stack_trace,
+            "level": "error",
+        }
+    return {"status": "ok", "error_type": None, "error_message": None,
+            "status_code": None, "stack_trace": None, "level": None}
+
+
 def _prepare_value(value: Any, max_len: int = _MAX_VALUE_LEN) -> Optional[Union[str, Dict[str, Any]]]:
     """Prepare a value for storage in the JSONB input/output column.
 
@@ -172,6 +242,10 @@ class RunHandle:
         self.input: Optional[Union[str, Dict[str, Any]]] = None
         self.output: Optional[Union[str, Dict[str, Any]]] = None
         self.metadata: Dict[str, Any] = {}
+        # Manually-recorded run-level error (via set_error_summary). When set
+        # without a raised exception, the run finalises as ``error``.
+        self.error_summary: Optional[str] = None
+        self.error_type: Optional[str] = None
 
     def set_input(self, value: Any) -> None:
         self.input = _prepare_value(value)
@@ -182,6 +256,15 @@ class RunHandle:
     def set_metadata(self, **kwargs: Any) -> None:
         self.metadata.update(kwargs)
 
+    def set_error_summary(self, summary: str, *, type: Optional[str] = None) -> None:
+        """Mark the run as errored without raising — e.g. a soft failure the
+        agent recovered from but you still want recorded. Sets ``status='error'``
+        and ``error_summary`` on the run at finalisation.
+        """
+        self.error_summary = _truncate(summary, 4_000)
+        if type:
+            self.error_type = str(type)[:128]
+
 
 class SpanHandle:
     """Handle returned by span context manager for setting output/attrs."""
@@ -204,6 +287,48 @@ class SpanHandle:
         self.cost_details: Optional[Dict[str, float]] = None
         self.temperature: Optional[float] = None
         self.tool_name: Optional[str] = None
+        # Severity for this span (Langfuse parity). Leave None for the default
+        # behaviour (backend derives 'error' on a thrown exception, else
+        # 'default'). Set 'warning' for a recovered/retried step, 'debug' for
+        # verbose spans.
+        self.level: Optional[str] = None
+        # Manually-recorded error (via set_error) — applied at span close even
+        # when the body didn't raise. A raised exception still wins over these.
+        self.error_type: Optional[str] = None
+        self.error_message: Optional[str] = None
+        self.status_code: Optional[str] = None
+        self.stack_trace: Optional[str] = None
+
+    def set_level(self, level: str) -> None:
+        """Mark this span's severity (does not change ok/error status)."""
+        self.level = level
+
+    def set_error(
+        self,
+        message: str,
+        *,
+        type: Optional[str] = None,
+        status_code: Optional[Any] = None,
+        stack_trace: Optional[str] = None,
+    ) -> None:
+        """Record an error on this span without raising — for when you catch an
+        exception to recover but still want it captured. Sets ``status='error'``
+        plus ``error_type`` / ``error_message`` (and optional ``status_code``),
+        and defaults the severity to ``error``.
+        """
+        self.error_message = _truncate(message, 4_000)
+        self.error_type = str(type or "Error")[:128]
+        if status_code is not None and status_code != "":
+            self.status_code = str(status_code)[:32]
+        if stack_trace:
+            self.stack_trace = _truncate(stack_trace, 20_000)
+        if self.level is None:
+            self.level = "error"
+
+    @property
+    def has_error(self) -> bool:
+        """True when set_error was called (span should finalise as error)."""
+        return self.error_message is not None or self.error_type is not None
 
     def set_input(self, value: Any) -> None:
         self.input = _prepare_value(value)
@@ -418,10 +543,22 @@ class wrap_agent:
         assert self.handle is not None
         ended_iso = _now_iso()
         duration_ms = int(time.time() * 1000.0 - self._started_ms)
-        status = "error" if exc is not None else "ok"
-        error_summary = None
+        # Error precedence: a raised exception wins; otherwise a manual
+        # run.set_error_summary(...) marks the run errored without raising.
+        manual_run_error = self.handle.error_summary is not None
         if exc is not None:
-            error_summary = _truncate(str(exc), 4_000)
+            status = "error"
+            einfo = describe_error(exc_type, exc, tb)
+            error_summary = einfo["error_message"]
+            error_type = einfo["error_type"]
+        elif manual_run_error:
+            status = "error"
+            error_summary = self.handle.error_summary
+            error_type = self.handle.error_type
+        else:
+            status = "ok"
+            error_summary = None
+            error_type = None
 
         pending = self._processor.get_pending(self.handle.run_id)
         agg = _aggregate(pending)
@@ -433,12 +570,14 @@ class wrap_agent:
             conversation_id=self._conversation_id,
             parent_run_id=self._parent_run_id,
             status=status,
+            level="error" if status == "error" else None,
             input=self.handle.input,
             output=self.handle.output,
             started_at=self._started_iso,
             ended_at=ended_iso,
             duration_ms=duration_ms,
             error_summary=error_summary,
+            error_type=error_type,
             metadata={**(self._metadata or {}), **self.handle.metadata} or None,
             total_tokens_in=agg["total_tokens_in"],
             total_tokens_out=agg["total_tokens_out"],
@@ -583,9 +722,9 @@ class join_run:
             return None
         ended_iso = _now_iso()
         duration_ms = int(time.time() * 1000.0 - self._started_ms)
-        status = "error" if exc is not None else "ok"
-        error_type = exc_type.__name__ if exc_type else None
-        error_message = _truncate(str(exc), 4_000) if exc else None
+        einfo = _resolve_error(self.handle, exc_type, exc, tb)
+        status = einfo["status"]
+        level = self.handle.level or einfo["level"]
 
         trodo_span = TrodoSpan(
             span_id=self._span_id,
@@ -594,13 +733,16 @@ class join_run:
             kind=self._kind,
             name=self._name,
             status=status,
+            level=level,
             started_at=self._started_iso,
             ended_at=ended_iso,
             duration_ms=duration_ms,
             input=self.handle.input,
             output=self.handle.output,
-            error_type=error_type,
-            error_message=error_message,
+            error_type=einfo["error_type"],
+            error_message=einfo["error_message"],
+            status_code=einfo["status_code"],
+            stack_trace=einfo["stack_trace"],
             model=self.handle.model,
             provider=self.handle.provider,
             input_tokens=self.handle.input_tokens,
@@ -675,9 +817,9 @@ class span:
             return None
         ended_iso = _now_iso()
         duration_ms = int(time.time() * 1000.0 - self._started_ms)
-        status = "error" if exc is not None else "ok"
-        error_type = exc_type.__name__ if exc_type else None
-        error_message = _truncate(str(exc), 4_000) if exc else None
+        einfo = _resolve_error(self.handle, exc_type, exc, tb)
+        status = einfo["status"]
+        level = self.handle.level or einfo["level"]
 
         trodo_span = TrodoSpan(
             span_id=self._span_id,
@@ -686,13 +828,16 @@ class span:
             kind=self._kind,
             name=self._name,
             status=status,
+            level=level,
             started_at=self._started_iso,
             ended_at=ended_iso,
             duration_ms=duration_ms,
             input=self.handle.input,
             output=self.handle.output,
-            error_type=error_type,
-            error_message=error_message,
+            error_type=einfo["error_type"],
+            error_message=einfo["error_message"],
+            status_code=einfo["status_code"],
+            stack_trace=einfo["stack_trace"],
             model=self.handle.model,
             provider=self.handle.provider,
             input_tokens=self.handle.input_tokens,

{trodo_python-2.8.0.dist-info → trodo_python-2.10.0.dist-info}/METADATA

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

{trodo_python-2.8.0.dist-info → trodo_python-2.10.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-trodo/__init__.py,sha256=UhZyFiLF3cVeDzreNw_4QCHkcP-wM1ifPF0adtbUHyk,16678
+trodo/__init__.py,sha256=qkeqpKx-jNb_bkLxbo-JmFR6tfMrc3QAuVvKRdJSMgk,16679
 trodo/client.py,sha256=8DsKoLh_eaNxj93qkHynfeee-QsdomB_kXfUQjGnWDk,18607
 trodo/types.py,sha256=eySgUvCXROG2TxtxgiU0MNr5iH0DEcduK8bmYtTKG44,3138
 trodo/user_context.py,sha256=9la6azzwEanVmdP4ps_xMoufbeWVeIGU-M8ychmgajg,7859
@@ -12,20 +12,20 @@ trodo/managers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 trodo/managers/group_manager.py,sha256=ki3Se3qEoSZfREX63oeDeBmEfZF-ISHLE8azEtLg0tM,3542
 trodo/managers/people_manager.py,sha256=mMVnx40Mlifx6NGgChvohC9ViK6dQu2mkXNHbV8pK1E,2882
 trodo/otel/__init__.py,sha256=yiRFXWUU45bAM2CV37XeO7zf1hmnmjufdP4XO50yEyE,624
-trodo/otel/auto_instrument.py,sha256=7uKhir0o0Mo_od1H2oMf5PHZovcUocHtgV18mRm2Erc,11193
+trodo/otel/auto_instrument.py,sha256=gym90cYD6NzVDVsNtUjKHdKANy17t4AnU4lYGEGHyo8,12866
 trodo/otel/context.py,sha256=iJ1rE42-SbO8VZHAxhIl2ZJXgNwLIVps5xLg8GKgfFc,1165
-trodo/otel/helpers.py,sha256=7N1Iyi9IsDHkXpKnGnHl6fuLynQKX0tx61cgeuspCy4,20004
-trodo/otel/processor.py,sha256=Qtc5QEIKKv5EaGO0KF7kp02DUZbCziKvWDIHxCss8H0,6884
+trodo/otel/helpers.py,sha256=4HsjMOrE-7zuvaRSiGXxV7ZyfXQ5gLxtR3HdpLut9sk,20054
+trodo/otel/processor.py,sha256=aqcTmzTw9cESgIp829pu_XCa5_dG_2MaeJNsqJZeqQU,7495
 trodo/otel/register.py,sha256=YV2EnkUoa-_54YAuChOe-Mg28UUKg8JO7-qhVP9G6u4,7644
 trodo/otel/transport.py,sha256=hzZz8gwSMGJ8CxdijmLn1Ljt18owr9XTWy13DLbwYbw,2441
-trodo/otel/wrap_agent.py,sha256=NZ3yc2grRyoImjWDqCOuhBxJGbXxGQzKL8b2Yqp_iQc,27370
+trodo/otel/wrap_agent.py,sha256=zci2Nkoxwojz2f565fTCXfKUbQtaqfo8t7H2K3xr1CU,33511
 trodo/queue/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 trodo/queue/batch_flusher.py,sha256=4Lg6T3Urwi9U0Q4FpFGPmjDYKg4ZliCTR-ND8BJvWaY,1298
 trodo/queue/event_queue.py,sha256=EVFZrhlq_kwC3jJ2GK0wMhHISf9UzLCZNDnT_aZ2I2A,872
 trodo/session/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 trodo/session/server_session.py,sha256=McsudEiq33XDq3nqxgzBcUvIjQxCMscwEuAPnYXrTjs,2136
 trodo/session/session_manager.py,sha256=JrgH1VeicmtlxPR4dXEuJbxhi23OelkgwW3-9Slv80o,2525
-trodo_python-2.8.0.dist-info/METADATA,sha256=RfMusdv9xrhyXjlg_zXFxeaEMfppXm8yg2mw7ClATKA,20482
-trodo_python-2.8.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-trodo_python-2.8.0.dist-info/top_level.txt,sha256=VCQu1CJWFmNsqTs1YxMcw4Mq35Tc3z3uI9RwHEXAayQ,6
-trodo_python-2.8.0.dist-info/RECORD,,
+trodo_python-2.10.0.dist-info/METADATA,sha256=ygRdfLxMzy896pqXhPsUEHeAULJ2P2BopImCjynGC08,20483
+trodo_python-2.10.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+trodo_python-2.10.0.dist-info/top_level.txt,sha256=VCQu1CJWFmNsqTs1YxMcw4Mq35Tc3z3uI9RwHEXAayQ,6
+trodo_python-2.10.0.dist-info/RECORD,,

{trodo_python-2.8.0.dist-info → trodo_python-2.10.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (82.0.1)
+Generator: setuptools (83.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any