beamlit 0.0.33rc50__py3-none-any.whl → 0.0.34__py3-none-any.whl

beamlit/common/instrumentation.py

@@ -1,17 +1,25 @@
-from typing import Any
+import importlib
+import logging
+from typing import Any, Optional, Type
 
 from fastapi import FastAPI
-from opentelemetry import metrics, trace
-from opentelemetry.exporter.otlp.proto.grpc.metric_exporter import (
+from opentelemetry import _logs, metrics, trace
+from opentelemetry._logs import set_logger_provider
+from opentelemetry.exporter.otlp.proto.http._log_exporter import (
+    OTLPLogExporter,
+)
+from opentelemetry.exporter.otlp.proto.http.metric_exporter import (
     OTLPMetricExporter,
 )
-from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import (
+from opentelemetry.exporter.otlp.proto.http.trace_exporter import (
     OTLPSpanExporter,
 )
-from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor
-from opentelemetry.instrumentation.httpx import HTTPXClientInstrumentor
-from opentelemetry.instrumentation.logging import LoggingInstrumentor
+from opentelemetry.instrumentation.fastapi import (  # type: ignore
+    FastAPIInstrumentor,
+)
 from opentelemetry.metrics import NoOpMeterProvider
+from opentelemetry.sdk._logs import LoggerProvider, LoggingHandler
+from opentelemetry.sdk._logs.export import BatchLogRecordProcessor
 from opentelemetry.sdk.metrics import MeterProvider
 from opentelemetry.sdk.metrics.export import PeriodicExportingMetricReader
 from opentelemetry.sdk.resources import Resource
@@ -20,22 +28,30 @@ from opentelemetry.sdk.trace.export import BatchSpanProcessor
 from opentelemetry.trace import NoOpTracerProvider
 from typing_extensions import Dict
 
+from beamlit.authentication import get_authentication_headers
+
 from .settings import get_settings
 
 tracer: trace.Tracer | None = None
 meter: metrics.Meter | None = None
+logger: LoggerProvider | None = None
 
+log = logging.getLogger(__name__)
 
-def get_tracer() -> trace.Tracer:
-    if tracer is None:
-        raise Exception("Tracer is not initialized")
-    return tracer
 
+def auth_headers() -> Dict[str, str]:
+    settings = get_settings()
+    headers = get_authentication_headers(settings)
+    return {
+        "x-beamlit-authorization": headers.get("X-Beamlit-Authorization", ""),
+        "x-beamlit-workspace": headers.get("X-Beamlit-Workspace", ""),
+    }
 
-def get_meter() -> metrics.Meter:
-    if meter is None:
-        raise Exception("Meter is not initialized")
-    return meter
+
+def get_logger() -> LoggerProvider:
+    if logger is None:
+        raise Exception("Logger is not initialized")
+    return logger
 
 
 def get_resource_attributes() -> Dict[str, Any]:
@@ -44,8 +60,6 @@ def get_resource_attributes() -> Dict[str, Any]:
     for key in resources.attributes:
         resources_dict[key] = resources.attributes[key]
     settings = get_settings()
-    if settings is None:
-        raise Exception("Settings are not initialized")
     resources_dict["workspace"] = settings.workspace
     resources_dict["service.name"] = settings.name
     return resources_dict
@@ -53,28 +67,144 @@ def get_resource_attributes() -> Dict[str, Any]:
 
 def get_metrics_exporter() -> OTLPMetricExporter | None:
     settings = get_settings()
-    if settings is None:
-        raise Exception("Settings are not initialized")
     if not settings.enable_opentelemetry:
-        # Return None or a NoOpExporter equivalent
         return None
-    return OTLPMetricExporter()
+    return OTLPMetricExporter(headers=auth_headers())
 
 
 def get_span_exporter() -> OTLPSpanExporter | None:
     settings = get_settings()
     if not settings.enable_opentelemetry:
         return None
-    return OTLPSpanExporter()
+    return OTLPSpanExporter(headers=auth_headers())
+
+
+def get_log_exporter() -> OTLPLogExporter | None:
+    settings = get_settings()
+    if not settings.enable_opentelemetry:
+        return None
+    return OTLPLogExporter(headers=auth_headers())
+
+
+def _import_class(module_path: str, class_name: str) -> Optional[Type]:  # type: ignore
+    """Dynamically import a class from a module path."""
+    try:
+        module = importlib.import_module(module_path)
+        return getattr(module, class_name)
+    except (ImportError, AttributeError) as e:
+        log.error(f"Could not import {class_name} from {module_path}: {str(e)}")
+        return None
+
+
+# Define mapping of instrumentor info: (module path, class name, required package)
+INSTRUMENTOR_CONFIGS = {
+    "httpx": (
+        "opentelemetry.instrumentation.httpx",
+        "HTTPXClientInstrumentor",
+        "httpx",
+    ),
+    "anthropic": (
+        "opentelemetry.instrumentation.anthropic",
+        "AnthropicInstrumentor",
+        "anthropic",
+    ),
+    "chroma": (
+        "opentelemetry.instrumentation.chroma",
+        "ChromaInstrumentor",
+        "chromadb",
+    ),
+    "cohere": (
+        "opentelemetry.instrumentation.cohere",
+        "CohereInstrumentor",
+        "cohere",
+    ),
+    "groq": ("opentelemetry.instrumentation.groq", "GroqInstrumentor", "groq"),
+    "lance": (
+        "opentelemetry.instrumentation.lance",
+        "LanceInstrumentor",
+        "pylance",
+    ),
+    "langchain": (
+        "opentelemetry.instrumentation.langchain",
+        "LangchainInstrumentor",
+        "langchain",
+    ),
+    "llama_index": (
+        "opentelemetry.instrumentation.llama_index",
+        "LlamaIndexInstrumentor",
+        "llama_index",
+    ),
+    "marqo": (
+        "opentelemetry.instrumentation.marqo",
+        "MarqoInstrumentor",
+        "marqo",
+    ),
+    "milvus": (
+        "opentelemetry.instrumentation.milvus",
+        "MilvusInstrumentor",
+        "pymilvus",
+    ),
+    "mistralai": (
+        "opentelemetry.instrumentation.mistralai",
+        "MistralAiInstrumentor",
+        "mistralai",
+    ),
+    "ollama": (
+        "opentelemetry.instrumentation.ollama",
+        "OllamaInstrumentor",
+        "ollama",
+    ),
+    "openai": (
+        "opentelemetry.instrumentation.openai",
+        "OpenAIInstrumentor",
+        "openai",
+    ),
+    "pinecone": (
+        "opentelemetry.instrumentation.pinecone",
+        "PineconeInstrumentor",
+        "pinecone",
+    ),
+    "qdrant": (
+        "opentelemetry.instrumentation.qdrant",
+        "QdrantInstrumentor",
+        "qdrant_client",
+    ),
+    "replicate": (
+        "opentelemetry.instrumentation.replicate",
+        "ReplicateInstrumentor",
+        "replicate",
+    ),
+    "together": (
+        "opentelemetry.instrumentation.together",
+        "TogetherAiInstrumentor",
+        "together",
+    ),
+    "watsonx": (
+        "opentelemetry.instrumentation.watsonx",
+        "WatsonxInstrumentor",
+        "ibm_watson_machine_learning",
+    ),
+    "weaviate": (
+        "opentelemetry.instrumentation.weaviate",
+        "WeaviateInstrumentor",
+        "weaviate",
+    ),
+}
+
+
+def _is_package_installed(package_name: str) -> bool:
+    """Check if a package is installed."""
+    try:
+        importlib.import_module(package_name)
+        return True
+    except (ImportError, ModuleNotFoundError):
+        return False
 
 
 def instrument_app(app: FastAPI):
     global tracer
     global meter
     settings = get_settings()
-    if settings is None:
-        raise Exception("Settings are not initialized")
-
     if not settings.enable_opentelemetry:
         # Use NoOp implementations to stub tracing and metrics
         trace.set_tracer_provider(NoOpTracerProvider())
@@ -95,7 +225,7 @@ def instrument_app(app: FastAPI):
     # Set up the TracerProvider if not already set
     if not isinstance(trace.get_tracer_provider(), TracerProvider):
         trace_provider = TracerProvider(resource=resource)
-        span_processor = BatchSpanProcessor(get_span_exporter())
+        span_processor = BatchSpanProcessor(get_span_exporter())  # type: ignore
         trace_provider.add_span_processor(span_processor)
         trace.set_tracer_provider(trace_provider)
         tracer = trace_provider.get_tracer(__name__)
@@ -104,7 +234,7 @@ def instrument_app(app: FastAPI):
 
     # Set up the MeterProvider if not already set
     if not isinstance(metrics.get_meter_provider(), MeterProvider):
-        metrics_exporter = PeriodicExportingMetricReader(get_metrics_exporter())
+        metrics_exporter = PeriodicExportingMetricReader(get_metrics_exporter())  # type: ignore
         meter_provider = MeterProvider(
             resource=resource, metric_readers=[metrics_exporter]
         )
@@ -113,11 +243,49 @@ def instrument_app(app: FastAPI):
     else:
         meter = metrics.get_meter(__name__)
 
+    if not isinstance(_logs.get_logger_provider(), LoggerProvider):
+        logger_provider = LoggerProvider(resource=resource)
+        set_logger_provider(logger_provider)
+        logger_provider.add_log_record_processor(
+            BatchLogRecordProcessor(get_log_exporter())  # type: ignore
+        )
+        handler = LoggingHandler(
+            level=logging.NOTSET, logger_provider=logger_provider
+        )
+        logging.getLogger().addHandler(handler)
+    else:
+        logger_provider = _logs.get_logger_provider()
+
     # Only instrument the app when OpenTelemetry is enabled
-    FastAPIInstrumentor.instrument_app(
-        app=app, tracer_provider=trace.get_tracer_provider(), meter_provider=metrics.get_meter_provider()
-    )
-    HTTPXClientInstrumentor().instrument(meter_provider=metrics.get_meter_provider())
-    LoggingInstrumentor(tracer_provider=trace.get_tracer_provider()).instrument(
-        set_logging_format=True
-    )
+    FastAPIInstrumentor.instrument_app(app)  # type: ignore
+
+    for name, (
+        module_path,
+        class_name,
+        required_package,
+    ) in INSTRUMENTOR_CONFIGS.items():
+        if _is_package_installed(required_package):
+            instrumentor_class = _import_class(module_path, class_name)  # type: ignore
+            if instrumentor_class:
+                try:
+                    instrumentor_class().instrument()
+                    log.info(f"Successfully instrumented {name}")
+                except Exception as e:
+                    log.error(f"Failed to instrument {name}: {str(e)}")
+            else:
+                log.error(f"Could not load instrumentor for {name}")
+        else:
+            log.debug(
+                f"Skipping {name} instrumentation - required package '{required_package}' not installed"
+            )
+
+
+def shutdown_instrumentation():
+    if tracer is not None:
+        trace_provider = trace.get_tracer_provider()
+        if isinstance(trace_provider, TracerProvider):
+            trace_provider.shutdown()
+    if meter is not None:
+        meter_provider = metrics.get_meter_provider()
+        if isinstance(meter_provider, MeterProvider):
+            meter_provider.shutdown()

beamlit/common/settings.py

@@ -57,6 +57,7 @@ class Settings(BaseSettings):
     type: str = Field(default="agent")
     name: str = Field(default="beamlit-agent")
     base_url: str = Field(default="https://api.beamlit.com/v0")
+    app_url: str = Field(default="https://app.beamlit.com")
     run_url: str = Field(default="https://run.beamlit.com")
     mcp_hub_url: str = Field(default="https://mcp-hub-server.beamlit.workers.com")
     registry_url: str = Field(default="https://us.registry.beamlit.com")
@@ -73,7 +74,8 @@ class Settings(BaseSettings):
             self.run_url = os.getenv('BL_RUN_URL') or "https://run.beamlit.dev"
             self.mcp_hub_url = os.getenv('BL_MCP_HUB_URL') or "https://mcp-hub-server.beamlit.workers.dev"
             self.registry_url = os.getenv('BL_REGISTRY_URL') or "https://eu.registry.beamlit.dev"
-
+            self.app_url = os.getenv('BL_APP_URL') or "https://app.beamlit.dev"
+            
     @classmethod
     def settings_customise_sources(
         cls,

beamlit/deploy/deploy.py

@@ -1,11 +1,17 @@
 import ast
 import json
 import os
+import shutil
 import sys
-import uuid
 from logging import getLogger
+from pathlib import Path
 from typing import Literal
 
+import yaml
+
+from beamlit.api.agents import get_agent
+from beamlit.authentication import new_client
+from beamlit.client import AuthenticatedClient
 from beamlit.common import slugify
 from beamlit.common.settings import Settings, get_settings, init
 from beamlit.models import (
@@ -15,40 +21,25 @@ from beamlit.models import (
     Flavor,
     Function,
     FunctionSpec,
-    Runtime,
+    MetadataLabels,
 )
 
-from .format import arg_to_dict, format_agent_chain, format_parameters
+from .format import arg_to_dict
 from .parser import Resource, get_description, get_parameters, get_resources
 
 sys.path.insert(0, os.getcwd())
 sys.path.insert(0, os.path.join(os.getcwd(), "src"))
 
-random_id = str(uuid.uuid4())[:8]
-
-def get_runtime_image(type: str, name: str) -> str:
-    settings = get_settings()
-    registry_url = settings.registry_url.replace("https://", "").replace("http://", "")
-    image = f"{registry_url}/{settings.workspace}/{type}s/{name}"
-    # Generate a random ID to ensure unique image tags
-    image = f"{image}:{random_id}"
-    return image
-
-
 def set_default_values(resource: Resource, deployment: Agent | Function):
     settings = get_settings()
     deployment.metadata.workspace = settings.workspace
     deployment.metadata.environment = settings.environment
     if not deployment.metadata.name:
-        deployment.metadata.name = resource.name
+        deployment.metadata.name = slugify(resource.name)
     if not deployment.metadata.display_name:
         deployment.metadata.display_name = deployment.metadata.name
     if not deployment.spec.description:
         deployment.spec.description = get_description(None, resource)
-    if not deployment.spec.runtime:
-        deployment.spec.runtime = Runtime()
-    if not deployment.spec.runtime.image:
-        deployment.spec.runtime.image = get_runtime_image(resource.type, deployment.metadata.name)
     return deployment
 
 def get_beamlit_deployment_from_resource(
@@ -105,7 +96,7 @@ def get_flavors(flavors: list[Flavor]) -> str:
     return json.dumps([flavor.to_dict() for flavor in flavors])
 
 def get_agent_yaml(
-    agent: Agent, functions: list[tuple[Resource, Function]], settings: Settings
+    agent: Agent, functions: list[tuple[Resource, Function]], settings: Settings, client: AuthenticatedClient
 ) -> str:
     """
     Generates YAML configuration for an agent deployment.
@@ -118,30 +109,24 @@ def get_agent_yaml(
     Returns:
         str: YAML configuration string
     """
+    try:
+        agent_response = get_agent.sync(agent.metadata.name, client=client)
+        agent.spec.repository = agent_response.spec.repository
+    except Exception:
+        pass
+    agent.spec.functions = [slugify(function.metadata.name) for (_, function) in functions]
+    agent.metadata.labels = agent.metadata.labels and MetadataLabels.from_dict(agent.metadata.labels) or MetadataLabels()
+    agent.metadata.labels["x-beamlit-auto-generated"] = "true"
+    agent_yaml = yaml.dump(agent.to_dict())
     template = f"""
 apiVersion: beamlit.com/v1alpha1
 kind: Agent
-metadata:
-  name: {slugify(agent.metadata.name)}
-  displayName: {agent.metadata.display_name or agent.metadata.name}
-  environment: {settings.environment}
-  workspace: {settings.workspace}
-spec:
-  enabled: true
-  policies: [{", ".join(agent.spec.policies or [])}]
-  functions: [{", ".join([f"{slugify(function.metadata.name)}" for (_, function) in functions])}]
-  agentChain: {format_agent_chain(agent.spec.agent_chain)}
-  model: {agent.spec.model}
-  runtime:
-    image: {agent.spec.runtime.image}
+{agent_yaml}
 """
-    if agent.spec.description:
-        template += f"""    description: |
-      {agent.spec.description}"""
     return template
 
 
-def get_function_yaml(function: Function, settings: Settings) -> str:
+def get_function_yaml(function: Function, settings: Settings, client: AuthenticatedClient) -> str:
     """
     Generates YAML configuration for a function deployment.
 
@@ -152,21 +137,13 @@ def get_function_yaml(function: Function, settings: Settings) -> str:
     Returns:
         str: YAML configuration string
     """
+    function.metadata.labels = function.metadata.labels and MetadataLabels.from_dict(function.metadata.labels) or MetadataLabels()
+    function.metadata.labels["x-beamlit-auto-generated"] = "true"
+    function_yaml = yaml.dump(function.to_dict())
     return f"""
 apiVersion: beamlit.com/v1alpha1
 kind: Function
-metadata:
-  name: {slugify(function.metadata.name)}
-  displayName: {function.metadata.display_name or function.metadata.name}
-  environment: {settings.environment}
-spec:
-  enabled: true
-  policies: [{", ".join(function.spec.policies or [])}]
-  description: |
-    {function.spec.description}
-  parameters: {format_parameters(function.spec.parameters)}
-  runtime:
-    image: {function.spec.runtime.image}
+{function_yaml}
 """
 
 
@@ -220,8 +197,37 @@ ENV PATH="/beamlit/.venv/bin:$PATH"
 ENTRYPOINT [{cmd_str}]
 """
 
+def clean_auto_generated(
+    directory: str,
+    type: Literal["agent", "function"],
+    deployments: list[tuple[Resource, Agent | Function]]
+):
+    """
+    Cleans up auto-generated deployments of a specific type.
 
-def generate_beamlit_deployment(directory: str):
+    Args:
+        directory (str): Base directory containing deployments
+        type (str): Type of deployment ("agent" or "function")
+        deployments (list[tuple[Resource, Agent | Function]]): List of deployment resources and configurations
+    """
+    
+    deploy_dir = Path(directory) / f"{type}s"
+    deploy_names = [d.metadata.name for (_, d) in deployments]
+
+    if deploy_dir.exists():
+        for item_dir in deploy_dir.iterdir():
+            if item_dir.is_dir() and item_dir.name not in deploy_names:
+                yaml_file = item_dir / f"{type}.yaml"
+                if yaml_file.exists():
+                    with open(yaml_file) as f:
+                        try:
+                            content = yaml.safe_load(f)
+                            if content.get("metadata", {}).get("labels", {}).get("x-beamlit-auto-generated") == "true":
+                                shutil.rmtree(item_dir)
+                        except yaml.YAMLError:
+                            continue
+
+def generate_beamlit_deployment(directory: str, name: str):
     """
     Generates all necessary deployment files for Beamlit agents and functions.
 
@@ -234,12 +240,15 @@ def generate_beamlit_deployment(directory: str):
         - Directory structure for agents and functions
     """
     settings = init()
+    client = new_client()
     logger = getLogger(__name__)
     logger.info(f"Importing server module: {settings.server.module}")
     functions: list[tuple[Resource, Function]] = []
     agents: list[tuple[Resource, Agent]] = []
     for resource in get_resources("agent", settings.server.directory):
         agent = get_beamlit_deployment_from_resource(resource)
+        if name and agent.metadata.name != name:
+            agent.metadata.name = slugify(name)
         if agent:
             agents.append((resource, agent))
     for resource in get_resources("function", settings.server.directory):
@@ -257,28 +266,23 @@ def generate_beamlit_deployment(directory: str):
         agent_dir = os.path.join(agents_dir, agent.metadata.name)
         os.makedirs(agent_dir, exist_ok=True)
         with open(os.path.join(agent_dir, "agent.yaml"), "w") as f:
-            content = get_agent_yaml(agent, functions, settings)
+            content = get_agent_yaml(agent, functions, settings, client)
             f.write(content)
         # write dockerfile for build
         with open(os.path.join(agent_dir, "Dockerfile"), "w") as f:
             content = dockerfile("agent", resource, agent)
             f.write(content)
-        # write destination docker
-        with open(os.path.join(agent_dir, "destination.txt"), "w") as f:
-            content = agent.spec.runtime.image
-            f.write(content)
     for resource, function in functions:
         # write deployment file
         function_dir = os.path.join(functions_dir, function.metadata.name)
         os.makedirs(function_dir, exist_ok=True)
         with open(os.path.join(function_dir, "function.yaml"), "w") as f:
-            content = get_function_yaml(function, settings)
+            content = get_function_yaml(function, settings, client)
             f.write(content)
         # write dockerfile for build
         with open(os.path.join(function_dir, "Dockerfile"), "w") as f:
             content = dockerfile("function", resource, function)
             f.write(content)
-        # write destination docker
-        with open(os.path.join(function_dir, "destination.txt"), "w") as f:
-            content = function.spec.runtime.image
-            f.write(content)
+
+    clean_auto_generated(directory, "agent", agents)
+    clean_auto_generated(directory, "function", functions)

beamlit/deploy/format.py

@@ -48,6 +48,16 @@ def format_parameters(parameters: list[StoreFunctionParameter]) -> str:
 
     return "\n".join(formatted)
 
+def format_dict(obj: dict) -> str:
+    if not obj:
+        return "null"
+    ret = ""
+    for k, v in obj.items():
+        if not v:
+            ret += f"{k}: null\n"
+        else:
+            ret += f"{k}: {v}\n"
+    return ret
 
 def format_agent_chain(agentChain: list[AgentChain]) -> str:
     """

beamlit/functions/__init__.py

@@ -1,5 +1,5 @@
 """Functions package providing function decorators and utilities."""
 
-from .decorator import function, kit
+from .decorator import function, get_functions, kit
 
-__all__ = ["function", "kit"]
+__all__ = ["function", "kit", "get_functions"]