reactifact 0.9.0__tar.gz → 0.9.1__tar.gz

{reactifact-0.9.0/reactifact.egg-info → reactifact-0.9.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reactifact
-Version: 0.9.0
+Version: 0.9.1
 Summary: Reactive, artifact-driven agent runtime: agents transform versioned, typed, provenance-aware artifacts inside an evolving context
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/bzdvdn/reactifact

{reactifact-0.9.0 → reactifact-0.9.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "reactifact"
-version = "0.9.0"
+version = "0.9.1"
 description = "Reactive, artifact-driven agent runtime: agents transform versioned, typed, provenance-aware artifacts inside an evolving context"
 readme = "README.md"
 requires-python = ">=3.11"

{reactifact-0.9.0 → reactifact-0.9.1}/reactifact/__init__.py

@@ -48,7 +48,7 @@ from .session import Session, SessionStore
 from .tools import FunctionTool, Tool, ToolOutput, tool
 from .triggers import Trigger
 
-__version__ = "0.9.0"
+__version__ = "0.9.1"
 
 __all__ = [
     "Agent",

{reactifact-0.9.0 → reactifact-0.9.1}/reactifact/tracing/tracer.py

@@ -16,6 +16,7 @@ from __future__ import annotations
 
 import asyncio
 import json
+import logging
 import time
 import uuid
 from collections.abc import AsyncIterator, Callable, Iterable
@@ -34,24 +35,52 @@ if TYPE_CHECKING:
     from ..events import Event
     from ..patches import Patch
 
+logger = logging.getLogger(__name__)
+
 #: Up to what size to truncate artifact/response data in a trace.
 TRACE_TRUNCATE = 1500
 
 
+def _swallow_tracing_error(where: str, exc: BaseException) -> None:
+    """Reports a tracing failure and lets the run continue (§54).
+
+    Observability is best-effort by contract: a sink that is unreachable
+    (Langfuse down, Postgres refusing connections), a custom `Tracer`
+    callback that raises, or a malformed payload must never abort the
+    business run it was only supposed to observe. Every tracer call site
+    funnels its exceptions here and carries on; the trace for that step is
+    simply dropped. `exc_info` keeps the failure debuggable in logs.
+    """
+    logger.warning(
+        "tracing step %r failed; run continues without it: %s", where, exc, exc_info=exc
+    )
+
+
 def _clip(value: str, limit: int = TRACE_TRUNCATE) -> str:
     if len(value) <= limit:
         return value
     return value[:limit] + "…"
 
 
-def _clip_messages(messages: list[dict[str, Any]]) -> list[dict[str, Any]]:
-    return [
-        {
-            "role": msg.get("role", ""),
-            "content": _clip(str(msg.get("content") or "")),
-        }
-        for msg in messages
-    ]
+def _message_fields(message: Any) -> tuple[str, Any]:
+    """Reads role/content off a `Message` dataclass, dict, or pydantic-like object.
+
+    `LLMRequest.messages` is typed `list[Message]` (a plain dataclass without
+    `model_dump`), but providers/hand-rolled callers can also hand over dicts or
+    pydantic models — only these two fields are ever traced, so attribute access
+    covers all of them without assuming a serialization method.
+    """
+    if isinstance(message, dict):
+        return str(message.get("role", "")), message.get("content")
+    return str(getattr(message, "role", "")), getattr(message, "content", None)
+
+
+def _clip_messages(messages: Iterable[Any]) -> list[dict[str, Any]]:
+    clipped: list[dict[str, Any]] = []
+    for message in messages:
+        role, content = _message_fields(message)
+        clipped.append({"role": role, "content": _clip(str(content or ""))})
+    return clipped
 
 
 class Tracer:
@@ -87,7 +116,10 @@ class Tracer:
 
     async def on_turn_end(self, trace: RunTrace) -> None:
         for sink in self.sinks:
-            await sink.export(trace)
+            try:
+                await sink.export(trace)
+            except Exception as exc:  # noqa: BLE001 — one bad sink must not fail the run
+                _swallow_tracing_error(f"{type(sink).__name__}.export", exc)
 
 
 class RecordingLLM(LLMProvider):
@@ -110,14 +142,33 @@ class RecordingLLM(LLMProvider):
         try:
             response = await self._inner.complete(request)
         except Exception as exc:  # noqa: BLE001 — record and re-raise
-            self._record(request, None, (time.monotonic() - started) * 1000, str(exc))
+            self._safe_record(
+                request, None, (time.monotonic() - started) * 1000, str(exc)
+            )
             raise
-        self._record(request, response, (time.monotonic() - started) * 1000, None)
+        self._safe_record(request, response, (time.monotonic() - started) * 1000, None)
         return response
 
     def stream(self, request: LLMRequest) -> AsyncIterator[LLMResponseChunk]:
         return self._inner.stream(request)
 
+    def _safe_record(
+        self,
+        request: LLMRequest,
+        response: LLMResponse | None,
+        latency_ms: float,
+        error: str | None,
+    ) -> None:
+        """`_record`, isolated: losing one LLMCall must not fail the LLM call.
+
+        The error path matters most: if recording raised while handling the
+        provider's own exception, it would mask that original error.
+        """
+        try:
+            self._record(request, response, latency_ms, error)
+        except Exception as exc:  # noqa: BLE001 — best-effort observability
+            _swallow_tracing_error("RecordingLLM._record", exc)
+
     def _record(
         self,
         request: LLMRequest,
@@ -130,12 +181,7 @@ class RecordingLLM(LLMProvider):
             agent=self._agent_of(),
             provider=self._provider,
             model=str(getattr(self._inner, "model", "") or ""),
-            messages=_clip_messages(
-                [
-                    m.model_dump() if hasattr(m, "model_dump") else m.__dict__
-                    for m in request.messages
-                ]
-            ),
+            messages=_clip_messages(request.messages),
             response=_clip(response.text) if response is not None else "",
             prompt_tokens=int(usage.get("prompt_tokens") or usage.get("prompt") or 0),
             completion_tokens=int(
@@ -157,15 +203,26 @@ class CompositeTracer:
         self, run_id: str, *, session_id: str, started_at: datetime
     ) -> None:
         for tracer in self.tracers:
-            tracer.on_turn_begin(run_id, session_id=session_id, started_at=started_at)
+            try:
+                tracer.on_turn_begin(
+                    run_id, session_id=session_id, started_at=started_at
+                )
+            except Exception as exc:  # noqa: BLE001 — isolate one bad tracer
+                _swallow_tracing_error(f"{type(tracer).__name__}.on_turn_begin", exc)
 
     def on_span(self, span: AgentSpan) -> None:
         for tracer in self.tracers:
-            tracer.on_span(span)
+            try:
+                tracer.on_span(span)
+            except Exception as exc:  # noqa: BLE001 — isolate one bad tracer
+                _swallow_tracing_error(f"{type(tracer).__name__}.on_span", exc)
 
     async def on_turn_end(self, trace: RunTrace) -> None:
         for tracer in self.tracers:
-            await tracer.on_turn_end(trace)
+            try:
+                await tracer.on_turn_end(trace)
+            except Exception as exc:  # noqa: BLE001 — isolate one bad tracer
+                _swallow_tracing_error(f"{type(tracer).__name__}.on_turn_end", exc)
 
 
 class RunTracer:
@@ -272,44 +329,52 @@ class RunTracer:
         ]
 
     def write_refs(self, patch: Patch, writes: list[Write]) -> list[ArtifactRef]:
-        ops_by_id: dict[str, tuple[str, Any | None]] = {}
-        for op in patch.operations:
-            artifact_id = getattr(op, "artifact_id", None)
-            if artifact_id is None:
-                continue
-            if isinstance(op, Create):
-                model: Any | None = op.data
-            elif isinstance(op, Update):
-                model = op.new_data
-            else:
-                model = None
-            ops_by_id[artifact_id] = (op.to_dict().get("type", ""), model)
-        return [
-            self.artifact_ref(
-                w.artifact_id,
-                w.version,
-                ops_by_id.get(w.artifact_id, ("", None))[0],
-                ops_by_id.get(w.artifact_id, ("", None))[1],
-            )
-            for w in writes
-        ]
+        try:
+            ops_by_id: dict[str, tuple[str, Any | None]] = {}
+            for op in patch.operations:
+                artifact_id = getattr(op, "artifact_id", None)
+                if artifact_id is None:
+                    continue
+                if isinstance(op, Create):
+                    model: Any | None = op.data
+                elif isinstance(op, Update):
+                    model = op.new_data
+                else:
+                    model = None
+                ops_by_id[artifact_id] = (op.to_dict().get("type", ""), model)
+            return [
+                self.artifact_ref(
+                    w.artifact_id,
+                    w.version,
+                    ops_by_id.get(w.artifact_id, ("", None))[0],
+                    ops_by_id.get(w.artifact_id, ("", None))[1],
+                )
+                for w in writes
+            ]
+        except Exception as exc:  # noqa: BLE001 — best-effort observability
+            _swallow_tracing_error("write_refs", exc)
+            return []
 
     def relation_refs(self, patch: Patch) -> list[RelationRef]:
         """Provenance edges (`patch.link`) recorded for the span (§34)."""
-        refs: list[RelationRef] = []
-        for op in patch.operations:
-            if not isinstance(op, Link):
-                continue
-            refs.append(
-                RelationRef(
-                    source_id=op.artifact_id,
-                    relation=op.relation,
-                    target_id=op.target_id,
-                    source_type=self._type_name(op.artifact_id, self._context),
-                    target_type=self._type_name(op.target_id, self._context),
+        try:
+            refs: list[RelationRef] = []
+            for op in patch.operations:
+                if not isinstance(op, Link):
+                    continue
+                refs.append(
+                    RelationRef(
+                        source_id=op.artifact_id,
+                        relation=op.relation,
+                        target_id=op.target_id,
+                        source_type=self._type_name(op.artifact_id, self._context),
+                        target_type=self._type_name(op.target_id, self._context),
+                    )
                 )
-            )
-        return refs
+            return refs
+        except Exception as exc:  # noqa: BLE001 — best-effort observability
+            _swallow_tracing_error("relation_refs", exc)
+            return []
 
     # ---- per-turn lifecycle ----
 
@@ -319,9 +384,12 @@ class RunTracer:
         self.run_id = str(uuid.uuid4())
         self.spans = []
         self._trace_data_cache = {}
-        self.tracer.on_turn_begin(
-            self.run_id, session_id=session_id, started_at=datetime.now(UTC)
-        )
+        try:
+            self.tracer.on_turn_begin(
+                self.run_id, session_id=session_id, started_at=datetime.now(UTC)
+            )
+        except Exception as exc:  # noqa: BLE001 — best-effort observability
+            _swallow_tracing_error("on_turn_begin", exc)
 
     def record_span(
         self,
@@ -340,31 +408,37 @@ class RunTracer:
         """
         if self.tracer is None:
             return None
-        span = AgentSpan(
-            agent=agent.name,
-            event_type=event.type.value,
-            reads=self.read_refs(reads),
-            latency_ms=latency_ms,
-            llm_calls=self._pending_llm.pop(agent.name, []),
-            error=f"{type(error).__name__}: {error}" if error is not None else None,
-            started_at=datetime.now(UTC),
-        )
-        self.spans.append(span)
-        self.tracer.on_span(span)
-        return span
+        try:
+            span = AgentSpan(
+                agent=agent.name,
+                event_type=event.type.value,
+                reads=self.read_refs(reads),
+                latency_ms=latency_ms,
+                llm_calls=self._pending_llm.pop(agent.name, []),
+                error=f"{type(error).__name__}: {error}" if error is not None else None,
+                started_at=datetime.now(UTC),
+            )
+            self.spans.append(span)
+            self.tracer.on_span(span)
+            return span
+        except Exception as exc:  # noqa: BLE001 — best-effort observability
+            _swallow_tracing_error("on_span", exc)
+            return None
 
     async def end_turn(
         self, *, session_id: str, duration_ms: float, outcome: str
     ) -> None:
         if self.tracer is None:
             return
-        await self.tracer.on_turn_end(
-            RunTrace(
-                id=self.run_id,
-                session_id=session_id,
-                started_at=datetime.now(UTC),
-                duration_ms=duration_ms,
-                outcome=outcome,
-                spans=self.spans,
-            )
+        trace = RunTrace(
+            id=self.run_id,
+            session_id=session_id,
+            started_at=datetime.now(UTC),
+            duration_ms=duration_ms,
+            outcome=outcome,
+            spans=self.spans,
         )
+        try:
+            await self.tracer.on_turn_end(trace)
+        except Exception as exc:  # noqa: BLE001 — best-effort observability
+            _swallow_tracing_error("on_turn_end", exc)

{reactifact-0.9.0 → reactifact-0.9.1/reactifact.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reactifact
-Version: 0.9.0
+Version: 0.9.1
 Summary: Reactive, artifact-driven agent runtime: agents transform versioned, typed, provenance-aware artifacts inside an evolving context
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/bzdvdn/reactifact

{reactifact-0.9.0 → reactifact-0.9.1}/tests/test_tracing.py

@@ -3,11 +3,12 @@ import json
 
 from pydantic import BaseModel
 from reactifact import Agent, Consume, Context, Patch, Runtime, RuntimeResources
-from reactifact.providers import LLMProvider, LLMRequest, LLMResponse
+from reactifact.providers import LLMProvider, LLMRequest, LLMResponse, Message
 from reactifact.tracing import (
     AgentSpan,
     ArtifactRef,
     LLMCall,
+    RecordingLLM,
     RelationRef,
     RunTrace,
     Tracer,
@@ -202,6 +203,81 @@ def test_composite_tracer_fans_out(tmp_path):
     assert run(store_b.query())["total"] == 1
 
 
+class BoomSink:
+    """A sink that is always unreachable (e.g. a down Langfuse)."""
+
+    async def export(self, trace: RunTrace) -> None:
+        raise RuntimeError("langfuse is down")
+
+
+class CapturingSink:
+    """Records the traces it received, to prove fan-out continued."""
+
+    def __init__(self) -> None:
+        self.traces: list[RunTrace] = []
+
+    async def export(self, trace: RunTrace) -> None:
+        self.traces.append(trace)
+
+
+def test_failing_sink_does_not_break_the_run():
+    """An unreachable sink is skipped; the run and healthy sinks still proceed."""
+    ok = CapturingSink()
+    ctx = Context(resources=RuntimeResources(llm=ReplyLLM()))
+    runtime = Runtime(ctx, agents=[Greeter()], tracer=Tracer(sinks=[BoomSink(), ok]))
+    ctx.create(Question(text="привет"))
+
+    assert asyncio.run(runtime.arun()) >= 1
+    assert ctx.list_artifacts(Answer)  # business outcome still produced
+    assert len(ok.traces) == 1  # the healthy sibling still got the trace
+
+
+class BoomTracer(Tracer):
+    """A custom tracer whose every callback raises."""
+
+    def on_turn_begin(self, run_id, *, session_id, started_at) -> None:
+        raise RuntimeError("boom")
+
+    def on_span(self, span) -> None:
+        raise RuntimeError("boom")
+
+    async def on_turn_end(self, trace: RunTrace) -> None:
+        raise RuntimeError("boom")
+
+
+def test_failing_custom_tracer_does_not_break_the_run():
+    ctx = Context(resources=RuntimeResources(llm=ReplyLLM()))
+    runtime = Runtime(ctx, agents=[Greeter()], tracer=BoomTracer())
+    ctx.create(Question(text="привет"))
+
+    assert asyncio.run(runtime.arun()) >= 1
+    assert ctx.list_artifacts(Answer)
+
+
+def test_composite_tracer_isolates_a_failing_member():
+    ok = CapturingSink()
+    ctx = Context(resources=RuntimeResources(llm=ReplyLLM()))
+    runtime = Runtime(
+        ctx, agents=[Greeter()], tracer=[BoomTracer(), Tracer(sinks=[ok])]
+    )
+    ctx.create(Question(text="привет"))
+
+    assert asyncio.run(runtime.arun()) >= 1
+    assert len(ok.traces) == 1  # the second tracer still received the trace
+
+
+def test_recording_llm_ignores_a_failing_recorder():
+    """A raising `on_call` must not fail the wrapped LLM call."""
+
+    def boom(call: LLMCall) -> None:
+        raise RuntimeError("tracer is down")
+
+    llm = RecordingLLM(ReplyLLM(), on_call=boom, agent_of=lambda: "agent")
+    response = asyncio.run(llm.complete(LLMRequest(messages=[Message.user("hi")])))
+
+    assert response.text == '{"text":"привет"}'
+
+
 def test_trace_store_migrates_old_schema(tmp_path):
     """Old DB without the llm_calls column — migrated without data loss."""
     import sqlite3