Skip to content

:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.

feat(aio): serve trace node detail from a node resource (#120146)

Carlos Marchalb9f3c258c55f
diff --git a/frontend/snapshots.yml b/frontend/snapshots.yml
index 54997972c0ed..91b75822308a 100644
--- a/frontend/snapshots.yml
+++ b/frontend/snapshots.yml
@@ -9175,9 +9175,13 @@ snapshots:
scenes-app-ai-observability-trace-view-message-part--tool-call-multiline-args--light:
hash: v1.k794b7964.9574ac70d0b3fcabc0a60c1fb7b677ceb53a636337094f215b45862c289c8ee8.oELNCo2z_5ClcAdMZJArSx-p3v0tTepDm2JSRpUOC_Y
scenes-app-ai-observability-trace-view-node-detail--content-load-error--dark:
- hash: v1.k794b7964.f8fdba7601160c5e3ae32e997e2b571c43ee4735a5d3164a18af1fc387b830e9.v1Ybpavq8kWeP78qkS3yCKLOvhwNJK2C8fYLrLadHpE
+ hash: v1.k794b7964.5e36d3da09795c3413edf6908a4e90314fceb472621916dbb6de77ac40ac2a48.MayzNXkmRuKZfIU9L-TAGE67PKAPgJcY6R1UaTw1CRY
scenes-app-ai-observability-trace-view-node-detail--content-load-error--light:
- hash: v1.k794b7964.9c41bf277ca69973253ee4511786bb860e3b41c3136e7642956f1cc2f3478099.NGDcm0HC3GXzNonYv7TeTVtn696qxLC1DswZcApxOyw
+ hash: v1.k794b7964.888a327ae27d5d8ffe6cfde13c9b1871dddf48915a8957787a92f89017fc3ed9._CuQ3SAqbn5iQYF-gsQhWQPCWOjRw5gywJsKBzXZdH0
+ scenes-app-ai-observability-trace-view-node-detail--content-not-found--dark:
+ hash: v1.k794b7964.aa5f2ea36c16d32009ed51721b09b89687f10d6752c2244c0030240154736b9d.h1bZtLYGaahqQMGZ99NcWY4WezCo324_wg9Qr4sjH3o
+ scenes-app-ai-observability-trace-view-node-detail--content-not-found--light:
+ hash: v1.k794b7964.d5221fe9b3ba087f1d8715258424d71707ee37b9a2817adef30216272914353b.ZS6oiD8HREwTLnh0qdgNV7IU6TaoG5ryyrBMC6BbDzI
scenes-app-ai-observability-trace-view-node-detail--evals-load-error--dark:
hash: v1.k794b7964.8e974f8628c9cc06a2f376f029a8d4d1e5e6755bfc4e15cf1425d50ac27d5507.8xlC3RbKsMdoSiqaBI0oIq7qF844Mjm5g4b4yhjjEKA
scenes-app-ai-observability-trace-view-node-detail--evals-load-error--light:
@@ -9210,6 +9214,10 @@ snapshots:
hash: v1.k794b7964.190b2c059d38d9a4716b35b1e9c40289f527206b095aa1751f36c57b1a08f83f.CYx8ZM77Xrh0mipyOxjxDW89lmpREnNVg_WJG6JB5pk
scenes-app-ai-observability-trace-view-node-detail--nothing-captured--light:
hash: v1.k794b7964.c25dcd37e1256ce57a18d5b14719b431c974fe360b9097bc25628354f3f65b2e.UJizBxDMm7WoFJWlPPo6jv_tswAx-pRdrF5wuFpXs5Y
+ scenes-app-ai-observability-trace-view-node-detail--raw-tab-while-loading--dark:
+ hash: v1.k794b7964.18cf781434dc68c49196fc46b7b7e741d8bbaf988f969e87cddba444dda970dc.JlcKvloACxrmr1NHcJP1U9fCvsgwg0WzigUF25xx0BM
+ scenes-app-ai-observability-trace-view-node-detail--raw-tab-while-loading--light:
+ hash: v1.k794b7964.963ea7f1028cf1cac01798ba8a9666073a119fb9a80500e9f0f8138e030f9ac0.faMrLWo2r8TFBrRAi_DApZcAJ4r6AwhCiSt_GZEsXxY
scenes-app-ai-observability-trace-view-node-detail--span-details-tab--dark:
hash: v1.k794b7964.c8765f600847c62e2d29705c6833a4e43707668a4c53f57e918e8c958e25d401.KDRSsssfGhhPMk88hskuIT4xCo_HEmeHTjs17yqXbaM
scenes-app-ai-observability-trace-view-node-detail--span-details-tab--light:
@@ -9266,6 +9274,10 @@ snapshots:
hash: v1.k794b7964.f5b92092a059f22776c712b8afec2b4fa99a51f7f733fdc918cd2f288920570f.O_OKuMlShlDsZtzN8ld1vQhh1wMlc9UfPqwwgnWLc6o
scenes-app-ai-observability-trace-view-raw-event--default--light:
hash: v1.k794b7964.6feab338f432d042f8e53f328dc7709cdc79bd2fda46b6274db876c9c3ef078b.R-d9RNKhCeOY388cXbLAQhzde0lPGMMo-Dfbk3gRf6Q
+ scenes-app-ai-observability-trace-view-raw-event--no-trace-event--dark:
+ hash: v1.k794b7964.bda2d5985bf7439273c42268b1279aa6eb2fee37e1aaafb4c199e98b1a8b7e94.oySozMrViJSTs1dyaKsz_3EdiTOd9MBj91nk8MO71fc
+ scenes-app-ai-observability-trace-view-raw-event--no-trace-event--light:
+ hash: v1.k794b7964.4a4e729043d00b03247ce25fe10de02bc132f3811c6c288032abcd36ed2fea03.REnmV4U-vFpxUJB4Lfun1zLM9Tf8tvqFDafAwrTYKeo
scenes-app-ai-observability-trace-view-thread--anthropic-thinking-and-tools--dark:
hash: v1.k794b7964.b3d0fe41e4ce3167d04d9c3f1fdb4b25414b9c27f3d9b26dc4122e5490b97663.rVseBKdzxKu43YsBqrE-cO9KxX7roQd9qLgsEj49jPo
scenes-app-ai-observability-trace-view-thread--anthropic-thinking-and-tools--light:
@@ -9282,6 +9294,10 @@ snapshots:
hash: v1.k794b7964.10d636c7559a25e66b17140445ddc81e64c86227a53777de3361b3e3139b6fcd.Iv_7m3XW9y78EXvDCTLNfk-hmv7aJIGEuj-Ydq9ElP0
scenes-app-ai-observability-trace-view-thread--image-input-with-error--light:
hash: v1.k794b7964.427c25b2c17800207a09b427bd5022fc7c35a66d89b7485bcde127137a410cec.Tb6OzKrK5aukGNqRLLegxDIi6Qe_JGpImEX8rqPMD3s
+ scenes-app-ai-observability-trace-view-thread--load-error--dark:
+ hash: v1.k794b7964.833678e26fd6966ee891cb56f241ea7a49ca1481c2639c973eec48bb1f4faf28.a-7RiKkuaazD7C3uM4sG6lZLckC9f9SYc0Yyn6LAES4
+ scenes-app-ai-observability-trace-view-thread--load-error--light:
+ hash: v1.k794b7964.093afa3e6bb6a4e7bbbf07e575d729555242d2c50c2ed1d555fdcec683c9bbc7.ohzNaMQSSLTTH2R84l_YIFyh9Ak2wa5e8PtoGlk2Lic
scenes-app-ai-observability-trace-view-thread--loading--dark:
hash: v1.k794b7964.d19bc82013117a8c7c4eab890f02c545447f1f6bc1fb8dc60ab23a03fe2aaabe.qKU9q9cnJS-tZNtvV9U5Kf4gXB1BgxYq1Y6LYzWJnKE
scenes-app-ai-observability-trace-view-thread--loading--light:
diff --git a/products/ai_observability/backend/facade/api.py b/products/ai_observability/backend/facade/api.py
index 6b3033f9a66e..6c012cfd5202 100644
--- a/products/ai_observability/backend/facade/api.py
+++ b/products/ai_observability/backend/facade/api.py
@@ -3,9 +3,11 @@ from datetime import datetime
from posthog.models import Team, User
from ..logic.evaluations.pass_filters import build_evaluation_pass_filters
+from ..logic.traces.events_fallback import fallback_window
+from ..logic.traces.node import NodeEvent
from ..logic.traces.timeline import TimelineRow
from ..logic.traces.trace import Trace
-from ..logic.traces.trace_queries import fallback_window, load_trace
+from ..logic.traces.trace_queries import load_trace, load_trace_node, load_trace_root
from ..logic.traces.tree import TreeNode
from ..logic.traces.usage import Usage
from . import contracts
@@ -15,6 +17,15 @@ class TraceNotFoundError(Exception):
pass
+class TraceNodeNotFoundError(Exception):
+ pass
+
+
+_NO_METADATA = contracts.TraceNodeMetadata(
+ provider=None, temperature=None, session_id=None, prompt_name=None, prompt_version=None
+)
+
+
def is_usable_timestamp_hint(timestamp_hint: datetime) -> bool:
try:
fallback_window(timestamp_hint)
@@ -30,6 +41,22 @@ def get_trace(team: Team, user: User | None, trace_id: str, timestamp_hint: date
return _to_trace(Trace(trace_id, loaded.rows, loaded.person))
+def get_trace_node(
+ team: Team, user: User | None, trace_id: str, node_id: str, timestamp_hint: datetime | None
+) -> contracts.TraceNodeDetail:
+ if node_id == trace_id:
+ root = load_trace_root(team, user, trace_id, timestamp_hint)
+ if not root.trace_found:
+ raise TraceNodeNotFoundError(node_id)
+ if root.trace_event is None:
+ return contracts.TraceNodeDetail(id=trace_id, kind="trace", error=None, metadata=_NO_METADATA, event=None)
+ return _to_node_detail(trace_id, NodeEvent(row=root.trace_event))
+ row = load_trace_node(team, user, trace_id, node_id, timestamp_hint)
+ if row is None:
+ raise TraceNodeNotFoundError(node_id)
+ return _to_node_detail(node_id, NodeEvent(row=row))
+
+
def _to_stats(usage: Usage) -> contracts.TraceNodeStats:
return contracts.TraceNodeStats(
cost_usd=usage.cost_usd,
@@ -94,6 +121,32 @@ def _to_trace(trace: Trace) -> contracts.Trace:
timeline=[_to_timeline_row(row) for row in trace.timeline.rows],
total_ms=trace.timeline.total_ms,
thread_node_ids=trace.thread_node_ids,
+ default_node_id=trace.default_node_id,
+ node_ids_by_alias=trace.node_ids_by_alias,
+ )
+
+
+def _to_node_detail(node_id: str, event: NodeEvent) -> contracts.TraceNodeDetail:
+ keys = event.io_keys
+ metadata = event.metadata
+ return contracts.TraceNodeDetail(
+ id=node_id,
+ kind=event.kind,
+ error=event.error,
+ metadata=contracts.TraceNodeMetadata(
+ provider=metadata.provider,
+ temperature=metadata.temperature,
+ session_id=metadata.session_id,
+ prompt_name=metadata.prompt_name,
+ prompt_version=metadata.prompt_version,
+ ),
+ event=contracts.TraceNodeEvent(
+ name=event.row.event,
+ uuid=event.row.uuid,
+ timestamp=event.row.timestamp,
+ properties=event.row.properties,
+ io_keys=contracts.TraceNodeIOKeys(input=keys.input, output=keys.output, tools=keys.tools),
+ ),
)
diff --git a/products/ai_observability/backend/facade/contracts.py b/products/ai_observability/backend/facade/contracts.py
index 859a9e87b032..9f1669cad03e 100644
--- a/products/ai_observability/backend/facade/contracts.py
+++ b/products/ai_observability/backend/facade/contracts.py
@@ -1,7 +1,7 @@
from datetime import datetime
-from typing import Literal, get_args
+from typing import Any, Literal, get_args
-from pydantic import BaseModel, ConfigDict
+from pydantic import BaseModel, ConfigDict, Field
from pydantic.alias_generators import to_camel
@@ -66,6 +66,42 @@ class Trace(Contract):
timeline: list[TraceTimelineRow]
total_ms: float
thread_node_ids: list[str]
+ default_node_id: str
+ node_ids_by_alias: dict[str, str]
+
+
+class TraceNodeIOKeys(Contract):
+ input: str | None
+ output: str | None
+ tools: str | None
+
+
+class TraceNodeMetadata(Contract):
+ provider: str | None
+ temperature: float | None
+ session_id: str | None
+ prompt_name: str | None
+ prompt_version: float | None
+
+
+class TraceNodeEvent(Contract):
+ name: str
+ uuid: str
+ timestamp: datetime
+ properties: dict[str, Any] = Field(
+ description="The event's properties as ingested, including its input and output values."
+ )
+ io_keys: TraceNodeIOKeys = Field(
+ description="Which keys of `properties` hold the node's input, output and tools, or null when it has none."
+ )
+
+
+class TraceNodeDetail(Contract):
+ id: str
+ kind: TraceNodeKind
+ error: str | None
+ metadata: TraceNodeMetadata
+ event: TraceNodeEvent | None
class EvaluationPassFilters(Contract):
diff --git a/products/ai_observability/backend/logic/traces/event.py b/products/ai_observability/backend/logic/traces/event.py
index 89e4bd1ae8c0..c76d5ac1c3f5 100644
--- a/products/ai_observability/backend/logic/traces/event.py
+++ b/products/ai_observability/backend/logic/traces/event.py
@@ -9,6 +9,18 @@ from .usage import Usage
ANNOTATION_EVENTS = frozenset({"$ai_feedback", "$ai_metric"})
+def kind_of_event(event_name: str) -> TraceNodeKind:
+ match event_name:
+ case "$ai_generation":
+ return "generation"
+ case "$ai_embedding":
+ return "embedding"
+ case "$ai_trace":
+ return "trace"
+ case _:
+ return "span"
+
+
@frozen
class TraceEvent:
row: TraceEventRow
@@ -28,15 +40,7 @@ class TraceEvent:
@property
def kind(self) -> TraceNodeKind:
- match self.row.event:
- case "$ai_generation":
- return "generation"
- case "$ai_embedding":
- return "embedding"
- case "$ai_trace":
- return "trace"
- case _:
- return "span"
+ return kind_of_event(self.row.event)
@property
def is_trace_event(self) -> bool:
diff --git a/products/ai_observability/backend/logic/traces/events_fallback.py b/products/ai_observability/backend/logic/traces/events_fallback.py
new file mode 100644
index 000000000000..5ef3d9e5f946
--- /dev/null
+++ b/products/ai_observability/backend/logic/traces/events_fallback.py
@@ -0,0 +1,51 @@
+from datetime import UTC, datetime, timedelta
+
+from posthog.hogql import ast
+
+from posthog.dataclasses import frozen
+
+FALLBACK_BEFORE_HINT = timedelta(minutes=10)
+FALLBACK_AFTER_HINT = timedelta(days=7)
+# The legacy trace view used this date as its default range start when a link carried no timestamp.
+UNHINTED_FALLBACK_START = datetime(2025, 1, 10, tzinfo=UTC)
+
+
+@frozen
+class FallbackWindow:
+ start: datetime
+ end: datetime
+
+
+def fallback_window(timestamp_hint: datetime) -> FallbackWindow:
+ """Raises OverflowError when the window around the hint leaves the datetime range."""
+ return FallbackWindow(start=timestamp_hint - FALLBACK_BEFORE_HINT, end=timestamp_hint + FALLBACK_AFTER_HINT)
+
+
+def unhinted_window() -> FallbackWindow:
+ return FallbackWindow(
+ start=UNHINTED_FALLBACK_START - FALLBACK_BEFORE_HINT, end=datetime.now(UTC) + FALLBACK_AFTER_HINT
+ )
+
+
+def events_filter(*, trace_filter: ast.Expr, event_filter: ast.Expr, window: FallbackWindow | None) -> ast.Expr:
+ if window is None:
+ # The shared events table is not sorted by trace id, so a read without a window must not scan it.
+ return ast.Constant(value=False)
+ # The events table sorts by event and has no index on uuid, so without the event filter the root's uuid lookup
+ # scans every event of the team in the window.
+ return ast.And(
+ exprs=[
+ event_filter,
+ trace_filter,
+ ast.CompareOperation(
+ op=ast.CompareOperationOp.GtEq,
+ left=ast.Field(chain=["timestamp"]),
+ right=ast.Constant(value=window.start),
+ ),
+ ast.CompareOperation(
+ op=ast.CompareOperationOp.LtEq,
+ left=ast.Field(chain=["timestamp"]),
+ right=ast.Constant(value=window.end),
+ ),
+ ]
+ )
diff --git a/products/ai_observability/backend/logic/traces/node.py b/products/ai_observability/backend/logic/traces/node.py
new file mode 100644
index 000000000000..02584052f526
--- /dev/null
+++ b/products/ai_observability/backend/logic/traces/node.py
@@ -0,0 +1,89 @@
+import json
+
+from posthog.dataclasses import frozen
+
+from ...facade.contracts import TraceNodeKind
+from .event import kind_of_event
+from .trace_queries import TraceNodeRow, read_flag, read_number, read_text
+
+FAILED_STEP_MESSAGE = "This step failed."
+
+
+@frozen
+class IOKeyCandidates:
+ input: tuple[str, ...]
+ output: tuple[str, ...]
+ tools: tuple[str, ...]
+
+
+IO_KEY_CANDIDATES: dict[TraceNodeKind, IOKeyCandidates] = {
+ "generation": IOKeyCandidates(
+ input=("$ai_input",), output=("$ai_output_choices", "$ai_output"), tools=("$ai_tools",)
+ ),
+ "embedding": IOKeyCandidates(input=("$ai_input",), output=(), tools=()),
+ "span": IOKeyCandidates(
+ input=("$ai_input", "$ai_input_state"),
+ output=("$ai_output_choices", "$ai_output_state", "$ai_output"),
+ tools=(),
+ ),
+ "trace": IOKeyCandidates(
+ input=("$ai_input_state", "$ai_input"),
+ output=("$ai_output_state", "$ai_output_choices", "$ai_output"),
+ tools=(),
+ ),
+}
+
+
+@frozen
+class IOKeys:
+ input: str | None
+ output: str | None
+ tools: str | None
+
+
+@frozen
+class NodeMetadata:
+ provider: str | None
+ temperature: float | None
+ session_id: str | None
+ prompt_name: str | None
+ prompt_version: float | None
+
+
+@frozen
+class NodeEvent:
+ row: TraceNodeRow
+
+ @property
+ def kind(self) -> TraceNodeKind:
+ return kind_of_event(self.row.event)
+
+ @property
+ def io_keys(self) -> IOKeys:
+ candidates = IO_KEY_CANDIDATES[self.kind]
+ return IOKeys(
+ input=self._first_present(candidates.input),
+ output=self._first_present(candidates.output),
+ tools=self._first_present(candidates.tools),
+ )
+
+ @property
+ def error(self) -> str | None:
+ value = self.row.properties.get("$ai_error")
+ if not value:
+ return FAILED_STEP_MESSAGE if read_flag(self.row.properties.get("$ai_is_error")) else None
+ return value if isinstance(value, str) else json.dumps(value, indent=2, ensure_ascii=False)
+
+ @property
+ def metadata(self) -> NodeMetadata:
+ properties = self.row.properties
+ return NodeMetadata(
+ provider=read_text(properties.get("$ai_provider")),
+ temperature=read_number(properties.get("$ai_temperature")),
+ session_id=read_text(properties.get("$ai_session_id")),
+ prompt_name=read_text(properties.get("$ai_prompt_name")),
+ prompt_version=read_number(properties.get("$ai_prompt_version")),
+ )
+
+ def _first_present(self, keys: tuple[str, ...]) -> str | None:
+ return next((key for key in keys if self.row.properties.get(key) is not None), None)
diff --git a/products/ai_observability/backend/logic/traces/trace.py b/products/ai_observability/backend/logic/traces/trace.py
index 56d93f95ce1c..1d8e34535269 100644
--- a/products/ai_observability/backend/logic/traces/trace.py
+++ b/products/ai_observability/backend/logic/traces/trace.py
@@ -66,6 +66,25 @@ class Trace:
generation = pick_user_visible_generation(self.events)
return [generation.id] if generation else []
+ @cached_property
+ def default_node_id(self) -> str:
+ if any(event.is_trace_event for event in self.events):
+ return self.id
+ first_generation = next((node for node in self.tree if node.event.kind == "generation"), None)
+ chosen = first_generation or next(iter(self.tree), None)
+ return chosen.event.id if chosen else self.id
+
+ @cached_property
+ def node_ids_by_alias(self) -> dict[str, str]:
+ aliases: dict[str, str] = {}
+ for event in self.events:
+ if event.is_annotation or event.is_trace_event:
+ continue
+ for alias in (event.row.generation_id, event.row.span_id):
+ if alias and alias != event.id:
+ aliases.setdefault(alias, event.id)
+ return aliases
+
@property
def person_label(self) -> str | None:
if self.person is None or not self.person.distinct_id:
diff --git a/products/ai_observability/backend/logic/traces/trace_queries.py b/products/ai_observability/backend/logic/traces/trace_queries.py
index 2f8cecb510f2..e6e77c1dfe4b 100644
--- a/products/ai_observability/backend/logic/traces/trace_queries.py
+++ b/products/ai_observability/backend/logic/traces/trace_queries.py
@@ -1,28 +1,32 @@
import json
import math
-from collections.abc import Sequence
-from datetime import UTC, datetime, timedelta
+from collections.abc import Callable, Sequence
+from datetime import datetime
from typing import Any
+from uuid import UUID
import structlog
from posthog.hogql import ast
+from posthog.hogql.context import HogQLContext
+from posthog.hogql.database.database import Database
from posthog.hogql.query import execute_hogql_query
from posthog.clickhouse.query_tagging import Product, tag_queries, tags_context
from posthog.dataclasses import frozen
from posthog.hogql_queries.ai.ai_table_resolver import query_ai_events
+from posthog.hogql_queries.ai.utils import merge_heavy_properties
from posthog.models import Team, User
+from .events_fallback import FallbackWindow, events_filter, fallback_window, unhinted_window
from .person import trace_distinct_id
TRACE_EVENT_NAMES = ("$ai_trace", "$ai_span", "$ai_generation", "$ai_embedding", "$ai_metric", "$ai_feedback")
+NODE_EVENT_NAMES = ("$ai_span", "$ai_generation", "$ai_embedding")
+_HEAVY_COLUMNS = ("input", "output", "output_choices", "input_state", "output_state", "tools")
+_NODE_COLUMNS = ("uuid", "event", "timestamp", "properties", *_HEAVY_COLUMNS)
# The largest result HogQL returns; without an explicit limit it returns 100 rows.
MAX_TRACE_EVENTS = 50_000
-FALLBACK_BEFORE_HINT = timedelta(minutes=10)
-FALLBACK_AFTER_HINT = timedelta(days=7)
-# The legacy trace view used this date as its default range start when a link carried no timestamp.
-UNHINTED_FALLBACK_START = datetime(2025, 1, 10, tzinfo=UTC)
TOKEN_PROPERTIES = {
"input_tokens": "$ai_input_tokens",
"output_tokens": "$ai_output_tokens",
@@ -65,12 +69,26 @@ class PersonRow:
name: str | None
+@frozen
+class TraceNodeRow:
+ uuid: str
+ event: str
+ timestamp: datetime
+ properties: dict[str, Any]
+
+
@frozen
class LoadedTrace:
rows: tuple[TraceEventRow, ...]
person: PersonRow | None
+@frozen
+class TraceRootLookup:
+ trace_event: TraceNodeRow | None
+ trace_found: bool
+
+
def _raw_property(name: str) -> ast.Call:
return ast.Call(name="JSONExtractRaw", args=[ast.Field(chain=["properties"]), ast.Constant(value=name)])
@@ -126,26 +144,57 @@ def _ai_events() -> ast.JoinExpr:
return ast.JoinExpr(table=ast.Field(chain=["posthog", "ai_events"]), alias="ai_events")
+def _event_in(names: Sequence[str]) -> ast.Expr:
+ return ast.CompareOperation(
+ op=ast.CompareOperationOp.In,
+ left=ast.Field(chain=["event"]),
+ right=ast.Tuple(exprs=[ast.Constant(value=name) for name in names]),
+ )
+
+
+def _equals(column: str, value: str) -> ast.Expr:
+ return ast.CompareOperation(
+ op=ast.CompareOperationOp.Eq, left=ast.Field(chain=[column]), right=ast.Constant(value=value)
+ )
+
+
+def _filter_conditions() -> ast.Placeholder:
+ return ast.Placeholder(expr=ast.Field(chain=["filter_conditions"]))
+
+
def _trace_rows_query() -> ast.SelectQuery:
return ast.SelectQuery(
select=_select(),
select_from=_ai_events(),
- where=ast.And(
- exprs=[
- ast.CompareOperation(
- op=ast.CompareOperationOp.In,
- left=ast.Field(chain=["event"]),
- right=ast.Tuple(exprs=[ast.Constant(value=name) for name in TRACE_EVENT_NAMES]),
- ),
- ast.Placeholder(expr=ast.Field(chain=["filter_conditions"])),
- ]
- ),
+ where=ast.And(exprs=[_event_in(TRACE_EVENT_NAMES), _filter_conditions()]),
order_by=[ast.OrderExpr(expr=ast.Field(chain=["timestamp"]), order="ASC")],
limit_by=ast.LimitByExpr(n=ast.Constant(value=1), exprs=[ast.Field(chain=["uuid"])]),
limit=ast.Constant(value=MAX_TRACE_EVENTS),
)
+def _node_query(selection: ast.Expr) -> ast.SelectQuery:
+ return ast.SelectQuery(
+ select=[ast.Field(chain=[column]) for column in _NODE_COLUMNS],
+ select_from=_ai_events(),
+ where=ast.And(exprs=[selection, _filter_conditions()]),
+ limit=ast.Constant(value=1),
+ )
+
+
+def _node_selection(node_id: str) -> ast.Expr:
+ return ast.And(exprs=[_event_in(NODE_EVENT_NAMES), _equals("uuid", node_id)])
+
+
+def _trace_exists_query() -> ast.SelectQuery:
+ return ast.SelectQuery(
+ select=[ast.Field(chain=["uuid"])],
+ select_from=_ai_events(),
+ where=ast.And(exprs=[_event_in(TRACE_EVENT_NAMES), _filter_conditions()]),
+ limit=ast.Constant(value=1),
+ )
+
+
def _person_query(distinct_id: str) -> ast.SelectQuery:
def latest(column: str) -> ast.Call:
return ast.Call(name="argMax", args=[ast.Field(chain=[column]), ast.Field(chain=["version"])])
@@ -172,41 +221,7 @@ def _person_query(distinct_id: str) -> ast.SelectQuery:
def _trace_filter(trace_id: str) -> ast.Expr:
- return ast.CompareOperation(
- op=ast.CompareOperationOp.Eq, left=ast.Field(chain=["trace_id"]), right=ast.Constant(value=trace_id)
- )
-
-
-@frozen
-class FallbackWindow:
- start: datetime
- end: datetime
-
-
-def fallback_window(timestamp_hint: datetime) -> FallbackWindow:
- """Raises OverflowError when the window around the hint leaves the datetime range."""
- return FallbackWindow(start=timestamp_hint - FALLBACK_BEFORE_HINT, end=timestamp_hint + FALLBACK_AFTER_HINT)
-
-
-def _fallback_filter(trace_id: str, window: FallbackWindow | None) -> ast.Expr:
- if window is None:
- # The shared events table is not sorted by trace id, so a read without a window must not scan it.
- return ast.Constant(value=False)
- return ast.And(
- exprs=[
- _trace_filter(trace_id),
- ast.CompareOperation(
- op=ast.CompareOperationOp.GtEq,
- left=ast.Field(chain=["timestamp"]),
- right=ast.Constant(value=window.start),
- ),
- ast.CompareOperation(
- op=ast.CompareOperationOp.LtEq,
- left=ast.Field(chain=["timestamp"]),
- right=ast.Constant(value=window.end),
- ),
- ]
- )
+ return _equals("trace_id", trace_id)
def _read(
@@ -225,22 +240,27 @@ def _read(
user=user,
query_type=name,
fall_back_to_events=True,
- fallback_placeholders={"filter_conditions": _fallback_filter(trace_id, window)},
+ fallback_placeholders={
+ "filter_conditions": events_filter(
+ trace_filter=_trace_filter(trace_id), event_filter=_event_in(TRACE_EVENT_NAMES), window=window
+ )
+ },
+ posthog_tables_only=True,
)
return list(response.results or [])
-def _text(value: Any) -> str | None:
+def read_text(value: Any) -> str | None:
return value if isinstance(value, str) and value else None
-def _flag(value: Any) -> bool:
+def read_flag(value: Any) -> bool:
if isinstance(value, str):
return value.strip().lower() in ("true", "1")
return value is True or value == 1
-def _number(value: Any) -> float | None:
+def read_number(value: Any) -> float | None:
# The events fallback reads untyped properties, so a count or cost can arrive as any string.
if value is None or isinstance(value, bool):
return None
@@ -252,7 +272,7 @@ def _number(value: Any) -> float | None:
def _count(value: Any) -> int | None:
- number = _number(value)
+ number = read_number(value)
return None if number is None else int(number)
@@ -288,20 +308,20 @@ def _trace_event_row(values: Sequence[Any]) -> TraceEventRow:
event=str(raw["event"]),
timestamp=raw["timestamp"],
distinct_id=str(raw["distinct_id"]),
- session_id=_text(raw["session_id"]),
- parent_id=_text(raw["parent_id"]),
- span_id=_text(raw["span_id"]),
- generation_id=_text(raw["generation_id"]),
- span_name=_text(raw["span_name"]),
- trace_name=_text(raw["trace_name"]),
- model=_text(raw["model"]),
- provider=_text(raw["provider"]),
+ session_id=read_text(raw["session_id"]),
+ parent_id=read_text(raw["parent_id"]),
+ span_id=read_text(raw["span_id"]),
+ generation_id=read_text(raw["generation_id"]),
+ span_name=read_text(raw["span_name"]),
+ trace_name=read_text(raw["trace_name"]),
+ model=read_text(raw["model"]),
+ provider=read_text(raw["provider"]),
**tokens,
- total_cost_usd=_number(raw["total_cost_usd"]),
- latency=_number(raw["latency"]),
- is_error=_flag(raw["is_error"]),
+ total_cost_usd=read_number(raw["total_cost_usd"]),
+ latency=read_number(raw["latency"]),
+ is_error=read_flag(raw["is_error"]),
error_is_truthy=is_truthy_json(raw["error_raw"]),
- ingestion_source=_text(raw["ingestion_source"]),
+ ingestion_source=read_text(raw["ingestion_source"]),
)
@@ -309,27 +329,92 @@ def _read_person(team: Team, user: User | None, distinct_id: str) -> PersonRow:
name = "ai_trace_person"
with tags_context(product=Product.LLM_ANALYTICS):
tag_queries(name=name)
- response = execute_hogql_query(query=_person_query(distinct_id), team=team, user=user, query_type=name)
+ response = execute_hogql_query(
+ query=_person_query(distinct_id),
+ team=team,
+ user=user,
+ query_type=name,
+ context=HogQLContext(
+ team_id=team.pk, team=team, user=user, database=Database.create_for_posthog_tables(team)
+ ),
+ )
email, person_name = response.results[0] if response.results else (None, None)
- return PersonRow(distinct_id=distinct_id, email=_text(email), name=_text(person_name))
+ return PersonRow(distinct_id=distinct_id, email=read_text(email), name=read_text(person_name))
-def _read_rows(team: Team, user: User | None, trace_id: str, timestamp_hint: datetime | None) -> list[Sequence[Any]]:
- name = "ai_trace_rows"
+def _read_trace(
+ name: str,
+ build_query: Callable[[], ast.SelectQuery],
+ team: Team,
+ user: User | None,
+ trace_id: str,
+ timestamp_hint: datetime | None,
+ *,
+ widen_unhinted: bool,
+) -> list[Sequence[Any]]:
if timestamp_hint is not None:
- return _read(name, _trace_rows_query(), team, user, trace_id, fallback_window(timestamp_hint))
- results = _read(name, _trace_rows_query(), team, user, trace_id, None)
- if results:
+ return _read(name, build_query(), team, user, trace_id, fallback_window(timestamp_hint))
+ results = _read(name, build_query(), team, user, trace_id, None)
+ if results or not widen_unhinted:
return results
- logger.warning("ai_trace_unhinted_events_fallback", team_id=team.pk, trace_id_length=len(trace_id))
- window = FallbackWindow(
- start=UNHINTED_FALLBACK_START - FALLBACK_BEFORE_HINT, end=datetime.now(UTC) + FALLBACK_AFTER_HINT
- )
- return _read(name, _trace_rows_query(), team, user, trace_id, window)
+ logger.warning("ai_trace_unhinted_events_fallback", team_id=team.pk, trace_id_length=len(trace_id), read=name)
+ return _read(name, build_query(), team, user, trace_id, unhinted_window())
def load_trace(team: Team, user: User | None, trace_id: str, timestamp_hint: datetime | None) -> LoadedTrace:
- rows = tuple(_trace_event_row(values) for values in _read_rows(team, user, trace_id, timestamp_hint))
+ rows = tuple(
+ _trace_event_row(values)
+ for values in _read_trace(
+ "ai_trace_rows", _trace_rows_query, team, user, trace_id, timestamp_hint, widen_unhinted=True
+ )
+ )
distinct_id = trace_distinct_id(rows)
person = _read_person(team, user, distinct_id) if distinct_id else None
return LoadedTrace(rows=rows, person=person)
+
+
+def _canonical_uuid(value: str) -> str | None:
+ try:
+ return str(UUID(value))
+ except ValueError:
+ return None
+
+
+def _trace_node_row(values: Sequence[Any]) -> TraceNodeRow:
+ raw = dict(zip(_NODE_COLUMNS, values))
+ return TraceNodeRow(
+ uuid=str(raw["uuid"]),
+ event=str(raw["event"]),
+ timestamp=raw["timestamp"],
+ properties=merge_heavy_properties(raw["properties"], {column: raw[column] for column in _HEAVY_COLUMNS}),
+ )
+
+
+# Node ids come from links and can be stale or SDK ids, so node reads never widen to the unhinted events scan.
+def load_trace_node(
+ team: Team, user: User | None, trace_id: str, node_id: str, timestamp_hint: datetime | None
+) -> TraceNodeRow | None:
+ event_uuid = _canonical_uuid(node_id)
+ if event_uuid is None:
+ return None
+ results = _read_trace(
+ "ai_trace_node",
+ lambda: _node_query(_node_selection(event_uuid)),
+ team,
+ user,
+ trace_id,
+ timestamp_hint,
+ widen_unhinted=False,
+ )
+ return _trace_node_row(results[0]) if results else None
+
+
+def load_trace_root(team: Team, user: User | None, trace_id: str, timestamp_hint: datetime | None) -> TraceRootLookup:
+ def read(name: str, build_query: Callable[[], ast.SelectQuery]) -> list[Sequence[Any]]:
+ return _read_trace(name, build_query, team, user, trace_id, timestamp_hint, widen_unhinted=False)
+
+ results = read("ai_trace_root", lambda: _node_query(_equals("event", "$ai_trace")))
+ if results:
+ return TraceRootLookup(trace_event=_trace_node_row(results[0]), trace_found=True)
+ # Most traces have no $ai_trace event, so the existence check reads light columns instead of a step's payload.
+ return TraceRootLookup(trace_event=None, trace_found=bool(read("ai_trace_exists", _trace_exists_query)))
diff --git a/products/ai_observability/backend/presentation/views.py b/products/ai_observability/backend/presentation/views.py
index a815df813550..2d0dcd3f9129 100644
--- a/products/ai_observability/backend/presentation/views.py
+++ b/products/ai_observability/backend/presentation/views.py
@@ -1,9 +1,11 @@
+from collections.abc import Callable
from datetime import datetime
from typing import Any
from drf_spectacular.types import OpenApiTypes
from drf_spectacular.utils import OpenApiParameter, OpenApiResponse
from rest_framework import serializers, status, viewsets
+from rest_framework.decorators import action
from rest_framework.response import Response
from posthog.api.documentation import _FallbackSerializer
@@ -29,27 +31,42 @@ class TraceQuerySerializer(serializers.Serializer):
return value
+TRACE_ID_PARAMETER = OpenApiParameter(
+ "id",
+ OpenApiTypes.STR,
+ OpenApiParameter.PATH,
+ description="The trace id, sent as the unpadded base64url encoding of its UTF-8 bytes.",
+)
+NODE_ID_PARAMETER = OpenApiParameter(
+ "node_id",
+ OpenApiTypes.STR,
+ OpenApiParameter.PATH,
+ description="The node id, sent as the unpadded base64url encoding of its UTF-8 bytes. The root node's id is the trace id.",
+)
+THROTTLED_RESPONSE = OpenApiResponse(description="Too many queries are running for the project or organization.")
+
+
class TraceViewSet(TeamAndOrgViewSetMixin, viewsets.ViewSet):
scope_object = "llm_analytics"
+ scope_object_read_actions = ["retrieve", "node"]
# Traces are project-wide data, so a grant on a single llm_analytics object must not open them.
requires_resource_level_access = True
serializer_class = _FallbackSerializer
+ def _read[T](self, request: ValidatedRequest, read: Callable[[User | None, datetime | None], T]) -> T:
+ tag_queries(feature=Feature.QUERY)
+ user = request.user if isinstance(request.user, User) else None
+ with query_concurrency_slots(self.team):
+ return read(user, request.validated_query_data.get("timestamp_hint"))
+
@validated_request(
query_serializer=TraceQuerySerializer,
- parameters=[
- OpenApiParameter(
- "id",
- OpenApiTypes.STR,
- OpenApiParameter.PATH,
- description="The trace id, sent as the unpadded base64url encoding of its UTF-8 bytes.",
- )
- ],
+ parameters=[TRACE_ID_PARAMETER],
responses={
200: OpenApiResponse(response=contracts.Trace),
400: OpenApiResponse(description="The timestamp hint or the encoded trace id is malformed."),
404: OpenApiResponse(description="No trace with this id in the project."),
- 429: OpenApiResponse(description="Too many queries are running for the project or organization."),
+ 429: THROTTLED_RESPONSE,
},
operation_id="ai_observability_traces_retrieve",
)
@@ -59,11 +76,35 @@ class TraceViewSet(TeamAndOrgViewSetMixin, viewsets.ViewSet):
trace_id = decode_trace_id_segment(pk)
except MalformedTraceIdSegmentError:
return Response({"detail": "Malformed encoded trace id."}, status=status.HTTP_400_BAD_REQUEST)
- tag_queries(feature=Feature.QUERY)
- user = request.user if isinstance(request.user, User) else None
try:
- with query_concurrency_slots(self.team):
- trace = api.get_trace(self.team, user, trace_id, request.validated_query_data.get("timestamp_hint"))
+ trace = self._read(request, lambda user, hint: api.get_trace(self.team, user, trace_id, hint))
except api.TraceNotFoundError:
return Response({"detail": "Trace not found."}, status=status.HTTP_404_NOT_FOUND)
return Response(trace.model_dump(mode="json", by_alias=True))
+
+ @validated_request(
+ query_serializer=TraceQuerySerializer,
+ parameters=[TRACE_ID_PARAMETER, NODE_ID_PARAMETER],
+ responses={
+ 200: OpenApiResponse(response=contracts.TraceNodeDetail),
+ 400: OpenApiResponse(description="The timestamp hint or an encoded id is malformed."),
+ 404: OpenApiResponse(description="No node with this id in the trace."),
+ 429: THROTTLED_RESPONSE,
+ },
+ operation_id="ai_observability_traces_nodes_retrieve",
+ )
+ @action(detail=True, methods=["GET"], url_path=r"nodes/(?P<node_id>[A-Za-z0-9_-]+)")
+ def node(self, request: ValidatedRequest, pk: str, node_id: str, **kwargs: Any) -> Response:
+ """One node of a trace: its event properties as ingested, the keys that hold its input, output and tools, its error and its metadata."""
+ try:
+ trace_id = decode_trace_id_segment(pk)
+ decoded_node_id = decode_trace_id_segment(node_id)
+ except MalformedTraceIdSegmentError:
+ return Response({"detail": "Malformed encoded id."}, status=status.HTTP_400_BAD_REQUEST)
+ try:
+ node = self._read(
+ request, lambda user, hint: api.get_trace_node(self.team, user, trace_id, decoded_node_id, hint)
+ )
+ except api.TraceNodeNotFoundError:
+ return Response({"detail": "Node not found."}, status=status.HTTP_404_NOT_FOUND)
+ return Response(node.model_dump(mode="json", by_alias=True))
diff --git a/products/ai_observability/backend/tests/logic/traces/test_node.py b/products/ai_observability/backend/tests/logic/traces/test_node.py
new file mode 100644
index 000000000000..1bb770120bea
--- /dev/null
+++ b/products/ai_observability/backend/tests/logic/traces/test_node.py
@@ -0,0 +1,124 @@
+import json
+from datetime import UTC, datetime
+from typing import Any
+
+from parameterized import parameterized
+
+from products.ai_observability.backend.logic.traces.node import FAILED_STEP_MESSAGE, IOKeys, NodeEvent, NodeMetadata
+from products.ai_observability.backend.logic.traces.trace_queries import TraceNodeRow
+
+T0 = datetime(2026, 9, 1, 10, 0, tzinfo=UTC)
+MESSAGES = [{"role": "user", "content": "Why did my invoice go up?"}]
+NO_METADATA = NodeMetadata(provider=None, temperature=None, session_id=None, prompt_name=None, prompt_version=None)
+
+
+def node_event(event: str, properties: dict[str, Any]) -> NodeEvent:
+ return NodeEvent(row=TraceNodeRow(uuid="node-1", event=event, timestamp=T0, properties=properties))
+
+
+ [
+ (
+ "generation",
+ "$ai_generation",
+ {"$ai_input": MESSAGES, "$ai_output_choices": MESSAGES, "$ai_tools": []},
+ IOKeys(input="$ai_input", output="$ai_output_choices", tools="$ai_tools"),
+ ),
+ (
+ "generation with a plain output",
+ "$ai_generation",
+ {"$ai_input": MESSAGES, "$ai_output": "Two seats were added."},
+ IOKeys(input="$ai_input", output="$ai_output", tools=None),
+ ),
+ (
+ "generation whose output choices are null",
+ "$ai_generation",
+ {"$ai_output_choices": None, "$ai_output": "Two seats were added."},
+ IOKeys(input=None, output="$ai_output", tools=None),
+ ),
+ ("generation with nothing captured", "$ai_generation", {}, IOKeys(input=None, output=None, tools=None)),
+ (
+ "embedding never has an output",
+ "$ai_embedding",
+ {"$ai_input": "invoice", "$ai_output": [0.1, 0.2]},
+ IOKeys(input="$ai_input", output=None, tools=None),
+ ),
+ (
+ "span state",
+ "$ai_span",
+ {"$ai_input_state": {"question": "x"}, "$ai_output_state": {"answer": "y"}},
+ IOKeys(input="$ai_input_state", output="$ai_output_state", tools=None),
+ ),
+ (
+ "OTel span with messages before its state",
+ "$ai_span",
+ {"$ai_input": MESSAGES, "$ai_output_choices": MESSAGES, "$ai_input_state": {"question": "x"}},
+ IOKeys(input="$ai_input", output="$ai_output_choices", tools=None),
+ ),
+ ("span never has tools", "$ai_span", {"$ai_tools": []}, IOKeys(input=None, output=None, tools=None)),
+ (
+ "trace event state",
+ "$ai_trace",
+ {"$ai_input_state": {"question": "x"}, "$ai_output_state": {"answer": "y"}},
+ IOKeys(input="$ai_input_state", output="$ai_output_state", tools=None),
+ ),
+ (
+ "trace event with messages and state prefers the state",
+ "$ai_trace",
+ {
+ "$ai_input": MESSAGES,
+ "$ai_input_state": {"question": "x"},
+ "$ai_output_choices": MESSAGES,
+ "$ai_output_state": {"answer": "y"},
+ },
+ IOKeys(input="$ai_input_state", output="$ai_output_state", tools=None),
+ ),
+ ]
+)
+def test_io_keys(_name: str, event: str, properties: dict[str, Any], expected: IOKeys) -> None:
+ assert node_event(event, properties).io_keys == expected
+
+
+ [
+ ("text error", {"$ai_error": "Rate limited"}, "Rate limited"),
+ ("structured error", {"$ai_error": {"message": "boom"}}, json.dumps({"message": "boom"}, indent=2)),
+ ("flag without a message", {"$ai_is_error": True}, FAILED_STEP_MESSAGE),
+ ("SDK-serialized flag with an empty message", {"$ai_is_error": "true", "$ai_error": ""}, FAILED_STEP_MESSAGE),
+ ("empty message without a flag", {"$ai_error": ""}, None),
+ ("flag off", {"$ai_is_error": False}, None),
+ ]
+)
+def test_error(_name: str, properties: dict[str, Any], expected: str | None) -> None:
+ assert node_event("$ai_span", properties).error == expected
+
+
+ [
+ (
+ "values as sent",
+ {
+ "$ai_provider": "openai",
+ "$ai_temperature": 0.2,
+ "$ai_session_id": "sess-1",
+ "$ai_prompt_name": "billing-answer",
+ "$ai_prompt_version": 6,
+ },
+ NodeMetadata(
+ provider="openai",
+ temperature=0.2,
+ session_id="sess-1",
+ prompt_name="billing-answer",
+ prompt_version=6.0,
+ ),
+ ),
+ (
+ "numbers sent as text and empty text",
+ {"$ai_temperature": "0.2", "$ai_session_id": "", "$ai_prompt_version": "6"},
+ NodeMetadata(provider=None, temperature=0.2, session_id=None, prompt_name=None, prompt_version=6.0),
+ ),
+ ("values that are not numbers", {"$ai_temperature": "warm", "$ai_prompt_version": float("inf")}, NO_METADATA),
+ ]
+)
+def test_metadata(_name: str, properties: dict[str, Any], expected: NodeMetadata) -> None:
+ assert node_event("$ai_generation", properties).metadata == expected
diff --git a/products/ai_observability/backend/tests/logic/traces/test_trace.py b/products/ai_observability/backend/tests/logic/traces/test_trace.py
index 1e80bb260171..d84faca6c538 100644
--- a/products/ai_observability/backend/tests/logic/traces/test_trace.py
+++ b/products/ai_observability/backend/tests/logic/traces/test_trace.py
@@ -89,3 +89,47 @@ def test_thread_node_ids_hold_the_user_visible_generation() -> None:
)
def test_person_label(_name: str, person: PersonRow | None, expected: str | None) -> None:
assert trace({}, person=person).person_label == expected
+
+
+ [
+ (
+ "a trace event makes the root the default",
+ [{"event": "$ai_trace"}, {"event": "$ai_generation"}],
+ "trace-1",
+ ),
+ (
+ "otherwise the first top-level generation",
+ [
+ {"event": "$ai_span", "timestamp": T0},
+ {"event": "$ai_generation", "timestamp": T0 + timedelta(seconds=1)},
+ {"event": "$ai_generation", "timestamp": T0 + timedelta(seconds=2)},
+ ],
+ "e1",
+ ),
+ (
+ "otherwise the first top-level node",
+ [
+ {"event": "$ai_span", "span_id": "s", "timestamp": T0},
+ {"event": "$ai_generation", "parent_id": "s", "timestamp": T0 + timedelta(seconds=1)},
+ ],
+ "e0",
+ ),
+ ("a trace without nodes falls back to the root", [{"event": "$ai_feedback"}], "trace-1"),
+ ]
+)
+def test_default_node_id(_name: str, rows: list[dict[str, Any]], expected: str) -> None:
+ assert trace(*rows).default_node_id == expected
+
+
+def test_node_ids_by_alias_map_sdk_ids_of_tree_nodes_to_their_uuids() -> None:
+ aliases = trace(
+ {"event": "$ai_span", "span_id": "span-a"},
+ {"event": "$ai_generation", "generation_id": "gen-a", "parent_id": "span-a"},
+ {"event": "$ai_generation", "generation_id": "gen-a"},
+ {"event": "$ai_span", "span_id": "e3"},
+ {"event": "$ai_feedback", "span_id": "feedback-a"},
+ {"event": "$ai_trace", "span_id": "trace-a"},
+ ).node_ids_by_alias
+
+ assert aliases == {"span-a": "e0", "gen-a": "e1"}
diff --git a/products/ai_observability/backend/tests/logic/traces/test_trace_queries.py b/products/ai_observability/backend/tests/logic/traces/test_trace_queries.py
index 77c79623499c..aa133f67436a 100644
--- a/products/ai_observability/backend/tests/logic/traces/test_trace_queries.py
+++ b/products/ai_observability/backend/tests/logic/traces/test_trace_queries.py
@@ -6,11 +6,18 @@ from posthog.test.base import BaseTest, ClickhouseTestMixin, _create_person
from parameterized import parameterized
from posthog.clickhouse.client import sync_execute
+from posthog.models import Team
from posthog.models.ai_events.sql import AI_EVENTS_MV_SQL
from posthog.models.ai_events.test_util import bulk_create_ai_events
from posthog.models.event.util import bulk_create_events
-from products.ai_observability.backend.logic.traces.trace_queries import is_truthy_json, load_trace
+from products.ai_observability.backend.logic.traces.trace_queries import (
+ TraceRootLookup,
+ is_truthy_json,
+ load_trace,
+ load_trace_node,
+ load_trace_root,
+)
T0 = datetime(2026, 9, 1, 10, 0, tzinfo=UTC)
INGESTED_SOURCE = """(
@@ -49,7 +56,9 @@ def test_is_truthy_json(_name: str, raw: str, expected: bool) -> None:
assert is_truthy_json(raw) is expected
-class TestLoadTrace(ClickhouseTestMixin, BaseTest):
+class TraceEventsMixin:
+ team: Team
+
def _event(
self,
uuid: str,
@@ -68,12 +77,12 @@ class TestLoadTrace(ClickhouseTestMixin, BaseTest):
"properties": {"$ai_trace_id": trace_id, **(properties or {})},
}
- def _ingest(self, uuid: str, properties: dict[str, object]) -> None:
+ def _ingest(self, uuid: str, properties: dict[str, object], *, event: str = "$ai_span") -> None:
# Goes through the materialized view expressions, because bulk_create_ai_events types columns differently.
mv_select = AI_EVENTS_MV_SQL(kafka_table=INGESTED_SOURCE).split("AS SELECT", 1)[1]
params = {
"uuid": uuid,
- "event": "$ai_span",
+ "event": event,
"timestamp": T0.strftime("%Y-%m-%d %H:%M:%S.%f"),
"team_id": self.team.pk,
"properties": json.dumps({"$ai_trace_id": "trace-1", **properties}),
@@ -85,6 +94,8 @@ class TestLoadTrace(ClickhouseTestMixin, BaseTest):
flush=False,
)
+
+class TestLoadTrace(TraceEventsMixin, ClickhouseTestMixin, BaseTest):
def test_reads_every_event_once_and_only_this_trace(self) -> None:
uuids = [f"00000000-0000-0000-0000-{index:012d}" for index in range(150)]
failed = self._event(uuids[0], properties={"$ai_latency": 1.0, "$ai_error": {"message": "boom"}})
@@ -110,6 +121,92 @@ class TestLoadTrace(ClickhouseTestMixin, BaseTest):
("00000000-0000-0000-0000-000000000002", True, 3),
]
+ def test_person_comes_from_the_trace_event_distinct_id(self) -> None:
+ _create_person(distinct_ids=["user-1"], team=self.team, properties={"email": "[email protected]"})
+ _create_person(distinct_ids=["user-2"], team=self.team, properties={"email": "[email protected]"})
+ earlier_span = {**self._event("00000000-0000-0000-0000-000000000002"), "distinct_id": "user-2"}
+ trace_event = self._event(
+ "00000000-0000-0000-0000-000000000001", event="$ai_trace", timestamp=T0 + timedelta(seconds=1)
+ )
+ bulk_create_ai_events([earlier_span, trace_event])
+
+ person = load_trace(self.team, None, "trace-1", None).person
+
+ assert person is not None and (person.distinct_id, person.email) == ("user-1", "[email protected]")
+
+
+NODE = "00000000-0000-0000-0000-000000000001"
+TRACE_EVENT = "00000000-0000-0000-0000-000000000002"
+QUESTION = [{"role": "user", "content": "Why did my invoice go up?"}]
+ANSWER = [{"role": "assistant", "content": "Two seats were added."}]
+
+
+class TestLoadTraceNode(TraceEventsMixin, ClickhouseTestMixin, BaseTest):
+ def test_merges_the_heavy_columns_back_into_the_properties(self) -> None:
+ self._ingest(
+ NODE,
+ {"$ai_input": QUESTION, "$ai_output_choices": ANSWER, "$ai_model": "gpt-4.1-mini"},
+ event="$ai_generation",
+ )
+
+ row = load_trace_node(self.team, None, "trace-1", NODE, None)
+
+ assert row is not None
+ assert (row.uuid, row.event) == (NODE, "$ai_generation")
+ assert (row.properties["$ai_input"], row.properties["$ai_output_choices"]) == (QUESTION, ANSWER)
+ assert row.properties["$ai_model"] == "gpt-4.1-mini"
+
+ @parameterized.expand(
+ [
+ ("an annotation", "$ai_feedback", "trace-1", NODE),
+ ("a node of another trace", "$ai_span", "other", NODE),
+ ("an id that is not an event uuid", "$ai_span", "trace-1", "gen_8f2c"),
+ ]
+ )
+ def test_finds_nothing_for(self, _name: str, event: str, trace_id: str, requested: str) -> None:
+ bulk_create_ai_events([self._event(NODE, trace_id=trace_id, event=event)])
+
+ assert load_trace_node(self.team, None, "trace-1", requested, None) is None
+
+ def test_root_reads_the_trace_event_even_when_other_events_come_first(self) -> None:
+ bulk_create_ai_events(
+ [
+ self._event(NODE, timestamp=T0),
+ self._event(
+ TRACE_EVENT,
+ event="$ai_trace",
+ timestamp=T0 + timedelta(seconds=5),
+ properties={"$ai_input_state": {"question": "x"}},
+ ),
+ ]
+ )
+
+ root = load_trace_root(self.team, None, "trace-1", None)
+
+ assert root.trace_found and root.trace_event is not None
+ assert (root.trace_event.uuid, root.trace_event.properties["$ai_input_state"]) == (
+ TRACE_EVENT,
+ {"question": "x"},
+ )
+
+ @parameterized.expand([("a trace without a trace event", True), ("an unknown trace", False)])
+ def test_root_without_a_trace_event(self, _name: str, has_events: bool) -> None:
+ if has_events:
+ bulk_create_ai_events([self._event(NODE)])
+
+ assert load_trace_root(self.team, None, "trace-1", None) == TraceRootLookup(
+ trace_event=None, trace_found=has_events
+ )
+
+ def test_node_id_matches_however_the_uuid_is_written(self) -> None:
+ bulk_create_ai_events([self._event(NODE)])
+
+ row = load_trace_node(self.team, None, "trace-1", NODE.upper().replace("-", ""), None)
+
+ assert row is not None and row.uuid == NODE
+
+
+class TestEventsFallback(TraceEventsMixin, ClickhouseTestMixin, BaseTest):
@parameterized.expand([("with a hint", T0), ("without a hint", None)])
def test_falls_back_to_events(self, _name: str, timestamp_hint: datetime | None) -> None:
old_span: dict[str, object] = {"$ai_span_name": "old", "$ai_error": {"message": "boom"}}
@@ -140,15 +237,22 @@ class TestLoadTrace(ClickhouseTestMixin, BaseTest):
assert load_trace(self.team, None, "trace-1", None).rows == ()
- def test_person_comes_from_the_trace_event_distinct_id(self) -> None:
- _create_person(distinct_ids=["user-1"], team=self.team, properties={"email": "[email protected]"})
- _create_person(distinct_ids=["user-2"], team=self.team, properties={"email": "[email protected]"})
- earlier_span = {**self._event("00000000-0000-0000-0000-000000000002"), "distinct_id": "user-2"}
- trace_event = self._event(
- "00000000-0000-0000-0000-000000000001", event="$ai_trace", timestamp=T0 + timedelta(seconds=1)
+ def test_node_and_root_fall_back_to_events(self) -> None:
+ bulk_create_events(
+ [
+ self._event(NODE, properties={"$ai_span_name": "old"}),
+ self._event(TRACE_EVENT, event="$ai_trace", timestamp=T0 + timedelta(seconds=1)),
+ ]
)
- bulk_create_ai_events([earlier_span, trace_event])
- person = load_trace(self.team, None, "trace-1", None).person
+ row = load_trace_node(self.team, None, "trace-1", NODE, T0)
+ root = load_trace_root(self.team, None, "trace-1", T0)
- assert person is not None and (person.distinct_id, person.email) == ("user-1", "[email protected]")
+ assert row is not None and row.properties["$ai_span_name"] == "old"
+ assert root.trace_event is not None and root.trace_event.uuid == TRACE_EVENT
+
+ def test_node_and_root_without_a_hint_never_scan_events(self) -> None:
+ bulk_create_events([self._event(NODE), self._event(TRACE_EVENT, event="$ai_trace")])
+
+ assert load_trace_node(self.team, None, "trace-1", NODE, None) is None
+ assert load_trace_root(self.team, None, "trace-1", None) == TraceRootLookup(trace_event=None, trace_found=False)
diff --git a/products/ai_observability/backend/tests/test_contracts.py b/products/ai_observability/backend/tests/test_contracts.py
index db1989c3efbb..f7a8499904ef 100644
--- a/products/ai_observability/backend/tests/test_contracts.py
+++ b/products/ai_observability/backend/tests/test_contracts.py
@@ -29,6 +29,8 @@ def test_trace_dumps_declared_fields_in_camel_case_and_every_field_is_required_i
timeline=[],
total_ms=0.0,
thread_node_ids=[],
+ default_node_id="trace-1",
+ node_ids_by_alias={},
)
dumped = trace.model_dump(mode="json", by_alias=True)
@@ -46,6 +48,8 @@ def test_trace_dumps_declared_fields_in_camel_case_and_every_field_is_required_i
"timeline",
"totalMs",
"threadNodeIds",
+ "defaultNodeId",
+ "nodeIdsByAlias",
}
assert dumped["totals"]["cacheWriteTokens"] is None
assert dumped["person"] == {"distinctId": "user-1", "label": "[email protected]"}
diff --git a/products/ai_observability/backend/tests/test_trace_views.py b/products/ai_observability/backend/tests/test_trace_views.py
index 12e6be4d726a..0a5bf3c091a7 100644
--- a/products/ai_observability/backend/tests/test_trace_views.py
+++ b/products/ai_observability/backend/tests/test_trace_views.py
@@ -13,10 +13,17 @@ from posthog.models.ai_events.test_util import bulk_create_ai_events
from posthog.models.organization import OrganizationMembership
from posthog.models.user import User
+from products.access_control.backend.facade.contracts import PropertyAccessLevel
from products.access_control.backend.models.access_control import AccessControl
+from products.access_control.backend.models.property_access_control import PropertyAccessControl
from products.ai_observability.backend.models.review_queues import ReviewQueue
+from products.event_definitions.backend.models.property_definition import PropertyDefinition
T0 = datetime(2026, 9, 1, 10, 0, tzinfo=UTC)
+GENERATION = "00000000-0000-0000-0000-000000000001"
+TRACE_EVENT = "00000000-0000-0000-0000-000000000002"
+QUESTION = [{"role": "user", "content": "Why did my invoice go up?"}]
+ANSWER = [{"role": "assistant", "content": "Two seats were added."}]
def _create_trace(team: Team, trace_id: str = "trace-1") -> None:
@@ -34,6 +41,45 @@ def _create_trace(team: Team, trace_id: str = "trace-1") -> None:
)
+def _create_node_trace(
+ team: Team,
+ trace_id: str = "trace-1",
+ *,
+ with_trace_event: bool = True,
+ extra_properties: dict[str, object] | None = None,
+) -> None:
+ events: list[dict[str, object]] = [
+ {
+ "event": "$ai_generation",
+ "event_uuid": GENERATION,
+ "distinct_id": "user-1",
+ "team": team,
+ "timestamp": T0,
+ "properties": {
+ "$ai_trace_id": trace_id,
+ "$ai_parent_id": trace_id,
+ "$ai_input": QUESTION,
+ "$ai_output_choices": ANSWER,
+ "$ai_tools": [{"name": "lookup_invoice"}],
+ "$ai_provider": "openai",
+ **(extra_properties or {}),
+ },
+ }
+ ]
+ if with_trace_event:
+ events.append(
+ {
+ "event": "$ai_trace",
+ "event_uuid": TRACE_EVENT,
+ "distinct_id": "user-1",
+ "team": team,
+ "timestamp": T0,
+ "properties": {"$ai_trace_id": trace_id, "$ai_input_state": {"question": "Why?"}},
+ }
+ )
+ bulk_create_ai_events(events)
+
+
def _encode(trace_id: str) -> str:
return base64.urlsafe_b64encode(trace_id.encode()).decode().rstrip("=")
@@ -54,6 +100,8 @@ class TestTraceViewSet(ClickhouseTestMixin, APIBaseTest):
assert body["tree"][0]["children"][0]["id"] == "00000000-0000-0000-0000-000000000001"
assert body["totals"]["inputTokens"] == 3
assert body["threadNodeIds"] == ["00000000-0000-0000-0000-000000000001"]
+ assert body["defaultNodeId"] == "00000000-0000-0000-0000-000000000001"
+ assert body["nodeIdsByAlias"] == {}
@parameterized.expand([("unknown trace", False), ("another team's trace", True)])
def test_not_found(self, _name: str, other_team_owns_it: bool) -> None:
@@ -75,9 +123,18 @@ class TestTraceViewSet(ClickhouseTestMixin, APIBaseTest):
assert self.client.get(self._url(segment), query).status_code == 400
- @parameterized.expand([("browser session", False, "app_per_org"), ("personal api key", True, "api_per_team")])
+ @parameterized.expand(
+ [
+ (f"{reader} {read}", with_api_key, exhausted_limit, suffix)
+ for reader, with_api_key, exhausted_limit in [
+ ("browser session", False, "app_per_org"),
+ ("personal api key", True, "api_per_team"),
+ ]
+ for read, suffix in [("trace", ""), ("node", f"nodes/{_encode('trace-1')}/")]
+ ]
+ )
def test_throttles_when_the_query_concurrency_limit_is_exhausted(
- self, _name: str, with_api_key: bool, exhausted_limit: str
+ self, _name: str, with_api_key: bool, exhausted_limit: str, suffix: str
) -> None:
_create_trace(self.team, "trace-1")
headers = {}
@@ -94,11 +151,90 @@ class TestTraceViewSet(ClickhouseTestMixin, APIBaseTest):
patch("posthog.clickhouse.client.limit.TEST", False),
patch.object(RateLimit, "use", autospec=True, side_effect=use),
):
- response = self.client.get(self._url(_encode("trace-1")), headers=headers)
+ response = self.client.get(self._url(_encode("trace-1")) + suffix, headers=headers)
assert response.status_code == 429
+class TestTraceNodeView(ClickhouseTestMixin, APIBaseTest):
+ def _url(self, trace_id: str, node_segment: str) -> str:
+ return f"/api/projects/{self.team.id}/ai_observability/traces/{_encode(trace_id)}/nodes/{node_segment}/"
+
+ def test_returns_the_properties_as_ingested_and_names_the_io_keys(self) -> None:
+ _create_node_trace(self.team)
+
+ response = self.client.get(self._url("trace-1", _encode(GENERATION)))
+
+ assert response.status_code == 200, response.content
+ body = response.json()
+ assert (body["id"], body["kind"], body["error"]) == (GENERATION, "generation", None)
+ assert body["metadata"]["provider"] == "openai"
+ assert body["event"]["ioKeys"] == {"input": "$ai_input", "output": "$ai_output_choices", "tools": "$ai_tools"}
+ assert body["event"]["properties"]["$ai_input"] == QUESTION
+
+ @parameterized.expand([("plain id", "trace-1"), ("id with a slash", "a/b")])
+ def test_root_node_is_the_trace_event(self, _name: str, trace_id: str) -> None:
+ _create_node_trace(self.team, trace_id)
+
+ body = self.client.get(self._url(trace_id, _encode(trace_id))).json()
+
+ assert (body["id"], body["kind"]) == (trace_id, "trace")
+ assert body["event"]["ioKeys"]["input"] == "$ai_input_state"
+
+ def test_root_without_a_trace_event_has_no_event(self) -> None:
+ _create_node_trace(self.team, with_trace_event=False)
+
+ response = self.client.get(self._url("trace-1", _encode("trace-1")))
+
+ assert response.status_code == 200
+ assert response.json()["event"] is None
+
+ @parameterized.expand(
+ [
+ ("unknown node", "trace-1", "00000000-0000-0000-0000-00000000ffff"),
+ ("root of an unknown trace", "trace-2", "trace-2"),
+ ("node of another trace", "trace-2", GENERATION),
+ ]
+ )
+ def test_node_not_found(self, _name: str, trace_id: str, node_id: str) -> None:
+ _create_node_trace(self.team)
+
+ assert self.client.get(self._url(trace_id, _encode(node_id))).status_code == 404
+
+ @parameterized.expand(
+ [
+ ("malformed trace segment", "A", _encode(GENERATION)),
+ ("malformed node segment", _encode("trace-1"), "A"),
+ ]
+ )
+ def test_rejects_a_malformed_segment(self, _name: str, trace_segment: str, node_segment: str) -> None:
+ _create_node_trace(self.team)
+
+ url = f"/api/projects/{self.team.id}/ai_observability/traces/{trace_segment}/nodes/{node_segment}/"
+ assert self.client.get(url).status_code == 400
+
+ def test_masks_properties_the_viewer_may_not_read(self) -> None:
+ self.organization.available_product_features = [
+ {"key": AvailableFeature.PROPERTY_ACCESS_CONTROL, "name": AvailableFeature.PROPERTY_ACCESS_CONTROL}
+ ]
+ self.organization.save()
+ definition = PropertyDefinition.objects.create(
+ team=self.team, name="secret_plan", property_type="String", type=PropertyDefinition.Type.EVENT
+ )
+ PropertyAccessControl.objects.create(
+ team=self.team,
+ property_definition=definition,
+ organization_member=self.organization_membership,
+ access_level=PropertyAccessLevel.NONE.value,
+ )
+ _create_node_trace(self.team, extra_properties={"secret_plan": "enterprise"})
+
+ properties = self.client.get(self._url("trace-1", _encode(GENERATION))).json()["event"]["properties"]
+
+ assert "secret_plan" not in properties
+ assert properties["$ai_provider"] == "openai"
+
+
class TestTraceViewSetResourceLevelAccess(ClickhouseTestMixin, APIBaseTest):
def test_a_grant_on_one_object_does_not_open_traces(self) -> None:
self.organization.available_product_features = [
diff --git a/products/ai_observability/frontend/generated/api.schemas.ts b/products/ai_observability/frontend/generated/api.schemas.ts
index e5c598199f66..bf167846c394 100644
--- a/products/ai_observability/frontend/generated/api.schemas.ts
+++ b/products/ai_observability/frontend/generated/api.schemas.ts
@@ -1283,6 +1283,8 @@ export interface OfflineHistoryPageApi {
results: OfflineHistoryPointApi[]
}
+export type TraceApiNodeIdsByAlias = { [key: string]: string }
+
export interface TracePersonApi {
distinctId: string
label: string
@@ -1339,6 +1341,45 @@ export interface TraceApi {
timeline: TraceTimelineRowApi[]
totalMs: number
threadNodeIds: string[]
+ defaultNodeId: string
+ nodeIdsByAlias: TraceApiNodeIdsByAlias
+}
+
+export interface TraceNodeMetadataApi {
+ provider: string | null
+ temperature: number | null
+ sessionId: string | null
+ promptName: string | null
+ promptVersion: number | null
+}
+
+export interface TraceNodeIOKeysApi {
+ input: string | null
+ output: string | null
+ tools: string | null
+}
+
+/**
+ * The event's properties as ingested, including its input and output values.
+ */
+export type TraceNodeEventApiProperties = { [key: string]: unknown }
+
+export interface TraceNodeEventApi {
+ name: string
+ uuid: string
+ timestamp: string
+ /** The event's properties as ingested, including its input and output values. */
+ properties: TraceNodeEventApiProperties
+ /** Which keys of `properties` hold the node's input, output and tools, or null when it has none. */
+ ioKeys: TraceNodeIOKeysApi
+}
+
+export interface TraceNodeDetailApi {
+ id: string
+ kind: TraceNodeKindEnumApi
+ error: string | null
+ metadata: TraceNodeMetadataApi
+ event: TraceNodeEventApi | null
}
export type DatasetJSONValueApi = { [key: string]: unknown } | unknown[] | string | number | boolean
@@ -5068,6 +5109,13 @@ export type AiObservabilityTracesRetrieveParams = {
timestamp_hint?: string
}
+export type AiObservabilityTracesNodesRetrieveParams = {
+ /**
+ * When the trace happened, as carried by links into it. Lets a trace older than the AI events retention load from the shared events table.
+ */
+ timestamp_hint?: string
+}
+
export type DatasetItemsListParams = {
/**
* Return archived items instead of active items.
diff --git a/products/ai_observability/frontend/generated/api.ts b/products/ai_observability/frontend/generated/api.ts
index 2c9637cbd771..3d452f40baf0 100644
--- a/products/ai_observability/frontend/generated/api.ts
+++ b/products/ai_observability/frontend/generated/api.ts
@@ -16,6 +16,7 @@ import type {
AiObservabilityOfflineExperimentsResultCellsRetrieveParams,
AiObservabilityOfflineExperimentsScorerSummariesListParams,
AiObservabilityOfflineScorersHistoryListParams,
+ AiObservabilityTracesNodesRetrieveParams,
AiObservabilityTracesRetrieveParams,
BatchCheckRequestApi,
BatchCheckResponseApi,
@@ -142,6 +143,7 @@ import type {
TextReprRequestApi,
TextReprResponseApi,
TraceApi,
+ TraceNodeDetailApi,
TraceReviewApi,
TraceReviewCreateApi,
TranslateRequestApi,
@@ -673,6 +675,43 @@ export const aiObservabilityTracesRetrieve = async (
})
}
+export const getAiObservabilityTracesNodesRetrieveUrl = (
+ projectId: string,
+ id: string,
+ nodeId: string,
+ params?: AiObservabilityTracesNodesRetrieveParams
+) => {
+ const normalizedParams = new URLSearchParams()
+
+ Object.entries(params || {}).forEach(([key, value]) => {
+ if (value !== undefined) {
+ normalizedParams.append(key, value === null ? 'null' : String(value))
+ }
+ })
+
+ const stringifiedParams = normalizedParams.toString()
+
+ return stringifiedParams.length > 0
+ ? `/api/projects/${projectId}/ai_observability/traces/${id}/nodes/${nodeId}/?${stringifiedParams}`
+ : `/api/projects/${projectId}/ai_observability/traces/${id}/nodes/${nodeId}/`
+}
+
+/**
+ * One node of a trace: its event properties as ingested, the keys that hold its input, output and tools, its error and its metadata.
+ */
+export const aiObservabilityTracesNodesRetrieve = async (
+ projectId: string,
+ id: string,
+ nodeId: string,
+ params?: AiObservabilityTracesNodesRetrieveParams,
+ options?: RequestInit
+): Promise<TraceNodeDetailApi> => {
+ return apiMutator<TraceNodeDetailApi>(getAiObservabilityTracesNodesRetrieveUrl(projectId, id, nodeId, params), {
+ ...options,
+ method: 'GET',
+ })
+}
+
export const getDatasetItemsListUrl = (projectId: string, params: DatasetItemsListParams) => {
const normalizedParams = new URLSearchParams()
diff --git a/products/ai_observability/frontend/redesign/trace/TraceScene.tsx b/products/ai_observability/frontend/redesign/trace/TraceScene.tsx
index bb721a04403c..8f7b25e1c86e 100644
--- a/products/ai_observability/frontend/redesign/trace/TraceScene.tsx
+++ b/products/ai_observability/frontend/redesign/trace/TraceScene.tsx
@@ -25,6 +25,7 @@ interface ReadyActions {
selectAndShowSpans: (id: string) => void
setDetailTab: (tab: NodeDetailTab) => void
viewInThread: () => void
+ prefetchNode: (id: string) => void
}
function toReadyProps(values: ReadyValues, actions: ReadyActions): TraceViewReadyProps | null {
@@ -39,6 +40,7 @@ function toReadyProps(values: ReadyValues, actions: ReadyActions): TraceViewRead
tree: values.tree,
selectedNodeId: values.selectedNodeId,
onSelectNode: actions.selectNode,
+ onPrefetchNode: actions.prefetchNode,
onSelectFromView: actions.selectAndShowSpans,
detail: values.detailData
? {
@@ -54,8 +56,8 @@ function toReadyProps(values: ReadyValues, actions: ReadyActions): TraceViewRead
}
export function TraceScene(): JSX.Element {
- const { traceId, query, dateRange } = useValues(aiObservabilityTraceLogic)
- const logic = traceViewAdapterLogic({ traceId, query, timestampHint: dateRange?.dateFrom ?? null })
+ const { traceId, dateRange } = useValues(aiObservabilityTraceLogic)
+ const logic = traceViewAdapterLogic({ traceId, timestampHint: dateRange?.dateFrom ?? null })
// Every kea value getter is a hook, so read them all on every render, whatever the status.
const {
status,
diff --git a/products/ai_observability/frontend/redesign/trace/adapter/eventIO.test.ts b/products/ai_observability/frontend/redesign/trace/adapter/eventIO.test.ts
deleted file mode 100644
index b5af1ef69dd0..000000000000
--- a/products/ai_observability/frontend/redesign/trace/adapter/eventIO.test.ts
+++ /dev/null
@@ -1,140 +0,0 @@
-import { LLMTraceEvent } from '~/queries/schema/schema-general'
-
-import { AIData } from '../../../aiObservabilityAIDataLogic'
-import { heavyDataLookup, resolveEventIO } from './eventIO'
-import { makeEvent } from './testFixtures'
-
-interface ResolveEventIOCase {
- name: string
- event: LLMTraceEvent
- cache: Record<string, AIData | null>
- expected: { input: unknown; output: unknown; loading: boolean }
-}
-
-const resolveEventIOCases: ResolveEventIOCase[] = [
- {
- name: 'a generation with inline input and output',
- event: makeEvent({
- id: 'gen-1',
- event: '$ai_generation',
- properties: {
- $ai_input: [{ role: 'user', content: 'Why did my invoice go up?' }],
- $ai_output_choices: [{ role: 'assistant', content: 'Two seats were added.' }],
- },
- }),
- cache: {},
- expected: {
- input: [{ role: 'user', content: 'Why did my invoice go up?' }],
- output: [{ role: 'assistant', content: 'Two seats were added.' }],
- loading: false,
- },
- },
- {
- name: 'a generation missing input, with no cache entry yet',
- event: makeEvent({ id: 'gen-2', event: '$ai_generation', properties: {} }),
- cache: {},
- expected: { input: undefined, output: undefined, loading: true },
- },
- {
- name: 'a generation missing input, with a cache entry that found nothing',
- event: makeEvent({ id: 'gen-3', event: '$ai_generation', properties: {} }),
- cache: { 'gen-3': null },
- expected: { input: undefined, output: undefined, loading: false },
- },
- {
- name: 'a generation missing input, with a loaded cache entry',
- event: makeEvent({ id: 'gen-4', event: '$ai_generation', properties: {} }),
- cache: {
- 'gen-4': {
- input: [{ role: 'user', content: 'Cached question' }],
- output: [{ role: 'assistant', content: 'Cached answer' }],
- tools: null,
- },
- },
- expected: {
- input: [{ role: 'user', content: 'Cached question' }],
- output: [{ role: 'assistant', content: 'Cached answer' }],
- loading: false,
- },
- },
- {
- name: 'an embedding',
- event: makeEvent({ id: 'emb-1', event: '$ai_embedding', properties: { $ai_input: 'embed this text' } }),
- cache: {},
- expected: { input: 'embed this text', output: null, loading: false },
- },
- {
- name: 'a span',
- event: makeEvent({
- id: 'span-1',
- event: '$ai_span',
- properties: { $ai_input_state: { step: 1 }, $ai_output_state: { step: 2 } },
- }),
- cache: {},
- expected: { input: { step: 1 }, output: { step: 2 }, loading: false },
- },
- {
- name: 'an OTel span that carries generation-style input and output',
- event: makeEvent({
- id: 'span-2',
- event: '$ai_span',
- properties: {
- $ai_input: [{ role: 'user', content: 'Suggest hashtags' }],
- $ai_output_choices: 'Added #levelup',
- },
- }),
- cache: {},
- expected: { input: [{ role: 'user', content: 'Suggest hashtags' }], output: 'Added #levelup', loading: false },
- },
-]
-
-describe('eventIO', () => {
- describe('resolveEventIO', () => {
- it.each(resolveEventIOCases)('$name', ({ event, cache, expected }) => {
- expect(resolveEventIO(event, cache)).toEqual(expected)
- })
- })
-
- describe('heavyDataLookup', () => {
- it('returns null for a generation with both input and output present', () => {
- const event = makeEvent({
- id: 'gen-1',
- event: '$ai_generation',
- properties: {
- $ai_input: [{ role: 'user', content: 'Why did my invoice go up?' }],
- $ai_output_choices: [{ role: 'assistant', content: 'Two seats were added.' }],
- },
- })
- expect(heavyDataLookup(event, 'trace-1')).toBeNull()
- })
-
- it('returns null for a span', () => {
- const event = makeEvent({
- id: 'span-1',
- event: '$ai_span',
- properties: { $ai_input_state: { step: 1 }, $ai_output_state: { step: 2 } },
- })
- expect(heavyDataLookup(event, 'trace-1')).toBeNull()
- })
-
- it('returns a lookup for a generation missing output', () => {
- const event = makeEvent({
- id: 'gen-2',
- event: '$ai_generation',
- createdAt: '2026-09-01T10:15:02Z',
- properties: {
- $ai_input: [{ role: 'user', content: 'Why did my invoice go up?' }],
- $ai_tools: [{ name: 'lookup_invoice' }],
- },
- })
- expect(heavyDataLookup(event, 'trace-1')).toEqual({
- eventId: 'gen-2',
- input: [{ role: 'user', content: 'Why did my invoice go up?' }],
- output: undefined,
- tools: [{ name: 'lookup_invoice' }],
- traceId: 'trace-1',
- timestamp: '2026-09-01T10:15:02Z',
- })
- })
- })
-})
diff --git a/products/ai_observability/frontend/redesign/trace/adapter/eventIO.ts b/products/ai_observability/frontend/redesign/trace/adapter/eventIO.ts
deleted file mode 100644
index 0bccdd33fbba..000000000000
--- a/products/ai_observability/frontend/redesign/trace/adapter/eventIO.ts
+++ /dev/null
@@ -1,43 +0,0 @@
-import { LLMTraceEvent } from '~/queries/schema/schema-general'
-
-import { AIData, AIDataLookup } from '../../../aiObservabilityAIDataLogic'
-import { getLLMEventKind, readAiInput, readAiOutput } from '../../../utils'
-
-function generationOutput(event: LLMTraceEvent): unknown {
- return event.properties.$ai_output_choices ?? event.properties.$ai_output
-}
-
-function isMissingGenerationData(event: LLMTraceEvent): boolean {
- return event.properties.$ai_input == null || generationOutput(event) == null
-}
-
-export function heavyDataLookup(event: LLMTraceEvent, traceId: string): AIDataLookup | null {
- if (getLLMEventKind(event) !== 'generation' || !isMissingGenerationData(event)) {
- return null
- }
- return {
- eventId: event.id,
- input: event.properties.$ai_input,
- output: generationOutput(event),
- tools: event.properties.$ai_tools,
- traceId,
- timestamp: event.createdAt,
- }
-}
-
-export function resolveEventIO(
- event: LLMTraceEvent,
- cache: Record<string, AIData | null>
-): { input: unknown; output: unknown; loading: boolean } {
- const kind = getLLMEventKind(event)
- if (kind === 'generation') {
- const cached = cache[event.id]
- const input = cached?.input ?? event.properties.$ai_input
- const output = cached?.output ?? generationOutput(event)
- return { input, output, loading: isMissingGenerationData(event) && cached === undefined }
- }
- if (kind === 'embedding') {
- return { input: event.properties.$ai_input, output: null, loading: false }
- }
- return { input: readAiInput(event.properties), output: readAiOutput(event.properties), loading: false }
-}
diff --git a/products/ai_observability/frontend/redesign/trace/adapter/nodeIO.ts b/products/ai_observability/frontend/redesign/trace/adapter/nodeIO.ts
new file mode 100644
index 000000000000..74487155a1ea
--- /dev/null
+++ b/products/ai_observability/frontend/redesign/trace/adapter/nodeIO.ts
@@ -0,0 +1,17 @@
+import type { TraceNodeDetailApi } from '../../../generated/api.schemas'
+
+export interface NodeIO {
+ input: unknown
+ output: unknown
+}
+
+export function readNodeIO(node: TraceNodeDetailApi): NodeIO {
+ if (!node.event) {
+ return { input: undefined, output: undefined }
+ }
+ const { properties, ioKeys } = node.event
+ return {
+ input: ioKeys.input ? properties[ioKeys.input] : undefined,
+ output: ioKeys.output ? properties[ioKeys.output] : undefined,
+ }
+}
diff --git a/products/ai_observability/frontend/redesign/trace/adapter/propertyReaders.test.ts b/products/ai_observability/frontend/redesign/trace/adapter/propertyReaders.test.ts
deleted file mode 100644
index 5c3d21dc4549..000000000000
--- a/products/ai_observability/frontend/redesign/trace/adapter/propertyReaders.test.ts
+++ /dev/null
@@ -1,14 +0,0 @@
-import { readNumber } from './propertyReaders'
-
-describe('readNumber', () => {
- it.each([
- ['', null],
- [' ', null],
- ['0.2', 0.2],
- [0, 0],
- ['abc', null],
- [undefined, null],
- ])('reads %p as %p', (input, expected) => {
- expect(readNumber(input)).toBe(expected)
- })
-})
diff --git a/products/ai_observability/frontend/redesign/trace/adapter/propertyReaders.ts b/products/ai_observability/frontend/redesign/trace/adapter/propertyReaders.ts
deleted file mode 100644
index 636c014d380d..000000000000
--- a/products/ai_observability/frontend/redesign/trace/adapter/propertyReaders.ts
+++ /dev/null
@@ -1,11 +0,0 @@
-export function readString(value: unknown): string | null {
- return typeof value === 'string' && value !== '' ? value : null
-}
-
-export function readNumber(value: unknown): number | null {
- if (typeof value === 'string' && value.trim() === '') {
- return null
- }
- const parsed = typeof value === 'string' ? Number(value) : value
- return typeof parsed === 'number' && Number.isFinite(parsed) ? parsed : null
-}
diff --git a/products/ai_observability/frontend/redesign/trace/adapter/testFixtures.ts b/products/ai_observability/frontend/redesign/trace/adapter/testFixtures.ts
index 8b1368b5c07f..226e0d6a76de 100644
--- a/products/ai_observability/frontend/redesign/trace/adapter/testFixtures.ts
+++ b/products/ai_observability/frontend/redesign/trace/adapter/testFixtures.ts
@@ -1,6 +1,13 @@
import { LLMTrace, LLMTraceEvent } from '~/queries/schema/schema-general'
-import type { TraceApi, TraceNodeStatsApi } from '../../../generated/api.schemas'
+import type {
+ TraceApi,
+ TraceNodeApi,
+ TraceNodeDetailApi,
+ TraceNodeIOKeysApi,
+ TraceNodeMetadataApi,
+ TraceNodeStatsApi,
+} from '../../../generated/api.schemas'
export function makeEvent(overrides: Partial<LLMTraceEvent> & { id: string }): LLMTraceEvent {
return { event: '$ai_span', properties: {}, createdAt: '2026-09-01T10:15:00Z', ...overrides }
@@ -30,6 +37,54 @@ const emptyStats: TraceNodeStatsApi = {
latencyMs: null,
}
+export function decodeIdSegment(segment: string): string {
+ const binary = atob(segment.replace(/-/g, '+').replace(/_/g, '/'))
+ return new TextDecoder().decode(Uint8Array.from(binary, (char) => char.charCodeAt(0)))
+}
+
+interface NodeDetailFixture {
+ id: string
+ kind?: TraceNodeApi['kind']
+ properties?: Record<string, unknown>
+ ioKeys?: Partial<TraceNodeIOKeysApi>
+ error?: string | null
+ metadata?: Partial<TraceNodeMetadataApi>
+ withEvent?: boolean
+}
+
+export function makeNodeDetail({
+ id,
+ kind = 'generation',
+ properties = {},
+ ioKeys = {},
+ error = null,
+ metadata = {},
+ withEvent = true,
+}: NodeDetailFixture): TraceNodeDetailApi {
+ return {
+ id,
+ kind,
+ error,
+ metadata: {
+ provider: null,
+ temperature: null,
+ sessionId: null,
+ promptName: null,
+ promptVersion: null,
+ ...metadata,
+ },
+ event: withEvent
+ ? {
+ name: `$ai_${kind}`,
+ uuid: id,
+ timestamp: '2026-09-01T10:15:02Z',
+ properties,
+ ioKeys: { input: null, output: null, tools: null, ...ioKeys },
+ }
+ : null,
+ }
+}
+
export function makeTraceResource(overrides: Partial<TraceApi> = {}): TraceApi {
const childIds = ['span-1', 'gen-1', 'gen-2']
return {
@@ -63,6 +118,8 @@ export function makeTraceResource(overrides: Partial<TraceApi> = {}): TraceApi {
timeline: [],
totalMs: 0,
threadNodeIds: ['gen-2'],
+ defaultNodeId: 'trace-1',
+ nodeIdsByAlias: {},
...overrides,
}
}
diff --git a/products/ai_observability/frontend/redesign/trace/adapter/toNodeDetail.test.ts b/products/ai_observability/frontend/redesign/trace/adapter/toNodeDetail.test.ts
index b9b3be013b2f..44f7c40e9914 100644
--- a/products/ai_observability/frontend/redesign/trace/adapter/toNodeDetail.test.ts
+++ b/products/ai_observability/frontend/redesign/trace/adapter/toNodeDetail.test.ts
@@ -1,8 +1,7 @@
import { EvaluationRun } from '../../../evaluations/types'
import type { TraceNodeApi } from '../../../generated/api.schemas'
-import { isLLMEvent } from '../../../utils'
-import { EvalResult, EvalsState } from '../types'
-import { makeEvent, makeTrace } from './testFixtures'
+import { EvalResult, EvalsState, NodeLoad } from '../types'
+import { makeNodeDetail } from './testFixtures'
import { toNodeDetail } from './toNodeDetail'
const node = (id: string, kind: 'trace' | 'span' | 'generation'): TraceNodeApi => ({
@@ -42,11 +41,11 @@ function readyResults(evals: EvalsState): EvalResult[] {
return evals.results
}
+const ready = (detail: ReturnType<typeof makeNodeDetail>): NodeLoad => ({ status: 'ready', node: detail })
+
describe('toNodeDetail', () => {
const base = {
- trace: makeTrace(),
tree: [],
- cache: {},
evalRuns: [],
evalRunsLoading: false,
evaluations: [],
@@ -54,33 +53,45 @@ describe('toNodeDetail', () => {
evaluationsSettled: true,
teamId: 7,
person: null,
+ trace: { createdAt: '2026-09-01T10:15:00Z', sessionId: 'sess-1' },
}
- it('generation without inline IO and no cache entry yields loading', () => {
- const event = makeEvent({ id: 'gen-1', event: '$ai_generation', properties: {} })
- const detail = toNodeDetail({ ...base, event, node: node('gen-1', 'generation') })
- expect(detail.content).toEqual({ kind: 'loading' })
+ it.each<[string, NodeLoad, unknown]>([
+ ['loading', { status: 'loading' }, { kind: 'loading' }],
+ [
+ 'not found',
+ { status: 'error', failure: 'not_found' },
+ {
+ kind: 'error',
+ message:
+ 'This step could not be found. It may have been deleted, or it is outside the retention period.',
+ },
+ ],
+ [
+ 'failed',
+ { status: 'error', failure: 'failed' },
+ { kind: 'error', message: 'This step could not be loaded. Select it again to retry.' },
+ ],
+ ])('a %s node shows its load state, no raw event and no time', (_name, load, content) => {
+ const detail = toNodeDetail({ ...base, node: node('gen-1', 'generation'), load })
+ expect(detail.content).toEqual(content)
+ expect(detail.raw).toBeNull()
+ expect(detail.properties.timestamp).toBeNull()
})
- it('generation with content yields messages, properties and its own evals', () => {
- const event = makeEvent({
- id: 'gen-1',
- event: '$ai_generation',
- properties: {
- $ai_input: [{ role: 'user', content: 'Hi' }],
- $ai_output_choices: [{ role: 'assistant', content: 'Hello' }],
- $ai_model: 'gpt-4.1-mini',
- $ai_provider: 'openai',
- $ai_temperature: 0.2,
- $ai_session_id: 'sess-1',
- $ai_prompt_name: 'billing-answer',
- $ai_prompt_version: 6,
- },
- })
+ it('generation reads its messages through the io keys and keeps its details, raw event and own evals', () => {
+ const input = [{ role: 'user', content: 'Hi' }]
const detail = toNodeDetail({
...base,
- event,
node: node('gen-1', 'generation'),
+ load: ready(
+ makeNodeDetail({
+ id: 'gen-1',
+ properties: { $ai_input: input, $ai_output_choices: [{ role: 'assistant', content: 'Hello' }] },
+ ioKeys: { input: '$ai_input', output: '$ai_output_choices' },
+ metadata: { provider: 'openai', temperature: 0.2, sessionId: 'sess-9', promptVersion: 6 },
+ })
+ ),
evalRuns: [run(), run({ id: 'r2', generation_id: 'gen-other' })],
})
expect(detail.content).toMatchObject({
@@ -89,11 +100,13 @@ describe('toNodeDetail', () => {
output: [{ role: 'assistant', parts: [{ kind: 'text', text: 'Hello' }] }],
})
expect(detail.properties).toMatchObject({
+ timestamp: '2026-09-01T10:15:02Z',
provider: 'openai',
temperature: 0.2,
- sessionId: 'sess-1',
+ sessionId: 'sess-9',
promptVersion: 6,
})
+ expect(detail.raw).toMatchObject({ event: '$ai_generation', uuid: 'gen-1', properties: { $ai_input: input } })
expect(readyResults(detail.evals).map((result) => result.id)).toEqual(['r1'])
})
@@ -101,80 +114,79 @@ describe('toNodeDetail', () => {
['eval runs are loading', { evalRunsLoading: true }],
['the evaluation configs that decide detector polarity have not loaded', { evaluationsSettled: false }],
])('reports evals as loading while %s', (_name, overrides) => {
- const event = makeEvent({ id: 'gen-1', event: '$ai_generation', properties: {} })
const detail = toNodeDetail({
...base,
...overrides,
- event,
node: node('gen-1', 'generation'),
+ load: { status: 'loading' },
evalRuns: [run()],
})
expect(detail.evals).toEqual({ status: 'loading' })
})
- it.each([
- { name: 'a person label', person: '[email protected]' },
- { name: 'no person', person: null },
- ])(
- 'span shows its state as input and output, surfaces its error, and labels the person with $name',
- ({ person }) => {
- const event = makeEvent({
- id: 'span-1',
- properties: {
- $ai_input_state: { q: 'x' },
- $ai_output_state: null,
- $ai_is_error: true,
- $ai_error: 'Timeout',
- },
- })
- const detail = toNodeDetail({ ...base, event, node: node('span-1', 'span'), person })
- expect(detail.content).toEqual({ kind: 'io', input: { q: 'x' }, output: undefined })
- expect(detail.error).toBe('Timeout')
- expect(detail.properties.person).toBe(person)
- }
- )
+ it('span shows its state as input and output, surfaces its error and labels the person', () => {
+ const detail = toNodeDetail({
+ ...base,
+ person: '[email protected]',
+ node: node('span-1', 'span'),
+ load: ready(
+ makeNodeDetail({
+ id: 'span-1',
+ kind: 'span',
+ properties: { $ai_input_state: { q: 'x' } },
+ ioKeys: { input: '$ai_input_state' },
+ error: 'Timeout',
+ })
+ ),
+ })
+ expect(detail.content).toEqual({ kind: 'io', input: { q: 'x' }, output: undefined })
+ expect(detail.error).toBe('Timeout')
+ expect(detail.properties.person).toBe('[email protected]')
+ })
- it('trace root shows the trace state and every eval run', () => {
- const trace = makeTrace({ inputState: { question: 'Hi' }, outputState: { answer: 'Hello' } })
+ it.each([
+ ['with a trace event', true],
+ ['without a trace event', false],
+ ])('trace root %s takes its time and session from the trace and shows every eval run', (_name, withEvent) => {
const detail = toNodeDetail({
...base,
- trace,
- event: trace,
node: node('trace-1', 'trace'),
+ load: ready(
+ makeNodeDetail({
+ id: 'trace-1',
+ kind: 'trace',
+ withEvent,
+ properties: { $ai_input_state: { question: 'Hi' } },
+ ioKeys: { input: '$ai_input_state' },
+ })
+ ),
evalRuns: [run(), run({ id: 'r2' })],
})
- expect(detail.content).toEqual({ kind: 'io', input: { question: 'Hi' }, output: { answer: 'Hello' } })
+ expect(detail.properties).toMatchObject({ timestamp: '2026-09-01T10:15:00Z', sessionId: 'sess-1' })
expect(readyResults(detail.evals)).toHaveLength(2)
- expect(detail.raw).not.toHaveProperty('events')
+ expect(detail.content).toEqual({
+ kind: 'io',
+ input: withEvent ? { question: 'Hi' } : undefined,
+ output: undefined,
+ })
+ expect(detail.raw === null).toBe(!withEvent)
})
- it.each([
- {
- name: 'trace state holding message arrays',
- event: makeTrace({
- inputState: [{ role: 'user', content: 'Move my flight to Friday' }],
- outputState: [{ role: 'assistant', content: 'Moved to Friday 09:15' }],
- }),
- kind: 'trace' as const,
- },
- {
- name: 'an OTel span with a message array input and a text output',
- event: makeEvent({
- id: 'span-2',
- properties: {
- $ai_input: [{ role: 'user', content: 'Move my flight to Friday' }],
- $ai_output_choices: 'Moved to Friday 09:15',
- },
- }),
- kind: 'span' as const,
- },
- ])('renders $name as input and output messages', ({ event, kind }) => {
- const trace = isLLMEvent(event) ? base.trace : event
+ it('renders an OTel span with a message array input and a text output as messages', () => {
const detail = toNodeDetail({
...base,
- trace,
- event,
- node: node(isLLMEvent(event) ? event.id : trace.id, kind),
+ node: node('span-2', 'span'),
+ load: ready(
+ makeNodeDetail({
+ id: 'span-2',
+ kind: 'span',
+ properties: {
+ $ai_input: [{ role: 'user', content: 'Move my flight to Friday' }],
+ $ai_output_choices: 'Moved to Friday 09:15',
+ },
+ ioKeys: { input: '$ai_input', output: '$ai_output_choices' },
+ })
+ ),
})
expect(detail.content).toMatchObject({
kind: 'messages',
diff --git a/products/ai_observability/frontend/redesign/trace/adapter/toNodeDetail.ts b/products/ai_observability/frontend/redesign/trace/adapter/toNodeDetail.ts
index c624f6d138d4..27401e540e02 100644
--- a/products/ai_observability/frontend/redesign/trace/adapter/toNodeDetail.ts
+++ b/products/ai_observability/frontend/redesign/trace/adapter/toNodeDetail.ts
@@ -1,26 +1,23 @@
-import { LLMTrace, LLMTraceEvent } from '~/queries/schema/schema-general'
-
-import { AIData } from '../../../aiObservabilityAIDataLogic'
import { EvaluationConfig, EvaluationRun } from '../../../evaluations/types'
-import type { TraceNodeApi } from '../../../generated/api.schemas'
-import { isLLMEvent } from '../../../utils'
+import type { TraceNodeApi, TraceNodeDetailApi } from '../../../generated/api.schemas'
import { NodeDetailProps } from '../components/NodeDetail'
-import { EvalsState, NodeContent, NodeProperties } from '../types'
-import { resolveEventIO } from './eventIO'
-import { readNumber, readString } from './propertyReaders'
+import { EvalsState, LoadFailure, NodeContent, NodeLoad, NodeProperties } from '../types'
+import { NodeIO, readNodeIO } from './nodeIO'
import { TeamId } from './toAttachment'
import { toEvalResults } from './toEvalResults'
import { toMessageIO } from './toThread'
import { isMessageIO } from './toThreadMessages'
-import { eventError } from './toTraceTree'
export type NodeDetailData = Omit<NodeDetailProps, 'tab' | 'onTabChange' | 'onViewInThread' | 'onSelectNode'>
+const NODE_LOAD_ERRORS: Record<LoadFailure, string> = {
+ not_found: 'This step could not be found. It may have been deleted, or it is outside the retention period.',
+ failed: 'This step could not be loaded. Select it again to retry.',
+}
+
interface NodeDetailArgs {
- trace: LLMTrace
- event: LLMTrace | LLMTraceEvent
node: TraceNodeApi
- cache: Record<string, AIData | null>
+ load: NodeLoad
tree: TraceNodeApi[]
evalRuns: EvaluationRun[]
evalRunsLoading: boolean
@@ -29,48 +26,56 @@ interface NodeDetailArgs {
evaluationsSettled: boolean
teamId: TeamId
person: string | null
+ trace: { createdAt: string; sessionId: string | null }
}
-function ioContent(io: { input: unknown; output: unknown }, node: TraceNodeApi, teamId: TeamId): NodeContent {
+function ioContent(io: NodeIO, node: TraceNodeApi, teamId: TeamId): NodeContent {
if (node.kind === 'generation' || isMessageIO(io.input, io.output)) {
return { kind: 'messages', ...toMessageIO(io, node.id, teamId) }
}
return { kind: 'io', input: io.input, output: io.output }
}
-function eventContent(
- event: LLMTraceEvent,
- node: TraceNodeApi,
- cache: Record<string, AIData | null>,
- teamId: TeamId
-): NodeContent {
- const io = resolveEventIO(event, cache)
- return io.loading ? { kind: 'loading' } : ioContent(io, node, teamId)
+function loadedContent(load: NodeLoad, node: TraceNodeApi, teamId: TeamId): NodeContent {
+ switch (load.status) {
+ case 'loading':
+ return { kind: 'loading' }
+ case 'error':
+ return { kind: 'error', message: NODE_LOAD_ERRORS[load.failure] }
+ case 'ready':
+ return ioContent(readNodeIO(load.node), node, teamId)
+ }
}
-function eventProperties(event: LLMTraceEvent, person: string | null): NodeProperties {
- const properties = event.properties
+function nodeProperties(load: NodeLoad, node: TraceNodeApi, args: NodeDetailArgs): NodeProperties {
+ if (node.kind === 'trace') {
+ return {
+ timestamp: args.trace.createdAt,
+ provider: null,
+ temperature: null,
+ sessionId: args.trace.sessionId,
+ promptName: null,
+ promptVersion: null,
+ person: args.person,
+ }
+ }
+ const detail = load.status === 'ready' ? load.node : null
return {
- timestamp: event.createdAt,
- provider: readString(properties.$ai_provider),
- temperature: readNumber(properties.$ai_temperature),
- sessionId: readString(properties.$ai_session_id),
- promptName: readString(properties.$ai_prompt_name),
- promptVersion: readNumber(properties.$ai_prompt_version),
- person,
+ timestamp: detail?.event?.timestamp ?? null,
+ provider: detail?.metadata.provider ?? null,
+ temperature: detail?.metadata.temperature ?? null,
+ sessionId: detail?.metadata.sessionId ?? null,
+ promptName: detail?.metadata.promptName ?? null,
+ promptVersion: detail?.metadata.promptVersion ?? null,
+ person: args.person,
}
}
-function traceProperties(trace: LLMTrace, person: string | null): NodeProperties {
- return {
- timestamp: trace.createdAt,
- provider: null,
- temperature: null,
- sessionId: trace.aiSessionId ?? null,
- promptName: null,
- promptVersion: null,
- person,
- }
+function rawEvent(detail: TraceNodeDetailApi): Record<string, unknown> | null {
+ const { event } = detail
+ return event
+ ? { event: event.name, uuid: event.uuid, timestamp: event.timestamp, properties: event.properties }
+ : null
}
// Detector polarity comes from the evaluation configs, so results wait for them to avoid showing a flipped verdict.
@@ -90,27 +95,14 @@ function evalsState(runs: EvaluationRun[], node: TraceNodeApi, args: NodeDetailA
}
export function toNodeDetail(args: NodeDetailArgs): NodeDetailData {
- const { trace, event, node, cache, evalRuns, teamId, person } = args
+ const { node, load, evalRuns, teamId } = args
const runs = node.kind === 'trace' ? evalRuns : evalRuns.filter((run) => run.generation_id === node.id)
- const evals = evalsState(runs, node, args)
-
- if (!isLLMEvent(event)) {
- const { events: _events, ...raw } = trace
- return {
- node,
- content: ioContent({ input: trace.inputState, output: trace.outputState }, node, teamId),
- error: null,
- properties: traceProperties(trace, person),
- evals,
- raw,
- }
- }
return {
node,
- content: eventContent(event, node, cache, teamId),
- error: eventError(event),
- properties: eventProperties(event, person),
- evals,
- raw: { event: event.event, id: event.id, createdAt: event.createdAt, properties: event.properties },
+ content: loadedContent(load, node, teamId),
+ error: load.status === 'ready' ? load.node.error : null,
+ properties: nodeProperties(load, node, args),
+ evals: evalsState(runs, node, args),
+ raw: load.status === 'ready' ? rawEvent(load.node) : null,
}
}
diff --git a/products/ai_observability/frontend/redesign/trace/adapter/toThread.test.ts b/products/ai_observability/frontend/redesign/trace/adapter/toThread.test.ts
index 9579d6343e3b..1a9e938cb61f 100644
--- a/products/ai_observability/frontend/redesign/trace/adapter/toThread.test.ts
+++ b/products/ai_observability/frontend/redesign/trace/adapter/toThread.test.ts
@@ -1,5 +1,5 @@
-import { ConversationState, ConversationTurn } from '../types'
-import { makeEvent, makeTrace } from './testFixtures'
+import { ConversationState, ConversationTurn, NodeLoad } from '../types'
+import { makeNodeDetail } from './testFixtures'
import { toThread } from './toThread'
function readyTurns(thread: ConversationState): ConversationTurn[] {
@@ -10,22 +10,25 @@ function readyTurns(thread: ConversationState): ConversationTurn[] {
}
describe('toThread', () => {
- const generation = makeEvent({
- id: 'gen-1',
- event: '$ai_generation',
- createdAt: '2026-09-01T10:15:02Z',
- properties: {
- $ai_input: [{ role: 'user', content: 'Why did my invoice go up?' }],
- $ai_output_choices: [{ role: 'assistant', content: 'Two seats were added.' }],
- },
+ const base = { traceId: 'trace-1', createdAt: '2026-09-01T10:15:00Z', teamId: 7 }
+ const answered = (error: string | null = null): NodeLoad => ({
+ status: 'ready',
+ node: makeNodeDetail({
+ id: 'gen-1',
+ error,
+ properties: {
+ $ai_input: [{ role: 'user', content: 'Why did my invoice go up?' }],
+ $ai_output_choices: [{ role: 'assistant', content: 'Two seats were added.' }],
+ },
+ ioKeys: { input: '$ai_input', output: '$ai_output_choices' },
+ }),
})
- it('builds one turn for the trace from its user-visible generation', () => {
- const thread = toThread(makeTrace({ events: [generation] }), {}, 7)
+ it('builds one turn for the trace from its thread node', () => {
+ const thread = toThread({ ...base, load: answered() })
expect(thread).toMatchObject({ status: 'ready', activeTurnId: 'trace-1' })
const turns = readyTurns(thread)
- expect(turns).toHaveLength(1)
- expect(turns[0].messages.map((m) => [m.role, m.sourceNodeId])).toEqual([
+ expect(turns[0].messages.map((message) => [message.role, message.sourceNodeId])).toEqual([
['user', 'gen-1'],
['assistant', 'gen-1'],
])
@@ -33,40 +36,23 @@ describe('toThread', () => {
})
it('carries the error of a failed generation on its turn', () => {
- const failed = makeEvent({
- id: 'gen-3',
- event: '$ai_generation',
- properties: {
- $ai_input: [{ role: 'user', content: 'Describe this photo.' }],
- $ai_output_choices: [],
- $ai_is_error: true,
- $ai_error: 'Model does not support image input',
- },
- })
- expect(readyTurns(toThread(makeTrace({ events: [failed] }), {}, 7))[0].error).toBe(
+ expect(readyTurns(toThread({ ...base, load: answered('Model does not support image input') }))[0].error).toBe(
'Model does not support image input'
)
})
- it.each([
- ['is loading while its offloaded content is not cached', {}, { status: 'loading' }],
+ it.each<[string, NodeLoad, ConversationState]>([
+ ['loading', { status: 'loading' }, { status: 'loading' }],
[
- 'uses its offloaded content once cached',
- {
- 'gen-2': {
- input: [{ role: 'user', content: 'Hi' }],
- output: [{ role: 'assistant', content: 'Hello' }],
- tools: null,
- },
- },
- { status: 'ready', turns: [{ messages: [{ role: 'user' }, { role: 'assistant' }] }] },
+ 'failed',
+ { status: 'error', failure: 'failed' },
+ { status: 'error', message: 'The conversation could not be loaded. Reload the page to try again.' },
],
- ])('an offloaded generation %s', (_name, cache, expected) => {
- const offloaded = makeEvent({ id: 'gen-2', event: '$ai_generation', properties: {} })
- expect(toThread(makeTrace({ events: [offloaded] }), cache, 7)).toMatchObject(expected)
+ ])('a thread whose node is %s', (_name, load, expected) => {
+ expect(toThread({ ...base, load })).toEqual(expected)
})
- it('gives an empty turn when the trace has no generation', () => {
- expect(readyTurns(toThread(makeTrace({ events: [makeEvent({ id: 's1' })] }), {}, 7))[0].messages).toEqual([])
+ it('gives an empty turn when the trace has no thread node', () => {
+ expect(readyTurns(toThread({ ...base, load: null }))[0].messages).toEqual([])
})
})
diff --git a/products/ai_observability/frontend/redesign/trace/adapter/toThread.ts b/products/ai_observability/frontend/redesign/trace/adapter/toThread.ts
index b0d66f82361c..aef26e21aea7 100644
--- a/products/ai_observability/frontend/redesign/trace/adapter/toThread.ts
+++ b/products/ai_observability/frontend/redesign/trace/adapter/toThread.ts
@@ -1,12 +1,7 @@
-import { LLMTrace } from '~/queries/schema/schema-general'
-
-import { AIData } from '../../../aiObservabilityAIDataLogic'
-import { pickUserVisibleTurn } from '../../../extractSessionTurns'
-import { ConversationState, ThreadMessage } from '../types'
-import { resolveEventIO } from './eventIO'
+import { ConversationState, NodeLoad, ThreadMessage } from '../types'
+import { readNodeIO } from './nodeIO'
import { TeamId } from './toAttachment'
import { toThreadMessages } from './toThreadMessages'
-import { eventError } from './toTraceTree'
export interface MessageIO {
input: ThreadMessage[]
@@ -30,23 +25,36 @@ export function toMessageIO(io: { input: unknown; output: unknown }, sourceNodeI
}
}
-function readyThread(trace: LLMTrace, messages: ThreadMessage[], error: string | null): ConversationState {
- return {
- status: 'ready',
- turns: [{ id: trace.id, timestamp: trace.createdAt, messages, error }],
- activeTurnId: trace.id,
- }
+const THREAD_LOAD_ERROR = 'The conversation could not be loaded. Reload the page to try again.'
+
+interface ThreadArgs {
+ traceId: string
+ createdAt: string
+ load: NodeLoad | null
+ teamId: TeamId
+}
+
+function readyThread(
+ traceId: string,
+ createdAt: string,
+ messages: ThreadMessage[],
+ error: string | null
+): ConversationState {
+ return { status: 'ready', turns: [{ id: traceId, timestamp: createdAt, messages, error }], activeTurnId: traceId }
}
-export function toThread(trace: LLMTrace, cache: Record<string, AIData | null>, teamId: TeamId): ConversationState {
- const turnEvent = pickUserVisibleTurn(trace)
- if (!turnEvent) {
- return readyThread(trace, [], null)
+export function toThread({ traceId, createdAt, load, teamId }: ThreadArgs): ConversationState {
+ if (load === null) {
+ return readyThread(traceId, createdAt, [], null)
}
- const io = resolveEventIO(turnEvent, cache)
- if (io.loading) {
- return { status: 'loading' }
+ switch (load.status) {
+ case 'loading':
+ return { status: 'loading' }
+ case 'error':
+ return { status: 'error', message: THREAD_LOAD_ERROR }
+ case 'ready': {
+ const { input, output } = toMessageIO(readNodeIO(load.node), load.node.id, teamId)
+ return readyThread(traceId, createdAt, [...input, ...output], load.node.error)
+ }
}
- const { input, output } = toMessageIO(io, turnEvent.id, teamId)
- return readyThread(trace, [...input, ...output], eventError(turnEvent))
}
diff --git a/products/ai_observability/frontend/redesign/trace/adapter/toTraceTree.test.ts b/products/ai_observability/frontend/redesign/trace/adapter/toTraceTree.test.ts
deleted file mode 100644
index da29766b93e9..000000000000
--- a/products/ai_observability/frontend/redesign/trace/adapter/toTraceTree.test.ts
+++ /dev/null
@@ -1,15 +0,0 @@
-import { makeEvent } from './testFixtures'
-import { isErrorEvent } from './toTraceTree'
-
-describe('toTraceTree', () => {
- describe('isErrorEvent', () => {
- it.each([
- ['a populated $ai_error with no flag', { $ai_error: 'boom' }, true],
- ['$ai_is_error: true with no error payload', { $ai_is_error: true }, true],
- ['$ai_is_error: "true" (SDK-serialized boolean)', { $ai_is_error: 'true' }, true],
- ['neither an error payload nor a truthy flag', { $ai_is_error: false }, false],
- ])('%s -> %s', (_description, properties, expected) => {
- expect(isErrorEvent(makeEvent({ id: 'e1', properties }))).toBe(expected)
- })
- })
-})
diff --git a/products/ai_observability/frontend/redesign/trace/adapter/toTraceTree.ts b/products/ai_observability/frontend/redesign/trace/adapter/toTraceTree.ts
index 706de6eeb5f3..adbc20d8b2cd 100644
--- a/products/ai_observability/frontend/redesign/trace/adapter/toTraceTree.ts
+++ b/products/ai_observability/frontend/redesign/trace/adapter/toTraceTree.ts
@@ -1,16 +1,4 @@
-import { LLMTraceEvent } from '~/queries/schema/schema-general'
-
import type { TraceNodeApi } from '../../../generated/api.schemas'
-import { toDisplayText } from '../components/jsonText'
-
-export function isErrorEvent(event: LLMTraceEvent): boolean {
- const isErrorFlag = event.properties.$ai_is_error
- return !!event.properties.$ai_error || isErrorFlag === true || isErrorFlag === 'true'
-}
-
-export function eventError(event: LLMTraceEvent): string | null {
- return isErrorEvent(event) ? toDisplayText(event.properties.$ai_error ?? 'This step failed.') : null
-}
export function findTreeNode(nodes: TraceNodeApi[], id: string): TraceNodeApi | null {
for (const node of nodes) {
diff --git a/products/ai_observability/frontend/redesign/trace/adapter/traceSceneWiring.test.tsx b/products/ai_observability/frontend/redesign/trace/adapter/traceSceneWiring.test.tsx
index 186bd79ce5f9..35072fd85e89 100644
--- a/products/ai_observability/frontend/redesign/trace/adapter/traceSceneWiring.test.tsx
+++ b/products/ai_observability/frontend/redesign/trace/adapter/traceSceneWiring.test.tsx
@@ -11,7 +11,7 @@ import { initKeaTests } from '~/test/init'
import { aiObservabilityTraceLogic } from '../../../aiObservabilityTraceLogic'
import { TraceScene } from '../TraceScene'
-import { makeEvent, makeTrace, makeTraceResource } from './testFixtures'
+import { decodeIdSegment, makeEvent, makeNodeDetail, makeTrace, makeTraceResource } from './testFixtures'
const FLAG = FEATURE_FLAGS.AI_OBSERVABILITY_TRACE_REDESIGN
@@ -21,6 +21,25 @@ jest.mock('../../../utils', () => ({
queryEvaluationRuns: jest.fn().mockResolvedValue([]),
}))
+const TRACE_URL = '/api/projects/:team_id/ai_observability/traces/:id/'
+const NODE_URL = '/api/projects/:team_id/ai_observability/traces/:id/nodes/:node_id/'
+const answeredGeneration = makeNodeDetail({
+ id: 'gen-2',
+ properties: {
+ $ai_input: [{ role: 'user', content: 'Why did my invoice go up?' }],
+ $ai_output_choices: [{ role: 'assistant', content: 'Two seats were added.' }],
+ },
+ ioKeys: { input: '$ai_input', output: '$ai_output_choices' },
+})
+let nodeRequests: string[] = []
+const nodeMock = {
+ [NODE_URL]: ({ params }: { params: Record<string, unknown> }) => {
+ const nodeId = decodeIdSegment(String(params.node_id))
+ nodeRequests.push(nodeId)
+ return [200, nodeId === 'gen-2' ? answeredGeneration : makeNodeDetail({ id: nodeId })]
+ },
+}
+
const generation = makeEvent({
id: 'gen-1',
event: '$ai_generation',
@@ -33,36 +52,49 @@ const generation = makeEvent({
},
})
+function renderNewView(): ReturnType<typeof render> {
+ initKeaTests()
+ nodeRequests = []
+ jest.mocked(performQuery).mockReset()
+ jest.mocked(performQuery).mockResolvedValue({ results: [] })
+ aiObservabilityTraceLogic.mount()
+ router.actions.push(urls.aiObservabilityTrace('trace-1'))
+ return render(<TraceScene />)
+}
+
describe('TraceScene', () => {
afterEach(cleanup)
- it('renders the loaded trace after showing the loading state', async () => {
- initKeaTests()
- type QueryResult = Awaited<ReturnType<typeof performQuery>>
- let resolveQuery: (value: QueryResult) => void = () => {}
- jest.mocked(performQuery).mockReturnValue(
- new Promise<QueryResult>((resolve) => {
- resolveQuery = resolve
- })
- )
- useMocks({ get: { '/api/projects/:team_id/ai_observability/traces/:id/': () => [200, makeTraceResource()] } })
- aiObservabilityTraceLogic.mount()
- router.actions.push(urls.aiObservabilityTrace('trace-1'))
-
- const { findAllByText, queryByText } = render(<TraceScene />)
- expect(queryByText('answer-billing-question')).toBeNull()
-
- resolveQuery({ results: [makeTrace({ events: [generation] })] })
-
- expect((await findAllByText('answer-billing-question')).length).toBeGreaterThan(0)
- await waitFor(() => expect(queryByText('Two seats were added.')).not.toBeNull())
+ describe('the new view', () => {
+ beforeEach(() => {
+ useMocks({ get: { [TRACE_URL]: () => [200, makeTraceResource({ defaultNodeId: 'gen-2' })], ...nodeMock } })
+ })
+
+ it('opens on the default node without the legacy trace query', async () => {
+ const { findAllByText, findByText } = renderNewView()
+
+ expect((await findAllByText('answer-billing-question')).length).toBeGreaterThan(0)
+ expect(await findByText('Two seats were added.')).toBeTruthy()
+ expect(jest.mocked(performQuery).mock.calls.some(([query]) => query.kind === 'TraceQuery')).toBe(false)
+ })
+
+ it('starts reading a step when the pointer rests on its row', async () => {
+ const { findByText } = renderNewView()
+ const row = (await findByText('span-1')).closest('[data-attr="trace-view-tree-node"]')
+ if (!row) {
+ throw new Error('expected span-1 to render as a tree row')
+ }
+ nodeRequests = []
+
+ fireEvent.mouseEnter(row)
+
+ await waitFor(() => expect(nodeRequests).toContain('span-1'))
+ })
})
describe('behind the flag gate', () => {
beforeEach(() => {
- useMocks({
- get: { '/api/projects/:team_id/ai_observability/traces/:id/': () => [200, makeTraceResource()] },
- })
+ useMocks({ get: { [TRACE_URL]: () => [200, makeTraceResource()], ...nodeMock } })
})
async function renderTraceRoute(flagEnabled: boolean): Promise<ReturnType<typeof render>> {
diff --git a/products/ai_observability/frontend/redesign/trace/adapter/traceViewAdapterLogic.test.ts b/products/ai_observability/frontend/redesign/trace/adapter/traceViewAdapterLogic.test.ts
index b987d20ffaa7..39b16099d8f5 100644
--- a/products/ai_observability/frontend/redesign/trace/adapter/traceViewAdapterLogic.test.ts
+++ b/products/ai_observability/frontend/redesign/trace/adapter/traceViewAdapterLogic.test.ts
@@ -1,5 +1,7 @@
+import { waitFor } from '@testing-library/react'
import { router } from 'kea-router'
import { expectLogic } from 'kea-test-utils'
+import posthog from 'posthog-js'
import { urls } from 'scenes/urls'
@@ -7,9 +9,9 @@ import { useMocks } from '~/mocks/jest'
import { performQuery } from '~/queries/query'
import { initKeaTests } from '~/test/init'
-import { aiObservabilityAIDataLogic } from '../../../aiObservabilityAIDataLogic'
import { aiObservabilityTraceLogic } from '../../../aiObservabilityTraceLogic'
-import { makeEvent, makeTrace, makeTraceResource } from './testFixtures'
+import type { TraceApi } from '../../../generated/api.schemas'
+import { decodeIdSegment, makeNodeDetail, makeTraceResource } from './testFixtures'
import { traceViewAdapterLogic } from './traceViewAdapterLogic'
jest.mock('~/queries/query', () => ({ ...jest.requireActual('~/queries/query'), performQuery: jest.fn() }))
@@ -18,95 +20,191 @@ jest.mock('../../../utils', () => ({
queryEvaluationRuns: jest.fn().mockResolvedValue([]),
}))
-const offloadedGeneration = makeEvent({
- id: 'gen-1',
- event: '$ai_generation',
- createdAt: '2026-09-01T10:15:02Z',
- properties: { $ai_trace_id: 'trace-1', $ai_parent_id: 'trace-1' },
-})
+const TRACE_URL = '/api/projects/:team_id/ai_observability/traces/:id/'
+const NODE_URL = '/api/projects/:team_id/ai_observability/traces/:id/nodes/:node_id/'
-// The latest generation, so `pickUserVisibleTurn` picks this one for the thread. Carries
-// inline input/output so `toThread` produces messages tagged with this event's id.
-const answeredGeneration = makeEvent({
+const answeredGeneration = makeNodeDetail({
id: 'gen-2',
- event: '$ai_generation',
- createdAt: '2026-09-01T10:15:03Z',
properties: {
- $ai_trace_id: 'trace-1',
- $ai_parent_id: 'trace-1',
$ai_input: [{ role: 'user', content: 'Why did my invoice go up?' }],
$ai_output_choices: [{ role: 'assistant', content: 'Two seats were added.' }],
},
-})
-
-const offloadedLatestGeneration = makeEvent({
- id: 'gen-3',
- event: '$ai_generation',
- createdAt: '2026-09-01T10:15:04Z',
- properties: { $ai_trace_id: 'trace-1', $ai_parent_id: 'trace-1' },
-})
-
-const unrelatedSpan = makeEvent({
- id: 'span-1',
- event: '$ai_span',
- createdAt: '2026-09-01T10:15:01Z',
- properties: { $ai_trace_id: 'trace-1', $ai_parent_id: 'trace-1' },
+ ioKeys: { input: '$ai_input', output: '$ai_output_choices' },
})
describe('traceViewAdapterLogic', () => {
let logic: ReturnType<typeof traceViewAdapterLogic.build>
-
- function remount(): void {
- logic.unmount()
- const { query } = aiObservabilityTraceLogic.values
- logic = traceViewAdapterLogic({ traceId: 'trace-1', query, timestampHint: null })
+ let traceResource: TraceApi
+ let traceGate: Promise<void>
+ let nodeRequests: string[]
+ let failingNodeId: string | null
+
+ function mountAt(params: Record<string, string> = {}): void {
+ router.actions.push(urls.aiObservabilityTrace('trace-1', params))
+ logic = traceViewAdapterLogic({ traceId: 'trace-1', timestampHint: null })
logic.mount()
}
- beforeEach(async () => {
- useMocks({ get: { '/api/projects/:team_id/ai_observability/traces/:id/': () => [200, makeTraceResource()] } })
+ beforeEach(() => {
+ traceResource = makeTraceResource({ nodeIdsByAlias: { 'sdk-gen-1': 'gen-1' } })
+ traceGate = Promise.resolve()
+ nodeRequests = []
+ failingNodeId = null
+ useMocks({
+ get: {
+ [TRACE_URL]: async () => {
+ await traceGate
+ return [200, traceResource]
+ },
+ [NODE_URL]: ({ params }) => {
+ const nodeId = decodeIdSegment(String(params.node_id))
+ nodeRequests.push(nodeId)
+ if (nodeId === failingNodeId) {
+ failingNodeId = null
+ return [500, { detail: 'Server error.' }]
+ }
+ if (nodeId === 'gen-2') {
+ return [200, answeredGeneration]
+ }
+ const known = ['trace-1', 'span-1', 'gen-1'].includes(nodeId)
+ return known ? [200, makeNodeDetail({ id: nodeId })] : [404, { detail: 'Node not found.' }]
+ },
+ },
+ })
initKeaTests()
- jest.mocked(performQuery).mockResolvedValue({
- results: [makeTrace({ events: [offloadedGeneration, answeredGeneration, unrelatedSpan] })],
- } as any)
+ jest.mocked(performQuery).mockReset()
+ jest.mocked(performQuery).mockResolvedValue({ results: [] })
aiObservabilityTraceLogic.mount()
- router.actions.push(urls.aiObservabilityTrace('trace-1'))
- const { query } = aiObservabilityTraceLogic.values
- logic = traceViewAdapterLogic({ traceId: 'trace-1', query, timestampHint: null })
- logic.mount()
- await expectLogic(logic).toFinishAllListeners().toMatchValues({ status: 'ready' })
})
- afterEach(() => logic.unmount())
+ afterEach(() => {
+ logic.unmount()
+ jest.restoreAllMocks()
+ })
+
+ it('reads a deep-linked node alongside the trace, then the thread node, and never runs the legacy trace query', async () => {
+ let releaseTrace = (): void => {}
+ traceGate = new Promise<void>((resolve) => {
+ releaseTrace = resolve
+ })
+ mountAt({ event: 'span-1' })
+
+ await waitFor(() => expect(nodeRequests).toEqual(['span-1']))
+ expect(logic.values.status).toBe('loading')
+
+ releaseTrace()
+ await expectLogic(logic).toFinishAllListeners().toMatchValues({ status: 'ready', selectedNodeId: 'span-1' })
+
+ expect(nodeRequests).toEqual(['span-1', 'gen-2'])
+ expect(jest.mocked(performQuery).mock.calls.some(([query]) => query.kind === 'TraceQuery')).toBe(false)
+ })
it.each([
- ['a generation when it is selected', null, () => logic.actions.selectNode('gen-1'), 'gen-1'],
- [
- 'the offloaded latest generation, which the thread shows, on mount',
- [answeredGeneration, offloadedLatestGeneration],
- null,
- 'gen-3',
- ],
- ])('asks the heavy-data loader for %s', async (_name, events, act, expectedEventId) => {
- if (events) {
- jest.mocked(performQuery).mockResolvedValue({ results: [makeTrace({ events })] } as any)
- }
- await expectLogic(logic, () => (act ? act() : remount())).toDispatchActions([
- (action) =>
- action.type === aiObservabilityAIDataLogic.actionTypes.ensureAIDataLoaded &&
- action.payload.lookups.some((lookup: { eventId: string }) => lookup.eventId === expectedEventId),
+ ['a node in the tree', { event: 'span-1' }, 'span-1'],
+ ['an SDK id through its alias', { event: 'sdk-gen-1' }, 'gen-1'],
+ ['a stale id as the root', { event: 'missing' }, 'trace-1'],
+ ['no id as the default node', {}, 'gen-1'],
+ ['a trace-level link as the root', { tab: 'summary' }, 'trace-1'],
+ ])('selects %s', async (_name, params: Record<string, string>, expected) => {
+ traceResource = makeTraceResource({ defaultNodeId: 'gen-1', nodeIdsByAlias: { 'sdk-gen-1': 'gen-1' } })
+ mountAt(params)
+
+ await expectLogic(logic).toFinishAllListeners().toMatchValues({ selectedNodeId: expected })
+ expect(logic.values.detailData?.content.kind).not.toBe('error')
+ })
+
+ it('asks for the neighbours once the trace arrives', async () => {
+ mountAt()
+
+ await expectLogic(logic).toDispatchActions([
+ aiObservabilityTraceLogic.actionCreators.loadNeighbors('trace-1', '2026-09-01T10:15:00Z'),
])
})
- it('falls back to the root node when the event id is unknown', async () => {
- await expectLogic(logic, () => logic.actions.selectNode('does-not-exist')).toMatchValues({
- selectedNodeId: 'trace-1',
- canViewInThread: true,
+ it('reports the reads that open the view as navigation and a click on an unread step as a selection', async () => {
+ const capture = jest.spyOn(posthog, 'capture')
+ traceResource = makeTraceResource({ defaultNodeId: 'gen-1' })
+ mountAt()
+ await expectLogic(logic).toFinishAllListeners()
+
+ expect(nodeRequests).toContain('gen-1')
+ expect(capture).toHaveBeenCalledWith('llma trace node loaded', {
+ load_ms: expect.any(Number),
+ trigger: 'navigation',
+ waited_ms: null,
+ })
+ expect(capture).not.toHaveBeenCalledWith(
+ 'llma trace node loaded',
+ expect.objectContaining({ trigger: 'selection' })
+ )
+ capture.mockClear()
+
+ logic.actions.selectNode('span-1')
+ await expectLogic(logic).toFinishAllListeners()
+
+ expect(capture).toHaveBeenCalledWith('llma trace node loaded', {
+ load_ms: expect.any(Number),
+ trigger: 'selection',
+ waited_ms: expect.any(Number),
})
})
+ it('prefetches only the row the pointer rests on, without rebuilding the shown step or the thread', async () => {
+ mountAt()
+ await expectLogic(logic).toFinishAllListeners()
+ nodeRequests = []
+ const { detailData, thread } = logic.values
+
+ logic.actions.prefetchNode('span-1')
+ logic.actions.prefetchNode('gen-1')
+ await expectLogic(logic).toFinishAllListeners()
+
+ expect(nodeRequests).toEqual(['gen-1'])
+ expect(logic.values.detailData).toBe(detailData)
+ expect(logic.values.thread).toBe(thread)
+ })
+
+ it('builds the thread from the thread node', async () => {
+ mountAt()
+
+ await expectLogic(logic)
+ .toFinishAllListeners()
+ .toMatchValues({
+ thread: expect.objectContaining({
+ status: 'ready',
+ turns: [
+ expect.objectContaining({
+ messages: [
+ expect.objectContaining({ role: 'user' }),
+ expect.objectContaining({ role: 'assistant' }),
+ ],
+ }),
+ ],
+ }),
+ })
+ })
+
+ it.each(['selectNode', 'selectAndShowSpans'] as const)(
+ 'reads a failed node again when %s picks it again',
+ async (select) => {
+ failingNodeId = 'span-1'
+ mountAt({ event: 'span-1' })
+ await expectLogic(logic).toFinishAllListeners()
+ expect(logic.values.detailData?.content.kind).toBe('error')
+
+ logic.actions[select]('span-1')
+ await expectLogic(logic).toFinishAllListeners()
+
+ expect(nodeRequests.filter((nodeId) => nodeId === 'span-1')).toHaveLength(2)
+ expect(logic.values.detailData?.content.kind).toBe('io')
+ }
+ )
+
it('selecting from the thread or timeline switches to spans', async () => {
+ mountAt()
+ await expectLogic(logic).toFinishAllListeners()
logic.actions.setMode('timeline')
+
await expectLogic(logic, () => logic.actions.selectAndShowSpans('gen-1')).toMatchValues({
mode: 'spans',
selectedNodeId: 'gen-1',
@@ -114,30 +212,13 @@ describe('traceViewAdapterLogic', () => {
})
it.each([
- ['gen-2', 'a generation whose messages the thread carries', true],
- ['span-1', 'a span the thread never mentions', false],
+ ['gen-2', 'the thread node', true],
+ ['trace-1', 'the root', true],
+ ['span-1', 'a span outside the thread', false],
])('canViewInThread for %s (%s) is %s', async (nodeId, _description, expected) => {
- await expectLogic(logic, () => logic.actions.selectNode(nodeId)).toMatchValues({ canViewInThread: expected })
- })
+ mountAt()
+ await expectLogic(logic).toFinishAllListeners()
- it('clears a search query left over from a shared legacy URL, so it does not silently filter the tree, and keeps the other params', async () => {
- router.actions.push(
- urls.aiObservabilityTrace('trace-1', {
- search: 'does-not-match-anything',
- event: 'gen-2',
- line: '4',
- back_to: 'generations',
- date_from: '-7d',
- })
- )
- remount()
-
- await expectLogic(logic).toFinishAllListeners().toMatchValues({ status: 'ready' })
- expect(router.values.searchParams).toEqual({
- event: 'gen-2',
- line: 4,
- back_to: 'generations',
- date_from: '-7d',
- })
+ await expectLogic(logic, () => logic.actions.selectNode(nodeId)).toMatchValues({ canViewInThread: expected })
})
})
diff --git a/products/ai_observability/frontend/redesign/trace/adapter/traceViewAdapterLogic.ts b/products/ai_observability/frontend/redesign/trace/adapter/traceViewAdapterLogic.ts
index 343305b60f61..43eb6fdb93ba 100644
--- a/products/ai_observability/frontend/redesign/trace/adapter/traceViewAdapterLogic.ts
+++ b/products/ai_observability/frontend/redesign/trace/adapter/traceViewAdapterLogic.ts
@@ -1,25 +1,18 @@
-import { MakeLogicType, actions, afterMount, connect, kea, key, listeners, path, props, reducers, selectors } from 'kea'
+import { MakeLogicType, actions, connect, kea, key, listeners, path, props, reducers, selectors } from 'kea'
import { router } from 'kea-router'
import { subscriptions } from 'kea-subscriptions'
import { teamLogic } from 'scenes/teamLogic'
-import { DataTableNode, LLMTrace, LLMTraceEvent } from '~/queries/schema/schema-general'
-
-import { AIData, AIDataLookup, aiObservabilityAIDataLogic } from '../../../aiObservabilityAIDataLogic'
-import { aiObservabilityTraceDataLogic } from '../../../aiObservabilityTraceDataLogic'
import { aiObservabilityTraceLogic } from '../../../aiObservabilityTraceLogic'
import { llmEvaluationsLogic } from '../../../evaluations/llmEvaluationsLogic'
import { EvaluationConfig, EvaluationRun } from '../../../evaluations/types'
-import { pickUserVisibleTurn } from '../../../extractSessionTurns'
import type { TraceNodeApi, TraceTimelineRowApi } from '../../../generated/api.schemas'
import { generationEvaluationRunsLogic } from '../../../generationEvaluationRunsLogic'
-import { isLLMEvent } from '../../../utils'
import { TraceHeaderProps } from '../components/TraceHeader'
import { TraceSummaryBarProps } from '../components/TraceSummaryBar'
import { TraceViewStatus, traceViewLogic } from '../traceViewLogic'
-import { ConversationState, LabeledLink, NodeDetailTab, TraceMode } from '../types'
-import { heavyDataLookup } from './eventIO'
+import { ConversationState, LabeledLink, NodeDetailTab, NodeLoad, TraceMode } from '../types'
import { toBackLink, toHeader } from './toHeader'
import { NodeDetailData, toNodeDetail } from './toNodeDetail'
import { toThread } from './toThread'
@@ -27,15 +20,13 @@ import { findTreeNode } from './toTraceTree'
export interface TraceViewAdapterLogicProps {
traceId: string
- query: DataTableNode
timestampHint: string | null
}
// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface traceViewAdapterLogicValues {
- aiDataCache: Record<string, AIData | null> // aiObservabilityAIDataLogic
- event: LLMTrace | LLMTraceEvent | null // aiObservabilityTraceDataLogic
- trace: LLMTrace | undefined // aiObservabilityTraceDataLogic
+ eventId: string | null // aiObservabilityTraceLogic
+ initialTab: string | null // aiObservabilityTraceLogic
newerTimestamp: string | null // aiObservabilityTraceLogic
newerTraceId: string | null // aiObservabilityTraceLogic
olderTimestamp: string | null // aiObservabilityTraceLogic
@@ -47,10 +38,16 @@ export interface traceViewAdapterLogicValues {
evaluationsSettled: boolean // llmEvaluationsLogic
searchParams: Record<string, any> // router
currentTeamId: number | null // teamLogic
+ createdAt: string | null // traceViewLogic
+ defaultNodeId: string // traceViewLogic
errorMessage: string // traceViewLogic
+ nodeIdsByAlias: Record<string, string> // traceViewLogic
+ nodes: Record<string, NodeLoad> // traceViewLogic
personLabel: string | null // traceViewLogic
+ sessionId: string | null // traceViewLogic
status: TraceViewStatus // traceViewLogic
summary: TraceSummaryBarProps | null // traceViewLogic
+ threadNodeIds: string[] // traceViewLogic
timeline: {
rows: TraceTimelineRowApi[]
totalMs: number
@@ -63,21 +60,43 @@ export interface traceViewAdapterLogicValues {
detailData: NodeDetailData | null
detailTab: NodeDetailTab
header: TraceHeaderProps
- heavyDataLookups: AIDataLookup[]
mode: TraceMode
- selectedNodeId: string | null
+ selectedNodeId: string
+ selectedNodeLoad: NodeLoad
selectedTreeNode: TraceNodeApi | null
thread: ConversationState
+ threadNodeLoad: NodeLoad | null
}
// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface traceViewAdapterLogicActions {
- ensureAIDataLoaded: (lookups: AIDataLookup[]) => {
- lookups: AIDataLookup[]
- } // aiObservabilityAIDataLogic
+ loadNeighbors: (
+ traceId: string,
+ timestamp: string
+ ) => {
+ timestamp: string
+ traceId: string
+ } // aiObservabilityTraceLogic
setEventId: (eventId: string | null) => {
eventId: string | null
} // aiObservabilityTraceLogic
+ loadNode: (
+ nodeId: string,
+ trigger: import('../types').NodeLoadTrigger
+ ) => {
+ nodeId: string
+ trigger: import('../types').NodeLoadTrigger
+ } // traceViewLogic
+ loadTraceSuccess: (
+ trace: import('../../../generated/api.schemas').TraceApi,
+ payload?: any
+ ) => {
+ payload?: any
+ trace: import('../../../generated/api.schemas').TraceApi
+ } // traceViewLogic
+ prefetchNode: (id: string) => {
+ id: string
+ }
selectAndShowSpans: (id: string) => {
id: string
}
@@ -99,8 +118,18 @@ export interface traceViewAdapterLogicActions {
export interface traceViewAdapterLogicMeta {
key: string
__keaTypeGenInternalSelectorTypes: {
- selectedNodeId: (event: LLMTrace | LLMTraceEvent | null, traceId: string) => string | null
- selectedTreeNode: (tree: TraceNodeApi[], selectedNodeId: string | null) => TraceNodeApi | null
+ selectedNodeId: (
+ eventId: string | null,
+ initialTab: string | null,
+ tree: TraceNodeApi[],
+ status: TraceViewStatus,
+ defaultNodeId: string,
+ nodeIdsByAlias: Record<string, string>,
+ traceId: string
+ ) => string
+ selectedTreeNode: (tree: TraceNodeApi[], selectedNodeId: string) => TraceNodeApi | null
+ selectedNodeLoad: (selectedNodeId: string, nodes: Record<string, NodeLoad>) => NodeLoad
+ threadNodeLoad: (threadNodeIds: string[], nodes: Record<string, NodeLoad>) => NodeLoad | null
backLink: (searchParams: Record<string, any>) => LabeledLink
header: (
traceName: string,
@@ -112,26 +141,27 @@ export interface traceViewAdapterLogicMeta {
searchParams: Record<string, any>
) => TraceHeaderProps
detailData: (
- trace: LLMTrace | undefined,
- event: LLMTrace | LLMTraceEvent | null,
- tree: TraceNodeApi[],
selectedTreeNode: TraceNodeApi | null,
- aiDataCache: Record<string, AIData | null>,
+ selectedNodeLoad: NodeLoad,
+ tree: TraceNodeApi[],
generationEvaluationRuns: EvaluationRun[],
generationEvaluationRunsLoading: boolean,
evaluations: EvaluationConfig[],
detectorEvaluationIds: string[],
evaluationsSettled: boolean,
currentTeamId: number | null,
- personLabel: string | null
+ personLabel: string | null,
+ createdAt: string | null,
+ sessionId: string | null
) => NodeDetailData | null
thread: (
- trace: LLMTrace | undefined,
- aiDataCache: Record<string, AIData | null>,
- currentTeamId: number | null
+ status: TraceViewStatus,
+ threadNodeLoad: NodeLoad | null,
+ createdAt: string | null,
+ currentTeamId: number | null,
+ traceId: string
) => ConversationState
- canViewInThread: (selectedNodeId: string | null, thread: ConversationState, traceId: string) => boolean
- heavyDataLookups: (trace: LLMTrace | undefined, event: LLMTrace | LLMTraceEvent | null) => AIDataLookup[]
+ canViewInThread: (selectedNodeId: string, threadNodeIds: string[], traceId: string) => boolean
}
}
@@ -142,6 +172,10 @@ export type traceViewAdapterLogicType = MakeLogicType<
traceViewAdapterLogicMeta
>
+const LOADING: NodeLoad = { status: 'loading' }
+// Skimming the tree with the pointer must not start a read for every row it crosses.
+const PREFETCH_DELAY_MS = 75
+
export const traceViewAdapterLogic = kea<traceViewAdapterLogicType>([
path((key) => ['products', 'ai_observability', 'frontend', 'redesign', 'trace', 'traceViewAdapterLogic', key]),
props({} as TraceViewAdapterLogicProps),
@@ -149,18 +183,24 @@ export const traceViewAdapterLogic = kea<traceViewAdapterLogicType>([
connect((props: TraceViewAdapterLogicProps) => ({
values: [
traceViewLogic({ traceId: props.traceId, timestampHint: props.timestampHint }),
- ['status', 'errorMessage', 'tree', 'summary', 'timeline', 'traceName', 'traceHasError', 'personLabel'],
+ [
+ 'status',
+ 'errorMessage',
+ 'tree',
+ 'summary',
+ 'timeline',
+ 'traceName',
+ 'traceHasError',
+ 'personLabel',
+ 'nodes',
+ 'threadNodeIds',
+ 'createdAt',
+ 'sessionId',
+ 'defaultNodeId',
+ 'nodeIdsByAlias',
+ ],
aiObservabilityTraceLogic,
- ['olderTraceId', 'olderTimestamp', 'newerTraceId', 'newerTimestamp'],
- aiObservabilityTraceDataLogic({
- traceId: props.traceId,
- query: props.query,
- cachedResults: null,
- searchQuery: '',
- }),
- ['trace', 'event'],
- aiObservabilityAIDataLogic,
- ['aiDataCache'],
+ ['eventId', 'initialTab', 'olderTraceId', 'olderTimestamp', 'newerTraceId', 'newerTimestamp'],
generationEvaluationRunsLogic({ traceId: props.traceId }),
['generationEvaluationRuns', 'generationEvaluationRunsLoading'],
teamLogic,
@@ -170,7 +210,12 @@ export const traceViewAdapterLogic = kea<traceViewAdapterLogicType>([
router,
['searchParams'],
],
- actions: [aiObservabilityTraceLogic, ['setEventId'], aiObservabilityAIDataLogic, ['ensureAIDataLoaded']],
+ actions: [
+ aiObservabilityTraceLogic,
+ ['setEventId', 'loadNeighbors'],
+ traceViewLogic({ traceId: props.traceId, timestampHint: props.timestampHint }),
+ ['loadNode', 'loadTraceSuccess'],
+ ],
})),
actions({
setMode: (mode: TraceMode) => ({ mode }),
@@ -178,6 +223,7 @@ export const traceViewAdapterLogic = kea<traceViewAdapterLogicType>([
selectNode: (id: string) => ({ id }),
selectAndShowSpans: (id: string) => ({ id }),
viewInThread: true,
+ prefetchNode: (id: string) => ({ id }),
}),
reducers({
mode: [
@@ -192,14 +238,42 @@ export const traceViewAdapterLogic = kea<traceViewAdapterLogicType>([
}),
selectors({
selectedNodeId: [
- (s, p) => [s.event, p.traceId],
- (event: LLMTrace | LLMTraceEvent | null, traceId: string): string | null =>
- event ? (isLLMEvent(event) ? event.id : traceId) : null,
+ (s, p) => [s.eventId, s.initialTab, s.tree, s.status, s.defaultNodeId, s.nodeIdsByAlias, p.traceId],
+ (
+ eventId: string | null,
+ initialTab: string | null,
+ tree: TraceNodeApi[],
+ status: TraceViewStatus,
+ defaultNodeId: string,
+ nodeIdsByAlias: Record<string, string>,
+ traceId: string
+ ): string => {
+ if (status !== 'ready') {
+ return eventId ?? traceId
+ }
+ if (!eventId) {
+ // Trace-level links from clusters and sessions ask for the trace itself with tab=summary.
+ return initialTab === 'summary' ? traceId : defaultNodeId
+ }
+ if (findTreeNode(tree, eventId)) {
+ return eventId
+ }
+ return nodeIdsByAlias[eventId] ?? traceId
+ },
],
selectedTreeNode: [
(s) => [s.tree, s.selectedNodeId],
- (tree: TraceNodeApi[], selectedNodeId: string | null): TraceNodeApi | null =>
- selectedNodeId ? findTreeNode(tree, selectedNodeId) : null,
+ (tree: TraceNodeApi[], selectedNodeId: string): TraceNodeApi | null => findTreeNode(tree, selectedNodeId),
+ ],
+ // Each consumer reads its own node load, so a prefetch of another node does not rebuild its heavy messages.
+ selectedNodeLoad: [
+ (s) => [s.selectedNodeId, s.nodes],
+ (selectedNodeId: string, nodes: Record<string, NodeLoad>): NodeLoad => nodes[selectedNodeId] ?? LOADING,
+ ],
+ threadNodeLoad: [
+ (s) => [s.threadNodeIds, s.nodes],
+ (threadNodeIds: string[], nodes: Record<string, NodeLoad>): NodeLoad | null =>
+ threadNodeIds[0] ? (nodes[threadNodeIds[0]] ?? LOADING) : null,
],
backLink: [
(s) => [s.searchParams],
@@ -232,11 +306,9 @@ export const traceViewAdapterLogic = kea<traceViewAdapterLogicType>([
],
detailData: [
(s) => [
- s.trace,
- s.event,
- s.tree,
s.selectedTreeNode,
- s.aiDataCache,
+ s.selectedNodeLoad,
+ s.tree,
s.generationEvaluationRuns,
s.generationEvaluationRunsLoading,
s.evaluations,
@@ -244,28 +316,28 @@ export const traceViewAdapterLogic = kea<traceViewAdapterLogicType>([
s.evaluationsSettled,
s.currentTeamId,
s.personLabel,
+ s.createdAt,
+ s.sessionId,
],
(
- trace: LLMTrace | undefined,
- event: LLMTrace | LLMTraceEvent | null,
- tree: TraceNodeApi[],
node: TraceNodeApi | null,
- cache: Record<string, AIData | null>,
+ load: NodeLoad,
+ tree: TraceNodeApi[],
evalRuns: EvaluationRun[],
evalRunsLoading: boolean,
evaluations: EvaluationConfig[],
detectorEvaluationIds: string[],
evaluationsSettled: boolean,
teamId: number | null,
- person: string | null
+ person: string | null,
+ createdAt: string | null,
+ sessionId: string | null
): NodeDetailData | null =>
- trace && event && node
+ node && createdAt
? toNodeDetail({
- trace,
- event,
- tree,
node,
- cache,
+ load,
+ tree,
evalRuns,
evalRunsLoading,
evaluations,
@@ -273,62 +345,50 @@ export const traceViewAdapterLogic = kea<traceViewAdapterLogicType>([
evaluationsSettled,
teamId,
person,
+ trace: { createdAt, sessionId },
})
: null,
],
thread: [
- (s) => [s.trace, s.aiDataCache, s.currentTeamId],
+ (s, p) => [s.status, s.threadNodeLoad, s.createdAt, s.currentTeamId, p.traceId],
(
- trace: LLMTrace | undefined,
- cache: Record<string, AIData | null>,
- teamId: number | null
- ): ConversationState => (trace ? toThread(trace, cache, teamId) : { status: 'loading' }),
- ],
- canViewInThread: [
- (s, p) => [s.selectedNodeId, s.thread, p.traceId],
- (selectedNodeId: string | null, thread: ConversationState, traceId: string): boolean => {
- if (!selectedNodeId) {
- return false
- }
- if (selectedNodeId === traceId) {
- return true
+ status: TraceViewStatus,
+ load: NodeLoad | null,
+ createdAt: string | null,
+ teamId: number | null,
+ traceId: string
+ ): ConversationState => {
+ if (status !== 'ready' || !createdAt) {
+ return { status: 'loading' }
}
- const turnMessages = thread.status === 'ready' ? (thread.turns[0]?.messages ?? []) : []
- return turnMessages.some((message) => message.sourceNodeId === selectedNodeId)
+ return toThread({ traceId, createdAt, load, teamId })
},
],
- heavyDataLookups: [
- (s) => [s.trace, s.event],
- (trace: LLMTrace | undefined, event: LLMTrace | LLMTraceEvent | null): AIDataLookup[] => {
- if (!trace) {
- return []
- }
- const candidates = [event && isLLMEvent(event) ? event : null, pickUserVisibleTurn(trace) ?? null]
- return candidates
- .map((candidate) => (candidate ? heavyDataLookup(candidate, trace.id) : null))
- .filter((lookup): lookup is AIDataLookup => lookup !== null)
- },
+ canViewInThread: [
+ (s, p) => [s.selectedNodeId, s.threadNodeIds, p.traceId],
+ (selectedNodeId: string, threadNodeIds: string[], traceId: string): boolean =>
+ selectedNodeId === traceId || threadNodeIds.includes(selectedNodeId),
],
}),
- listeners(({ actions }) => ({
- selectNode: ({ id }) => actions.setEventId(id),
- selectAndShowSpans: ({ id }) => actions.setEventId(id),
- })),
- subscriptions(({ actions }) => ({
- heavyDataLookups: (lookups: AIDataLookup[]) => {
- if (lookups.length > 0) {
- actions.ensureAIDataLoaded(lookups)
- }
- },
- })),
- afterMount(() => {
- // The legacy scene writes a `search` param into shared trace links. This view has no
- // search UI, so without clearing it the tree silently filters down to whatever the
- // stale query matched. Removing only that param keeps every other permalink param, and
- // the legacy trace logic reads the new URL and clears its search query.
- const { search, ...searchParams } = router.values.searchParams
- if (search !== undefined) {
- router.actions.replace(router.values.location.pathname, searchParams, router.values.hashParams)
+ listeners(({ actions, props }) => {
+ // The click's read starts before the selection moves, so the selectedNodeId subscription's navigation read
+ // for the same id is deduped and the load event reports a click. Selecting the node that is already
+ // selected changes no value and the subscription does not fire, so this read also retries a failed node.
+ const select = ({ id }: { id: string }): void => {
+ actions.loadNode(id, 'selection')
+ actions.setEventId(id)
+ }
+ return {
+ selectNode: select,
+ selectAndShowSpans: select,
+ prefetchNode: async ({ id }, breakpoint) => {
+ await breakpoint(PREFETCH_DELAY_MS)
+ actions.loadNode(id, 'prefetch')
+ },
+ loadTraceSuccess: ({ trace }) => actions.loadNeighbors(props.traceId, trace.createdAt),
}
}),
+ subscriptions(({ actions }) => ({
+ selectedNodeId: (selectedNodeId: string) => actions.loadNode(selectedNodeId, 'navigation'),
+ })),
])
diff --git a/products/ai_observability/frontend/redesign/trace/components/NodeDetail.stories.tsx b/products/ai_observability/frontend/redesign/trace/components/NodeDetail.stories.tsx
index af38a59a37bf..e4b290fe671b 100644
--- a/products/ai_observability/frontend/redesign/trace/components/NodeDetail.stories.tsx
+++ b/products/ai_observability/frontend/redesign/trace/components/NodeDetail.stories.tsx
@@ -62,7 +62,20 @@ export const LoadingContent: Story = {
parameters: { testOptions: { waitForLoadersToDisappear: false } },
}
export const ContentLoadError: Story = {
- args: { ...base, content: { kind: 'error', message: 'This step could not be loaded. Try again later.' } },
+ args: { ...base, content: { kind: 'error', message: 'This step could not be loaded. Select it again to retry.' } },
+}
+export const ContentNotFound: Story = {
+ args: {
+ ...base,
+ content: {
+ kind: 'error',
+ message: 'This step could not be found. It may have been deleted, or it is outside the retention period.',
+ },
+ },
+}
+export const RawTabWhileLoading: Story = {
+ args: { ...base, content: { kind: 'loading' }, initialTab: 'raw' },
+ parameters: { testOptions: { waitForLoadersToDisappear: false } },
}
export const WithError: Story = {
args: {
diff --git a/products/ai_observability/frontend/redesign/trace/components/NodeDetail.tsx b/products/ai_observability/frontend/redesign/trace/components/NodeDetail.tsx
index 1a20ed6c267b..f0cb37a468ac 100644
--- a/products/ai_observability/frontend/redesign/trace/components/NodeDetail.tsx
+++ b/products/ai_observability/frontend/redesign/trace/components/NodeDetail.tsx
@@ -1,7 +1,8 @@
-import { LemonTabs } from '@posthog/lemon-ui'
+import { LemonSkeleton, LemonTabs } from '@posthog/lemon-ui'
import type { TraceNodeApi } from '../../../generated/api.schemas'
import { EvalsState, NodeContent, NodeDetailTab, NodeProperties } from '../types'
+import { ErrorCallout } from './ErrorCallout'
import { EvalResultList } from './EvalResultList'
import { NodeDetailHeader } from './NodeDetailHeader'
import { NodeMessagesTab } from './NodeMessagesTab'
@@ -16,7 +17,7 @@ export interface NodeDetailProps {
error: string | null
properties: NodeProperties
evals: EvalsState
- raw: Record<string, unknown>
+ raw: Record<string, unknown> | null
onViewInThread: (() => void) | null
onSelectNode: (nodeId: string) => void
}
@@ -59,7 +60,14 @@ export function NodeDetail(props: NodeDetailProps): JSX.Element {
key: 'raw',
label: 'Raw',
'data-attr': 'trace-view-detail-tab-raw',
- content: <NodeRawTab raw={props.raw} />,
+ content:
+ props.content.kind === 'loading' ? (
+ <LemonSkeleton repeat={3} className="h-16" />
+ ) : props.content.kind === 'error' ? (
+ <ErrorCallout message={props.content.message} />
+ ) : (
+ <NodeRawTab raw={props.raw} />
+ ),
},
]}
/>
diff --git a/products/ai_observability/frontend/redesign/trace/components/NodePropertyList.tsx b/products/ai_observability/frontend/redesign/trace/components/NodePropertyList.tsx
index e654ad620e21..b64cda373e75 100644
--- a/products/ai_observability/frontend/redesign/trace/components/NodePropertyList.tsx
+++ b/products/ai_observability/frontend/redesign/trace/components/NodePropertyList.tsx
@@ -17,7 +17,7 @@ export interface NodePropertyListProps {
export function NodePropertyList({ node, properties }: NodePropertyListProps): JSX.Element {
const { stats } = node
- const time = (
+ const time = properties.timestamp ? (
<TZLabel
time={properties.timestamp}
timestampStyle="absolute"
@@ -26,7 +26,7 @@ export function NodePropertyList({ node, properties }: NodePropertyListProps): J
showSeconds
className="font-mono"
/>
- )
+ ) : null
const tokens = formatTokenCounts(stats.inputTokens, stats.outputTokens) ?? UNKNOWN_VALUE
const cache = formatCacheTokens(stats.cacheReadTokens, stats.cacheWriteTokens)
const latency = stats.latencyMs !== null ? formatLatencyMs(stats.latencyMs) : UNKNOWN_VALUE
diff --git a/products/ai_observability/frontend/redesign/trace/components/NodeRawTab.stories.tsx b/products/ai_observability/frontend/redesign/trace/components/NodeRawTab.stories.tsx
index 491dac715328..ba1d62bc22df 100644
--- a/products/ai_observability/frontend/redesign/trace/components/NodeRawTab.stories.tsx
+++ b/products/ai_observability/frontend/redesign/trace/components/NodeRawTab.stories.tsx
@@ -17,3 +17,5 @@ export const Default: StoryObj<typeof NodeRawTab> = {
},
},
}
+
+export const NoTraceEvent: StoryObj<typeof NodeRawTab> = { args: { raw: null } }
diff --git a/products/ai_observability/frontend/redesign/trace/components/NodeRawTab.tsx b/products/ai_observability/frontend/redesign/trace/components/NodeRawTab.tsx
index 2ccb3f7ea15a..8ca6184ea88b 100644
--- a/products/ai_observability/frontend/redesign/trace/components/NodeRawTab.tsx
+++ b/products/ai_observability/frontend/redesign/trace/components/NodeRawTab.tsx
@@ -1,10 +1,18 @@
import { JSONViewer } from 'lib/components/JSONViewer'
export interface NodeRawTabProps {
- raw: Record<string, unknown>
+ raw: Record<string, unknown> | null
}
export function NodeRawTab({ raw }: NodeRawTabProps): JSX.Element {
+ if (!raw) {
+ return (
+ <p className="m-0 text-secondary">
+ This trace has no event of its own, so there is no raw event to show. Select a step to see its raw
+ event.
+ </p>
+ )
+ }
return (
<div className="overflow-auto rounded border border-primary bg-surface-primary p-2">
<JSONViewer src={raw} name={null} collapsed={2} sortKeys />
diff --git a/products/ai_observability/frontend/redesign/trace/components/Thread.stories.tsx b/products/ai_observability/frontend/redesign/trace/components/Thread.stories.tsx
index 18bc8eba9916..e367382fd49c 100644
--- a/products/ai_observability/frontend/redesign/trace/components/Thread.stories.tsx
+++ b/products/ai_observability/frontend/redesign/trace/components/Thread.stories.tsx
@@ -25,6 +25,15 @@ export const Loading: Story = {
decorators: [withWidth(720)],
parameters: { testOptions: { waitForLoadersToDisappear: false } },
}
+export const LoadError: Story = {
+ args: {
+ conversation: {
+ status: 'error',
+ message: 'The conversation could not be loaded. Reload the page to try again.',
+ },
+ },
+ decorators: [withWidth(720)],
+}
export const Empty: Story = { args: ready([{ ...FIXTURE_TURN, messages: [] }]) }
export const SystemOnly: Story = { args: ready([{ ...FIXTURE_TURN, messages: [FIXTURE_GENERATION_MESSAGES[0]] }]) }
export const ErrorWithoutMessages: Story = {
diff --git a/products/ai_observability/frontend/redesign/trace/components/Thread.tsx b/products/ai_observability/frontend/redesign/trace/components/Thread.tsx
index cc385f0c0070..a4ffd8fa3dc7 100644
--- a/products/ai_observability/frontend/redesign/trace/components/Thread.tsx
+++ b/products/ai_observability/frontend/redesign/trace/components/Thread.tsx
@@ -2,6 +2,7 @@ import { LemonSkeleton } from '@posthog/lemon-ui'
import { ConversationState } from '../types'
import { conversationalMessages } from './conversationalMessages'
+import { ErrorCallout } from './ErrorCallout'
import { ThreadTurn } from './ThreadTurn'
export interface ThreadProps {
@@ -19,6 +20,9 @@ export function Thread({ conversation, onSelectMessage }: ThreadProps): JSX.Elem
</div>
)
}
+ if (conversation.status === 'error') {
+ return <ErrorCallout message={conversation.message} />
+ }
const { turns, activeTurnId } = conversation
if (turns.every((turn) => conversationalMessages(turn.messages).length === 0 && !turn.error)) {
return (
diff --git a/products/ai_observability/frontend/redesign/trace/components/TimelineRow.tsx b/products/ai_observability/frontend/redesign/trace/components/TimelineRow.tsx
index 5174a14f069e..fbe16360a2cd 100644
--- a/products/ai_observability/frontend/redesign/trace/components/TimelineRow.tsx
+++ b/products/ai_observability/frontend/redesign/trace/components/TimelineRow.tsx
@@ -19,15 +19,18 @@ export interface TimelineRowProps {
ticks: TimelineTick[]
isSelected: boolean
onSelect: () => void
+ onPrefetch: () => void
}
-export function TimelineRow({ row, totalMs, ticks, isSelected, onSelect }: TimelineRowProps): JSX.Element {
+export function TimelineRow({ row, totalMs, ticks, isSelected, onSelect, onPrefetch }: TimelineRowProps): JSX.Element {
const { leftPercent, widthPercent } = timelineBarGeometry(row.startMs, row.durationMs ?? 0, totalMs)
const barColors = row.hasError ? ERROR_BAR_COLORS : NODE_KIND_COLORS[row.kind]
return (
<button
type="button"
onClick={onSelect}
+ onMouseEnter={onPrefetch}
+ onFocus={onPrefetch}
data-attr="trace-view-timeline-row"
className={cn(
'grid w-full items-center border-b border-primary text-left hover:bg-fill-button-tertiary-hover',
diff --git a/products/ai_observability/frontend/redesign/trace/components/TraceSplitView.stories.tsx b/products/ai_observability/frontend/redesign/trace/components/TraceSplitView.stories.tsx
index 4b671731261b..dc51b5275a82 100644
--- a/products/ai_observability/frontend/redesign/trace/components/TraceSplitView.stories.tsx
+++ b/products/ai_observability/frontend/redesign/trace/components/TraceSplitView.stories.tsx
@@ -19,6 +19,7 @@ const meta: Meta<typeof TraceSplitView> = {
tree: FIXTURE_TREE,
selectedNodeId: generation.id,
onSelectNode: () => {},
+ onPrefetchNode: () => {},
detail: {
node: generation,
tab: 'messages',
diff --git a/products/ai_observability/frontend/redesign/trace/components/TraceSplitView.tsx b/products/ai_observability/frontend/redesign/trace/components/TraceSplitView.tsx
index 66287768f7ba..8df6d36ee2d2 100644
--- a/products/ai_observability/frontend/redesign/trace/components/TraceSplitView.tsx
+++ b/products/ai_observability/frontend/redesign/trace/components/TraceSplitView.tsx
@@ -6,15 +6,27 @@ export interface TraceSplitViewProps {
tree: TraceNodeApi[]
selectedNodeId: string | null
onSelectNode: (id: string) => void
+ onPrefetchNode: (id: string) => void
detail: Omit<NodeDetailProps, 'onSelectNode'> | null
}
-export function TraceSplitView({ tree, selectedNodeId, onSelectNode, detail }: TraceSplitViewProps): JSX.Element {
+export function TraceSplitView({
+ tree,
+ selectedNodeId,
+ onSelectNode,
+ onPrefetchNode,
+ detail,
+}: TraceSplitViewProps): JSX.Element {
return (
<div className="@container">
<div className="flex flex-col gap-4 @3xl:flex-row @3xl:items-start">
<aside className="w-full shrink-0 @3xl:w-72">
- <TraceTree nodes={tree} selectedNodeId={selectedNodeId} onSelectNode={onSelectNode} />
+ <TraceTree
+ nodes={tree}
+ selectedNodeId={selectedNodeId}
+ onSelectNode={onSelectNode}
+ onPrefetchNode={onPrefetchNode}
+ />
</aside>
<div className="min-w-0 flex-1 @3xl:sticky @3xl:top-[var(--scene-title-section-height,50px)] @3xl:max-h-[calc(100vh-var(--scene-title-section-height,50px))] @3xl:overflow-y-auto">
{detail ? (
diff --git a/products/ai_observability/frontend/redesign/trace/components/TraceTimeline.stories.tsx b/products/ai_observability/frontend/redesign/trace/components/TraceTimeline.stories.tsx
index 682651b3daea..15fd6c4be9c3 100644
--- a/products/ai_observability/frontend/redesign/trace/components/TraceTimeline.stories.tsx
+++ b/products/ai_observability/frontend/redesign/trace/components/TraceTimeline.stories.tsx
@@ -9,7 +9,13 @@ import { TraceTimeline } from './TraceTimeline'
const meta: Meta<typeof TraceTimeline> = {
title: 'Scenes-App/AI observability/Trace view/Trace timeline',
component: TraceTimeline,
- args: { rows: FIXTURE_TIMELINE_ROWS, totalMs: 2310, selectedNodeId: 'gen-answer', onSelectNode: () => {} },
+ args: {
+ rows: FIXTURE_TIMELINE_ROWS,
+ totalMs: 2310,
+ selectedNodeId: 'gen-answer',
+ onSelectNode: () => {},
+ onPrefetchNode: () => {},
+ },
}
export default meta
diff --git a/products/ai_observability/frontend/redesign/trace/components/TraceTimeline.tsx b/products/ai_observability/frontend/redesign/trace/components/TraceTimeline.tsx
index 287d17540b7c..24ac221628ba 100644
--- a/products/ai_observability/frontend/redesign/trace/components/TraceTimeline.tsx
+++ b/products/ai_observability/frontend/redesign/trace/components/TraceTimeline.tsx
@@ -10,9 +10,16 @@ export interface TraceTimelineProps {
totalMs: number
selectedNodeId: string | null
onSelectNode: (id: string) => void
+ onPrefetchNode: (id: string) => void
}
-export function TraceTimeline({ rows, totalMs, selectedNodeId, onSelectNode }: TraceTimelineProps): JSX.Element {
+export function TraceTimeline({
+ rows,
+ totalMs,
+ selectedNodeId,
+ onSelectNode,
+ onPrefetchNode,
+}: TraceTimelineProps): JSX.Element {
if (rows.length === 0) {
return <p className="m-0 text-secondary">This trace has no timed steps.</p>
}
@@ -31,6 +38,7 @@ export function TraceTimeline({ rows, totalMs, selectedNodeId, onSelectNode }: T
ticks={ticks}
isSelected={row.id === selectedNodeId}
onSelect={() => onSelectNode(row.id)}
+ onPrefetch={() => onPrefetchNode(row.id)}
/>
))}
</div>
diff --git a/products/ai_observability/frontend/redesign/trace/components/TraceTree.stories.tsx b/products/ai_observability/frontend/redesign/trace/components/TraceTree.stories.tsx
index 6f75424c0972..80657ebe6ef9 100644
--- a/products/ai_observability/frontend/redesign/trace/components/TraceTree.stories.tsx
+++ b/products/ai_observability/frontend/redesign/trace/components/TraceTree.stories.tsx
@@ -14,7 +14,7 @@ function Stateful({
initialSelectedId?: string
}): JSX.Element {
const [selected, setSelected] = useState<string | null>(initialSelectedId)
- return <TraceTree nodes={nodes} selectedNodeId={selected} onSelectNode={setSelected} />
+ return <TraceTree nodes={nodes} selectedNodeId={selected} onSelectNode={setSelected} onPrefetchNode={() => {}} />
}
const meta: Meta<typeof Stateful> = {
diff --git a/products/ai_observability/frontend/redesign/trace/components/TraceTree.tsx b/products/ai_observability/frontend/redesign/trace/components/TraceTree.tsx
index b66a6afb1817..fbee84640593 100644
--- a/products/ai_observability/frontend/redesign/trace/components/TraceTree.tsx
+++ b/products/ai_observability/frontend/redesign/trace/components/TraceTree.tsx
@@ -5,9 +5,10 @@ export interface TraceTreeProps {
nodes: TraceNodeApi[]
selectedNodeId: string | null
onSelectNode: (id: string) => void
+ onPrefetchNode: (id: string) => void
}
-export function TraceTree({ nodes, selectedNodeId, onSelectNode }: TraceTreeProps): JSX.Element {
+export function TraceTree({ nodes, selectedNodeId, onSelectNode, onPrefetchNode }: TraceTreeProps): JSX.Element {
return (
<ul aria-label="Trace steps" className="m-0 list-none rounded border border-primary bg-surface-primary p-1">
{nodes.map((node) => (
@@ -17,6 +18,7 @@ export function TraceTree({ nodes, selectedNodeId, onSelectNode }: TraceTreeProp
depth={0}
selectedNodeId={selectedNodeId}
onSelectNode={onSelectNode}
+ onPrefetchNode={onPrefetchNode}
/>
))}
</ul>
diff --git a/products/ai_observability/frontend/redesign/trace/components/TraceTreeRow.tsx b/products/ai_observability/frontend/redesign/trace/components/TraceTreeRow.tsx
index f6ae347fcea4..6f3bfc939c50 100644
--- a/products/ai_observability/frontend/redesign/trace/components/TraceTreeRow.tsx
+++ b/products/ai_observability/frontend/redesign/trace/components/TraceTreeRow.tsx
@@ -11,15 +11,24 @@ export interface TraceTreeRowProps {
depth: number
selectedNodeId: string | null
onSelectNode: (id: string) => void
+ onPrefetchNode: (id: string) => void
}
-export function TraceTreeRow({ node, depth, selectedNodeId, onSelectNode }: TraceTreeRowProps): JSX.Element {
+export function TraceTreeRow({
+ node,
+ depth,
+ selectedNodeId,
+ onSelectNode,
+ onPrefetchNode,
+}: TraceTreeRowProps): JSX.Element {
const isSelected = node.id === selectedNodeId
return (
<li>
<button
type="button"
onClick={() => onSelectNode(node.id)}
+ onMouseEnter={() => onPrefetchNode(node.id)}
+ onFocus={() => onPrefetchNode(node.id)}
aria-current={isSelected ? 'true' : undefined}
data-attr="trace-view-tree-node"
className={cn(
@@ -53,6 +62,7 @@ export function TraceTreeRow({ node, depth, selectedNodeId, onSelectNode }: Trac
depth={depth + 1}
selectedNodeId={selectedNodeId}
onSelectNode={onSelectNode}
+ onPrefetchNode={onPrefetchNode}
/>
))}
</ul>
diff --git a/products/ai_observability/frontend/redesign/trace/components/TraceView.stories.tsx b/products/ai_observability/frontend/redesign/trace/components/TraceView.stories.tsx
index d20ce9d61d66..29b18ad5498f 100644
--- a/products/ai_observability/frontend/redesign/trace/components/TraceView.stories.tsx
+++ b/products/ai_observability/frontend/redesign/trace/components/TraceView.stories.tsx
@@ -69,6 +69,7 @@ function Playground({ fixture, initialMode, initialNodeId }: PlaygroundProps): J
tree={fixture.tree}
selectedNodeId={selectedNodeId}
onSelectNode={setSelectedNodeId}
+ onPrefetchNode={() => {}}
onSelectFromView={selectAndShowSpans}
detail={{
...fixture.details[node.id],
diff --git a/products/ai_observability/frontend/redesign/trace/components/TraceView.tsx b/products/ai_observability/frontend/redesign/trace/components/TraceView.tsx
index 935f0cbbf42a..c00c1c14554a 100644
--- a/products/ai_observability/frontend/redesign/trace/components/TraceView.tsx
+++ b/products/ai_observability/frontend/redesign/trace/components/TraceView.tsx
@@ -18,6 +18,7 @@ export interface TraceViewReadyProps {
tree: TraceNodeApi[]
selectedNodeId: string | null
onSelectNode: (id: string) => void
+ onPrefetchNode: (id: string) => void
onSelectFromView: (id: string) => void
detail: Omit<NodeDetailProps, 'onSelectNode'> | null
thread: ConversationState
@@ -46,6 +47,7 @@ export function TraceView(props: TraceViewProps): JSX.Element {
tree={props.tree}
selectedNodeId={props.selectedNodeId}
onSelectNode={props.onSelectNode}
+ onPrefetchNode={props.onPrefetchNode}
detail={props.detail}
/>
) : props.mode === 'thread' ? (
@@ -56,6 +58,7 @@ export function TraceView(props: TraceViewProps): JSX.Element {
totalMs={props.timeline.totalMs}
selectedNodeId={props.selectedNodeId}
onSelectNode={props.onSelectFromView}
+ onPrefetchNode={props.onPrefetchNode}
/>
)}
</div>
diff --git a/products/ai_observability/frontend/redesign/trace/traceViewLogic.test.ts b/products/ai_observability/frontend/redesign/trace/traceViewLogic.test.ts
index bae776039574..f33d88d23bcb 100644
--- a/products/ai_observability/frontend/redesign/trace/traceViewLogic.test.ts
+++ b/products/ai_observability/frontend/redesign/trace/traceViewLogic.test.ts
@@ -1,23 +1,67 @@
import { expectLogic } from 'kea-test-utils'
+import posthog from 'posthog-js'
import { resumeKeaLoadersErrors, silenceKeaLoadersErrors } from '~/initKea'
import { useMocks } from '~/mocks/jest'
import { initKeaTests } from '~/test/init'
-import { makeTraceResource } from './adapter/testFixtures'
+import type { TraceTimelineRowApi } from '../../generated/api.schemas'
+import { decodeIdSegment, makeNodeDetail, makeTraceResource } from './adapter/testFixtures'
import { traceViewLogic } from './traceViewLogic'
const TRACE_URL = '/api/projects/:team_id/ai_observability/traces/:id/'
+const NODE_URL = '/api/projects/:team_id/ai_observability/traces/:id/nodes/:node_id/'
+const EXPIRED_ROW: TraceTimelineRowApi = {
+ id: 'expired-1',
+ kind: 'span',
+ name: 'expired-1',
+ depth: 0,
+ startMs: 0,
+ durationMs: null,
+ hasError: false,
+}
+
+function deferred(): { promise: Promise<void>; resolve: () => void } {
+ let resolve = (): void => {}
+ const promise = new Promise<void>((done) => {
+ resolve = done
+ })
+ return { promise, resolve }
+}
describe('traceViewLogic', () => {
let requestedHint: string | null = null
let requestedPath: string | null = null
+ let nodeRequests: string[] = []
+ let nodeHints: (string | null)[] = []
+ let nodeStatus = 200
+ let nodeGate: Promise<void> = Promise.resolve()
+ let firstNodeAnswer = deferred()
beforeEach(() => {
requestedHint = null
requestedPath = null
+ nodeRequests = []
+ nodeHints = []
+ nodeStatus = 200
+ nodeGate = Promise.resolve()
+ firstNodeAnswer = deferred()
useMocks({
get: {
+ // `expired-*` ids stand for nodes of a trace past the ai_events retention: the backend only finds
+ // them when the read carries a timestamp hint.
+ [NODE_URL]: async ({ request, params }) => {
+ const nodeId = decodeIdSegment(String(params.node_id))
+ const hint = new URL(request.url).searchParams.get('timestamp_hint')
+ nodeRequests.push(nodeId)
+ nodeHints.push(hint)
+ await nodeGate
+ firstNodeAnswer.resolve()
+ if (nodeId.startsWith('expired-') && !hint) {
+ return [404, { detail: 'Node not found.' }]
+ }
+ return nodeStatus === 200 ? [200, makeNodeDetail({ id: nodeId })] : [nodeStatus, { detail: 'nope' }]
+ },
[TRACE_URL]: ({ request }) => {
const url = new URL(request.url)
requestedHint = url.searchParams.get('timestamp_hint')
@@ -29,7 +73,17 @@ describe('traceViewLogic', () => {
initKeaTests()
})
- afterEach(resumeKeaLoadersErrors)
+ afterEach(() => {
+ resumeKeaLoadersErrors()
+ jest.restoreAllMocks()
+ })
+
+ async function mountedLogic(): Promise<ReturnType<typeof traceViewLogic.build>> {
+ const logic = traceViewLogic({ traceId: 'trace-1', timestampHint: null })
+ logic.mount()
+ await expectLogic(logic).toFinishAllListeners()
+ return logic
+ }
it('loads the trace by its encoded id with the link timestamp as the hint and derives the summary', async () => {
const logic = traceViewLogic({ traceId: 'a/b', timestampHint: '2026-09-01T10:15:00Z' })
@@ -59,4 +113,231 @@ describe('traceViewLogic', () => {
.toFinishAllListeners()
.toMatchValues({ status: 'error', errorMessage: expectedMessage })
})
+
+ it('loads the thread nodes once the trace arrives', async () => {
+ const logic = await mountedLogic()
+
+ expect(nodeRequests).toEqual(['gen-2'])
+ expect(logic.values.nodes['gen-2']).toMatchObject({ status: 'ready' })
+ })
+
+ it('reads each node once, however many times it is asked for', async () => {
+ const logic = await mountedLogic()
+
+ logic.actions.loadNode('span-1', 'prefetch')
+ logic.actions.loadNode('span-1', 'selection')
+ await expectLogic(logic).toFinishAllListeners()
+ logic.actions.loadNode('span-1', 'selection')
+ await expectLogic(logic).toFinishAllListeners()
+
+ expect(nodeRequests.filter((id) => id === 'span-1')).toHaveLength(1)
+ })
+
+ it.each([
+ ['a later prefetch once the first one is answered', 'prefetch', 200],
+ ['a later prefetch once the first one fails', 'prefetch', 500],
+ ['a selection while the first one is in flight', 'selection', 200],
+ ] as const)(
+ 'drops a prefetch while another is in flight, then reads the node for %s',
+ async (_description, trigger, firstStatus) => {
+ const logic = await mountedLogic()
+ const firstPrefetch = deferred()
+ nodeGate = firstPrefetch.promise
+ nodeStatus = firstStatus
+ nodeRequests = []
+
+ logic.actions.loadNode('span-1', 'prefetch')
+ logic.actions.loadNode('gen-1', 'prefetch')
+ expect(logic.values.nodes['gen-1']).toBeUndefined()
+
+ if (trigger === 'prefetch') {
+ firstPrefetch.resolve()
+ await expectLogic(logic).toFinishAllListeners()
+ }
+ logic.actions.loadNode('gen-1', trigger)
+ firstPrefetch.resolve()
+ await expectLogic(logic).toFinishAllListeners()
+
+ expect([...nodeRequests].sort()).toEqual(['gen-1', 'span-1'])
+ }
+ )
+
+ it.each([
+ [404, 'not_found'],
+ [500, 'failed'],
+ ])('a node read answered with %s fails as %s', async (status, failure) => {
+ const logic = await mountedLogic()
+ nodeStatus = status
+
+ logic.actions.loadNode('span-1', 'selection')
+ await expectLogic(logic).toFinishAllListeners()
+
+ expect(logic.values.nodes['span-1']).toEqual({ status: 'error', failure })
+ })
+
+ it.each(['selection', 'navigation'] as const)(
+ 'retries a failed node on a %s but not on a prefetch',
+ async (trigger) => {
+ const logic = await mountedLogic()
+ nodeStatus = 500
+ logic.actions.loadNode('span-1', trigger)
+ await expectLogic(logic).toFinishAllListeners()
+ nodeStatus = 200
+
+ logic.actions.loadNode('span-1', 'prefetch')
+ await expectLogic(logic).toFinishAllListeners()
+ expect(logic.values.nodes['span-1']).toMatchObject({ status: 'error' })
+
+ logic.actions.loadNode('span-1', trigger)
+ await expectLogic(logic).toFinishAllListeners()
+ expect(logic.values.nodes['span-1']).toMatchObject({ status: 'ready' })
+ }
+ )
+
+ it('times a retried read from the click that retries it', async () => {
+ const logic = await mountedLogic()
+ const capture = jest.spyOn(posthog, 'capture')
+ let now = 1000
+ jest.spyOn(performance, 'now').mockImplementation(() => now)
+ nodeStatus = 500
+ logic.actions.loadNode('span-1', 'selection')
+ await expectLogic(logic).toFinishAllListeners()
+
+ now = 5000
+ nodeStatus = 200
+ logic.actions.loadNode('span-1', 'selection')
+ await expectLogic(logic).toFinishAllListeners()
+
+ expect(capture).toHaveBeenCalledWith('llma trace node loaded', {
+ load_ms: 0,
+ trigger: 'selection',
+ waited_ms: 0,
+ })
+ })
+
+ it('reports how long the reads took and how long a click waited', async () => {
+ const capture = jest.spyOn(posthog, 'capture')
+ const logic = await mountedLogic()
+
+ logic.actions.loadNode('span-1', 'prefetch')
+ logic.actions.loadNode('span-1', 'selection')
+ logic.actions.loadNode('gen-1', 'navigation')
+ await expectLogic(logic).toFinishAllListeners()
+
+ expect(capture).toHaveBeenCalledWith('llma trace view loaded', {
+ trace_load_ms: expect.any(Number),
+ node_count: 0,
+ })
+ expect(capture).toHaveBeenCalledWith('llma trace node loaded', {
+ load_ms: expect.any(Number),
+ trigger: 'thread',
+ waited_ms: null,
+ })
+ expect(capture).toHaveBeenCalledWith('llma trace node loaded', {
+ load_ms: expect.any(Number),
+ trigger: 'prefetch',
+ waited_ms: expect.any(Number),
+ })
+ expect(capture).toHaveBeenCalledWith('llma trace node loaded', {
+ load_ms: expect.any(Number),
+ trigger: 'navigation',
+ waited_ms: null,
+ })
+ })
+
+ it.each([
+ ['misses', 'expired-1'],
+ ['succeeds', 'closed-1'],
+ ])('drops a read that %s after the view is closed, even once the trace is open again', async (_, nodeId) => {
+ useMocks({ get: { [TRACE_URL]: () => [200, makeTraceResource({ timeline: [EXPIRED_ROW] })] } })
+ const heldNodeReads = deferred()
+ nodeGate = heldNodeReads.promise
+ const logic = traceViewLogic({ traceId: 'trace-1', timestampHint: null })
+ logic.mount()
+ logic.actions.loadNode(nodeId, 'selection')
+ await expectLogic(logic).toDispatchActions(['loadTraceSuccess'])
+ logic.unmount()
+ const reopened = traceViewLogic({ traceId: 'trace-1', timestampHint: null })
+ reopened.mount()
+ await expectLogic(reopened).toDispatchActions(['loadTraceSuccess'])
+ heldNodeReads.resolve()
+
+ await expectLogic(reopened).toFinishAllListeners()
+
+ expect(nodeRequests.filter((id) => id === nodeId)).toHaveLength(1)
+ expect(reopened.values.nodes[nodeId]).toBeUndefined()
+ })
+
+ describe('nodes of a trace past the ai_events retention', () => {
+ it.each([
+ ['trace', 'expired-1', [null, '2026-09-01T10:15:00Z'], 'ready'],
+ ['node', 'expired-1', [null, '2026-09-01T10:15:00Z'], 'ready'],
+ ['trace', 'expired-9', [null], 'error'],
+ ['node', 'expired-9', [null], 'error'],
+ ])(
+ 'when the %s response comes first, an early read of %s is sent with %j and ends as %s',
+ async (firstResponse, nodeId, expectedHints, expectedStatus) => {
+ const heldNodeReads = deferred()
+ if (firstResponse === 'trace') {
+ nodeGate = heldNodeReads.promise
+ }
+ useMocks({
+ get: {
+ [TRACE_URL]: async () => {
+ if (firstResponse === 'node') {
+ await firstNodeAnswer.promise
+ }
+ return [200, makeTraceResource({ timeline: [EXPIRED_ROW] })]
+ },
+ },
+ })
+ const logic = traceViewLogic({ traceId: 'trace-1', timestampHint: '2026-09-01T10:15:00Z' })
+ logic.mount()
+ logic.actions.loadNode(nodeId, 'selection')
+ if (firstResponse === 'trace') {
+ await expectLogic(logic).toDispatchActions(['loadTraceSuccess'])
+ heldNodeReads.resolve()
+ }
+
+ await expectLogic(logic).toFinishAllListeners()
+
+ expect(logic.values.nodes[nodeId]).toMatchObject({ status: expectedStatus })
+ expect(nodeHints.filter((_, index) => nodeRequests[index] === nodeId)).toEqual(expectedHints)
+ }
+ )
+
+ it('times a reread from the first request to its answer', async () => {
+ const capture = jest.spyOn(posthog, 'capture')
+ let now = 1000
+ jest.spyOn(performance, 'now').mockImplementation(() => now)
+ const heldTrace = deferred()
+ useMocks({
+ get: {
+ [TRACE_URL]: async () => {
+ await heldTrace.promise
+ return [200, makeTraceResource({ timeline: [EXPIRED_ROW] })]
+ },
+ },
+ })
+ const logic = traceViewLogic({ traceId: 'trace-1', timestampHint: null })
+ logic.mount()
+ logic.actions.loadNode('expired-1', 'selection')
+ await expectLogic(logic).toDispatchActions(['nodeMissedWithoutHint'])
+
+ const heldReread = deferred()
+ nodeGate = heldReread.promise
+ now = 3000
+ heldTrace.resolve()
+ await expectLogic(logic).toDispatchActions(['loadTraceSuccess'])
+ now = 7000
+ heldReread.resolve()
+ await expectLogic(logic).toFinishAllListeners()
+
+ expect(capture).toHaveBeenCalledWith('llma trace node loaded', {
+ load_ms: 6000,
+ trigger: 'selection',
+ waited_ms: 6000,
+ })
+ })
+ })
})
diff --git a/products/ai_observability/frontend/redesign/trace/traceViewLogic.ts b/products/ai_observability/frontend/redesign/trace/traceViewLogic.ts
index a81694700a8c..3607fb69f038 100644
--- a/products/ai_observability/frontend/redesign/trace/traceViewLogic.ts
+++ b/products/ai_observability/frontend/redesign/trace/traceViewLogic.ts
@@ -1,13 +1,15 @@
-import { MakeLogicType, afterMount, kea, key, path, props, reducers, selectors } from 'kea'
+import { MakeLogicType, actions, afterMount, kea, key, listeners, path, props, reducers, selectors } from 'kea'
import { loaders } from 'kea-loaders'
+import posthog from 'posthog-js'
import { ApiConfig, ApiError } from 'lib/api'
import { urls } from 'scenes/urls'
-import { aiObservabilityTracesRetrieve } from '../../generated/api'
-import type { TraceApi, TraceNodeApi, TraceTimelineRowApi } from '../../generated/api.schemas'
+import { aiObservabilityTracesNodesRetrieve, aiObservabilityTracesRetrieve } from '../../generated/api'
+import type { TraceApi, TraceNodeApi, TraceNodeDetailApi, TraceTimelineRowApi } from '../../generated/api.schemas'
import { TraceSummaryBarProps } from './components/TraceSummaryBar'
import { encodeTraceIdSegment } from './traceIdSegment'
+import type { LoadFailure, NodeLoad, NodeLoadTrigger } from './types'
export interface TraceViewLogicProps {
traceId: string
@@ -16,15 +18,20 @@ export interface TraceViewLogicProps {
export type TraceViewStatus = 'loading' | 'error' | 'ready'
-type LoadFailure = 'not_found' | 'failed'
-
// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface traceViewLogicValues {
+ createdAt: string | null
+ defaultNodeId: string
errorMessage: string
loadFailure: LoadFailure | null
+ nodeIdsByAlias: Record<string, string>
+ nodes: Record<string, NodeLoad>
+ nodesMissedWithoutHint: Record<string, NodeLoadTrigger>
personLabel: string | null
+ sessionId: string | null
status: TraceViewStatus
summary: TraceSummaryBarProps | null
+ threadNodeIds: string[]
timeline: {
rows: TraceTimelineRowApi[]
totalMs: number
@@ -38,6 +45,27 @@ export interface traceViewLogicValues {
// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
export interface traceViewLogicActions {
+ loadNode: (
+ nodeId: string,
+ trigger: NodeLoadTrigger
+ ) => {
+ nodeId: string
+ trigger: NodeLoadTrigger
+ }
+ loadNodeFailure: (
+ nodeId: string,
+ failure: LoadFailure
+ ) => {
+ failure: LoadFailure
+ nodeId: string
+ }
+ loadNodeSuccess: (
+ nodeId: string,
+ node: TraceNodeDetailApi
+ ) => {
+ node: TraceNodeDetailApi
+ nodeId: string
+ }
loadTrace: () => any
loadTraceFailure: (
error: string,
@@ -53,6 +81,20 @@ export interface traceViewLogicActions {
trace: TraceApi
payload?: any
}
+ nodeMissedWithoutHint: (
+ nodeId: string,
+ trigger: NodeLoadTrigger
+ ) => {
+ nodeId: string
+ trigger: NodeLoadTrigger
+ }
+ nodeRequested: (
+ nodeId: string,
+ trigger: NodeLoadTrigger
+ ) => {
+ nodeId: string
+ trigger: NodeLoadTrigger
+ }
}
// Generated by kea-typegen. Update if you're an agent, ignore if you're human.
@@ -70,6 +112,11 @@ export interface traceViewLogicMeta {
traceHasError: (trace: TraceApi | null) => boolean
personLabel: (trace: TraceApi | null) => string | null
summary: (trace: TraceApi | null) => TraceSummaryBarProps | null
+ threadNodeIds: (trace: TraceApi | null) => string[]
+ createdAt: (trace: TraceApi | null) => string | null
+ sessionId: (trace: TraceApi | null) => string | null
+ defaultNodeId: (trace: TraceApi | null, traceId: string) => string
+ nodeIdsByAlias: (trace: TraceApi | null) => Record<string, string>
}
}
@@ -80,20 +127,37 @@ export type traceViewLogicType = MakeLogicType<
traceViewLogicMeta
>
+function toLoadFailure(error: unknown): LoadFailure {
+ return error instanceof ApiError && error.status === 404 ? 'not_found' : 'failed'
+}
+
+function elapsedMs(since: number): number {
+ return Math.round(performance.now() - since)
+}
+
export const traceViewLogic = kea<traceViewLogicType>([
path((key) => ['products', 'ai_observability', 'frontend', 'redesign', 'trace', 'traceViewLogic', key]),
props({} as TraceViewLogicProps),
key((props) => props.traceId),
- loaders(({ props }) => ({
+ actions({
+ loadNode: (nodeId: string, trigger: NodeLoadTrigger) => ({ nodeId, trigger }),
+ nodeRequested: (nodeId: string, trigger: NodeLoadTrigger) => ({ nodeId, trigger }),
+ nodeMissedWithoutHint: (nodeId: string, trigger: NodeLoadTrigger) => ({ nodeId, trigger }),
+ loadNodeSuccess: (nodeId: string, node: TraceNodeDetailApi) => ({ nodeId, node }),
+ loadNodeFailure: (nodeId: string, failure: LoadFailure) => ({ nodeId, failure }),
+ }),
+ loaders(({ props, cache }) => ({
trace: [
null as TraceApi | null,
{
- loadTrace: async (): Promise<TraceApi> =>
- await aiObservabilityTracesRetrieve(
+ loadTrace: async (): Promise<TraceApi> => {
+ cache.traceRequestedAt = performance.now()
+ return await aiObservabilityTracesRetrieve(
String(ApiConfig.getCurrentProjectId()),
encodeTraceIdSegment(props.traceId),
props.timestampHint ? { timestamp_hint: props.timestampHint } : undefined
- ),
+ )
+ },
},
],
})),
@@ -102,8 +166,24 @@ export const traceViewLogic = kea<traceViewLogicType>([
null as LoadFailure | null,
{
loadTrace: () => null,
- loadTraceFailure: (_, { errorObject }) =>
- errorObject instanceof ApiError && errorObject.status === 404 ? 'not_found' : 'failed',
+ loadTraceFailure: (_, { errorObject }) => toLoadFailure(errorObject),
+ },
+ ],
+ nodes: [
+ {} as Record<string, NodeLoad>,
+ {
+ nodeRequested: (state, { nodeId }): Record<string, NodeLoad> => ({
+ ...state,
+ [nodeId]: { status: 'loading' },
+ }),
+ loadNodeSuccess: (state, { nodeId, node }): Record<string, NodeLoad> => ({
+ ...state,
+ [nodeId]: { status: 'ready', node },
+ }),
+ loadNodeFailure: (state, { nodeId, failure }): Record<string, NodeLoad> => ({
+ ...state,
+ [nodeId]: { status: 'error', failure },
+ }),
},
],
}),
@@ -145,8 +225,141 @@ export const traceViewLogic = kea<traceViewLogicType>([
}
: null,
],
+ threadNodeIds: [(s) => [s.trace], (trace: TraceApi | null): string[] => trace?.threadNodeIds ?? []],
+ createdAt: [(s) => [s.trace], (trace: TraceApi | null): string | null => trace?.createdAt ?? null],
+ sessionId: [(s) => [s.trace], (trace: TraceApi | null): string | null => trace?.sessionId ?? null],
+ defaultNodeId: [
+ (s, p) => [s.trace, p.traceId],
+ (trace: TraceApi | null, traceId: string): string => trace?.defaultNodeId ?? traceId,
+ ],
+ nodeIdsByAlias: [
+ (s) => [s.trace],
+ (trace: TraceApi | null): Record<string, string> => trace?.nodeIdsByAlias ?? {},
+ ],
+ }),
+ listeners(({ actions, values, props, cache }) => {
+ const selectedAt = (): Record<string, number> => (cache.selectedAt ??= {})
+ const requestedAt = (): Record<string, number> => (cache.requestedAt ??= {})
+
+ const endRead = (nodeId: string): void => {
+ delete selectedAt()[nodeId]
+ delete requestedAt()[nodeId]
+ if (cache.prefetchingNodeId === nodeId) {
+ cache.prefetchingNodeId = null
+ }
+ }
+
+ return {
+ loadTraceSuccess: ({ trace }) => {
+ posthog.capture('llma trace view loaded', {
+ trace_load_ms: elapsedMs(cache.traceRequestedAt),
+ node_count: trace.timeline.length,
+ })
+ for (const nodeId of trace.threadNodeIds) {
+ actions.loadNode(nodeId, 'thread')
+ }
+ },
+ loadNode: ({ nodeId, trigger }) => {
+ const current = values.nodes[nodeId]
+ if (trigger === 'selection' && current?.status !== 'ready') {
+ selectedAt()[nodeId] ??= performance.now()
+ }
+ if (current?.status === 'loading' || current?.status === 'ready') {
+ return
+ }
+ if (current?.status === 'error' && trigger !== 'selection' && trigger !== 'navigation') {
+ return
+ }
+ if (trigger === 'prefetch') {
+ // Each read holds one of the organization's query slots, so a slow sweep over the tree must
+ // not start one read per row it crosses.
+ if (cache.prefetchingNodeId) {
+ return
+ }
+ cache.prefetchingNodeId = nodeId
+ }
+ actions.nodeRequested(nodeId, trigger)
+ },
+ nodeRequested: async ({ nodeId, trigger }) => {
+ const hint = values.createdAt
+ const firstRequestedAt = (requestedAt()[nodeId] ??= performance.now())
+ const result = await aiObservabilityTracesNodesRetrieve(
+ String(ApiConfig.getCurrentProjectId()),
+ encodeTraceIdSegment(props.traceId),
+ encodeTraceIdSegment(nodeId),
+ hint ? { timestamp_hint: hint } : undefined
+ ).then(
+ (node: TraceNodeDetailApi) => ({ node }),
+ (error: unknown) => ({ failure: toLoadFailure(error) })
+ )
+ // A read can answer after the view closed, and a reopened view of the trace shares its actions.
+ if (cache.disposables.isDisposed) {
+ return
+ }
+ if ('failure' in result) {
+ if (result.failure === 'not_found' && !hint) {
+ actions.nodeMissedWithoutHint(nodeId, trigger)
+ } else {
+ actions.loadNodeFailure(nodeId, result.failure)
+ }
+ return
+ }
+ const waitedSince = selectedAt()[nodeId]
+ const loadMs = elapsedMs(firstRequestedAt)
+ const waitedMs = waitedSince === undefined ? null : elapsedMs(waitedSince)
+ actions.loadNodeSuccess(nodeId, result.node)
+ posthog.capture('llma trace node loaded', { load_ms: loadMs, trigger, waited_ms: waitedMs })
+ },
+ loadNodeSuccess: ({ nodeId }) => endRead(nodeId),
+ loadNodeFailure: ({ nodeId }) => endRead(nodeId),
+ }
}),
afterMount(({ actions }) => {
actions.loadTrace()
}),
+ // Without a hint the backend reads ai_events only, so an early read of a node from a trace past the ai_events
+ // retention misses. The node stays loading and is read again once the trace's timestamp is known.
+ reducers({
+ nodesMissedWithoutHint: [
+ {} as Record<string, NodeLoadTrigger>,
+ {
+ nodeMissedWithoutHint: (state, { nodeId, trigger }): Record<string, NodeLoadTrigger> => ({
+ ...state,
+ [nodeId]: trigger,
+ }),
+ nodeRequested: (state, { nodeId }): Record<string, NodeLoadTrigger> => {
+ const { [nodeId]: _, ...rest } = state
+ return rest
+ },
+ loadNodeFailure: (state, { nodeId }): Record<string, NodeLoadTrigger> => {
+ const { [nodeId]: _, ...rest } = state
+ return rest
+ },
+ },
+ ],
+ }),
+ listeners(({ actions, values }) => {
+ // The timeline lists every tree node, so an id outside it is a stale or SDK id that no hint will find.
+ const isTraceNode = (trace: TraceApi, nodeId: string): boolean =>
+ nodeId === trace.id || trace.timeline.some((row) => row.id === nodeId)
+
+ const rereadMissedNodes = (): void => {
+ const { trace } = values
+ if (!trace) {
+ return
+ }
+ for (const [nodeId, trigger] of Object.entries(values.nodesMissedWithoutHint)) {
+ if (isTraceNode(trace, nodeId)) {
+ actions.nodeRequested(nodeId, trigger)
+ } else {
+ actions.loadNodeFailure(nodeId, 'not_found')
+ }
+ }
+ }
+
+ return {
+ loadTraceSuccess: rereadMissedNodes,
+ nodeMissedWithoutHint: rereadMissedNodes,
+ }
+ }),
])
diff --git a/products/ai_observability/frontend/redesign/trace/types.ts b/products/ai_observability/frontend/redesign/trace/types.ts
index 9956c67ca896..864a6a6271f5 100644
--- a/products/ai_observability/frontend/redesign/trace/types.ts
+++ b/products/ai_observability/frontend/redesign/trace/types.ts
@@ -1,4 +1,4 @@
-import type { TraceNodeApi } from '../../generated/api.schemas'
+import type { TraceNodeApi, TraceNodeDetailApi } from '../../generated/api.schemas'
export type TraceNodeKind = TraceNodeApi['kind']
@@ -8,6 +8,19 @@ export type TraceViewChoice = 'new' | 'legacy'
export type NodeDetailTab = 'messages' | 'details' | 'evals' | 'raw'
+export type LoadFailure = 'not_found' | 'failed'
+
+/**
+ * `selection` is a click on a step. `navigation` is a node the view selects without a click: on open, from a
+ * link, as the default node, as the root while the trace loads, or from the browser history.
+ */
+export type NodeLoadTrigger = 'selection' | 'navigation' | 'prefetch' | 'thread'
+
+export type NodeLoad =
+ | { status: 'loading' }
+ | { status: 'ready'; node: TraceNodeDetailApi }
+ | { status: 'error'; failure: LoadFailure }
+
export type MessageRole = 'system' | 'user' | 'assistant' | 'tool'
export type AttachmentMediaType = 'image' | 'audio' | 'video' | 'file'
@@ -41,6 +54,7 @@ export interface ConversationTurn {
export type ConversationState =
| { status: 'loading' }
+ | { status: 'error'; message: string }
| { status: 'ready'; turns: ConversationTurn[]; activeTurnId: string | null }
export type NodeContent =
@@ -50,7 +64,7 @@ export type NodeContent =
| { kind: 'error'; message: string }
export interface NodeProperties {
- timestamp: string
+ timestamp: string | null
provider: string | null
temperature: number | null
sessionId: string | null
diff --git a/services/mcp/src/api/generated.ts b/services/mcp/src/api/generated.ts
index 8c39ab1028c3..29dc7ad1688c 100644
--- a/services/mcp/src/api/generated.ts
+++ b/services/mcp/src/api/generated.ts
@@ -114685,6 +114685,8 @@ export namespace Schemas {
change: WoWChange | null;
}
+ export type TraceNodeIdsByAlias = {[key: string]: string};
+
export interface TracePerson {
distinctId: string;
label: string;
@@ -114742,6 +114744,45 @@ export namespace Schemas {
timeline: TraceTimelineRow[];
totalMs: number;
threadNodeIds: string[];
+ defaultNodeId: string;
+ nodeIdsByAlias: TraceNodeIdsByAlias;
+ }
+
+ export interface TraceNodeMetadata {
+ provider: string | null;
+ temperature: number | null;
+ sessionId: string | null;
+ promptName: string | null;
+ promptVersion: number | null;
+ }
+
+ export interface TraceNodeIOKeys {
+ input: string | null;
+ output: string | null;
+ tools: string | null;
+ }
+
+ /**
+ * The event's properties as ingested, including its input and output values.
+ */
+ export type TraceNodeEventProperties = { [key: string]: unknown };
+
+ export interface TraceNodeEvent {
+ name: string;
+ uuid: string;
+ timestamp: string;
+ /** The event's properties as ingested, including its input and output values. */
+ properties: TraceNodeEventProperties;
+ /** Which keys of `properties` hold the node's input, output and tools, or null when it has none. */
+ ioKeys: TraceNodeIOKeys;
+ }
+
+ export interface TraceNodeDetail {
+ id: string;
+ kind: TraceNodeKindEnum;
+ error: string | null;
+ metadata: TraceNodeMetadata;
+ event: TraceNodeEvent | null;
}
export interface TraceReviewCreate {
@@ -122939,6 +122980,13 @@ export namespace Schemas {
timestamp_hint?: string;
};
+ export type AiObservabilityTracesNodesRetrieveParams = {
+ /**
+ * When the trace happened, as carried by links into it. Lets a trace older than the AI events retention load from the shared events table.
+ */
+ timestamp_hint?: string;
+ };
+
export type AlertsListParams = {
/**
* Optional. Restrict results to alerts created by the user with this UUID.