arize-phoenix 3.25.0__py3-none-any.whl → 4.0.1__py3-none-any.whl

phoenix/server/main.py

@@ -1,24 +1,29 @@
 import atexit
 import logging
 import os
+import warnings
 from argparse import ArgumentParser
 from pathlib import Path
-from random import random
 from threading import Thread
 from time import sleep, time
-from typing import Iterable, Optional, Protocol, TypeVar
+from typing import List, Optional
 
 import pkg_resources
 from uvicorn import Config, Server
 
+import phoenix.trace.v1 as pb
 from phoenix.config import (
     EXPORT_DIR,
+    get_env_database_connection_str,
+    get_env_enable_prometheus,
+    get_env_grpc_port,
     get_env_host,
     get_env_port,
     get_pids_path,
+    get_working_dir,
 )
 from phoenix.core.model_schema_adapter import create_model_from_datasets
-from phoenix.core.traces import Traces
+from phoenix.db import get_printable_db_url
 from phoenix.inferences.fixtures import FIXTURES, get_datasets
 from phoenix.inferences.inferences import EMPTY_INFERENCES, Inferences
 from phoenix.pointcloud.umap_parameters import (
@@ -28,16 +33,17 @@ from phoenix.pointcloud.umap_parameters import (
     UMAPParameters,
 )
 from phoenix.server.app import create_app
-from phoenix.storage.span_store import SpanStore
+from phoenix.settings import Settings
 from phoenix.trace.fixtures import (
     TRACES_FIXTURES,
-    _download_traces_fixture,
-    _get_trace_fixture_by_name,
+    download_traces_fixture,
     get_evals_from_fixture,
+    get_trace_fixture_by_name,
+    reset_fixture_span_ids_and_timestamps,
 )
 from phoenix.trace.otel import decode_otlp_span, encode_span_to_otlp
+from phoenix.trace.schemas import Span
 from phoenix.trace.span_json_decoder import json_string_to_span
-from phoenix.utilities.span_store import get_span_store, load_traces_data_from_store
 
 logger = logging.getLogger(__name__)
 
@@ -48,7 +54,7 @@ _WELCOME_MESSAGE = """
 ██████╔╝███████║██║   ██║█████╗  ██╔██╗ ██║██║ ╚███╔╝
 ██╔═══╝ ██╔══██║██║   ██║██╔══╝  ██║╚██╗██║██║ ██╔██╗
 ██║     ██║  ██║╚██████╔╝███████╗██║ ╚████║██║██╔╝ ██╗
-╚═╝     ╚═╝  ╚═╝ ╚═════╝ ╚══════╝╚═╝  ╚═══╝╚═╝╚═╝  ╚═╝ v{0}
+╚═╝     ╚═╝  ╚═╝ ╚═════╝ ╚══════╝╚═╝  ╚═══╝╚═╝╚═╝  ╚═╝ v{version}
 
 |
 |  🌎 Join our Community 🌎
@@ -61,9 +67,11 @@ _WELCOME_MESSAGE = """
 |  https://docs.arize.com/phoenix
 |
 |  🚀 Phoenix Server 🚀
-|  Phoenix UI: http://{1}:{2}
-|  Log traces: /v1/traces over HTTP
-|
+|  Phoenix UI: http://{host}:{port}
+|  Log traces:
+|    - gRPC: http://{host}:{grpc_port}
+|    - HTTP: http://{host}:{port}/v1/traces
+|  Storage: {storage}
 """
 
 
@@ -88,24 +96,6 @@ def _get_pid_file() -> Path:
     return get_pids_path() / str(os.getpid())
 
 
-_Item = TypeVar("_Item", contravariant=True)
-
-
-class _SupportsPut(Protocol[_Item]):
-    def put(self, item: _Item) -> None: ...
-
-
-def _load_items(
-    queue: _SupportsPut[_Item],
-    items: Iterable[_Item],
-    simulate_streaming: Optional[bool] = False,
-) -> None:
-    for item in items:
-        if simulate_streaming:
-            sleep(random())
-        queue.put(item)
-
-
 DEFAULT_UMAP_PARAMS_STR = f"{DEFAULT_MIN_DIST},{DEFAULT_N_NEIGHBORS},{DEFAULT_N_SAMPLES}"
 
 if __name__ == "__main__":
@@ -118,10 +108,14 @@ if __name__ == "__main__":
     reference_dataset: Optional[Inferences] = None
     corpus_dataset: Optional[Inferences] = None
 
+    # Initialize the settings for the Server
+    Settings.log_migrations = True
+
     # automatically remove the pid file when the process is being gracefully terminated
     atexit.register(_remove_pid_file)
 
     parser = ArgumentParser()
+    parser.add_argument("--database-url", required=False)
     parser.add_argument("--export_path")
     parser.add_argument("--host", type=str, required=False)
     parser.add_argument("--port", type=int, required=False)
@@ -152,8 +146,10 @@ if __name__ == "__main__":
     )
     demo_parser.add_argument("--simulate-streaming", action="store_true")
     args = parser.parse_args()
+    db_connection_str = (
+        args.database_url if args.database_url else get_env_database_connection_str()
+    )
     export_path = Path(args.export_path) if args.export_path else EXPORT_DIR
-    span_store: Optional[SpanStore] = None
     if args.command == "datasets":
         primary_dataset_name = args.primary
         reference_dataset_name = args.reference
@@ -189,33 +185,38 @@ if __name__ == "__main__":
         trace_dataset_name = args.trace_fixture
         simulate_streaming = args.simulate_streaming
 
+    host: Optional[str] = args.host or get_env_host()
+    display_host = host or "localhost"
+    # If the host is "::", the convention is to bind to all interfaces. However, uvicorn
+    # does not support this directly unless the host is set to None.
+    if host and ":" in host:
+        # format IPv6 hosts in brackets
+        display_host = f"[{host}]"
+    if host == "::":
+        # TODO(dustin): why is this necessary? it's not type compliant
+        host = None
+
+    port = args.port or get_env_port()
+
     model = create_model_from_datasets(
         primary_dataset,
         reference_dataset,
     )
-    traces = Traces()
-    if span_store := get_span_store():
-        Thread(target=load_traces_data_from_store, args=(traces, span_store), daemon=True).start()
+
+    fixture_spans: List[Span] = []
+    fixture_evals: List[pb.Evaluation] = []
     if trace_dataset_name is not None:
-        fixture_spans = list(
-            # Apply `encode` here because legacy jsonl files contains UUIDs as strings.
-            # `encode` removes the hyphens in the UUIDs.
-            decode_otlp_span(encode_span_to_otlp(json_string_to_span(json_span)))
-            for json_span in _download_traces_fixture(
-                _get_trace_fixture_by_name(trace_dataset_name)
-            )
+        fixture_spans, fixture_evals = reset_fixture_span_ids_and_timestamps(
+            (
+                # Apply `encode` here because legacy jsonl files contains UUIDs as strings.
+                # `encode` removes the hyphens in the UUIDs.
+                decode_otlp_span(encode_span_to_otlp(json_string_to_span(json_span)))
+                for json_span in download_traces_fixture(
+                    get_trace_fixture_by_name(trace_dataset_name)
+                )
+            ),
+            get_evals_from_fixture(trace_dataset_name),
         )
-        Thread(
-            target=_load_items,
-            args=(traces, fixture_spans, simulate_streaming),
-            daemon=True,
-        ).start()
-        fixture_evals = list(get_evals_from_fixture(trace_dataset_name))
-        Thread(
-            target=_load_items,
-            args=(traces, fixture_evals, simulate_streaming),
-            daemon=True,
-        ).start()
     umap_params_list = args.umap_params.split(",")
     umap_params = UMAPParameters(
         min_dist=float(umap_params_list[0]),
@@ -224,31 +225,45 @@ if __name__ == "__main__":
     )
     read_only = args.read_only
     logger.info(f"Server umap params: {umap_params}")
-    if enable_prometheus := args.enable_prometheus:
+    if enable_prometheus := (get_env_enable_prometheus() or args.enable_prometheus):
+        if args.enable_prometheus:
+            warnings.warn(
+                "The --enable-prometheus command line argument is being deprecated "
+                "and will be removed in an upcoming release. "
+                "Please set the PHOENIX_ENABLE_PROMETHEUS environment variable to TRUE.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
         from phoenix.server.prometheus import start_prometheus
 
         start_prometheus()
+
+    working_dir = get_working_dir().resolve()
     app = create_app(
+        database_url=db_connection_str,
         export_path=export_path,
         model=model,
         umap_params=umap_params,
-        traces=traces,
         corpus=None if corpus_dataset is None else create_model_from_datasets(corpus_dataset),
         debug=args.debug,
         read_only=read_only,
-        span_store=span_store,
         enable_prometheus=enable_prometheus,
+        initial_spans=fixture_spans,
+        initial_evaluations=fixture_evals,
     )
-    host = args.host or get_env_host()
-    port = args.port or get_env_port()
-    server = Server(config=Config(app, host=host, port=port))
+    server = Server(config=Config(app, host=host, port=port))  # type: ignore
     Thread(target=_write_pid_file_when_ready, args=(server,), daemon=True).start()
 
     # Print information about the server
     phoenix_version = pkg_resources.get_distribution("arize-phoenix").version
-    print(
-        _WELCOME_MESSAGE.format(phoenix_version, host if host != "0.0.0.0" else "localhost", port)
-    )
+    config = {
+        "version": phoenix_version,
+        "host": display_host,
+        "port": port,
+        "grpc_port": get_env_grpc_port(),
+        "storage": get_printable_db_url(db_connection_str),
+    }
+    print(_WELCOME_MESSAGE.format(**config))
 
     # Start the server
     server.run()

phoenix/server/openapi/docs.py

@@ -0,0 +1,218 @@
+import json
+from typing import Any, Dict, Optional
+
+from starlette.responses import HTMLResponse
+
+swagger_ui_default_parameters: Dict[str, Any] = {
+    "dom_id": "#swagger-ui",
+    "layout": "BaseLayout",
+    "deepLinking": True,
+    "showExtensions": True,
+    "showCommonExtensions": True,
+}
+
+
+def get_swagger_ui_html(
+    *,
+    openapi_url: str = "/schema",
+    title: str,
+    swagger_js_url: str = "https://cdn.jsdelivr.net/npm/swagger-ui-dist@5.9.0/swagger-ui-bundle.js",
+    swagger_css_url: str = "https://cdn.jsdelivr.net/npm/swagger-ui-dist@5.9.0/swagger-ui.css",
+    swagger_favicon_url: str = "/favicon.ico",
+    oauth2_redirect_url: Optional[str] = None,
+    init_oauth: Optional[str] = None,
+    swagger_ui_parameters: Optional[Dict[str, Any]] = None,
+) -> HTMLResponse:
+    """
+    Generate and return the HTML  that loads Swagger UI for the interactive API
+    docs (normally served at `/docs`).
+    """
+    current_swagger_ui_parameters = swagger_ui_default_parameters.copy()
+    if swagger_ui_parameters:
+        current_swagger_ui_parameters.update(swagger_ui_parameters)
+
+    html = f"""
+    <!DOCTYPE html>
+    <html>
+    <head>
+    <link type="text/css" rel="stylesheet" href="{swagger_css_url}">
+    <link rel="shortcut icon" href="{swagger_favicon_url}">
+    <title>{title}</title>
+    </head>
+    <body>
+    <div id="swagger-ui">
+    </div>
+    <script src="{swagger_js_url}"></script>
+    <!-- `SwaggerUIBundle` is now available on the page -->
+    <script>
+    const ui = SwaggerUIBundle({{
+        url: '{openapi_url}',
+    """
+
+    for key, value in current_swagger_ui_parameters.items():
+        html += f"{json.dumps(key)}: {json.dumps(value)},\n"
+
+    if oauth2_redirect_url:
+        html += f"oauth2RedirectUrl: window.location.origin + '{oauth2_redirect_url}',"
+
+    html += """
+    presets: [
+        SwaggerUIBundle.presets.apis,
+        SwaggerUIBundle.SwaggerUIStandalonePreset
+        ],
+    })"""
+
+    if init_oauth:
+        html += f"""
+        ui.initOAuth({json.dumps(init_oauth)})
+        """
+
+    html += """
+    </script>
+    </body>
+    </html>
+    """
+    return HTMLResponse(html)
+
+
+def get_redoc_html(
+    *,
+    openapi_url: str,
+    title: str,
+    redoc_js_url: str = "https://cdn.jsdelivr.net/npm/redoc@next/bundles/redoc.standalone.js",
+    redoc_favicon_url: str = "/favicon.ico",
+    with_google_fonts: bool = True,
+) -> HTMLResponse:
+    """
+    Generate and return the HTML response that loads ReDoc for the alternative
+    API docs (normally served at `/redoc`).
+
+
+    """
+    html = f"""
+    <!DOCTYPE html>
+    <html>
+    <head>
+    <title>{title}</title>
+    <!-- needed for adaptive design -->
+    <meta charset="utf-8"/>
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    """
+    if with_google_fonts:
+        html += """
+    <link href="https://fonts.googleapis.com/css?family=Montserrat:300,400,700|Roboto:300,400,700" rel="stylesheet">
+    """  # noqa: E501
+    html += f"""
+    <link rel="shortcut icon" href="{redoc_favicon_url}">
+    <!--
+    ReDoc doesn't change outer page styles
+    -->
+    <style>
+      body {{
+        margin: 0;
+        padding: 0;
+      }}
+    </style>
+    </head>
+    <body>
+    <noscript>
+        ReDoc requires Javascript to function. Please enable it to browse the documentation.
+    </noscript>
+    <redoc spec-url="{openapi_url}"></redoc>
+    <script src="{redoc_js_url}"> </script>
+    </body>
+    </html>
+    """
+    return HTMLResponse(html)
+
+
+# Not needed now but copy-pasting for future reference
+def get_swagger_ui_oauth2_redirect_html() -> HTMLResponse:
+    """
+    Generate the HTML response with the OAuth2 redirection for Swagger UI.
+
+    You normally don't need to use or change this.
+    """
+    # copied from https://github.com/swagger-api/swagger-ui/blob/v4.14.0/dist/oauth2-redirect.html
+    html = """
+    <!doctype html>
+    <html lang="en-US">
+    <head>
+        <title>Swagger UI: OAuth2 Redirect</title>
+    </head>
+    <body>
+    <script>
+        'use strict';
+        function run () {
+            var oauth2 = window.opener.swaggerUIRedirectOauth2;
+            var sentState = oauth2.state;
+            var redirectUrl = oauth2.redirectUrl;
+            var isValid, qp, arr;
+
+            if (/code|token|error/.test(window.location.hash)) {
+                qp = window.location.hash.substring(1).replace('?', '&');
+            } else {
+                qp = location.search.substring(1);
+            }
+
+            arr = qp.split("&");
+            arr.forEach(function (v,i,_arr) { _arr[i] = '"' + v.replace('=', '":"') + '"';});
+            qp = qp ? JSON.parse('{' + arr.join() + '}',
+                    function (key, value) {
+                        return key === "" ? value : decodeURIComponent(value);
+                    }
+            ) : {};
+
+            isValid = qp.state === sentState;
+
+            if ((
+              oauth2.auth.schema.get("flow") === "accessCode" ||
+              oauth2.auth.schema.get("flow") === "authorizationCode" ||
+              oauth2.auth.schema.get("flow") === "authorization_code"
+            ) && !oauth2.auth.code) {
+                if (!isValid) {
+                    oauth2.errCb({
+                        authId: oauth2.auth.name,
+                        source: "auth",
+                        level: "warning",
+                        message: "Authorization may be unsafe, passed state was changed in server. The passed state wasn't returned from auth server."
+                    });
+                }
+
+                if (qp.code) {
+                    delete oauth2.state;
+                    oauth2.auth.code = qp.code;
+                    oauth2.callback({auth: oauth2.auth, redirectUrl: redirectUrl});
+                } else {
+                    let oauthErrorMsg;
+                    if (qp.error) {
+                        oauthErrorMsg = "["+qp.error+"]: " +
+                            (qp.error_description ? qp.error_description+ ". " : "no accessCode received from the server. ") +
+                            (qp.error_uri ? "More info: "+qp.error_uri : "");
+                    }
+
+                    oauth2.errCb({
+                        authId: oauth2.auth.name,
+                        source: "auth",
+                        level: "error",
+                        message: oauthErrorMsg || "[Authorization failed]: no accessCode received from the server."
+                    });
+                }
+            } else {
+                oauth2.callback({auth: oauth2.auth, token: qp, isValid: isValid, redirectUrl: redirectUrl});
+            }
+            window.close();
+        }
+
+        if (document.readyState !== 'loading') {
+            run();
+        } else {
+            document.addEventListener('DOMContentLoaded', function () {
+                run();
+            });
+        }
+    </script>
+    </body>
+    </html>
+        """  # noqa: E501
+    return HTMLResponse(content=html)

phoenix/server/prometheus.py

@@ -5,7 +5,7 @@ import psutil
 from prometheus_client import (
     Counter,
     Gauge,
-    Histogram,
+    Summary,
     start_http_server,
 )
 from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoint
@@ -13,9 +13,9 @@ 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)",
+REQUESTS_PROCESSING_TIME = Summary(
+    name="starlette_requests_processing_time_seconds_summary",
+    documentation="Summary of requests processing time by method and path (in seconds)",
     labelnames=["method", "path"],
 )
 EXCEPTIONS = Counter(
@@ -33,6 +33,22 @@ CPU_METRIC = Gauge(
     documentation="CPU usage percent",
     labelnames=["core"],
 )
+BULK_LOADER_INSERTION_TIME = Summary(
+    name="bulk_loader_insertion_time_seconds_summary",
+    documentation="Summary of database insertion time (seconds)",
+)
+BULK_LOADER_SPAN_INSERTIONS = Counter(
+    name="bulk_loader_span_insertions_total",
+    documentation="Total count of bulk loader span insertions",
+)
+BULK_LOADER_EVALUATION_INSERTIONS = Counter(
+    name="bulk_loader_evaluation_insertions_total",
+    documentation="Total count of bulk loader evaluation insertions",
+)
+BULK_LOADER_EXCEPTIONS = Counter(
+    name="bulk_loader_exceptions_total",
+    documentation="Total count of bulk loader exceptions",
+)
 
 
 class PrometheusMiddleware(BaseHTTPMiddleware):
@@ -51,14 +67,14 @@ class PrometheusMiddleware(BaseHTTPMiddleware):
         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)
+        end_time = time.perf_counter()
+        REQUESTS_PROCESSING_TIME.labels(method=method, path=path).observe(end_time - start_time)
         return response
 
 
 def start_prometheus() -> None:
     Thread(target=gather_system_data, daemon=True).start()
-    start_http_server(9090)
+    start_http_server(9090, addr="::")
 
 
 def gather_system_data() -> None: