llama-deploy-appserver 0.2.7a1__py3-none-any.whl → 0.3.0__py3-none-any.whl

llama_deploy/appserver/app.py

@@ -1,24 +1,143 @@
+import argparse
 import logging
 import os
+import threading
+import time
+import webbrowser
+from contextlib import asynccontextmanager
+from importlib.metadata import version
+from pathlib import Path
+from typing import Any, AsyncGenerator, Literal, cast
 
+import uvicorn
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
-from fastapi.requests import Request
-from fastapi.responses import JSONResponse, RedirectResponse
-
-from .routers import deployments_router, status_router
-from .server import lifespan, manager
-from .settings import settings
-from .tracing import configure_tracing
+from fastapi.responses import RedirectResponse
+from llama_deploy.appserver.configure_logging import (
+    add_log_middleware,
+    setup_logging,
+)
+from llama_deploy.appserver.deployment_config_parser import (
+    get_deployment_config,
+)
+from llama_deploy.appserver.routers.deployments import (
+    create_base_router,
+    create_deployments_router,
+)
+from llama_deploy.appserver.routers.ui_proxy import (
+    create_ui_proxy_router,
+    mount_static_files,
+)
+from llama_deploy.appserver.settings import configure_settings, settings
+from llama_deploy.appserver.workflow_loader import (
+    _exclude_venv_warning,
+    build_ui,
+    inject_appserver_into_target,
+    install_ui,
+    load_environment_variables,
+    load_workflows,
+    start_dev_ui_process,
+)
+from llama_deploy.core.config import DEFAULT_DEPLOYMENT_FILE_PATH
+from prometheus_fastapi_instrumentator import Instrumentator
+from starlette.applications import Starlette
+from workflows.server import WorkflowServer
 
+from .deployment import Deployment
+from .interrupts import shutdown_event
+from .process_utils import run_process
+from .routers import health_router
+from .stats import apiserver_state
 
 logger = logging.getLogger("uvicorn.info")
 
+# Auto-configure logging on import when requested (e.g., uvicorn reload workers)
+if os.getenv("LLAMA_DEPLOY_AUTO_LOGGING", "0") == "1":
+    setup_logging(os.getenv("LOG_LEVEL", "INFO"))
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI) -> AsyncGenerator[None, Any]:
+    shutdown_event.clear()
+    apiserver_state.state("starting")
+    config = get_deployment_config()
+
+    workflows = load_workflows(config)
+    deployment = Deployment(workflows)
+    base_router = create_base_router(config.name)
+    deploy_router = create_deployments_router(config.name, deployment)
+    server = deployment.mount_workflow_server(app)
+
+    app.include_router(base_router)
+    app.include_router(deploy_router)
+
+    _setup_openapi(config.name, app, server)
+
+    if config.ui is not None:
+        if settings.proxy_ui:
+            ui_router = create_ui_proxy_router(config.name, settings.proxy_ui_port)
+            app.include_router(ui_router)
+        else:
+            # otherwise serve the pre-built if available
+            mount_static_files(app, config, settings)
+
+        @app.get(f"/deployments/{config.name}", include_in_schema=False)
+        @app.get(f"/deployments/{config.name}/", include_in_schema=False)
+        @app.get(f"/deployments/{config.name}/ui", include_in_schema=False)
+        def redirect_to_ui() -> RedirectResponse:
+            return RedirectResponse(f"/deployments/{config.name}/ui/")
+    else:
+
+        @app.get(f"/deployments/{config.name}", include_in_schema=False)
+        @app.get(f"/deployments/{config.name}/", include_in_schema=False)
+        def redirect_to_docs() -> RedirectResponse:
+            return RedirectResponse(f"/deployments/{config.name}/docs")
+
+    apiserver_state.state("running")
+    # terrible sad cludge
+    async with server._lifespan(cast(Starlette, {})):
+        yield
 
-app = FastAPI(lifespan=lifespan)
+    apiserver_state.state("stopped")
+
+
+def _setup_openapi(name: str, app: FastAPI, server: WorkflowServer) -> None:
+    """
+    extends the fastapi based openapi schema with starlette generated schema
+    """
+    schema_title = "Llama Deploy App Server"
+    app_version = version("llama-deploy-appserver")
+
+    prefix = f"/deployments/{name}"
+
+    schema = server.openapi_schema()
+    schema["info"]["title"] = schema_title
+    schema["info"]["version"] = app_version
+    paths = cast(dict, schema["paths"])
+    new_paths = {}
+    for path, methods in list(paths.items()):
+        if "head" in methods:
+            methods.pop("head")
+        new_paths[prefix + path] = methods
+
+    schema["paths"] = new_paths
+
+    def custom_openapi():
+        return schema
+
+    app.openapi = custom_openapi  # ty: ignore[invalid-assignment] - doesn't like us overwriting the method
+
+
+_config = get_deployment_config()
+_prefix = f"/deployments/{_config.name}"
+app = FastAPI(
+    lifespan=lifespan,
+    docs_url=_prefix + "/docs",
+    redoc_url=_prefix + "/redoc",
+    openapi_url=_prefix + "/openapi.json",
+)
+Instrumentator().instrument(app).expose(app, include_in_schema=False)
 
-# Setup tracing
-configure_tracing(settings)
 
 # Configure CORS middleware if the environment variable is set
 if not os.environ.get("DISABLE_CORS", False):
@@ -30,20 +149,149 @@ if not os.environ.get("DISABLE_CORS", False):
         allow_headers=["Content-Type", "Authorization"],
     )
 
-app.include_router(deployments_router)
-app.include_router(status_router)
-
-
-@app.get("/", response_model=None)
-async def root(request: Request) -> JSONResponse | RedirectResponse:
-    # for local dev, just redirect to the one UI if we have one
-    if len(manager.deployment_names) == 1:
-        deployment = manager.get_deployment(manager.deployment_names[0])
-        if deployment is not None and deployment._ui_server_process is not None:
-            return RedirectResponse(f"deployments/{deployment.name}/ui")
-    return JSONResponse(
-        {
-            "swagger_docs": f"{request.base_url}docs",
-            "status": f"{request.base_url}status",
-        }
+app.include_router(health_router)
+add_log_middleware(app)
+
+
+def open_browser_async(host: str, port: int) -> None:
+    def _open_with_delay() -> None:
+        time.sleep(1)
+        webbrowser.open(f"http://{host}:{port}")
+
+    threading.Thread(target=_open_with_delay).start()
+
+
+def prepare_server(
+    deployment_file: Path | None = None,
+    install: bool = False,
+    build: bool = False,
+) -> None:
+    configure_settings(
+        deployment_file_path=deployment_file or Path(DEFAULT_DEPLOYMENT_FILE_PATH)
+    )
+    load_environment_variables(get_deployment_config(), settings.resolved_config_parent)
+    if install:
+        config = get_deployment_config()
+        inject_appserver_into_target(config, settings.resolved_config_parent)
+        install_ui(config, settings.resolved_config_parent)
+    if build:
+        build_ui(settings.resolved_config_parent, get_deployment_config(), settings)
+
+
+def start_server(
+    proxy_ui: bool = False,
+    reload: bool = False,
+    cwd: Path | None = None,
+    deployment_file: Path | None = None,
+    open_browser: bool = False,
+    configure_logging: bool = True,
+) -> None:
+    # Configure via environment so uvicorn reload workers inherit the values
+    configure_settings(
+        proxy_ui=proxy_ui,
+        app_root=cwd,
+        deployment_file_path=deployment_file or Path(DEFAULT_DEPLOYMENT_FILE_PATH),
+        reload=reload,
+    )
+    load_environment_variables(get_deployment_config(), settings.resolved_config_parent)
+
+    ui_process = None
+    if proxy_ui:
+        ui_process = start_dev_ui_process(
+            settings.resolved_config_parent, settings, get_deployment_config()
+        )
+    try:
+        if open_browser:
+            open_browser_async(settings.host, settings.port)
+        # Ensure reload workers configure logging on import
+        os.environ["LLAMA_DEPLOY_AUTO_LOGGING"] = "1"
+        # Configure logging for the launcher process as well
+        if configure_logging:
+            setup_logging(os.getenv("LOG_LEVEL", "INFO"))
+        uvicorn.run(
+            "llama_deploy.appserver.app:app",
+            host=settings.host,
+            port=settings.port,
+            reload=reload,
+            timeout_graceful_shutdown=60,
+            access_log=False,
+            log_config=None,
+        )
+    finally:
+        if ui_process is not None:
+            ui_process.terminate()
+
+
+def start_server_in_target_venv(
+    proxy_ui: bool = False,
+    reload: bool = False,
+    cwd: Path | None = None,
+    deployment_file: Path | None = None,
+    open_browser: bool = False,
+    port: int | None = None,
+    ui_port: int | None = None,
+    log_level: str | None = None,
+    log_format: str | None = None,
+    persistence: Literal["memory", "local", "cloud"] | None = None,
+    local_persistence_path: str | None = None,
+    cloud_persistence_name: str | None = None,
+) -> None:
+    # Ensure settings reflect the intended working directory before computing paths
+
+    configure_settings(
+        app_root=cwd,
+        deployment_file_path=deployment_file,
+        reload=reload,
+        proxy_ui=proxy_ui,
+        persistence=persistence,
+        local_persistence_path=local_persistence_path,
+        cloud_persistence_name=cloud_persistence_name,
+    )
+    base_dir = cwd or Path.cwd()
+    path = settings.resolved_config_parent.relative_to(base_dir)
+    args = ["uv", "run", "--no-progress", "python", "-m", "llama_deploy.appserver.app"]
+    if proxy_ui:
+        args.append("--proxy-ui")
+    if reload:
+        args.append("--reload")
+    if deployment_file:
+        args.append("--deployment-file")
+        args.append(str(deployment_file))
+    if open_browser:
+        args.append("--open-browser")
+
+    env = os.environ.copy()
+    if port:
+        env["LLAMA_DEPLOY_APISERVER_PORT"] = str(port)
+    if ui_port:
+        env["LLAMA_DEPLOY_APISERVER_PROXY_UI_PORT"] = str(ui_port)
+    if log_level:
+        env["LOG_LEVEL"] = log_level
+    if log_format:
+        env["LOG_FORMAT"] = log_format
+
+    ret = run_process(
+        args,
+        cwd=path,
+        env=env,
+        line_transform=_exclude_venv_warning,
+    )
+
+    if ret != 0:
+        raise SystemExit(ret)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--proxy-ui", action="store_true")
+    parser.add_argument("--reload", action="store_true")
+    parser.add_argument("--deployment-file", type=Path)
+    parser.add_argument("--open-browser", action="store_true")
+
+    args = parser.parse_args()
+    start_server(
+        proxy_ui=args.proxy_ui,
+        reload=args.reload,
+        deployment_file=args.deployment_file,
+        open_browser=args.open_browser,
     )

llama_deploy/appserver/bootstrap.py

@@ -1,43 +1,73 @@
 """
 Bootstraps an application from a remote github repository given environment variables.
 
-This just sets up the files from the repository. It's more of a build process, does not start an application.
+This just sets up the files from the repository. It's more of a build process.
 """
 
-import asyncio
+import os
+from pathlib import Path
+
+from llama_deploy.appserver.deployment_config_parser import get_deployment_config
+from llama_deploy.appserver.settings import (
+    BootstrapSettings,
+    configure_settings,
+    settings,
+)
+from llama_deploy.appserver.workflow_loader import (
+    build_ui,
+    inject_appserver_into_target,
+    install_ui,
+    load_environment_variables,
+)
 from llama_deploy.core.git.git_util import (
     clone_repo,
 )
-from pydantic import Field
-from pydantic_settings import BaseSettings, SettingsConfigDict
 
 
-class BootstrapSettings(BaseSettings):
-    model_config = SettingsConfigDict(env_prefix="LLAMA_DEPLOY_")
-    git_url: str = Field(..., description="The URL of the git repository to clone")
-    git_token: str | None = Field(
-        default=None, description="The token to use to clone the git repository"
-    )
-    git_ref: str | None = Field(
-        default=None, description="The git reference to checkout"
-    )
-    git_sha: str | None = Field(default=None, description="The git SHA to checkout")
-    deployment_file_path: str = Field(
-        default="llama_deploy.yaml", description="The path to the deployment file"
+def bootstrap_app_from_repo(
+    target_dir: str = "/opt/app",
+):
+    bootstrap_settings = BootstrapSettings()
+    # Needs the github url+auth, and the deployment file path
+    # clones the repo to a standard directory
+    # (eventually) runs the UI build process and moves that to a standard directory for a file server
+
+    repo_url = bootstrap_settings.repo_url
+    if repo_url is None:
+        raise ValueError("repo_url is required to bootstrap")
+    clone_repo(
+        repository_url=repo_url,
+        git_ref=bootstrap_settings.git_sha or bootstrap_settings.git_ref,
+        basic_auth=bootstrap_settings.auth_token,
+        dest_dir=target_dir,
     )
-    deployment_name: str | None = Field(
-        default=None, description="The name of the deployment"
+    # Ensure target_dir exists locally when running tests outside a container
+    os.makedirs(target_dir, exist_ok=True)
+    os.chdir(target_dir)
+    configure_settings(
+        app_root=Path(target_dir),
+        deployment_file_path=Path(bootstrap_settings.deployment_file_path),
     )
+    config = get_deployment_config()
+    load_environment_variables(config, settings.resolved_config_parent)
 
+    sdists = None
+    if bootstrap_settings.bootstrap_sdists:
+        sdists = [
+            Path(bootstrap_settings.bootstrap_sdists) / f
+            for f in os.listdir(bootstrap_settings.bootstrap_sdists)
+        ]
+        sdists = [f for f in sdists if f.is_file() and f.name.endswith(".tar.gz")]
+        if not sdists:
+            sdists = None
+    # Use the explicit base path rather than relying on global settings so tests
+    # can safely mock configure_settings without affecting call arguments.
+    inject_appserver_into_target(config, settings.resolved_config_parent, sdists)
+    install_ui(config, settings.resolved_config_parent)
+    build_ui(settings.resolved_config_parent, config, settings)
 
-async def main():
-    settings = BootstrapSettings()
-    # Needs the github url+auth, and the deployment file path
-    # clones the repo to a standard directory
-    # (eventually) runs the UI build process and moves that to a standard directory for a file server
-    clone_repo(settings.git_url, "/app/", settings.git_token)
     pass
 
 
 if __name__ == "__main__":
-    asyncio.run(main())
+    bootstrap_app_from_repo()

llama_deploy/appserver/configure_logging.py

@@ -0,0 +1,189 @@
+import logging
+import logging.config
+import os
+import time
+from contextlib import asynccontextmanager
+from contextvars import ContextVar
+from typing import Any, AsyncGenerator, Awaitable, Callable
+
+import structlog
+from fastapi import FastAPI, Request, Response
+from llama_deploy.appserver.correlation_id import (
+    create_correlation_id,
+    get_correlation_id,
+    set_correlation_id,
+)
+from llama_deploy.appserver.process_utils import should_use_color
+
+access_logger = logging.getLogger("app.access")
+
+
+def _get_or_create_correlation_id(request: Request) -> str:
+    return request.headers.get("X-Request-ID", create_correlation_id())
+
+
+def add_log_middleware(app: FastAPI):
+    @app.middleware("http")
+    async def add_log_id(
+        request: Request, call_next: Callable[[Request], Awaitable[Response]]
+    ):
+        set_correlation_id(_get_or_create_correlation_id(request))
+        return await call_next(request)
+
+    @app.middleware("http")
+    async def access_log_middleware(
+        request: Request, call_next: Callable[[Request], Awaitable[Response]]
+    ):
+        if _is_proxy_request(request):
+            return await call_next(request)
+        start = time.perf_counter()
+        response = await call_next(request)
+        dur_ms = (time.perf_counter() - start) * 1000
+        qp = str(request.query_params)
+        if qp:
+            qp = f"?{qp}"
+        access_logger.info(
+            f"{request.method} {request.url.path}{qp}",
+            extra={
+                "duration_ms": round(dur_ms, 2),
+                "status_code": response.status_code,
+            },
+        )
+        return response
+
+
+def _add_request_id(_: Any, __: str, event_dict: dict[str, Any]) -> dict[str, Any]:
+    req_id = get_correlation_id()
+    if req_id and "request_id" not in event_dict:
+        event_dict["request_id"] = req_id
+    return event_dict
+
+
+def _drop_uvicorn_color_message(
+    _: Any, __: str, event_dict: dict[str, Any]
+) -> dict[str, Any]:
+    # Uvicorn injects an ANSI-colored duplicate of the message under this key
+    event_dict.pop("color_message", None)
+    return event_dict
+
+
+def setup_logging(level: str = "INFO") -> None:
+    """
+    Configure console logging via structlog with a compact, dev-friendly format.
+    Includes request_id and respects logging.extra.
+    """
+    # Choose renderer and timestamp format based on LOG_FORMAT
+    log_format = os.getenv("LOG_FORMAT", "console").lower()
+    is_console = log_format == "console"
+
+    if log_format == "json":
+        renderer = structlog.processors.JSONRenderer()
+        timestamper = structlog.processors.TimeStamper(fmt="iso", key="timestamp")
+    else:
+        renderer = structlog.dev.ConsoleRenderer(colors=should_use_color())
+        timestamper = structlog.processors.TimeStamper(fmt="%H:%M:%S", key="timestamp")
+
+    pre_chain = [
+        structlog.contextvars.merge_contextvars,
+        structlog.stdlib.add_logger_name,
+        structlog.stdlib.add_log_level,
+        timestamper,
+        _add_request_id,
+    ]
+
+    # Ensure stdlib logs (foreign to structlog) also include `extra={...}` fields
+    # and that exceptions/stack info are rendered nicely (esp. for JSON format)
+    foreign_pre_chain = [
+        *pre_chain,
+        structlog.stdlib.ExtraAdder(),
+        *(  # otherwise ConsoleRenderer will render nice rich stack traces
+            [
+                structlog.processors.StackInfoRenderer(),
+                structlog.processors.format_exc_info,
+            ]
+            if not is_console
+            else []
+        ),
+        _drop_uvicorn_color_message,
+    ]
+
+    structlog.configure(
+        processors=[
+            *pre_chain,
+            structlog.stdlib.PositionalArgumentsFormatter(),
+            structlog.stdlib.ExtraAdder(),
+            structlog.processors.StackInfoRenderer(),
+            structlog.processors.format_exc_info,
+            structlog.stdlib.ProcessorFormatter.wrap_for_formatter,
+        ],
+        logger_factory=structlog.stdlib.LoggerFactory(),
+        cache_logger_on_first_use=True,
+    )
+
+    handler = {
+        "class": "logging.StreamHandler",
+        "level": level,
+        "formatter": "console",
+        "stream": "ext://sys.stdout",
+    }
+
+    logging.config.dictConfig(
+        {
+            "version": 1,
+            "disable_existing_loggers": False,
+            "formatters": {
+                "console": {
+                    "()": structlog.stdlib.ProcessorFormatter,
+                    # With Rich, let it handle the final formatting; otherwise use our renderer
+                    "processor": renderer,
+                    "foreign_pre_chain": foreign_pre_chain,
+                }
+            },
+            "handlers": {"console": handler, "default": handler},
+            "root": {
+                "handlers": ["console"],
+                "level": level,
+            },
+            "loggers": {
+                "uvicorn.access": {  # disable access logging, we have our own access log
+                    "level": "WARNING",
+                    "handlers": ["console"],
+                    "propagate": False,
+                },
+            },
+        }
+    )
+
+    # Reduce noise from httpx globally, with fine-grained suppression controlled per-request
+    logging.getLogger("httpx").addFilter(_HttpxProxyNoiseFilter())
+
+
+#####################################################################################
+### Proxying through the fastapi server in dev mode is noisy, various suppressions
+###
+def _is_proxy_request(request: Request) -> bool:
+    parts = request.url.path.split("/")
+    return len(parts) >= 4 and parts[1] == "deployments" and parts[3] == "ui"
+
+
+_suppress_httpx_logging: ContextVar[bool] = ContextVar(
+    "suppress_httpx_logging", default=False
+)
+
+
+class _HttpxProxyNoiseFilter(logging.Filter):
+    def filter(self, record: logging.LogRecord) -> bool:
+        """Return False to drop httpx info/debug logs when suppression is active."""
+        try:
+            if record.name.startswith("httpx") and record.levelno <= logging.INFO:
+                return not _suppress_httpx_logging.get()
+        except Exception:
+            return True
+        return True
+
+
+@asynccontextmanager
+async def suppress_httpx_logs() -> AsyncGenerator[None, None]:
+    _suppress_httpx_logging.set(True)
+    yield
+    _suppress_httpx_logging.set(False)

llama_deploy/appserver/correlation_id.py

@@ -0,0 +1,24 @@
+import random
+import string
+from contextvars import ContextVar
+
+correlation_id_var: ContextVar[str] = ContextVar("correlation_id", default="")
+
+
+def get_correlation_id() -> str:
+    return correlation_id_var.get()
+
+
+def set_correlation_id(correlation_id: str) -> None:
+    correlation_id_var.set(correlation_id)
+
+
+def create_correlation_id() -> str:
+    return random_alphanumeric_string(8)
+
+
+_alphanumeric_chars = string.ascii_letters + string.digits
+
+
+def random_alphanumeric_string(length: int) -> str:
+    return "".join(random.choices(_alphanumeric_chars, k=length))