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

phoenix/server/telemetry.py

@@ -0,0 +1,68 @@
+import os
+from typing import TYPE_CHECKING
+
+from phoenix.config import (
+    ENV_PHOENIX_SERVER_INSTRUMENTATION_OTLP_TRACE_COLLECTOR_GRPC_ENDPOINT,
+    ENV_PHOENIX_SERVER_INSTRUMENTATION_OTLP_TRACE_COLLECTOR_HTTP_ENDPOINT,
+)
+
+if TYPE_CHECKING:
+    from opentelemetry.trace import TracerProvider
+from logging import getLogger
+
+logger = getLogger(__name__)
+
+
+def normalize_http_collector_endpoint(endpoint: str) -> str:
+    normalized_endpoint = endpoint
+    if not normalized_endpoint.startswith("http://") and not normalized_endpoint.startswith(
+        "https://"
+    ):
+        logger.warning(
+            "HTTP collector endpoint should include the protocol (http:// or https://)."
+            "Assuming http."
+        )
+        # assume http if no protocol is provided
+        normalized_endpoint = f"http://{endpoint}"
+    if normalized_endpoint.endswith("/v1/traces"):
+        logger.warning(
+            "HTTP collector endpoint should not include the /v1/traces path. Removing it."
+        )
+        # remove the /v1/traces path
+        normalized_endpoint = normalized_endpoint[: -len("/v1/traces")]
+    # remove trailing slashes
+    normalized_endpoint = normalized_endpoint.rstrip("/")
+    return normalized_endpoint
+
+
+def initialize_opentelemetry_tracer_provider() -> "TracerProvider":
+    logger.info("Initializing OpenTelemetry tracer provider")
+    from opentelemetry.sdk import trace as trace_sdk
+    from opentelemetry.sdk.resources import Resource
+    from opentelemetry.sdk.trace.export import BatchSpanProcessor
+    from opentelemetry.semconv.resource import ResourceAttributes
+
+    tracer_provider = trace_sdk.TracerProvider(
+        resource=Resource(attributes={ResourceAttributes.SERVICE_NAME: "arize-phoenix-server"})
+    )
+    if http_endpoint := os.getenv(
+        ENV_PHOENIX_SERVER_INSTRUMENTATION_OTLP_TRACE_COLLECTOR_HTTP_ENDPOINT
+    ):
+        logger.info(f"Using HTTP collector endpoint: {http_endpoint}")
+        http_endpoint = normalize_http_collector_endpoint(http_endpoint) + "/v1/traces"
+        from opentelemetry.exporter.otlp.proto.http.trace_exporter import (
+            OTLPSpanExporter as HttpExporter,
+        )
+
+        tracer_provider.add_span_processor(BatchSpanProcessor(HttpExporter(http_endpoint)))
+    if grpc_endpoint := os.getenv(
+        ENV_PHOENIX_SERVER_INSTRUMENTATION_OTLP_TRACE_COLLECTOR_GRPC_ENDPOINT
+    ):
+        logger.info(f"Using gRPC collector endpoint: {grpc_endpoint}")
+        from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import (
+            OTLPSpanExporter as GrpcExporter,
+        )
+
+        tracer_provider.add_span_processor(BatchSpanProcessor(GrpcExporter(grpc_endpoint)))
+    logger.info("🔭 OpenTelemetry tracer provider initialized")
+    return tracer_provider

phoenix/services.py

@@ -107,6 +107,7 @@ class AppService(Service):
 
     def __init__(
         self,
+        database_url: str,
         export_path: Path,
         host: str,
         port: int,
@@ -117,6 +118,7 @@ class AppService(Service):
         corpus_dataset_name: Optional[str],
         trace_dataset_name: Optional[str],
     ):
+        self.database_url = database_url
         self.export_path = export_path
         self.host = host
         self.port = port
@@ -133,6 +135,8 @@ class AppService(Service):
         command = [
             sys.executable,
             "main.py",
+            "--database-url",
+            self.database_url,
             "--export_path",
             str(self.export_path),
             "--host",

phoenix/session/client.py

@@ -3,7 +3,7 @@ import logging
 import weakref
 from datetime import datetime
 from io import BytesIO
-from typing import List, Optional, Union, cast
+from typing import Any, List, Optional, Union, cast
 from urllib.parse import urljoin
 
 import pandas as pd
@@ -15,14 +15,14 @@ from opentelemetry.proto.trace.v1.trace_pb2 import ResourceSpans, ScopeSpans
 from pyarrow import ArrowInvalid
 from requests import Session
 
-import phoenix as px
 from phoenix.config import (
     get_env_collector_endpoint,
     get_env_host,
     get_env_port,
     get_env_project_name,
 )
-from phoenix.session.data_extractor import TraceDataExtractor
+from phoenix.datetime_utils import normalize_datetime
+from phoenix.session.data_extractor import DEFAULT_SPAN_LIMIT, TraceDataExtractor
 from phoenix.trace import Evaluations, TraceDataset
 from phoenix.trace.dsl import SpanQuery
 from phoenix.trace.otel import encode_span_to_otlp
@@ -35,7 +35,8 @@ class Client(TraceDataExtractor):
         self,
         *,
         endpoint: Optional[str] = None,
-        use_active_session_if_available: bool = True,
+        warn_if_server_not_running: bool = True,
+        **kwargs: Any,  # for backward-compatibility
     ):
         """
         Client for connecting to a Phoenix server.
@@ -43,12 +44,14 @@ class Client(TraceDataExtractor):
         Args:
             endpoint (str, optional): Phoenix server endpoint, e.g. http://localhost:6006. If not
                 provided, the endpoint will be inferred from the environment variables.
-            use_active_session_if_available (bool, optional): If px.active_session() is available
-                in the same runtime, e.g. the same Jupyter notebook, delegate the request to the
-                active session instead of making HTTP requests. This argument is set to False if
-                endpoint is provided explicitly.
         """
-        self._use_active_session_if_available = use_active_session_if_available and not endpoint
+        if kwargs.pop("use_active_session_if_available", None) is not None:
+            print(
+                "`use_active_session_if_available` is deprecated "
+                "and will be removed in the future."
+            )
+        if kwargs:
+            raise TypeError(f"Unexpected keyword arguments: {', '.join(kwargs)}")
         host = get_env_host()
         if host == "0.0.0.0":
             host = "127.0.0.1"
@@ -57,16 +60,19 @@ class Client(TraceDataExtractor):
         )
         self._session = Session()
         weakref.finalize(self, self._session.close)
-        if not (self._use_active_session_if_available and px.active_session()):
+        if warn_if_server_not_running:
             self._warn_if_phoenix_is_not_running()
 
     def query_spans(
         self,
         *queries: SpanQuery,
         start_time: Optional[datetime] = None,
-        stop_time: Optional[datetime] = None,
+        end_time: Optional[datetime] = None,
+        limit: Optional[int] = DEFAULT_SPAN_LIMIT,
         root_spans_only: Optional[bool] = None,
         project_name: Optional[str] = None,
+        # Deprecated
+        stop_time: Optional[datetime] = None,
     ) -> Optional[Union[pd.DataFrame, List[pd.DataFrame]]]:
         """
         Queries spans from the Phoenix server or active session based on specified criteria.
@@ -74,7 +80,7 @@ class Client(TraceDataExtractor):
         Args:
             queries (SpanQuery): One or more SpanQuery objects defining the query criteria.
             start_time (datetime, optional): The start time for the query range. Default None.
-            stop_time (datetime, optional): The stop time for the query range. Default None.
+            end_time (datetime, optional): The end time for the query range. Default None.
             root_spans_only (bool, optional): If True, only root spans are returned. Default None.
             project_name (str, optional): The project name to query spans for. This can be set
                 using environment variables. If not provided, falls back to the default project.
@@ -86,22 +92,21 @@ class Client(TraceDataExtractor):
         project_name = project_name or get_env_project_name()
         if not queries:
             queries = (SpanQuery(),)
-        if self._use_active_session_if_available and (session := px.active_session()):
-            return session.query_spans(
-                *queries,
-                start_time=start_time,
-                stop_time=stop_time,
-                root_spans_only=root_spans_only,
-                project_name=project_name,
+        if stop_time is not None:
+            # Deprecated. Raise a warning
+            logger.warning(
+                "stop_time is deprecated. Use end_time instead.",
             )
-        response = self._session.get(
+            end_time = end_time or stop_time
+        response = self._session.post(
             url=urljoin(self._base_url, "/v1/spans"),
+            params={"project-name": project_name},
             json={
                 "queries": [q.to_dict() for q in queries],
-                "start_time": _to_iso_format(start_time),
-                "stop_time": _to_iso_format(stop_time),
+                "start_time": _to_iso_format(normalize_datetime(start_time)),
+                "end_time": _to_iso_format(normalize_datetime(end_time)),
+                "limit": limit,
                 "root_spans_only": root_spans_only,
-                "project_name": project_name,
             },
         )
         if response.status_code == 404:
@@ -140,11 +145,9 @@ class Client(TraceDataExtractor):
                 empty list if no evaluations are found.
         """
         project_name = project_name or get_env_project_name()
-        if self._use_active_session_if_available and (session := px.active_session()):
-            return session.get_evaluations(project_name=project_name)
         response = self._session.get(
             urljoin(self._base_url, "/v1/evaluations"),
-            json={"project_name": project_name},
+            params={"project-name": project_name},
         )
         if response.status_code == 404:
             logger.info("No evaluations found.")
@@ -171,7 +174,7 @@ class Client(TraceDataExtractor):
                 f"with `import phoenix as px; px.launch_app()`"
             )
 
-    def log_evaluations(self, *evals: Evaluations, project_name: Optional[str] = None) -> None:
+    def log_evaluations(self, *evals: Evaluations, **kwargs: Any) -> None:
         """
         Logs evaluation data to the Phoenix server.
 
@@ -184,13 +187,14 @@ class Client(TraceDataExtractor):
         Returns:
             None
         """
-        project_name = project_name or get_env_project_name()
+        if kwargs.pop("project_name", None) is not None:
+            print("Keyword argument `project_name` is no longer necessary and is ignored.")
+        if kwargs:
+            raise TypeError(f"Unexpected keyword arguments: {', '.join(kwargs)}")
         for evaluation in evals:
             table = evaluation.to_pyarrow_table()
             sink = pa.BufferOutputStream()
             headers = {"content-type": "application/x-pandas-arrow"}
-            if project_name:
-                headers["project-name"] = project_name
             with pa.ipc.new_stream(sink, table.schema) as writer:
                 writer.write_table(table)
             self._session.post(

phoenix/session/data_extractor.py

@@ -8,6 +8,8 @@ from phoenix.trace import Evaluations
 from phoenix.trace.dsl import SpanQuery
 from phoenix.trace.trace_dataset import TraceDataset
 
+DEFAULT_SPAN_LIMIT = 1000
+
 
 class TraceDataExtractor(ABC):
     """
@@ -20,7 +22,8 @@ class TraceDataExtractor(ABC):
         self,
         *queries: SpanQuery,
         start_time: Optional[datetime] = None,
-        stop_time: Optional[datetime] = None,
+        end_time: Optional[datetime] = None,
+        limit: Optional[int] = DEFAULT_SPAN_LIMIT,
         root_spans_only: Optional[bool] = None,
         project_name: Optional[str] = None,
     ) -> Optional[Union[pd.DataFrame, List[pd.DataFrame]]]: ...
@@ -30,7 +33,8 @@ class TraceDataExtractor(ABC):
         filter_condition: Optional[str] = None,
         *,
         start_time: Optional[datetime] = None,
-        stop_time: Optional[datetime] = None,
+        end_time: Optional[datetime] = None,
+        limit: Optional[int] = DEFAULT_SPAN_LIMIT,
         root_spans_only: Optional[bool] = None,
         project_name: Optional[str] = None,
     ) -> Optional[pd.DataFrame]:
@@ -39,7 +43,8 @@ class TraceDataExtractor(ABC):
             self.query_spans(
                 SpanQuery().where(filter_condition or ""),
                 start_time=start_time,
-                stop_time=stop_time,
+                end_time=end_time,
+                limit=limit,
                 root_spans_only=root_spans_only,
                 project_name=project_name,
             ),