arize-phoenix 2.11.1__py3-none-any.whl → 3.0.1__py3-none-any.whl

phoenix/trace/otel.py

@@ -19,6 +19,7 @@ from typing import (
     cast,
 )
 
+import numpy as np
 import opentelemetry.proto.trace.v1.trace_pb2 as otlp
 from opentelemetry.proto.common.v1.common_pb2 import AnyValue, ArrayValue, KeyValue
 from opentelemetry.util.types import Attributes, AttributeValue
@@ -320,7 +321,11 @@ def encode(span: Span) -> otlp.Span:
                 attributes[key] = json.dumps(value)
             else:
                 attributes.update(_flatten_mapping(value, key))
-        elif not isinstance(value, str) and isinstance(value, Sequence) and _has_mapping(value):
+        elif (
+            not isinstance(value, str)
+            and (isinstance(value, Sequence) or isinstance(value, np.ndarray))
+            and _has_mapping(value)
+        ):
             attributes.pop(key, None)
             attributes.update(_flatten_sequence(value, key))
 
@@ -413,6 +418,8 @@ def _encode_attributes(attributes: Attributes) -> Iterator[KeyValue]:
     if not attributes:
         return
     for key, value in attributes.items():
+        if isinstance(value, np.ndarray):
+            value = value.tolist()
         yield KeyValue(key=key, value=_encode_value(value))
 
 

phoenix/trace/tracer.py

@@ -1,122 +1,99 @@
+"""
+This module is defunct and will be removed in the future. It's currently
+maintaining a dummy class to avoid breaking any import code.
+"""
 import logging
-from datetime import datetime
-from threading import RLock
-from typing import Any, Callable, Iterator, List, Optional, Protocol
-from uuid import uuid4
-
-from .schemas import (
-    Span,
-    SpanAttributes,
-    SpanContext,
-    SpanConversationAttributes,
-    SpanEvent,
-    SpanID,
-    SpanKind,
-    SpanStatusCode,
-    TraceID,
-)
+import sys
+from typing import Any, Iterator, Protocol
+
+from phoenix.trace.exporter import HttpExporter
 
 logger = logging.getLogger(__name__)
-logger.addHandler(logging.NullHandler())
 
 
 class SpanExporter(Protocol):
-    def export(self, span: Span) -> None:
+    def export(self, _: Any) -> None:
         ...
 
 
+_DEFUNCT_MSG = (
+    "`phoenix.trace.tracer.Tracer` is defunct in the current version of Phoenix, "
+    "and will be removed in the future. For a migration guide, see "
+    "https://github.com/Arize-ai/phoenix/blob/main/MIGRATION.md"
+)
+
+_USE_ENV_MSG = """
+Setting the Phoenix endpoint via HttpExporter() is no longer supported.
+Please use environment variables instead:
+  - os.environ["PHOENIX_HOST"] = "127.0.0.1"
+  - os.environ["PHOENIX_PORT"] = "54321"
+  - os.environ["PHOENIX_COLLECTOR_ENDPOINT"] = "http://127.0.0.1:54321
+For a migration guide, see https://github.com/Arize-ai/phoenix/blob/main/MIGRATION.md
+"""
+
+_ON_APPEND_DEPRECATION_MSG = (
+    "OpenInference has been updated for full OpenTelemetry compliance. The ability to set "
+    "`on_append` callbacks are removed. For a migration guide, see "
+    "https://github.com/Arize-ai/phoenix/blob/main/MIGRATION.md"
+)
+
+
+def _show_deprecation_warnings(obj: object, *args: Any, **kwargs: Any) -> None:
+    if args or kwargs:
+        logger.warning(
+            f"{obj.__class__.__name__}() no longer takes any arguments. "
+            "The arguments provided has been ignored. For a migration guide, "
+            "see https://github.com/Arize-ai/phoenix/blob/main/MIGRATION.md"
+        )
+        if any(callable(arg) for arg in args) or "callback" in kwargs:
+            logger.warning(
+                "The `callback` argument is defunct and no longer has any effect. "
+                "If you need access to spans for processing, some options include "
+                "exporting spans from Phoenix or adding a SpanProcessor to the "
+                "OpenTelemetry TracerProvider. For a migration guide, "
+                "see https://github.com/Arize-ai/phoenix/blob/main/MIGRATION.md"
+            )
+        if any(isinstance(arg, HttpExporter) for arg in args):
+            logger.warning(_USE_ENV_MSG)
+
+
 class Tracer:
-    """
-    Tracer creates spans containing more information about what is happening for
-    a given operation, such as a request in a service.
-
-    OpenTelemetry Inspiration:
-    https://opentelemetry.io/docs/concepts/signals/traces/#tracer
-    """
-
-    span_buffer: List[Span]
-    on_append: Optional[Callable[[List[Span]], None]]
-
-    def __init__(
-        self,
-        exporter: Optional[SpanExporter] = None,
-        on_append: Optional[Callable[[List[Span]], None]] = None,
-        *args: Any,
-        **kwargs: Any,
-    ):
-        """
-        Create a new Tracer. A Tracer's main purpose is to create spans.
-        Serialization should be handled by a separate component.
-
-        Args:
-            on_append:
-                A callback function that will be called when a span is
-                created and appended to the buffer. This is useful for
-                serializing data to a file or sending it to a remote server.
-        """
-        self.span_buffer = []
-        self.on_append = on_append
-        self._exporter: Optional[SpanExporter] = exporter
-        self._lock = RLock()
-        super().__init__(*args, **kwargs)
-
-    def create_span(
-        self,
-        name: str,
-        span_kind: SpanKind,
-        start_time: datetime,
-        end_time: Optional[datetime] = None,
-        status_code: SpanStatusCode = SpanStatusCode.UNSET,
-        status_message: Optional[str] = "",
-        parent_id: Optional[SpanID] = None,
-        trace_id: Optional[TraceID] = None,
-        attributes: Optional[SpanAttributes] = None,
-        events: Optional[List[SpanEvent]] = None,
-        conversation: Optional[SpanConversationAttributes] = None,
-        span_id: Optional[SpanID] = None,
-    ) -> Span:
-        """
-        create_span creates a new span with the given name and options.
-        """
-        # If no trace_id is provided, generate a new one
-        if trace_id is None:
-            trace_id = TraceID(uuid4())
-
-        # If no attributes are provided, create an empty dict
-        if attributes is None:
-            attributes = {}
-
-        # If no events are provided, create an empty list
-        if events is None:
-            events = []
-
-        span = Span(
-            name=name,
-            context=SpanContext(trace_id=trace_id, span_id=span_id or SpanID(uuid4())),
-            span_kind=span_kind,
-            parent_id=parent_id,
-            start_time=start_time,
-            end_time=end_time,
-            status_code=status_code,
-            status_message=status_message if status_message is not None else "",
-            attributes=attributes,
-            events=events,
-            conversation=conversation,
+    _exporter: Any
+
+    def __init__(self, exporter: Any = None, on_append: Any = None) -> None:
+        logger.warning(_DEFUNCT_MSG)
+        if exporter is not None:
+            logger.warning(_USE_ENV_MSG)
+        if on_append is not None:
+            logger.warning(_ON_APPEND_DEPRECATION_MSG)
+
+    def create_span(self, *_: Any, **__: Any) -> Any:
+        logger.warning(_DEFUNCT_MSG)
+
+    def get_spans(self) -> Iterator[Any]:
+        logger.warning(_DEFUNCT_MSG)
+        logger.warning(
+            ".get_spans() is a defunct method that does nothing. "
+            "It will be removed in the future. For a migration guide, "
+            "see https://github.com/Arize-ai/phoenix/blob/main/MIGRATION.md"
         )
+        return iter(())
+
 
-        if self._exporter:
-            self._exporter.export(span)
+class _DefunctModule:
+    __all__ = ("Tracer", "SpanExporter")
 
-        with self._lock:
-            self.span_buffer.append(span)
+    def __getattr__(self, name: str) -> Any:
+        if name == "Tracer":
+            logger.warning(_DEFUNCT_MSG)
+            return Tracer
+        if name == "SpanExporter":
+            logger.warning("`SpanExporter` is defunct and will be removed in the future.")
+            return SpanExporter
+        if name == "_show_deprecation_warnings":
+            return _show_deprecation_warnings
+        raise AttributeError(f"module {__name__} has no attribute {name}")
 
-        if self.on_append is not None:
-            self.on_append(self.span_buffer)
-        return span
 
-    def get_spans(self) -> Iterator[Span]:
-        """
-        Returns the spans stored in the tracer. This is useful if you are running
-        in a notebook environment and you want to inspect the spans.
-        """
-        yield from self.span_buffer
+# See e.g. https://stackoverflow.com/a/7668273
+sys.modules[__name__] = _DefunctModule()  # type: ignore

phoenix/version.py

@@ -1 +1 @@
-__version__ = "2.11.1"
+__version__ = "3.0.1"

phoenix/trace/llama_index/streaming.py

@@ -1,92 +0,0 @@
-from datetime import datetime, timezone
-from typing import TYPE_CHECKING, Generator, List
-
-from llama_index.callbacks.schema import TIMESTAMP_FORMAT
-from llama_index.response.schema import StreamingResponse
-
-from phoenix.trace.schemas import SpanID, SpanKind, SpanStatusCode
-from phoenix.trace.semantic_conventions import OUTPUT_VALUE
-from phoenix.trace.tracer import Tracer
-
-if TYPE_CHECKING:
-    from phoenix.trace.llama_index.callback import CBEventData
-
-_LOCAL_TZINFO = datetime.now().astimezone().tzinfo
-
-
-class TokenGenInstrumentor:
-    def __init__(
-        self, stream: Generator[str, None, None], tracer: Tracer, event_data: "CBEventData"
-    ):
-        self._stream = stream
-        self._token_stream: List[str] = []
-        self._finished = False
-        self._tracer = tracer
-        self._event_data = event_data
-
-    def __iter__(self) -> "TokenGenInstrumentor":
-        return self
-
-    def __next__(self) -> str:
-        if self._finished:
-            raise StopIteration
-
-        try:
-            value = next(self._stream)
-            self._token_stream.append(value)
-            return value
-        except StopIteration:
-            self._finished = True
-            self._handle_end_of_stream()
-            raise
-
-    def _handle_end_of_stream(self) -> None:
-        # Handle the end-of-stream logic here
-        parent_id = self._event_data.parent_id
-        output = "".join(self._token_stream)
-        start_event = self._event_data.start_event
-        if start_event:
-            start_time = _timestamp_to_tz_aware_datetime(start_event.time)
-        else:
-            start_time = datetime.now(timezone.utc)
-        attributes = self._event_data.attributes
-        attributes.update({OUTPUT_VALUE: output})
-        self._tracer.create_span(
-            name=self._event_data.name if self._event_data.name else "",
-            span_kind=SpanKind.LLM,
-            trace_id=self._event_data.trace_id,
-            start_time=start_time,
-            end_time=datetime.now(timezone.utc),
-            status_code=SpanStatusCode.OK,
-            status_message="",
-            parent_id=SpanID(parent_id) if parent_id else None,
-            attributes=self._event_data.attributes,
-            events=[],
-            conversation=None,
-            span_id=SpanID(self._event_data.span_id),
-        )
-
-
-def instrument_streaming_response(
-    response: StreamingResponse,
-    tracer: Tracer,
-    event_data: "CBEventData",
-) -> StreamingResponse:
-    if response.response_gen is not None:
-        response.response_gen = TokenGenInstrumentor(response.response_gen, tracer, event_data)  # type: ignore
-    return response
-
-
-def _timestamp_to_tz_aware_datetime(timestamp: str) -> datetime:
-    """Converts a timestamp string to a timezone-aware datetime."""
-    return _tz_naive_to_tz_aware_datetime(_timestamp_to_tz_naive_datetime(timestamp))
-
-
-def _timestamp_to_tz_naive_datetime(timestamp: str) -> datetime:
-    """Converts a timestamp string to a timezone-naive datetime."""
-    return datetime.strptime(timestamp, TIMESTAMP_FORMAT)
-
-
-def _tz_naive_to_tz_aware_datetime(timestamp: datetime) -> datetime:
-    """Converts a timezone-naive datetime to a timezone-aware datetime."""
-    return timestamp.replace(tzinfo=_LOCAL_TZINFO)