arize-phoenix 10.0.4__py3-none-any.whl → 12.28.1__py3-none-any.whl

phoenix/server/api/types/Project.py

@@ -1,48 +1,54 @@
-from __future__ import annotations
-
 import operator
-from datetime import datetime, timedelta
-from typing import TYPE_CHECKING, Annotated, Any, ClassVar, Optional
+from datetime import datetime, timezone
+from typing import TYPE_CHECKING, Annotated, Any, Literal, Optional, cast
 
 import strawberry
-from aioitertools.itertools import islice
+from aioitertools.itertools import groupby, islice
 from openinference.semconv.trace import SpanAttributes
-from sqlalchemy import desc, distinct, func, or_, select
+from sqlalchemy import and_, case, desc, distinct, exists, func, or_, select
 from sqlalchemy.dialects import postgresql, sqlite
-from sqlalchemy.sql.elements import ColumnElement
 from sqlalchemy.sql.expression import tuple_
-from strawberry import ID, UNSET, Private, lazy
-from strawberry.relay import Connection, Node, NodeID
+from sqlalchemy.sql.functions import percentile_cont
+from strawberry import ID, UNSET, lazy
+from strawberry.relay import Connection, Edge, Node, NodeID, PageInfo
 from strawberry.types import Info
 from typing_extensions import assert_never
 
-from phoenix.datetime_utils import right_open_time_range
+from phoenix.datetime_utils import get_timestamp_range, normalize_datetime, right_open_time_range
 from phoenix.db import models
-from phoenix.db.helpers import SupportedSQLDialect
+from phoenix.db.helpers import SupportedSQLDialect, date_trunc
 from phoenix.server.api.context import Context
+from phoenix.server.api.exceptions import BadRequest
 from phoenix.server.api.input_types.ProjectSessionSort import (
-    ProjectSessionColumn,
     ProjectSessionSort,
+    ProjectSessionSortConfig,
 )
-from phoenix.server.api.input_types.SpanSort import SpanSort, SpanSortConfig
+from phoenix.server.api.input_types.SpanSort import SpanColumn, SpanSort, SpanSortConfig
+from phoenix.server.api.input_types.TimeBinConfig import TimeBinConfig, TimeBinScale
 from phoenix.server.api.input_types.TimeRange import TimeRange
 from phoenix.server.api.types.AnnotationConfig import AnnotationConfig, to_gql_annotation_config
 from phoenix.server.api.types.AnnotationSummary import AnnotationSummary
+from phoenix.server.api.types.CostBreakdown import CostBreakdown
 from phoenix.server.api.types.DocumentEvaluationSummary import DocumentEvaluationSummary
+from phoenix.server.api.types.GenerativeModel import GenerativeModel
 from phoenix.server.api.types.pagination import (
     ConnectionArgs,
     Cursor,
     CursorSortColumn,
+    CursorSortColumnDataType,
     CursorString,
     connection_from_cursors_and_nodes,
     connection_from_list,
 )
-from phoenix.server.api.types.ProjectSession import ProjectSession, to_gql_project_session
+from phoenix.server.api.types.ProjectSession import ProjectSession
 from phoenix.server.api.types.SortDir import SortDir
 from phoenix.server.api.types.Span import Span
+from phoenix.server.api.types.SpanCostSummary import SpanCostSummary
 from phoenix.server.api.types.TimeSeries import TimeSeries, TimeSeriesDataPoint
 from phoenix.server.api.types.Trace import Trace
 from phoenix.server.api.types.ValidationResult import ValidationResult
+from phoenix.server.session_filters import get_filtered_session_rowids_subquery
+from phoenix.server.types import DbSessionFactory
 from phoenix.trace.dsl import SpanFilter
 
 DEFAULT_PAGE_SIZE = 30
@@ -52,12 +58,11 @@ if TYPE_CHECKING:
 
 @strawberry.type
 class Project(Node):
-    _table: ClassVar[type[models.Base]] = models.Project
-    project_rowid: NodeID[int]
-    db_project: Private[models.Project] = UNSET
+    id: NodeID[int]
+    db_record: strawberry.Private[Optional[models.Project]] = None
 
     def __post_init__(self) -> None:
-        if self.db_project and self.project_rowid != self.db_project.id:
+        if self.db_record and self.id != self.db_record.id:
             raise ValueError("Project ID mismatch")
 
     @strawberry.field
@@ -65,11 +70,11 @@ class Project(Node):
         self,
         info: Info[Context, None],
     ) -> str:
-        if self.db_project:
-            name = self.db_project.name
+        if self.db_record:
+            name = self.db_record.name
         else:
             name = await info.context.data_loaders.project_fields.load(
-                (self.project_rowid, models.Project.name),
+                (self.id, models.Project.name),
             )
         return name
 
@@ -78,11 +83,11 @@ class Project(Node):
         self,
         info: Info[Context, None],
     ) -> str:
-        if self.db_project:
-            gradient_start_color = self.db_project.gradient_start_color
+        if self.db_record:
+            gradient_start_color = self.db_record.gradient_start_color
         else:
             gradient_start_color = await info.context.data_loaders.project_fields.load(
-                (self.project_rowid, models.Project.gradient_start_color),
+                (self.id, models.Project.gradient_start_color),
             )
         return gradient_start_color
 
@@ -91,11 +96,11 @@ class Project(Node):
         self,
         info: Info[Context, None],
     ) -> str:
-        if self.db_project:
-            gradient_end_color = self.db_project.gradient_end_color
+        if self.db_record:
+            gradient_end_color = self.db_record.gradient_end_color
         else:
             gradient_end_color = await info.context.data_loaders.project_fields.load(
-                (self.project_rowid, models.Project.gradient_end_color),
+                (self.id, models.Project.gradient_end_color),
             )
         return gradient_end_color
 
@@ -105,7 +110,7 @@ class Project(Node):
         info: Info[Context, None],
     ) -> Optional[datetime]:
         start_time = await info.context.data_loaders.min_start_or_max_end_times.load(
-            (self.project_rowid, "start"),
+            (self.id, "start"),
         )
         start_time, _ = right_open_time_range(start_time, None)
         return start_time
@@ -116,7 +121,7 @@ class Project(Node):
         info: Info[Context, None],
     ) -> Optional[datetime]:
         end_time = await info.context.data_loaders.min_start_or_max_end_times.load(
-            (self.project_rowid, "end"),
+            (self.id, "end"),
         )
         _, end_time = right_open_time_range(None, end_time)
         return end_time
@@ -127,9 +132,21 @@ class Project(Node):
         info: Info[Context, None],
         time_range: Optional[TimeRange] = UNSET,
         filter_condition: Optional[str] = UNSET,
+        session_filter_condition: Optional[str] = UNSET,
     ) -> int:
+        if filter_condition and session_filter_condition:
+            raise BadRequest(
+                "Both a filter condition and session filter condition "
+                "cannot be applied at the same time"
+            )
         return await info.context.data_loaders.record_counts.load(
-            ("span", self.project_rowid, time_range, filter_condition),
+            (
+                "span",
+                self.id,
+                time_range or None,
+                filter_condition or None,
+                session_filter_condition or None,
+            ),
         )
 
     @strawberry.field
@@ -137,9 +154,22 @@ class Project(Node):
         self,
         info: Info[Context, None],
         time_range: Optional[TimeRange] = UNSET,
+        filter_condition: Optional[str] = UNSET,
+        session_filter_condition: Optional[str] = UNSET,
     ) -> int:
+        if filter_condition and session_filter_condition:
+            raise BadRequest(
+                "Both a filter condition and session filter condition "
+                "cannot be applied at the same time"
+            )
         return await info.context.data_loaders.record_counts.load(
-            ("trace", self.project_rowid, time_range, None),
+            (
+                "trace",
+                self.id,
+                time_range or None,
+                filter_condition or None,
+                session_filter_condition or None,
+            ),
         )
 
     @strawberry.field
@@ -150,7 +180,7 @@ class Project(Node):
         filter_condition: Optional[str] = UNSET,
     ) -> float:
         return await info.context.data_loaders.token_counts.load(
-            ("total", self.project_rowid, time_range, filter_condition),
+            ("total", self.id, time_range, filter_condition),
         )
 
     @strawberry.field
@@ -161,7 +191,7 @@ class Project(Node):
         filter_condition: Optional[str] = UNSET,
     ) -> float:
         return await info.context.data_loaders.token_counts.load(
-            ("prompt", self.project_rowid, time_range, filter_condition),
+            ("prompt", self.id, time_range, filter_condition),
         )
 
     @strawberry.field
@@ -172,7 +202,43 @@ class Project(Node):
         filter_condition: Optional[str] = UNSET,
     ) -> float:
         return await info.context.data_loaders.token_counts.load(
-            ("completion", self.project_rowid, time_range, filter_condition),
+            ("completion", self.id, time_range, filter_condition),
+        )
+
+    @strawberry.field
+    async def cost_summary(
+        self,
+        info: Info[Context, None],
+        time_range: Optional[TimeRange] = UNSET,
+        filter_condition: Optional[str] = UNSET,
+        session_filter_condition: Optional[str] = UNSET,
+    ) -> SpanCostSummary:
+        if filter_condition and session_filter_condition:
+            raise BadRequest(
+                "Both a filter condition and session filter condition "
+                "cannot be applied at the same time"
+            )
+        summary = await info.context.data_loaders.span_cost_summary_by_project.load(
+            (
+                self.id,
+                time_range or None,
+                filter_condition or None,
+                session_filter_condition or None,
+            )
+        )
+        return SpanCostSummary(
+            prompt=CostBreakdown(
+                tokens=summary.prompt.tokens,
+                cost=summary.prompt.cost,
+            ),
+            completion=CostBreakdown(
+                tokens=summary.completion.tokens,
+                cost=summary.completion.cost,
+            ),
+            total=CostBreakdown(
+                tokens=summary.total.tokens,
+                cost=summary.total.cost,
+            ),
         )
 
     @strawberry.field
@@ -181,13 +247,21 @@ class Project(Node):
         info: Info[Context, None],
         probability: float,
         time_range: Optional[TimeRange] = UNSET,
+        filter_condition: Optional[str] = UNSET,
+        session_filter_condition: Optional[str] = UNSET,
     ) -> Optional[float]:
+        if filter_condition and session_filter_condition:
+            raise BadRequest(
+                "Both a filter condition and session filter condition "
+                "cannot be applied at the same time"
+            )
         return await info.context.data_loaders.latency_ms_quantile.load(
             (
                 "trace",
-                self.project_rowid,
-                time_range,
-                None,
+                self.id,
+                time_range or None,
+                filter_condition or None,
+                session_filter_condition or None,
                 probability,
             ),
         )
@@ -199,13 +273,20 @@ class Project(Node):
         probability: float,
         time_range: Optional[TimeRange] = UNSET,
         filter_condition: Optional[str] = UNSET,
+        session_filter_condition: Optional[str] = UNSET,
     ) -> Optional[float]:
+        if filter_condition and session_filter_condition:
+            raise BadRequest(
+                "Both a filter condition and session filter condition "
+                "cannot be applied at the same time"
+            )
         return await info.context.data_loaders.latency_ms_quantile.load(
             (
                 "span",
-                self.project_rowid,
-                time_range,
-                filter_condition,
+                self.id,
+                time_range or None,
+                filter_condition or None,
+                session_filter_condition or None,
                 probability,
             ),
         )
@@ -215,12 +296,12 @@ class Project(Node):
         stmt = (
             select(models.Trace)
             .where(models.Trace.trace_id == str(trace_id))
-            .where(models.Trace.project_rowid == self.project_rowid)
+            .where(models.Trace.project_rowid == self.id)
         )
         async with info.context.db() as session:
             if (trace := await session.scalar(stmt)) is None:
                 return None
-        return Trace(trace_rowid=trace.id, db_trace=trace)
+        return Trace(id=trace.id, db_record=trace)
 
     @strawberry.field
     async def spans(
@@ -236,10 +317,21 @@ class Project(Node):
         filter_condition: Optional[str] = UNSET,
         orphan_span_as_root_span: Optional[bool] = True,
     ) -> Connection[Span]:
+        if root_spans_only and not filter_condition and sort and sort.col is SpanColumn.startTime:
+            return await _paginate_span_by_trace_start_time(
+                db=info.context.db,
+                project_rowid=self.id,
+                time_range=time_range,
+                first=first,
+                after=after,
+                sort=sort,
+                orphan_span_as_root_span=orphan_span_as_root_span,
+            )
         stmt = (
             select(models.Span.id)
+            .select_from(models.Span)
             .join(models.Trace)
-            .where(models.Trace.project_rowid == self.project_rowid)
+            .where(models.Trace.project_rowid == self.id)
         )
         if time_range:
             if time_range.start:
@@ -261,12 +353,16 @@ class Project(Node):
             if sort_config and cursor.sort_column:
                 sort_column = cursor.sort_column
                 compare = operator.lt if sort_config.dir is SortDir.desc else operator.gt
-                stmt = stmt.where(
-                    compare(
-                        tuple_(sort_config.orm_expression, models.Span.id),
-                        (sort_column.value, cursor.rowid),
+                if sort_column.type is CursorSortColumnDataType.NULL:
+                    stmt = stmt.where(sort_config.orm_expression.is_(None))
+                    stmt = stmt.where(compare(models.Span.id, cursor.rowid))
+                else:
+                    stmt = stmt.where(
+                        compare(
+                            tuple_(sort_config.orm_expression, models.Span.id),
+                            (sort_column.value, cursor.rowid),
+                        )
                     )
-                )
             else:
                 stmt = stmt.where(models.Span.id > cursor.rowid)
         stmt = stmt.order_by(cursor_rowid_column)
@@ -304,7 +400,7 @@ class Project(Node):
                         type=sort_config.column_data_type,
                         value=span_record[1],
                     )
-                cursors_and_nodes.append((cursor, Span(span_rowid=span_rowid)))
+                cursors_and_nodes.append((cursor, Span(id=span_rowid)))
             has_next_page = True
             try:
                 await span_records.__anext__()
@@ -326,87 +422,66 @@ class Project(Node):
         after: Optional[CursorString] = UNSET,
         sort: Optional[ProjectSessionSort] = UNSET,
         filter_io_substring: Optional[str] = UNSET,
+        session_id: Optional[str] = UNSET,
     ) -> Connection[ProjectSession]:
         table = models.ProjectSession
-        stmt = select(table).filter_by(project_id=self.project_rowid)
+        if session_id:
+            async with info.context.db() as session:
+                ans = await session.scalar(
+                    select(table).filter_by(
+                        session_id=session_id,
+                        project_id=self.id,
+                    )
+                )
+            if ans:
+                return connection_from_list(
+                    data=[ProjectSession(id=ans.id, db_record=ans)],
+                    args=ConnectionArgs(),
+                )
+            elif not filter_io_substring:
+                return connection_from_list(
+                    data=[],
+                    args=ConnectionArgs(),
+                )
+        stmt = select(table).filter_by(project_id=self.id)
         if time_range:
             if time_range.start:
                 stmt = stmt.where(time_range.start <= table.start_time)
             if time_range.end:
                 stmt = stmt.where(table.start_time < time_range.end)
         if filter_io_substring:
-            filter_subq = (
-                stmt.with_only_columns(distinct(table.id).label("id"))
-                .join_from(table, models.Trace)
-                .join_from(models.Trace, models.Span)
-                .where(models.Span.parent_id.is_(None))
-                .where(
-                    or_(
-                        models.TextContains(
-                            models.Span.attributes[INPUT_VALUE].as_string(),
-                            filter_io_substring,
-                        ),
-                        models.TextContains(
-                            models.Span.attributes[OUTPUT_VALUE].as_string(),
-                            filter_io_substring,
-                        ),
-                    )
-                )
-            ).subquery()
-            stmt = stmt.join(filter_subq, table.id == filter_subq.c.id)
+            filtered_session_rowids = get_filtered_session_rowids_subquery(
+                session_filter_condition=filter_io_substring,
+                project_rowids=[self.id],
+                start_time=time_range.start if time_range else None,
+                end_time=time_range.end if time_range else None,
+            )
+            stmt = stmt.where(table.id.in_(filtered_session_rowids))
+        sort_config: Optional[ProjectSessionSortConfig] = None
+        cursor_rowid_column: Any = table.id
         if sort:
-            key: ColumnElement[Any]
-            if sort.col is ProjectSessionColumn.startTime:
-                key = table.start_time.label("key")
-            elif sort.col is ProjectSessionColumn.endTime:
-                key = table.end_time.label("key")
-            elif (
-                sort.col is ProjectSessionColumn.tokenCountTotal
-                or sort.col is ProjectSessionColumn.numTraces
-            ):
-                if sort.col is ProjectSessionColumn.tokenCountTotal:
-                    sort_subq = (
-                        select(
-                            models.Trace.project_session_rowid.label("id"),
-                            func.sum(models.Span.cumulative_llm_token_count_total).label("key"),
-                        )
-                        .join_from(models.Trace, models.Span)
-                        .where(models.Span.parent_id.is_(None))
-                        .group_by(models.Trace.project_session_rowid)
-                    ).subquery()
-                elif sort.col is ProjectSessionColumn.numTraces:
-                    sort_subq = (
-                        select(
-                            models.Trace.project_session_rowid.label("id"),
-                            func.count(models.Trace.id).label("key"),
-                        ).group_by(models.Trace.project_session_rowid)
-                    ).subquery()
+            sort_config = sort.update_orm_expr(stmt)
+            stmt = sort_config.stmt
+            if sort_config.dir is SortDir.desc:
+                cursor_rowid_column = desc(cursor_rowid_column)
+        if after:
+            cursor = Cursor.from_string(after)
+            if sort_config and cursor.sort_column:
+                sort_column = cursor.sort_column
+                compare = operator.lt if sort_config.dir is SortDir.desc else operator.gt
+                if sort_column.type is CursorSortColumnDataType.NULL:
+                    stmt = stmt.where(sort_config.orm_expression.is_(None))
+                    stmt = stmt.where(compare(table.id, cursor.rowid))
                 else:
-                    assert_never(sort.col)
-                key = sort_subq.c.key
-                stmt = stmt.join(sort_subq, table.id == sort_subq.c.id)
-            else:
-                assert_never(sort.col)
-            stmt = stmt.add_columns(key)
-            if sort.dir is SortDir.asc:
-                stmt = stmt.order_by(key.asc(), table.id.asc())
-            else:
-                stmt = stmt.order_by(key.desc(), table.id.desc())
-            if after:
-                cursor = Cursor.from_string(after)
-                assert cursor.sort_column is not None
-                compare = operator.lt if sort.dir is SortDir.desc else operator.gt
-                stmt = stmt.where(
-                    compare(
-                        tuple_(key, table.id),
-                        (cursor.sort_column.value, cursor.rowid),
+                    stmt = stmt.where(
+                        compare(
+                            tuple_(sort_config.orm_expression, table.id),
+                            (sort_column.value, cursor.rowid),
+                        )
                     )
-                )
-        else:
-            stmt = stmt.order_by(table.id.desc())
-            if after:
-                cursor = Cursor.from_string(after)
+            else:
                 stmt = stmt.where(table.id < cursor.rowid)
+        stmt = stmt.order_by(cursor_rowid_column)
         if first:
             stmt = stmt.limit(
                 first + 1  # over-fetch by one to determine whether there's a next page
@@ -417,13 +492,15 @@ class Project(Node):
             async for record in islice(records, first):
                 project_session = record[0]
                 cursor = Cursor(rowid=project_session.id)
-                if sort:
+                if sort_config:
                     assert len(record) > 1
                     cursor.sort_column = CursorSortColumn(
-                        type=sort.col.data_type,
+                        type=sort_config.column_data_type,
                         value=record[1],
                     )
-                cursors_and_nodes.append((cursor, to_gql_project_session(project_session)))
+                cursors_and_nodes.append(
+                    (cursor, ProjectSession(id=project_session.id, db_record=project_session))
+                )
             has_next_page = True
             try:
                 await records.__anext__()
@@ -446,7 +523,7 @@ class Project(Node):
         stmt = (
             select(distinct(models.TraceAnnotation.name))
             .join(models.Trace)
-            .where(models.Trace.project_rowid == self.project_rowid)
+            .where(models.Trace.project_rowid == self.id)
         )
         async with info.context.db() as session:
             return list(await session.scalars(stmt))
@@ -463,7 +540,23 @@ class Project(Node):
             select(distinct(models.SpanAnnotation.name))
             .join(models.Span)
             .join(models.Trace, models.Span.trace_rowid == models.Trace.id)
-            .where(models.Trace.project_rowid == self.project_rowid)
+            .where(models.Trace.project_rowid == self.id)
+        )
+        async with info.context.db() as session:
+            return list(await session.scalars(stmt))
+
+    @strawberry.field(
+        description="Names of all available annotations for sessions. "
+        "(The list contains no duplicates.)"
+    )  # type: ignore
+    async def session_annotation_names(
+        self,
+        info: Info[Context, None],
+    ) -> list[str]:
+        stmt = (
+            select(distinct(models.ProjectSessionAnnotation.name))
+            .join(models.ProjectSession)
+            .where(models.ProjectSession.project_id == self.id)
         )
         async with info.context.db() as session:
             return list(await session.scalars(stmt))
@@ -480,7 +573,7 @@ class Project(Node):
             select(distinct(models.DocumentAnnotation.name))
             .join(models.Span)
             .join(models.Trace, models.Span.trace_rowid == models.Trace.id)
-            .where(models.Trace.project_rowid == self.project_rowid)
+            .where(models.Trace.project_rowid == self.id)
             .where(models.DocumentAnnotation.annotator_kind == "LLM")
         )
         if span_id:
@@ -493,10 +586,24 @@ class Project(Node):
         self,
         info: Info[Context, None],
         annotation_name: str,
+        filter_condition: Optional[str] = UNSET,
+        session_filter_condition: Optional[str] = UNSET,
         time_range: Optional[TimeRange] = UNSET,
     ) -> Optional[AnnotationSummary]:
+        if filter_condition and session_filter_condition:
+            raise BadRequest(
+                "Both a filter condition and session filter condition "
+                "cannot be applied at the same time"
+            )
         return await info.context.data_loaders.annotation_summaries.load(
-            ("trace", self.project_rowid, time_range, None, annotation_name),
+            (
+                "trace",
+                self.id,
+                time_range or None,
+                filter_condition or None,
+                session_filter_condition or None,
+                annotation_name,
+            ),
         )
 
     @strawberry.field
@@ -506,9 +613,22 @@ class Project(Node):
         annotation_name: str,
         time_range: Optional[TimeRange] = UNSET,
         filter_condition: Optional[str] = UNSET,
+        session_filter_condition: Optional[str] = UNSET,
     ) -> Optional[AnnotationSummary]:
+        if filter_condition and session_filter_condition:
+            raise BadRequest(
+                "Both a filter condition and session filter condition "
+                "cannot be applied at the same time"
+            )
         return await info.context.data_loaders.annotation_summaries.load(
-            ("span", self.project_rowid, time_range, filter_condition, annotation_name),
+            (
+                "span",
+                self.id,
+                time_range or None,
+                filter_condition or None,
+                session_filter_condition or None,
+                annotation_name,
+            ),
         )
 
     @strawberry.field
@@ -520,7 +640,7 @@ class Project(Node):
         filter_condition: Optional[str] = UNSET,
     ) -> Optional[DocumentEvaluationSummary]:
         return await info.context.data_loaders.document_evaluation_summaries.load(
-            (self.project_rowid, time_range, filter_condition, evaluation_name),
+            (self.id, time_range, filter_condition, evaluation_name),
         )
 
     @strawberry.field
@@ -528,7 +648,7 @@ class Project(Node):
         self,
         info: Info[Context, None],
     ) -> Optional[datetime]:
-        return info.context.last_updated_at.get(self._table, self.project_rowid)
+        return info.context.last_updated_at.get(models.Project, self.id)
 
     @strawberry.field
     async def validate_span_filter_condition(
@@ -561,7 +681,7 @@ class Project(Node):
             stmt = span_filter(select(models.Span))
             dialect = info.context.db.dialect
             if dialect is SupportedSQLDialect.POSTGRESQL:
-                str(stmt.compile(dialect=sqlite.dialect()))  # type: ignore[no-untyped-call]
+                str(stmt.compile(dialect=sqlite.dialect()))
             elif dialect is SupportedSQLDialect.SQLITE:
                 str(stmt.compile(dialect=postgresql.dialect()))  # type: ignore[no-untyped-call]
             else:
@@ -588,30 +708,19 @@ class Project(Node):
             last=last,
             before=before if isinstance(before, CursorString) else None,
         )
-        async with info.context.db() as session:
-            annotation_configs = await session.stream_scalars(
-                select(models.AnnotationConfig)
-                .join(
-                    models.ProjectAnnotationConfig,
-                    models.AnnotationConfig.id
-                    == models.ProjectAnnotationConfig.annotation_config_id,
-                )
-                .where(models.ProjectAnnotationConfig.project_id == self.project_rowid)
-                .order_by(models.AnnotationConfig.name)
-            )
-            data = [to_gql_annotation_config(config) async for config in annotation_configs]
+        loader = info.context.data_loaders.annotation_configs_by_project
+        configs = await loader.load(self.id)
+        data = [to_gql_annotation_config(config) for config in configs]
         return connection_from_list(data=data, args=args)
 
     @strawberry.field
     async def trace_retention_policy(
         self,
         info: Info[Context, None],
-    ) -> Annotated[ProjectTraceRetentionPolicy, lazy(".ProjectTraceRetentionPolicy")]:
+    ) -> Annotated["ProjectTraceRetentionPolicy", lazy(".ProjectTraceRetentionPolicy")]:
         from .ProjectTraceRetentionPolicy import ProjectTraceRetentionPolicy
 
-        id_ = await info.context.data_loaders.trace_retention_policy_id_by_project_id.load(
-            self.project_rowid
-        )
+        id_ = await info.context.data_loaders.trace_retention_policy_id_by_project_id.load(self.id)
         return ProjectTraceRetentionPolicy(id=id_)
 
     @strawberry.field
@@ -619,11 +728,11 @@ class Project(Node):
         self,
         info: Info[Context, None],
     ) -> datetime:
-        if self.db_project:
-            created_at = self.db_project.created_at
+        if self.db_record:
+            created_at = self.db_record.created_at
         else:
             created_at = await info.context.data_loaders.project_fields.load(
-                (self.project_rowid, models.Project.created_at),
+                (self.id, models.Project.created_at),
             )
         return created_at
 
@@ -632,96 +741,841 @@ class Project(Node):
         self,
         info: Info[Context, None],
     ) -> datetime:
-        if self.db_project:
-            updated_at = self.db_project.updated_at
+        if self.db_record:
+            updated_at = self.db_record.updated_at
         else:
             updated_at = await info.context.data_loaders.project_fields.load(
-                (self.project_rowid, models.Project.updated_at),
+                (self.id, models.Project.updated_at),
             )
         return updated_at
 
-    @strawberry.field(
-        description="Hourly span count for the project.",
-    )  # type: ignore
+    @strawberry.field
     async def span_count_time_series(
         self,
         info: Info[Context, None],
-        time_range: Optional[TimeRange] = UNSET,
-    ) -> SpanCountTimeSeries:
-        """Returns a time series of span counts grouped by hour for the project.
+        time_range: TimeRange,
+        time_bin_config: Optional[TimeBinConfig] = UNSET,
+        filter_condition: Optional[str] = UNSET,
+    ) -> "SpanCountTimeSeries":
+        if time_range.start is None:
+            raise BadRequest("Start time is required")
 
-        This field provides hourly aggregated span counts, which can be useful for
-        visualizing span activity over time. The data points represent the number
-        of spans that started in each hour.
+        dialect = info.context.db.dialect
+        utc_offset_minutes = 0
+        field: Literal["minute", "hour", "day", "week", "month", "year"] = "hour"
+        if time_bin_config:
+            utc_offset_minutes = time_bin_config.utc_offset_minutes
+            if time_bin_config.scale is TimeBinScale.MINUTE:
+                field = "minute"
+            elif time_bin_config.scale is TimeBinScale.HOUR:
+                field = "hour"
+            elif time_bin_config.scale is TimeBinScale.DAY:
+                field = "day"
+            elif time_bin_config.scale is TimeBinScale.WEEK:
+                field = "week"
+            elif time_bin_config.scale is TimeBinScale.MONTH:
+                field = "month"
+            elif time_bin_config.scale is TimeBinScale.YEAR:
+                field = "year"
+        bucket = date_trunc(dialect, field, models.Span.start_time, utc_offset_minutes)
+        stmt = (
+            select(
+                bucket,
+                func.count(models.Span.id).label("total_count"),
+                func.sum(case((models.Span.status_code == "OK", 1), else_=0)).label("ok_count"),
+                func.sum(case((models.Span.status_code == "ERROR", 1), else_=0)).label(
+                    "error_count"
+                ),
+                func.sum(case((models.Span.status_code == "UNSET", 1), else_=0)).label(
+                    "unset_count"
+                ),
+            )
+            .join_from(models.Span, models.Trace)
+            .where(models.Trace.project_rowid == self.id)
+            .group_by(bucket)
+            .order_by(bucket)
+        )
+        if time_range.start:
+            stmt = stmt.where(time_range.start <= models.Span.start_time)
+        if time_range.end:
+            stmt = stmt.where(models.Span.start_time < time_range.end)
+        if filter_condition:
+            span_filter = SpanFilter(condition=filter_condition)
+            stmt = span_filter(stmt)
 
-        Args:
-            info: The GraphQL info object containing context information.
-            time_range: Optional time range to filter the spans. If provided, only
-                spans that started within this range will be counted.
+        data = {}
+        async with info.context.db() as session:
+            async for t, total_count, ok_count, error_count, unset_count in await session.stream(
+                stmt
+            ):
+                timestamp = _as_datetime(t)
+                data[timestamp] = SpanCountTimeSeriesDataPoint(
+                    timestamp=timestamp,
+                    ok_count=ok_count,
+                    error_count=error_count,
+                    unset_count=unset_count,
+                    total_count=total_count,
+                )
 
-        Returns:
-            A SpanCountTimeSeries object containing data points with timestamps
-            (rounded to the nearest hour) and corresponding span counts.
-
-        Notes:
-            - The timestamps are rounded down to the nearest hour.
-            - If a time range is provided, the start time is rounded down to the
-              nearest hour, and the end time is rounded up to the nearest hour.
-            - The SQL query is optimized for both PostgreSQL and SQLite databases.
-        """
-        # Determine the appropriate SQL function to truncate timestamps to hours
-        # based on the database dialect
-        if info.context.db.dialect is SupportedSQLDialect.POSTGRESQL:
-            # PostgreSQL uses date_trunc for timestamp truncation
-            hour = func.date_trunc("hour", models.Span.start_time)
-        elif info.context.db.dialect is SupportedSQLDialect.SQLITE:
-            # SQLite uses strftime for timestamp formatting
-            hour = func.strftime("%Y-%m-%dT%H:00:00.000+00:00", models.Span.start_time)
+        data_timestamps: list[datetime] = [data_point.timestamp for data_point in data.values()]
+        min_time = min([*data_timestamps, time_range.start])
+        max_time = max(
+            [
+                *data_timestamps,
+                *([time_range.end] if time_range.end else [datetime.now(timezone.utc)]),
+            ],
+        )
+        for timestamp in get_timestamp_range(
+            start_time=min_time,
+            end_time=max_time,
+            stride=field,
+            utc_offset_minutes=utc_offset_minutes,
+        ):
+            if timestamp not in data:
+                data[timestamp] = SpanCountTimeSeriesDataPoint(timestamp=timestamp)
+        return SpanCountTimeSeries(data=sorted(data.values(), key=lambda x: x.timestamp))
+
+    @strawberry.field
+    async def trace_count_time_series(
+        self,
+        info: Info[Context, None],
+        time_range: TimeRange,
+        time_bin_config: Optional[TimeBinConfig] = UNSET,
+    ) -> "TraceCountTimeSeries":
+        if time_range.start is None:
+            raise BadRequest("Start time is required")
+
+        dialect = info.context.db.dialect
+        utc_offset_minutes = 0
+        field: Literal["minute", "hour", "day", "week", "month", "year"] = "hour"
+        if time_bin_config:
+            utc_offset_minutes = time_bin_config.utc_offset_minutes
+            if time_bin_config.scale is TimeBinScale.MINUTE:
+                field = "minute"
+            elif time_bin_config.scale is TimeBinScale.HOUR:
+                field = "hour"
+            elif time_bin_config.scale is TimeBinScale.DAY:
+                field = "day"
+            elif time_bin_config.scale is TimeBinScale.WEEK:
+                field = "week"
+            elif time_bin_config.scale is TimeBinScale.MONTH:
+                field = "month"
+            elif time_bin_config.scale is TimeBinScale.YEAR:
+                field = "year"
+        bucket = date_trunc(dialect, field, models.Trace.start_time, utc_offset_minutes)
+        stmt = (
+            select(bucket, func.count(models.Trace.id))
+            .where(models.Trace.project_rowid == self.id)
+            .group_by(bucket)
+            .order_by(bucket)
+        )
+        if time_range:
+            if time_range.start:
+                stmt = stmt.where(time_range.start <= models.Trace.start_time)
+            if time_range.end:
+                stmt = stmt.where(models.Trace.start_time < time_range.end)
+        data = {}
+        async with info.context.db() as session:
+            async for t, v in await session.stream(stmt):
+                timestamp = _as_datetime(t)
+                data[timestamp] = TimeSeriesDataPoint(timestamp=timestamp, value=v)
+
+        data_timestamps: list[datetime] = [data_point.timestamp for data_point in data.values()]
+        min_time = min([*data_timestamps, time_range.start])
+        max_time = max(
+            [
+                *data_timestamps,
+                *([time_range.end] if time_range.end else [datetime.now(timezone.utc)]),
+            ],
+        )
+        for timestamp in get_timestamp_range(
+            start_time=min_time,
+            end_time=max_time,
+            stride=field,
+            utc_offset_minutes=utc_offset_minutes,
+        ):
+            if timestamp not in data:
+                data[timestamp] = TimeSeriesDataPoint(timestamp=timestamp)
+        return TraceCountTimeSeries(data=sorted(data.values(), key=lambda x: x.timestamp))
+
+    @strawberry.field
+    async def trace_count_by_status_time_series(
+        self,
+        info: Info[Context, None],
+        time_range: TimeRange,
+        time_bin_config: Optional[TimeBinConfig] = UNSET,
+    ) -> "TraceCountByStatusTimeSeries":
+        if time_range.start is None:
+            raise BadRequest("Start time is required")
+
+        dialect = info.context.db.dialect
+        utc_offset_minutes = 0
+        field: Literal["minute", "hour", "day", "week", "month", "year"] = "hour"
+        if time_bin_config:
+            utc_offset_minutes = time_bin_config.utc_offset_minutes
+            if time_bin_config.scale is TimeBinScale.MINUTE:
+                field = "minute"
+            elif time_bin_config.scale is TimeBinScale.HOUR:
+                field = "hour"
+            elif time_bin_config.scale is TimeBinScale.DAY:
+                field = "day"
+            elif time_bin_config.scale is TimeBinScale.WEEK:
+                field = "week"
+            elif time_bin_config.scale is TimeBinScale.MONTH:
+                field = "month"
+            elif time_bin_config.scale is TimeBinScale.YEAR:
+                field = "year"
+        bucket = date_trunc(dialect, field, models.Trace.start_time, utc_offset_minutes)
+        trace_error_status_counts = (
+            select(
+                models.Span.trace_rowid,
+            )
+            .where(models.Span.parent_id.is_(None))
+            .group_by(models.Span.trace_rowid)
+            .having(func.max(models.Span.cumulative_error_count) > 0)
+        ).subquery()
+        stmt = (
+            select(
+                bucket,
+                func.count(models.Trace.id).label("total_count"),
+                func.coalesce(func.count(trace_error_status_counts.c.trace_rowid), 0).label(
+                    "error_count"
+                ),
+            )
+            .join_from(
+                models.Trace,
+                trace_error_status_counts,
+                onclause=trace_error_status_counts.c.trace_rowid == models.Trace.id,
+                isouter=True,
+            )
+            .where(models.Trace.project_rowid == self.id)
+            .group_by(bucket)
+            .order_by(bucket)
+        )
+        if time_range:
+            if time_range.start:
+                stmt = stmt.where(time_range.start <= models.Trace.start_time)
+            if time_range.end:
+                stmt = stmt.where(models.Trace.start_time < time_range.end)
+        data: dict[datetime, TraceCountByStatusTimeSeriesDataPoint] = {}
+        async with info.context.db() as session:
+            async for t, total_count, error_count in await session.stream(stmt):
+                timestamp = _as_datetime(t)
+                data[timestamp] = TraceCountByStatusTimeSeriesDataPoint(
+                    timestamp=timestamp,
+                    ok_count=total_count - error_count,
+                    error_count=error_count,
+                    total_count=total_count,
+                )
+
+        data_timestamps: list[datetime] = [data_point.timestamp for data_point in data.values()]
+        min_time = min([*data_timestamps, time_range.start])
+        max_time = max(
+            [
+                *data_timestamps,
+                *([time_range.end] if time_range.end else [datetime.now(timezone.utc)]),
+            ],
+        )
+        for timestamp in get_timestamp_range(
+            start_time=min_time,
+            end_time=max_time,
+            stride=field,
+            utc_offset_minutes=utc_offset_minutes,
+        ):
+            if timestamp not in data:
+                data[timestamp] = TraceCountByStatusTimeSeriesDataPoint(
+                    timestamp=timestamp,
+                    ok_count=0,
+                    error_count=0,
+                    total_count=0,
+                )
+        return TraceCountByStatusTimeSeries(data=sorted(data.values(), key=lambda x: x.timestamp))
+
+    @strawberry.field
+    async def trace_latency_ms_percentile_time_series(
+        self,
+        info: Info[Context, None],
+        time_range: TimeRange,
+        time_bin_config: Optional[TimeBinConfig] = UNSET,
+    ) -> "TraceLatencyPercentileTimeSeries":
+        if time_range.start is None:
+            raise BadRequest("Start time is required")
+
+        dialect = info.context.db.dialect
+        utc_offset_minutes = 0
+        field: Literal["minute", "hour", "day", "week", "month", "year"] = "hour"
+        if time_bin_config:
+            utc_offset_minutes = time_bin_config.utc_offset_minutes
+            if time_bin_config.scale is TimeBinScale.MINUTE:
+                field = "minute"
+            elif time_bin_config.scale is TimeBinScale.HOUR:
+                field = "hour"
+            elif time_bin_config.scale is TimeBinScale.DAY:
+                field = "day"
+            elif time_bin_config.scale is TimeBinScale.WEEK:
+                field = "week"
+            elif time_bin_config.scale is TimeBinScale.MONTH:
+                field = "month"
+            elif time_bin_config.scale is TimeBinScale.YEAR:
+                field = "year"
+        bucket = date_trunc(dialect, field, models.Trace.start_time, utc_offset_minutes)
+
+        stmt = select(bucket).where(models.Trace.project_rowid == self.id)
+        if time_range.start:
+            stmt = stmt.where(time_range.start <= models.Trace.start_time)
+        if time_range.end:
+            stmt = stmt.where(models.Trace.start_time < time_range.end)
+
+        if dialect is SupportedSQLDialect.POSTGRESQL:
+            stmt = stmt.add_columns(
+                percentile_cont(0.50).within_group(models.Trace.latency_ms.asc()).label("p50"),
+                percentile_cont(0.75).within_group(models.Trace.latency_ms.asc()).label("p75"),
+                percentile_cont(0.90).within_group(models.Trace.latency_ms.asc()).label("p90"),
+                percentile_cont(0.95).within_group(models.Trace.latency_ms.asc()).label("p95"),
+                percentile_cont(0.99).within_group(models.Trace.latency_ms.asc()).label("p99"),
+                percentile_cont(0.999).within_group(models.Trace.latency_ms.asc()).label("p999"),
+                func.max(models.Trace.latency_ms).label("max"),
+            )
+        elif dialect is SupportedSQLDialect.SQLITE:
+            stmt = stmt.add_columns(
+                func.percentile(models.Trace.latency_ms, 50).label("p50"),
+                func.percentile(models.Trace.latency_ms, 75).label("p75"),
+                func.percentile(models.Trace.latency_ms, 90).label("p90"),
+                func.percentile(models.Trace.latency_ms, 95).label("p95"),
+                func.percentile(models.Trace.latency_ms, 99).label("p99"),
+                func.percentile(models.Trace.latency_ms, 99.9).label("p999"),
+                func.max(models.Trace.latency_ms).label("max"),
+            )
         else:
-            assert_never(info.context.db.dialect)
+            assert_never(dialect)
+
+        stmt = stmt.group_by(bucket).order_by(bucket)
+
+        data: dict[datetime, TraceLatencyMsPercentileTimeSeriesDataPoint] = {}
+        async with info.context.db() as session:
+            async for (
+                bucket_time,
+                p50,
+                p75,
+                p90,
+                p95,
+                p99,
+                p999,
+                max_latency,
+            ) in await session.stream(stmt):
+                timestamp = _as_datetime(bucket_time)
+                data[timestamp] = TraceLatencyMsPercentileTimeSeriesDataPoint(
+                    timestamp=timestamp,
+                    p50=p50,
+                    p75=p75,
+                    p90=p90,
+                    p95=p95,
+                    p99=p99,
+                    p999=p999,
+                    max=max_latency,
+                )
+
+        data_timestamps: list[datetime] = [data_point.timestamp for data_point in data.values()]
+        min_time = min([*data_timestamps, time_range.start])
+        max_time = max(
+            [
+                *data_timestamps,
+                *([time_range.end] if time_range.end else [datetime.now(timezone.utc)]),
+            ],
+        )
+        for timestamp in get_timestamp_range(
+            start_time=min_time,
+            end_time=max_time,
+            stride=field,
+            utc_offset_minutes=utc_offset_minutes,
+        ):
+            if timestamp not in data:
+                data[timestamp] = TraceLatencyMsPercentileTimeSeriesDataPoint(timestamp=timestamp)
+        return TraceLatencyPercentileTimeSeries(
+            data=sorted(data.values(), key=lambda x: x.timestamp)
+        )
 
-        # Build the base query to count spans grouped by hour
+    @strawberry.field
+    async def trace_token_count_time_series(
+        self,
+        info: Info[Context, None],
+        time_range: TimeRange,
+        time_bin_config: Optional[TimeBinConfig] = UNSET,
+    ) -> "TraceTokenCountTimeSeries":
+        if time_range.start is None:
+            raise BadRequest("Start time is required")
+
+        dialect = info.context.db.dialect
+        utc_offset_minutes = 0
+        field: Literal["minute", "hour", "day", "week", "month", "year"] = "hour"
+        if time_bin_config:
+            utc_offset_minutes = time_bin_config.utc_offset_minutes
+            if time_bin_config.scale is TimeBinScale.MINUTE:
+                field = "minute"
+            elif time_bin_config.scale is TimeBinScale.HOUR:
+                field = "hour"
+            elif time_bin_config.scale is TimeBinScale.DAY:
+                field = "day"
+            elif time_bin_config.scale is TimeBinScale.WEEK:
+                field = "week"
+            elif time_bin_config.scale is TimeBinScale.MONTH:
+                field = "month"
+            elif time_bin_config.scale is TimeBinScale.YEAR:
+                field = "year"
+        bucket = date_trunc(dialect, field, models.Trace.start_time, utc_offset_minutes)
         stmt = (
-            select(hour, func.count())
-            .join(models.Trace)
-            .where(models.Trace.project_rowid == self.project_rowid)
-            .group_by(hour)
-            .order_by(hour)
+            select(
+                bucket,
+                func.sum(models.SpanCost.total_tokens),
+                func.sum(models.SpanCost.prompt_tokens),
+                func.sum(models.SpanCost.completion_tokens),
+            )
+            .join_from(
+                models.Trace,
+                models.SpanCost,
+                onclause=models.SpanCost.trace_rowid == models.Trace.id,
+            )
+            .where(models.Trace.project_rowid == self.id)
+            .group_by(bucket)
+            .order_by(bucket)
         )
+        if time_range:
+            if time_range.start:
+                stmt = stmt.where(time_range.start <= models.Trace.start_time)
+            if time_range.end:
+                stmt = stmt.where(models.Trace.start_time < time_range.end)
+        data: dict[datetime, TraceTokenCountTimeSeriesDataPoint] = {}
+        async with info.context.db() as session:
+            async for (
+                t,
+                total_tokens,
+                prompt_tokens,
+                completion_tokens,
+            ) in await session.stream(stmt):
+                timestamp = _as_datetime(t)
+                data[timestamp] = TraceTokenCountTimeSeriesDataPoint(
+                    timestamp=timestamp,
+                    prompt_token_count=prompt_tokens,
+                    completion_token_count=completion_tokens,
+                    total_token_count=total_tokens,
+                )
 
-        # Apply time range filtering if provided
+        data_timestamps: list[datetime] = [data_point.timestamp for data_point in data.values()]
+        min_time = min([*data_timestamps, time_range.start])
+        max_time = max(
+            [
+                *data_timestamps,
+                *([time_range.end] if time_range.end else [datetime.now(timezone.utc)]),
+            ],
+        )
+        for timestamp in get_timestamp_range(
+            start_time=min_time,
+            end_time=max_time,
+            stride=field,
+            utc_offset_minutes=utc_offset_minutes,
+        ):
+            if timestamp not in data:
+                data[timestamp] = TraceTokenCountTimeSeriesDataPoint(timestamp=timestamp)
+        return TraceTokenCountTimeSeries(data=sorted(data.values(), key=lambda x: x.timestamp))
+
+    @strawberry.field
+    async def trace_token_cost_time_series(
+        self,
+        info: Info[Context, None],
+        time_range: TimeRange,
+        time_bin_config: Optional[TimeBinConfig] = UNSET,
+    ) -> "TraceTokenCostTimeSeries":
+        if time_range.start is None:
+            raise BadRequest("Start time is required")
+
+        dialect = info.context.db.dialect
+        utc_offset_minutes = 0
+        field: Literal["minute", "hour", "day", "week", "month", "year"] = "hour"
+        if time_bin_config:
+            utc_offset_minutes = time_bin_config.utc_offset_minutes
+            if time_bin_config.scale is TimeBinScale.MINUTE:
+                field = "minute"
+            elif time_bin_config.scale is TimeBinScale.HOUR:
+                field = "hour"
+            elif time_bin_config.scale is TimeBinScale.DAY:
+                field = "day"
+            elif time_bin_config.scale is TimeBinScale.WEEK:
+                field = "week"
+            elif time_bin_config.scale is TimeBinScale.MONTH:
+                field = "month"
+            elif time_bin_config.scale is TimeBinScale.YEAR:
+                field = "year"
+        bucket = date_trunc(dialect, field, models.Trace.start_time, utc_offset_minutes)
+        stmt = (
+            select(
+                bucket,
+                func.sum(models.SpanCost.total_cost),
+                func.sum(models.SpanCost.prompt_cost),
+                func.sum(models.SpanCost.completion_cost),
+            )
+            .join_from(
+                models.Trace,
+                models.SpanCost,
+                onclause=models.SpanCost.trace_rowid == models.Trace.id,
+            )
+            .where(models.Trace.project_rowid == self.id)
+            .group_by(bucket)
+            .order_by(bucket)
+        )
         if time_range:
-            if t := time_range.start:
-                # Round down to nearest hour for the start time
-                start = t.replace(minute=0, second=0, microsecond=0)
-                stmt = stmt.where(start <= models.Span.start_time)
-            if t := time_range.end:
-                # Round up to nearest hour for the end time
-                # If the time is already at the start of an hour, use it as is
-                if t.minute == 0 and t.second == 0 and t.microsecond == 0:
-                    end = t
-                else:
-                    # Otherwise, round up to the next hour
-                    end = t.replace(minute=0, second=0, microsecond=0) + timedelta(hours=1)
-                stmt = stmt.where(models.Span.start_time < end)
+            if time_range.start:
+                stmt = stmt.where(time_range.start <= models.Trace.start_time)
+            if time_range.end:
+                stmt = stmt.where(models.Trace.start_time < time_range.end)
+        data: dict[datetime, TraceTokenCostTimeSeriesDataPoint] = {}
+        async with info.context.db() as session:
+            async for (
+                t,
+                total_cost,
+                prompt_cost,
+                completion_cost,
+            ) in await session.stream(stmt):
+                timestamp = _as_datetime(t)
+                data[timestamp] = TraceTokenCostTimeSeriesDataPoint(
+                    timestamp=timestamp,
+                    prompt_cost=prompt_cost,
+                    completion_cost=completion_cost,
+                    total_cost=total_cost,
+                )
+
+        data_timestamps: list[datetime] = [data_point.timestamp for data_point in data.values()]
+        min_time = min([*data_timestamps, time_range.start])
+        max_time = max(
+            [
+                *data_timestamps,
+                *([time_range.end] if time_range.end else [datetime.now(timezone.utc)]),
+            ],
+        )
+        for timestamp in get_timestamp_range(
+            start_time=min_time,
+            end_time=max_time,
+            stride=field,
+            utc_offset_minutes=utc_offset_minutes,
+        ):
+            if timestamp not in data:
+                data[timestamp] = TraceTokenCostTimeSeriesDataPoint(timestamp=timestamp)
+        return TraceTokenCostTimeSeries(data=sorted(data.values(), key=lambda x: x.timestamp))
 
-        # Execute the query and convert the results to a time series
+    @strawberry.field
+    async def span_annotation_score_time_series(
+        self,
+        info: Info[Context, None],
+        time_range: TimeRange,
+        time_bin_config: Optional[TimeBinConfig] = UNSET,
+    ) -> "SpanAnnotationScoreTimeSeries":
+        if time_range.start is None:
+            raise BadRequest("Start time is required")
+
+        dialect = info.context.db.dialect
+        utc_offset_minutes = 0
+        field: Literal["minute", "hour", "day", "week", "month", "year"] = "hour"
+        if time_bin_config:
+            utc_offset_minutes = time_bin_config.utc_offset_minutes
+            if time_bin_config.scale is TimeBinScale.MINUTE:
+                field = "minute"
+            elif time_bin_config.scale is TimeBinScale.HOUR:
+                field = "hour"
+            elif time_bin_config.scale is TimeBinScale.DAY:
+                field = "day"
+            elif time_bin_config.scale is TimeBinScale.WEEK:
+                field = "week"
+            elif time_bin_config.scale is TimeBinScale.MONTH:
+                field = "month"
+            elif time_bin_config.scale is TimeBinScale.YEAR:
+                field = "year"
+        bucket = date_trunc(dialect, field, models.Trace.start_time, utc_offset_minutes)
+        stmt = (
+            select(
+                bucket,
+                models.SpanAnnotation.name,
+                func.avg(models.SpanAnnotation.score).label("average_score"),
+            )
+            .join_from(
+                models.SpanAnnotation,
+                models.Span,
+                onclause=models.SpanAnnotation.span_rowid == models.Span.id,
+            )
+            .join_from(
+                models.Span,
+                models.Trace,
+                onclause=models.Span.trace_rowid == models.Trace.id,
+            )
+            .where(models.Trace.project_rowid == self.id)
+            .group_by(bucket, models.SpanAnnotation.name)
+            .order_by(bucket)
+        )
+        if time_range:
+            if time_range.start:
+                stmt = stmt.where(time_range.start <= models.Trace.start_time)
+            if time_range.end:
+                stmt = stmt.where(models.Trace.start_time < time_range.end)
+        scores: dict[datetime, dict[str, float]] = {}
+        unique_names: set[str] = set()
         async with info.context.db() as session:
-            data = await session.stream(stmt)
-            return SpanCountTimeSeries(
-                data=[
-                    TimeSeriesDataPoint(
-                        timestamp=_as_datetime(t),
-                        value=v,
-                    )
-                    async for t, v in data
-                ]
+            async for (
+                t,
+                name,
+                average_score,
+            ) in await session.stream(stmt):
+                if average_score is None:
+                    continue
+                timestamp = _as_datetime(t)
+                if timestamp not in scores:
+                    scores[timestamp] = {}
+                scores[timestamp][name] = average_score
+                unique_names.add(name)
+
+        score_timestamps: list[datetime] = [timestamp for timestamp in scores]
+        min_time = min([*score_timestamps, time_range.start])
+        max_time = max(
+            [
+                *score_timestamps,
+                *([time_range.end] if time_range.end else [datetime.now(timezone.utc)]),
+            ],
+        )
+        data: dict[datetime, SpanAnnotationScoreTimeSeriesDataPoint] = {
+            timestamp: SpanAnnotationScoreTimeSeriesDataPoint(
+                timestamp=timestamp,
+                scores_with_labels=[
+                    SpanAnnotationScoreWithLabel(label=label, score=scores[timestamp][label])
+                    for label in scores[timestamp]
+                ],
             )
+            for timestamp in score_timestamps
+        }
+        for timestamp in get_timestamp_range(
+            start_time=min_time,
+            end_time=max_time,
+            stride=field,
+            utc_offset_minutes=utc_offset_minutes,
+        ):
+            if timestamp not in data:
+                data[timestamp] = SpanAnnotationScoreTimeSeriesDataPoint(
+                    timestamp=timestamp,
+                    scores_with_labels=[],
+                )
+        return SpanAnnotationScoreTimeSeries(
+            data=sorted(data.values(), key=lambda x: x.timestamp),
+            names=sorted(list(unique_names)),
+        )
+
+    @strawberry.field
+    async def top_models_by_cost(
+        self,
+        info: Info[Context, None],
+        time_range: TimeRange,
+    ) -> list[GenerativeModel]:
+        if time_range.start is None:
+            raise BadRequest("Start time is required")
+
+        async with info.context.db() as session:
+            stmt = (
+                select(
+                    models.GenerativeModel,
+                    func.sum(models.SpanCost.total_tokens).label("total_tokens"),
+                    func.sum(models.SpanCost.prompt_tokens).label("prompt_tokens"),
+                    func.sum(models.SpanCost.completion_tokens).label("completion_tokens"),
+                    func.sum(models.SpanCost.total_cost).label("total_cost"),
+                    func.sum(models.SpanCost.prompt_cost).label("prompt_cost"),
+                    func.sum(models.SpanCost.completion_cost).label("completion_cost"),
+                )
+                .join(
+                    models.SpanCost,
+                    models.SpanCost.model_id == models.GenerativeModel.id,
+                )
+                .join(
+                    models.Trace,
+                    models.SpanCost.trace_rowid == models.Trace.id,
+                )
+                .where(models.Trace.project_rowid == self.id)
+                .where(models.SpanCost.model_id.isnot(None))
+                .where(models.SpanCost.span_start_time >= time_range.start)
+                .group_by(models.GenerativeModel.id)
+                .order_by(func.sum(models.SpanCost.total_cost).desc())
+            )
+            if time_range.end:
+                stmt = stmt.where(models.SpanCost.span_start_time < time_range.end)
+            results: list[GenerativeModel] = []
+            async for (
+                model,
+                total_tokens,
+                prompt_tokens,
+                completion_tokens,
+                total_cost,
+                prompt_cost,
+                completion_cost,
+            ) in await session.stream(stmt):
+                cost_summary = SpanCostSummary(
+                    prompt=CostBreakdown(tokens=prompt_tokens, cost=prompt_cost),
+                    completion=CostBreakdown(tokens=completion_tokens, cost=completion_cost),
+                    total=CostBreakdown(tokens=total_tokens, cost=total_cost),
+                )
+                cache_time_range = TimeRange(
+                    start=time_range.start,
+                    end=time_range.end,
+                )
+                gql_model = GenerativeModel(id=model.id, db_record=model)
+                gql_model.add_cached_cost_summary(self.id, cache_time_range, cost_summary)
+                results.append(gql_model)
+            return results
+
+    @strawberry.field
+    async def top_models_by_token_count(
+        self,
+        info: Info[Context, None],
+        time_range: TimeRange,
+    ) -> list[GenerativeModel]:
+        if time_range.start is None:
+            raise BadRequest("Start time is required")
+
+        async with info.context.db() as session:
+            stmt = (
+                select(
+                    models.GenerativeModel,
+                    func.sum(models.SpanCost.total_tokens).label("total_tokens"),
+                    func.sum(models.SpanCost.prompt_tokens).label("prompt_tokens"),
+                    func.sum(models.SpanCost.completion_tokens).label("completion_tokens"),
+                    func.sum(models.SpanCost.total_cost).label("total_cost"),
+                    func.sum(models.SpanCost.prompt_cost).label("prompt_cost"),
+                    func.sum(models.SpanCost.completion_cost).label("completion_cost"),
+                )
+                .join(
+                    models.SpanCost,
+                    models.SpanCost.model_id == models.GenerativeModel.id,
+                )
+                .join(
+                    models.Trace,
+                    models.SpanCost.trace_rowid == models.Trace.id,
+                )
+                .where(models.Trace.project_rowid == self.id)
+                .where(models.SpanCost.model_id.isnot(None))
+                .where(models.SpanCost.span_start_time >= time_range.start)
+                .group_by(models.GenerativeModel.id)
+                .order_by(func.sum(models.SpanCost.total_tokens).desc())
+            )
+            if time_range.end:
+                stmt = stmt.where(models.SpanCost.span_start_time < time_range.end)
+            results: list[GenerativeModel] = []
+            async for (
+                model,
+                total_tokens,
+                prompt_tokens,
+                completion_tokens,
+                total_cost,
+                prompt_cost,
+                completion_cost,
+            ) in await session.stream(stmt):
+                cost_summary = SpanCostSummary(
+                    prompt=CostBreakdown(tokens=prompt_tokens, cost=prompt_cost),
+                    completion=CostBreakdown(tokens=completion_tokens, cost=completion_cost),
+                    total=CostBreakdown(tokens=total_tokens, cost=total_cost),
+                )
+                cache_time_range = TimeRange(
+                    start=time_range.start,
+                    end=time_range.end,
+                )
+                gql_model = GenerativeModel(id=model.id, db_record=model)
+                gql_model.add_cached_cost_summary(self.id, cache_time_range, cost_summary)
+                results.append(gql_model)
+            return results
+
+
+@strawberry.type
+class SpanCountTimeSeriesDataPoint:
+    timestamp: datetime
+    ok_count: Optional[int] = None
+    error_count: Optional[int] = None
+    unset_count: Optional[int] = None
+    total_count: Optional[int] = None
+
+
+@strawberry.type
+class SpanCountTimeSeries:
+    data: list[SpanCountTimeSeriesDataPoint]
+
+
+@strawberry.type
+class TraceCountTimeSeries(TimeSeries):
+    """A time series of trace count"""
+
+
+@strawberry.type
+class TraceCountByStatusTimeSeriesDataPoint:
+    timestamp: datetime
+    ok_count: int
+    error_count: int
+    total_count: int
+
+
+@strawberry.type
+class TraceCountByStatusTimeSeries:
+    data: list[TraceCountByStatusTimeSeriesDataPoint]
+
+
+@strawberry.type
+class TraceLatencyMsPercentileTimeSeriesDataPoint:
+    timestamp: datetime
+    p50: Optional[float] = None
+    p75: Optional[float] = None
+    p90: Optional[float] = None
+    p95: Optional[float] = None
+    p99: Optional[float] = None
+    p999: Optional[float] = None
+    max: Optional[float] = None
+
+
+@strawberry.type
+class TraceLatencyPercentileTimeSeries:
+    data: list[TraceLatencyMsPercentileTimeSeriesDataPoint]
+
+
+@strawberry.type
+class TraceTokenCountTimeSeriesDataPoint:
+    timestamp: datetime
+    prompt_token_count: Optional[float] = None
+    completion_token_count: Optional[float] = None
+    total_token_count: Optional[float] = None
+
+
+@strawberry.type
+class TraceTokenCountTimeSeries:
+    data: list[TraceTokenCountTimeSeriesDataPoint]
+
+
+@strawberry.type
+class TraceTokenCostTimeSeriesDataPoint:
+    timestamp: datetime
+    prompt_cost: Optional[float] = None
+    completion_cost: Optional[float] = None
+    total_cost: Optional[float] = None
+
+
+@strawberry.type
+class TraceTokenCostTimeSeries:
+    data: list[TraceTokenCostTimeSeriesDataPoint]
+
+
+@strawberry.type
+class SpanAnnotationScoreWithLabel:
+    label: str
+    score: float
 
 
 @strawberry.type
-class SpanCountTimeSeries(TimeSeries):
-    """A time series of span count"""
+class SpanAnnotationScoreTimeSeriesDataPoint:
+    timestamp: datetime
+    scores_with_labels: list[SpanAnnotationScoreWithLabel]
+
+
+@strawberry.type
+class SpanAnnotationScoreTimeSeries:
+    data: list[SpanAnnotationScoreTimeSeriesDataPoint]
+    names: list[str]
 
 
 INPUT_VALUE = SpanAttributes.INPUT_VALUE.split(".")
@@ -732,5 +1586,213 @@ def _as_datetime(value: Any) -> datetime:
     if isinstance(value, datetime):
         return value
     if isinstance(value, str):
-        return datetime.fromisoformat(value)
+        return cast(datetime, normalize_datetime(datetime.fromisoformat(value), timezone.utc))
     raise ValueError(f"Cannot convert {value} to datetime")
+
+
+async def _paginate_span_by_trace_start_time(
+    db: DbSessionFactory,
+    project_rowid: int,
+    time_range: Optional[TimeRange] = None,
+    first: Optional[int] = DEFAULT_PAGE_SIZE,
+    after: Optional[CursorString] = None,
+    sort: SpanSort = SpanSort(col=SpanColumn.startTime, dir=SortDir.desc),
+    orphan_span_as_root_span: Optional[bool] = True,
+    retries: int = 3,
+) -> Connection[Span]:
+    """Return one representative root span per trace, ordered by trace start time.
+
+    **Note**: Despite the function name, cursors are based on trace rowids, not span rowids.
+    This is because we paginate by traces (one span per trace), not individual spans.
+
+    **Important**: The edges list can be empty while has_next_page=True. This happens
+    when traces exist but have no matching root spans. Pagination continues because there
+    may be more traces ahead with spans.
+
+    Args:
+        db: Database session factory.
+        project_rowid: Project ID to query spans from.
+        time_range: Optional time range filter on trace start times.
+        first: Maximum number of edges to return (default: DEFAULT_PAGE_SIZE).
+        after: Cursor for pagination (points to trace position, not span).
+        sort: Sort by trace start time (asc/desc only).
+        orphan_span_as_root_span: Whether to include orphan spans as root spans.
+            True: spans with parent_id=NULL OR pointing to non-existent spans.
+            False: only spans with parent_id=NULL.
+        retries: Maximum number of retry attempts when insufficient edges are found.
+            When traces exist but lack root spans, the function retries pagination
+            to find traces with spans. Set to 0 to disable retries.
+
+    Returns:
+        Connection[Span] with:
+        - edges: At most one Edge per trace (may be empty list).
+        - page_info: Pagination info based on trace positions.
+
+    Key Points:
+        - Traces without root spans produce NO edges
+        - Spans ordered by trace start time, not span start time
+        - Cursors track trace positions for efficient large-scale pagination
+    """
+    # Build base trace query ordered by start time
+    traces = select(
+        models.Trace.id,
+        models.Trace.start_time,
+    ).where(models.Trace.project_rowid == project_rowid)
+    if sort.dir is SortDir.desc:
+        traces = traces.order_by(
+            models.Trace.start_time.desc(),
+            models.Trace.id.desc(),
+        )
+    else:
+        traces = traces.order_by(
+            models.Trace.start_time.asc(),
+            models.Trace.id.asc(),
+        )
+
+    # Apply time range filters
+    if time_range:
+        if time_range.start:
+            traces = traces.where(time_range.start <= models.Trace.start_time)
+        if time_range.end:
+            traces = traces.where(models.Trace.start_time < time_range.end)
+
+    # Apply cursor pagination
+    if after:
+        cursor = Cursor.from_string(after)
+        assert cursor.sort_column
+        compare = operator.lt if sort.dir is SortDir.desc else operator.gt
+        traces = traces.where(
+            compare(
+                tuple_(models.Trace.start_time, models.Trace.id),
+                (cursor.sort_column.value, cursor.rowid),
+            )
+        )
+
+    # Limit for pagination
+    if first:
+        traces = traces.limit(
+            first + 1  # over-fetch by one to determine whether there's a next page
+        )
+    traces_cte = traces.cte()
+
+    # Define join condition for root spans
+    if orphan_span_as_root_span:
+        # Include both NULL parent_id and orphaned spans
+        parent_spans = select(models.Span.span_id).alias("parent_spans")
+        onclause = and_(
+            models.Span.trace_rowid == traces_cte.c.id,
+            or_(
+                models.Span.parent_id.is_(None),
+                ~exists().where(models.Span.parent_id == parent_spans.c.span_id),
+            ),
+        )
+    else:
+        # Only spans with no parent (parent_id is NULL, excludes orphaned spans)
+        onclause = and_(
+            models.Span.trace_rowid == traces_cte.c.id,
+            models.Span.parent_id.is_(None),
+        )
+
+    # Join traces with root spans (left join allows traces without spans)
+    stmt = select(
+        traces_cte.c.id,
+        traces_cte.c.start_time,
+        models.Span.id,
+    ).join_from(
+        traces_cte,
+        models.Span,
+        onclause=onclause,
+        isouter=True,
+    )
+
+    # Order by trace time, then pick earliest span per trace
+    if sort.dir is SortDir.desc:
+        stmt = stmt.order_by(
+            traces_cte.c.start_time.desc(),
+            traces_cte.c.id.desc(),
+            models.Span.start_time.asc(),  # earliest span
+            models.Span.id.desc(),
+        )
+    else:
+        stmt = stmt.order_by(
+            traces_cte.c.start_time.asc(),
+            traces_cte.c.id.asc(),
+            models.Span.start_time.asc(),  # earliest span
+            models.Span.id.desc(),
+        )
+
+    # Use DISTINCT for PostgreSQL, manual grouping for SQLite
+    if db.dialect is SupportedSQLDialect.POSTGRESQL:
+        stmt = stmt.distinct(traces_cte.c.start_time, traces_cte.c.id)
+    elif db.dialect is SupportedSQLDialect.SQLITE:
+        # too complicated for SQLite, so we rely on groupby() below
+        pass
+    else:
+        assert_never(db.dialect)
+
+    # Process results and build edges
+    edges: list[Edge[Span]] = []
+    start_cursor: Optional[str] = None
+    end_cursor: Optional[str] = None
+    async with db() as session:
+        records = groupby(await session.stream(stmt), key=lambda record: record[:2])
+        async for (trace_rowid, trace_start_time), group in islice(records, first):
+            cursor = Cursor(
+                rowid=trace_rowid,
+                sort_column=CursorSortColumn(
+                    type=CursorSortColumnDataType.DATETIME,
+                    value=trace_start_time,
+                ),
+            )
+            if start_cursor is None:
+                start_cursor = str(cursor)
+            end_cursor = str(cursor)
+            first_record = group[0]
+            # Only create edge if trace has a root span
+            if (span_rowid := first_record[2]) is not None:
+                edges.append(Edge(node=Span(id=span_rowid), cursor=str(cursor)))
+        has_next_page = True
+        try:
+            await records.__anext__()
+        except StopAsyncIteration:
+            has_next_page = False
+
+    # Retry if we need more edges and more traces exist
+    if first and len(edges) < first and has_next_page:
+        while retries and (num_needed := first - len(edges)) and has_next_page:
+            retries -= 1
+            batch_size = max(first, 1000)
+            more = await _paginate_span_by_trace_start_time(
+                db=db,
+                project_rowid=project_rowid,
+                time_range=time_range,
+                first=batch_size,
+                after=end_cursor,
+                sort=sort,
+                orphan_span_as_root_span=orphan_span_as_root_span,
+                retries=0,
+            )
+            edges.extend(more.edges[:num_needed])
+            start_cursor = start_cursor or more.page_info.start_cursor
+            end_cursor = more.page_info.end_cursor if len(edges) < first else edges[-1].cursor
+            has_next_page = len(more.edges) > num_needed or more.page_info.has_next_page
+
+    return Connection(
+        edges=edges,
+        page_info=PageInfo(
+            start_cursor=start_cursor,
+            end_cursor=end_cursor,
+            has_previous_page=False,
+            has_next_page=has_next_page,
+        ),
+    )
+
+
+def to_gql_project(project: models.Project) -> Project:
+    """
+    Converts an ORM project to a GraphQL project.
+    """
+    return Project(
+        id=project.id,
+        db_record=project,
+    )