arize-phoenix 11.33.0__py3-none-any.whl → 11.34.0__py3-none-any.whl

{arize_phoenix-11.33.0.dist-info → arize_phoenix-11.34.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arize-phoenix
-Version: 11.33.0
+Version: 11.34.0
 Summary: AI Observability and Evaluation
 Project-URL: Documentation, https://arize.com/docs/phoenix/
 Project-URL: Issues, https://github.com/Arize-ai/phoenix/issues

{arize_phoenix-11.33.0.dist-info → arize_phoenix-11.34.0.dist-info}/RECORD

@@ -1,12 +1,12 @@
 phoenix/__init__.py,sha256=Sgb4r2MLoY2BbC9Caky5C0bwnOyiVOMHly2sRItmg3Q,5555
 phoenix/auth.py,sha256=9rscOefuxy5VPcb6MlOYenuy3gDd5l7RxknONovGslE,11342
-phoenix/config.py,sha256=iZ0KE4Yc7msAwx3MykjhCx79_wSYBL6KTpLA9KuXD9I,63432
+phoenix/config.py,sha256=J0qpqoweNwQOErnvGnzrH8g3QC2VCyjNYQ0EKECvzCg,65211
 phoenix/datetime_utils.py,sha256=pRD-nzxXYKlMWNtd3r2tKGKfPFhwuJhfOAtlGLVAO60,8784
 phoenix/exceptions.py,sha256=n2L2KKuecrdflB9MsCdAYCiSEvGJptIsfRkXMoJle7A,169
 phoenix/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 phoenix/services.py,sha256=ngkyKGVatX3cO2WJdo2hKdaVKP-xJCMvqthvga6kJss,5196
 phoenix/settings.py,sha256=2kHfT3BNOVd4dAO1bq-syEQbHSG8oX2-7NhOwK2QREk,896
-phoenix/version.py,sha256=xS5dPjVBtFwJKeFvYvMVblVOWUcPzZ-FdUN6AhQ-9K8,24
+phoenix/version.py,sha256=muN5TyR0wlxL44978731Bf111znItdl8HBAWgNnGSOQ,24
 phoenix/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 phoenix/core/embedding_dimension.py,sha256=zKGbcvwOXgLf-yrJBpQyKtd-LEOPRKHnUToyAU8Owis,87
 phoenix/core/model.py,sha256=qBFraOtmwCCnWJltKNP18DDG0mULXigytlFsa6YOz6k,4837
@@ -15,7 +15,7 @@ phoenix/core/model_schema_adapter.py,sha256=y1RXPYGt2HLTGpkB2X-XVQvRJXYGmJ9EL4m7
 phoenix/db/README.md,sha256=51cZyk1XzkUz0jn1cIRkgrZW3LeQZmhWCIXUMWjWO90,10905
 phoenix/db/__init__.py,sha256=pDjEFXukHmJBM-1D8RjmXkvLsz85YWNxMQczt81ec3A,118
 phoenix/db/alembic.ini,sha256=GIS6HpHaKaJbbuahZg1Rc1D2_QqyCkV9r58wdARGf6w,3262
-phoenix/db/bulk_inserter.py,sha256=MbbmKip6gFtnLP1ZA3Z-mP-zy-Qnb9bPD8mRXJQOW2c,14536
+phoenix/db/bulk_inserter.py,sha256=yfhnSJU4kpLlZxQr971fTAmkzP2LjQKMyYLXEijomMU,13761
 phoenix/db/constants.py,sha256=-YE2rkzcROG06_rerfnX5hC7fLzOHx1Gjw4nXhX_um4,46
 phoenix/db/engines.py,sha256=e-VdW9FZVrs-F8P8FeQP2NzOTOXuq9LeUq1ebv99ZdM,6731
 phoenix/db/enums.py,sha256=w3O5YuJEEzVTwVDZb8b2UUFhU8yK_GosF081VVrrno0,188
@@ -91,16 +91,16 @@ phoenix/pointcloud/pointcloud.py,sha256=SN_1wXZcwKrtSnHGZLDZGx71orqE1WyVF7E-D58d
 phoenix/pointcloud/projectors.py,sha256=TQgwc9cJDjJkin1WZyZzgl3HsYrLLiyWD7Czy4jNW3U,1088
 phoenix/pointcloud/umap_parameters.py,sha256=db_WEPoamuWtopZx7tQfAXPnoE0MS8FkAV0_ThjEx_Q,1735
 phoenix/server/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-phoenix/server/app.py,sha256=LFnFe4GTxeqkGY1Wc6qnmlBchjuG_vKfW_MoIevQVlc,49187
+phoenix/server/app.py,sha256=wSCpFMo_PWnOftbxvPdexnLfW9HbX_9gjErVykCTVLQ,50319
 phoenix/server/authorization.py,sha256=OxROn7ibpKtCTrcgDkzWuNxVaQcSQ8MAx7zbjZiliK0,3201
 phoenix/server/bearer_auth.py,sha256=f4v4W94KyTdGGCPsK1tXOe0vouPuvanAEa03XSdCvPE,6650
 phoenix/server/dml_event.py,sha256=8UciN7W8X_IqQfAnAeAh68BezNmfxSxuTeD6IUerTW8,2911
 phoenix/server/dml_event_handler.py,sha256=71_iPcHiJ4E-8Z7sGL2j0vx_RpkmcMVEUFIBsWrdp-E,8483
-phoenix/server/grpc_server.py,sha256=ahHC394gFZYM3h4FmjQxZwL-a4x3mWmV2EdXYFlNEC8,4676
+phoenix/server/grpc_server.py,sha256=THDdkMKXQEC3gZjFG2nUgXHFbUnWsRHgFM9oh5WtAX0,4758
 phoenix/server/jwt_store.py,sha256=B6uVildN_dQDTG_-aHHvuVSI7wIVK1yvED-_y6se2GU,16905
 phoenix/server/main.py,sha256=UBwxrQIEE7ci-SbE6GAlRYmbMHooI6JYG6sG-UpBFFs,18905
 phoenix/server/oauth2.py,sha256=GvUqZBoZ5dG-l2G1RMl1SUcN10jNAjaMXFznMSWz2Zs,3336
-phoenix/server/prometheus.py,sha256=PV3XNUvtBQqpIjFS5ulyhGK_WF-2v-Wf3rsXjfDxeUs,8694
+phoenix/server/prometheus.py,sha256=ovh6Hrw2mLUC6KddGydT0_lv-yK0upV9mL-T9UjqlcE,9373
 phoenix/server/rate_limiters.py,sha256=cFc73D2NaxqNZZDbwfIDw4So-fRVOJPBtqxOZ8Qky_s,7155
 phoenix/server/retention.py,sha256=MQe1FWuc_NxhqgIq5q2hfFhWT8ddAmpppgI74xYEQ6c,3064
 phoenix/server/session_filters.py,sha256=zEJHnF2sDCxjWti2eOz1Yx4r4-zS1rAzq0oUxzl0gEY,1697
@@ -265,16 +265,16 @@ phoenix/server/api/routers/v1/__init__.py,sha256=_CxVCs26dPuC2KygV3VzYqmoAECeFwi
 phoenix/server/api/routers/v1/annotation_configs.py,sha256=xp5lJmKYlRsINCUrRD9-lTAElw2v4hdFndS5BWrxICA,16048
 phoenix/server/api/routers/v1/annotations.py,sha256=V_Cm_XOJaSVpMsTCfxBd1H39sk17b2y6Lyk5qwwDHvI,11433
 phoenix/server/api/routers/v1/datasets.py,sha256=9iPORLmbOrPKgUUcRDMs6ZczSIz7hvc6bngJy3IbdR0,38331
-phoenix/server/api/routers/v1/documents.py,sha256=iA_vYU6_p2-pazh_Rp930kiOsiHYFIPPqsZSSXwPgVI,5733
-phoenix/server/api/routers/v1/evaluations.py,sha256=aBrPO-xCAWyTxydaHq7W2wQFm65k89uVR-H3VWsd6WQ,13062
+phoenix/server/api/routers/v1/documents.py,sha256=qSEQaavpKd3IFuvEiIPj4oYU4AZOi4CLlDu-ZTwWMDw,5745
+phoenix/server/api/routers/v1/evaluations.py,sha256=bZmOttGlI7MIDC80YfSX7-gYPa5c0WKQDIA6qbQRNEU,13084
 phoenix/server/api/routers/v1/experiment_evaluations.py,sha256=DZ3UK9OoYKElpRcEER7559-KiAqWr-1IXpZ27FbfP3k,5249
 phoenix/server/api/routers/v1/experiment_runs.py,sha256=KaQ6EI1qQrIE-q1C22C9sEUnr9aho-23xcDDPIIkwko,8378
 phoenix/server/api/routers/v1/experiments.py,sha256=-xoAh4rTMKkmjDJSICNv3dvlTtMdCGB6ZuxuossHuMY,20617
 phoenix/server/api/routers/v1/models.py,sha256=p3gJN-9SWiUYTUTft4bZMsZVCBNTb4nN1Foy68eRZzQ,1997
 phoenix/server/api/routers/v1/projects.py,sha256=XR6uJxHXXtC1q8LNyS9W6iaj440sv1OKCu-OSBfxEys,12824
 phoenix/server/api/routers/v1/prompts.py,sha256=chRYcLkOYDJdJfVZVukVTUyIRnLPvsJCg41CuPxOIU8,26695
-phoenix/server/api/routers/v1/spans.py,sha256=9xWj5RZEGCjOUVCx9bl-tHdQrIS6VvaUROfo3ROg7J4,47583
-phoenix/server/api/routers/v1/traces.py,sha256=-_g-Imy31J_jWyCOMIOAHMEdMB6KxeLRNW56r9-6REI,9849
+phoenix/server/api/routers/v1/spans.py,sha256=m_4VfYndU6wVZ4xXMMJyajfuYHBiB28HCl8BAC2t2V0,47581
+phoenix/server/api/routers/v1/traces.py,sha256=dtJej9kHcbxb0OXa7HBSD19nO-HASaR1ixj0-HFJgc4,10454
 phoenix/server/api/routers/v1/users.py,sha256=eO8zMtGU33Td2_G1l9D7Z0a4CG1CwBUCj_Z9z2uk7wg,12089
 phoenix/server/api/routers/v1/utils.py,sha256=oXIOGPzPTkE0ZWUTRCoRIQQ7wTzoSwtWFaUSjlGBqts,4960
 phoenix/server/api/types/Annotation.py,sha256=gsl8CwjIbDUbZRj4d9USwZ_w_Tkz4i7zuZh9ftV80jA,1132
@@ -379,7 +379,7 @@ phoenix/server/cost_tracking/token_cost_calculator.py,sha256=2JEZnvusx2-xbhp8krp
 phoenix/server/daemons/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 phoenix/server/daemons/db_disk_usage_monitor.py,sha256=2WBkrL1QyRGbLtskXEdxwAdnWLjtdQ-mix95AkLQSbg,7997
 phoenix/server/daemons/generative_model_store.py,sha256=CkMG0jFWtxcUNP_7iFTgzHPyl5IgnXUwwJb7584pmkI,1566
-phoenix/server/daemons/span_cost_calculator.py,sha256=M7bG8fas99xz37bZUkBXnG37U2otUcu1-FI5RmrtPgU,3052
+phoenix/server/daemons/span_cost_calculator.py,sha256=0P0ErNmUd8Hi8jqjieNR-bakAMiYfiBlB7QkLEoHX3o,3284
 phoenix/server/email/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 phoenix/server/email/sender.py,sha256=tmigvAyLV6cyGLfH6Ks_q0L5wlTpo6mBB951QCmhadw,5161
 phoenix/server/email/types.py,sha256=f1XXk4OQJlLSCHweujrGlkZic7CtbUSnfdPXzqP9WRI,772
@@ -402,16 +402,16 @@ phoenix/server/static/apple-touch-icon-76x76.png,sha256=CT_xT12I0u2i0WU8JzBZBuOQ
 phoenix/server/static/apple-touch-icon.png,sha256=fOfpjqGpWYbJ0eAurKsyoZP1EAs6ZVooBJ_SGk2ZkDs,3801
 phoenix/server/static/favicon.ico,sha256=bY0vvCKRftemZfPShwZtE93DiiQdaYaozkPGwNFr6H8,34494
 phoenix/server/static/modernizr.js,sha256=mvK-XtkNqjOral-QvzoqsyOMECXIMu5BQwSVN_wcU9c,2564
-phoenix/server/static/.vite/manifest.json,sha256=I1RfIYC-Ma_2QY8DosqhJZM5PRTNeDwIqDUt2iKCFM0,2328
-phoenix/server/static/assets/components-YTHUASXI.js,sha256=o7lPFFwvxIor_Bpckbv5w5hExx6cPajyxqTUDBxrLOQ,675981
-phoenix/server/static/assets/index-CugQp26L.js,sha256=JurvXdTz3puPThXy94Wl3wA1ogRF93oW1EWRdep4rBI,62934
-phoenix/server/static/assets/pages-4Qu8GNlt.js,sha256=Vhbzq1Xxfo0jI8GVyOaBHGhlC5o99VsH2rczS95mljE,1296687
+phoenix/server/static/.vite/manifest.json,sha256=UKiCtA5rvKMr8U4zLFRXo5S5Fdvy8dKouD1kF3GESko,2328
+phoenix/server/static/assets/components-CdQiQTvs.js,sha256=ffg4jmfz-Bc9PTLXXAz7OduRazQDl5KZyeR_3S2aILs,675981
+phoenix/server/static/assets/index-B1VuXYRI.js,sha256=jOk_qo0Q0SRXWfvHVlValebC3vs1mUfV1v-Kf94B2rc,62934
+phoenix/server/static/assets/pages-CnfZ3RhB.js,sha256=XYLansUm9qmewwVwsW-dskFdfP72RCMzRAdzlLMJMhg,1298004
 phoenix/server/static/assets/vendor-BGzfc4EU.css,sha256=Nx5Lmx-bqYR7nsO_O4kEBcrJ8cwknWjZ6seHN3_s4UQ,3171
-phoenix/server/static/assets/vendor-CRRxHwSp.js,sha256=hzYvX7n-hUemSlnmufuzR9u5zx2bbLHSXC5qz_PqcA8,2572316
-phoenix/server/static/assets/vendor-arizeai-CUN6lRd9.js,sha256=W5vabYWQPD5YY7vzrISgQYPmks2i8LUSMZNq3tXBfOI,121519
-phoenix/server/static/assets/vendor-codemirror-sJXwoqrE.js,sha256=O13CkiI3OeAgFPEXPDnk2f1_lRi8qgMMErektFdbwcE,413196
-phoenix/server/static/assets/vendor-recharts-BT_PeGhc.js,sha256=H-ZcKdntQ3IQ21wf58hqD7sqH5Z3cXEdp_hnuo3cRU4,231653
-phoenix/server/static/assets/vendor-shiki-1F3op0QC.js,sha256=M8KLH3pUDvSv68dNETLOk0TFfeHQNtZ2vPj1NPTdJw8,305160
+phoenix/server/static/assets/vendor-Cfrr9FCF.js,sha256=e5sXxTzHgKwjsNy7bFWp19fM9QolSJBQ9FvE4hmxrPs,2575393
+phoenix/server/static/assets/vendor-arizeai-Dz0kN-lQ.js,sha256=hPa1rpMUjztQaAsf5h87E_RCDhcuWowkoTrfMaTS5_g,121519
+phoenix/server/static/assets/vendor-codemirror-ClqtONZQ.js,sha256=zPD9V1TJW7mlnmIQcpjjaajHLATsDb0dxXnGsq24Qcg,413205
+phoenix/server/static/assets/vendor-recharts-D6kvOpmb.js,sha256=AcaZOFH-ggGi-znCeAP_b072ALbIcPqhqYDZn63Hjps,231653
+phoenix/server/static/assets/vendor-shiki-xSOiKxt0.js,sha256=itTnSRR18G_YLCygdVlLLqMrXHaPqjnD2Z6WcS4O9ro,305160
 phoenix/server/static/assets/vendor-three-BLWp5bic.js,sha256=vfSCVXS20jA0Ceo_O0mDxYBcROinWMdPE6RR4JXmtec,620972
 phoenix/server/templates/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 phoenix/server/templates/index.html,sha256=QAYh0TG5mg-GvDQUR09aD9ebl9Sfq0fYAcfIa5G7J6E,7148
@@ -451,9 +451,9 @@ phoenix/utilities/project.py,sha256=auVpARXkDb-JgeX5f2aStyFIkeKvGwN9l7qrFeJMVxI,
 phoenix/utilities/re.py,sha256=6YyUWIkv0zc2SigsxfOWIHzdpjKA_TZo2iqKq7zJKvw,2081
 phoenix/utilities/span_store.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 phoenix/utilities/template_formatters.py,sha256=gh9PJD6WEGw7TEYXfSst1UR4pWWwmjxMLrDVQ_CkpkQ,2779
-arize_phoenix-11.33.0.dist-info/METADATA,sha256=3u7AfNj8jQE1YYnMYyxGZUEuhqO5B-eDJ1PU04hebFw,32877
-arize_phoenix-11.33.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-arize_phoenix-11.33.0.dist-info/entry_points.txt,sha256=Pgpn8Upxx9P8z8joPXZWl2LlnAlGc3gcQoVchb06X1Q,94
-arize_phoenix-11.33.0.dist-info/licenses/IP_NOTICE,sha256=JBqyyCYYxGDfzQ0TtsQgjts41IJoa-hiwDrBjCb9gHM,469
-arize_phoenix-11.33.0.dist-info/licenses/LICENSE,sha256=HFkW9REuMOkvKRACuwLPT0hRydHb3zNg-fdFt94td18,3794
-arize_phoenix-11.33.0.dist-info/RECORD,,
+arize_phoenix-11.34.0.dist-info/METADATA,sha256=Gz2R_IDvu10Q5Ek_NSzZjyWxitfXO8VYnIgUxxxvOQ0,32877
+arize_phoenix-11.34.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+arize_phoenix-11.34.0.dist-info/entry_points.txt,sha256=Pgpn8Upxx9P8z8joPXZWl2LlnAlGc3gcQoVchb06X1Q,94
+arize_phoenix-11.34.0.dist-info/licenses/IP_NOTICE,sha256=JBqyyCYYxGDfzQ0TtsQgjts41IJoa-hiwDrBjCb9gHM,469
+arize_phoenix-11.34.0.dist-info/licenses/LICENSE,sha256=HFkW9REuMOkvKRACuwLPT0hRydHb3zNg-fdFt94td18,3794
+arize_phoenix-11.34.0.dist-info/RECORD,,

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.

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:

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}

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(

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,