arize-phoenix 11.33.0__tar.gz → 11.35.0__tar.gz

{arize_phoenix-11.33.0 → arize_phoenix-11.35.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arize-phoenix
-Version: 11.33.0
+Version: 11.35.0
 Summary: AI Observability and Evaluation
 Project-URL: Documentation, https://arize.com/docs/phoenix/
 Project-URL: Issues, https://github.com/Arize-ai/phoenix/issues
@@ -21,7 +21,7 @@ Requires-Dist: aioitertools
 Requires-Dist: aiosqlite
 Requires-Dist: alembic<2,>=1.3.0
 Requires-Dist: arize-phoenix-client
-Requires-Dist: arize-phoenix-evals>=0.20.6
+Requires-Dist: arize-phoenix-evals>=2.0.0
 Requires-Dist: arize-phoenix-otel>=0.10.3
 Requires-Dist: authlib
 Requires-Dist: cachetools
@@ -121,12 +121,6 @@ Requires-Dist: numba>=0.60.0; extra == 'embeddings'
 Requires-Dist: umap-learn; extra == 'embeddings'
 Provides-Extra: evals
 Provides-Extra: experimental
-Provides-Extra: llama-index
-Requires-Dist: llama-index-agent-openai>=0.2.7; extra == 'llama-index'
-Requires-Dist: llama-index-embeddings-openai>=0.1.10; extra == 'llama-index'
-Requires-Dist: llama-index-llms-openai>=0.1.24; extra == 'llama-index'
-Requires-Dist: llama-index-readers-file>=0.1.25; extra == 'llama-index'
-Requires-Dist: llama-index==0.11.0; extra == 'llama-index'
 Provides-Extra: pg
 Requires-Dist: asyncpg; extra == 'pg'
 Requires-Dist: psycopg[binary,pool]; extra == 'pg'
@@ -241,6 +235,15 @@ Phoenix is built on top of OpenTelemetry and is vendor, language, and framework
 | [Autogen AgentChat](https://arize.com/docs/phoenix/integrations/frameworks/autogen/autogen-tracing) | `openinference-instrumentation-autogen-agentchat` | [![PyPI Version](https://img.shields.io/pypi/v/openinference-instrumentation-autogen-agentchat.svg)](https://pypi.python.org/pypi/openinference-instrumentation-autogen-agentchat) |
 | [Portkey](https://arize.com/docs/phoenix/integrations/portkey) | `openinference-instrumentation-portkey` | [![PyPI Version](https://img.shields.io/pypi/v/openinference-instrumentation-portkey.svg)](https://pypi.python.org/pypi/openinference-instrumentation-portkey) |
 
+## Span Processors
+
+Normalize and convert data across other instrumentation libraries by adding span processors that unify data.
+
+| Package                                                                                                           | Description                                                      | Version                                                                                                                                                                |
+| ----------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| [`openinference-instrumentation-openlit`](./python/instrumentation/openinference-instrumentation-openlit)         | OpenInference Span Processor for OpenLIT traces.                 | [![PyPI Version](https://img.shields.io/pypi/v/openinference-instrumentation-openlit.svg)](https://pypi.python.org/pypi/openinference-instrumentation-openlit)         |
+| [`openinference-instrumentation-openllmetry`](./python/instrumentation/openinference-instrumentation-openllmetry) | OpenInference Span Processor for OpenLLMetry (Traceloop) traces. | [![PyPI Version](https://img.shields.io/pypi/v/openinference-instrumentation-openllmetry.svg)](https://pypi.python.org/pypi/openinference-instrumentation-openllmetry) |
+
 ### JavaScript Integrations
 
 | Integration                                                                                | Package                                            | Version Badge                                                                                                                                                                       |
@@ -256,7 +259,7 @@ Phoenix is built on top of OpenTelemetry and is vendor, language, and framework
 | Integration                                                                                                                       | Package                                     | Version Badge                                                                                                                                                                                                 |
 | --------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | [LangChain4j](https://github.com/Arize-ai/openinference/tree/main/java/instrumentation/openinference-instrumentation-langchain4j) | `openinference-instrumentation-langchain4j` | [![Maven Central](https://img.shields.io/maven-central/v/com.arize/openinference-instrumentation-langchain4j.svg)](https://central.sonatype.com/artifact/com.arize/openinference-instrumentation-langchain4j) |
-| [SpringAI](https://central.sonatype.com/artifact/com.arize/openinference-instrumentation-springAI)                                | `openinference-instrumentation-springAI`    | [![Maven Central](https://img.shields.io/maven-central/v/com.arize/openinference-instrumentation-springAI.svg)](https://central.sonatype.com/artifact/com.arize/openinference-instrumentation-springAI)       |
+| SpringAI                                                                                                                          | `openinference-instrumentation-springAI`    | [![Maven Central](https://img.shields.io/maven-central/v/com.arize/openinference-instrumentation-springAI.svg)](https://central.sonatype.com/artifact/com.arize/openinference-instrumentation-springAI)       |
 
 ### Platforms
 

{arize_phoenix-11.33.0 → arize_phoenix-11.35.0}/README.md

@@ -106,6 +106,15 @@ Phoenix is built on top of OpenTelemetry and is vendor, language, and framework
 | [Autogen AgentChat](https://arize.com/docs/phoenix/integrations/frameworks/autogen/autogen-tracing) | `openinference-instrumentation-autogen-agentchat` | [![PyPI Version](https://img.shields.io/pypi/v/openinference-instrumentation-autogen-agentchat.svg)](https://pypi.python.org/pypi/openinference-instrumentation-autogen-agentchat) |
 | [Portkey](https://arize.com/docs/phoenix/integrations/portkey) | `openinference-instrumentation-portkey` | [![PyPI Version](https://img.shields.io/pypi/v/openinference-instrumentation-portkey.svg)](https://pypi.python.org/pypi/openinference-instrumentation-portkey) |
 
+## Span Processors
+
+Normalize and convert data across other instrumentation libraries by adding span processors that unify data.
+
+| Package                                                                                                           | Description                                                      | Version                                                                                                                                                                |
+| ----------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| [`openinference-instrumentation-openlit`](./python/instrumentation/openinference-instrumentation-openlit)         | OpenInference Span Processor for OpenLIT traces.                 | [![PyPI Version](https://img.shields.io/pypi/v/openinference-instrumentation-openlit.svg)](https://pypi.python.org/pypi/openinference-instrumentation-openlit)         |
+| [`openinference-instrumentation-openllmetry`](./python/instrumentation/openinference-instrumentation-openllmetry) | OpenInference Span Processor for OpenLLMetry (Traceloop) traces. | [![PyPI Version](https://img.shields.io/pypi/v/openinference-instrumentation-openllmetry.svg)](https://pypi.python.org/pypi/openinference-instrumentation-openllmetry) |
+
 ### JavaScript Integrations
 
 | Integration                                                                                | Package                                            | Version Badge                                                                                                                                                                       |
@@ -121,7 +130,7 @@ Phoenix is built on top of OpenTelemetry and is vendor, language, and framework
 | Integration                                                                                                                       | Package                                     | Version Badge                                                                                                                                                                                                 |
 | --------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | [LangChain4j](https://github.com/Arize-ai/openinference/tree/main/java/instrumentation/openinference-instrumentation-langchain4j) | `openinference-instrumentation-langchain4j` | [![Maven Central](https://img.shields.io/maven-central/v/com.arize/openinference-instrumentation-langchain4j.svg)](https://central.sonatype.com/artifact/com.arize/openinference-instrumentation-langchain4j) |
-| [SpringAI](https://central.sonatype.com/artifact/com.arize/openinference-instrumentation-springAI)                                | `openinference-instrumentation-springAI`    | [![Maven Central](https://img.shields.io/maven-central/v/com.arize/openinference-instrumentation-springAI.svg)](https://central.sonatype.com/artifact/com.arize/openinference-instrumentation-springAI)       |
+| SpringAI                                                                                                                          | `openinference-instrumentation-springAI`    | [![Maven Central](https://img.shields.io/maven-central/v/com.arize/openinference-instrumentation-springAI.svg)](https://central.sonatype.com/artifact/com.arize/openinference-instrumentation-springAI)       |
 
 ### Platforms
 

{arize_phoenix-11.33.0 → arize_phoenix-11.35.0}/pyproject.toml

@@ -53,7 +53,7 @@ dependencies = [
   "sqlean.py>=3.45.1,<3.50; platform_system == 'Windows'",  # https://github.com/nalgeon/sqlean.py/commit/2714a4789998811b7dd9f102f5b45ea071ed879e
   "cachetools",
   "python-multipart",  # see https://www.starlette.io/#dependencies
-  "arize-phoenix-evals>=0.20.6",
+  "arize-phoenix-evals>=2.0.0",
   "arize-phoenix-otel>=0.10.3",
   "fastapi",
   "pydantic>=2.1.0", # exclude 2.0.* since it does not support the `json_encoders` configuration setting
@@ -115,13 +115,6 @@ embeddings = [
 ]
 evals = []
 experimental = []
-llama-index = [
-  "llama-index==0.11.0",  # always pin to a version that keeps our notebooks working
-  "llama-index-readers-file>=0.1.25",
-  "llama-index-llms-openai>=0.1.24",
-  "llama-index-embeddings-openai>=0.1.10",
-  "llama-index-agent-openai>=0.2.7",
-]
 pg = [
   "asyncpg",
   "psycopg[binary,pool]",

{arize_phoenix-11.33.0 → arize_phoenix-11.35.0}/src/phoenix/config.py

@@ -134,6 +134,25 @@ ENV_PHOENIX_ENABLE_PROMETHEUS = "PHOENIX_ENABLE_PROMETHEUS"
 """
 Whether to enable Prometheus. Defaults to false.
 """
+ENV_PHOENIX_MAX_SPANS_QUEUE_SIZE = "PHOENIX_MAX_SPANS_QUEUE_SIZE"
+"""
+The maximum number of spans to hold in the processing queue before rejecting new requests.
+
+This is a heuristic to prevent memory issues when spans accumulate faster than they can be
+written to the database. When this limit is reached, new incoming requests will be rejected
+to protect system memory.
+
+Note: The actual queue size may exceed this limit due to batch processing. Requests are
+accepted or rejected before spans are deserialized, but a single accepted request may
+contain multiple spans. This behavior is intentional to balance memory protection with
+processing efficiency.
+
+Memory usage: If an average span takes ~50KiB of memory, then 20,000 spans would use ~1GiB
+of memory. Adjust this value based on your system's available memory and expected database
+throughput.
+
+Defaults to 20000.
+"""
 ENV_LOGGING_MODE = "PHOENIX_LOGGING_MODE"
 """
 The logging mode (either 'default' or 'structured').
@@ -1422,6 +1441,30 @@ def get_env_enable_prometheus() -> bool:
     )
 
 
+def get_env_max_spans_queue_size() -> int:
+    """
+    Gets the maximum spans queue size from the PHOENIX_MAX_SPANS_QUEUE_SIZE environment variable.
+
+    Returns:
+        int: The maximum number of spans to hold in queue before rejecting requests.
+             Defaults to 20,000 if not set.
+
+    Raises:
+        ValueError: If the value is not a positive integer.
+
+    Note:
+        The actual queue size may exceed this limit due to batch processing where a single
+        accepted request can contain multiple spans. This is a heuristic for memory protection.
+    """
+    max_size = _int_val(ENV_PHOENIX_MAX_SPANS_QUEUE_SIZE, 20_000)
+    if max_size <= 0:
+        raise ValueError(
+            f"Invalid value for environment variable {ENV_PHOENIX_MAX_SPANS_QUEUE_SIZE}: "
+            f"{max_size}. Value must be a positive integer."
+        )
+    return max_size
+
+
 def get_env_client_headers() -> dict[str, str]:
     headers = parse_env_headers(getenv(ENV_PHOENIX_CLIENT_HEADERS))
     if (api_key := get_env_phoenix_api_key()) and "authorization" not in [
@@ -1684,6 +1727,7 @@ def verify_server_environment_variables() -> None:
     get_env_database_allocated_storage_capacity_gibibytes()
     get_env_database_usage_email_warning_threshold_percentage()
     get_env_database_usage_insertion_blocking_threshold_percentage()
+    get_env_max_spans_queue_size()
     validate_env_support_email()
 
     # Notify users about deprecated environment variables if they are being used.

{arize_phoenix-11.33.0 → arize_phoenix-11.35.0}/src/phoenix/db/bulk_inserter.py

@@ -1,17 +1,17 @@
 import asyncio
 import logging
 from asyncio import Queue, as_completed
-from collections.abc import AsyncIterator, Awaitable, Callable, Iterable
+from collections import deque
 from dataclasses import dataclass, field
 from functools import singledispatchmethod
-from itertools import islice
-from time import perf_counter
-from typing import Any, Optional, cast
+from time import perf_counter, time
+from typing import Any, AsyncIterator, Awaitable, Callable, Iterable, Optional, cast
 
 from openinference.semconv.trace import SpanAttributes
 from typing_extensions import TypeAlias
 
 import phoenix.trace.v1 as pb
+from phoenix.db import models
 from phoenix.db.insertion.constants import DEFAULT_RETRY_ALLOWANCE, DEFAULT_RETRY_DELAY_SEC
 from phoenix.db.insertion.document_annotation import DocumentAnnotationQueueInserter
 from phoenix.db.insertion.evaluation import (
@@ -29,15 +29,23 @@ from phoenix.db.insertion.trace_annotation import TraceAnnotationQueueInserter
 from phoenix.db.insertion.types import Insertables, Precursors
 from phoenix.server.daemons.span_cost_calculator import (
     SpanCostCalculator,
-    SpanCostCalculatorQueueItem,
 )
 from phoenix.server.dml_event import DmlEvent, SpanInsertEvent
+from phoenix.server.prometheus import (
+    BULK_LOADER_EVALUATION_INSERTIONS,
+    BULK_LOADER_EXCEPTIONS,
+    BULK_LOADER_LAST_ACTIVITY,
+    BULK_LOADER_SPAN_EXCEPTIONS,
+    BULK_LOADER_SPAN_INSERTION_TIME,
+    SPAN_QUEUE_SIZE,
+)
 from phoenix.server.types import CanPutItem, DbSessionFactory
 from phoenix.trace.schemas import Span
 
 logger = logging.getLogger(__name__)
 
 ProjectRowId: TypeAlias = int
+ProjectName: TypeAlias = str
 
 
 @dataclass(frozen=True)
@@ -52,12 +60,12 @@ class BulkInserter:
         *,
         event_queue: CanPutItem[DmlEvent],
         span_cost_calculator: SpanCostCalculator,
-        initial_batch_of_spans: Optional[Iterable[tuple[Span, str]]] = None,
-        initial_batch_of_evaluations: Optional[Iterable[pb.Evaluation]] = None,
+        initial_batch_of_spans: Iterable[tuple[Span, ProjectName]] = (),
+        initial_batch_of_evaluations: Iterable[pb.Evaluation] = (),
         sleep: float = 0.1,
         max_ops_per_transaction: int = 1000,
         max_queue_size: int = 1000,
-        enable_prometheus: bool = False,
+        max_spans_queue_size: Optional[int] = None,
         retry_delay_sec: float = DEFAULT_RETRY_DELAY_SEC,
         retry_allowance: int = DEFAULT_RETRY_ALLOWANCE,
     ) -> None:
@@ -68,7 +76,6 @@ class BulkInserter:
         :param max_ops_per_transaction: The maximum number of operations to dequeue from
         the operations queue for each transaction.
         :param max_queue_size: The maximum length of the operations queue.
-        :param enable_prometheus: Whether Prometheus is enabled.
         """
         self._db = db
         self._running = False
@@ -76,20 +83,20 @@ class BulkInserter:
         self._max_ops_per_transaction = max_ops_per_transaction
         self._operations: Optional[Queue[DataManipulation]] = None
         self._max_queue_size = max_queue_size
-        self._spans: list[tuple[Span, str]] = (
-            [] if initial_batch_of_spans is None else list(initial_batch_of_spans)
-        )
-        self._evaluations: list[pb.Evaluation] = (
-            [] if initial_batch_of_evaluations is None else list(initial_batch_of_evaluations)
-        )
+        self._max_spans_queue_size = max_spans_queue_size
+        self._spans: deque[tuple[Span, ProjectName]] = deque(initial_batch_of_spans)
+        self._evaluations: deque[pb.Evaluation] = deque(initial_batch_of_evaluations)
         self._task: Optional[asyncio.Task[None]] = None
         self._event_queue = event_queue
-        self._enable_prometheus = enable_prometheus
         self._retry_delay_sec = retry_delay_sec
         self._retry_allowance = retry_allowance
         self._queue_inserters = _QueueInserters(db, self._retry_delay_sec, self._retry_allowance)
         self._span_cost_calculator = span_cost_calculator
 
+    @property
+    def is_full(self) -> bool:
+        return bool(self._max_spans_queue_size and self._max_spans_queue_size <= len(self._spans))
+
     async def __aenter__(
         self,
     ) -> tuple[
@@ -102,9 +109,9 @@ class BulkInserter:
         self._operations = Queue(maxsize=self._max_queue_size)
         self._task = asyncio.create_task(self._bulk_insert())
         return (
-            self._enqueue,
-            self._queue_span,
-            self._queue_evaluation,
+            self._enqueue_annotations,
+            self._enqueue_span,
+            self._enqueue_evaluation,
             self._enqueue_operation,
         )
 
@@ -114,23 +121,22 @@ class BulkInserter:
             self._task.cancel()
             self._task = None
 
-    async def _enqueue(self, *items: Any) -> None:
+    async def _enqueue_annotations(self, *items: Any) -> None:
         await self._queue_inserters.enqueue(*items)
 
     def _enqueue_operation(self, operation: DataManipulation) -> None:
         cast("Queue[DataManipulation]", self._operations).put_nowait(operation)
 
-    async def _queue_span(self, span: Span, project_name: str) -> None:
+    async def _enqueue_span(self, span: Span, project_name: str) -> None:
         self._spans.append((span, project_name))
 
-    async def _queue_evaluation(self, evaluation: pb.Evaluation) -> None:
+    async def _enqueue_evaluation(self, evaluation: pb.Evaluation) -> None:
         self._evaluations.append(evaluation)
 
     async def _process_events(self, events: Iterable[Optional[DataManipulationEvent]]) -> None: ...
 
     async def _bulk_insert(self) -> None:
         assert isinstance(self._operations, Queue)
-        spans_buffer, evaluations_buffer = None, None
         # start first insert immediately if the inserter has not run recently
         while (
             self._running
@@ -139,6 +145,8 @@ class BulkInserter:
             or self._spans
             or self._evaluations
         ):
+            BULK_LOADER_LAST_ACTIVITY.set(time())
+            SPAN_QUEUE_SIZE.set(len(self._spans))
             if (
                 self._queue_inserters.empty
                 and self._operations.empty()
@@ -156,113 +164,100 @@ class BulkInserter:
                         async with session.begin_nested():
                             await op(session)
                     except Exception as e:
-                        if self._enable_prometheus:
-                            from phoenix.server.prometheus import BULK_LOADER_EXCEPTIONS
-
-                            BULK_LOADER_EXCEPTIONS.inc()
+                        BULK_LOADER_EXCEPTIONS.inc()
                         logger.exception(str(e))
             # It's important to grab the buffers at the same time so there's
             # no race condition, since an eval insertion will fail if the span
             # it references doesn't exist. Grabbing the eval buffer later may
             # include an eval whose span is in the queue but missed being
             # included in the span buffer that was grabbed previously.
-            if self._spans:
-                spans_buffer = self._spans
-                self._spans = []
-            if self._evaluations:
-                evaluations_buffer = self._evaluations
-                self._evaluations = []
+            num_spans_to_insert = min(self._max_ops_per_transaction, len(self._spans))
+            num_evals_to_insert = min(self._max_ops_per_transaction, len(self._evaluations))
             # Spans should be inserted before the evaluations, since an evaluation
             # insertion will fail if the span it references doesn't exist.
-            if spans_buffer:
-                await self._insert_spans(spans_buffer)
-                spans_buffer = None
-            if evaluations_buffer:
-                await self._insert_evaluations(evaluations_buffer)
-                evaluations_buffer = None
+            await self._insert_spans(num_spans_to_insert)
+            await self._insert_evaluations(num_evals_to_insert)
             async for event in self._queue_inserters.insert():
                 self._event_queue.put(event)
             await asyncio.sleep(self._sleep)
 
-    async def _insert_spans(self, spans: list[tuple[Span, str]]) -> None:
+    async def _insert_spans(self, num_spans_to_insert: int) -> None:
+        if not num_spans_to_insert or not self._spans:
+            return
         project_ids = set()
-        span_cost_calculator_queue: list[SpanCostCalculatorQueueItem] = []
-        for i in range(0, len(spans), self._max_ops_per_transaction):
-            try:
-                start = perf_counter()
-                async with self._db() as session:
-                    for span, project_name in islice(spans, i, i + self._max_ops_per_transaction):
-                        if self._enable_prometheus:
-                            from phoenix.server.prometheus import BULK_LOADER_SPAN_INSERTIONS
-
-                            BULK_LOADER_SPAN_INSERTIONS.inc()
-                        result: Optional[SpanInsertionEvent] = None
-                        try:
-                            async with session.begin_nested():
-                                result = await insert_span(session, span, project_name)
-                        except Exception:
-                            if self._enable_prometheus:
-                                from phoenix.server.prometheus import BULK_LOADER_EXCEPTIONS
-
-                                BULK_LOADER_EXCEPTIONS.inc()
-                            logger.exception(
-                                f"Failed to insert span with span_id={span.context.span_id}"
-                            )
-                        if result is not None:
-                            project_ids.add(result.project_rowid)
-                            if should_calculate_span_cost(span.attributes):
-                                span_cost_calculator_queue.append(
-                                    SpanCostCalculatorQueueItem(
-                                        span_rowid=result.span_rowid,
-                                        trace_rowid=result.trace_rowid,
-                                        attributes=span.attributes,
-                                        span_start_time=span.start_time,
-                                    )
-                                )
-
-                if self._enable_prometheus:
-                    from phoenix.server.prometheus import BULK_LOADER_INSERTION_TIME
-
-                    BULK_LOADER_INSERTION_TIME.observe(perf_counter() - start)
-            except Exception:
-                if self._enable_prometheus:
-                    from phoenix.server.prometheus import BULK_LOADER_EXCEPTIONS
-
-                    BULK_LOADER_EXCEPTIONS.inc()
-                logger.exception("Failed to insert spans")
-        self._event_queue.put(SpanInsertEvent(tuple(project_ids)))
-        for item in span_cost_calculator_queue:
-            self._span_cost_calculator.put_nowait(item)
-
-    async def _insert_evaluations(self, evaluations: list[pb.Evaluation]) -> None:
-        for i in range(0, len(evaluations), self._max_ops_per_transaction):
-            try:
-                start = perf_counter()
-                async with self._db() as session:
-                    for evaluation in islice(evaluations, i, i + self._max_ops_per_transaction):
-                        if self._enable_prometheus:
-                            from phoenix.server.prometheus import BULK_LOADER_EVALUATION_INSERTIONS
-
-                            BULK_LOADER_EVALUATION_INSERTIONS.inc()
-                        try:
-                            async with session.begin_nested():
-                                await insert_evaluation(session, evaluation)
-                        except InsertEvaluationError as error:
-                            if self._enable_prometheus:
-                                from phoenix.server.prometheus import BULK_LOADER_EXCEPTIONS
-
-                                BULK_LOADER_EXCEPTIONS.inc()
-                            logger.exception(f"Failed to insert evaluation: {str(error)}")
-                if self._enable_prometheus:
-                    from phoenix.server.prometheus import BULK_LOADER_INSERTION_TIME
-
-                    BULK_LOADER_INSERTION_TIME.observe(perf_counter() - start)
-            except Exception:
-                if self._enable_prometheus:
-                    from phoenix.server.prometheus import BULK_LOADER_EXCEPTIONS
+        span_costs: list[models.SpanCost] = []
+        try:
+            start = perf_counter()
+            async with self._db() as session:
+                while num_spans_to_insert > 0:
+                    num_spans_to_insert -= 1
+                    if not self._spans:
+                        break
+                    span, project_name = self._spans.popleft()
+                    result: Optional[SpanInsertionEvent] = None
+                    try:
+                        async with session.begin_nested():
+                            result = await insert_span(session, span, project_name)
+                    except Exception:
+                        BULK_LOADER_SPAN_EXCEPTIONS.inc()
+                        logger.exception(
+                            f"Failed to insert span with span_id={span.context.span_id}"
+                        )
+                    if result is None:
+                        continue
+                    project_ids.add(result.project_rowid)
+                    try:
+                        if not should_calculate_span_cost(span.attributes):
+                            continue
+                        span_cost = self._span_cost_calculator.calculate_cost(
+                            span.start_time,
+                            span.attributes,
+                        )
+                    except Exception:
+                        logger.exception(
+                            f"Failed to calculate span cost for span with "
+                            f"span_id={span.context.span_id}"
+                        )
+                    else:
+                        if span_cost is None:
+                            continue
+                        span_cost.span_rowid = result.span_rowid
+                        span_cost.trace_rowid = result.trace_rowid
+                        span_costs.append(span_cost)
+            BULK_LOADER_SPAN_INSERTION_TIME.observe(perf_counter() - start)
+        except Exception:
+            BULK_LOADER_SPAN_EXCEPTIONS.inc()
+            logger.exception("Failed to insert spans")
+        if project_ids:
+            self._event_queue.put(SpanInsertEvent(tuple(project_ids)))
+        if not span_costs:
+            return
+        try:
+            async with self._db() as session:
+                session.add_all(span_costs)
+        except Exception:
+            logger.exception("Failed to insert span costs")
 
-                    BULK_LOADER_EXCEPTIONS.inc()
-                logger.exception("Failed to insert evaluations")
+    async def _insert_evaluations(self, num_evals_to_insert: int) -> None:
+        if not num_evals_to_insert or not self._evaluations:
+            return
+        try:
+            async with self._db() as session:
+                while num_evals_to_insert > 0:
+                    num_evals_to_insert -= 1
+                    if not self._evaluations:
+                        break
+                    evaluation = self._evaluations.popleft()
+                    BULK_LOADER_EVALUATION_INSERTIONS.inc()
+                    try:
+                        async with session.begin_nested():
+                            await insert_evaluation(session, evaluation)
+                    except InsertEvaluationError as error:
+                        BULK_LOADER_EXCEPTIONS.inc()
+                        logger.exception(f"Failed to insert evaluation: {str(error)}")
+        except Exception:
+            BULK_LOADER_EXCEPTIONS.inc()
+            logger.exception("Failed to insert evaluations")
 
 
 class _QueueInserters:

{arize_phoenix-11.33.0 → arize_phoenix-11.35.0}/src/phoenix/server/api/routers/v1/documents.py

@@ -82,7 +82,7 @@ async def annotate_span_documents(
         annotation.as_precursor(user_id=user_id) for annotation in span_document_annotations
     ]
     if not sync:
-        await request.state.enqueue(*precursors)
+        await request.state.enqueue_annotations(*precursors)
         return AnnotateSpanDocumentsResponseBody(data=[])
 
     span_ids = {p.span_id for p in precursors}

{arize_phoenix-11.33.0 → arize_phoenix-11.35.0}/src/phoenix/server/api/routers/v1/evaluations.py

@@ -102,7 +102,7 @@ async def post_evaluations(
             detail="Evaluation name must not be blank/empty",
             status_code=HTTP_422_UNPROCESSABLE_ENTITY,
         )
-    await request.state.queue_evaluation_for_bulk_insert(evaluation)
+    await request.state.enqueue_evaluation(evaluation)
     return Response()
 
 
@@ -221,7 +221,7 @@ async def _add_evaluations(state: State, evaluations: Evaluations) -> None:
                 explanation=explanation,
                 metadata_={},
             )
-            await state.enqueue(document_annotation)
+            await state.enqueue_annotations(document_annotation)
     elif len(names) == 1 and names[0] in ("context.span_id", "span_id"):
         for index, row in dataframe.iterrows():
             score, label, explanation = _get_annotation_result(row)
@@ -235,7 +235,7 @@ async def _add_evaluations(state: State, evaluations: Evaluations) -> None:
                 explanation=explanation,
                 metadata_={},
             )
-            await state.enqueue(span_annotation)
+            await state.enqueue_annotations(span_annotation)
     elif len(names) == 1 and names[0] in ("context.trace_id", "trace_id"):
         for index, row in dataframe.iterrows():
             score, label, explanation = _get_annotation_result(row)
@@ -249,7 +249,7 @@ async def _add_evaluations(state: State, evaluations: Evaluations) -> None:
                 explanation=explanation,
                 metadata_={},
             )
-            await state.enqueue(trace_annotation)
+            await state.enqueue_annotations(trace_annotation)
 
 
 def _get_annotation_result(

{arize_phoenix-11.33.0 → arize_phoenix-11.35.0}/src/phoenix/server/api/routers/v1/spans.py

@@ -897,7 +897,7 @@ async def annotate_spans(
         )
     precursors = [d.as_precursor(user_id=user_id) for d in filtered_span_annotations]
     if not sync:
-        await request.state.enqueue(*precursors)
+        await request.state.enqueue_annotations(*precursors)
         return AnnotateSpansResponseBody(data=[])
 
     span_ids = {p.span_id for p in precursors}
@@ -1072,7 +1072,7 @@ async def create_spans(
 
     # All spans are valid, queue them all
     for span_for_insertion, project_name in spans_to_queue:
-        await request.state.queue_span_for_bulk_insert(span_for_insertion, project_name)
+        await request.state.enqueue_span(span_for_insertion, project_name)
 
     return CreateSpansResponseBody(
         total_received=total_received,

{arize_phoenix-11.33.0 → arize_phoenix-11.35.0}/src/phoenix/server/api/routers/v1/traces.py

@@ -18,6 +18,7 @@ from starlette.status import (
     HTTP_404_NOT_FOUND,
     HTTP_415_UNSUPPORTED_MEDIA_TYPE,
     HTTP_422_UNPROCESSABLE_ENTITY,
+    HTTP_503_SERVICE_UNAVAILABLE,
 )
 from strawberry.relay import GlobalID
 
@@ -29,6 +30,7 @@ from phoenix.server.api.types.node import from_global_id_with_expected_type
 from phoenix.server.authorization import is_not_locked
 from phoenix.server.bearer_auth import PhoenixUser
 from phoenix.server.dml_event import SpanDeleteEvent, TraceAnnotationInsertEvent
+from phoenix.server.prometheus import SPAN_QUEUE_REJECTIONS
 from phoenix.trace.otel import decode_otlp_span
 from phoenix.utilities.project import get_project_name
 
@@ -42,9 +44,18 @@ from .utils import (
 router = APIRouter(tags=["traces"])
 
 
+def is_not_at_capacity(request: Request) -> None:
+    if request.app.state.span_queue_is_full():
+        SPAN_QUEUE_REJECTIONS.inc()
+        raise HTTPException(
+            detail="Server is at capacity and cannot process more requests",
+            status_code=HTTP_503_SERVICE_UNAVAILABLE,
+        )
+
+
 @router.post(
     "/traces",
-    dependencies=[Depends(is_not_locked)],
+    dependencies=[Depends(is_not_locked), Depends(is_not_at_capacity)],
     operation_id="addTraces",
     summary="Send traces",
     responses=add_errors_to_responses(
@@ -56,6 +67,10 @@ router = APIRouter(tags=["traces"])
                 ),
             },
             {"status_code": HTTP_422_UNPROCESSABLE_ENTITY, "description": "Invalid request body"},
+            {
+                "status_code": HTTP_503_SERVICE_UNAVAILABLE,
+                "description": "Server is at capacity and cannot process more requests",
+            },
         ]
     ),
     openapi_extra={
@@ -145,7 +160,7 @@ async def annotate_traces(
 
     precursors = [d.as_precursor(user_id=user_id) for d in request_body.data]
     if not sync:
-        await request.state.enqueue(*precursors)
+        await request.state.enqueue_annotations(*precursors)
         return AnnotateTracesResponseBody(data=[])
 
     trace_ids = {p.trace_id for p in precursors}
@@ -193,7 +208,7 @@ async def _add_spans(req: ExportTraceServiceRequest, state: State) -> None:
         for scope_span in resource_spans.scope_spans:
             for otlp_span in scope_span.spans:
                 span = await run_in_threadpool(decode_otlp_span, otlp_span)
-                await state.queue_span_for_bulk_insert(span, project_name)
+                await state.enqueue_span(span, project_name)
 
 
 @router.delete(