arize-phoenix 4.28.1__py3-none-any.whl → 4.29.0__py3-none-any.whl

{arize_phoenix-4.28.1.dist-info → arize_phoenix-4.29.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: arize-phoenix
-Version: 4.28.1
+Version: 4.29.0
 Summary: AI Observability and Evaluation
 Project-URL: Documentation, https://docs.arize.com/phoenix/
 Project-URL: Issues, https://github.com/Arize-ai/phoenix/issues
@@ -21,6 +21,7 @@ Requires-Dist: aioitertools
 Requires-Dist: aiosqlite
 Requires-Dist: alembic<2,>=1.3.0
 Requires-Dist: arize-phoenix-evals>=0.13.1
+Requires-Dist: arize-phoenix-otel>=0.4.1
 Requires-Dist: cachetools
 Requires-Dist: fastapi
 Requires-Dist: grpcio

{arize_phoenix-4.28.1.dist-info → arize_phoenix-4.29.0.dist-info}/RECORD

@@ -6,7 +6,7 @@ phoenix/exceptions.py,sha256=n2L2KKuecrdflB9MsCdAYCiSEvGJptIsfRkXMoJle7A,169
 phoenix/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 phoenix/services.py,sha256=OyML4t2XGnlqF0JXA9_uccL8HslTABxep9Ci7MViKEU,5216
 phoenix/settings.py,sha256=cO-qgis_S27nHirTobYI9hHPfZH18R--WMmxNdsVUwc,273
-phoenix/version.py,sha256=Jx45Ra5pNxAdns6eybNAM7MCr8Ahz7F-CtwNB93XmFE,23
+phoenix/version.py,sha256=i2svGkhQxPKAQeMjtRMY-YcR__KOdErWKzax-PEH1rY,23
 phoenix/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 phoenix/core/embedding_dimension.py,sha256=zKGbcvwOXgLf-yrJBpQyKtd-LEOPRKHnUToyAU8Owis,87
 phoenix/core/model.py,sha256=km_a--PBHOuA337ClRw9xqhOHhrUT6Rl9pz_zV0JYkQ,4843
@@ -63,6 +63,9 @@ phoenix/metrics/mixins.py,sha256=moZ5hENIKzUQt2IRhWOd5EFXnoqQkVrpqEqMH7KQzyA,744
 phoenix/metrics/retrieval_metrics.py,sha256=XFQPo66h16w7-1AJ92M1VL_BUIXIWxXHGKF_QVOABZI,4384
 phoenix/metrics/timeseries.py,sha256=Cib3E0njJzi0vZpmyADvbakFQA98rIkfDaYAOmsmBz8,6277
 phoenix/metrics/wrappers.py,sha256=umZqa_5lf1wZSFe3FgzxF-qp1xbPdKD54W628GlGCUI,8392
+phoenix/otel/__init__.py,sha256=YvEiD-3aGZs9agwLNCXU34ofV3G-Q-dolfsiinOJuT0,407
+phoenix/otel/otel.py,sha256=6tlr7VHdVzykQ3Pu5VjvDcjUBKG6GV5fJVZCluXi_d0,11793
+phoenix/otel/settings.py,sha256=Qr2-RkgLQRfLhJqtLpEkSpqns7qLjPoOvpEOTqeSohM,3026
 phoenix/pointcloud/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 phoenix/pointcloud/clustering.py,sha256=IzcG67kJ2hPP7pcqVmKPSL_6gKRonKdOT3bCtbTOqnk,820
 phoenix/pointcloud/pointcloud.py,sha256=4zAIkKs2xOUbchpj4XDAV-iPMXrfAJ15TG6rlIYGrao,2145
@@ -80,14 +83,15 @@ phoenix/server/thread_server.py,sha256=RwXQGP_QhGD7le6WB7xEygEEuwBl5Ck_Zo8xGIYGi
 phoenix/server/types.py,sha256=S2dReLNboR2nzjRK5j3MUyUDqu6AQFD7KRwJkeKj1q4,3609
 phoenix/server/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 phoenix/server/api/context.py,sha256=WuhGT2549C5Yc7pWj2S7NaPeT4a-N-_mmz-Vg5bUkI8,3637
+phoenix/server/api/exceptions.py,sha256=KdAzgwNan-wQ7THDrSoeJU2k9zWQVcH6lRiB462VsRA,990
 phoenix/server/api/interceptor.py,sha256=ykDnoC_apUd-llVli3m1CW18kNSIgjz2qZ6m5JmPDu8,1294
-phoenix/server/api/queries.py,sha256=GXQzz1KmRqZCOENemdgoqBlTVA_4V2AZE-g0hBcO0Qk,23839
-phoenix/server/api/schema.py,sha256=BcxdqO5CSGqpKd-AAJHMjFlzaK9oJA8GJuxmMfcdjn4,434
+phoenix/server/api/queries.py,sha256=hUzeHOUWuBQ-kjXh13-d5LgJfkbB8XSpFaHJX4YXpC8,23875
+phoenix/server/api/schema.py,sha256=4L2m6QXhaV13YPTZCEZ3hqCPQFHZOy3QnJVLRYQFzpg,548
 phoenix/server/api/utils.py,sha256=Kl47G-1A7QKTDrc75BU2QK6HupsG6MWuXxy351FOfKQ,858
 phoenix/server/api/dataloaders/__init__.py,sha256=TrOGnU_SD_vEIxOE_dm8HrD5C2ScLFQ4xQ7f8r-E76s,3064
 phoenix/server/api/dataloaders/annotation_summaries.py,sha256=Wv8AORZoGd5TJ4Y-em8iqJu87AMpZP7lWOTr-SML-x8,5560
 phoenix/server/api/dataloaders/average_experiment_run_latency.py,sha256=q091UmkXx37OBKh7L-GJ5LXHyRXfX2w4XTk1NMHtPpw,1827
-phoenix/server/api/dataloaders/dataset_example_revisions.py,sha256=i0g8F4akEf3kQOzAvBjO27QwXNsq-kJEM8dtzduxQgY,3720
+phoenix/server/api/dataloaders/dataset_example_revisions.py,sha256=rZhJoIYUGgYhXwVBtq5u0bqtHmIQ2Sh6HNnJsSGIXis,3767
 phoenix/server/api/dataloaders/dataset_example_spans.py,sha256=-TjdyyJv2c2JiN1OXu6MMmQ-BEKlHXucEDcuObeRVsU,1416
 phoenix/server/api/dataloaders/document_evaluation_summaries.py,sha256=5XOom2KRAmCwPmtlraiZOSl3vhfaW-eiiYkmetAEalw,5616
 phoenix/server/api/dataloaders/document_evaluations.py,sha256=V6sE34jON_qFxt7eArJbktykAsty-gnBZHlEkORcj0E,1296
@@ -140,11 +144,11 @@ phoenix/server/api/input_types/TraceAnnotationSort.py,sha256=BzwiUnMh2VsgQYnhDlb
 phoenix/server/api/input_types/UserRoleInput.py,sha256=xxhFe0ITZOgRVEJbVem_W6F1Ip_H6xDENdQqMMx-kKE,129
 phoenix/server/api/input_types/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 phoenix/server/api/mutations/__init__.py,sha256=JS3WRqYxNeoaLsKjODFvJnZb6CF19IFW-lfOsUq3rtM,1074
-phoenix/server/api/mutations/api_key_mutations.py,sha256=cv6AT6UAL55lTC_UqMdcN-1TjWAgqqZi__S9Tw12t6I,3688
+phoenix/server/api/mutations/api_key_mutations.py,sha256=5GDsP0gURgXokbajc3GJEor3AGt6BGd1IMWMg054E7U,4683
 phoenix/server/api/mutations/auth.py,sha256=8o4tTfGCPkpUauuB9ijPH84Od77UX_UrQWfmUsnujI4,524
-phoenix/server/api/mutations/auth_mutations.py,sha256=6--KYnvY3k9JC70Z7iHWhrEa9xKjGH1sW-iOtC13Oxw,2041
-phoenix/server/api/mutations/dataset_mutations.py,sha256=0feBUW_07FEIx6uzepjxfRVhk5lAck0AkrqS1GVdoF4,27041
-phoenix/server/api/mutations/experiment_mutations.py,sha256=OXtLYdLA33RGy1MFctfv6ug2sODcDElhJph_J9vkIjk,3157
+phoenix/server/api/mutations/auth_mutations.py,sha256=XLCxmsjyVp1riGWxUhVUOiGhIFs_ZmOfZM77vs_RLDw,2182
+phoenix/server/api/mutations/dataset_mutations.py,sha256=8S6qjmraSBxA7ioNogTQPp6q27ZdvdAn6yt0Z4fmOI0,27096
+phoenix/server/api/mutations/experiment_mutations.py,sha256=Z2xPrK8J117l5XWN-IvdKpykWIiVXysaUhzuwbIiLtk,3226
 phoenix/server/api/mutations/export_events_mutations.py,sha256=t_wYBxaqvBJYRoHslh3Bmoxmwlzoy0u8SsBKWIKN5hE,4028
 phoenix/server/api/mutations/project_mutations.py,sha256=MLm7I97lJ85hTuc1tq8sdYA8Ps5WKMV-bGqeeN-Ey90,2279
 phoenix/server/api/mutations/span_annotations_mutations.py,sha256=DM9gzxrMSAcxwXQ6jNaNGDVgl8oP50LZsBWRYQwLaSo,5955
@@ -160,7 +164,7 @@ phoenix/server/api/routers/v1/datasets.py,sha256=l3Hlc9AVyvX5GdT9iOXBsV-i4c_vtnC
 phoenix/server/api/routers/v1/evaluations.py,sha256=FSfz9MTi8s65F07abDXlb9-y97fDZSYbqsCXpimwO7g,12628
 phoenix/server/api/routers/v1/experiment_evaluations.py,sha256=RTQnjupjmh07xowjq77ajbuAZhzIEfYxA4ZtECvGwOU,4844
 phoenix/server/api/routers/v1/experiment_runs.py,sha256=0G7GgGcZv9dzK47tsPp-p4k5O7W4F_aNRrsNuJN7mho,6393
-phoenix/server/api/routers/v1/experiments.py,sha256=3u275sGuYSiMyzC_obbjK3mf6aYb7SkY2c_wOg3z4xg,11751
+phoenix/server/api/routers/v1/experiments.py,sha256=6Ouby3jQDZjeb_nJoD5eH8h2jxINBLrHzCPMsklzcJI,11820
 phoenix/server/api/routers/v1/pydantic_compat.py,sha256=FeK8oe2brqu-djsoqRxiKL4tw5cHmi89OHVfCFxYsAo,2890
 phoenix/server/api/routers/v1/spans.py,sha256=MAkMLrONFtItQxkHJde_Wpvz0jsgydegxVZOkZkRUsU,8781
 phoenix/server/api/routers/v1/traces.py,sha256=HJDmYKMATL40dZEJro6uQ3imbCZBzk3nUun9d21jcDs,7799
@@ -291,8 +295,8 @@ phoenix/utilities/logging.py,sha256=lDXd6EGaamBNcQxL4vP1au9-i_SXe0OraUDiJOcszSw,
 phoenix/utilities/project.py,sha256=8IJuMM4yUMoooPi37sictGj8Etu9rGmq6RFtc9848cQ,436
 phoenix/utilities/re.py,sha256=PDve_OLjRTM8yQQJHC8-n3HdIONi7aNils3ZKRZ5uBM,2045
 phoenix/utilities/span_store.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-arize_phoenix-4.28.1.dist-info/METADATA,sha256=YRglZu4_XOWN3jc_U8mD8QkVN5m1t6me2zuhNiw5iFk,11936
-arize_phoenix-4.28.1.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-arize_phoenix-4.28.1.dist-info/licenses/IP_NOTICE,sha256=JBqyyCYYxGDfzQ0TtsQgjts41IJoa-hiwDrBjCb9gHM,469
-arize_phoenix-4.28.1.dist-info/licenses/LICENSE,sha256=HFkW9REuMOkvKRACuwLPT0hRydHb3zNg-fdFt94td18,3794
-arize_phoenix-4.28.1.dist-info/RECORD,,
+arize_phoenix-4.29.0.dist-info/METADATA,sha256=UJiskTOjTLRjXDFO41I1ioPp3KZDU2nmgqMucGUyuAI,11977
+arize_phoenix-4.29.0.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+arize_phoenix-4.29.0.dist-info/licenses/IP_NOTICE,sha256=JBqyyCYYxGDfzQ0TtsQgjts41IJoa-hiwDrBjCb9gHM,469
+arize_phoenix-4.29.0.dist-info/licenses/LICENSE,sha256=HFkW9REuMOkvKRACuwLPT0hRydHb3zNg-fdFt94td18,3794
+arize_phoenix-4.29.0.dist-info/RECORD,,

phoenix/otel/__init__.py

@@ -0,0 +1,22 @@
+from opentelemetry.sdk.resources import Resource
+
+from .otel import (
+    PROJECT_NAME,
+    BatchSpanProcessor,
+    GRPCSpanExporter,
+    HTTPSpanExporter,
+    SimpleSpanProcessor,
+    TracerProvider,
+    register,
+)
+
+__all__ = [
+    "TracerProvider",
+    "SimpleSpanProcessor",
+    "BatchSpanProcessor",
+    "HTTPSpanExporter",
+    "GRPCSpanExporter",
+    "Resource",
+    "PROJECT_NAME",
+    "register",
+]

phoenix/otel/otel.py

@@ -0,0 +1,284 @@
+import inspect
+import os
+import warnings
+from typing import Any, Dict, List, Optional, Tuple, Union, cast
+from urllib.parse import ParseResult, urlparse
+
+from openinference.semconv.resource import ResourceAttributes as _ResourceAttributes
+from opentelemetry import trace as trace_api
+from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import (
+    OTLPSpanExporter as _GRPCSpanExporter,
+)
+from opentelemetry.exporter.otlp.proto.http.trace_exporter import (
+    OTLPSpanExporter as _HTTPSpanExporter,
+)
+from opentelemetry.sdk.resources import Resource
+from opentelemetry.sdk.trace import SpanProcessor
+from opentelemetry.sdk.trace import TracerProvider as _TracerProvider
+from opentelemetry.sdk.trace.export import BatchSpanProcessor as _BatchSpanProcessor
+from opentelemetry.sdk.trace.export import SimpleSpanProcessor as _SimpleSpanProcessor
+from opentelemetry.sdk.trace.export import SpanExporter
+
+from .settings import get_env_client_headers, get_env_collector_endpoint, get_env_project_name
+
+PROJECT_NAME = _ResourceAttributes.PROJECT_NAME
+
+_DEFAULT_GRPC_PORT = 4317
+
+
+def register(
+    *,
+    endpoint: Optional[str] = None,
+    project_name: Optional[str] = None,
+    batch: bool = False,
+    set_global_tracer: bool = True,
+    headers: Optional[Dict[str, str]] = None,
+    verbose: bool = True,
+) -> _TracerProvider:
+    """
+    Creates an OpenTelemetry TracerProvider for enabling OpenInference tracing.
+
+    For futher configuration, the `phoenix.otel` module provides drop-in replacements for
+    OpenTelemetry TracerProvider, SimpleSpanProcessor, BatchSpanProcessor, HTTPSpanExporter, and
+    GRPCSpanExporter objects with Phoenix-aware defaults. Documentation on how to configure tracing
+    can be found at https://opentelemetry.io/docs/specs/otel/trace/sdk/.
+
+    Args:
+        endpoint (str, optional): The collector endpoint to which spans will be exported. If not
+            provided, the `PHOENIX_OTEL_COLLECTOR_ENDPOINT` environment variable will be used. The
+            export protocol will be inferred from the endpoint.
+        project_name (str, optional): The name of the project to which spans will be associated. If
+            not provided, the `PHOENIX_PROJECT_NAME` environment variable will be used.
+        batch (bool): If True, spans will be processed using a BatchSpanprocessor. If False, spans
+            will be processed one at a time using a SimpleSpanProcessor.
+        set_global_tracer (bool): If False, the TracerProvider will not be set as the global
+            tracer provider. Defaults to True.
+        headers (dict, optional): Optional headers to include in the HTTP request to the collector.
+        verbose (bool): If True, configuration details will be printed to stdout.
+    """
+
+    project_name = project_name or get_env_project_name()
+    resource = Resource.create({PROJECT_NAME: project_name})
+    tracer_provider = TracerProvider(resource=resource, verbose=False)
+    span_processor: SpanProcessor
+    if batch:
+        span_processor = BatchSpanProcessor(endpoint=endpoint, headers=headers)
+    else:
+        span_processor = SimpleSpanProcessor(endpoint=endpoint, headers=headers)
+    tracer_provider.add_span_processor(span_processor)
+    tracer_provider._default_processor = True
+
+    if set_global_tracer:
+        trace_api.set_tracer_provider(tracer_provider)
+        global_provider_msg = (
+            "|  \n"
+            "|  `register` has set this TracerProvider as the global OpenTelemetry default.\n"
+            "|  To disable this behavior, call `register` with `set_global_tracer=False`.\n"
+        )
+    else:
+        global_provider_msg = ""
+
+    details = tracer_provider._tracing_details()
+    if verbose:
+        print(f"{details}" f"{global_provider_msg}")
+    return tracer_provider
+
+
+class TracerProvider(_TracerProvider):
+    def __init__(
+        self, *args: Any, endpoint: Optional[str] = None, verbose: bool = True, **kwargs: Any
+    ):
+        sig = inspect.signature(_TracerProvider)
+        bound_args = sig.bind_partial(*args, **kwargs)
+        bound_args.apply_defaults()
+        if bound_args.arguments.get("resource") is None:
+            bound_args.arguments["resource"] = Resource.create(
+                {PROJECT_NAME: get_env_project_name()}
+            )
+        super().__init__(**bound_args.arguments)
+
+        parsed_url, endpoint = _normalized_endpoint(endpoint)
+        self._default_processor = False
+
+        if _maybe_http_endpoint(parsed_url):
+            http_exporter: SpanExporter = HTTPSpanExporter(endpoint=endpoint)
+            self.add_span_processor(SimpleSpanProcessor(span_exporter=http_exporter))
+            self._default_processor = True
+        elif _maybe_grpc_endpoint(parsed_url):
+            grpc_exporter: SpanExporter = GRPCSpanExporter(endpoint=endpoint)
+            self.add_span_processor(SimpleSpanProcessor(span_exporter=grpc_exporter))
+            self._default_processor = True
+        if verbose:
+            print(self._tracing_details())
+
+    def add_span_processor(self, *args: Any, **kwargs: Any) -> None:
+        if self._default_processor:
+            self._active_span_processor.shutdown()
+            self._active_span_processor._span_processors = tuple()  # remove default processors
+            self._default_processor = False
+        return super().add_span_processor(*args, **kwargs)
+
+    def _tracing_details(self) -> str:
+        project = self.resource.attributes.get(PROJECT_NAME)
+        processor_name: Optional[str] = None
+        endpoint: Optional[str] = None
+        transport: Optional[str] = None
+        headers: Optional[Union[Dict[str, str], str]] = None
+
+        if self._active_span_processor:
+            if processors := self._active_span_processor._span_processors:
+                if len(processors) == 1:
+                    span_processor = self._active_span_processor._span_processors[0]
+                    if exporter := getattr(span_processor, "span_exporter"):
+                        processor_name = span_processor.__class__.__name__
+                        endpoint = exporter._endpoint
+                        transport = _exporter_transport(exporter)
+                        headers = _printable_headers(exporter._headers)
+                else:
+                    processor_name = "Multiple Span Processors"
+                    endpoint = "Multiple Span Exporters"
+                    transport = "Multiple Span Exporters"
+                    headers = "Multiple Span Exporters"
+
+        if os.name == "nt":
+            details_header = "OpenTelemetry Tracing Details"
+        else:
+            details_header = "🔭 OpenTelemetry Tracing Details 🔭"
+
+        configuration_msg = (
+            "|  Using a default SpanProcessor. `add_span_processor` will overwrite this default.\n"
+        )
+
+        details_msg = (
+            f"{details_header}\n"
+            f"|  Phoenix Project: {project}\n"
+            f"|  Span Processor: {processor_name}\n"
+            f"|  Collector Endpoint: {endpoint}\n"
+            f"|  Transport: {transport}\n"
+            f"|  Transport Headers: {headers}\n"
+            "|  \n"
+            f"{configuration_msg if self._default_processor else ''}"
+        )
+        return details_msg
+
+
+class SimpleSpanProcessor(_SimpleSpanProcessor):
+    def __init__(
+        self,
+        span_exporter: Optional[SpanExporter] = None,
+        endpoint: Optional[str] = None,
+        headers: Optional[Dict[str, str]] = None,
+    ):
+        if span_exporter is None:
+            parsed_url, endpoint = _normalized_endpoint(endpoint)
+            if _maybe_http_endpoint(parsed_url):
+                span_exporter = HTTPSpanExporter(endpoint=endpoint, headers=headers)
+            elif _maybe_grpc_endpoint(parsed_url):
+                span_exporter = GRPCSpanExporter(endpoint=endpoint, headers=headers)
+            else:
+                warnings.warn("Could not infer collector endpoint protocol, defaulting to HTTP.")
+                span_exporter = HTTPSpanExporter(endpoint=endpoint, headers=headers)
+        super().__init__(span_exporter)
+
+
+class BatchSpanProcessor(_BatchSpanProcessor):
+    def __init__(
+        self,
+        span_exporter: Optional[SpanExporter] = None,
+        endpoint: Optional[str] = None,
+        headers: Optional[Dict[str, str]] = None,
+    ):
+        if span_exporter is None:
+            parsed_url, endpoint = _normalized_endpoint(endpoint)
+            if _maybe_http_endpoint(parsed_url):
+                span_exporter = HTTPSpanExporter(endpoint=endpoint, headers=headers)
+            elif _maybe_grpc_endpoint(parsed_url):
+                span_exporter = GRPCSpanExporter(endpoint=endpoint, headers=headers)
+            else:
+                warnings.warn("Could not infer collector endpoint protocol, defaulting to HTTP.")
+                span_exporter = HTTPSpanExporter(endpoint=endpoint, headers=headers)
+        super().__init__(span_exporter)
+
+
+class HTTPSpanExporter(_HTTPSpanExporter):
+    def __init__(self, *args: Any, **kwargs: Any):
+        sig = inspect.signature(_HTTPSpanExporter)
+        bound_args = sig.bind_partial(*args, **kwargs)
+        bound_args.apply_defaults()
+
+        if not bound_args.arguments.get("headers"):
+            bound_args.arguments["headers"] = get_env_client_headers()
+
+        if bound_args.arguments.get("endpoint") is None:
+            _, endpoint = _normalized_endpoint(None)
+            bound_args.arguments["endpoint"] = endpoint
+        super().__init__(**bound_args.arguments)
+
+
+class GRPCSpanExporter(_GRPCSpanExporter):
+    def __init__(self, *args: Any, **kwargs: Any):
+        sig = inspect.signature(_GRPCSpanExporter)
+        bound_args = sig.bind_partial(*args, **kwargs)
+        bound_args.apply_defaults()
+
+        if not bound_args.arguments.get("headers"):
+            bound_args.arguments["headers"] = get_env_client_headers()
+
+        if bound_args.arguments.get("endpoint") is None:
+            _, endpoint = _normalized_endpoint(None)
+            bound_args.arguments["endpoint"] = endpoint
+        super().__init__(**bound_args.arguments)
+
+
+def _maybe_http_endpoint(parsed_endpoint: ParseResult) -> bool:
+    if parsed_endpoint.path == "/v1/traces":
+        return True
+    return False
+
+
+def _maybe_grpc_endpoint(parsed_endpoint: ParseResult) -> bool:
+    if not parsed_endpoint.path and parsed_endpoint.port == 4317:
+        return True
+    return False
+
+
+def _exporter_transport(exporter: SpanExporter) -> str:
+    if isinstance(exporter, _HTTPSpanExporter):
+        return "HTTP"
+    if isinstance(exporter, _GRPCSpanExporter):
+        return "gRPC"
+    else:
+        return exporter.__class__.__name__
+
+
+def _printable_headers(headers: Union[List[Tuple[str, str]], Dict[str, str]]) -> Dict[str, str]:
+    if isinstance(headers, dict):
+        return {key.lower(): "****" for key, _ in headers.items()}
+    return {key.lower(): "****" for key, _ in headers}
+
+
+def _construct_http_endpoint(parsed_endpoint: ParseResult) -> ParseResult:
+    return parsed_endpoint._replace(path="/v1/traces")
+
+
+def _construct_grpc_endpoint(parsed_endpoint: ParseResult) -> ParseResult:
+    return parsed_endpoint._replace(netloc=f"{parsed_endpoint.hostname}:{_DEFAULT_GRPC_PORT}")
+
+
+_KNOWN_PROVIDERS = {
+    "app.phoenix.arize.com": _construct_http_endpoint,
+}
+
+
+def _normalized_endpoint(endpoint: Optional[str]) -> Tuple[ParseResult, str]:
+    if endpoint is None:
+        base_endpoint = get_env_collector_endpoint() or "http://localhost:6006"
+        parsed = urlparse(base_endpoint)
+        if parsed.hostname in _KNOWN_PROVIDERS:
+            parsed = _KNOWN_PROVIDERS[parsed.hostname](parsed)
+        else:
+            parsed = _construct_grpc_endpoint(parsed)
+    else:
+        parsed = urlparse(endpoint)
+    parsed = cast(ParseResult, parsed)
+    return parsed, parsed.geturl()

phoenix/otel/settings.py

@@ -0,0 +1,82 @@
+import os
+import urllib
+from logging import getLogger
+from re import compile
+from typing import Dict, List, Optional
+
+_logger = getLogger(__name__)
+
+# Environment variables specific to the subpackage
+ENV_PHOENIX_COLLECTOR_ENDPOINT = "PHOENIX_COLLECTOR_ENDPOINT"
+ENV_PHOENIX_PROJECT_NAME = "PHOENIX_PROJECT_NAME"
+ENV_PHOENIX_CLIENT_HEADERS = "PHOENIX_CLIENT_HEADERS"
+
+
+def get_env_collector_endpoint() -> Optional[str]:
+    return os.getenv(ENV_PHOENIX_COLLECTOR_ENDPOINT)
+
+
+def get_env_project_name() -> str:
+    return os.getenv(ENV_PHOENIX_PROJECT_NAME, "default")
+
+
+def get_env_client_headers() -> Optional[Dict[str, str]]:
+    if headers_str := os.getenv(ENV_PHOENIX_CLIENT_HEADERS):
+        return parse_env_headers(headers_str)
+    return None
+
+
+# Optional whitespace
+_OWS = r"[ \t]*"
+# A key contains printable US-ASCII characters except: SP and "(),/:;<=>?@[\]{}
+_KEY_FORMAT = r"[\x21\x23-\x27\x2a\x2b\x2d\x2e\x30-\x39\x41-\x5a\x5e-\x7a\x7c\x7e]+"
+# A value contains a URL-encoded UTF-8 string. The encoded form can contain any
+# printable US-ASCII characters (0x20-0x7f) other than SP, DEL, and ",;/
+_VALUE_FORMAT = r"[\x21\x23-\x2b\x2d-\x3a\x3c-\x5b\x5d-\x7e]*"
+# A key-value is key=value, with optional whitespace surrounding key and value
+_KEY_VALUE_FORMAT = rf"{_OWS}{_KEY_FORMAT}{_OWS}={_OWS}{_VALUE_FORMAT}{_OWS}"
+
+_HEADER_PATTERN = compile(_KEY_VALUE_FORMAT)
+_DELIMITER_PATTERN = compile(r"[ \t]*,[ \t]*")
+
+
+def parse_env_headers(s: str) -> Dict[str, str]:
+    """
+    Parse ``s``, which is a ``str`` instance containing HTTP headers encoded
+    for use in ENV variables per the W3C Baggage HTTP header format at
+    https://www.w3.org/TR/baggage/#baggage-http-header-format, except that
+    additional semi-colon delimited metadata is not supported.
+
+    If the headers are not urlencoded, we will log a warning and attempt to urldecode them.
+    """
+    headers: Dict[str, str] = {}
+    headers_list: List[str] = _DELIMITER_PATTERN.split(s)
+
+    for header in headers_list:
+        if not header:  # empty string
+            continue
+
+        match = _HEADER_PATTERN.fullmatch(header.strip())
+        if not match:
+            parts = header.split("=", 1)
+            name, value = parts
+            encoded_header = f"{urllib.parse.quote(name)}={urllib.parse.quote(value)}"
+            match = _HEADER_PATTERN.fullmatch(encoded_header.strip())
+            if not match:
+                _logger.warning(
+                    "Header format invalid! Header values in environment variables must be "
+                    "URL encoded: %s",
+                    f"{name}: ****",
+                )
+                continue
+            _logger.warning(
+                "Header values in environment variables should be URL encoded, attempting to "
+                "URL encode header: {name}: ****"
+            )
+
+        name, value = header.split("=", 1)
+        name = urllib.parse.unquote(name).strip().lower()
+        value = urllib.parse.unquote(value).strip()
+        headers[name] = value
+
+    return headers

phoenix/server/api/dataloaders/dataset_example_revisions.py

@@ -10,6 +10,7 @@ from strawberry.dataloader import DataLoader
 from typing_extensions import TypeAlias
 
 from phoenix.db import models
+from phoenix.server.api.exceptions import NotFound
 from phoenix.server.api.types.DatasetExampleRevision import DatasetExampleRevision
 from phoenix.server.types import DbSessionFactory
 
@@ -24,7 +25,7 @@ class DatasetExampleRevisionsDataLoader(DataLoader[Key, Result]):
         super().__init__(load_fn=self._load_fn)
         self._db = db
 
-    async def _load_fn(self, keys: List[Key]) -> List[Union[Result, ValueError]]:
+    async def _load_fn(self, keys: List[Key]) -> List[Union[Result, NotFound]]:
         # sqlalchemy has limited SQLite support for VALUES, so use UNION ALL instead.
         # For details, see https://github.com/sqlalchemy/sqlalchemy/issues/7228
         keys_subquery = union(
@@ -95,4 +96,4 @@ class DatasetExampleRevisionsDataLoader(DataLoader[Key, Result]):
                 ) in await session.stream(query)
                 if is_valid_version
             }
-        return [results.get(key, ValueError("Could not find revision.")) for key in keys]
+        return [results.get(key, NotFound("Could not find revision.")) for key in keys]

phoenix/server/api/exceptions.py

@@ -0,0 +1,41 @@
+from graphql.error import GraphQLError
+from strawberry.extensions import MaskErrors
+
+
+class CustomGraphQLError(Exception):
+    """
+    An error that represents an expected error scenario in a GraphQL resolver.
+    """
+
+
+class BadRequest(CustomGraphQLError):
+    """
+    An error raised due to a malformed or invalid request.
+    """
+
+
+class NotFound(CustomGraphQLError):
+    """
+    An error raised when the requested resource is not found.
+    """
+
+
+class Unauthorized(CustomGraphQLError):
+    """
+    An error raised when login fails or a user or other entity is not authorized
+    to access a resource.
+    """
+
+
+def get_mask_errors_extension() -> MaskErrors:
+    return MaskErrors(
+        should_mask_error=_should_mask_error,
+        error_message="an unexpected error occurred",
+    )
+
+
+def _should_mask_error(error: GraphQLError) -> bool:
+    """
+    Masks unexpected errors raised from GraphQL resolvers.
+    """
+    return not isinstance(error.original_error, CustomGraphQLError)

phoenix/server/api/mutations/api_key_mutations.py

@@ -5,12 +5,15 @@ import jwt
 import strawberry
 from sqlalchemy import insert, select
 from strawberry import UNSET
+from strawberry.relay import GlobalID
 from strawberry.types import Info
 
 from phoenix.db import models
 from phoenix.server.api.context import Context
+from phoenix.server.api.exceptions import NotFound
 from phoenix.server.api.mutations.auth import HasSecret, IsAuthenticated
 from phoenix.server.api.queries import Query
+from phoenix.server.api.types.node import from_global_id_with_expected_type
 from phoenix.server.api.types.SystemApiKey import SystemApiKey
 
 
@@ -28,6 +31,16 @@ class CreateApiKeyInput:
     expires_at: Optional[datetime] = UNSET
 
 
+@strawberry.input
+class DeleteApiKeyInput:
+    id: GlobalID
+
+
+@strawberry.type
+class DeleteSystemApiKeyMutationPayload:
+    id: GlobalID
+
+
 @strawberry.type
 class ApiKeyMutationMixin:
     @strawberry.mutation(permission_classes=[HasSecret, IsAuthenticated])  # type: ignore
@@ -79,6 +92,22 @@ class ApiKeyMutationMixin:
             query=Query(),
         )
 
+    @strawberry.mutation(permission_classes=[HasSecret, IsAuthenticated])  # type: ignore
+    async def delete_system_api_key(
+        self, info: Info[Context, None], input: DeleteApiKeyInput
+    ) -> DeleteSystemApiKeyMutationPayload:
+        api_key_id = from_global_id_with_expected_type(
+            input.id, expected_type_name=SystemApiKey.__name__
+        )
+        async with info.context.db() as session:
+            api_key = await session.get(models.APIKey, api_key_id)
+            if api_key is None:
+                raise NotFound(f"Unknown System API Key: {input.id}")
+
+            await session.delete(api_key)
+
+        return DeleteSystemApiKeyMutationPayload(id=input.id)
+
 
 def create_jwt(
     *,

phoenix/server/api/mutations/auth_mutations.py

@@ -8,10 +8,12 @@ from strawberry.types import Info
 from phoenix.auth import is_valid_password
 from phoenix.db import models
 from phoenix.server.api.context import Context
+from phoenix.server.api.exceptions import Unauthorized
 from phoenix.server.api.mutations.auth import HasSecret
 
 PHOENIX_ACCESS_TOKEN_COOKIE_NAME = "phoenix-access-token"
 PHOENIX_ACCESS_TOKEN_COOKIE_MAX_AGE_IN_SECONDS = int(timedelta(days=31).total_seconds())
+FAILED_LOGIN_MESSAGE = "login failed"
 
 
 @strawberry.input
@@ -34,7 +36,7 @@ class AuthMutationMixin:
                     select(models.User).where(models.User.email == input.email)
                 )
             ) is None or (password_hash := user.password_hash) is None:
-                raise ValueError
+                raise Unauthorized(FAILED_LOGIN_MESSAGE)
         secret = info.context.get_secret()
         loop = asyncio.get_running_loop()
         if not await loop.run_in_executor(
@@ -43,7 +45,7 @@ class AuthMutationMixin:
                 password=input.password, salt=secret, password_hash=password_hash
             ),
         ):
-            raise ValueError
+            raise Unauthorized(FAILED_LOGIN_MESSAGE)
         response = info.context.get_response()
         response.set_cookie(
             key=PHOENIX_ACCESS_TOKEN_COOKIE_NAME,

phoenix/server/api/mutations/dataset_mutations.py

@@ -13,6 +13,7 @@ from strawberry.types import Info
 from phoenix.db import models
 from phoenix.db.helpers import get_eval_trace_ids_for_datasets, get_project_names_for_datasets
 from phoenix.server.api.context import Context
+from phoenix.server.api.exceptions import BadRequest, NotFound
 from phoenix.server.api.helpers.dataset_helpers import (
     get_dataset_example_input,
     get_dataset_example_output,
@@ -362,7 +363,7 @@ class DatasetMutationMixin:
                 expected_type_name=Dataset.__name__,
             )
         except ValueError:
-            raise ValueError(f"Unknown dataset: {input.dataset_id}")
+            raise NotFound(f"Unknown dataset: {input.dataset_id}")
         project_names_stmt = get_project_names_for_datasets(dataset_id)
         eval_trace_ids_stmt = get_eval_trace_ids_for_datasets(dataset_id)
         stmt = (
@@ -372,7 +373,7 @@ class DatasetMutationMixin:
             project_names = await session.scalars(project_names_stmt)
             eval_trace_ids = await session.scalars(eval_trace_ids_stmt)
             if not (dataset := await session.scalar(stmt)):
-                raise ValueError(f"Unknown dataset: {input.dataset_id}")
+                raise NotFound(f"Unknown dataset: {input.dataset_id}")
         await asyncio.gather(
             delete_projects(info.context.db, *project_names),
             delete_traces(info.context.db, *eval_trace_ids),
@@ -388,7 +389,7 @@ class DatasetMutationMixin:
         input: PatchDatasetExamplesInput,
     ) -> DatasetMutationPayload:
         if not (patches := input.patches):
-            raise ValueError("Must provide examples to patch.")
+            raise BadRequest("Must provide examples to patch.")
         by_numeric_id = [
             (
                 from_global_id_with_expected_type(patch.example_id, DatasetExample.__name__),
@@ -399,9 +400,9 @@ class DatasetMutationMixin:
         ]
         example_ids, _, patches = map(list, zip(*sorted(by_numeric_id)))
         if len(set(example_ids)) < len(example_ids):
-            raise ValueError("Cannot patch the same example more than once per mutation.")
+            raise BadRequest("Cannot patch the same example more than once per mutation.")
         if any(patch.is_empty() for patch in patches):
-            raise ValueError("Received one or more empty patches that contain no fields to update.")
+            raise BadRequest("Received one or more empty patches that contain no fields to update.")
         version_description = input.version_description or None
         version_metadata = input.version_metadata
         async with info.context.db() as session:
@@ -419,9 +420,9 @@ class DatasetMutationMixin:
                 )
             ).all()
             if not datasets:
-                raise ValueError("No examples found.")
+                raise NotFound("No examples found.")
             if len(set(ds.id for ds in datasets)) > 1:
-                raise ValueError("Examples must come from the same dataset.")
+                raise BadRequest("Examples must come from the same dataset.")
             dataset = datasets[0]
 
             revision_ids = (
@@ -445,7 +446,7 @@ class DatasetMutationMixin:
                 )
             ).all()
             if (num_missing_examples := len(example_ids) - len(revisions)) > 0:
-                raise ValueError(f"{num_missing_examples} example(s) could not be found.")
+                raise NotFound(f"{num_missing_examples} example(s) could not be found.")
 
             version_id = await session.scalar(
                 insert(models.DatasetVersion)

phoenix/server/api/mutations/experiment_mutations.py

@@ -9,6 +9,7 @@ from strawberry.types import Info
 from phoenix.db import models
 from phoenix.db.helpers import get_eval_trace_ids_for_experiments, get_project_names_for_experiments
 from phoenix.server.api.context import Context
+from phoenix.server.api.exceptions import CustomGraphQLError
 from phoenix.server.api.input_types.DeleteExperimentsInput import DeleteExperimentsInput
 from phoenix.server.api.mutations.auth import IsAuthenticated
 from phoenix.server.api.types.Experiment import Experiment, to_gql_experiment
@@ -52,7 +53,7 @@ class ExperimentMutationMixin:
             }
             if unknown_experiment_ids := set(experiment_ids) - set(experiments.keys()):
                 await savepoint.rollback()
-                raise ValueError(
+                raise CustomGraphQLError(
                     "Failed to delete experiment(s), "
                     "probably due to invalid input experiment ID(s): "
                     + str(

phoenix/server/api/queries.py

@@ -33,6 +33,7 @@ from phoenix.db.models import (
 )
 from phoenix.pointcloud.clustering import Hdbscan
 from phoenix.server.api.context import Context
+from phoenix.server.api.exceptions import NotFound
 from phoenix.server.api.helpers import ensure_list
 from phoenix.server.api.input_types.ClusterInput import ClusterInput
 from phoenix.server.api.input_types.Coordinates import (
@@ -391,7 +392,7 @@ class Query:
             async with info.context.db() as session:
                 project = (await session.execute(project_stmt)).first()
             if project is None:
-                raise ValueError(f"Unknown project: {id}")
+                raise NotFound(f"Unknown project: {id}")
             return Project(
                 id_attr=project.id,
                 name=project.name,
@@ -406,7 +407,7 @@ class Query:
             async with info.context.db() as session:
                 trace = (await session.execute(trace_stmt)).first()
             if trace is None:
-                raise ValueError(f"Unknown trace: {id}")
+                raise NotFound(f"Unknown trace: {id}")
             return Trace(
                 id_attr=trace.id, trace_id=trace.trace_id, project_rowid=trace.project_rowid
             )
@@ -421,13 +422,13 @@ class Query:
             async with info.context.db() as session:
                 span = await session.scalar(span_stmt)
             if span is None:
-                raise ValueError(f"Unknown span: {id}")
+                raise NotFound(f"Unknown span: {id}")
             return to_gql_span(span)
         elif type_name == Dataset.__name__:
             dataset_stmt = select(models.Dataset).where(models.Dataset.id == node_id)
             async with info.context.db() as session:
                 if (dataset := await session.scalar(dataset_stmt)) is None:
-                    raise ValueError(f"Unknown dataset: {id}")
+                    raise NotFound(f"Unknown dataset: {id}")
             return to_gql_dataset(dataset)
         elif type_name == DatasetExample.__name__:
             example_id = node_id
@@ -453,7 +454,7 @@ class Query:
                     )
                 )
             if not example:
-                raise ValueError(f"Unknown dataset example: {id}")
+                raise NotFound(f"Unknown dataset example: {id}")
             return DatasetExample(
                 id_attr=example.id,
                 created_at=example.created_at,
@@ -464,7 +465,7 @@ class Query:
                     select(models.Experiment).where(models.Experiment.id == node_id)
                 )
             if not experiment:
-                raise ValueError(f"Unknown experiment: {id}")
+                raise NotFound(f"Unknown experiment: {id}")
             return Experiment(
                 id_attr=experiment.id,
                 name=experiment.name,
@@ -485,9 +486,9 @@ class Query:
                         )
                     )
                 ):
-                    raise ValueError(f"Unknown experiment run: {id}")
+                    raise NotFound(f"Unknown experiment run: {id}")
             return to_gql_experiment_run(run)
-        raise Exception(f"Unknown node type: {type_name}")
+        raise NotFound(f"Unknown node type: {type_name}")
 
     @strawberry.field
     def clusters(

phoenix/server/api/routers/v1/experiments.py

@@ -2,7 +2,7 @@ from datetime import datetime
 from random import getrandbits
 from typing import Any, Dict, List, Optional
 
-from fastapi import APIRouter, HTTPException
+from fastapi import APIRouter, HTTPException, Path
 from pydantic import Field
 from sqlalchemy import select
 from starlette.requests import Request
@@ -18,7 +18,7 @@ from phoenix.server.dml_event import ExperimentInsertEvent
 from .pydantic_compat import V1RoutesBaseModel
 from .utils import ResponseBody, add_errors_to_responses
 
-router = APIRouter(tags=["experiments"], include_in_schema=False)
+router = APIRouter(tags=["experiments"], include_in_schema=True)
 
 
 def _short_uuid() -> str:
@@ -90,8 +90,8 @@ class CreateExperimentResponseBody(ResponseBody[Experiment]):
 )
 async def create_experiment(
     request: Request,
-    dataset_id: str,
     request_body: CreateExperimentRequestBody,
+    dataset_id: str = Path(..., title="Dataset ID"),
 ) -> CreateExperimentResponseBody:
     dataset_globalid = GlobalID.from_id(dataset_id)
     try:
@@ -266,7 +266,7 @@ class ListExperimentsResponseBody(ResponseBody[List[Experiment]]):
 )
 async def list_experiments(
     request: Request,
-    dataset_id: str,
+    dataset_id: str = Path(..., title="Dataset ID"),
 ) -> ListExperimentsResponseBody:
     dataset_gid = GlobalID.from_id(dataset_id)
     try:

phoenix/server/api/schema.py

@@ -1,5 +1,6 @@
 import strawberry
 
+from phoenix.server.api.exceptions import get_mask_errors_extension
 from phoenix.server.api.mutations import Mutation
 from phoenix.server.api.queries import Query
 
@@ -10,4 +11,5 @@ from phoenix.server.api.queries import Query
 schema = strawberry.Schema(
     query=Query,
     mutation=Mutation,
+    extensions=[get_mask_errors_extension()],
 )

phoenix/version.py

@@ -1 +1 @@
-__version__ = "4.28.1"
+__version__ = "4.29.0"