arize-phoenix 8.1.0__py3-none-any.whl → 8.2.1__py3-none-any.whl

phoenix/server/api/types/Trace.py

@@ -6,10 +6,10 @@ from typing import TYPE_CHECKING, Annotated, Optional, Union
 import strawberry
 from openinference.semconv.trace import SpanAttributes
 from sqlalchemy import desc, select
-from sqlalchemy.orm import contains_eager
 from strawberry import UNSET, Private, lazy
 from strawberry.relay import Connection, GlobalID, Node, NodeID
 from strawberry.types import Info
+from typing_extensions import TypeAlias
 
 from phoenix.db import models
 from phoenix.server.api.context import Context
@@ -20,17 +20,20 @@ from phoenix.server.api.types.pagination import (
     connection_from_list,
 )
 from phoenix.server.api.types.SortDir import SortDir
-from phoenix.server.api.types.Span import Span, to_gql_span
+from phoenix.server.api.types.Span import Span
 from phoenix.server.api.types.TraceAnnotation import TraceAnnotation, to_gql_trace_annotation
 
 if TYPE_CHECKING:
     from phoenix.server.api.types.ProjectSession import ProjectSession
 
+ProjectRowId: TypeAlias = int
+TraceRowId: TypeAlias = int
+
 
 @strawberry.type
 class Trace(Node):
-    id_attr: NodeID[int]
-    project_rowid: Private[int]
+    trace_rowid: NodeID[TraceRowId]
+    project_rowid: Private[ProjectRowId]
     project_session_rowid: Private[Optional[int]]
     trace_id: str
     start_time: datetime
@@ -45,7 +48,7 @@ class Trace(Node):
             latency = await session.scalar(
                 select(
                     models.Trace.latency_ms,
-                ).where(models.Trace.id == self.id_attr)
+                ).where(models.Trace.id == self.trace_rowid)
             )
         return latency
 
@@ -84,10 +87,10 @@ class Trace(Node):
         self,
         info: Info[Context, None],
     ) -> Optional[Span]:
-        span = await info.context.data_loaders.trace_root_spans.load(self.id_attr)
-        if span is None:
+        span_rowid = await info.context.data_loaders.trace_root_spans.load(self.trace_rowid)
+        if span_rowid is None:
             return None
-        return to_gql_span(span)
+        return Span(span_rowid=span_rowid)
 
     @strawberry.field
     async def spans(
@@ -105,18 +108,17 @@ class Trace(Node):
             before=before if isinstance(before, CursorString) else None,
         )
         stmt = (
-            select(models.Span)
+            select(models.Span.id)
             .join(models.Trace)
-            .where(models.Trace.id == self.id_attr)
-            .options(contains_eager(models.Span.trace).load_only(models.Trace.trace_id))
+            .where(models.Trace.id == self.trace_rowid)
             # Sort descending because the root span tends to show up later
             # in the ingestion process.
             .order_by(desc(models.Span.id))
             .limit(first)
         )
         async with info.context.db() as session:
-            spans = await session.stream_scalars(stmt)
-            data = [to_gql_span(span) async for span in spans]
+            span_rowids = await session.stream_scalars(stmt)
+            data = [Span(span_rowid=span_rowid) async for span_rowid in span_rowids]
         return connection_from_list(data=data, args=args)
 
     @strawberry.field(description="Annotations associated with the trace.")  # type: ignore
@@ -126,7 +128,7 @@ class Trace(Node):
         sort: Optional[TraceAnnotationSort] = None,
     ) -> list[TraceAnnotation]:
         async with info.context.db() as session:
-            stmt = select(models.TraceAnnotation).filter_by(span_rowid=self.id_attr)
+            stmt = select(models.TraceAnnotation).filter_by(span_rowid=self.trace_rowid)
             if sort:
                 sort_col = getattr(models.TraceAnnotation, sort.col.value)
                 if sort.dir is SortDir.desc:
@@ -141,7 +143,7 @@ class Trace(Node):
 
 def to_gql_trace(trace: models.Trace) -> Trace:
     return Trace(
-        id_attr=trace.id,
+        trace_rowid=trace.id,
         project_rowid=trace.project_rowid,
         project_session_rowid=trace.project_session_rowid,
         trace_id=trace.trace_id,

phoenix/server/app.py

@@ -94,8 +94,10 @@ from phoenix.server.api.dataloaders import (
     SessionTokenUsagesDataLoader,
     SessionTraceLatencyMsQuantileDataLoader,
     SpanAnnotationsDataLoader,
+    SpanByIdDataLoader,
     SpanDatasetExamplesDataLoader,
     SpanDescendantsDataLoader,
+    SpanFieldsDataLoader,
     SpanProjectsDataLoader,
     TokenCountDataLoader,
     TraceByTraceIdsDataLoader,
@@ -624,6 +626,8 @@ def create_graphql_router(
                 session_token_usages=SessionTokenUsagesDataLoader(db),
                 session_trace_latency_ms_quantile=SessionTraceLatencyMsQuantileDataLoader(db),
                 span_annotations=SpanAnnotationsDataLoader(db),
+                span_fields=SpanFieldsDataLoader(db),
+                span_by_id=SpanByIdDataLoader(db),
                 span_dataset_examples=SpanDatasetExamplesDataLoader(db),
                 span_descendants=SpanDescendantsDataLoader(db),
                 span_projects=SpanProjectsDataLoader(db),

phoenix/server/prometheus.py

@@ -1,5 +1,9 @@
+import os
+import sys
 import time
+from functools import lru_cache
 from threading import Thread
+from typing import Optional
 
 import psutil
 from prometheus_client import (
@@ -31,7 +35,6 @@ RAM_METRIC = Gauge(
 CPU_METRIC = Gauge(
     name="cpu_usage_percent",
     documentation="CPU usage percent",
-    labelnames=["core"],
 )
 BULK_LOADER_INSERTION_TIME = Summary(
     name="bulk_loader_insertion_time_seconds_summary",
@@ -101,11 +104,114 @@ def gather_system_data() -> None:
     while True:
         time.sleep(1)
 
-        ram = psutil.virtual_memory()
-        swap = psutil.swap_memory()
+        RAM_METRIC.labels(type="virtual").set(estimate_memory_usage_bytes())
+        RAM_METRIC.labels(type="swap").set(estimate_swap_usage_bytes())
+        if cpu_metric := estimate_cpu_usage_percent():
+            CPU_METRIC.set(cpu_metric)
 
-        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)
+def estimate_memory_usage_bytes() -> int:
+    # https://docs.docker.com/engine/containers/runmetrics/
+    # psutil reports host-level metrics, use cgroups if running on linux
+
+    if sys.platform == "linux":
+        cgroup_v1_file = "/sys/fs/cgroup/memory/memory.usage_in_bytes"
+        cgroup_v2_file = "/sys/fs/cgroup/memory.current"
+
+        if is_cgroup_v2():
+            try:
+                with open(cgroup_v2_file, "r") as f:
+                    return int(f.read().strip())
+            except Exception:
+                pass
+        else:
+            try:
+                with open(cgroup_v1_file, "r") as f:
+                    return int(f.read().strip())
+            except Exception:
+                pass
+    return psutil.virtual_memory().used
+
+
+def estimate_swap_usage_bytes() -> int:
+    if sys.platform == "linux":
+        # cgroup v2: swap usage file (if swap accounting is enabled).
+        cgroup_v2_swap_file = "/sys/fs/cgroup/memory.swap.current"
+        cgroup_v1_swap_file = "/sys/fs/cgroup/memory/memory.memsw.usage_in_bytes"
+
+        if is_cgroup_v2() and os.path.exists(cgroup_v2_swap_file):
+            try:
+                with open(cgroup_v2_swap_file, "r") as f:
+                    return int(f.read().strip())
+            except Exception:
+                pass
+        elif os.path.exists(cgroup_v1_swap_file):
+            try:
+                with open(cgroup_v1_swap_file, "r") as f:
+                    return int(f.read().strip())
+            except Exception:
+                pass
+    return psutil.swap_memory().used
+
+
+_previous_cpu_sample: dict[str, tuple[float, float]] = {}  # cache for previous cpu usage sample
+
+
+def estimate_cpu_usage_percent() -> Optional[float]:
+    # https://docs.docker.com/engine/containers/runmetrics/
+    # psutil reports host-level metrics, use cgroups if running on linux
+
+    current_time = time.time()
+
+    if sys.platform.startswith("linux"):
+        cgroup_v2_cpu_stat = "/sys/fs/cgroup/cpu.stat"
+        cgroup_v1_cpu_usage = "/sys/fs/cgroup/cpuacct/cpuacct.usage"
+        if is_cgroup_v2():
+            try:
+                with open(cgroup_v2_cpu_stat, "r") as f:
+                    lines = f.readlines()
+                stats = {}
+                for line in lines:
+                    parts = line.strip().split()
+                    if len(parts) == 2:
+                        stats[parts[0]] = float(parts[1])
+                if "usage_usec" in stats:
+                    usage = stats["usage_usec"]
+                    key = "cgroup_v2"
+                    if key in _previous_cpu_sample:
+                        prev_usage, prev_time = _previous_cpu_sample[key]
+                        delta_usage = usage - prev_usage  # in microseconds
+                        delta_time = current_time - prev_time
+                        _previous_cpu_sample[key] = (usage, current_time)
+                        if delta_time > 0:
+                            # Convert microseconds to seconds.
+                            return round((delta_usage / (delta_time * 1e6)) * 100, 2)
+                    else:
+                        _previous_cpu_sample[key] = (usage, current_time)
+                        return None  # No previous sample yet.
+            except Exception:
+                pass
+        else:
+            try:
+                with open(cgroup_v1_cpu_usage, "r") as f:
+                    usage = int(f.read().strip())
+                key = "cgroup_v1"
+                if key in _previous_cpu_sample:
+                    prev_usage, prev_time = _previous_cpu_sample[key]
+                    delta_usage = usage - prev_usage  # in nanoseconds
+                    delta_time = current_time - prev_time
+                    _previous_cpu_sample[key] = (usage, current_time)
+                    if delta_time > 0:
+                        # Convert nanoseconds to seconds.
+                        return round((delta_usage / (delta_time * 1e9)) * 100, 2)
+                else:
+                    _previous_cpu_sample[key] = (usage, current_time)
+                    return None  # No previous sample yet.
+            except Exception:
+                pass
+        return psutil.cpu_percent(interval=None)
+
+
+@lru_cache(maxsize=1)
+def is_cgroup_v2() -> bool:
+    return os.path.exists("/sys/fs/cgroup/cgroup.controllers")

phoenix/server/static/.vite/manifest.json

@@ -1,32 +1,32 @@
 {
-  "_components-B-qgPyHv.js": {
-    "file": "assets/components-B-qgPyHv.js",
+  "_components-CgcYOKnv.js": {
+    "file": "assets/components-CgcYOKnv.js",
     "name": "components",
     "imports": [
-      "_vendor-DQp7CrDA.js",
-      "_pages-DdcuL3Rh.js",
-      "_vendor-arizeai-C1nEIEQq.js",
-      "_vendor-codemirror-BZXYUIkP.js",
+      "_vendor-Cqfydjep.js",
+      "_pages-Cz-JsoAE.js",
+      "_vendor-arizeai-WnerlUPN.js",
+      "_vendor-codemirror-D-ZZKLFq.js",
       "_vendor-three-C-AGeJYv.js"
     ]
   },
-  "_pages-DdcuL3Rh.js": {
-    "file": "assets/pages-DdcuL3Rh.js",
+  "_pages-Cz-JsoAE.js": {
+    "file": "assets/pages-Cz-JsoAE.js",
     "name": "pages",
     "imports": [
-      "_vendor-DQp7CrDA.js",
-      "_vendor-arizeai-C1nEIEQq.js",
-      "_components-B-qgPyHv.js",
-      "_vendor-codemirror-BZXYUIkP.js",
-      "_vendor-recharts-BUFpwCVD.js"
+      "_vendor-Cqfydjep.js",
+      "_vendor-arizeai-WnerlUPN.js",
+      "_components-CgcYOKnv.js",
+      "_vendor-codemirror-D-ZZKLFq.js",
+      "_vendor-recharts-KY97ZPfK.js"
     ]
   },
   "_vendor-Cg6lcjUC.css": {
     "file": "assets/vendor-Cg6lcjUC.css",
     "src": "_vendor-Cg6lcjUC.css"
   },
-  "_vendor-DQp7CrDA.js": {
-    "file": "assets/vendor-DQp7CrDA.js",
+  "_vendor-Cqfydjep.js": {
+    "file": "assets/vendor-Cqfydjep.js",
     "name": "vendor",
     "imports": [
       "_vendor-three-C-AGeJYv.js"
@@ -35,33 +35,33 @@
       "assets/vendor-Cg6lcjUC.css"
     ]
   },
-  "_vendor-arizeai-C1nEIEQq.js": {
-    "file": "assets/vendor-arizeai-C1nEIEQq.js",
+  "_vendor-arizeai-WnerlUPN.js": {
+    "file": "assets/vendor-arizeai-WnerlUPN.js",
     "name": "vendor-arizeai",
     "imports": [
-      "_vendor-DQp7CrDA.js"
+      "_vendor-Cqfydjep.js"
     ]
   },
-  "_vendor-codemirror-BZXYUIkP.js": {
-    "file": "assets/vendor-codemirror-BZXYUIkP.js",
+  "_vendor-codemirror-D-ZZKLFq.js": {
+    "file": "assets/vendor-codemirror-D-ZZKLFq.js",
     "name": "vendor-codemirror",
     "imports": [
-      "_vendor-DQp7CrDA.js",
-      "_vendor-shiki-C8L-c9jT.js"
+      "_vendor-Cqfydjep.js",
+      "_vendor-shiki-D5K9GnFn.js"
     ]
   },
-  "_vendor-recharts-BUFpwCVD.js": {
-    "file": "assets/vendor-recharts-BUFpwCVD.js",
+  "_vendor-recharts-KY97ZPfK.js": {
+    "file": "assets/vendor-recharts-KY97ZPfK.js",
     "name": "vendor-recharts",
     "imports": [
-      "_vendor-DQp7CrDA.js"
+      "_vendor-Cqfydjep.js"
     ]
   },
-  "_vendor-shiki-C8L-c9jT.js": {
-    "file": "assets/vendor-shiki-C8L-c9jT.js",
+  "_vendor-shiki-D5K9GnFn.js": {
+    "file": "assets/vendor-shiki-D5K9GnFn.js",
     "name": "vendor-shiki",
     "imports": [
-      "_vendor-DQp7CrDA.js"
+      "_vendor-Cqfydjep.js"
     ]
   },
   "_vendor-three-C-AGeJYv.js": {
@@ -69,19 +69,19 @@
     "name": "vendor-three"
   },
   "index.tsx": {
-    "file": "assets/index-D4KO1IcF.js",
+    "file": "assets/index-B_Nkd6Rh.js",
     "name": "index",
     "src": "index.tsx",
     "isEntry": true,
     "imports": [
-      "_vendor-DQp7CrDA.js",
-      "_vendor-arizeai-C1nEIEQq.js",
-      "_pages-DdcuL3Rh.js",
-      "_components-B-qgPyHv.js",
+      "_vendor-Cqfydjep.js",
+      "_vendor-arizeai-WnerlUPN.js",
+      "_pages-Cz-JsoAE.js",
+      "_components-CgcYOKnv.js",
       "_vendor-three-C-AGeJYv.js",
-      "_vendor-codemirror-BZXYUIkP.js",
-      "_vendor-shiki-C8L-c9jT.js",
-      "_vendor-recharts-BUFpwCVD.js"
+      "_vendor-codemirror-D-ZZKLFq.js",
+      "_vendor-shiki-D5K9GnFn.js",
+      "_vendor-recharts-KY97ZPfK.js"
     ]
   }
 }