arize-phoenix 4.35.2__tar.gz → 4.36.0__tar.gz

{arize_phoenix-4.35.2 → arize_phoenix-4.36.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: arize-phoenix
-Version: 4.35.2
+Version: 4.36.0
 Summary: AI Observability and Evaluation
 Project-URL: Documentation, https://docs.arize.com/phoenix/
 Project-URL: Issues, https://github.com/Arize-ai/phoenix/issues

{arize_phoenix-4.35.2 → arize_phoenix-4.36.0}/pyproject.toml

@@ -191,33 +191,35 @@ dependencies = [
 
 [tool.hatch.envs.type]
 dependencies = [
+  "grpcio",
+  "litellm>=1.0.3",
   "mypy==1.11.2",
-  "tenacity",
-  "pandas>=1.0",
-  "pandas-stubs==2.0.3.230814",
-  "types-tabulate",
-  "types-psutil",
-  "types-tqdm",
-  "types-protobuf",
-  "types-setuptools",
-  "types-cachetools",
   "openai>=1.0.0",
-  "litellm>=1.0.3",
-  "prometheus_client",
-  "grpcio",
-  "opentelemetry-sdk",
-  "opentelemetry-proto>=1.12.0",
   "opentelemetry-exporter-otlp",
-  "opentelemetry-semantic-conventions",
   "opentelemetry-instrumentation-fastapi",
-  "opentelemetry-instrumentation-sqlalchemy",
   "opentelemetry-instrumentation-grpc",
+  "opentelemetry-instrumentation-sqlalchemy",
+  "opentelemetry-proto>=1.12.0",
+  "opentelemetry-sdk",
+  "opentelemetry-semantic-conventions",
+  "pandas-stubs==2.0.3.230814",
+  "pandas>=1.0",
+  "prometheus_client",
   "py-grpc-prometheus",
-  "strawberry-graphql[opentelemetry]==0.236.0",  # need to pin version because we're monkey-patching
-  "requests",  # this is needed to type-check third-party packages
   "pydantic==1.10.17; python_version=='3.8'",  # lower minor versions of pydantic break strawberry mypy plugin
   "pydantic==1.10.17; python_version=='3.9'",  # lower minor versions of pydantic break strawberry mypy plugin
   "pydantic==2.8.2; python_version=='3.12'",
+  "pypistats",  # this is needed to type-check third-party packages
+  "requests",  # this is needed to type-check third-party packages
+  "strawberry-graphql[opentelemetry]==0.236.0",  # need to pin version because we're monkey-patching
+  "tenacity",
+  "types-cachetools",
+  "types-protobuf",
+  "types-psutil",
+  "types-requests",
+  "types-setuptools",
+  "types-tabulate",
+  "types-tqdm",
 ]
 
 [[tool.hatch.envs.type.matrix]]
@@ -389,7 +391,7 @@ exclude = [
   "sdist/",
   "tests/",
   "tutorials/",
-  "examples/manually-instrumented-chatbot/"
+  "examples/manually-instrumented-chatbot/",
 ]
 
 [[tool.mypy.overrides]]
@@ -411,6 +413,7 @@ module = [
   "grpc.*",
   "py_grpc_prometheus.*",
   "orjson",  # suppress fastapi internal type errors
+  "pypistats",
 ]
 ignore_missing_imports = true
 

{arize_phoenix-4.35.2 → arize_phoenix-4.36.0}/src/phoenix/config.py

@@ -1,13 +1,16 @@
+import logging
 import os
 import re
 import tempfile
-from logging import getLogger
+from enum import Enum
 from pathlib import Path
 from typing import Dict, List, Optional, Tuple
 
+from phoenix.utilities.logging import log_a_list
+
 from .utilities.re import parse_env_headers
 
-logger = getLogger(__name__)
+logger = logging.getLogger(__name__)
 
 # Phoenix environment variables
 ENV_PHOENIX_PORT = "PHOENIX_PORT"
@@ -56,6 +59,24 @@ ENV_PHOENIX_ENABLE_PROMETHEUS = "PHOENIX_ENABLE_PROMETHEUS"
 """
 Whether to enable Prometheus. Defaults to false.
 """
+ENV_LOGGING_MODE = "PHOENIX_LOGGING_MODE"
+"""
+The logging mode (either 'default' or 'structured').
+"""
+ENV_LOGGING_LEVEL = "PHOENIX_LOGGING_LEVEL"
+"""
+The logging level ('debug', 'info', 'warning', 'error', 'critical') for the Phoenix backend. For
+database logging see ENV_DB_LOGGING_LEVEL. Defaults to info.
+"""
+ENV_DB_LOGGING_LEVEL = "PHOENIX_DB_LOGGING_LEVEL"
+"""
+The logging level ('debug', 'info', 'warning', 'error', 'critical') for the Phoenix ORM.
+Defaults to warning.
+"""
+ENV_LOG_MIGRATIONS = "PHOENIX_LOG_MIGRATIONS"
+"""
+Whether or not to log migrations. Defaults to true.
+"""
 
 # Phoenix server OpenTelemetry instrumentation environment variables
 ENV_PHOENIX_SERVER_INSTRUMENTATION_OTLP_TRACE_COLLECTOR_HTTP_ENDPOINT = (
@@ -331,5 +352,74 @@ def get_web_base_url() -> str:
     return get_base_url()
 
 
+class LoggingMode(Enum):
+    DEFAULT = "default"
+    STRUCTURED = "structured"
+
+
+def get_env_logging_mode() -> LoggingMode:
+    if (logging_mode := os.getenv(ENV_LOGGING_MODE)) is None:
+        return LoggingMode.DEFAULT
+    try:
+        return LoggingMode(logging_mode.lower().strip())
+    except ValueError:
+        raise ValueError(
+            f"Invalid value `{logging_mode}` for env var `{ENV_LOGGING_MODE}`. "
+            f"Valid values are: {log_a_list([mode.value for mode in LoggingMode],'and')} "
+            "(case-insensitive)."
+        )
+
+
+def get_env_logging_level() -> int:
+    return _get_logging_level(
+        env_var=ENV_LOGGING_LEVEL,
+        default_level=logging.INFO,
+    )
+
+
+def get_env_db_logging_level() -> int:
+    return _get_logging_level(
+        env_var=ENV_DB_LOGGING_LEVEL,
+        default_level=logging.WARNING,
+    )
+
+
+def _get_logging_level(env_var: str, default_level: int) -> int:
+    logging_level = os.getenv(env_var)
+    if not logging_level:
+        return default_level
+
+    # levelNamesMapping = logging.getLevelNamesMapping() is not supported in python 3.8
+    # but is supported in 3.12. Hence, we define the mapping ourselves and will remove
+    # this once we drop support for older python versions
+    levelNamesMapping = logging._nameToLevel.copy()
+
+    valid_values = [level for level in levelNamesMapping if level != "NOTSET"]
+
+    if logging_level.upper() not in valid_values:
+        raise ValueError(
+            f"Invalid value `{logging_level}` for env var `{env_var}`. "
+            f"Valid values are: {log_a_list(valid_values,'and')} (case-insensitive)."
+        )
+    return levelNamesMapping[logging_level.upper()]
+
+
+def get_env_log_migrations() -> bool:
+    log_migrations = os.getenv(ENV_LOG_MIGRATIONS)
+    # Default to True
+    if log_migrations is None:
+        return True
+
+    if log_migrations.lower() == "true":
+        return True
+    elif log_migrations.lower() == "false":
+        return False
+    else:
+        raise ValueError(
+            f"Invalid value for environment variable {ENV_LOG_MIGRATIONS}: "
+            f"{log_migrations}. Value values are 'TRUE' and 'FALSE' (case-insensitive)."
+        )
+
+
 DEFAULT_PROJECT_NAME = "default"
 _KUBERNETES_PHOENIX_PORT_PATTERN = re.compile(r"^tcp://\d{1,3}[.]\d{1,3}[.]\d{1,3}[.]\d{1,3}:\d+$")

{arize_phoenix-4.35.2 → arize_phoenix-4.36.0}/src/phoenix/db/alembic.ini

@@ -83,37 +83,3 @@ version_path_separator = os  # Use os.pathsep. Default configuration used for ne
 # ruff.executable = %(here)s/.venv/bin/ruff
 # ruff.options = --fix REVISION_SCRIPT_FILENAME
 
-# Logging configuration
-[loggers]
-keys = root,sqlalchemy,alembic
-
-[handlers]
-keys = console
-
-[formatters]
-keys = generic
-
-[logger_root]
-level = WARN
-handlers = console
-qualname =
-
-[logger_sqlalchemy]
-level = WARN
-handlers =
-qualname = sqlalchemy.engine
-
-[logger_alembic]
-level = WARN
-handlers =
-qualname = alembic
-
-[handler_console]
-class = StreamHandler
-args = (sys.stderr,)
-level = NOTSET
-formatter = generic
-
-[formatter_generic]
-format = %(levelname)-5.5s [%(name)s] %(message)s
-datefmt = %H:%M:%S

{arize_phoenix-4.35.2 → arize_phoenix-4.36.0}/src/phoenix/db/engines.py

@@ -13,7 +13,7 @@ from sqlalchemy import URL, StaticPool, event, make_url
 from sqlalchemy.ext.asyncio import AsyncEngine, create_async_engine
 from typing_extensions import assert_never
 
-from phoenix.config import get_env_database_schema
+from phoenix.config import LoggingMode, get_env_database_schema
 from phoenix.db.helpers import SupportedSQLDialect
 from phoenix.db.migrate import migrate_in_thread
 from phoenix.db.models import init_models
@@ -64,7 +64,7 @@ def get_async_db_url(connection_str: str) -> URL:
 def create_engine(
     connection_str: str,
     migrate: bool = True,
-    echo: bool = False,
+    log_to_stdout: bool = False,
 ) -> AsyncEngine:
     """
     Factory to create a SQLAlchemy engine from a URL string.
@@ -74,10 +74,25 @@ def create_engine(
         raise ValueError("Failed to parse database from connection string")
     backend = SupportedSQLDialect(url.get_backend_name())
     url = get_async_db_url(url.render_as_string(hide_password=False))
+    # If Phoenix is run as an application, we want to pass log_migrations_to_stdout=False
+    # and let the configured sqlalchemy logger handle the migration logs
+    log_migrations_to_stdout = (
+        Settings.log_migrations and Settings.logging_mode != LoggingMode.STRUCTURED
+    )
     if backend is SupportedSQLDialect.SQLITE:
-        return aio_sqlite_engine(url=url, migrate=migrate, echo=echo)
+        return aio_sqlite_engine(
+            url=url,
+            migrate=migrate,
+            log_to_stdout=log_to_stdout,
+            log_migrations_to_stdout=log_migrations_to_stdout,
+        )
     elif backend is SupportedSQLDialect.POSTGRESQL:
-        return aio_postgresql_engine(url=url, migrate=migrate, echo=echo)
+        return aio_postgresql_engine(
+            url=url,
+            migrate=migrate,
+            log_to_stdout=log_to_stdout,
+            log_migrations_to_stdout=log_migrations_to_stdout,
+        )
     else:
         assert_never(backend)
 
@@ -85,8 +100,9 @@ def create_engine(
 def aio_sqlite_engine(
     url: URL,
     migrate: bool = True,
-    echo: bool = False,
     shared_cache: bool = True,
+    log_to_stdout: bool = False,
+    log_migrations_to_stdout: bool = True,
 ) -> AsyncEngine:
     database = url.database or ":memory:"
     if database.startswith("file:"):
@@ -105,7 +121,7 @@ def aio_sqlite_engine(
 
     engine = create_async_engine(
         url=url,
-        echo=echo,
+        echo=log_to_stdout,
         json_serializer=_dumps,
         async_creator=async_creator,
         poolclass=StaticPool,
@@ -123,7 +139,7 @@ def aio_sqlite_engine(
     else:
         sync_engine = sqlalchemy.create_engine(
             url=url.set(drivername="sqlite"),
-            echo=Settings.log_migrations,
+            echo=log_migrations_to_stdout,
             json_serializer=_dumps,
             creator=lambda: sqlean.connect(f"file:{database}", uri=True),
         )
@@ -143,14 +159,15 @@ def set_postgresql_search_path(schema: str) -> Callable[[Connection, Any], None]
 def aio_postgresql_engine(
     url: URL,
     migrate: bool = True,
-    echo: bool = False,
+    log_to_stdout: bool = False,
+    log_migrations_to_stdout: bool = True,
 ) -> AsyncEngine:
-    engine = create_async_engine(url=url, echo=echo, json_serializer=_dumps)
+    engine = create_async_engine(url=url, echo=log_to_stdout, json_serializer=_dumps)
     if not migrate:
         return engine
     sync_engine = sqlalchemy.create_engine(
         url=url.set(drivername="postgresql+psycopg"),
-        echo=Settings.log_migrations,
+        echo=log_migrations_to_stdout,
         json_serializer=_dumps,
     )
     if schema := get_env_database_schema():

{arize_phoenix-4.35.2 → arize_phoenix-4.36.0}/src/phoenix/db/insertion/dataset.py

@@ -24,7 +24,6 @@ from phoenix.db import models
 from phoenix.db.insertion.helpers import DataManipulationEvent
 
 logger = logging.getLogger(__name__)
-logger.addHandler(logging.NullHandler())
 
 DatasetId: TypeAlias = int
 DatasetVersionId: TypeAlias = int

{arize_phoenix-4.35.2 → arize_phoenix-4.36.0}/src/phoenix/db/insertion/types.py

@@ -29,7 +29,7 @@ from phoenix.db.insertion.helpers import insert_on_conflict
 from phoenix.server.dml_event import DmlEvent
 from phoenix.server.types import DbSessionFactory
 
-logger = logging.getLogger("__name__")
+logger = logging.getLogger(__name__)
 
 
 class Insertable(Protocol):

{arize_phoenix-4.35.2 → arize_phoenix-4.36.0}/src/phoenix/db/migrate.py

@@ -14,7 +14,6 @@ from phoenix.exceptions import PhoenixMigrationError
 from phoenix.settings import Settings
 
 logger = logging.getLogger(__name__)
-logger.addHandler(logging.NullHandler())
 
 
 def printif(condition: bool, text: str) -> None:
@@ -48,8 +47,9 @@ def migrate(
         alembic_cfg.set_main_option("script_location", scripts_location)
         url = str(engine.url).replace("%", "%%")
         alembic_cfg.set_main_option("sqlalchemy.url", url)
-        alembic_cfg.attributes["connection"] = engine.connect()
-        command.upgrade(alembic_cfg, "head")
+        with engine.connect() as conn:
+            alembic_cfg.attributes["connection"] = conn
+            command.upgrade(alembic_cfg, "head")
         engine.dispose()
         printif(log_migrations, "---------------------------")
         printif(log_migrations, "✅ Migrations complete.")

{arize_phoenix-4.35.2 → arize_phoenix-4.36.0}/src/phoenix/db/migrations/env.py

@@ -1,5 +1,4 @@
 import asyncio
-from logging.config import fileConfig
 
 from alembic import context
 from sqlalchemy import Connection, engine_from_config, pool
@@ -14,14 +13,8 @@ from phoenix.settings import Settings
 # access to the values within the .ini file in use.
 config = context.config
 
-# Interpret the config file for Python logging.
-# This line sets up loggers basically.
-if config.config_file_name is not None:
-    fileConfig(config.config_file_name, disable_existing_loggers=False)
-
 # add your model's MetaData object here
 # for 'autogenerate' support
-
 target_metadata = Base.metadata
 
 # other values from the config, defined by the needs of env.py,

{arize_phoenix-4.35.2 → arize_phoenix-4.36.0}/src/phoenix/inferences/fixtures.py

@@ -18,7 +18,6 @@ from phoenix.inferences.schema import (
 )
 
 logger = logging.getLogger(__name__)
-logger.addHandler(logging.NullHandler())
 
 
 class InferencesRole(Enum):

{arize_phoenix-4.35.2 → arize_phoenix-4.36.0}/src/phoenix/inferences/inferences.py

@@ -34,7 +34,6 @@ from .schema import (
 from .validation import validate_inferences_inputs
 
 logger = logging.getLogger(__name__)
-logger.addHandler(logging.NullHandler())
 
 # A schema like object. Not recommended to use this directly
 SchemaLike: TypeAlias = Any

arize_phoenix-4.36.0/src/phoenix/logging/__init__.py

@@ -0,0 +1,3 @@
+from ._config import setup_logging
+
+__all__ = ["setup_logging"]

arize_phoenix-4.36.0/src/phoenix/logging/_config.py

@@ -0,0 +1,90 @@
+import atexit
+import logging
+import logging.config
+import logging.handlers
+import queue
+from sys import stderr, stdout
+
+from typing_extensions import assert_never
+
+from phoenix.config import LoggingMode
+from phoenix.logging._filter import NonErrorFilter
+from phoenix.settings import Settings
+
+from ._formatter import PhoenixJSONFormatter
+
+
+def setup_logging() -> None:
+    """
+    Configures logging for the specified logging mode.
+    """
+    logging_mode = Settings.logging_mode
+    if logging_mode is LoggingMode.DEFAULT:
+        _setup_library_logging()
+    elif logging_mode is LoggingMode.STRUCTURED:
+        _setup_application_logging()
+    else:
+        assert_never(logging_mode)
+
+
+def _setup_library_logging() -> None:
+    """
+    Configures logging if Phoenix is used as a library
+    """
+    logger = logging.getLogger("phoenix")
+    logger.setLevel(Settings.logging_level)
+    db_logger = logging.getLogger("sqlalchemy")
+    db_logger.setLevel(Settings.db_logging_level)
+    logger.info("Default logging ready")
+
+
+def _setup_application_logging() -> None:
+    """
+    Configures logging if Phoenix is used as an application
+    """
+    sql_engine_logger = logging.getLogger("sqlalchemy.engine.Engine")
+    # Remove all existing handlers
+    for handler in sql_engine_logger.handlers[:]:
+        sql_engine_logger.removeHandler(handler)
+        handler.close()
+
+    phoenix_logger = logging.getLogger("phoenix")
+    phoenix_logger.setLevel(Settings.logging_level)
+    phoenix_logger.propagate = False  # Do not pass records to the root logger
+    sql_logger = logging.getLogger("sqlalchemy")
+    sql_logger.setLevel(Settings.db_logging_level)
+    sql_logger.propagate = False  # Do not pass records to the root logger
+
+    log_queue = queue.Queue()  # type:ignore
+    queue_handler = logging.handlers.QueueHandler(log_queue)
+    phoenix_logger.addHandler(queue_handler)
+    sql_logger.addHandler(queue_handler)
+
+    fmt_keys = {
+        "level": "levelname",
+        "message": "message",
+        "timestamp": "timestamp",
+        "logger": "name",
+        "module": "module",
+        "function": "funcName",
+        "line": "lineno",
+        "thread_name": "threadName",
+    }
+    formatter = PhoenixJSONFormatter(fmt_keys=fmt_keys)
+
+    # stdout handler
+    stdout_handler = logging.StreamHandler(stdout)
+    stdout_handler.setFormatter(formatter)
+    stdout_handler.setLevel(Settings.logging_level)
+    stdout_handler.addFilter(NonErrorFilter())
+
+    # stderr handler
+    stderr_handler = logging.StreamHandler(stderr)
+    stderr_handler.setFormatter(formatter)
+    stderr_handler.setLevel(logging.WARNING)
+
+    queue_listener = logging.handlers.QueueListener(log_queue, stdout_handler, stderr_handler)
+    if queue_listener is not None:
+        queue_listener.start()
+        atexit.register(queue_listener.stop)
+    phoenix_logger.info("Structured logging ready")

arize_phoenix-4.36.0/src/phoenix/logging/_filter.py

@@ -0,0 +1,6 @@
+import logging
+
+
+class NonErrorFilter(logging.Filter):
+    def filter(self, record: logging.LogRecord) -> bool:
+        return record.levelno <= logging.INFO

arize_phoenix-4.36.0/src/phoenix/logging/_formatter.py

@@ -0,0 +1,69 @@
+import datetime as dt
+import json
+import logging
+from typing import Dict, Optional
+
+LOG_RECORD_BUILTIN_ATTRS = {
+    "args",
+    "asctime",
+    "created",
+    "exc_info",
+    "exc_text",
+    "filename",
+    "funcName",
+    "levelname",
+    "levelno",
+    "lineno",
+    "module",
+    "msecs",
+    "message",
+    "msg",
+    "name",
+    "pathname",
+    "process",
+    "processName",
+    "relativeCreated",
+    "stack_info",
+    "thread",
+    "threadName",
+    "taskName",
+}
+
+
+class PhoenixJSONFormatter(logging.Formatter):
+    def __init__(
+        self,
+        *,
+        fmt_keys: Optional[Dict[str, str]] = None,
+    ):
+        super().__init__()
+        self.fmt_keys = fmt_keys if fmt_keys is not None else {}
+
+    def format(self, record: logging.LogRecord) -> str:
+        message = self._prepare_log_dict(record)
+        return json.dumps(message, default=str)
+
+    def _prepare_log_dict(self, record: logging.LogRecord) -> Dict[str, str]:
+        always_fields = {
+            "message": record.getMessage(),
+            "timestamp": dt.datetime.fromtimestamp(record.created, tz=dt.timezone.utc).isoformat(),
+        }
+        if record.exc_info is not None:
+            always_fields["exc_info"] = self.formatException(record.exc_info)
+
+        if record.stack_info is not None:
+            always_fields["stack_info"] = self.formatStack(record.stack_info)
+
+        message = {
+            key: msg_val
+            if (msg_val := always_fields.pop(val, None)) is not None
+            else getattr(record, val)
+            for key, val in self.fmt_keys.items()
+        }
+        message.update(always_fields)
+
+        for key, val in record.__dict__.items():
+            if key not in LOG_RECORD_BUILTIN_ATTRS:
+                message[key] = val
+
+        return message

{arize_phoenix-4.35.2 → arize_phoenix-4.36.0}/src/phoenix/metrics/__init__.py

@@ -10,7 +10,6 @@ import pandas as pd
 from phoenix.core.model_schema import Column
 
 logger = logging.getLogger(__name__)
-logger.addHandler(logging.NullHandler())
 
 
 @dataclass(frozen=True)

{arize_phoenix-4.35.2 → arize_phoenix-4.36.0}/src/phoenix/server/api/routers/v1/datasets.py

@@ -71,7 +71,6 @@ from .utils import (
 )
 
 logger = logging.getLogger(__name__)
-logger.addHandler(logging.NullHandler())
 
 DATASET_NODE_NAME = DatasetNodeType.__name__
 DATASET_VERSION_NODE_NAME = DatasetVersionNodeType.__name__

{arize_phoenix-4.35.2 → arize_phoenix-4.36.0}/src/phoenix/server/app.py

@@ -118,8 +118,6 @@ if TYPE_CHECKING:
     from opentelemetry.trace import TracerProvider
 
 logger = logging.getLogger(__name__)
-logger.setLevel(logging.INFO)
-logger.addHandler(logging.NullHandler())
 
 router = APIRouter(include_in_schema=False)
 
@@ -542,7 +540,7 @@ def create_engine_and_run_migrations(
     database_url: str,
 ) -> AsyncEngine:
     try:
-        return create_engine(database_url)
+        return create_engine(connection_str=database_url, migrate=True, log_to_stdout=False)
     except PhoenixMigrationError as e:
         msg = (
             "\n\n⚠️⚠️ Phoenix failed to migrate the database to the latest version. ⚠️⚠️\n\n"
@@ -604,6 +602,7 @@ def create_app(
     secret: Optional[str] = None,
     scaffolder_config: Optional[ScaffolderConfig] = None,
 ) -> FastAPI:
+    logger.info(f"Server umap params: {umap_params}")
     startup_callbacks_list: List[_Callback] = list(startup_callbacks)
     shutdown_callbacks_list: List[_Callback] = list(shutdown_callbacks)
     initial_batch_of_spans: Iterable[Tuple[Span, str]] = (