arize-phoenix 10.5.0__tar.gz → 10.6.1__tar.gz

{arize_phoenix-10.5.0 → arize_phoenix-10.6.1}/.gitignore

@@ -32,6 +32,8 @@ pyrightconfig.json
 !/packages/phoenix-client/tests/canary/sdk/pyrightconfig.json
 !/tests/integration/pyrightconfig.json
 
+.cursorrules
+
 # Demo data
 tutorials/internal/demo_llama_index/*.json
 examples/agent_framework_comparison/utils/saved_traces/*.parquet

{arize_phoenix-10.5.0 → arize_phoenix-10.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arize-phoenix
-Version: 10.5.0
+Version: 10.6.1
 Summary: AI Observability and Evaluation
 Project-URL: Documentation, https://arize.com/docs/phoenix/
 Project-URL: Issues, https://github.com/Arize-ai/phoenix/issues
@@ -32,8 +32,8 @@ Requires-Dist: grpcio
 Requires-Dist: httpx
 Requires-Dist: jinja2
 Requires-Dist: numpy!=2.0.0
-Requires-Dist: openinference-instrumentation>=0.1.12
-Requires-Dist: openinference-semantic-conventions>=0.1.12
+Requires-Dist: openinference-instrumentation>=0.1.32
+Requires-Dist: openinference-semantic-conventions>=0.1.17
 Requires-Dist: opentelemetry-exporter-otlp
 Requires-Dist: opentelemetry-proto>=1.12.0
 Requires-Dist: opentelemetry-sdk

{arize_phoenix-10.5.0 → arize_phoenix-10.6.1}/pyproject.toml

@@ -43,8 +43,8 @@ dependencies = [
   "opentelemetry-proto>=1.12.0",  # needed to avoid this issue: https://github.com/Arize-ai/phoenix/issues/2695
   "opentelemetry-exporter-otlp",
   "opentelemetry-semantic-conventions",
-  "openinference-semantic-conventions>=0.1.12",
-  "openinference-instrumentation>=0.1.12",
+  "openinference-semantic-conventions>=0.1.17",
+  "openinference-instrumentation>=0.1.32",
   "sqlalchemy[asyncio]>=2.0.4, <3",
   "alembic>=1.3.0, <2",
   "aiosqlite",

{arize_phoenix-10.5.0 → arize_phoenix-10.6.1}/src/phoenix/server/api/routers/v1/annotations.py

@@ -62,6 +62,17 @@ async def list_span_annotations(
     span_ids: list[str] = Query(
         ..., min_length=1, description="One or more span id to fetch annotations for"
     ),
+    include_annotation_names: Optional[list[str]] = Query(
+        default=None,
+        description=(
+            "Optional list of annotation names to include. If provided, only annotations with "
+            "these names will be returned. 'note' annotations are excluded by default unless "
+            "explicitly included in this list."
+        ),
+    ),
+    exclude_annotation_names: Optional[list[str]] = Query(
+        default=None, description="Optional list of annotation names to exclude from results."
+    ),
     cursor: Optional[str] = Query(default=None, description="A cursor for pagination"),
     limit: int = Query(
         default=10,
@@ -84,15 +95,26 @@ async def list_span_annotations(
                 status_code=HTTP_404_NOT_FOUND,
                 detail=f"Project with identifier {project_identifier} not found",
             )
+
+        # Build the base query
+        where_conditions = [
+            models.Project.id == project.id,
+            models.Span.span_id.in_(span_ids),
+        ]
+
+        # Add annotation name filtering
+        if include_annotation_names:
+            where_conditions.append(models.SpanAnnotation.name.in_(include_annotation_names))
+
+        if exclude_annotation_names:
+            where_conditions.append(models.SpanAnnotation.name.not_in(exclude_annotation_names))
+
         stmt = (
             select(models.Span.span_id, models.SpanAnnotation)
             .join(models.Trace, models.Span.trace_rowid == models.Trace.id)
             .join(models.Project, models.Trace.project_rowid == models.Project.id)
             .join(models.SpanAnnotation, models.SpanAnnotation.span_rowid == models.Span.id)
-            .where(
-                models.Project.id == project.id,
-                models.Span.span_id.in_(span_ids),
-            )
+            .where(*where_conditions)
             .order_by(models.SpanAnnotation.id.desc())
             .limit(limit + 1)
         )

{arize_phoenix-10.5.0 → arize_phoenix-10.6.1}/src/phoenix/server/api/routers/v1/spans.py

@@ -370,12 +370,48 @@ class OtlpSpan(BaseModel):
     )
 
 
-class SpanSearchResponseBody(PaginatedResponseBody[OtlpSpan]):
+class OtlpSpansResponseBody(PaginatedResponseBody[OtlpSpan]):
     """Paginated response where each span follows OTLP JSON structure."""
 
     pass
 
 
+################################################################################
+# Phoenix Span Models
+################################################################################
+
+
+class SpanContext(V1RoutesBaseModel):
+    trace_id: str = Field(description="OpenTelemetry trace ID")
+    span_id: str = Field(description="OpenTelemetry span ID")
+
+
+class SpanEvent(V1RoutesBaseModel):
+    name: str = Field(description="Name of the event")
+    timestamp: datetime = Field(description="When the event occurred")
+    attributes: dict[str, Any] = Field(default_factory=dict, description="Event attributes")
+
+
+class Span(V1RoutesBaseModel):
+    id: str = Field(description="Span Global ID, distinct from the OpenTelemetry span ID")
+    name: str = Field(description="Name of the span operation")
+    context: SpanContext = Field(description="Span context containing trace_id and span_id")
+    span_kind: str = Field(description="Type of work that the span encapsulates")
+    parent_id: Optional[str] = Field(
+        default=None, description="OpenTelemetry span ID of the parent span"
+    )
+    start_time: datetime = Field(description="Start time of the span")
+    end_time: datetime = Field(description="End time of the span")
+    status_code: str = Field(description="Status code of the span")
+    status_message: str = Field(default="", description="Status message")
+    attributes: dict[str, Any] = Field(default_factory=dict, description="Span attributes")
+    events: list[SpanEvent] = Field(default_factory=list, description="Span events")
+
+
+class SpansResponseBody(PaginatedResponseBody[Span]):
+    pass
+
+
 # TODO: Add property details to SpanQuery schema
 @router.post(
     "/spans",
@@ -513,11 +549,11 @@ def _to_any_value(value: Any) -> OtlpAnyValue:
     "/projects/{project_identifier}/spans/otlpv1",
     operation_id="spanSearch",
     summary="Search spans with simple filters (no DSL)",
-    description="Return spans within a project filtered by time range, annotation names, "
-    "and ordered by start_time. Supports cursor-based pagination.",
+    description="Return spans within a project filtered by time range. "
+    "Supports cursor-based pagination.",
     responses=add_errors_to_responses([HTTP_404_NOT_FOUND, HTTP_422_UNPROCESSABLE_ENTITY]),
 )
-async def span_search(
+async def span_search_otlpv1(
     request: Request,
     project_identifier: str = Path(
         description=(
@@ -525,30 +561,18 @@ async def span_search(
             "it cannot contain slash (/), question mark (?), or pound sign (#) characters."
         )
     ),
-    cursor: Optional[str] = Query(default=None, description="Pagination cursor (GlobalID of Span)"),
+    cursor: Optional[str] = Query(default=None, description="Pagination cursor (Span Global ID)"),
     limit: int = Query(default=100, gt=0, le=1000, description="Maximum number of spans to return"),
-    sort_direction: Literal["asc", "desc"] = Query(
-        default="desc",
-        description="Sort direction for the sort field",
-    ),
     start_time: Optional[datetime] = Query(default=None, description="Inclusive lower bound time"),
     end_time: Optional[datetime] = Query(default=None, description="Exclusive upper bound time"),
-    annotation_names: Optional[list[str]] = Query(
-        default=None,
-        description=(
-            "If provided, only include spans that have at least one annotation with one "
-            "of these names."
-        ),
-        alias="annotationNames",
-    ),
-) -> SpanSearchResponseBody:
+) -> OtlpSpansResponseBody:
     """Search spans with minimal filters instead of the old SpanQuery DSL."""
 
     async with request.app.state.db() as session:
         project = await _get_project_by_identifier(session, project_identifier)
 
     project_id: int = project.id
-    order_by = [models.Span.id.asc() if sort_direction == "asc" else models.Span.id.desc()]
+    order_by = [models.Span.id.desc()]
 
     stmt = (
         select(
@@ -565,23 +589,10 @@ async def span_search(
     if end_time:
         stmt = stmt.where(models.Span.start_time < normalize_datetime(end_time, timezone.utc))
 
-    if annotation_names:
-        stmt = (
-            stmt.join(
-                models.SpanAnnotation,
-                onclause=models.SpanAnnotation.span_rowid == models.Span.id,
-            )
-            .where(models.SpanAnnotation.name.in_(annotation_names))
-            .group_by(models.Span.id, models.Trace.trace_id)
-        )
-
     if cursor:
         try:
             cursor_rowid = int(GlobalID.from_id(cursor).node_id)
-            if sort_direction == "asc":
-                stmt = stmt.where(models.Span.id >= cursor_rowid)
-            else:
-                stmt = stmt.where(models.Span.id <= cursor_rowid)
+            stmt = stmt.where(models.Span.id <= cursor_rowid)
         except Exception:
             raise HTTPException(status_code=HTTP_422_UNPROCESSABLE_ENTITY, detail="Invalid cursor")
 
@@ -591,7 +602,7 @@ async def span_search(
         rows: list[tuple[models.Span, str]] = [r async for r in await session.stream(stmt)]
 
     if not rows:
-        return SpanSearchResponseBody(next_cursor=None, data=[])
+        return OtlpSpansResponseBody(next_cursor=None, data=[])
 
     next_cursor: Optional[str] = None
     if len(rows) == limit + 1:
@@ -668,7 +679,141 @@ async def span_search(
             )
         )
 
-    return SpanSearchResponseBody(next_cursor=next_cursor, data=result_spans)
+    return OtlpSpansResponseBody(next_cursor=next_cursor, data=result_spans)
+
+
+@router.get(
+    "/projects/{project_identifier}/spans",
+    operation_id="getSpans",
+    summary="List spans with simple filters (no DSL)",
+    description="Return spans within a project filtered by time range. "
+    "Supports cursor-based pagination.",
+    responses=add_errors_to_responses([HTTP_404_NOT_FOUND, HTTP_422_UNPROCESSABLE_ENTITY]),
+)
+async def span_search(
+    request: Request,
+    project_identifier: str = Path(
+        description=(
+            "The project identifier: either project ID or project name. If using a project name, "
+            "it cannot contain slash (/), question mark (?), or pound sign (#) characters."
+        )
+    ),
+    cursor: Optional[str] = Query(default=None, description="Pagination cursor (Span Global ID)"),
+    limit: int = Query(default=100, gt=0, le=1000, description="Maximum number of spans to return"),
+    start_time: Optional[datetime] = Query(default=None, description="Inclusive lower bound time"),
+    end_time: Optional[datetime] = Query(default=None, description="Exclusive upper bound time"),
+) -> SpansResponseBody:
+    async with request.app.state.db() as session:
+        project = await _get_project_by_identifier(session, project_identifier)
+
+    project_id: int = project.id
+    order_by = [models.Span.id.desc()]
+
+    stmt = (
+        select(
+            models.Span,
+            models.Trace.trace_id,
+        )
+        .join(models.Trace, onclause=models.Trace.id == models.Span.trace_rowid)
+        .join(models.Project, onclause=models.Project.id == project_id)
+        .order_by(*order_by)
+    )
+
+    if start_time:
+        stmt = stmt.where(models.Span.start_time >= normalize_datetime(start_time, timezone.utc))
+    if end_time:
+        stmt = stmt.where(models.Span.start_time < normalize_datetime(end_time, timezone.utc))
+
+    if cursor:
+        try:
+            cursor_rowid = int(GlobalID.from_id(cursor).node_id)
+        except Exception:
+            raise HTTPException(status_code=HTTP_422_UNPROCESSABLE_ENTITY, detail="Invalid cursor")
+        stmt = stmt.where(models.Span.id <= cursor_rowid)
+
+    stmt = stmt.limit(limit + 1)
+
+    async with request.app.state.db() as session:
+        rows: list[tuple[models.Span, str]] = [r async for r in await session.stream(stmt)]
+
+    if not rows:
+        return SpansResponseBody(next_cursor=None, data=[])
+
+    next_cursor: Optional[str] = None
+    if len(rows) == limit + 1:
+        *rows, extra = rows  # extra is first item of next page
+        span_extra, _ = extra
+        next_cursor = str(GlobalID("Span", str(span_extra.id)))
+
+    # Convert ORM rows -> Phoenix spans
+    result_spans: list[Span] = []
+    for span_orm, trace_id in rows:
+        # Convert events to Phoenix Event list
+        events: list[SpanEvent] = []
+        for event in span_orm.events:
+            event_time = event.get("timestamp")
+            parsed_time = None
+
+            if event_time:
+                if isinstance(event_time, datetime):
+                    parsed_time = normalize_datetime(event_time, timezone.utc)
+                elif isinstance(event_time, str):
+                    try:
+                        naive_time = datetime.fromisoformat(event_time)
+                        parsed_time = normalize_datetime(naive_time, timezone.utc)
+                    except ValueError:
+                        # If ISO format fails, try to parse as timestamp
+                        try:
+                            parsed_time = datetime.fromtimestamp(float(event_time), tz=timezone.utc)
+                        except (ValueError, TypeError):
+                            parsed_time = datetime.now(timezone.utc)  # fallback
+                elif isinstance(event_time, (int, float)):
+                    try:
+                        # Assume nanoseconds if very large, otherwise seconds
+                        if event_time > 1e12:  # nanoseconds
+                            parsed_time = datetime.fromtimestamp(
+                                event_time / 1_000_000_000, tz=timezone.utc
+                            )
+                        else:  # seconds
+                            parsed_time = datetime.fromtimestamp(event_time, tz=timezone.utc)
+                    except (ValueError, OSError):
+                        parsed_time = datetime.now(timezone.utc)  # fallback
+            else:
+                parsed_time = datetime.now(timezone.utc)  # fallback
+
+            events.append(
+                SpanEvent(
+                    name=event.get("name", ""),
+                    timestamp=parsed_time,
+                    attributes=event.get("attributes", {}),
+                )
+            )
+
+        attributes = {
+            k: v for k, v in flatten(span_orm.attributes or dict(), recurse_on_sequence=True)
+        }
+        openinference_span_kind = attributes.pop("openinference.span.kind", "UNKNOWN")
+
+        result_spans.append(
+            Span(
+                id=str(GlobalID("Span", str(span_orm.id))),
+                name=span_orm.name or "",
+                context=SpanContext(
+                    trace_id=trace_id,
+                    span_id=span_orm.span_id or "",
+                ),
+                span_kind=openinference_span_kind,
+                parent_id=span_orm.parent_id,
+                start_time=span_orm.start_time,
+                end_time=span_orm.end_time,
+                status_code=span_orm.status_code,
+                status_message=span_orm.status_message or "",
+                attributes=attributes,
+                events=events,
+            )
+        )
+
+    return SpansResponseBody(next_cursor=next_cursor, data=result_spans)
 
 
 @router.get("/spans", include_in_schema=False, deprecated=True)

arize_phoenix-10.6.1/src/phoenix/server/static/.vite/manifest.json

@@ -0,0 +1,87 @@
+{
+  "_components-J06J_j9O.js": {
+    "file": "assets/components-J06J_j9O.js",
+    "name": "components",
+    "imports": [
+      "_vendor-B52WHALA.js",
+      "_pages-nxs-tDxQ.js",
+      "_vendor-arizeai-DGHetzZW.js",
+      "_vendor-codemirror-QIdVJrP_.js",
+      "_vendor-three-C5WAXd5r.js"
+    ]
+  },
+  "_pages-nxs-tDxQ.js": {
+    "file": "assets/pages-nxs-tDxQ.js",
+    "name": "pages",
+    "imports": [
+      "_vendor-B52WHALA.js",
+      "_vendor-arizeai-DGHetzZW.js",
+      "_components-J06J_j9O.js",
+      "_vendor-codemirror-QIdVJrP_.js",
+      "_vendor-recharts-GmWamXB4.js"
+    ]
+  },
+  "_vendor-B52WHALA.js": {
+    "file": "assets/vendor-B52WHALA.js",
+    "name": "vendor",
+    "imports": [
+      "_vendor-three-C5WAXd5r.js"
+    ],
+    "css": [
+      "assets/vendor-WIZid84E.css"
+    ]
+  },
+  "_vendor-WIZid84E.css": {
+    "file": "assets/vendor-WIZid84E.css",
+    "src": "_vendor-WIZid84E.css"
+  },
+  "_vendor-arizeai-DGHetzZW.js": {
+    "file": "assets/vendor-arizeai-DGHetzZW.js",
+    "name": "vendor-arizeai",
+    "imports": [
+      "_vendor-B52WHALA.js"
+    ]
+  },
+  "_vendor-codemirror-QIdVJrP_.js": {
+    "file": "assets/vendor-codemirror-QIdVJrP_.js",
+    "name": "vendor-codemirror",
+    "imports": [
+      "_vendor-B52WHALA.js",
+      "_vendor-shiki-C8cTrXI5.js"
+    ]
+  },
+  "_vendor-recharts-GmWamXB4.js": {
+    "file": "assets/vendor-recharts-GmWamXB4.js",
+    "name": "vendor-recharts",
+    "imports": [
+      "_vendor-B52WHALA.js"
+    ]
+  },
+  "_vendor-shiki-C8cTrXI5.js": {
+    "file": "assets/vendor-shiki-C8cTrXI5.js",
+    "name": "vendor-shiki",
+    "imports": [
+      "_vendor-B52WHALA.js"
+    ]
+  },
+  "_vendor-three-C5WAXd5r.js": {
+    "file": "assets/vendor-three-C5WAXd5r.js",
+    "name": "vendor-three"
+  },
+  "index.tsx": {
+    "file": "assets/index-DfT39tc3.js",
+    "name": "index",
+    "src": "index.tsx",
+    "isEntry": true,
+    "imports": [
+      "_vendor-B52WHALA.js",
+      "_vendor-arizeai-DGHetzZW.js",
+      "_pages-nxs-tDxQ.js",
+      "_components-J06J_j9O.js",
+      "_vendor-three-C5WAXd5r.js",
+      "_vendor-codemirror-QIdVJrP_.js",
+      "_vendor-shiki-C8cTrXI5.js",
+      "_vendor-recharts-GmWamXB4.js"
+    ]
+  }
+}