arize-phoenix 3.16.1__tar.gz → 3.16.3__tar.gz

{arize_phoenix-3.16.1 → arize_phoenix-3.16.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: arize-phoenix
-Version: 3.16.1
+Version: 3.16.3
 Summary: AI Observability and Evaluation
 Project-URL: Documentation, https://docs.arize.com/phoenix/
 Project-URL: Issues, https://github.com/Arize-ai/phoenix/issues
@@ -17,7 +17,6 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Python: <3.13,>=3.8
-Requires-Dist: ddsketch
 Requires-Dist: hdbscan>=0.8.33
 Requires-Dist: jinja2
 Requires-Dist: numpy
@@ -44,6 +43,8 @@ Requires-Dist: typing-extensions>=4.6; python_version >= '3.12'
 Requires-Dist: umap-learn
 Requires-Dist: uvicorn
 Requires-Dist: wrapt
+Provides-Extra: container
+Requires-Dist: prometheus-client; extra == 'container'
 Provides-Extra: dev
 Requires-Dist: anthropic; extra == 'dev'
 Requires-Dist: arize[autoembeddings,llm-evaluation]; extra == 'dev'
@@ -57,6 +58,7 @@ Requires-Dist: llama-index>=0.10.3; extra == 'dev'
 Requires-Dist: nbqa; extra == 'dev'
 Requires-Dist: pandas-stubs<=2.0.2.230605; extra == 'dev'
 Requires-Dist: pre-commit; extra == 'dev'
+Requires-Dist: prometheus-client; extra == 'dev'
 Requires-Dist: pytest-asyncio; extra == 'dev'
 Requires-Dist: pytest-cov; extra == 'dev'
 Requires-Dist: pytest-lazy-fixture; extra == 'dev'

{arize_phoenix-3.16.1 → arize_phoenix-3.16.3}/pyproject.toml

@@ -40,7 +40,6 @@ dependencies = [
   "wrapt",
   "sortedcontainers",
   "protobuf>=3.20, <5.0",
-  "ddsketch",
   "tqdm",
   "requests",
   "opentelemetry-sdk",
@@ -73,6 +72,7 @@ dev = [
   "litellm>=1.0.3",
   "google-cloud-aiplatform>=1.3",
   "anthropic",
+  "prometheus_client",
 ]
 evals = [
   "arize-phoenix-evals>=0.3.0",
@@ -85,6 +85,9 @@ llama-index = [
   "llama-index-callbacks-arize-phoenix>=0.1.2",
   "openinference-instrumentation-llama-index>=1.2.0",
 ]
+container = [
+  "prometheus-client",
+]
 
 [project.urls]
 Documentation = "https://docs.arize.com/phoenix/"
@@ -145,6 +148,7 @@ dependencies = [
   "types-setuptools",
   "openai>=1.0.0",
   "litellm>=1.0.3",
+  "prometheus_client",
 ]
 
 [tool.hatch.envs.style]

{arize_phoenix-3.16.1 → arize_phoenix-3.16.3}/src/phoenix/core/project.py

@@ -20,7 +20,6 @@ from typing import (
 )
 
 import numpy as np
-from ddsketch import DDSketch
 from google.protobuf.json_format import MessageToDict
 from openinference.semconv.trace import SpanAttributes
 from pandas import DataFrame, Index, MultiIndex
@@ -216,10 +215,15 @@ class _Spans:
         self._start_time_sorted_root_spans: SortedKeyList[WrappedSpan] = SortedKeyList(
             key=lambda span: span.start_time,
         )
+        """
+        A root span is defined to be a span whose parent span is not in our collection.
+        This includes spans whose parent is None and spans whose parent has not arrived
+        (or will not arrive). For spans whose parent is not None, the root span status
+        is temporary and will be revoked when its parent span arrives.
+        """
         self._latency_sorted_root_spans: SortedKeyList[WrappedSpan] = SortedKeyList(
             key=lambda span: span[ComputedAttributes.LATENCY_MS],
         )
-        self._root_span_latency_ms_sketch = DDSketch()
         self._token_count_total: int = 0
         self._last_updated_at: Optional[datetime] = None
 
@@ -285,7 +289,15 @@ class _Spans:
     def root_span_latency_ms_quantiles(self, probability: float) -> Optional[float]:
         """Root span latency quantiles in milliseconds"""
         with self._lock:
-            return self._root_span_latency_ms_sketch.get_quantile_value(probability)
+            spans = self._latency_sorted_root_spans
+            if not (n := len(spans)):
+                return None
+            if probability >= 1:
+                return cast(float, spans[-1][ComputedAttributes.LATENCY_MS])
+            if probability <= 0:
+                return cast(float, spans[0][ComputedAttributes.LATENCY_MS])
+            k = max(0, round(n * probability) - 1)
+            return cast(float, spans[k][ComputedAttributes.LATENCY_MS])
 
     def get_descendant_spans(self, span_id: SpanID) -> Iterator[WrappedSpan]:
         for span in self._get_descendant_spans(span_id):
@@ -353,26 +365,27 @@ class _Spans:
             return
 
         parent_span_id = span.parent_id
-        is_root_span = parent_span_id is None
-        if not is_root_span:
+        if parent_span_id is not None:
             self._child_spans[parent_span_id].add(span)
             self._parent_span_ids[span_id] = parent_span_id
 
+        for child_span in self._child_spans.get(span_id, ()):
+            # A root span is a span whose parent span is not in our collection.
+            # Now that their parent span has arrived, they are no longer root spans.
+            self._start_time_sorted_root_spans.remove(child_span)
+            self._latency_sorted_root_spans.remove(child_span)
+
         # Add computed attributes to span
         start_time = span.start_time
         end_time = span.end_time
-        span[ComputedAttributes.LATENCY_MS] = latency = (
-            end_time - start_time
-        ).total_seconds() * 1000
-        if is_root_span:
-            self._root_span_latency_ms_sketch.add(latency)
+        span[ComputedAttributes.LATENCY_MS] = (end_time - start_time).total_seconds() * 1000
         span[ComputedAttributes.ERROR_COUNT] = int(span.status_code is SpanStatusCode.ERROR)
 
         # Store the new span (after adding computed attributes)
         self._spans[span_id] = span
         self._traces[span.context.trace_id].add(span)
         self._start_time_sorted_spans.add(span)
-        if is_root_span:
+        if parent_span_id is None or parent_span_id not in self._spans:
             self._start_time_sorted_root_spans.add(span)
             self._latency_sorted_root_spans.add(span)
         self._propagate_cumulative_values(span)

{arize_phoenix-3.16.1 → arize_phoenix-3.16.3}/src/phoenix/server/api/routers/evaluation_handler.py

@@ -29,7 +29,7 @@ class EvaluationHandler(HTTPEndpoint):
         content_type = request.headers.get("content-type")
         project_name = request.headers.get("project-name", DEFAULT_PROJECT_NAME)
         if content_type == "application/x-pandas-arrow":
-            return await self._process_pyarrow(request)
+            return await self._process_pyarrow(request, project_name)
         if content_type != "application/x-protobuf":
             return Response(
                 content="Unsupported content type",
@@ -81,7 +81,7 @@ class EvaluationHandler(HTTPEndpoint):
             media_type="application/x-pandas-arrow",
         )
 
-    async def _process_pyarrow(self, request: Request) -> Response:
+    async def _process_pyarrow(self, request: Request, project_name: str) -> Response:
         body = await request.body()
         try:
             reader = pa.ipc.open_stream(body)
@@ -101,9 +101,10 @@ class EvaluationHandler(HTTPEndpoint):
             background=BackgroundTask(
                 self._add_evaluations,
                 evaluations,
+                project_name,
             )
         )
 
-    async def _add_evaluations(self, evaluations: Evaluations) -> None:
+    async def _add_evaluations(self, evaluations: Evaluations, project_name: str) -> None:
         for evaluation in encode_evaluations(evaluations):
-            self.traces.put(evaluation)
+            self.traces.put(evaluation, project_name=project_name)

{arize_phoenix-3.16.1 → arize_phoenix-3.16.3}/src/phoenix/server/api/types/Span.py

@@ -11,7 +11,6 @@ from strawberry import ID, UNSET
 from strawberry.types import Info
 
 import phoenix.trace.schemas as trace_schema
-from phoenix.config import DEFAULT_PROJECT_NAME
 from phoenix.core.project import Project, WrappedSpan
 from phoenix.metrics.retrieval_metrics import RetrievalMetrics
 from phoenix.server.api.context import Context
@@ -144,18 +143,11 @@ class Span:
         "an LLM, an evaluation may assess the helpfulness of its response with "
         "respect to its input."
     )  # type: ignore
-    def span_evaluations(
-        self,
-        info: Info[Context, None],
-    ) -> List[SpanEvaluation]:
-        if not (traces := info.context.traces) or not (
-            project := traces.get_project(DEFAULT_PROJECT_NAME)
-        ):
-            return []
+    def span_evaluations(self) -> List[SpanEvaluation]:
         span_id = SpanID(str(self.context.span_id))
         return [
             SpanEvaluation.from_pb_evaluation(evaluation)
-            for evaluation in project.get_evaluations_by_span_id(span_id)
+            for evaluation in self.project.get_evaluations_by_span_id(span_id)
         ]
 
     @strawberry.field(
@@ -166,18 +158,11 @@ class Span:
         "a list, and each evaluation is identified by its document's (zero-based) "
         "index in that list."
     )  # type: ignore
-    def document_evaluations(
-        self,
-        info: Info[Context, None],
-    ) -> List[DocumentEvaluation]:
-        if not (traces := info.context.traces) or not (
-            project := traces.get_project(DEFAULT_PROJECT_NAME)
-        ):
-            return []
+    def document_evaluations(self) -> List[DocumentEvaluation]:
         span_id = SpanID(str(self.context.span_id))
         return [
             DocumentEvaluation.from_pb_evaluation(evaluation)
-            for evaluation in project.get_document_evaluations_by_span_id(span_id)
+            for evaluation in self.project.get_document_evaluations_by_span_id(span_id)
         ]
 
     @strawberry.field(
@@ -185,7 +170,6 @@ class Span:
     )  # type: ignore
     def document_retrieval_metrics(
         self,
-        info: Info[Context, None],
         evaluation_name: Optional[str] = UNSET,
     ) -> List[DocumentRetrievalMetrics]:
         if not self.num_documents:

{arize_phoenix-3.16.1 → arize_phoenix-3.16.3}/src/phoenix/server/app.py

@@ -151,6 +151,7 @@ def create_app(
     span_store: Optional[SpanStore] = None,
     debug: bool = False,
     read_only: bool = False,
+    enable_prometheus: bool = False,
 ) -> Starlette:
     graphql = GraphQLWithContext(
         schema=schema,
@@ -160,9 +161,16 @@ def create_app(
         export_path=export_path,
         graphiql=True,
     )
+    if enable_prometheus:
+        from phoenix.server.prometheus import PrometheusMiddleware
+
+        prometheus_middlewares = [Middleware(PrometheusMiddleware)]
+    else:
+        prometheus_middlewares = []
     return Starlette(
         middleware=[
             Middleware(HeadersMiddleware),
+            *prometheus_middlewares,
         ],
         debug=debug,
         routes=(

{arize_phoenix-3.16.1 → arize_phoenix-3.16.3}/src/phoenix/server/main.py

@@ -129,6 +129,7 @@ if __name__ == "__main__":
     parser.add_argument("--no-internet", action="store_true")
     parser.add_argument("--umap_params", type=str, required=False, default=DEFAULT_UMAP_PARAMS_STR)
     parser.add_argument("--debug", action="store_false")
+    parser.add_argument("--enable-prometheus", type=bool, default=False)
     subparsers = parser.add_subparsers(dest="command", required=True)
     serve_parser = subparsers.add_parser("serve")
     datasets_parser = subparsers.add_parser("datasets")
@@ -223,6 +224,10 @@ if __name__ == "__main__":
     )
     read_only = args.read_only
     logger.info(f"Server umap params: {umap_params}")
+    if enable_prometheus := args.enable_prometheus:
+        from phoenix.server.prometheus import start_prometheus
+
+        start_prometheus()
     app = create_app(
         export_path=export_path,
         model=model,
@@ -232,6 +237,7 @@ if __name__ == "__main__":
         debug=args.debug,
         read_only=read_only,
         span_store=span_store,
+        enable_prometheus=enable_prometheus,
     )
     host = args.host or get_env_host()
     port = args.port or get_env_port()

arize_phoenix-3.16.3/src/phoenix/server/prometheus.py

@@ -0,0 +1,75 @@
+import time
+from threading import Thread
+
+import psutil
+from prometheus_client import (
+    Counter,
+    Gauge,
+    Histogram,
+    start_http_server,
+)
+from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoint
+from starlette.requests import Request
+from starlette.responses import Response
+from starlette.routing import Match
+
+REQUESTS_PROCESSING_TIME = Histogram(
+    name="starlette_requests_processing_time_seconds",
+    documentation="Histogram of requests processing time by method and path (in seconds)",
+    labelnames=["method", "path"],
+)
+EXCEPTIONS = Counter(
+    name="starlette_exceptions_total",
+    documentation="Total count of exceptions raised by method, path and exception type",
+    labelnames=["method", "path", "exception_type"],
+)
+RAM_METRIC = Gauge(
+    name="memory_usage_bytes",
+    documentation="Memory usage in bytes",
+    labelnames=["type"],
+)
+CPU_METRIC = Gauge(
+    name="cpu_usage_percent",
+    documentation="CPU usage percent",
+    labelnames=["core"],
+)
+
+
+class PrometheusMiddleware(BaseHTTPMiddleware):
+    async def dispatch(self, request: Request, call_next: RequestResponseEndpoint) -> Response:
+        for route in request.app.routes:
+            match, _ = route.matches(request.scope)
+            if match is Match.FULL:
+                path = route.path
+                break
+        else:
+            return await call_next(request)
+        method = request.method
+        start_time = time.perf_counter()
+        try:
+            response = await call_next(request)
+        except BaseException as e:
+            EXCEPTIONS.labels(method=method, path=path, exception_type=type(e).__name__).inc()
+            raise
+        stop_time = time.perf_counter()
+        REQUESTS_PROCESSING_TIME.labels(method=method, path=path).observe(stop_time - start_time)
+        return response
+
+
+def start_prometheus() -> None:
+    Thread(target=gather_system_data, daemon=True).start()
+    start_http_server(9090)
+
+
+def gather_system_data() -> None:
+    while True:
+        time.sleep(1)
+
+        ram = psutil.virtual_memory()
+        swap = psutil.swap_memory()
+
+        RAM_METRIC.labels(type="virtual").set(ram.used)
+        RAM_METRIC.labels(type="swap").set(swap.used)
+
+        for core, percent in enumerate(psutil.cpu_percent(interval=1, percpu=True)):
+            CPU_METRIC.labels(core=core).set(percent)