feat: at exporter initialization, warn user if Phoenix is not running

src/phoenix/server/app.py

@@ -9,7 +9,7 @@
 from starlette.middleware import Middleware
 from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoint
 from starlette.requests import Request
-from starlette.responses import FileResponse, Response
+from starlette.responses import FileResponse, PlainTextResponse, Response
 from starlette.routing import Mount, Route, WebSocketRoute
 from starlette.staticfiles import StaticFiles
 from starlette.templating import Jinja2Templates
@@ -18,6 +18,7 @@
 from strawberry.asgi import GraphQL
 from strawberry.schema import BaseSchema
 
+import phoenix
 from phoenix.config import SERVER_DIR
 from phoenix.core.model_schema import Model
 from phoenix.core.traces import Traces
@@ -122,6 +123,10 @@ async def get(self, request: Request) -> FileResponse:
         )
 
 
+async def version(_: Request) -> PlainTextResponse:
+    return PlainTextResponse(f"{phoenix.__version__}")
+
+
 def create_app(
     export_path: Path,
     model: Model,
@@ -157,6 +162,7 @@ def create_app(
             ]
         )
         + [
+            Route("/arize_phoenix_version", version),
             Route(
                 "/exports",
                 type(

src/phoenix/trace/exporter.py

@@ -6,6 +6,7 @@
 from types import MethodType
 from typing import Optional
 
+import requests
 from requests import Session
 
 from phoenix.config import get_env_host, get_env_port
@@ -27,9 +28,23 @@ def __init__(
         host: Optional[str] = None,
         port: Optional[int] = None,
     ) -> None:
+        """
+        Span Exporter using HTTP.
+
+        Parameters
+        ----------
+        host: Optional[str]
+            The host of the Phoenix server. It can also be set using environment
+            variable `PHOENIX_HOST`, otherwise it defaults to `127.0.0.1`.
+        port: Optional[int]
+            The port of the Phoenix server. It can also be set using environment
+            variable `PHOENIX_PORT`, otherwise it defaults to `6060`.
+        """
         self._host = host or get_env_host()
         self._port = port or get_env_port()
-        self._url = f"http://{self._host}:{self._port}/v1/spans"
+        self._base_url = f"http://{self._host}:{self._port}"
+        self._warn_if_phoenix_is_not_running()
+        self._url = f"{self._base_url}/v1/spans"
         self._session = Session()
         weakref.finalize(self, self._session.close)
         self._session.headers.update(
@@ -69,3 +84,12 @@ def _send(self, span: Span) -> None:
             self._session.post(self._url, data=data)
         except Exception as e:
             logger.exception(e)
+
+    def _warn_if_phoenix_is_not_running(self) -> None:
+        try:
+            requests.get(f"{self._base_url}/arize_phoenix_version").raise_for_status()
+        except Exception:
+            logger.warning(
+                f"Arize Phoenix is not running on {self._base_url}. Launch Phoenix "
+                f"with `import phoenix as px; px.launch_app()`"
+            )

src/phoenix/trace/llama_index/callback.py

@@ -186,10 +186,10 @@ class OpenInferenceTraceCallbackHandler(BaseCallbackHandler):
     def __init__(
         self,
         callback: Optional[Callable[[List[Span]], None]] = None,
-        exporter: Optional[SpanExporter] = HttpExporter(),
+        exporter: Optional[SpanExporter] = None,
     ) -> None:
         super().__init__(event_starts_to_ignore=[], event_ends_to_ignore=[])
-        self._tracer = Tracer(on_append=callback, exporter=exporter)
+        self._tracer = Tracer(on_append=callback, exporter=exporter or HttpExporter())
         self._event_id_to_event_data: EventData = defaultdict(lambda: CBEventData())
 
     def on_event_start(