reactifact 0.15.0__tar.gz → 0.15.2__tar.gz

{reactifact-0.15.0/reactifact.egg-info → reactifact-0.15.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reactifact
-Version: 0.15.0
+Version: 0.15.2
 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
@@ -380,7 +380,7 @@ uv sync --extra dev --extra web
 
 ## Status & contributing
 
-Active, `0.14.x`, pre-1.0 — the API is stabilizing and `1.0` will freeze it
+Active, `0.15.x`, pre-1.0 — the API is stabilizing and `1.0` will freeze it
 (see the [roadmap](docs/roadmap.md)); releases follow
 [Keep a Changelog](CHANGELOG.md). Questions and design discussion live in
 [GitHub Discussions](https://github.com/bzdvdn/reactifact/discussions); a star,

{reactifact-0.15.0 → reactifact-0.15.2}/README.md

@@ -334,7 +334,7 @@ uv sync --extra dev --extra web
 
 ## Status & contributing
 
-Active, `0.14.x`, pre-1.0 — the API is stabilizing and `1.0` will freeze it
+Active, `0.15.x`, pre-1.0 — the API is stabilizing and `1.0` will freeze it
 (see the [roadmap](docs/roadmap.md)); releases follow
 [Keep a Changelog](CHANGELOG.md). Questions and design discussion live in
 [GitHub Discussions](https://github.com/bzdvdn/reactifact/discussions); a star,

{reactifact-0.15.0 → reactifact-0.15.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "reactifact"
-version = "0.15.0"
+version = "0.15.2"
 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.15.0 → reactifact-0.15.2}/reactifact/__init__.py

@@ -51,7 +51,7 @@ from .tools import FunctionTool, Tool, ToolOutput, tool
 from .triggers import Trigger
 from .types import register as register_type
 
-__version__ = "0.15.0"
+__version__ = "0.15.2"
 
 __all__ = [
     "Agent",

{reactifact-0.15.0 → reactifact-0.15.2}/reactifact/a2a/server.py

@@ -25,6 +25,8 @@ tasks persists the `Context` with a `Session` itself.
 """
 
 import asyncio
+import contextlib
+from collections import OrderedDict
 from collections.abc import AsyncIterator, Callable, Sequence
 from dataclasses import dataclass, field
 from typing import Any
@@ -59,6 +61,10 @@ CreateMessage = Callable[[Context, str], str]
 Reply = Callable[[Context, str], str]
 ContextFactory = Callable[[], Context]
 
+#: In-process task store bound. A long-lived A2A server must not grow `_tasks`
+#: without limit; the oldest completed task is evicted first (see `_evict`).
+_MAX_TASKS = 512
+
 
 def default_create_message(context: Context, text: str) -> str:
     """Default input hook: seed a `UserMessage` artifact (apps override this)."""
@@ -106,10 +112,11 @@ class _A2AServer:
         self._reply = reply
         self._budget = budget
         self._max_iterations = max_iterations
-        self._tasks: dict[str, _TaskRecord] = {}
+        self._tasks: OrderedDict[str, _TaskRecord] = OrderedDict()
 
     def _record_for(self, message: Message) -> _TaskRecord:
         if message.taskId and message.taskId in self._tasks:
+            self._tasks.move_to_end(message.taskId)
             return self._tasks[message.taskId]
         record = _TaskRecord(
             id=message.taskId or uuid4().hex,
@@ -117,8 +124,20 @@ class _A2AServer:
             context=self._context_factory(),
         )
         self._tasks[record.id] = record
+        self._evict()
         return record
 
+    def _evict(self) -> None:
+        """Keep `_tasks` bounded: drop the oldest terminal task first."""
+        if len(self._tasks) <= _MAX_TASKS:
+            return
+        for task_id, record in list(self._tasks.items()):
+            if record.state in TERMINAL_STATES:
+                del self._tasks[task_id]
+                break
+        else:
+            self._tasks.popitem(last=False)
+
     async def _execute(
         self,
         record: _TaskRecord,
@@ -185,14 +204,23 @@ class _A2AServer:
         run = asyncio.create_task(
             self._execute(record, params.message.text, on_event=queue.put_nowait)
         )
-        while not run.done() or not queue.empty():
-            try:
-                event = await asyncio.wait_for(queue.get(), timeout=0.05)
-            except TimeoutError:
-                continue
-            yield _sse(request_id, _status_update(record, "working", event.message))
-        await run
-        yield _sse(request_id, self.task(record))
+        try:
+            while not run.done() or not queue.empty():
+                try:
+                    event = await asyncio.wait_for(queue.get(), timeout=0.05)
+                except TimeoutError:
+                    continue
+                yield _sse(request_id, _status_update(record, "working", event.message))
+            await run
+            yield _sse(request_id, self.task(record))
+        finally:
+            # A dropped SSE client closes this generator mid-run: cancel and
+            # await the run, or it keeps executing (tokens!) and is destroyed
+            # pending ("Task was destroyed but it is pending!").
+            if not run.done():
+                run.cancel()
+                with contextlib.suppress(asyncio.CancelledError):
+                    await run
 
     def get(self, task_id: str) -> Task | None:
         record = self._tasks.get(task_id)

{reactifact-0.15.0 → reactifact-0.15.2}/reactifact/agents.py

@@ -1,17 +1,42 @@
 from __future__ import annotations
 
+import time
 from abc import ABC
 from collections.abc import Sequence
+from contextvars import ContextVar, Token
 from typing import Any
 
 from .artifacts import Artifact
 from .consume import Consume
 from .context import Context
+from .effects import current_effects
 from .events import Event, EventType
 from .patches import Patch
 from .produce import Produce, ProduceCall
 from .triggers import Trigger
 
+#: Per-task log of the produces that ran for the current agent execution:
+#: ``(produce_class_name, operations_authored, latency_ms)``. ``Runtime._execute``
+#: opens it (and later records the span), ``Agent.execute`` appends — a
+#: contextvar so concurrent executions sharing one ``Agent`` instance never race.
+_produce_runs: ContextVar[list[tuple[str, int, float]] | None] = ContextVar(
+    "reactifact_produce_runs", default=None
+)
+
+
+def begin_produce_runs() -> Token[Any]:
+    """Opens the per-task produce-run log (see ``_produce_runs``)."""
+    return _produce_runs.set([])
+
+
+def produce_runs() -> list[tuple[str, int, float]]:
+    """The produce runs recorded for the current task (empty if none)."""
+    return _produce_runs.get() or []
+
+
+def end_produce_runs(token: Token[Any]) -> None:
+    _produce_runs.reset(token)
+
 
 class Agent(ABC):  # noqa: B024 — interface without abstract methods, run() has a default
     """Base container: consumes some artifacts and produces others.
@@ -154,14 +179,30 @@ class Agent(ABC):  # noqa: B024 — interface without abstract methods, run() ha
         if not self.produces:
             return None
         inputs = self._collect_inputs(context)
+        slot = current_effects()
+        log = _produce_runs.get()
         for p in self.produces:
             runs, trigger = self._resolve_produce_call(p, event, context)
             if not runs:
                 continue
+            before = len(slot.operations) if slot is not None else 0
+            started = time.monotonic()
             call = ProduceCall(
                 context=context, inputs=inputs, event=event, trigger=trigger
             )
-            await p.produce(call)
+            try:
+                await p.produce(call)
+            finally:
+                # Record the produce even when it raises — a failing produce is
+                # exactly what a trace should show (the span is then the error
+                # span, with this produce's partial operations/latency).
+                if log is not None:
+                    operations = (
+                        len(slot.operations) if slot is not None else 0
+                    ) - before
+                    log.append(
+                        (p.name, operations, (time.monotonic() - started) * 1000)
+                    )
         return None
 
     @staticmethod

{reactifact-0.15.0 → reactifact-0.15.2}/reactifact/chat.py

@@ -26,7 +26,7 @@ from collections.abc import (
     Mapping,
     Sequence,
 )
-from contextlib import asynccontextmanager
+from contextlib import asynccontextmanager, suppress
 from dataclasses import dataclass
 from typing import Any, Literal
 
@@ -414,9 +414,16 @@ class ChatAssistant:
                         self._session_locks.pop(session_id, None)
 
     async def _open(self, session_id: str) -> Session:
-        return await self.store.open(
-            session_id, resources=_resolve_with_session(self._resources, session_id)
-        )
+        resources = _resolve_with_session(self._resources, session_id)
+        try:
+            return await self.store.open(session_id, resources=resources)
+        except Exception:
+            # A callable `resources=` built a fresh per-turn instance; if the
+            # store fails to open the session nothing else will close it.
+            if callable(self._resources):
+                with suppress(Exception):
+                    await resources.aclose()
+            raise
 
     def _memory_agents(self) -> list[Agent]:
         """The bounded-memory agent implied by `memory=`, or none."""
@@ -497,6 +504,7 @@ class ChatAssistant:
         design (see the module docstring).
         """
         async with self._locked_session(session_id):
+            session: Session | None = None
             try:
                 session = await self._open(session_id)
                 runtime = self._build_runtime(session)
@@ -504,6 +512,12 @@ class ChatAssistant:
                 logger.exception(
                     "chat.ChatAssistant: failed to open session %r", session_id
                 )
+                # If the session did open but building the runtime failed, its
+                # per-turn resources still need closing (a callable `resources=`
+                # is never referenced again).
+                if session is not None and callable(self._resources):
+                    with suppress(Exception):
+                        await session.context.resources.aclose()
                 yield ChatEvent(
                     kind="message",
                     session_id=session_id,

{reactifact-0.15.0 → reactifact-0.15.2}/reactifact/produce.py

@@ -266,6 +266,37 @@ class Produce(Generic[TOut]):
         """
         return None
 
+    #: Explicit display name (set by e.g. tool-use produces); when unset,
+    #: `name` derives a readable one from the class/function/artifact type.
+    _name: str | None = None
+
+    @property
+    def name(self) -> str:
+        """A human-readable name for traces/logs.
+
+        Subclass-style produces use their class name; an ``@produce``-decorated
+        function uses the wrapped function's name; a bare ``Produce(Model)``
+        (declared only to widen an agent's allowed ``Create`` types) falls back
+        to its output artifact type — otherwise every such no-op would show up
+        as a generic ``Produce``. An explicit ``name`` (e.g. a tool-use produce's)
+        always wins.
+        """
+        explicit = getattr(self, "_name", None)
+        if explicit:
+            return str(explicit)
+        cls = type(self).__name__
+        if cls not in ("Produce", "_FunctionProduce"):
+            return cls
+        func = getattr(self, "_func", None)
+        if func is not None:
+            return str(getattr(func, "__name__", cls))
+        artifact = getattr(self.artifact_type, "__name__", "")
+        return f"Produce[{artifact}]" if artifact else cls
+
+    @name.setter
+    def name(self, value: str) -> None:
+        self._name = value
+
     def _apply_result(self, result: Any) -> None:
         """Writes a `@produce`-decorated function's return-style result into
         the effect slot (§24).
@@ -319,6 +350,8 @@ def produce(
             )
 
         class _FunctionProduce(Produce[Any]):
+            _func: Callable[[ProduceCall], Any]
+
             async def produce(self, call: ProduceCall) -> None:
                 result = func(call)
                 if asyncio.iscoroutine(result):
@@ -329,6 +362,8 @@ def produce(
         instance = _FunctionProduce(
             artifact_type=artifact_type, also_creates=also_creates, reacts_to=reacts_to
         )
+        # Keep the function for `Produce.name` (a readable trace/log label).
+        instance._func = func
         return instance
 
     return decorator

{reactifact-0.15.0 → reactifact-0.15.2}/reactifact/runtime.py

@@ -7,7 +7,7 @@ from collections.abc import AsyncIterator, Awaitable, Callable, Mapping
 from dataclasses import dataclass
 from typing import Any, Literal, cast
 
-from .agents import Agent
+from .agents import Agent, begin_produce_runs, end_produce_runs, produce_runs
 from .artifacts import Artifact
 from .budget import Budget, BudgetLLM, BudgetTracker, RunOutcome, RunStats
 from .commit import Commit, Read, Write
@@ -31,9 +31,17 @@ logger = get_logger(__name__)
 #: A scheduled patch with its trigger reads and (optional) trace span.
 PatchWork = tuple[Patch, Agent, list[Read], AgentSpan | None]
 #: One agent execution result: patch (if any), the agent/event/reads that
-#: produced it, latency, and the exception if the produce raised and
-#: `isolate_errors` was set.
-AgentResult = tuple[Patch | None, Agent, Event, list[Read], float, BaseException | None]
+#: produced it, latency, the exception if the produce raised and
+#: `isolate_errors` was set, and the produces that ran (name/ops/latency).
+AgentResult = tuple[
+    Patch | None,
+    Agent,
+    Event,
+    list[Read],
+    float,
+    BaseException | None,
+    list[tuple[str, int, float]],
+]
 #: Performs one committed `PendingAction` (outbox). Called by the runtime after
 #: the intent is committed; the app performs the real I/O and returns (or
 #: raises). Must be idempotent on `idempotency_key` (§42).
@@ -59,6 +67,11 @@ class RunInfo:
 _ACTIVE_RUNS: dict[str, RunInfo] = {}
 _RUN_TASKS: dict[str, "asyncio.Task[Any]"] = {}
 
+#: How long `astream` waits for a cancelled runner to unwind before giving up
+#: (a well-behaved turn stops immediately; this only guards a misbehaving agent
+#: that swallows `CancelledError`).
+_CANCEL_GRACE_SECONDS = 5.0
+
 
 def active_runs() -> list[RunInfo]:
     """Snapshots of the turns currently executing in this process.
@@ -645,18 +658,22 @@ class Runtime:
         """
         patches_to_apply: list[PatchWork] = []
         runs = 0
-        for patch, agent, event, reads, latency, error in results:
+        for patch, agent, event, reads, latency, error, produce_run_list in results:
             if self._budget_exhausted():
                 break
             runs += 1
             self._runs_used += 1
             if error is not None:
                 self._errors_used += 1
-                self._trace.record_span(agent, event, reads, latency, error=error)
+                self._trace.record_span(
+                    agent, event, reads, latency, error=error, produces=produce_run_list
+                )
                 continue
             if patch is None or patch.is_empty():
                 continue
-            span = self._trace.record_span(agent, event, reads, latency)
+            span = self._trace.record_span(
+                agent, event, reads, latency, produces=produce_run_list
+            )
             self._validate_patch_types(patch, agent)
             self._enforce_authorization(patch)
             patch = self._apply_guardrails(patch)
@@ -789,6 +806,7 @@ class Runtime:
         task = asyncio.current_task()
         self._trace.register_task(task, agent.name)
         effects_token = set_effects(Effects(self.context))
+        produce_runs_token = begin_produce_runs()
         slot: Effects | None = None
         patch: Patch | None = None
         error: BaseException | None = None
@@ -812,6 +830,8 @@ class Runtime:
                 if self.on_agent_error is not None:
                     self.on_agent_error(agent, event, exc)
         finally:
+            runs = produce_runs()
+            end_produce_runs(produce_runs_token)
             reset_effects(effects_token)
             self._trace.unregister_task(task)
         latency = (time.monotonic() - started) * 1000
@@ -824,7 +844,7 @@ class Runtime:
                     "error": repr(error),
                 },
             )
-            return None, agent, event, reads, latency, error
+            return None, agent, event, reads, latency, error, runs
         logger.debug(
             "agent finished",
             extra={"agent": agent.name, "latency_ms": round(latency, 2)},
@@ -838,7 +858,7 @@ class Runtime:
                 combined.merge(patch)
             combined.merge(slot.to_patch())
             patch = combined
-        return patch, agent, event, reads, latency, None
+        return patch, agent, event, reads, latency, None, runs
 
     async def arun(
         self,
@@ -1031,13 +1051,22 @@ class Runtime:
                     break
                 get_event = asyncio.ensure_future(queue.get())
                 wait_done = asyncio.ensure_future(done.wait())
-                finished, _ = await asyncio.wait(
-                    {get_event, wait_done}, return_when=asyncio.FIRST_COMPLETED
-                )
-                if get_event in finished:
-                    yield get_event.result()
-                else:
-                    get_event.cancel()
+                try:
+                    finished, _ = await asyncio.wait(
+                        {get_event, wait_done}, return_when=asyncio.FIRST_COMPLETED
+                    )
+                    if get_event in finished:
+                        yield get_event.result()
+                finally:
+                    # Always cancel *and await* the losing future. A task that is
+                    # cancelled but never awaited stays pending until the loop
+                    # closes, producing "Task was destroyed but it is pending!"
+                    # (`Queue.get`/`Event.wait`) on every early generator close
+                    # (e.g. a dropped SSE client).
+                    for fut in (get_event, wait_done):
+                        if not fut.done():
+                            fut.cancel()
+                    await asyncio.gather(get_event, wait_done, return_exceptions=True)
             # Re-raise any agent/runtime exception instead of silently dropping it:
             # an error inside a run must reach the caller, not hide in the task.
             await task
@@ -1053,6 +1082,15 @@ class Runtime:
             )
         finally:
             task.cancel()
+            # Settle the runner too, so an early generator close (client
+            # disconnect) does not leave the run task pending at loop shutdown.
+            # Bounded: an agent that swallows `CancelledError` must never hang
+            # the caller's disconnect/shutdown path.
+            with contextlib.suppress(Exception):
+                await asyncio.wait_for(
+                    asyncio.gather(task, return_exceptions=True),
+                    timeout=_CANCEL_GRACE_SECONDS,
+                )
             self.context.unsubscribe(queue)
 
     def _apply_patch(self, patch: Patch, commit: Commit) -> list[Write]:

{reactifact-0.15.0 → reactifact-0.15.2}/reactifact/streaming.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import asyncio
+import contextlib
 from dataclasses import dataclass, field
 from datetime import UTC, datetime
 from typing import Any
@@ -30,6 +31,11 @@ class ProgressEvent:
 
 QueueEvent = asyncio.Queue[ProgressEvent]
 
+#: Per-subscriber queue bound. Status events are best-effort UI hints: a
+#: subscriber that never drains must not grow the queue without bound, so the
+#: oldest event is dropped when this is reached.
+_DEFAULT_SUBSCRIBER_QUEUE_SIZE = 1024
+
 
 class EventHub:
     """Broadcaster of agent status events into a single- or multi-stream.
@@ -38,15 +44,16 @@ class EventHub:
     runs pay nothing for announce.
     """
 
-    def __init__(self) -> None:
+    def __init__(self, maxsize: int = _DEFAULT_SUBSCRIBER_QUEUE_SIZE) -> None:
         self._subscribers: set[QueueEvent] = set()
+        self._maxsize = maxsize
 
     @property
     def has_subscribers(self) -> bool:
         return bool(self._subscribers)
 
     def subscribe(self) -> QueueEvent:
-        queue: QueueEvent = asyncio.Queue()
+        queue: QueueEvent = asyncio.Queue(maxsize=self._maxsize)
         self._subscribers.add(queue)
         return queue
 
@@ -55,4 +62,8 @@ class EventHub:
 
     def publish(self, event: ProgressEvent) -> None:
         for queue in self._subscribers:
+            if queue.full():
+                # Drop the oldest status hint rather than block or grow forever.
+                with contextlib.suppress(asyncio.QueueEmpty):
+                    queue.get_nowait()
             queue.put_nowait(event)

{reactifact-0.15.0 → reactifact-0.15.2}/reactifact/tracing/__init__.py

@@ -11,6 +11,7 @@ from .models import (
     AgentSpan,
     ArtifactRef,
     LLMCall,
+    ProduceRun,
     RelationRef,
     RunTrace,
     Tag,
@@ -35,6 +36,7 @@ __all__ = [
     "LangfuseTracer",
     "OTLPTracer",
     "PostgresStore",
+    "ProduceRun",
     "RecordingLLM",
     "RelationRef",
     "RunTrace",

{reactifact-0.15.0 → reactifact-0.15.2}/reactifact/tracing/langfuse.py

@@ -96,6 +96,11 @@ class LangfuseTracer(Tracer):
             )
             span_start = span.started_at or run_start
             agent_span_id = _span_id(f"{trace_id}:span:{i}:{span.agent}")
+            spans.extend(
+                self._produce_spans(
+                    trace_id, agent_span_id, trace_attrs, run_start, i, span
+                )
+            )
             for j, call in enumerate(span.llm_calls):
                 spans.append(
                     self._llm_span(
@@ -145,8 +150,29 @@ class LangfuseTracer(Tracer):
                 _type_summary(span.writes),
             ),
         ]
+        if span.event_artifact_type:
+            attrs.append(
+                _attr(
+                    "langfuse.observation.metadata.event_artifact_type",
+                    span.event_artifact_type,
+                )
+            )
         if span.error:
             attrs.append(_attr("langfuse.observation.metadata.error", span.error))
+        if span.produces:
+            attrs.append(
+                _attr(
+                    "langfuse.observation.metadata.produces",
+                    [
+                        {
+                            "name": p.name,
+                            "operations": p.operations,
+                            "latency_ms": p.latency_ms,
+                        }
+                        for p in span.produces
+                    ],
+                )
+            )
         return {
             "traceId": trace_id,
             "spanId": _span_id(f"{trace_id}:span:{index}:{span.agent}"),
@@ -158,6 +184,53 @@ class LangfuseTracer(Tracer):
             "attributes": attrs,
         }
 
+    def _produce_spans(
+        self,
+        trace_id: str,
+        parent_span_id: str,
+        trace_attrs: list[dict[str, Any]],
+        run_start: datetime,
+        span_index: int,
+        span: AgentSpan,
+    ) -> list[dict[str, Any]]:
+        """One child observation per produce the agent ran, so Langfuse's
+        waterfall shows the ``Consume → Produce`` steps instead of a single
+        opaque agent span.
+
+        Produces run sequentially within an agent, so they are laid out
+        back-to-back from the span start by each one's measured latency.
+        """
+        if not span.produces:
+            return []
+        cursor = span.started_at or run_start
+        out: list[dict[str, Any]] = []
+        for k, produce in enumerate(span.produces):
+            end = cursor + timedelta(milliseconds=produce.latency_ms)
+            out.append(
+                {
+                    "traceId": trace_id,
+                    "spanId": _span_id(
+                        f"{trace_id}:produce:{span_index}:{k}:{produce.name}"
+                    ),
+                    "parentSpanId": parent_span_id,
+                    "name": produce.name,
+                    "kind": 1,
+                    "startTimeUnixNano": _unix_nanos(cursor),
+                    "endTimeUnixNano": _unix_nanos(end),
+                    "attributes": [
+                        *trace_attrs,
+                        _attr("langfuse.observation.type", "span"),
+                        _attr("langfuse.observation.metadata.agent", span.agent),
+                        _attr(
+                            "langfuse.observation.metadata.operations",
+                            produce.operations,
+                        ),
+                    ],
+                }
+            )
+            cursor = end
+        return out
+
     def _llm_span(
         self,
         trace_id: str,

{reactifact-0.15.0 → reactifact-0.15.2}/reactifact/tracing/models.py

@@ -88,11 +88,31 @@ class TagAssignment(BaseModel):
     updated_at: datetime | None = None
 
 
+class ProduceRun(BaseModel):
+    """One produce execution within an agent span (§54).
+
+    An agent runs one or more ``Produce``s per event; the span records which
+    ones actually ran and how much each contributed (``operations`` = authored
+    effect operations, so the produce that did the work is distinguishable from
+    one that merely matched the event).
+    """
+
+    name: str
+    operations: int = 0
+    latency_ms: float = 0.0
+
+
 class AgentSpan(BaseModel):
     """A single agent execution within a run (§54)."""
 
     agent: str
     event_type: str = ""
+    #: The artifact type whose change triggered this agent (its matched
+    #: ``Consume``) — e.g. ``DraftAnswer`` vs ``FinalResponse`` for an agent that
+    #: consumes both. ``event_type`` alone (created/updated) can't tell them apart.
+    event_artifact_type: str = ""
+    #: The produces that ran for this event, in execution order.
+    produces: list[ProduceRun] = Field(default_factory=list)
     reads: list[ArtifactRef] = Field(default_factory=list)
     writes: list[ArtifactRef] = Field(default_factory=list)
     relations: list[RelationRef] = Field(default_factory=list)

{reactifact-0.15.0 → reactifact-0.15.2}/reactifact/tracing/otlp.py

@@ -123,8 +123,19 @@ class OTLPTracer(Tracer):
             attr("reactifact.reads", type_summary(span.reads)),
             attr("reactifact.writes", type_summary(span.writes)),
         ]
+        if span.event_artifact_type:
+            attrs.append(
+                attr("reactifact.event_artifact_type", span.event_artifact_type)
+            )
         if span.error:
             attrs.append(attr("error.type", span.error))
+        if span.produces:
+            attrs.append(
+                attr(
+                    "reactifact.produces",
+                    ", ".join(f"{p.name}({p.operations})" for p in span.produces),
+                )
+            )
         return {
             "traceId": tid,
             "spanId": span_id(f"{tid}:span:{index}:{span.agent}"),