arize-phoenix 10.11.0__tar.gz → 10.13.0__tar.gz

{arize_phoenix-10.11.0 → arize_phoenix-10.13.0}/.gitignore

@@ -82,3 +82,6 @@ uv.lock
 packages/phoenix-otel/docs/build/
 packages/phoenix-client/docs/build/
 packages/phoenix-evals/docs/build/
+
+# Deployment
+helm/charts/*.tgz

{arize_phoenix-10.11.0 → arize_phoenix-10.13.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arize-phoenix
-Version: 10.11.0
+Version: 10.13.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-10.11.0 → arize_phoenix-10.13.0}/src/phoenix/config.py

@@ -50,6 +50,11 @@ ENV_PHOENIX_PROJECT_NAME = "PHOENIX_PROJECT_NAME"
 """
 The project name to use when logging traces and evals. defaults to 'default'.
 """
+ENV_PHOENIX_FULLSTORY_ORG = "PHOENIX_FULLSTORY_ORG"
+"""
+The FullStory organization ID for web analytics tracking. When set, FullStory tracking
+will be enabled in the Phoenix web interface.
+"""
 ENV_PHOENIX_SQL_DATABASE_URL = "PHOENIX_SQL_DATABASE_URL"
 """
 The SQL database URL to use when logging traces and evals.
@@ -1520,6 +1525,16 @@ def get_env_allowed_origins() -> Optional[list[str]]:
     return allowed_origins.split(",")
 
 
+def get_env_fullstory_org() -> Optional[str]:
+    """
+    Get the FullStory organization ID from environment variables.
+
+    Returns:
+        Optional[str]: The FullStory organization ID if set, None otherwise.
+    """
+    return getenv(ENV_PHOENIX_FULLSTORY_ORG)
+
+
 def verify_server_environment_variables() -> None:
     """Verify that the environment variables are set correctly. Raises an error otherwise."""
     get_env_root_url()

{arize_phoenix-10.11.0 → arize_phoenix-10.13.0}/src/phoenix/server/api/helpers/playground_clients.py

@@ -359,7 +359,6 @@ class OpenAIBaseStreamingClient(PlaygroundStreamingClient):
         ):
             if (usage := chunk.usage) is not None:
                 token_usage = usage
-                continue
             if not chunk.choices:
                 # for Azure, initial chunk contains the content filter
                 continue

{arize_phoenix-10.11.0 → arize_phoenix-10.13.0}/src/phoenix/server/api/queries.py

@@ -319,6 +319,16 @@ class Query:
         after: Optional[CursorString] = UNSET,
         filter_condition: Optional[str] = UNSET,
     ) -> Connection[ExperimentComparison]:
+        # Handle empty experiment_ids gracefully
+        if not experiment_ids:
+            return connection_from_list(
+                data=[],
+                args=ConnectionArgs(
+                    first=first,
+                    after=after if isinstance(after, CursorString) else None,
+                ),
+            )
+
         experiment_ids_ = [
             from_global_id_with_expected_type(experiment_id, OrmExperiment.__name__)
             for experiment_id in experiment_ids

{arize_phoenix-10.11.0 → arize_phoenix-10.13.0}/src/phoenix/server/api/routers/v1/spans.py

@@ -1,3 +1,4 @@
+import json
 import warnings
 from asyncio import get_running_loop
 from collections.abc import AsyncIterator
@@ -12,7 +13,12 @@ from pydantic import BaseModel, Field
 from sqlalchemy import select
 from starlette.requests import Request
 from starlette.responses import Response, StreamingResponse
-from starlette.status import HTTP_404_NOT_FOUND, HTTP_422_UNPROCESSABLE_ENTITY
+from starlette.status import (
+    HTTP_202_ACCEPTED,
+    HTTP_400_BAD_REQUEST,
+    HTTP_404_NOT_FOUND,
+    HTTP_422_UNPROCESSABLE_ENTITY,
+)
 from strawberry.relay import GlobalID
 
 from phoenix.config import DEFAULT_PROJECT_NAME
@@ -26,6 +32,19 @@ from phoenix.server.bearer_auth import PhoenixUser
 from phoenix.server.dml_event import SpanAnnotationInsertEvent
 from phoenix.trace.attributes import flatten
 from phoenix.trace.dsl import SpanQuery as SpanQuery_
+from phoenix.trace.schemas import (
+    Span as SpanForInsertion,
+)
+from phoenix.trace.schemas import (
+    SpanContext as InsertionSpanContext,
+)
+from phoenix.trace.schemas import (
+    SpanEvent as InternalSpanEvent,
+)
+from phoenix.trace.schemas import (
+    SpanKind,
+    SpanStatusCode,
+)
 from phoenix.utilities.json import encode_df_as_json_string
 
 from .models import V1RoutesBaseModel
@@ -393,7 +412,9 @@ class SpanEvent(V1RoutesBaseModel):
 
 
 class Span(V1RoutesBaseModel):
-    id: str = Field(description="Span Global ID, distinct from the OpenTelemetry span ID")
+    id: str = Field(
+        default="", 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")
@@ -440,7 +461,7 @@ async def query_spans_handler(
     )
     end_time = request_body.end_time or request_body.stop_time
     try:
-        span_queries = [SpanQuery_.from_dict(query.dict()) for query in queries]
+        span_queries = [SpanQuery_.from_dict(query.model_dump()) for query in queries]
     except Exception as e:
         raise HTTPException(
             detail=f"Invalid query: {e}",
@@ -956,3 +977,143 @@ async def annotate_spans(
             for id_ in inserted_ids
         ]
     )
+
+
+class CreateSpansRequestBody(RequestBody[list[Span]]):
+    data: list[Span]
+
+
+class CreateSpansResponseBody(V1RoutesBaseModel):
+    total_received: int = Field(description="Total number of spans received")
+    total_queued: int = Field(description="Number of spans successfully queued for insertion")
+
+
+@router.post(
+    "/projects/{project_identifier}/spans",
+    operation_id="createSpans",
+    summary="Create spans",
+    description=(
+        "Submit spans to be inserted into a project. If any spans are invalid or "
+        "duplicates, no spans will be inserted."
+    ),
+    responses=add_errors_to_responses([HTTP_404_NOT_FOUND, HTTP_400_BAD_REQUEST]),
+    status_code=HTTP_202_ACCEPTED,
+)
+async def create_spans(
+    request: Request,
+    request_body: CreateSpansRequestBody,
+    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."
+        )
+    ),
+) -> CreateSpansResponseBody:
+    def convert_api_span_for_insertion(api_span: Span) -> SpanForInsertion:
+        """
+        Convert from API Span to phoenix.trace.schemas.Span
+        Note: The 'id' field has a default empty string and is ignored during insertion.
+        """
+        try:
+            span_kind = SpanKind(api_span.span_kind.upper())
+        except ValueError:
+            span_kind = SpanKind.UNKNOWN
+
+        try:
+            status_code = SpanStatusCode(api_span.status_code.upper())
+        except ValueError:
+            status_code = SpanStatusCode.UNSET
+
+        internal_events: list[InternalSpanEvent] = []
+        for event in api_span.events:
+            if event.timestamp:
+                internal_events.append(
+                    InternalSpanEvent(
+                        name=event.name, timestamp=event.timestamp, attributes=event.attributes
+                    )
+                )
+
+        # Add back the openinference.span.kind attribute since it's stored separately in the API
+        attributes = dict(api_span.attributes)
+        attributes["openinference.span.kind"] = api_span.span_kind
+
+        # Create span for insertion - note we ignore the 'id' field as it's server-generated
+        return SpanForInsertion(
+            name=api_span.name,
+            context=InsertionSpanContext(
+                trace_id=api_span.context.trace_id, span_id=api_span.context.span_id
+            ),
+            span_kind=span_kind,
+            parent_id=api_span.parent_id,
+            start_time=api_span.start_time,
+            end_time=api_span.end_time,
+            status_code=status_code,
+            status_message=api_span.status_message,
+            attributes=attributes,
+            events=internal_events,
+            conversation=None,  # Unused
+        )
+
+    async with request.app.state.db() as session:
+        project = await _get_project_by_identifier(session, project_identifier)
+
+    total_received = len(request_body.data)
+    duplicate_spans: list[dict[str, str]] = []
+    invalid_spans: list[dict[str, str]] = []
+    spans_to_queue: list[tuple[SpanForInsertion, str]] = []
+
+    existing_span_ids: set[str] = set()
+    span_ids = [span.context.span_id for span in request_body.data]
+    async with request.app.state.db() as session:
+        existing_result = await session.execute(
+            select(models.Span.span_id).where(models.Span.span_id.in_(span_ids))
+        )
+        existing_span_ids = {row[0] for row in existing_result}
+
+    for api_span in request_body.data:
+        # Check if it's a duplicate
+        if api_span.context.span_id in existing_span_ids:
+            duplicate_spans.append(
+                {
+                    "span_id": api_span.context.span_id,
+                    "trace_id": api_span.context.trace_id,
+                }
+            )
+            continue
+
+        try:
+            span_for_insertion = convert_api_span_for_insertion(api_span)
+            spans_to_queue.append((span_for_insertion, project.name))
+        except Exception as e:
+            invalid_spans.append(
+                {
+                    "span_id": api_span.context.span_id,
+                    "trace_id": api_span.context.trace_id,
+                    "error": str(e),
+                }
+            )
+
+    # If there are any duplicates or invalid spans, reject the entire request
+    if duplicate_spans or invalid_spans:
+        error_detail = {
+            "error": "Request contains invalid or duplicate spans",
+            "total_received": total_received,
+            "total_queued": 0,  # No spans are queued when there are validation errors
+            "total_duplicates": len(duplicate_spans),
+            "total_invalid": len(invalid_spans),
+            "duplicate_spans": duplicate_spans,
+            "invalid_spans": invalid_spans,
+        }
+        raise HTTPException(
+            status_code=HTTP_400_BAD_REQUEST,
+            detail=json.dumps(error_detail),
+        )
+
+    # 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)
+
+    return CreateSpansResponseBody(
+        total_received=total_received,
+        total_queued=len(spans_to_queue),
+    )

{arize_phoenix-10.11.0 → arize_phoenix-10.13.0}/src/phoenix/server/api/types/Project.py

@@ -326,8 +326,27 @@ class Project(Node):
         after: Optional[CursorString] = UNSET,
         sort: Optional[ProjectSessionSort] = UNSET,
         filter_io_substring: Optional[str] = UNSET,
+        session_id: Optional[str] = UNSET,
     ) -> Connection[ProjectSession]:
         table = models.ProjectSession
+        if session_id:
+            async with info.context.db() as session:
+                ans = await session.scalar(
+                    select(table).filter_by(
+                        session_id=session_id,
+                        project_id=self.project_rowid,
+                    )
+                )
+            if ans:
+                return connection_from_list(
+                    data=[to_gql_project_session(ans)],
+                    args=ConnectionArgs(),
+                )
+            elif not filter_io_substring:
+                return connection_from_list(
+                    data=[],
+                    args=ConnectionArgs(),
+                )
         stmt = select(table).filter_by(project_id=self.project_rowid)
         if time_range:
             if time_range.start:

{arize_phoenix-10.11.0 → arize_phoenix-10.13.0}/src/phoenix/server/app.py

@@ -214,6 +214,8 @@ class AppConfig(NamedTuple):
     oauth2_idps: Sequence[OAuth2Idp]
     basic_auth_disabled: bool = False
     auto_login_idp_name: Optional[str] = None
+    fullstory_org: Optional[str] = None
+    """ FullStory organization ID for web analytics tracking """
 
 
 class Static(StaticFiles):
@@ -279,6 +281,7 @@ class Static(StaticFiles):
                     "oauth2_idps": self._app_config.oauth2_idps,
                     "basic_auth_disabled": self._app_config.basic_auth_disabled,
                     "auto_login_idp_name": self._app_config.auto_login_idp_name,
+                    "fullstory_org": self._app_config.fullstory_org,
                 },
             )
         except Exception as e:
@@ -964,6 +967,7 @@ def create_app(
                     oauth2_idps=oauth2_idps,
                     basic_auth_disabled=basic_auth_disabled,
                     auto_login_idp_name=auto_login_idp_name,
+                    fullstory_org=Settings.fullstory_org,
                 ),
             ),
             name="static",

{arize_phoenix-10.11.0 → arize_phoenix-10.13.0}/src/phoenix/server/main.py

@@ -25,6 +25,7 @@ from phoenix.config import (
     get_env_db_logging_level,
     get_env_disable_migrations,
     get_env_enable_prometheus,
+    get_env_fullstory_org,
     get_env_grpc_port,
     get_env_host,
     get_env_host_root_path,
@@ -484,11 +485,13 @@ def main() -> None:
 
 
 def initialize_settings() -> None:
+    """Initialize the settings from environment variables."""
     Settings.logging_mode = get_env_logging_mode()
     Settings.logging_level = get_env_logging_level()
     Settings.db_logging_level = get_env_db_logging_level()
     Settings.log_migrations = get_env_log_migrations()
     Settings.disable_migrations = get_env_disable_migrations()
+    Settings.fullstory_org = get_env_fullstory_org()
 
 
 if __name__ == "__main__":

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

@@ -0,0 +1,87 @@
+{
+  "_components-37rV35eH.js": {
+    "file": "assets/components-37rV35eH.js",
+    "name": "components",
+    "imports": [
+      "_vendor-BKYy4SMr.js",
+      "_pages-BWWAYqfd.js",
+      "_vendor-arizeai-hGVPFFRq.js",
+      "_vendor-codemirror-BlmFw5CA.js",
+      "_vendor-three-C5WAXd5r.js"
+    ]
+  },
+  "_pages-BWWAYqfd.js": {
+    "file": "assets/pages-BWWAYqfd.js",
+    "name": "pages",
+    "imports": [
+      "_vendor-BKYy4SMr.js",
+      "_vendor-arizeai-hGVPFFRq.js",
+      "_components-37rV35eH.js",
+      "_vendor-codemirror-BlmFw5CA.js",
+      "_vendor-recharts-Bz7zqjbW.js"
+    ]
+  },
+  "_vendor-BKYy4SMr.js": {
+    "file": "assets/vendor-BKYy4SMr.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-hGVPFFRq.js": {
+    "file": "assets/vendor-arizeai-hGVPFFRq.js",
+    "name": "vendor-arizeai",
+    "imports": [
+      "_vendor-BKYy4SMr.js"
+    ]
+  },
+  "_vendor-codemirror-BlmFw5CA.js": {
+    "file": "assets/vendor-codemirror-BlmFw5CA.js",
+    "name": "vendor-codemirror",
+    "imports": [
+      "_vendor-BKYy4SMr.js",
+      "_vendor-shiki-BitvudxD.js"
+    ]
+  },
+  "_vendor-recharts-Bz7zqjbW.js": {
+    "file": "assets/vendor-recharts-Bz7zqjbW.js",
+    "name": "vendor-recharts",
+    "imports": [
+      "_vendor-BKYy4SMr.js"
+    ]
+  },
+  "_vendor-shiki-BitvudxD.js": {
+    "file": "assets/vendor-shiki-BitvudxD.js",
+    "name": "vendor-shiki",
+    "imports": [
+      "_vendor-BKYy4SMr.js"
+    ]
+  },
+  "_vendor-three-C5WAXd5r.js": {
+    "file": "assets/vendor-three-C5WAXd5r.js",
+    "name": "vendor-three"
+  },
+  "index.tsx": {
+    "file": "assets/index-CdNW7TcY.js",
+    "name": "index",
+    "src": "index.tsx",
+    "isEntry": true,
+    "imports": [
+      "_vendor-BKYy4SMr.js",
+      "_vendor-arizeai-hGVPFFRq.js",
+      "_pages-BWWAYqfd.js",
+      "_components-37rV35eH.js",
+      "_vendor-three-C5WAXd5r.js",
+      "_vendor-codemirror-BlmFw5CA.js",
+      "_vendor-shiki-BitvudxD.js",
+      "_vendor-recharts-Bz7zqjbW.js"
+    ]
+  }
+}