blaxel 0.2.27__tar.gz → 0.2.29__tar.gz

{blaxel-0.2.27 → blaxel-0.2.29}/.github/workflows/dev.yaml

@@ -20,16 +20,24 @@ jobs:
           fetch-depth: 0
       - name: "Install uv"
         uses: astral-sh/setup-uv@v4
-      - name: Set version
+      - name: Set version and build config
+        env:
+          SENTRY_DSN: ${{ secrets.SENTRY_DSN }}
         run: |
           VERSION=$(git describe --tags --abbrev=0)
           VERSION="${VERSION#v}"
           # Split version into parts and increment minor version
           IFS='.' read -r major minor patch <<< "$VERSION"
           patch=$((patch + 1))
-          VERSION="${major}.${minor}.${patch}"
+          VERSION="${major}.${minor}.${patch}.pre-${{ github.run_number }}"
+          COMMIT=$(git rev-parse HEAD)
           echo "Current version: $VERSION"
-          sed -i -E "s/^version = .*/version = \"${VERSION}.pre-${{ github.run_number }}\"/" pyproject.toml
+          echo "Current commit: $COMMIT"
+          sed -i -E "s/^version = .*/version = \"${VERSION}\"/" pyproject.toml
+          # Inject build-time values into __init__.py
+          sed -i -E "s|^__version__ = .*|__version__ = \"${VERSION}\"|" src/blaxel/__init__.py
+          sed -i -E "s|^__commit__ = .*|__commit__ = \"${COMMIT}\"|" src/blaxel/__init__.py
+          sed -i -E "s|^__sentry_dsn__ = .*|__sentry_dsn__ = \"${SENTRY_DSN}\"|" src/blaxel/__init__.py
       - name: Test package installation
         run: |
           uv venv

{blaxel-0.2.27 → blaxel-0.2.29}/.github/workflows/prod.yaml

@@ -16,12 +16,20 @@ jobs:
       - uses: actions/checkout@v4
       - name: "Install uv"
         uses: astral-sh/setup-uv@v4
-      - name: Set version
+      - name: Set version and build config
+        env:
+          SENTRY_DSN: ${{ secrets.SENTRY_DSN }}
         run: |
           VERSION="${{ github.ref_name }}"
           VERSION="${VERSION#v}"
+          COMMIT=$(git rev-parse HEAD)
           echo "Setting version to $VERSION"
+          echo "Setting commit to $COMMIT"
           sed -i -E "s/^version = .*/version = \"${VERSION}\"/" pyproject.toml
+          # Inject build-time values into __init__.py
+          sed -i -E "s|^__version__ = .*|__version__ = \"${VERSION}\"|" src/blaxel/__init__.py
+          sed -i -E "s|^__commit__ = .*|__commit__ = \"${COMMIT}\"|" src/blaxel/__init__.py
+          sed -i -E "s|^__sentry_dsn__ = .*|__sentry_dsn__ = \"${SENTRY_DSN}\"|" src/blaxel/__init__.py
       - name: Test package installation
         run: |
           uv venv

{blaxel-0.2.27 → blaxel-0.2.29}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: blaxel
-Version: 0.2.27
+Version: 0.2.29
 Summary: Blaxel - AI development platform SDK
 Project-URL: Homepage, https://blaxel.ai
 Project-URL: Documentation, https://docs.blaxel.ai
@@ -17,6 +17,7 @@ Requires-Dist: pyjwt>=2.0.0
 Requires-Dist: python-dateutil>=2.8.0
 Requires-Dist: pyyaml>=6.0.0
 Requires-Dist: requests>=2.32.3
+Requires-Dist: sentry-sdk>=2.46.0
 Requires-Dist: tomli>=2.2.1
 Requires-Dist: websockets<16.0.0
 Provides-Extra: all

{blaxel-0.2.27 → blaxel-0.2.29}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "blaxel"
-version = "0.2.27"
+version = "0.2.29"
 description = "Blaxel - AI development platform SDK"
 readme = "README.md"
 authors = [{ name = "cploujoux", email = "cploujoux@blaxel.ai" }]
@@ -17,6 +17,7 @@ dependencies = [
   "attrs>=21.3.0",
   "httpx>=0.27.0",
   "mcp>=1.9.4",
+  "sentry-sdk>=2.46.0",
 ]
 
 [project.optional-dependencies]
@@ -148,6 +149,3 @@ test = [
   "flask>=3.0.0",
   "requests>=2.32.0",
 ]
-
-[tool.blaxel]
-commit = "01d868d9b1e77ea2965c9487b10316432d111fa0"

{blaxel-0.2.27 → blaxel-0.2.29}/src/blaxel/__init__.py

@@ -4,7 +4,9 @@ from .core.common.autoload import autoload
 from .core.common.env import env
 from .core.common.settings import settings
 
-autoload()
-
-__version__ = "0.2.0"
+__version__ = "0.2.29"
+__commit__ = "c29748cf62e4297aac41c1a3de70f608fbc919eb"
+__sentry_dsn__ = "https://9711de13cd02b285ca4378c01de8dc30@o4508714045276160.ingest.us.sentry.io/4510461121462272"
 __all__ = ["autoload", "settings", "env"]
+
+autoload()

{blaxel-0.2.27 → blaxel-0.2.29}/src/blaxel/core/common/__init__.py

@@ -1,4 +1,4 @@
-from .autoload import autoload
+from .autoload import autoload, capture_exception
 from .env import env
 from .internal import get_alphanumeric_limited_hash, get_global_unique_hash
 from .settings import Settings, settings
@@ -11,6 +11,7 @@ from .webhook import (
 
 __all__ = [
     "autoload",
+    "capture_exception",
     "Settings",
     "settings",
     "env",

blaxel-0.2.29/src/blaxel/core/common/autoload.py

@@ -0,0 +1,142 @@
+import atexit
+import logging
+import sys
+import threading
+
+from sentry_sdk import Client, Hub
+
+from ..client import client
+from ..client.response_interceptor import (
+    response_interceptors_async,
+    response_interceptors_sync,
+)
+from ..sandbox.client import client as client_sandbox
+from .settings import settings
+
+logger = logging.getLogger(__name__)
+
+# Isolated Sentry hub for SDK-only error tracking (doesn't interfere with user's Sentry)
+_sentry_hub: Hub | None = None
+_captured_exceptions: set = set()  # Track already captured exceptions to avoid duplicates
+
+
+def _get_exception_key(exc_type, exc_value, frame) -> str:
+    """Generate a unique key for an exception based on type, message, and origin."""
+    # Use type name + message + original file/line where exception was raised
+    # This ensures the same logical exception is only captured once
+    exc_name = exc_type.__name__ if exc_type else "Unknown"
+    exc_msg = str(exc_value) if exc_value else ""
+    # Get the original traceback location (where exception was first raised)
+    tb = getattr(exc_value, '__traceback__', None)
+    if tb:
+        # Walk to the deepest frame (origin of exception)
+        while tb.tb_next:
+            tb = tb.tb_next
+        origin = f"{tb.tb_frame.f_code.co_filename}:{tb.tb_lineno}"
+    else:
+        origin = f"{frame.f_code.co_filename}:{frame.f_lineno}"
+    return f"{exc_name}:{exc_msg}:{origin}"
+
+
+def _trace_blaxel_exceptions(frame, event, arg):
+    """Trace function that captures exceptions from blaxel SDK code."""
+    if event == 'exception':
+        exc_type, exc_value, exc_tb = arg
+        filename = frame.f_code.co_filename
+
+        # Only capture if it's from blaxel in site-packages
+        if 'site-packages/blaxel' in filename:
+            # Avoid capturing the same exception multiple times using a content-based key
+            exc_key = _get_exception_key(exc_type, exc_value, frame)
+            if exc_key not in _captured_exceptions:
+                _captured_exceptions.add(exc_key)
+                capture_exception(exc_value)
+                # Clean up old exception keys to prevent memory leak
+                if len(_captured_exceptions) > 1000:
+                    _captured_exceptions.clear()
+
+    return _trace_blaxel_exceptions
+
+
+def sentry() -> None:
+    """Initialize an isolated Sentry client for SDK error tracking."""
+    global _sentry_hub
+    try:
+        dsn = settings.sentry_dsn
+        if not dsn:
+            return
+
+        # Create an isolated client that won't interfere with user's Sentry
+        sentry_client = Client(
+            dsn=dsn,
+            environment=settings.env,
+            release=f"sdk-python@{settings.version}",
+            default_integrations=False,
+            auto_enabling_integrations=False,
+        )
+        _sentry_hub = Hub(sentry_client)
+
+        # Set SDK-specific tags
+        with _sentry_hub.configure_scope() as scope:
+            scope.set_tag("blaxel.workspace", settings.workspace)
+            scope.set_tag("blaxel.version", settings.version)
+            scope.set_tag("blaxel.commit", settings.commit)
+
+        # Install trace function to automatically capture SDK exceptions
+        sys.settrace(_trace_blaxel_exceptions)
+        threading.settrace(_trace_blaxel_exceptions)
+
+        # Register atexit handler to flush pending events
+        atexit.register(_flush_sentry)
+
+    except Exception as e:
+        logger.debug(f"Error initializing Sentry: {e}")
+
+
+def capture_exception(exception: Exception | None = None) -> None:
+    """Capture an exception to the SDK's isolated Sentry hub."""
+    if _sentry_hub is not None and _sentry_hub.client is not None:
+        _sentry_hub.capture_exception(exception)
+
+
+def _flush_sentry():
+    """Flush pending Sentry events on program exit."""
+    if _sentry_hub is not None and _sentry_hub.client is not None:
+        _sentry_hub.client.flush(timeout=2)
+
+
+def telemetry() -> None:
+    from blaxel.telemetry import telemetry_manager
+
+    telemetry_manager.initialize(settings)
+
+
+def autoload() -> None:
+    client.with_base_url(settings.base_url)
+    client.with_auth(settings.auth)
+
+    # Register response interceptors for authentication error handling
+    # Access the underlying httpx clients and add event hooks
+    # Use sync interceptors for sync clients and async interceptors for async clients
+    httpx_client = client.get_httpx_client()
+    httpx_client.event_hooks["response"] = response_interceptors_sync
+
+    httpx_async_client = client.get_async_httpx_client()
+    httpx_async_client.event_hooks["response"] = response_interceptors_async
+
+    httpx_sandbox_client = client_sandbox.get_httpx_client()
+    httpx_sandbox_client.event_hooks["response"] = response_interceptors_sync
+
+    httpx_sandbox_async_client = client_sandbox.get_async_httpx_client()
+    httpx_sandbox_async_client.event_hooks["response"] = response_interceptors_async
+
+    if settings.tracking:
+        try:
+            sentry()
+        except Exception:
+            pass
+
+    try:
+        telemetry()
+    except Exception:
+        pass

{blaxel-0.2.27 → blaxel-0.2.29}/src/blaxel/core/common/settings.py

@@ -3,31 +3,12 @@ import platform
 from pathlib import Path
 from typing import Dict
 
-import tomli
+import yaml
 
 from ..authentication import BlaxelAuth, auth
 from .logger import init_logger
 
 
-def _get_package_version() -> str:
-    """Get the package version from pyproject.toml."""
-    try:
-        # Navigate up from this file to the project root
-        current_file = Path(__file__)
-        project_root = current_file.parent.parent.parent.parent.parent
-        pyproject_path = project_root / "pyproject.toml"
-
-        if pyproject_path.exists():
-            with open(pyproject_path, "rb") as f:
-                pyproject_data = tomli.load(f)
-                return pyproject_data.get("project", {}).get("version", "unknown")
-        else:
-            return "unknown"
-    except Exception as e:
-        print(f"Warning: Failed to read package version: {e}")
-        return "unknown"
-
-
 def _get_os_arch() -> str:
     """Get OS and architecture information."""
     try:
@@ -56,33 +37,6 @@ def _get_os_arch() -> str:
         return "unknown/unknown"
 
 
-def _get_commit_hash() -> str:
-    """Get commit hash from pyproject.toml."""
-    try:
-        # Try to read from pyproject.toml (build-time injection)
-        current_file = Path(__file__)
-        project_root = current_file.parent.parent.parent.parent.parent
-        pyproject_path = project_root / "pyproject.toml"
-
-        if pyproject_path.exists():
-            with open(pyproject_path, "rb") as f:
-                pyproject_data = tomli.load(f)
-                # Check multiple possible locations for commit
-                commit = None
-                if "tool" in pyproject_data and "blaxel" in pyproject_data["tool"]:
-                    commit = pyproject_data["tool"]["blaxel"].get("commit")
-                if not commit and "project" in pyproject_data:
-                    commit = pyproject_data["project"].get("commit")
-                if not commit and "build" in pyproject_data:
-                    commit = pyproject_data["build"].get("commit")
-
-                if commit:
-                    return commit[:7] if len(commit) > 7 else commit
-    except Exception:
-        pass
-
-    return "unknown"
-
 class Settings:
     auth: BlaxelAuth
 
@@ -90,7 +44,6 @@ class Settings:
         init_logger(self.log_level)
         self.auth = auth(self.env, self.base_url)
         self._headers = None
-        self._version = None
 
     @property
     def env(self) -> str:
@@ -117,20 +70,30 @@ class Settings:
         return "https://run.blaxel.dev"
 
 
+    @property
+    def sentry_dsn(self) -> str:
+        """Get the Sentry DSN (injected at build time)."""
+        import blaxel
+        return blaxel.__sentry_dsn__
+
     @property
     def version(self) -> str:
-        """Get the package version."""
-        if self._version is None:
-            self._version = _get_package_version()
-        return self._version
+        """Get the package version (injected at build time)."""
+        import blaxel
+        return blaxel.__version__ or "unknown"
+
+    @property
+    def commit(self) -> str:
+        """Get the commit hash (injected at build time)."""
+        import blaxel
+        return blaxel.__commit__ or "unknown"
 
     @property
     def headers(self) -> Dict[str, str]:
         """Get the headers for API requests."""
         headers = self.auth.get_headers()
         os_arch = _get_os_arch()
-        commit_hash = _get_commit_hash()
-        headers["User-Agent"] = f"blaxel/sdk/python/{self.version} ({os_arch}) blaxel/{commit_hash}"
+        headers["User-Agent"] = f"blaxel/sdk/python/{self.version} ({os_arch}) blaxel/{self.commit}"
         return headers
 
 
@@ -176,4 +139,30 @@ class Settings:
         """Get the enable opentelemetry."""
         return os.getenv("BL_ENABLE_OPENTELEMETRY", "false").lower() == "true"
 
+    @property
+    def tracking(self) -> bool:
+        """
+        Get the tracking setting.
+
+        Priority:
+        1. Environment variable BL_TRACKING (true/false)
+        2. config.yaml tracking field
+        3. Default: true
+        """
+        env_value = os.environ.get("BL_TRACKING")
+        if env_value is not None:
+            return env_value.lower() == "true"
+
+        try:
+            home_dir = Path.home()
+            config_path = home_dir / ".blaxel" / "config.yaml"
+            with open(config_path, encoding="utf-8") as f:
+                config = yaml.safe_load(f)
+            if config and "tracking" in config:
+                return bool(config["tracking"])
+        except Exception:
+            pass
+
+        return True
+
 settings = Settings()

{blaxel-0.2.27 → blaxel-0.2.29}/src/blaxel/core/common/webhook.py

@@ -3,7 +3,7 @@
 import hashlib
 import hmac
 import time
-from typing import Optional, Protocol
+from typing import Protocol
 
 
 class RequestLike(Protocol):
@@ -40,7 +40,7 @@ def verify_webhook_signature(
     body: bytes | str,
     signature: str,
     secret: str,
-    timestamp: Optional[str] = None,
+    timestamp: str | None = None,
     max_age: int = 300,
 ) -> bool:
     """

{blaxel-0.2.27 → blaxel-0.2.29}/src/blaxel/core/jobs/__init__.py

@@ -1,10 +1,9 @@
 import argparse
 import asyncio
 import os
-import sys
 import time
 from logging import getLogger
-from typing import Any, Awaitable, Callable, Dict, List
+from typing import Any, Callable, Dict, List
 
 import requests
 
@@ -36,7 +35,7 @@ class BlJobWrapper:
                     args_dict[key] = unknown[i + 1]
             return args_dict
 
-        response = requests.get(os.getenv("BL_EXECUTION_DATA_URL"))
+        response = requests.get(os.getenv("BL_EXECUTION_DATA_URL") or "")
         data = response.json()
         tasks = data.get("tasks", [])
         return tasks[self.index] if self.index < len(tasks) else {}
@@ -63,8 +62,7 @@ class BlJobWrapper:
             else:
                 func(**parsed_args)
         except Exception as error:
-            print("Job execution failed:", error, file=sys.stderr)
-            sys.exit(1)
+            logger.error(f"Job execution failed: {error}")
 
 
 logger = getLogger(__name__)
@@ -145,7 +143,7 @@ class BlJob:
                 )
         return response.text
 
-    async def arun(self, input: Any, headers: dict = {}, params: dict = {}) -> Awaitable[str]:
+    async def arun(self, input: Any, headers: dict = {}, params: dict = {}) -> str:
         logger.debug(f"Job Calling: {self.name}")
         response = await self.acall(self.url, input, headers, params)
         if response.status_code >= 400:

{blaxel-0.2.27 → blaxel-0.2.29}/src/blaxel/core/sandbox/default/filesystem.py

@@ -1,6 +1,7 @@
 import asyncio
 import io
 import json
+import logging
 from pathlib import Path
 from typing import Any, Callable, Dict, List, Union
 
@@ -21,6 +22,8 @@ MULTIPART_THRESHOLD = 5 * 1024 * 1024  # 5MB
 CHUNK_SIZE = 5 * 1024 * 1024  # 5MB per part
 MAX_PARALLEL_UPLOADS = 3  # Number of parallel part uploads
 
+logger = logging.getLogger(__name__)
+
 
 class SandboxFileSystem(SandboxAction):
     def __init__(self, sandbox_config: SandboxConfiguration, process=None):
@@ -370,7 +373,7 @@ class SandboxFileSystem(SandboxAction):
             response = await client_instance.delete(url, headers=headers)
             # Don't raise error if abort fails - we want to throw the original error
             if not response.is_success:
-                print(f"Warning: Failed to abort multipart upload: {response.status_code}")
+                logger.warning(f"Warning: Failed to abort multipart upload: {response.status_code}")
 
     async def _upload_with_multipart(
         self, path: str, data: bytes, permissions: str = "0644"
@@ -426,5 +429,5 @@ class SandboxFileSystem(SandboxAction):
                 await self._abort_multipart_upload(upload_id)
             except Exception as abort_error:
                 # Log but don't throw - we want to throw the original error
-                print(f"Failed to abort multipart upload: {abort_error}")
+                logger.warning(f"Failed to abort multipart upload: {abort_error}")
             raise error

{blaxel-0.2.27 → blaxel-0.2.29}/src/blaxel/core/sandbox/sync/filesystem.py

@@ -1,5 +1,6 @@
 import io
 import json
+import logging
 import threading
 from pathlib import Path
 from typing import Any, Callable, Dict, List, Union
@@ -16,6 +17,8 @@ from ..types import (
 )
 from .action import SyncSandboxAction
 
+logger = logging.getLogger(__name__)
+
 # Multipart upload constants
 MULTIPART_THRESHOLD = 5 * 1024 * 1024  # 5MB
 CHUNK_SIZE = 5 * 1024 * 1024  # 5MB per part
@@ -256,7 +259,7 @@ class SyncSandboxFileSystem(SyncSandboxAction):
         with self.get_client() as client_instance:
             response = client_instance.delete(url, headers=headers)
             if not response.is_success:
-                print(f"Warning: Failed to abort multipart upload: {response.status_code}")
+                logger.warning(f"Failed to abort multipart upload: {response.status_code}")
 
     def _upload_with_multipart(self, path: str, data: bytes, permissions: str = "0644") -> SuccessResponse:
         init_response = self._initiate_multipart_upload(path, permissions)
@@ -293,7 +296,7 @@ class SyncSandboxFileSystem(SyncSandboxAction):
             try:
                 self._abort_multipart_upload(upload_id)
             except Exception as abort_error:
-                print(f"Failed to abort multipart upload: {abort_error}")
+                logger.warning(f"Failed to abort multipart upload: {abort_error}")
             raise error
 
 

{blaxel-0.2.27 → blaxel-0.2.29}/src/blaxel/googleadk/model.py

@@ -55,7 +55,6 @@ class AuthenticatedLiteLLMClient(LiteLLMClient):
 
 
 async def get_google_adk_model(url: str, type: str, model: str, **kwargs):
-    print("HEER TWO")
     llm_client = AuthenticatedLiteLLMClient()
     if type == "mistral":
         return LiteLlm(

{blaxel-0.2.27 → blaxel-0.2.29}/src/blaxel/livekit/model.py

@@ -22,7 +22,6 @@ class DynamicHeadersHTTPClient(httpx.AsyncClient):
         auth_headers = settings.auth.get_headers()
         for key, value in auth_headers.items():
             request.headers[key] = value
-        print(request.__dict__)
         return await super().send(request, *args, **kwargs)
 
 

blaxel-0.2.29/src/blaxel/telemetry/__init__.py

@@ -0,0 +1,10 @@
+"""Blaxel telemetry module."""
+
+try:
+    from .exporters import *  # noqa: F403, F401
+    from .instrumentation import *  # noqa: F403, F401
+    from .log import *  # noqa: F403, F401
+except ImportError:
+    pass
+
+from .manager import *  # noqa: F403, F401

blaxel-0.2.29/src/blaxel/telemetry/exporters.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+from typing import Callable, Dict, Sequence
+
+try:
+    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.http.trace_exporter import OTLPSpanExporter
+    from opentelemetry.sdk._logs import LogData
+    from opentelemetry.sdk.metrics.export import MetricExportResult, MetricsData
+
+    _OPENTELEMETRY_AVAILABLE = True
+except ImportError:
+    _OPENTELEMETRY_AVAILABLE = False
+    OTLPLogExporter = object
+    OTLPMetricExporter = object
+    OTLPSpanExporter = object
+    LogData = None
+    MetricExportResult = None
+    MetricsData = None
+
+
+class DynamicHeadersSpanExporter(OTLPSpanExporter):  # type: ignore[misc]
+    """Span exporter with dynamic headers."""
+
+    def __init__(self, get_headers: Callable[[], Dict[str, str]]):
+        self._get_headers = get_headers
+        super().__init__()
+
+    def export(self, spans):
+        self._session.headers.update(self._get_headers())
+        return super().export(spans)
+
+class DynamicHeadersMetricExporter(OTLPMetricExporter):  # type: ignore[misc]
+    """Metric exporter with dynamic headers."""
+
+    def __init__(self, get_headers: Callable[[], Dict[str, str]]):
+        self._get_headers = get_headers
+        super().__init__()
+
+    def export(
+        self,
+        metrics_data: MetricsData,  # type: ignore[reportUnknownReturnType]
+        timeout_millis: float = 10_000,
+        **kwargs,
+    ) -> MetricExportResult:  # type: ignore[reportUnknownReturnType]
+        self._session.headers.update(self._get_headers())
+        return super().export(metrics_data, timeout_millis, **kwargs)
+
+class DynamicHeadersLogExporter(OTLPLogExporter):  # type: ignore[misc]
+    """Log exporter with dynamic headers."""
+    def __init__(self, get_headers: Callable[[], Dict[str, str]]):
+        self._get_headers = get_headers
+        super().__init__()
+
+    def export(self, batch: Sequence[LogData]):  # type: ignore[reportUnknownReturnType]
+        self._session.headers.update(self._get_headers())
+        return super().export(batch)