arize-phoenix 11.24.0__py3-none-any.whl → 11.25.0__py3-none-any.whl

phoenix/server/api/dataloaders/record_counts.py

@@ -3,13 +3,14 @@ from datetime import datetime
 from typing import Any, Literal, Optional
 
 from cachetools import LFUCache, TTLCache
-from sqlalchemy import Select, func, select
+from sqlalchemy import Select, distinct, func, select
 from strawberry.dataloader import AbstractCache, DataLoader
 from typing_extensions import TypeAlias, assert_never
 
 from phoenix.db import models
 from phoenix.server.api.dataloaders.cache import TwoTierCache
 from phoenix.server.api.input_types.TimeRange import TimeRange
+from phoenix.server.session_filters import get_filtered_session_rowids_subquery
 from phoenix.server.types import DbSessionFactory
 from phoenix.trace.dsl import SpanFilter
 
@@ -17,27 +18,35 @@ Kind: TypeAlias = Literal["span", "trace"]
 ProjectRowId: TypeAlias = int
 TimeInterval: TypeAlias = tuple[Optional[datetime], Optional[datetime]]
 FilterCondition: TypeAlias = Optional[str]
+SessionFilterCondition: TypeAlias = Optional[str]
 SpanCount: TypeAlias = int
 
-Segment: TypeAlias = tuple[Kind, TimeInterval, FilterCondition]
+Segment: TypeAlias = tuple[Kind, TimeInterval, FilterCondition, SessionFilterCondition]
 Param: TypeAlias = ProjectRowId
 
-Key: TypeAlias = tuple[Kind, ProjectRowId, Optional[TimeRange], FilterCondition]
+Key: TypeAlias = tuple[
+    Kind, ProjectRowId, Optional[TimeRange], FilterCondition, SessionFilterCondition
+]
 Result: TypeAlias = SpanCount
 ResultPosition: TypeAlias = int
 DEFAULT_VALUE: Result = 0
 
 
 def _cache_key_fn(key: Key) -> tuple[Segment, Param]:
-    kind, project_rowid, time_range, filter_condition = key
+    kind, project_rowid, time_range, filter_condition, session_filter_condition = key
     interval = (
         (time_range.start, time_range.end) if isinstance(time_range, TimeRange) else (None, None)
     )
-    return (kind, interval, filter_condition), project_rowid
+    return (
+        kind,
+        interval,
+        filter_condition,
+        session_filter_condition,
+    ), project_rowid
 
 
 _Section: TypeAlias = ProjectRowId
-_SubKey: TypeAlias = tuple[TimeInterval, FilterCondition, Kind]
+_SubKey: TypeAlias = tuple[TimeInterval, FilterCondition, SessionFilterCondition, Kind]
 
 
 class RecordCountCache(
@@ -53,8 +62,10 @@ class RecordCountCache(
         )
 
     def _cache_key(self, key: Key) -> tuple[_Section, _SubKey]:
-        (kind, interval, filter_condition), project_rowid = _cache_key_fn(key)
-        return project_rowid, (interval, filter_condition, kind)
+        (kind, interval, filter_condition, session_filter_condition), project_rowid = _cache_key_fn(
+            key
+        )
+        return project_rowid, (interval, filter_condition, session_filter_condition, kind)
 
 
 class RecordCountDataLoader(DataLoader[Key, Result]):
@@ -93,7 +104,7 @@ def _get_stmt(
     segment: Segment,
     *project_rowids: Param,
 ) -> Select[Any]:
-    kind, (start_time, end_time), filter_condition = segment
+    kind, (start_time, end_time), filter_condition, session_filter_condition = segment
     pid = models.Trace.project_rowid
     stmt = select(pid)
     if kind == "span":
@@ -102,12 +113,28 @@ def _get_stmt(
         if filter_condition:
             sf = SpanFilter(filter_condition)
             stmt = sf(stmt)
+        stmt = stmt.add_columns(func.count().label("count"))
     elif kind == "trace":
         time_column = models.Trace.start_time
+        if filter_condition:
+            stmt = stmt.join(models.Span, models.Trace.id == models.Span.trace_rowid)
+            stmt = stmt.add_columns(func.count(distinct(models.Trace.id)).label("count"))
+            sf = SpanFilter(filter_condition)
+            stmt = sf(stmt)
+        else:
+            stmt = stmt.add_columns(func.count().label("count"))
     else:
         assert_never(kind)
-    stmt = stmt.add_columns(func.count().label("count"))
     stmt = stmt.where(pid.in_(project_rowids))
+
+    if session_filter_condition:
+        filtered_session_rowids = get_filtered_session_rowids_subquery(
+            session_filter_condition=session_filter_condition,
+            project_rowids=project_rowids,
+            start_time=start_time,
+            end_time=end_time,
+        )
+        stmt = stmt.where(models.Trace.project_session_rowid.in_(filtered_session_rowids))
     stmt = stmt.group_by(pid)
     if start_time:
         stmt = stmt.where(start_time <= time_column)

phoenix/server/api/dataloaders/span_cost_summary_by_project.py

@@ -12,32 +12,38 @@ from phoenix.db import models
 from phoenix.server.api.dataloaders.cache import TwoTierCache
 from phoenix.server.api.dataloaders.types import CostBreakdown, SpanCostSummary
 from phoenix.server.api.input_types.TimeRange import TimeRange
+from phoenix.server.session_filters import get_filtered_session_rowids_subquery
 from phoenix.server.types import DbSessionFactory
 from phoenix.trace.dsl import SpanFilter
 
 ProjectRowId: TypeAlias = int
 TimeInterval: TypeAlias = tuple[Optional[datetime], Optional[datetime]]
 FilterCondition: TypeAlias = Optional[str]
+SessionFilterCondition: TypeAlias = Optional[str]
 
-Segment: TypeAlias = tuple[TimeInterval, FilterCondition]
+Segment: TypeAlias = tuple[
+    TimeInterval,
+    FilterCondition,
+    SessionFilterCondition,
+]
 Param: TypeAlias = ProjectRowId
 
-Key: TypeAlias = tuple[ProjectRowId, Optional[TimeRange], FilterCondition]
+Key: TypeAlias = tuple[ProjectRowId, Optional[TimeRange], FilterCondition, SessionFilterCondition]
 Result: TypeAlias = SpanCostSummary
 ResultPosition: TypeAlias = int
 DEFAULT_VALUE: Result = SpanCostSummary()
 
 
 def _cache_key_fn(key: Key) -> tuple[Segment, Param]:
-    project_rowid, time_range, filter_condition = key
+    project_rowid, time_range, filter_condition, session_filter_condition = key
     interval = (
         (time_range.start, time_range.end) if isinstance(time_range, TimeRange) else (None, None)
     )
-    return (interval, filter_condition), project_rowid
+    return (interval, filter_condition, session_filter_condition), project_rowid
 
 
 _Section: TypeAlias = ProjectRowId
-_SubKey: TypeAlias = tuple[TimeInterval, FilterCondition]
+_SubKey: TypeAlias = tuple[TimeInterval, FilterCondition, SessionFilterCondition]
 
 
 class SpanCostSummaryCache(
@@ -53,8 +59,8 @@ class SpanCostSummaryCache(
         )
 
     def _cache_key(self, key: Key) -> tuple[_Section, _SubKey]:
-        (interval, filter_condition), project_rowid = _cache_key_fn(key)
-        return project_rowid, (interval, filter_condition)
+        (interval, filter_condition, session_filter_condition), project_rowid = _cache_key_fn(key)
+        return project_rowid, (interval, filter_condition, session_filter_condition)
 
 
 class SpanCostSummaryByProjectDataLoader(DataLoader[Key, Result]):
@@ -106,12 +112,12 @@ def _get_stmt(
     segment: Segment,
     *params: Param,
 ) -> Select[Any]:
-    (start_time, end_time), filter_condition = segment
-    pid = models.Trace.project_rowid
+    project_rowids = params
+    (start_time, end_time), filter_condition, session_filter_condition = segment
 
     stmt: Select[Any] = (
         select(
-            pid,
+            models.Trace.project_rowid,
             coalesce(func.sum(models.SpanCost.prompt_cost), 0).label("prompt_cost"),
             coalesce(func.sum(models.SpanCost.completion_cost), 0).label("completion_cost"),
             coalesce(func.sum(models.SpanCost.total_cost), 0).label("total_cost"),
@@ -119,8 +125,10 @@ def _get_stmt(
             coalesce(func.sum(models.SpanCost.completion_tokens), 0).label("completion_tokens"),
             coalesce(func.sum(models.SpanCost.total_tokens), 0).label("total_tokens"),
         )
-        .join_from(models.SpanCost, models.Trace)
-        .group_by(pid)
+        .select_from(models.Trace)
+        .join(models.SpanCost, models.Trace.id == models.SpanCost.trace_rowid)
+        .where(models.Trace.project_rowid.in_(project_rowids))
+        .group_by(models.Trace.project_rowid)
     )
 
     if start_time:
@@ -132,7 +140,13 @@ def _get_stmt(
         sf = SpanFilter(filter_condition)
         stmt = sf(stmt.join_from(models.SpanCost, models.Span))
 
-    project_ids = [rowid for rowid in params]
-    stmt = stmt.where(pid.in_(project_ids))
+    if session_filter_condition:
+        filtered_session_rowids = get_filtered_session_rowids_subquery(
+            session_filter_condition=session_filter_condition,
+            project_rowids=project_rowids,
+            start_time=start_time,
+            end_time=end_time,
+        )
+        stmt = stmt.where(models.Trace.project_session_rowid.in_(filtered_session_rowids))
 
     return stmt

phoenix/server/api/helpers/playground_clients.py

@@ -543,7 +543,10 @@ class DeepSeekStreamingClient(OpenAIBaseStreamingClient):
                 raise BadRequest("An API key is required for DeepSeek models")
             api_key = "sk-fake-api-key"
 
-        client = AsyncOpenAI(api_key=api_key, base_url=base_url or "https://api.deepseek.com")
+        client = AsyncOpenAI(
+            api_key=api_key,
+            base_url=base_url or "https://api.deepseek.com",
+        )
         super().__init__(client=client, model=model, credentials=credentials)
         # DeepSeek uses OpenAI-compatible API but we'll track it as a separate provider
         # Adding a custom "deepseek" provider value to make it distinguishable in traces
@@ -581,7 +584,10 @@ class XAIStreamingClient(OpenAIBaseStreamingClient):
                 raise BadRequest("An API key is required for xAI models")
             api_key = "sk-fake-api-key"
 
-        client = AsyncOpenAI(api_key=api_key, base_url=base_url or "https://api.x.ai/v1")
+        client = AsyncOpenAI(
+            api_key=api_key,
+            base_url=base_url or "https://api.x.ai/v1",
+        )
         super().__init__(client=client, model=model, credentials=credentials)
         # xAI uses OpenAI-compatible API but we'll track it as a separate provider
         # Adding a custom "xai" provider value to make it distinguishable in traces
@@ -1134,7 +1140,7 @@ class OpenAIStreamingClient(OpenAIBaseStreamingClient):
                 raise BadRequest("An API key is required for OpenAI models")
             api_key = "sk-fake-api-key"
 
-        client = AsyncOpenAI(api_key=api_key, base_url=base_url)
+        client = AsyncOpenAI(api_key=api_key, base_url=base_url, timeout=30)
         super().__init__(client=client, model=model, credentials=credentials)
         self._attributes[LLM_PROVIDER] = OpenInferenceLLMProviderValues.OPENAI.value
         self._attributes[LLM_SYSTEM] = OpenInferenceLLMSystemValues.OPENAI.value
@@ -1489,7 +1495,7 @@ class AnthropicStreamingClient(PlaygroundStreamingClient):
                 invocation_name="top_p",
                 canonical_name=CanonicalParameterName.TOP_P,
                 label="Top P",
-                default_value=1.0,
+                default_value=None,
                 min_value=0.0,
                 max_value=1.0,
             ),

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

@@ -3,10 +3,11 @@ from typing import Any, Literal, Optional
 
 from dateutil.parser import isoparse
 from fastapi import APIRouter, HTTPException
-from pydantic import Field
+from pydantic import Field, model_validator
 from starlette.requests import Request
 from starlette.status import HTTP_404_NOT_FOUND
 from strawberry.relay import GlobalID
+from typing_extensions import Self
 
 from phoenix.db import models
 from phoenix.db.helpers import SupportedSQLDialect
@@ -36,15 +37,25 @@ class UpsertExperimentEvaluationRequestBody(V1RoutesBaseModel):
     )
     start_time: datetime = Field(description="The start time of the evaluation in ISO format")
     end_time: datetime = Field(description="The end time of the evaluation in ISO format")
-    result: ExperimentEvaluationResult = Field(description="The result of the evaluation")
+    result: Optional[ExperimentEvaluationResult] = Field(
+        None, description="The result of the evaluation. Either result or error must be provided."
+    )
     error: Optional[str] = Field(
-        None, description="Optional error message if the evaluation encountered an error"
+        None,
+        description="Error message if the evaluation encountered an error. "
+        "Either result or error must be provided.",
     )
     metadata: Optional[dict[str, Any]] = Field(
         default=None, description="Metadata for the evaluation"
     )
     trace_id: Optional[str] = Field(default=None, description="Optional trace ID for tracking")
 
+    @model_validator(mode="after")
+    def validate_result_or_error(self) -> Self:
+        if self.result is None and self.error is None:
+            raise ValueError("Either 'result' or 'error' must be provided")
+        return self
+
 
 class UpsertExperimentEvaluationResponseBodyData(V1RoutesBaseModel):
     id: str = Field(description="The ID of the upserted experiment evaluation")

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

@@ -469,26 +469,26 @@ async def query_spans_handler(
             detail=f"Invalid query: {e}",
             status_code=HTTP_422_UNPROCESSABLE_ENTITY,
         )
+
     async with request.app.state.db() as session:
-        results = []
+        results: list[pd.DataFrame] = []
         for query in span_queries:
-            results.append(
-                await session.run_sync(
-                    query,
-                    project_name=project_name,
-                    start_time=normalize_datetime(
-                        request_body.start_time,
-                        timezone.utc,
-                    ),
-                    end_time=normalize_datetime(
-                        end_time,
-                        timezone.utc,
-                    ),
-                    limit=request_body.limit,
-                    root_spans_only=request_body.root_spans_only,
-                    orphan_span_as_root_span=request_body.orphan_span_as_root_span,
-                )
+            df = await session.run_sync(
+                query,
+                project_name=project_name,
+                start_time=normalize_datetime(
+                    request_body.start_time,
+                    timezone.utc,
+                ),
+                end_time=normalize_datetime(
+                    end_time,
+                    timezone.utc,
+                ),
+                limit=request_body.limit,
+                root_spans_only=request_body.root_spans_only,
+                orphan_span_as_root_span=request_body.orphan_span_as_root_span,
             )
+            results.append(df)
     if not results:
         raise HTTPException(status_code=HTTP_404_NOT_FOUND)
 

phoenix/server/api/types/Project.py

@@ -1,5 +1,3 @@
-from __future__ import annotations
-
 import operator
 from datetime import datetime, timezone
 from typing import TYPE_CHECKING, Annotated, Any, ClassVar, Literal, Optional, cast
@@ -50,6 +48,7 @@ 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
 
@@ -135,9 +134,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.project_rowid,
+                time_range or None,
+                filter_condition or None,
+                session_filter_condition or None,
+            ),
         )
 
     @strawberry.field
@@ -145,9 +156,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.project_rowid,
+                time_range or None,
+                filter_condition or None,
+                session_filter_condition or None,
+            ),
         )
 
     @strawberry.field
@@ -189,9 +213,21 @@ class Project(Node):
         info: Info[Context, None],
         time_range: Optional[TimeRange] = UNSET,
         filter_condition: Optional[str] = UNSET,
+        session_filter_condition: Optional[str] = UNSET,
     ) -> SpanCostSummary:
-        loader = info.context.data_loaders.span_cost_summary_by_project
-        summary = await loader.load((self.project_rowid, time_range, filter_condition))
+        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.project_rowid,
+                time_range or None,
+                filter_condition or None,
+                session_filter_condition or None,
+            )
+        )
         return SpanCostSummary(
             prompt=CostBreakdown(
                 tokens=summary.prompt.tokens,
@@ -213,13 +249,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,
+                time_range or None,
+                filter_condition or None,
+                session_filter_condition or None,
                 probability,
             ),
         )
@@ -231,13 +275,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,
+                time_range or None,
+                filter_condition or None,
+                session_filter_condition or None,
                 probability,
             ),
         )
@@ -397,31 +448,13 @@ class Project(Node):
             if time_range.end:
                 stmt = stmt.where(table.start_time < time_range.end)
         if filter_io_substring:
-            filter_stmt = (
-                select(distinct(models.Trace.project_session_rowid).label("id"))
-                .filter_by(project_rowid=self.project_rowid)
-                .join_from(models.Trace, models.Span)
-                .where(models.Span.parent_id.is_(None))
-                .where(
-                    or_(
-                        models.CaseInsensitiveContains(
-                            models.Span.attributes[INPUT_VALUE].as_string(),
-                            filter_io_substring,
-                        ),
-                        models.CaseInsensitiveContains(
-                            models.Span.attributes[OUTPUT_VALUE].as_string(),
-                            filter_io_substring,
-                        ),
-                    )
-                )
+            filtered_session_rowids = get_filtered_session_rowids_subquery(
+                session_filter_condition=filter_io_substring,
+                project_rowids=[self.project_rowid],
+                start_time=time_range.start if time_range else None,
+                end_time=time_range.end if time_range else None,
             )
-            if time_range:
-                if time_range.start:
-                    filter_stmt = filter_stmt.where(time_range.start <= models.Trace.start_time)
-                if time_range.end:
-                    filter_stmt = filter_stmt.where(models.Trace.start_time < time_range.end)
-            filter_subq = filter_stmt.subquery()
-            stmt = stmt.join(filter_subq, table.id == filter_subq.c.id)
+            stmt = stmt.where(table.id.in_(filtered_session_rowids))
         if sort:
             key: ColumnElement[Any]
             if sort.col is ProjectSessionColumn.startTime:
@@ -576,10 +609,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.project_rowid,
+                time_range or None,
+                filter_condition or None,
+                session_filter_condition or None,
+                annotation_name,
+            ),
         )
 
     @strawberry.field
@@ -589,9 +636,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.project_rowid,
+                time_range or None,
+                filter_condition or None,
+                session_filter_condition or None,
+                annotation_name,
+            ),
         )
 
     @strawberry.field
@@ -680,7 +740,7 @@ class Project(Node):
     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(
@@ -721,7 +781,7 @@ class Project(Node):
         time_range: TimeRange,
         time_bin_config: Optional[TimeBinConfig] = UNSET,
         filter_condition: Optional[str] = UNSET,
-    ) -> SpanCountTimeSeries:
+    ) -> "SpanCountTimeSeries":
         if time_range.start is None:
             raise BadRequest("Start time is required")
 
@@ -806,7 +866,7 @@ class Project(Node):
         info: Info[Context, None],
         time_range: TimeRange,
         time_bin_config: Optional[TimeBinConfig] = UNSET,
-    ) -> TraceCountTimeSeries:
+    ) -> "TraceCountTimeSeries":
         if time_range.start is None:
             raise BadRequest("Start time is required")
 
@@ -869,7 +929,7 @@ class Project(Node):
         info: Info[Context, None],
         time_range: TimeRange,
         time_bin_config: Optional[TimeBinConfig] = UNSET,
-    ) -> TraceCountByStatusTimeSeries:
+    ) -> "TraceCountByStatusTimeSeries":
         if time_range.start is None:
             raise BadRequest("Start time is required")
 
@@ -962,7 +1022,7 @@ class Project(Node):
         info: Info[Context, None],
         time_range: TimeRange,
         time_bin_config: Optional[TimeBinConfig] = UNSET,
-    ) -> TraceLatencyPercentileTimeSeries:
+    ) -> "TraceLatencyPercentileTimeSeries":
         if time_range.start is None:
             raise BadRequest("Start time is required")
 
@@ -1066,7 +1126,7 @@ class Project(Node):
         info: Info[Context, None],
         time_range: TimeRange,
         time_bin_config: Optional[TimeBinConfig] = UNSET,
-    ) -> TraceTokenCountTimeSeries:
+    ) -> "TraceTokenCountTimeSeries":
         if time_range.start is None:
             raise BadRequest("Start time is required")
 
@@ -1149,7 +1209,7 @@ class Project(Node):
         info: Info[Context, None],
         time_range: TimeRange,
         time_bin_config: Optional[TimeBinConfig] = UNSET,
-    ) -> TraceTokenCostTimeSeries:
+    ) -> "TraceTokenCostTimeSeries":
         if time_range.start is None:
             raise BadRequest("Start time is required")
 
@@ -1232,7 +1292,7 @@ class Project(Node):
         info: Info[Context, None],
         time_range: TimeRange,
         time_bin_config: Optional[TimeBinConfig] = UNSET,
-    ) -> SpanAnnotationScoreTimeSeries:
+    ) -> "SpanAnnotationScoreTimeSeries":
         if time_range.start is None:
             raise BadRequest("Start time is required")
 
@@ -1287,6 +1347,8 @@ class Project(Node):
                 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] = {}

phoenix/server/email/sender.py

@@ -88,21 +88,24 @@ class SimpleEmailSender:
         allocated_storage_gibibytes: float,
         notification_threshold_percentage: float,
     ) -> None:
-        subject = "[Phoenix] Database Usage Threshold Exceeded"
+        subject = "[Phoenix] Database Disk Space Usage Threshold Exceeded"
         template_name = "db_disk_usage_notification.html"
 
+        support_email = get_env_support_email()
         template = self.env.get_template(template_name)
         html_content = template.render(
             current_usage_gibibytes=current_usage_gibibytes,
             allocated_storage_gibibytes=allocated_storage_gibibytes,
             notification_threshold_percentage=notification_threshold_percentage,
-            support_email=get_env_support_email(),
+            support_email=support_email,
         )
 
         msg = EmailMessage()
         msg["Subject"] = subject
         msg["From"] = self.sender_email
         msg["To"] = email
+        if support_email:
+            msg["Cc"] = support_email
         msg.set_content(html_content, subtype="html")
 
         await to_thread.run_sync(self._send_email, msg)