trodo-python 2.9.0__tar.gz → 2.10.0__tar.gz

{trodo_python-2.9.0 → trodo_python-2.10.0}/PKG-INFO

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

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

{trodo_python-2.9.0 → trodo_python-2.10.0}/tests/test_error_enrichment.py

@@ -70,6 +70,29 @@ def test_errored_span_and_run_carry_rich_error_fields(processor, http):
     assert "rate limit exceeded" in run_payload["error_summary"]
 
 
+def test_set_error_records_without_raising(processor, http):
+    with wrap_agent(processor=processor, team_site_id="site-x", agent_name="chat") as run:
+        with span("soft-step", kind="tool") as s:
+            s.set_error("bad input", type="ValidationError", status_code=422)
+            # no raise — the span still finalises as error
+        run.set_error_summary("partial failure", type="PartialFailure")
+
+    ingest = http.run_ingest[0]
+    run_payload = ingest["run"]
+    s = next(x for x in ingest.get("spans", []) if x["name"] == "soft-step")
+
+    assert s["status"] == "error"
+    assert s["error_type"] == "ValidationError"
+    assert s["error_message"] == "bad input"
+    assert s["status_code"] == "422"
+    assert s["level"] == "error"
+
+    assert run_payload["status"] == "error"
+    assert run_payload["error_summary"] == "partial failure"
+    assert run_payload["error_type"] == "PartialFailure"
+    assert run_payload["level"] == "error"
+
+
 def test_healthy_span_omits_error_fields(processor, http):
     with wrap_agent(processor=processor, team_site_id="site-x", agent_name="chat"):
         with span("ok-step", kind="generic"):

{trodo_python-2.9.0 → trodo_python-2.10.0}/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.9.0"
+__version__ = "2.10.0"
 
 from typing import Any, Callable, Dict, List, Optional, Union
 

{trodo_python-2.9.0 → trodo_python-2.10.0}/trodo/otel/wrap_agent.py

@@ -128,6 +128,27 @@ def describe_error(exc_type, exc, tb=None) -> Dict[str, Optional[str]]:
     }
 
 
+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.
 
@@ -221,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)
@@ -231,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."""
@@ -258,11 +292,44 @@ class SpanHandle:
         # '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)
 
@@ -476,9 +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"
-        einfo = describe_error(exc_type, exc, tb) if exc is not None else None
-        error_summary = einfo["error_message"] if einfo else 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:
+            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)
@@ -490,14 +570,14 @@ class wrap_agent:
             conversation_id=self._conversation_id,
             parent_run_id=self._parent_run_id,
             status=status,
-            level="error" if exc is not None else None,
+            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=einfo["error_type"] if einfo else None,
+            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"],
@@ -642,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"
-        einfo = describe_error(exc_type, exc, tb) if exc is not None else None
-        level = self.handle.level or ("error" if exc is not None 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,
@@ -659,10 +739,10 @@ class join_run:
             duration_ms=duration_ms,
             input=self.handle.input,
             output=self.handle.output,
-            error_type=einfo["error_type"] if einfo else None,
-            error_message=einfo["error_message"] if einfo else None,
-            status_code=einfo["status_code"] if einfo else None,
-            stack_trace=einfo["stack_trace"] if einfo else None,
+            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,
@@ -737,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"
-        einfo = describe_error(exc_type, exc, tb) if exc is not None else None
-        level = self.handle.level or ("error" if exc is not None 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,
@@ -754,10 +834,10 @@ class span:
             duration_ms=duration_ms,
             input=self.handle.input,
             output=self.handle.output,
-            error_type=einfo["error_type"] if einfo else None,
-            error_message=einfo["error_message"] if einfo else None,
-            status_code=einfo["status_code"] if einfo else None,
-            stack_trace=einfo["stack_trace"] if einfo else None,
+            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.9.0 → trodo_python-2.10.0}/trodo_python.egg-info/PKG-INFO

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