arize-phoenix 4.19.0__py3-none-any.whl → 4.20.1__py3-none-any.whl

phoenix/db/insertion/types.py

@@ -21,11 +21,12 @@ from typing import (
 )
 
 from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy.sql.dml import ReturningInsert
+from sqlalchemy.sql.dml import Insert
 
 from phoenix.db import models
 from phoenix.db.insertion.constants import DEFAULT_RETRY_ALLOWANCE, DEFAULT_RETRY_DELAY_SEC
-from phoenix.db.insertion.helpers import as_kv, insert_on_conflict
+from phoenix.db.insertion.helpers import insert_on_conflict
+from phoenix.server.dml_event import DmlEvent
 from phoenix.server.types import DbSessionFactory
 
 logger = logging.getLogger("__name__")
@@ -40,6 +41,7 @@ _AnyT = TypeVar("_AnyT")
 _PrecursorT = TypeVar("_PrecursorT")
 _InsertableT = TypeVar("_InsertableT", bound=Insertable)
 _RowT = TypeVar("_RowT", bound=models.Base)
+_DmlEventT = TypeVar("_DmlEventT", bound=DmlEvent)
 
 
 @dataclass(frozen=True)
@@ -56,7 +58,7 @@ class Postponed(Received[_AnyT]):
     retries_left: int = field(default=DEFAULT_RETRY_ALLOWANCE)
 
 
-class QueueInserter(ABC, Generic[_PrecursorT, _InsertableT, _RowT]):
+class QueueInserter(ABC, Generic[_PrecursorT, _InsertableT, _RowT, _DmlEventT]):
     table: Type[_RowT]
     unique_by: Sequence[str]
 
@@ -97,59 +99,63 @@ class QueueInserter(ABC, Generic[_PrecursorT, _InsertableT, _RowT]):
         List[Received[_PrecursorT]],
     ]: ...
 
-    async def insert(self) -> Tuple[Type[_RowT], List[int]]:
+    async def insert(self) -> Optional[List[_DmlEventT]]:
         if not self._queue:
-            return self.table, []
-        parcels = self._queue
-        self._queue = []
-        inserted_ids: List[int] = []
+            return None
+        self._queue, parcels = [], self._queue
+        events: List[_DmlEventT] = []
         async with self._db() as session:
             to_insert, to_postpone, _ = await self._partition(session, *parcels)
             if to_insert:
-                inserted_ids, to_retry, _ = await self._insert(session, *to_insert)
-                to_postpone.extend(to_retry)
+                events, to_retry, _ = await self._insert(session, *to_insert)
+                if to_retry:
+                    to_postpone.extend(to_retry)
         if to_postpone:
             loop = asyncio.get_running_loop()
             loop.call_later(self._retry_delay_sec, self._queue.extend, to_postpone)
-        return self.table, inserted_ids
+        return events
 
-    def _stmt(self, *records: Mapping[str, Any]) -> ReturningInsert[Tuple[int]]:
-        pk = next(c for c in self.table.__table__.c if c.primary_key)
+    def _insert_on_conflict(self, *records: Mapping[str, Any]) -> Insert:
         return insert_on_conflict(
             *records,
             table=self.table,
             unique_by=self.unique_by,
             dialect=self._db.dialect,
-        ).returning(pk)
+        )
+
+    @abstractmethod
+    async def _events(
+        self,
+        session: AsyncSession,
+        *insertions: _InsertableT,
+    ) -> List[_DmlEventT]: ...
 
     async def _insert(
         self,
         session: AsyncSession,
-        *insertions: Received[_InsertableT],
-    ) -> Tuple[List[int], List[Postponed[_PrecursorT]], List[Received[_InsertableT]]]:
-        records = [dict(as_kv(ins.item.row)) for ins in insertions]
-        inserted_ids: List[int] = []
+        *parcels: Received[_InsertableT],
+    ) -> Tuple[
+        List[_DmlEventT],
+        List[Postponed[_PrecursorT]],
+        List[Received[_InsertableT]],
+    ]:
         to_retry: List[Postponed[_PrecursorT]] = []
         failures: List[Received[_InsertableT]] = []
-        stmt = self._stmt(*records)
+        events: List[_DmlEventT] = []
         try:
             async with session.begin_nested():
-                ids = [id_ async for id_ in await session.stream_scalars(stmt)]
-                inserted_ids.extend(ids)
+                events.extend(await self._events(session, *(p.item for p in parcels)))
         except BaseException:
             logger.exception(
                 f"Failed to bulk insert for {self.table.__name__}. "
-                f"Will try to insert ({len(records)} records) individually instead."
+                f"Will try to insert ({len(parcels)} records) individually instead."
             )
-            for i, record in enumerate(records):
-                stmt = self._stmt(record)
+            for p in parcels:
                 try:
                     async with session.begin_nested():
-                        ids = [id_ async for id_ in await session.stream_scalars(stmt)]
-                        inserted_ids.extend(ids)
+                        events.extend(await self._events(session, p.item))
                 except BaseException:
                     logger.exception(f"Failed to insert for {self.table.__name__}.")
-                    p = insertions[i]
                     if isinstance(p, Postponed) and p.retries_left == 1:
                         failures.append(p)
                     else:
@@ -162,7 +168,7 @@ class QueueInserter(ABC, Generic[_PrecursorT, _InsertableT, _RowT]):
                                 else self._retry_allowance,
                             )
                         )
-        return inserted_ids, to_retry, failures
+        return events, to_retry, failures
 
 
 class Precursors(ABC):

phoenix/server/api/context.py

@@ -1,10 +1,8 @@
 from dataclasses import dataclass
-from datetime import datetime
 from pathlib import Path
-from typing import Callable, Optional
+from typing import Any, Optional
 
 from strawberry.fastapi import BaseContext
-from typing_extensions import TypeAlias
 
 from phoenix.core.model_schema import Model
 from phoenix.server.api.dataloaders import (
@@ -34,7 +32,8 @@ from phoenix.server.api.dataloaders import (
     TraceEvaluationsDataLoader,
     TraceRowIdsDataLoader,
 )
-from phoenix.server.types import DbSessionFactory
+from phoenix.server.dml_event import DmlEvent
+from phoenix.server.types import CanGetLastUpdatedAt, CanPutItem, DbSessionFactory
 
 
 @dataclass
@@ -54,6 +53,7 @@ class DataLoaders:
     latency_ms_quantile: LatencyMsQuantileDataLoader
     min_start_or_max_end_times: MinStartOrMaxEndTimeDataLoader
     record_counts: RecordCountDataLoader
+    span_annotations: SpanAnnotationsDataLoader
     span_dataset_examples: SpanDatasetExamplesDataLoader
     span_descendants: SpanDescendantsDataLoader
     span_evaluations: SpanEvaluationsDataLoader
@@ -62,10 +62,11 @@ class DataLoaders:
     trace_evaluations: TraceEvaluationsDataLoader
     trace_row_ids: TraceRowIdsDataLoader
     project_by_name: ProjectByNameDataLoader
-    span_annotations: SpanAnnotationsDataLoader
 
 
-ProjectRowId: TypeAlias = int
+class _NoOp:
+    def get(self, *args: Any, **kwargs: Any) -> Any: ...
+    def put(self, *args: Any, **kwargs: Any) -> Any: ...
 
 
 @dataclass
@@ -75,6 +76,7 @@ class Context(BaseContext):
     cache_for_dataloaders: Optional[CacheForDataLoaders]
     model: Model
     export_path: Path
+    last_updated_at: CanGetLastUpdatedAt = _NoOp()
+    event_queue: CanPutItem[DmlEvent] = _NoOp()
     corpus: Optional[Model] = None
-    streaming_last_updated_at: Callable[[ProjectRowId], Optional[datetime]] = lambda _: None
     read_only: bool = False

phoenix/server/api/dataloaders/__init__.py

@@ -1,12 +1,4 @@
 from dataclasses import dataclass, field
-from functools import singledispatchmethod
-
-from phoenix.db.insertion.evaluation import (
-    DocumentEvaluationInsertionEvent,
-    SpanEvaluationInsertionEvent,
-    TraceEvaluationInsertionEvent,
-)
-from phoenix.db.insertion.span import ClearProjectSpansEvent, SpanInsertionEvent
 
 from .annotation_summaries import AnnotationSummaryCache, AnnotationSummaryDataLoader
 from .average_experiment_run_latency import AverageExperimentRunLatencyDataLoader
@@ -88,42 +80,3 @@ class CacheForDataLoaders:
     token_count: TokenCountCache = field(
         default_factory=TokenCountCache,
     )
-
-    def _update_spans(self, project_rowid: int) -> None:
-        self.latency_ms_quantile.invalidate(project_rowid)
-        self.token_count.invalidate(project_rowid)
-        self.record_count.invalidate(project_rowid)
-        self.min_start_or_max_end_time.invalidate(project_rowid)
-
-    def _clear_spans(self, project_rowid: int) -> None:
-        self._update_spans(project_rowid)
-        self.annotation_summary.invalidate_project(project_rowid)
-        self.evaluation_summary.invalidate_project(project_rowid)
-        self.document_evaluation_summary.invalidate_project(project_rowid)
-
-    @singledispatchmethod
-    def invalidate(self, event: SpanInsertionEvent) -> None:
-        project_rowid, *_ = event
-        self._update_spans(project_rowid)
-
-    @invalidate.register
-    def _(self, event: ClearProjectSpansEvent) -> None:
-        project_rowid, *_ = event
-        self._clear_spans(project_rowid)
-
-    @invalidate.register
-    def _(self, event: DocumentEvaluationInsertionEvent) -> None:
-        project_rowid, evaluation_name = event
-        self.document_evaluation_summary.invalidate((project_rowid, evaluation_name))
-
-    @invalidate.register
-    def _(self, event: SpanEvaluationInsertionEvent) -> None:
-        project_rowid, evaluation_name = event
-        self.annotation_summary.invalidate((project_rowid, evaluation_name, "span"))
-        self.evaluation_summary.invalidate((project_rowid, evaluation_name, "span"))
-
-    @invalidate.register
-    def _(self, event: TraceEvaluationInsertionEvent) -> None:
-        project_rowid, evaluation_name = event
-        self.annotation_summary.invalidate((project_rowid, evaluation_name, "trace"))
-        self.evaluation_summary.invalidate((project_rowid, evaluation_name, "trace"))

phoenix/server/api/dataloaders/span_annotations.py

@@ -8,12 +8,11 @@ from sqlalchemy import select
 from strawberry.dataloader import DataLoader
 from typing_extensions import TypeAlias
 
-from phoenix.db import models
-from phoenix.server.api.types.SpanAnnotation import SpanAnnotation, to_gql_span_annotation
+from phoenix.db.models import SpanAnnotation as ORMSpanAnnotation
 from phoenix.server.types import DbSessionFactory
 
 Key: TypeAlias = int
-Result: TypeAlias = List[SpanAnnotation]
+Result: TypeAlias = List[ORMSpanAnnotation]
 
 
 class SpanAnnotationsDataLoader(DataLoader[Key, Result]):
@@ -23,11 +22,9 @@ class SpanAnnotationsDataLoader(DataLoader[Key, Result]):
 
     async def _load_fn(self, keys: List[Key]) -> List[Result]:
         span_annotations_by_id: DefaultDict[Key, Result] = defaultdict(list)
-        msa = models.SpanAnnotation
         async with self._db() as session:
-            data = await session.stream_scalars(select(msa).where(msa.span_rowid.in_(keys)))
-            async for span_annotation in data:
-                span_annotations_by_id[span_annotation.span_rowid].append(
-                    to_gql_span_annotation(span_annotation)
-                )
+            async for span_annotation in await session.stream_scalars(
+                select(ORMSpanAnnotation).where(ORMSpanAnnotation.span_rowid.in_(keys))
+            ):
+                span_annotations_by_id[span_annotation.span_rowid].append(span_annotation)
         return [span_annotations_by_id[key] for key in keys]

phoenix/server/api/mutations/dataset_mutations.py

@@ -33,6 +33,7 @@ from phoenix.server.api.types.DatasetExample import DatasetExample
 from phoenix.server.api.types.node import from_global_id_with_expected_type
 from phoenix.server.api.types.Span import Span
 from phoenix.server.api.utils import delete_projects, delete_traces
+from phoenix.server.dml_event import DatasetDeleteEvent, DatasetInsertEvent
 
 
 @strawberry.type
@@ -62,6 +63,7 @@ class DatasetMutationMixin:
                 .returning(models.Dataset)
             )
             assert dataset is not None
+        info.context.event_queue.put(DatasetInsertEvent((dataset.id,)))
         return DatasetMutationPayload(dataset=to_gql_dataset(dataset))
 
     @strawberry.mutation(permission_classes=[IsAuthenticated])  # type: ignore
@@ -90,6 +92,7 @@ class DatasetMutationMixin:
                 .values(**patch)
             )
             assert dataset is not None
+        info.context.event_queue.put(DatasetInsertEvent((dataset.id,)))
         return DatasetMutationPayload(dataset=to_gql_dataset(dataset))
 
     @strawberry.mutation(permission_classes=[IsAuthenticated])  # type: ignore
@@ -154,6 +157,36 @@ class DatasetMutationMixin:
                 raise ValueError(
                     f"Could not find spans with rowids: {', '.join(map(str, missing_span_rowids))}"
                 )  # todo: implement error handling types https://github.com/Arize-ai/phoenix/issues/3221
+
+            span_annotations = (
+                await session.execute(
+                    select(
+                        models.SpanAnnotation.span_rowid,
+                        models.SpanAnnotation.name,
+                        models.SpanAnnotation.label,
+                        models.SpanAnnotation.score,
+                        models.SpanAnnotation.explanation,
+                        models.SpanAnnotation.metadata_,
+                        models.SpanAnnotation.annotator_kind,
+                    )
+                    .select_from(models.SpanAnnotation)
+                    .where(models.SpanAnnotation.span_rowid.in_(span_rowids))
+                )
+            ).all()
+
+            span_annotations_by_span: Dict[int, Dict[Any, Any]] = {span.id: {} for span in spans}
+            for annotation in span_annotations:
+                span_id = annotation.span_rowid
+                if span_id not in span_annotations_by_span:
+                    span_annotations_by_span[span_id] = dict()
+                span_annotations_by_span[span_id][annotation.name] = {
+                    "label": annotation.label,
+                    "score": annotation.score,
+                    "explanation": annotation.explanation,
+                    "metadata": annotation.metadata_,
+                    "annotator_kind": annotation.annotator_kind,
+                }
+
             DatasetExample = models.DatasetExample
             dataset_example_rowids = (
                 await session.scalars(
@@ -170,6 +203,7 @@ class DatasetMutationMixin:
             assert len(dataset_example_rowids) == len(spans)
             assert all(map(lambda id: isinstance(id, int), dataset_example_rowids))
             DatasetExampleRevision = models.DatasetExampleRevision
+
             await session.execute(
                 insert(DatasetExampleRevision),
                 [
@@ -178,12 +212,16 @@ class DatasetMutationMixin:
                         DatasetExampleRevision.dataset_version_id.key: dataset_version_rowid,
                         DatasetExampleRevision.input.key: get_dataset_example_input(span),
                         DatasetExampleRevision.output.key: get_dataset_example_output(span),
-                        DatasetExampleRevision.metadata_.key: span.attributes,
+                        DatasetExampleRevision.metadata_.key: {
+                            **span.attributes,
+                            "annotations": span_annotations_by_span[span.id],
+                        },
                         DatasetExampleRevision.revision_kind.key: "CREATE",
                     }
                     for dataset_example_rowid, span in zip(dataset_example_rowids, spans)
                 ],
             )
+        info.context.event_queue.put(DatasetInsertEvent((dataset.id,)))
         return DatasetMutationPayload(dataset=to_gql_dataset(dataset))
 
     @strawberry.mutation(permission_classes=[IsAuthenticated])  # type: ignore
@@ -269,6 +307,7 @@ class DatasetMutationMixin:
                     )
                 ],
             )
+        info.context.event_queue.put(DatasetInsertEvent((dataset.id,)))
         return DatasetMutationPayload(dataset=to_gql_dataset(dataset))
 
     @strawberry.mutation(permission_classes=[IsAuthenticated])  # type: ignore
@@ -299,6 +338,7 @@ class DatasetMutationMixin:
             delete_traces(info.context.db, *eval_trace_ids),
             return_exceptions=True,
         )
+        info.context.event_queue.put(DatasetDeleteEvent((dataset.id,)))
         return DatasetMutationPayload(dataset=to_gql_dataset(dataset))
 
     @strawberry.mutation(permission_classes=[IsAuthenticated])  # type: ignore
@@ -390,7 +430,7 @@ class DatasetMutationMixin:
                     for revision, patch, example_id in zip(revisions, patches, example_ids)
                 ],
             )
-
+        info.context.event_queue.put(DatasetInsertEvent((dataset.id,)))
         return DatasetMutationPayload(dataset=to_gql_dataset(dataset))
 
     @strawberry.mutation(permission_classes=[IsAuthenticated])  # type: ignore
@@ -473,8 +513,8 @@ class DatasetMutationMixin:
                     for dataset_example_rowid in example_db_ids
                 ],
             )
-
-            return DatasetMutationPayload(dataset=to_gql_dataset(dataset))
+        info.context.event_queue.put(DatasetInsertEvent((dataset.id,)))
+        return DatasetMutationPayload(dataset=to_gql_dataset(dataset))
 
 
 def _span_attribute(semconv: str) -> Any:

phoenix/server/api/mutations/experiment_mutations.py

@@ -14,6 +14,7 @@ from phoenix.server.api.mutations.auth import IsAuthenticated
 from phoenix.server.api.types.Experiment import Experiment, to_gql_experiment
 from phoenix.server.api.types.node import from_global_id_with_expected_type
 from phoenix.server.api.utils import delete_projects, delete_traces
+from phoenix.server.dml_event import ExperimentDeleteEvent
 
 
 @strawberry.type
@@ -66,6 +67,7 @@ class ExperimentMutationMixin:
             delete_traces(info.context.db, *eval_trace_ids),
             return_exceptions=True,
         )
+        info.context.event_queue.put(ExperimentDeleteEvent(tuple(experiments.keys())))
         return ExperimentMutationPayload(
             experiments=[
                 to_gql_experiment(experiments[experiment_id]) for experiment_id in experiment_ids

phoenix/server/api/mutations/project_mutations.py

@@ -6,23 +6,23 @@ from strawberry.types import Info
 
 from phoenix.config import DEFAULT_PROJECT_NAME
 from phoenix.db import models
-from phoenix.db.insertion.span import ClearProjectSpansEvent
 from phoenix.server.api.context import Context
 from phoenix.server.api.input_types.ClearProjectInput import ClearProjectInput
 from phoenix.server.api.mutations.auth import IsAuthenticated
 from phoenix.server.api.queries import Query
 from phoenix.server.api.types.node import from_global_id_with_expected_type
+from phoenix.server.dml_event import ProjectDeleteEvent, SpanDeleteEvent
 
 
 @strawberry.type
 class ProjectMutationMixin:
     @strawberry.mutation(permission_classes=[IsAuthenticated])  # type: ignore
     async def delete_project(self, info: Info[Context, None], id: GlobalID) -> Query:
-        node_id = from_global_id_with_expected_type(global_id=id, expected_type_name="Project")
+        project_id = from_global_id_with_expected_type(global_id=id, expected_type_name="Project")
         async with info.context.db() as session:
             project = await session.scalar(
                 select(models.Project)
-                .where(models.Project.id == node_id)
+                .where(models.Project.id == project_id)
                 .options(load_only(models.Project.name))
             )
             if project is None:
@@ -30,6 +30,7 @@ class ProjectMutationMixin:
             if project.name == DEFAULT_PROJECT_NAME:
                 raise ValueError(f"Cannot delete the {DEFAULT_PROJECT_NAME} project")
             await session.delete(project)
+        info.context.event_queue.put(ProjectDeleteEvent((project_id,)))
         return Query()
 
     @strawberry.mutation(permission_classes=[IsAuthenticated])  # type: ignore
@@ -42,6 +43,5 @@ class ProjectMutationMixin:
             delete_statement = delete_statement.where(models.Trace.start_time < input.end_time)
         async with info.context.db() as session:
             await session.execute(delete_statement)
-        if cache := info.context.cache_for_dataloaders:
-            cache.invalidate(ClearProjectSpansEvent(project_rowid=project_id))
+        info.context.event_queue.put(SpanDeleteEvent((project_id,)))
         return Query()

phoenix/server/api/mutations/span_annotations_mutations.py

@@ -14,6 +14,7 @@ from phoenix.server.api.mutations.auth import IsAuthenticated
 from phoenix.server.api.queries import Query
 from phoenix.server.api.types.node import from_global_id_with_expected_type
 from phoenix.server.api.types.SpanAnnotation import SpanAnnotation, to_gql_span_annotation
+from phoenix.server.dml_event import SpanAnnotationDeleteEvent, SpanAnnotationInsertEvent
 
 
 @strawberry.type
@@ -47,7 +48,10 @@ class SpanAnnotationMutationMixin:
             )
             result = await session.scalars(stmt)
             inserted_annotations = result.all()
-
+        if inserted_annotations:
+            info.context.event_queue.put(
+                SpanAnnotationInsertEvent(tuple(anno.id for anno in inserted_annotations))
+            )
         return SpanAnnotationMutationPayload(
             span_annotations=[
                 to_gql_span_annotation(annotation) for annotation in inserted_annotations
@@ -92,7 +96,7 @@ class SpanAnnotationMutationMixin:
                 )
                 if span_annotation is not None:
                     patched_annotations.append(to_gql_span_annotation(span_annotation))
-
+                    info.context.event_queue.put(SpanAnnotationInsertEvent((span_annotation.id,)))
         return SpanAnnotationMutationPayload(span_annotations=patched_annotations, query=Query())
 
     @strawberry.mutation(permission_classes=[IsAuthenticated])  # type: ignore
@@ -115,6 +119,10 @@ class SpanAnnotationMutationMixin:
             deleted_annotations_gql = [
                 to_gql_span_annotation(annotation) for annotation in deleted_annotations
             ]
+        if deleted_annotations:
+            info.context.event_queue.put(
+                SpanAnnotationDeleteEvent(tuple(anno.id for anno in deleted_annotations))
+            )
         return SpanAnnotationMutationPayload(
             span_annotations=deleted_annotations_gql, query=Query()
         )

phoenix/server/api/mutations/trace_annotations_mutations.py

@@ -14,6 +14,7 @@ from phoenix.server.api.mutations.auth import IsAuthenticated
 from phoenix.server.api.queries import Query
 from phoenix.server.api.types.node import from_global_id_with_expected_type
 from phoenix.server.api.types.TraceAnnotation import TraceAnnotation, to_gql_trace_annotation
+from phoenix.server.dml_event import TraceAnnotationDeleteEvent, TraceAnnotationInsertEvent
 
 
 @strawberry.type
@@ -47,7 +48,10 @@ class TraceAnnotationMutationMixin:
             )
             result = await session.scalars(stmt)
             inserted_annotations = result.all()
-
+        if inserted_annotations:
+            info.context.event_queue.put(
+                TraceAnnotationInsertEvent(tuple(anno.id for anno in inserted_annotations))
+            )
         return TraceAnnotationMutationPayload(
             trace_annotations=[
                 to_gql_trace_annotation(annotation) for annotation in inserted_annotations
@@ -91,7 +95,7 @@ class TraceAnnotationMutationMixin:
                 )
                 if trace_annotation:
                     patched_annotations.append(to_gql_trace_annotation(trace_annotation))
-
+                    info.context.event_queue.put(TraceAnnotationInsertEvent((trace_annotation.id,)))
         return TraceAnnotationMutationPayload(trace_annotations=patched_annotations, query=Query())
 
     @strawberry.mutation(permission_classes=[IsAuthenticated])  # type: ignore
@@ -114,6 +118,10 @@ class TraceAnnotationMutationMixin:
             deleted_annotations_gql = [
                 to_gql_trace_annotation(annotation) for annotation in deleted_annotations
             ]
+        if deleted_annotations:
+            info.context.event_queue.put(
+                TraceAnnotationDeleteEvent(tuple(anno.id for anno in deleted_annotations))
+            )
         return TraceAnnotationMutationPayload(
             trace_annotations=deleted_annotations_gql, query=Query()
         )

phoenix/server/api/queries.py

@@ -1,4 +1,5 @@
 from collections import defaultdict
+from datetime import datetime
 from typing import DefaultDict, Dict, List, Optional, Set, Union
 
 import numpy as np
@@ -107,6 +108,10 @@ class Query:
             ]
         return connection_from_list(data=data, args=args)
 
+    @strawberry.field
+    def projects_last_updated_at(self, info: Info[Context, None]) -> Optional[datetime]:
+        return info.context.last_updated_at.get(models.Project)
+
     @strawberry.field
     async def datasets(
         self,
@@ -133,6 +138,10 @@ class Query:
             data=[to_gql_dataset(dataset) for dataset in datasets], args=args
         )
 
+    @strawberry.field
+    def datasets_last_updated_at(self, info: Info[Context, None]) -> Optional[datetime]:
+        return info.context.last_updated_at.get(models.Dataset)
+
     @strawberry.field
     async def compare_experiments(
         self,

phoenix/server/api/routers/v1/datasets.py

@@ -60,6 +60,7 @@ from phoenix.server.api.types.DatasetExample import DatasetExample as DatasetExa
 from phoenix.server.api.types.DatasetVersion import DatasetVersion as DatasetVersionNodeType
 from phoenix.server.api.types.node import from_global_id_with_expected_type
 from phoenix.server.api.utils import delete_projects, delete_traces
+from phoenix.server.dml_event import DatasetInsertEvent
 
 from .pydantic_compat import V1RoutesBaseModel
 from .utils import (
@@ -481,6 +482,7 @@ async def upload_dataset(
     if sync:
         async with request.app.state.db() as session:
             dataset_id = (await operation(session)).dataset_id
+        request.state.event_queue.put(DatasetInsertEvent((dataset_id,)))
         return UploadDatasetResponseBody(
             data=UploadDatasetData(dataset_id=str(GlobalID(Dataset.__name__, str(dataset_id))))
         )

phoenix/server/api/routers/v1/experiment_evaluations.py

@@ -11,6 +11,7 @@ from phoenix.db import models
 from phoenix.db.helpers import SupportedSQLDialect
 from phoenix.db.insertion.helpers import insert_on_conflict
 from phoenix.server.api.types.node import from_global_id_with_expected_type
+from phoenix.server.dml_event import ExperimentRunAnnotationInsertEvent
 
 from .pydantic_compat import V1RoutesBaseModel
 from .utils import ResponseBody, add_errors_to_responses
@@ -108,6 +109,7 @@ async def upsert_experiment_evaluation(
             ).returning(models.ExperimentRunAnnotation)
         )
     evaluation_gid = GlobalID("ExperimentEvaluation", str(exp_eval_run.id))
+    request.state.event_queue.put(ExperimentRunAnnotationInsertEvent((exp_eval_run.id,)))
     return UpsertExperimentEvaluationResponseBody(
         data=UpsertExperimentEvaluationResponseBodyData(id=str(evaluation_gid))
     )

phoenix/server/api/routers/v1/experiment_runs.py

@@ -11,6 +11,7 @@ from strawberry.relay import GlobalID
 from phoenix.db import models
 from phoenix.db.models import ExperimentRunOutput
 from phoenix.server.api.types.node import from_global_id_with_expected_type
+from phoenix.server.dml_event import ExperimentRunInsertEvent
 
 from .pydantic_compat import V1RoutesBaseModel
 from .utils import ResponseBody, add_errors_to_responses
@@ -102,6 +103,7 @@ async def create_experiment_run(
         )
         session.add(exp_run)
         await session.flush()
+    request.state.event_queue.put(ExperimentRunInsertEvent((exp_run.id,)))
     run_gid = GlobalID("ExperimentRun", str(exp_run.id))
     return CreateExperimentResponseBody(data=CreateExperimentRunResponseBodyData(id=str(run_gid)))
 

phoenix/server/api/routers/v1/experiments.py

@@ -13,6 +13,7 @@ from phoenix.db import models
 from phoenix.db.helpers import SupportedSQLDialect
 from phoenix.db.insertion.helpers import insert_on_conflict
 from phoenix.server.api.types.node import from_global_id_with_expected_type
+from phoenix.server.dml_event import ExperimentInsertEvent
 
 from .pydantic_compat import V1RoutesBaseModel
 from .utils import ResponseBody, add_errors_to_responses
@@ -188,6 +189,7 @@ async def create_experiment(
             dataset_version_globalid = GlobalID(
                 "DatasetVersion", str(experiment.dataset_version_id)
             )
+    request.state.event_queue.put(ExperimentInsertEvent((experiment.id,)))
     return CreateExperimentResponseBody(
         data=Experiment(
             id=str(experiment_globalid),