arize-phoenix 3.16.0__py3-none-any.whl → 7.7.0__py3-none-any.whl

phoenix/trace/span_json_encoder.py

@@ -2,7 +2,7 @@ import json
 from dataclasses import asdict
 from datetime import datetime
 from enum import Enum
-from typing import Any, List
+from typing import Any
 from uuid import UUID
 
 import numpy as np
@@ -60,5 +60,5 @@ def span_to_json(span: Span) -> str:
     return json.dumps(span, cls=SpanJSONEncoder)
 
 
-def spans_to_jsonl(spans: List[Span]) -> str:
+def spans_to_jsonl(spans: list[Span]) -> str:
     return "\n".join(span_to_json(span) for span in spans)

phoenix/trace/trace_dataset.py

@@ -1,10 +1,12 @@
 import json
+from collections.abc import Iterable, Iterator
 from datetime import datetime
 from pathlib import Path
-from typing import Any, Iterable, Iterator, List, Optional, Tuple, Union, cast
+from typing import Any, Optional, Union, cast
 from uuid import UUID, uuid4
 from warnings import warn
 
+import numpy as np
 import pandas as pd
 from openinference.semconv.trace import (
     DocumentAttributes,
@@ -14,8 +16,9 @@ from openinference.semconv.trace import (
 from pandas import DataFrame, read_parquet
 from pyarrow import Schema, Table, parquet
 
-from phoenix.config import DATASET_DIR, GENERATED_DATASET_NAME_PREFIX, TRACE_DATASET_DIR
+from phoenix.config import GENERATED_INFERENCES_NAME_PREFIX, INFERENCES_DIR, TRACE_DATASETS_DIR
 from phoenix.datetime_utils import normalize_timestamps
+from phoenix.trace.attributes import flatten, unflatten
 from phoenix.trace.errors import InvalidParquetMetadataError
 from phoenix.trace.schemas import ATTRIBUTE_PREFIX, CONTEXT_PREFIX, Span
 from phoenix.trace.span_evaluations import Evaluations, SpanEvaluations
@@ -59,6 +62,7 @@ def normalize_dataframe(dataframe: DataFrame) -> "DataFrame":
     # Convert the start and end times to datetime
     dataframe["start_time"] = normalize_timestamps(dataframe["start_time"])
     dataframe["end_time"] = normalize_timestamps(dataframe["end_time"])
+    dataframe = dataframe.replace({np.nan: None})
     return dataframe
 
 
@@ -98,6 +102,14 @@ class TraceDataset:
     """
     A TraceDataset is a wrapper around a dataframe which is a flattened representation
     of Spans. The collection of spans trace the LLM application's execution.
+
+    Typical usage example::
+
+        from phoenix.trace.utils import json_lines_to_df
+
+        with open("trace.jsonl", "r") as f:
+            trace_ds = TraceDataset(json_lines_to_df(f.readlines()))
+        px.launch_app(trace=trace_ds)
     """
 
     name: str
@@ -105,7 +117,7 @@ class TraceDataset:
     A human readable name for the dataset.
     """
     dataframe: pd.DataFrame
-    evaluations: List[Evaluations] = []
+    evaluations: list[Evaluations] = []
     _id: UUID
     _data_file_name: str = "data.parquet"
 
@@ -119,15 +131,15 @@ class TraceDataset:
         Constructs a TraceDataset from a dataframe of spans. Optionally takes in
         evaluations for the spans in the dataset.
 
-        Parameters
-        __________
-        dataframe: pandas.DataFrame
-            the pandas dataframe containing the tracing data. Each row
-            represents a span.
-        evaluations: Optional[Iterable[SpanEvaluations]]
-            an optional list of evaluations for the spans in the dataset. If
-            provided, the evaluations can be materialized into a unified
-            dataframe as annotations.
+        Args:
+            dataframe (pandas.DataFrame): The pandas dataframe containing the
+                tracing data. Each row of which is a flattened representation
+                of a span.
+            name (str): The name used to identify the dataset in the application.
+                If not provided, a random name will be generated.
+            evaluations (Optional[Iterable[SpanEvaluations]]): An optional list of
+                evaluations for the spans in the dataset. If provided, the evaluations
+                can be materialized into a unified dataframe as annotations.
         """
         # Validate the the dataframe has required fields
         if missing_columns := set(REQUIRED_COLUMNS) - set(dataframe.columns):
@@ -137,15 +149,15 @@ class TraceDataset:
         self._id = uuid4()
         self.dataframe = normalize_dataframe(dataframe)
         # TODO: This is not used in any meaningful way. Should remove
-        self.name = name or f"{GENERATED_DATASET_NAME_PREFIX}{str(self._id)}"
+        self.name = name or f"{GENERATED_INFERENCES_NAME_PREFIX}{str(self._id)}"
         self.evaluations = list(evaluations)
 
     @classmethod
-    def from_spans(cls, spans: List[Span]) -> "TraceDataset":
+    def from_spans(cls, spans: list[Span]) -> "TraceDataset":
         """Creates a TraceDataset from a list of spans.
 
         Args:
-            spans (List[Span]): A list of spans.
+            spans (list[Span]): A list of spans.
 
         Returns:
             TraceDataset: A TraceDataset containing the spans.
@@ -161,13 +173,16 @@ class TraceDataset:
         for _, row in self.dataframe.iterrows():
             is_attribute = row.index.str.startswith(ATTRIBUTE_PREFIX)
             attribute_keys = row.index[is_attribute]
-            attributes = (
-                row.loc[is_attribute]
-                .rename(
-                    {key: key[len(ATTRIBUTE_PREFIX) :] for key in attribute_keys},
+            attributes = unflatten(
+                flatten(
+                    row.loc[is_attribute]
+                    .rename(
+                        {key: key[len(ATTRIBUTE_PREFIX) :] for key in attribute_keys},
+                    )
+                    .dropna()
+                    .to_dict(),
+                    recurse_on_sequence=True,
                 )
-                .dropna()
-                .to_dict()
             )
             is_context = row.index.str.startswith(CONTEXT_PREFIX)
             context_keys = row.index[is_context]
@@ -200,13 +215,13 @@ class TraceDataset:
     @classmethod
     def from_name(cls, name: str) -> "TraceDataset":
         """Retrieves a dataset by name from the file system"""
-        directory = DATASET_DIR / name
+        directory = INFERENCES_DIR / name
         df = read_parquet(directory / cls._data_file_name)
         return cls(df, name)
 
     def to_disc(self) -> None:
         """writes the data to disc"""
-        directory = DATASET_DIR / self.name
+        directory = INFERENCES_DIR / self.name
         directory.mkdir(parents=True, exist_ok=True)
         get_serializable_spans_dataframe(self.dataframe).to_parquet(
             directory / self._data_file_name,
@@ -222,14 +237,14 @@ class TraceDataset:
 
         Args:
             directory (Optional[Union[str, Path]], optional): An optional path
-            to a directory where the data will be written. If not provided, the
-            data will be written to a default location.
+                to a directory where the data will be written. If not provided, the
+                data will be written to a default location.
 
         Returns:
             UUID: The id of the trace dataset, which can be used as key to load
-            the dataset from disk using `load`.
+                the dataset from disk using `load`.
         """
-        directory = Path(directory or TRACE_DATASET_DIR)
+        directory = Path(directory or TRACE_DATASETS_DIR)
         for evals in self.evaluations:
             evals.save(directory)
         path = directory / TRACE_DATASET_PARQUET_FILE_NAME.format(id=self._id)
@@ -270,16 +285,16 @@ class TraceDataset:
             id (Union[str, UUID]): The ID of the trace dataset to be loaded.
 
             directory (Optional[Union[str, Path]], optional): The path to the
-            directory containing the persisted trace dataset parquet file. If
-            not provided, the parquet file will be loaded from the same default
-            location used by `save`.
+                directory containing the persisted trace dataset parquet file. If
+                not provided, the parquet file will be loaded from the same default
+                location used by `save`.
 
         Returns:
             TraceDataset: The loaded trace dataset.
         """
         if not isinstance(id, UUID):
             id = UUID(id)
-        path = Path(directory or TRACE_DATASET_DIR) / TRACE_DATASET_PARQUET_FILE_NAME.format(id=id)
+        path = Path(directory or TRACE_DATASETS_DIR) / TRACE_DATASET_PARQUET_FILE_NAME.format(id=id)
         schema = parquet.read_schema(path)
         dataset_id, dataset_name, eval_ids = _parse_schema_metadata(schema)
         if id != dataset_id:
@@ -335,7 +350,7 @@ class TraceDataset:
         return pd.concat([df, evals_df], axis=1)
 
 
-def _parse_schema_metadata(schema: Schema) -> Tuple[UUID, str, List[UUID]]:
+def _parse_schema_metadata(schema: Schema) -> tuple[UUID, str, list[UUID]]:
     """
     Returns parsed metadata from a parquet schema or raises an exception if the
     metadata is invalid.

phoenix/trace/utils.py

@@ -1,12 +1,29 @@
 import json
+import os
 import re
 from traceback import format_exception
-from typing import List, Optional, Tuple, cast
+from typing import Optional, cast
+from urllib import request
 
 import pandas as pd
 
 
-def json_lines_to_df(lines: List[str]) -> pd.DataFrame:
+def parse_file_extension(file_path: str) -> str:
+    return os.path.splitext(file_path)[-1]
+
+
+def download_json_traces_fixture(
+    url: str,
+) -> list[str]:
+    """
+    Stores the traces fixture as list of jsons from the jsonl files in the phoenix bucket.
+    """
+
+    with request.urlopen(url) as f:
+        return cast(list[str], f.readlines())
+
+
+def json_lines_to_df(lines: list[str]) -> pd.DataFrame:
     """
     Convert a list of JSON line strings to a Pandas DataFrame.
     """
@@ -39,9 +56,9 @@ def get_stacktrace(exception: BaseException) -> str:
 _VERSION_TRIPLET_REGEX = re.compile(r"(\d+)\.(\d+)\.(\d+)")
 
 
-def extract_version_triplet(version: str) -> Optional[Tuple[int, int, int]]:
+def extract_version_triplet(version: str) -> Optional[tuple[int, int, int]]:
     return (
-        cast(Tuple[int, int, int], tuple(map(int, match.groups())))
+        cast(tuple[int, int, int], tuple(map(int, match.groups())))
         if (match := _VERSION_TRIPLET_REGEX.search(version))
         else None
     )

phoenix/utilities/__init__.py

@@ -1,26 +0,0 @@
-from datetime import datetime
-from typing import List, Optional
-
-import pandas as pd
-
-from phoenix.core.project import Project
-from phoenix.trace.dsl import SpanQuery
-
-
-def query_spans(
-    project: Optional[Project],
-    *queries: SpanQuery,
-    start_time: Optional[datetime] = None,
-    stop_time: Optional[datetime] = None,
-    root_spans_only: Optional[bool] = None,
-) -> List[pd.DataFrame]:
-    if not queries or not project:
-        return []
-    spans = tuple(
-        project.get_spans(
-            start_time=start_time,
-            stop_time=stop_time,
-            root_spans_only=root_spans_only,
-        )
-    )
-    return [query(spans) for query in queries]

phoenix/utilities/client.py

@@ -0,0 +1,132 @@
+import warnings
+from typing import Any
+
+import httpx
+
+from phoenix.config import get_env_client_headers, get_env_phoenix_api_key
+
+PHOENIX_SERVER_VERSION_HEADER = "x-phoenix-server-version"
+
+
+class VersionedClient(httpx.Client):
+    """
+    A httpx.Client wrapper that warns if there is a server/client version mismatch.
+    """
+
+    def __init__(self, *args: Any, **kwargs: Any):
+        from phoenix.version import __version__ as phoenix_version
+
+        super().__init__(*args, **kwargs)
+
+        if env_headers := get_env_client_headers():
+            self.headers.update(env_headers)
+        if "authorization" not in [k.lower() for k in self.headers]:
+            if api_key := get_env_phoenix_api_key():
+                self.headers["Authorization"] = f"Bearer {api_key}"
+
+        self._client_phoenix_version = phoenix_version
+        self._warned_on_minor_version_mismatch = False
+
+    def _check_version(self, response: httpx.Response) -> None:
+        server_version = response.headers.get(PHOENIX_SERVER_VERSION_HEADER)
+
+        if server_version is None:
+            warnings.warn(
+                "The Phoenix server has an unknown version and may have compatibility issues."
+            )
+            return
+
+        try:
+            client_major, client_minor, client_patch = map(
+                int, self._client_phoenix_version.split(".")
+            )
+            server_major, server_minor, server_patch = map(int, server_version.split("."))
+            if abs(server_major - client_major) >= 1:
+                warnings.warn(
+                    f"⚠️⚠️ The Phoenix server ({server_version}) and client "
+                    f"({self._client_phoenix_version}) versions are severely mismatched. Upgrade "
+                    " either the client or server to ensure API compatibility ⚠️⚠️"
+                )
+            elif (
+                abs(server_minor - client_minor) >= 1 and not self._warned_on_minor_version_mismatch
+            ):
+                self._warned_on_minor_version_mismatch = True
+                warnings.warn(
+                    f"The Phoenix server ({server_version}) and client "
+                    f"({self._client_phoenix_version}) versions are mismatched and may have "
+                    "compatibility issues."
+                )
+        except ValueError:
+            # if either the client or server version includes a suffix e.g. "rc1", check for an
+            # exact version match of the version string
+            if self._client_phoenix_version != server_version:
+                warnings.warn(
+                    f"The Phoenix server ({server_version}) and client "
+                    f"({self._client_phoenix_version}) versions are mismatched and may have "
+                    "compatibility issues."
+                )
+
+    def request(self, *args: Any, **kwargs: Any) -> httpx.Response:
+        response = super().request(*args, **kwargs)
+        self._check_version(response)
+        return response
+
+
+class VersionedAsyncClient(httpx.AsyncClient):
+    """
+    A httpx.Client wrapper that warns if there is a server/client version mismatch.
+    """
+
+    def __init__(self, *args: Any, **kwargs: Any):
+        from phoenix.version import __version__ as phoenix_version
+
+        super().__init__(*args, **kwargs)
+
+        if env_headers := get_env_client_headers():
+            self.headers.update(env_headers)
+        if "authorization" not in [k.lower() for k in self.headers]:
+            if api_key := get_env_phoenix_api_key():
+                self.headers["Authorization"] = f"Bearer {api_key}"
+
+        self._client_phoenix_version = phoenix_version
+        self._warned_on_minor_version_mismatch = False
+
+    def _check_version(self, response: httpx.Response) -> None:
+        server_version = response.headers.get(PHOENIX_SERVER_VERSION_HEADER)
+
+        if server_version is None:
+            return
+
+        try:
+            client_major, client_minor, client_patch = map(
+                int, self._client_phoenix_version.split(".")
+            )
+            server_major, server_minor, server_patch = map(int, server_version.split("."))
+            if abs(server_major - client_major) >= 1:
+                warnings.warn(
+                    f"⚠️⚠️ The Phoenix server ({server_version}) and client "
+                    f"({self._client_phoenix_version}) versions are severely mismatched. Upgrade "
+                    " either the client or server to ensure API compatibility ⚠️⚠️"
+                )
+            elif (
+                abs(server_minor - client_minor) >= 1 and not self._warned_on_minor_version_mismatch
+            ):
+                self._warned_on_minor_version_mismatch = True
+                warnings.warn(
+                    f"The Phoenix server ({server_version}) and client "
+                    f"({self._client_phoenix_version}) versions are mismatched and may have "
+                    "compatibility issues."
+                )
+        except ValueError:
+            # if the version includes a suffix e.g. "rc1", check for an exact version match
+            if self._client_phoenix_version != server_version:
+                warnings.warn(
+                    f"The Phoenix server ({server_version}) and client "
+                    f"({self._client_phoenix_version}) versions are mismatched and may have "
+                    "compatibility issues."
+                )
+
+    async def request(self, *args: Any, **kwargs: Any) -> httpx.Response:
+        response = await super().request(*args, **kwargs)
+        self._check_version(response)
+        return response

phoenix/utilities/deprecation.py

@@ -0,0 +1,31 @@
+import functools
+import warnings
+from collections.abc import Callable
+from typing import Any, TypeVar
+
+GenericClass = TypeVar("GenericClass", bound=type[Any])
+CallableType = TypeVar("CallableType", bound=Callable[..., Any])
+
+
+def deprecated_class(message: str) -> Callable[[GenericClass], GenericClass]:
+    def decorator(original_class: GenericClass) -> GenericClass:
+        @functools.wraps(original_class)
+        def new_class(*args: Any, **kwargs: Any) -> Any:
+            warnings.warn(message, DeprecationWarning, stacklevel=2)
+            return original_class(*args, **kwargs)
+
+        return new_class  # type: ignore
+
+    return decorator
+
+
+def deprecated(message: str) -> Callable[[CallableType], CallableType]:
+    def decorator(original_func: CallableType) -> CallableType:
+        @functools.wraps(original_func)
+        def new_func(*args: Any, **kwargs: Any) -> Any:
+            warnings.warn(message, DeprecationWarning, stacklevel=2)
+            return original_func(*args, **kwargs)
+
+        return new_func  # type: ignore
+
+    return decorator

phoenix/utilities/error_handling.py

@@ -1,12 +1,13 @@
 import logging
 import traceback
-from typing import Any, Callable, Iterable, Optional, Type, TypeVar, cast
+from collections.abc import Callable, Iterable
+from typing import Any, Optional, TypeVar, cast
 
 F = TypeVar("F", bound=Callable[..., Any])
 
 
 def graceful_fallback(
-    fallback_method: Callable[..., Any], exceptions: Optional[Iterable[Type[BaseException]]] = None
+    fallback_method: Callable[..., Any], exceptions: Optional[Iterable[type[BaseException]]] = None
 ) -> Callable[[F], F]:
     """
     Decorator that reroutes failing functions to a specified fallback method.

phoenix/utilities/json.py

@@ -0,0 +1,109 @@
+import dataclasses
+import datetime
+from collections.abc import Mapping, Sequence
+from enum import Enum
+from io import StringIO
+from pathlib import Path
+from typing import Any, Union, cast, get_args, get_origin
+
+import numpy as np
+import pandas as pd
+from pandas.io.json import build_table_schema
+from pandas.io.json._table_schema import parse_table_schema  # type: ignore
+from strawberry import UNSET
+from strawberry.types.base import StrawberryObjectDefinition
+
+try:
+    from pandas.io.json import ujson_dumps  # type: ignore
+except ImportError:
+    # https://github.com/pandas-dev/pandas/pull/54581
+    from pandas.io.json import dumps as ujson_dumps  # type: ignore
+
+
+def jsonify(obj: Any) -> Any:
+    """
+    Coerce object to be json serializable.
+    """
+    if isinstance(obj, Enum):
+        return jsonify(obj.value)
+    if isinstance(obj, (str, int, float, bool)) or obj is None:
+        return obj
+    if isinstance(obj, (list, set, frozenset, Sequence)):
+        return [jsonify(v) for v in obj]
+    if isinstance(obj, (dict, Mapping)):
+        return {jsonify(k): jsonify(v) for k, v in obj.items()}
+    is_strawberry_type = isinstance(
+        getattr(obj, "__strawberry_definition__", None), StrawberryObjectDefinition
+    )
+    if is_strawberry_type:
+        return {
+            k: jsonify(v)
+            for field in dataclasses.fields(obj)
+            if (v := getattr(obj, (k := field.name))) is not UNSET
+        }
+    if dataclasses.is_dataclass(obj):
+        return {
+            k: jsonify(v)
+            for field in dataclasses.fields(obj)
+            if not (
+                (v := getattr(obj, (k := field.name))) is None
+                and get_origin(field) is Union
+                and type(None) in get_args(field)
+            )
+        }
+    if isinstance(obj, (datetime.date, datetime.datetime, datetime.time)):
+        return obj.isoformat()
+    if isinstance(obj, datetime.timedelta):
+        return obj.total_seconds()
+    if isinstance(obj, Path):
+        return str(obj)
+    if isinstance(obj, BaseException):
+        return str(obj)
+    if isinstance(obj, np.ndarray):
+        return [jsonify(v) for v in obj]
+    if hasattr(obj, "__float__"):
+        return float(obj)
+    if hasattr(obj, "model_dump") and callable(obj.model_dump):
+        # pydantic v2
+        try:
+            assert isinstance(d := obj.model_dump(), dict)
+        except BaseException:
+            pass
+        else:
+            return jsonify(d)
+    if hasattr(obj, "dict") and callable(obj.dict):
+        # pydantic v1
+        try:
+            assert isinstance(d := obj.dict(), dict)
+        except BaseException:
+            pass
+        else:
+            return jsonify(d)
+    cls = obj.__class__
+    return f"<{cls.__module__}.{cls.__name__} object>"
+
+
+def encode_df_as_json_string(df: pd.DataFrame) -> str:
+    index_names = df.index.names
+    n = len(index_names)
+    primary_key = [f"{i}_{(x or '')}" for i, x in enumerate(index_names)]
+    df = df.set_axis([f"{i}_{x}" for i, x in enumerate(df.columns, n)], axis=1)
+    df = df.reset_index(names=primary_key)
+    schema = build_table_schema(df, False, primary_key)  # type: ignore
+    data = df.to_dict("records")
+    return cast(
+        str,
+        ujson_dumps(
+            {"schema": schema, "data": data},
+            date_unit="ns",
+            iso_dates=True,
+            ensure_ascii=False,
+        ),
+    )
+
+
+def decode_df_from_json_string(obj: str) -> pd.DataFrame:
+    # Note: read_json converts an all null column to NaN
+    df = cast(pd.DataFrame, parse_table_schema(StringIO(obj).read(), False))
+    df.index.names = [x.split("_", 1)[1] or None for x in df.index.names]  # type: ignore
+    return df.set_axis([x.split("_", 1)[1] for x in df.columns], axis=1)

phoenix/utilities/logging.py

@@ -8,3 +8,11 @@ from tqdm.auto import tqdm
 def printif(condition: bool, *args: Any, **kwargs: Any) -> None:
     if condition:
         tqdm.write(*args, **kwargs)
+
+
+def log_a_list(list_of_str: list[str], join_word: str) -> str:
+    if list_of_str is None or len(list_of_str) == 0:
+        return ""
+    if len(list_of_str) == 1:
+        return list_of_str[0]
+    return f"{', '.join(map(str, list_of_str[:-1]))} {join_word} {list_of_str[-1]}"

phoenix/utilities/project.py

@@ -1,4 +1,4 @@
-from typing import Iterable
+from collections.abc import Iterable
 
 from openinference.semconv.resource import ResourceAttributes
 from opentelemetry.proto.common.v1.common_pb2 import KeyValue
@@ -9,5 +9,5 @@ from phoenix.config import DEFAULT_PROJECT_NAME
 def get_project_name(attributes: Iterable[KeyValue]) -> str:
     for kv in attributes:
         if kv.key == ResourceAttributes.PROJECT_NAME and (v := kv.value.string_value):
-            return v
+            return str(v)
     return DEFAULT_PROJECT_NAME

phoenix/utilities/re.py

@@ -0,0 +1,49 @@
+import logging
+from re import compile, split
+from urllib.parse import unquote
+
+logger = logging.getLogger(__name__)
+
+# 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.
+
+    src: https://github.com/open-telemetry/opentelemetry-python/blob/2d5cd58f33bd8a16f45f30be620a96699bc14297/opentelemetry-api/src/opentelemetry/util/re.py#L52
+    """
+    headers: dict[str, str] = {}
+    headers_list: list[str] = split(_DELIMITER_PATTERN, s)
+    for header in headers_list:
+        if not header:  # empty string
+            continue
+        match = _HEADER_PATTERN.fullmatch(header.strip())
+        if not match:
+            logger.warning(
+                "Header format invalid! Header values in environment variables must be "
+                "URL encoded: %s",
+                header,
+            )
+            continue
+        # value may contain any number of `=`
+        name, value = match.string.split("=", 1)
+        name = unquote(name).strip().lower()
+        value = unquote(value).strip()
+        headers[name] = value
+
+    return headers

phoenix/utilities/span_store.py

@@ -1,23 +0,0 @@
-from typing import Optional
-
-from phoenix.config import get_env_span_storage_type, get_storage_dir
-from phoenix.core.traces import Traces
-from phoenix.storage.span_store import SPAN_STORE_FACTORIES, SpanStore
-from phoenix.trace.otel import decode
-from phoenix.utilities.project import get_project_name
-
-
-def get_span_store() -> Optional[SpanStore]:
-    if span_store_type := get_env_span_storage_type():
-        span_store_factory = SPAN_STORE_FACTORIES[span_store_type]
-        return span_store_factory(get_storage_dir())
-    return None
-
-
-def load_traces_data_from_store(traces: Traces, span_store: SpanStore) -> None:
-    for traces_data in span_store.load():
-        for resource_spans in traces_data.resource_spans:
-            project_name = get_project_name(resource_spans.resource.attributes)
-            for scope_span in resource_spans.scope_spans:
-                for span in scope_span.spans:
-                    traces.put(decode(span), project_name=project_name)