arize-phoenix 8.2.2__py3-none-any.whl → 8.4.0__py3-none-any.whl

phoenix/server/api/dataloaders/{span_fields.py → table_fields.py}

@@ -8,35 +8,36 @@ from typing_extensions import TypeAlias
 from phoenix.db import models
 from phoenix.server.types import DbSessionFactory
 
-SpanRowId: TypeAlias = int
+RowId: TypeAlias = int
 
-Key: TypeAlias = tuple[SpanRowId, QueryableAttribute[Any]]
+Key: TypeAlias = tuple[RowId, QueryableAttribute[Any]]
 Result: TypeAlias = Any
 
-
 _ResultColumnPosition: TypeAlias = int
 _AttrStrIdentifier: TypeAlias = str
 
 
-class SpanFieldsDataLoader(DataLoader[Key, Result]):
-    def __init__(self, db: DbSessionFactory) -> None:
+class TableFieldsDataLoader(DataLoader[Key, Result]):
+    def __init__(self, db: DbSessionFactory, table: type[models.Base]) -> None:
         super().__init__(load_fn=self._load_fn)
         self._db = db
+        self._table = table
 
     async def _load_fn(self, keys: Iterable[Key]) -> list[Union[Result, ValueError]]:
-        result: dict[tuple[SpanRowId, _AttrStrIdentifier], Result] = {}
-        stmt, attr_strs = _get_stmt(keys)
+        result: dict[tuple[RowId, _AttrStrIdentifier], Result] = {}
+        stmt, attr_strs = _get_stmt(keys, self._table)
         async with self._db() as session:
             data = await session.stream(stmt)
             async for row in data:
-                span_rowid: SpanRowId = row[0]  # models.Span's primary key
+                rowid: RowId = row[0]  # models.Span's primary key
                 for i, value in enumerate(row[1:]):
-                    result[span_rowid, attr_strs[i]] = value
-        return [result.get((span_rowid, str(attr))) for span_rowid, attr in keys]
+                    result[rowid, attr_strs[i]] = value
+        return [result.get((rowid, str(attr))) for rowid, attr in keys]
 
 
 def _get_stmt(
-    keys: Iterable[Key],
+    keys: Iterable[tuple[RowId, QueryableAttribute[Any]]],
+    table: type[models.Base],
 ) -> tuple[
     Select[Any],
     dict[_ResultColumnPosition, _AttrStrIdentifier],
@@ -52,7 +53,8 @@ def _get_stmt(
 
     Args:
         keys (list[Key]): A list of tuples, where each tuple contains an integer ID, i.e. the
-            primary key of models.Span, and a QueryableAttribute.
+            primary key of table, and a QueryableAttribute.
+        table (models.Base): The table to query.
 
     Returns:
         tuple: A tuple containing:
@@ -61,16 +63,16 @@ def _get_stmt(
                 at the second column (because the first column is the span's primary key)--in the
                 result to the attribute's string identifier.
     """
-    span_rowids: set[SpanRowId] = set()
+    rowids: set[RowId] = set()
     attrs: dict[_AttrStrIdentifier, QueryableAttribute[Any]] = {}
     joins = set()
-    for span_rowid, attr in keys:
-        span_rowids.add(span_rowid)
+    for rowid, attr in keys:
+        rowids.add(rowid)
         attrs[str(attr)] = attr
-        if (entity := attr.parent.entity) is not models.Span:
+        if (entity := attr.parent.entity) is not table:
             joins.add(entity)
-    stmt = select(models.Span.id).where(models.Span.id.in_(span_rowids))
-    for table in joins:
-        stmt = stmt.join(table)
+    stmt = select(table.id).where(table.id.in_(rowids))
+    for other_table in joins:
+        stmt = stmt.join(other_table)
     identifiers, columns = zip(*attrs.items())
     return stmt.add_columns(*columns), dict(enumerate(identifiers))

phoenix/server/api/helpers/playground_clients.py

@@ -806,6 +806,10 @@ class AnthropicStreamingClient(PlaygroundStreamingClient):
                     raise NotImplementedError
                 elif isinstance(event, anthropic_streaming._types.CitationEvent):
                     raise NotImplementedError
+                elif isinstance(event, anthropic_streaming._types.ThinkingEvent):
+                    raise NotImplementedError
+                elif isinstance(event, anthropic_streaming._types.SignatureEvent):
+                    raise NotImplementedError
                 else:
                     assert_never(event)
 

phoenix/server/api/helpers/prompts/models.py

@@ -348,6 +348,7 @@ class AnthropicToolDefinition(PromptModel):
 class PromptOpenAIInvocationParametersContent(PromptModel):
     temperature: float = UNDEFINED
     max_tokens: int = UNDEFINED
+    max_completion_tokens: int = UNDEFINED
     frequency_penalty: float = UNDEFINED
     presence_penalty: float = UNDEFINED
     top_p: float = UNDEFINED

phoenix/server/api/queries.py

@@ -1,19 +1,21 @@
 from collections import defaultdict
 from datetime import datetime
-from typing import Optional, Union
+from typing import Iterable, Iterator, Optional, Union, cast
 
 import numpy as np
 import numpy.typing as npt
 import strawberry
-from sqlalchemy import and_, distinct, func, select
+from sqlalchemy import and_, distinct, func, select, text
 from sqlalchemy.orm import joinedload
 from starlette.authentication import UnauthenticatedUser
 from strawberry import ID, UNSET
 from strawberry.relay import Connection, GlobalID, Node
 from strawberry.types import Info
-from typing_extensions import Annotated, TypeAlias
+from typing_extensions import Annotated, TypeAlias, assert_never
 
+from phoenix.config import ENV_PHOENIX_SQL_DATABASE_SCHEMA, getenv
 from phoenix.db import enums, models
+from phoenix.db.helpers import SupportedSQLDialect
 from phoenix.db.models import DatasetExample as OrmExample
 from phoenix.db.models import DatasetExampleRevision as OrmRevision
 from phoenix.db.models import DatasetVersion as OrmVersion
@@ -66,7 +68,7 @@ from phoenix.server.api.types.PromptVersion import PromptVersion, to_gql_prompt_
 from phoenix.server.api.types.SortDir import SortDir
 from phoenix.server.api.types.Span import Span
 from phoenix.server.api.types.SystemApiKey import SystemApiKey
-from phoenix.server.api.types.Trace import to_gql_trace
+from phoenix.server.api.types.Trace import Trace
 from phoenix.server.api.types.User import User, to_gql_user
 from phoenix.server.api.types.UserApiKey import UserApiKey, to_gql_api_key
 from phoenix.server.api.types.UserRole import UserRole
@@ -81,6 +83,12 @@ class ModelsInput:
     model_name: Optional[str] = None
 
 
+@strawberry.type
+class DbTableStats:
+    table_name: str
+    num_bytes: int
+
+
 @strawberry.type
 class Query:
     @strawberry.field
@@ -236,10 +244,8 @@ class Query:
             projects = await session.stream_scalars(stmt)
             data = [
                 Project(
-                    id_attr=project.id,
-                    name=project.name,
-                    gradient_start_color=project.gradient_start_color,
-                    gradient_end_color=project.gradient_end_color,
+                    project_rowid=project.id,
+                    db_project=project,
                 )
                 async for project in projects
             ]
@@ -448,21 +454,14 @@ class Query:
             embedding_dimension = info.context.model.embedding_dimensions[node_id]
             return to_gql_embedding_dimension(node_id, embedding_dimension)
         elif type_name == "Project":
-            project_stmt = select(
-                models.Project.id,
-                models.Project.name,
-                models.Project.gradient_start_color,
-                models.Project.gradient_end_color,
-            ).where(models.Project.id == node_id)
+            project_stmt = select(models.Project).filter_by(id=node_id)
             async with info.context.db() as session:
-                project = (await session.execute(project_stmt)).first()
+                project = await session.scalar(project_stmt)
             if project is None:
                 raise NotFound(f"Unknown project: {id}")
             return Project(
-                id_attr=project.id,
-                name=project.name,
-                gradient_start_color=project.gradient_start_color,
-                gradient_end_color=project.gradient_end_color,
+                project_rowid=project.id,
+                db_project=project,
             )
         elif type_name == "Trace":
             trace_stmt = select(models.Trace).filter_by(id=node_id)
@@ -470,7 +469,7 @@ class Query:
                 trace = await session.scalar(trace_stmt)
             if trace is None:
                 raise NotFound(f"Unknown trace: {id}")
-            return to_gql_trace(trace)
+            return Trace(trace_rowid=trace.id, db_trace=trace)
         elif type_name == Span.__name__:
             span_stmt = (
                 select(models.Span)
@@ -789,3 +788,64 @@ class Query:
         return to_gql_clusters(
             clustered_events=clustered_events,
         )
+
+    @strawberry.field
+    async def db_table_stats(
+        self,
+        info: Info[Context, None],
+    ) -> list[DbTableStats]:
+        if info.context.db.dialect is SupportedSQLDialect.SQLITE:
+            stmt = text("SELECT name, sum(pgsize) FROM dbstat group by name;")
+            async with info.context.db() as session:
+                stats = cast(Iterable[tuple[str, int]], await session.execute(stmt))
+            stats = _consolidate_sqlite_db_table_stats(stats)
+        elif info.context.db.dialect is SupportedSQLDialect.POSTGRESQL:
+            stmt = text(f"""\
+                SELECT c.relname, pg_total_relation_size(c.oid)
+                FROM pg_class as c
+                INNER JOIN pg_namespace as n ON n.oid = c.relnamespace
+                WHERE c.relkind = 'r'
+                AND n.nspname = '{getenv(ENV_PHOENIX_SQL_DATABASE_SCHEMA) or "public"}';
+            """)
+            async with info.context.db() as session:
+                stats = cast(Iterable[tuple[str, int]], await session.execute(stmt))
+        else:
+            assert_never(info.context.db.dialect)
+        return [
+            DbTableStats(table_name=table_name, num_bytes=num_bytes)
+            for table_name, num_bytes in stats
+        ]
+
+
+def _consolidate_sqlite_db_table_stats(
+    stats: Iterable[tuple[str, int]],
+) -> Iterator[tuple[str, int]]:
+    """
+    Consolidate SQLite database stats by combining indexes with their respective tables.
+    """
+    aggregate: dict[str, int] = {}
+    for name, num_bytes in stats:
+        # Skip internal SQLite tables and indexes.
+        if name.startswith("ix_") or name.startswith("sqlite_"):
+            continue
+        aggregate[name] = num_bytes
+    for name, num_bytes in stats:
+        # Combine indexes with their respective tables.
+        for flag in ["sqlite_autoindex_", "ix_"]:
+            if not name.startswith(flag):
+                continue
+            if parent := _longest_matching_prefix(name[len(flag) :], aggregate.keys()):
+                aggregate[parent] += num_bytes
+            break
+    yield from aggregate.items()
+
+
+def _longest_matching_prefix(s: str, prefixes: Iterable[str]) -> str:
+    """
+    Return the longest prefix of s that matches any of the given prefixes.
+    """
+    longest = ""
+    for prefix in prefixes:
+        if s.startswith(prefix) and len(prefix) > len(longest):
+            longest = prefix
+    return longest

phoenix/server/api/types/Experiment.py

@@ -122,10 +122,8 @@ class Experiment(Node):
             return None
 
         return Project(
-            id_attr=db_project.id,
-            name=db_project.name,
-            gradient_start_color=db_project.gradient_start_color,
-            gradient_end_color=db_project.gradient_end_color,
+            project_rowid=db_project.id,
+            db_project=db_project,
         )
 
     @strawberry.field

phoenix/server/api/types/ExperimentRun.py

@@ -20,7 +20,7 @@ from phoenix.server.api.types.pagination import (
     CursorString,
     connection_from_list,
 )
-from phoenix.server.api.types.Trace import Trace, to_gql_trace
+from phoenix.server.api.types.Trace import Trace
 
 if TYPE_CHECKING:
     from phoenix.server.api.types.DatasetExample import DatasetExample
@@ -64,7 +64,7 @@ class ExperimentRun(Node):
         dataloader = info.context.data_loaders.trace_by_trace_ids
         if (trace := await dataloader.load(self.trace_id)) is None:
             return None
-        return to_gql_trace(trace)
+        return Trace(trace_rowid=trace.id, db_trace=trace)
 
     @strawberry.field
     async def example(

phoenix/server/api/types/ExperimentRunAnnotation.py

@@ -8,7 +8,7 @@ from strawberry.scalars import JSON
 
 from phoenix.db import models
 from phoenix.server.api.types.AnnotatorKind import ExperimentRunAnnotatorKind
-from phoenix.server.api.types.Trace import Trace, to_gql_trace
+from phoenix.server.api.types.Trace import Trace
 
 
 @strawberry.type
@@ -32,7 +32,7 @@ class ExperimentRunAnnotation(Node):
         dataloader = info.context.data_loaders.trace_by_trace_ids
         if (trace := await dataloader.load(self.trace_id)) is None:
             return None
-        return to_gql_trace(trace)
+        return Trace(trace_rowid=trace.id, db_trace=trace)
 
 
 def to_gql_experiment_run_annotation(

phoenix/server/api/types/Project.py

@@ -8,7 +8,7 @@ from openinference.semconv.trace import SpanAttributes
 from sqlalchemy import desc, distinct, func, or_, select
 from sqlalchemy.sql.elements import ColumnElement
 from sqlalchemy.sql.expression import tuple_
-from strawberry import ID, UNSET
+from strawberry import ID, UNSET, Private
 from strawberry.relay import Connection, Node, NodeID
 from strawberry.types import Info
 from typing_extensions import assert_never
@@ -33,7 +33,7 @@ from phoenix.server.api.types.pagination import (
 from phoenix.server.api.types.ProjectSession import ProjectSession, to_gql_project_session
 from phoenix.server.api.types.SortDir import SortDir
 from phoenix.server.api.types.Span import Span
-from phoenix.server.api.types.Trace import Trace, to_gql_trace
+from phoenix.server.api.types.Trace import Trace
 from phoenix.server.api.types.ValidationResult import ValidationResult
 from phoenix.trace.dsl import SpanFilter
 
@@ -41,10 +41,51 @@ from phoenix.trace.dsl import SpanFilter
 @strawberry.type
 class Project(Node):
     _table: ClassVar[type[models.Base]] = models.Project
-    id_attr: NodeID[int]
-    name: str
-    gradient_start_color: str
-    gradient_end_color: str
+    project_rowid: NodeID[int]
+    db_project: Private[models.Project] = UNSET
+
+    def __post_init__(self) -> None:
+        if self.db_project and self.project_rowid != self.db_project.id:
+            raise ValueError("Project ID mismatch")
+
+    @strawberry.field
+    async def name(
+        self,
+        info: Info[Context, None],
+    ) -> str:
+        if self.db_project:
+            name = self.db_project.name
+        else:
+            name = await info.context.data_loaders.project_fields.load(
+                (self.project_rowid, models.Project.name),
+            )
+        return name
+
+    @strawberry.field
+    async def gradient_start_color(
+        self,
+        info: Info[Context, None],
+    ) -> str:
+        if self.db_project:
+            gradient_start_color = self.db_project.gradient_start_color
+        else:
+            gradient_start_color = await info.context.data_loaders.project_fields.load(
+                (self.project_rowid, models.Project.gradient_start_color),
+            )
+        return gradient_start_color
+
+    @strawberry.field
+    async def gradient_end_color(
+        self,
+        info: Info[Context, None],
+    ) -> str:
+        if self.db_project:
+            gradient_end_color = self.db_project.gradient_end_color
+        else:
+            gradient_end_color = await info.context.data_loaders.project_fields.load(
+                (self.project_rowid, models.Project.gradient_end_color),
+            )
+        return gradient_end_color
 
     @strawberry.field
     async def start_time(
@@ -52,7 +93,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.id_attr, "start"),
+            (self.project_rowid, "start"),
         )
         start_time, _ = right_open_time_range(start_time, None)
         return start_time
@@ -63,7 +104,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.id_attr, "end"),
+            (self.project_rowid, "end"),
         )
         _, end_time = right_open_time_range(None, end_time)
         return end_time
@@ -76,7 +117,7 @@ class Project(Node):
         filter_condition: Optional[str] = UNSET,
     ) -> int:
         return await info.context.data_loaders.record_counts.load(
-            ("span", self.id_attr, time_range, filter_condition),
+            ("span", self.project_rowid, time_range, filter_condition),
         )
 
     @strawberry.field
@@ -86,7 +127,7 @@ class Project(Node):
         time_range: Optional[TimeRange] = UNSET,
     ) -> int:
         return await info.context.data_loaders.record_counts.load(
-            ("trace", self.id_attr, time_range, None),
+            ("trace", self.project_rowid, time_range, None),
         )
 
     @strawberry.field
@@ -97,7 +138,7 @@ class Project(Node):
         filter_condition: Optional[str] = UNSET,
     ) -> int:
         return await info.context.data_loaders.token_counts.load(
-            ("total", self.id_attr, time_range, filter_condition),
+            ("total", self.project_rowid, time_range, filter_condition),
         )
 
     @strawberry.field
@@ -108,7 +149,7 @@ class Project(Node):
         filter_condition: Optional[str] = UNSET,
     ) -> int:
         return await info.context.data_loaders.token_counts.load(
-            ("prompt", self.id_attr, time_range, filter_condition),
+            ("prompt", self.project_rowid, time_range, filter_condition),
         )
 
     @strawberry.field
@@ -119,7 +160,7 @@ class Project(Node):
         filter_condition: Optional[str] = UNSET,
     ) -> int:
         return await info.context.data_loaders.token_counts.load(
-            ("completion", self.id_attr, time_range, filter_condition),
+            ("completion", self.project_rowid, time_range, filter_condition),
         )
 
     @strawberry.field
@@ -132,7 +173,7 @@ class Project(Node):
         return await info.context.data_loaders.latency_ms_quantile.load(
             (
                 "trace",
-                self.id_attr,
+                self.project_rowid,
                 time_range,
                 None,
                 probability,
@@ -150,7 +191,7 @@ class Project(Node):
         return await info.context.data_loaders.latency_ms_quantile.load(
             (
                 "span",
-                self.id_attr,
+                self.project_rowid,
                 time_range,
                 filter_condition,
                 probability,
@@ -162,12 +203,12 @@ class Project(Node):
         stmt = (
             select(models.Trace)
             .where(models.Trace.trace_id == str(trace_id))
-            .where(models.Trace.project_rowid == self.id_attr)
+            .where(models.Trace.project_rowid == self.project_rowid)
         )
         async with info.context.db() as session:
             if (trace := await session.scalar(stmt)) is None:
                 return None
-        return to_gql_trace(trace)
+        return Trace(trace_rowid=trace.id, db_trace=trace)
 
     @strawberry.field
     async def spans(
@@ -185,7 +226,7 @@ class Project(Node):
         stmt = (
             select(models.Span.id)
             .join(models.Trace)
-            .where(models.Trace.project_rowid == self.id_attr)
+            .where(models.Trace.project_rowid == self.project_rowid)
         )
         if time_range:
             if time_range.start:
@@ -264,7 +305,7 @@ class Project(Node):
         filter_io_substring: Optional[str] = UNSET,
     ) -> Connection[ProjectSession]:
         table = models.ProjectSession
-        stmt = select(table).filter_by(project_id=self.id_attr)
+        stmt = select(table).filter_by(project_id=self.project_rowid)
         if time_range:
             if time_range.start:
                 stmt = stmt.where(time_range.start <= table.start_time)
@@ -382,7 +423,7 @@ class Project(Node):
         stmt = (
             select(distinct(models.TraceAnnotation.name))
             .join(models.Trace)
-            .where(models.Trace.project_rowid == self.id_attr)
+            .where(models.Trace.project_rowid == self.project_rowid)
         )
         async with info.context.db() as session:
             return list(await session.scalars(stmt))
@@ -399,7 +440,7 @@ 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.id_attr)
+            .where(models.Trace.project_rowid == self.project_rowid)
         )
         async with info.context.db() as session:
             return list(await session.scalars(stmt))
@@ -416,7 +457,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.id_attr)
+            .where(models.Trace.project_rowid == self.project_rowid)
             .where(models.DocumentAnnotation.annotator_kind == "LLM")
         )
         if span_id:
@@ -432,7 +473,7 @@ class Project(Node):
         time_range: Optional[TimeRange] = UNSET,
     ) -> Optional[AnnotationSummary]:
         return await info.context.data_loaders.annotation_summaries.load(
-            ("trace", self.id_attr, time_range, None, annotation_name),
+            ("trace", self.project_rowid, time_range, None, annotation_name),
         )
 
     @strawberry.field
@@ -444,7 +485,7 @@ class Project(Node):
         filter_condition: Optional[str] = UNSET,
     ) -> Optional[AnnotationSummary]:
         return await info.context.data_loaders.annotation_summaries.load(
-            ("span", self.id_attr, time_range, filter_condition, annotation_name),
+            ("span", self.project_rowid, time_range, filter_condition, annotation_name),
         )
 
     @strawberry.field
@@ -456,7 +497,7 @@ class Project(Node):
         filter_condition: Optional[str] = UNSET,
     ) -> Optional[DocumentEvaluationSummary]:
         return await info.context.data_loaders.document_evaluation_summaries.load(
-            (self.id_attr, time_range, filter_condition, evaluation_name),
+            (self.project_rowid, time_range, filter_condition, evaluation_name),
         )
 
     @strawberry.field
@@ -464,7 +505,7 @@ class Project(Node):
         self,
         info: Info[Context, None],
     ) -> Optional[datetime]:
-        return info.context.last_updated_at.get(self._table, self.id_attr)
+        return info.context.last_updated_at.get(self._table, self.project_rowid)
 
     @strawberry.field
     async def validate_span_filter_condition(self, condition: str) -> ValidationResult:
@@ -483,17 +524,5 @@ class Project(Node):
             )
 
 
-def to_gql_project(project: models.Project) -> Project:
-    """
-    Converts an ORM project to a GraphQL Project.
-    """
-    return Project(
-        id_attr=project.id,
-        name=project.name,
-        gradient_start_color=project.gradient_start_color,
-        gradient_end_color=project.gradient_end_color,
-    )
-
-
 INPUT_VALUE = SpanAttributes.INPUT_VALUE.split(".")
 OUTPUT_VALUE = SpanAttributes.OUTPUT_VALUE.split(".")

phoenix/server/api/types/ProjectSession.py

@@ -93,7 +93,7 @@ class ProjectSession(Node):
         after: Optional[CursorString] = UNSET,
         before: Optional[CursorString] = UNSET,
     ) -> Connection[Annotated["Trace", lazy(".Trace")]]:
-        from phoenix.server.api.types.Trace import to_gql_trace
+        from phoenix.server.api.types.Trace import Trace
 
         args = ConnectionArgs(
             first=first,
@@ -109,7 +109,7 @@ class ProjectSession(Node):
         )
         async with info.context.db() as session:
             traces = await session.stream_scalars(stmt)
-            data = [to_gql_trace(trace) async for trace in traces]
+            data = [Trace(trace_rowid=trace.id, db_trace=trace) async for trace in traces]
         return connection_from_list(data=data, args=args)
 
     @strawberry.field

phoenix/server/api/types/Span.py

@@ -37,6 +37,7 @@ from phoenix.trace.attributes import get_attribute_value
 
 if TYPE_CHECKING:
     from phoenix.server.api.types.Project import Project
+    from phoenix.server.api.types.Trace import Trace
 
 
 @strawberry.enum
@@ -216,6 +217,34 @@ class Span(Node):
             )
         return SpanKind(value)
 
+    @strawberry.field
+    async def span_id(
+        self,
+        info: Info[Context, None],
+    ) -> ID:
+        if self.db_span:
+            span_id = self.db_span.span_id
+        else:
+            span_id = await info.context.data_loaders.span_fields.load(
+                (self.span_rowid, models.Span.span_id),
+            )
+        return ID(span_id)
+
+    @strawberry.field
+    async def trace(
+        self,
+        info: Info[Context, None],
+    ) -> Annotated["Trace", strawberry.lazy(".Trace")]:
+        if self.db_span:
+            trace_rowid = self.db_span.trace_rowid
+        else:
+            trace_rowid = await info.context.data_loaders.span_fields.load(
+                (self.span_rowid, models.Span.trace_rowid),
+            )
+        from phoenix.server.api.types.Trace import Trace
+
+        return Trace(trace_rowid=trace_rowid)
+
     @strawberry.field
     async def context(
         self,
@@ -508,6 +537,10 @@ class Span(Node):
             (self.span_rowid, evaluation_name or None, num_documents),
         )
 
+    @strawberry.field
+    async def num_child_spans(self, info: Info[Context, None]) -> int:
+        return await info.context.data_loaders.num_child_spans.load(self.span_rowid)
+
     @strawberry.field(
         description="All descendant spans (children, grandchildren, etc.)",
     )  # type: ignore
@@ -561,11 +594,11 @@ class Span(Node):
     ) -> Annotated[
         "Project", strawberry.lazy("phoenix.server.api.types.Project")
     ]:  # use lazy types to avoid circular import: https://strawberry.rocks/docs/types/lazy
-        from phoenix.server.api.types.Project import to_gql_project
+        from phoenix.server.api.types.Project import Project
 
         span_id = self.span_rowid
         project = await info.context.data_loaders.span_projects.load(span_id)
-        return to_gql_project(project)
+        return Project(project_rowid=project.id, db_project=project)
 
     @strawberry.field(description="Indicates if the span is contained in any dataset")  # type: ignore
     async def contained_in_dataset(