blaxel 0.2.32__tar.gz → 0.2.34__tar.gz

{blaxel-0.2.32 → blaxel-0.2.34}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: blaxel
-Version: 0.2.32
+Version: 0.2.34
 Summary: Blaxel - AI development platform SDK
 Project-URL: Homepage, https://blaxel.ai
 Project-URL: Documentation, https://docs.blaxel.ai
@@ -17,7 +17,6 @@ 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.32 → blaxel-0.2.34}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "blaxel"
-version = "0.2.32"
+version = "0.2.34"
 description = "Blaxel - AI development platform SDK"
 readme = "README.md"
 authors = [{ name = "cploujoux", email = "cploujoux@blaxel.ai" }]
@@ -17,7 +17,6 @@ dependencies = [
   "attrs>=21.3.0",
   "httpx>=0.27.0",
   "mcp>=1.9.4",
-  "sentry-sdk>=2.46.0",
 ]
 
 [project.optional-dependencies]
@@ -133,7 +132,6 @@ dev = [
   "nest-asyncio>=1.6.0",
   "asgi-correlation-id>=4.3.4,<5.0.0",
   "fastapi>=0.115.12",
-  "nest-asyncio>=1.6.0",
   "pdoc3>=0.11.5",
   "python-dotenv>=1.1.0",
   "ruff>=0.8.2",

{blaxel-0.2.32 → blaxel-0.2.34}/src/blaxel/__init__.py

@@ -4,8 +4,8 @@ from .core.common.autoload import autoload
 from .core.common.env import env
 from .core.common.settings import settings
 
-__version__ = "0.2.32"
-__commit__ = "72a43488d87cfae83389f5a928dfa9256649396b"
+__version__ = "0.2.34"
+__commit__ = "84fc1c14e48dec727c7de1966c51022e09f7c80f"
 __sentry_dsn__ = "https://9711de13cd02b285ca4378c01de8dc30@o4508714045276160.ingest.us.sentry.io/4510461121462272"
 __all__ = ["autoload", "settings", "env"]
 

{blaxel-0.2.32 → blaxel-0.2.34}/src/blaxel/core/__init__.py

@@ -30,7 +30,7 @@ from .sandbox import (
 )
 from .sandbox.types import Sandbox
 from .tools import BlTools, bl_tools, convert_mcp_tool_to_blaxel_tool
-from .volume import VolumeCreateConfiguration, VolumeInstance
+from .volume import SyncVolumeInstance, VolumeCreateConfiguration, VolumeInstance
 
 __all__ = [
     "BlAgent",
@@ -65,6 +65,7 @@ __all__ = [
     "convert_mcp_tool_to_blaxel_tool",
     "websocket_client",
     "VolumeInstance",
+    "SyncVolumeInstance",
     "VolumeCreateConfiguration",
     "verify_webhook_signature",
     "verify_webhook_from_request",

{blaxel-0.2.32 → blaxel-0.2.34}/src/blaxel/core/common/__init__.py

@@ -1,5 +1,6 @@
-from .autoload import autoload, capture_exception
+from .autoload import autoload
 from .env import env
+from .sentry import capture_exception, flush_sentry, init_sentry, is_sentry_initialized
 from .internal import get_alphanumeric_limited_hash, get_global_unique_hash
 from .settings import Settings, settings
 from .webhook import (
@@ -12,6 +13,9 @@ from .webhook import (
 __all__ = [
     "autoload",
     "capture_exception",
+    "flush_sentry",
+    "init_sentry",
+    "is_sentry_initialized",
     "Settings",
     "settings",
     "env",

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

@@ -0,0 +1,49 @@
+import logging
+
+from ..client import client
+from ..client.response_interceptor import (
+    response_interceptors_async,
+    response_interceptors_sync,
+)
+from ..sandbox.client import client as client_sandbox
+from .sentry import init_sentry
+from .settings import settings
+
+logger = logging.getLogger(__name__)
+
+
+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:
+            init_sentry()
+        except Exception:
+            pass
+
+    try:
+        telemetry()
+    except Exception:
+        pass

blaxel-0.2.34/src/blaxel/core/common/sentry.py

@@ -0,0 +1,319 @@
+import atexit
+import json
+import logging
+import sys
+import threading
+import traceback
+import uuid
+from asyncio import CancelledError
+from datetime import datetime, timezone
+from typing import Any
+from urllib.parse import urlparse
+
+import httpx
+
+from .settings import settings
+
+logger = logging.getLogger(__name__)
+
+# Lightweight Sentry client using httpx - only captures SDK errors
+_sentry_initialized = False
+_captured_exceptions: set = set()  # Track already captured exceptions to avoid duplicates
+
+# Parsed DSN components
+_sentry_config: dict[str, str] | None = None
+
+# Queue for pending events
+_pending_events: list[dict[str, Any]] = []
+_flush_lock = threading.Lock()
+_handlers_registered = False
+
+# Exceptions that are part of normal control flow and should not be captured
+_IGNORED_EXCEPTIONS = (
+    StopIteration,  # Iterator exhaustion
+    StopAsyncIteration,  # Async iterator exhaustion
+    GeneratorExit,  # Generator cleanup
+    KeyboardInterrupt,  # User interrupt (Ctrl+C)
+    SystemExit,  # Program exit
+    CancelledError,  # Async task cancellation
+)
+
+# Optional dependencies that may not be installed - import errors for these are expected
+_OPTIONAL_DEPENDENCIES = ("opentelemetry",)
+
+# SDK path patterns to identify errors originating from our SDK
+_SDK_PATTERNS = [
+    "blaxel/",
+    "blaxel\\",
+    "site-packages/blaxel",
+    "site-packages\\blaxel",
+]
+
+
+def _is_from_sdk(error: Exception) -> bool:
+    """Check if an error originated from SDK code based on stack trace."""
+    tb = error.__traceback__
+    if not tb:
+        return False
+
+    # Walk through the traceback
+    while tb:
+        filename = tb.tb_frame.f_code.co_filename
+        if any(pattern in filename for pattern in _SDK_PATTERNS):
+            return True
+        tb = tb.tb_next
+
+    return False
+
+
+def _parse_dsn(dsn: str) -> dict[str, str] | None:
+    """
+    Parse a Sentry DSN into its components.
+    DSN format: https://{public_key}@{host}/{project_id}
+    """
+    try:
+        parsed = urlparse(dsn)
+        public_key = parsed.username
+        host = parsed.hostname
+        project_id = parsed.path.lstrip("/")
+
+        if not public_key or not host or not project_id:
+            return None
+
+        return {"public_key": public_key, "host": host, "project_id": project_id}
+    except Exception:
+        return None
+
+
+def _generate_event_id() -> str:
+    """Generate a UUID v4 for event ID."""
+    return uuid.uuid4().hex
+
+
+def _parse_stack_trace(exc: Exception) -> list[dict[str, Any]]:
+    """Parse exception traceback into Sentry-compatible frames."""
+    frames: list[dict[str, Any]] = []
+    tb = traceback.extract_tb(exc.__traceback__)
+
+    for frame in tb:
+        frames.append(
+            {
+                "filename": frame.filename,
+                "function": frame.name or "<anonymous>",
+                "lineno": frame.lineno,
+                "colno": 0,
+            }
+        )
+
+    return frames
+
+
+def _error_to_sentry_event(error: Exception) -> dict[str, Any]:
+    """Convert an Exception to a Sentry event payload."""
+    frames = _parse_stack_trace(error)
+
+    return {
+        "event_id": _generate_event_id(),
+        "timestamp": datetime.now(timezone.utc).timestamp(),
+        "platform": "python",
+        "level": "error",
+        "environment": settings.env,
+        "release": f"sdk-python@{settings.version}",
+        "tags": {
+            "blaxel.workspace": settings.workspace,
+            "blaxel.version": settings.version,
+            "blaxel.commit": settings.commit,
+        },
+        "exception": {
+            "values": [
+                {
+                    "type": type(error).__name__,
+                    "value": str(error),
+                    "stacktrace": {"frames": frames},
+                }
+            ]
+        },
+    }
+
+
+def _send_to_sentry(event: dict[str, Any]) -> None:
+    """Send an event to Sentry using httpx."""
+    if not _sentry_config:
+        return
+
+    public_key = _sentry_config["public_key"]
+    host = _sentry_config["host"]
+    project_id = _sentry_config["project_id"]
+    envelope_url = f"https://{host}/api/{project_id}/envelope/"
+
+    # Create envelope header
+    envelope_header = json.dumps(
+        {
+            "event_id": event["event_id"],
+            "sent_at": datetime.now(timezone.utc).isoformat(),
+            "dsn": f"https://{public_key}@{host}/{project_id}",
+        }
+    )
+
+    # Create item header
+    item_header = json.dumps({"type": "event", "content_type": "application/json"})
+
+    # Create envelope body
+    envelope = f"{envelope_header}\n{item_header}\n{json.dumps(event)}"
+
+    try:
+        httpx.post(
+            envelope_url,
+            headers={
+                "Content-Type": "application/x-sentry-envelope",
+                "X-Sentry-Auth": f"Sentry sentry_version=7, sentry_client=blaxel-sdk/{settings.version}, sentry_key={public_key}",
+            },
+            content=envelope,
+            timeout=5.0,
+        )
+    except Exception:
+        # Silently fail - error reporting should never break the SDK
+        pass
+
+
+def _get_exception_key(exc_type, exc_value, frame) -> str:
+    """Generate a unique key for an exception based on type, message, and origin."""
+    exc_name = exc_type.__name__ if exc_type else "Unknown"
+    exc_msg = str(exc_value) if exc_value else ""
+    tb = getattr(exc_value, "__traceback__", None)
+    if tb:
+        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 _is_optional_dependency_error(exc_type, exc_value) -> bool:
+    """Check if the exception is an import error for an optional dependency."""
+    if exc_type and issubclass(exc_type, ImportError):
+        msg = str(exc_value).lower()
+        return any(dep in msg for dep in _OPTIONAL_DEPENDENCIES)
+    return False
+
+
+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
+
+        # Skip control flow exceptions (not actual errors)
+        if exc_type and issubclass(exc_type, _IGNORED_EXCEPTIONS):
+            return _trace_blaxel_exceptions
+
+        # Skip import errors for optional dependencies (expected when not installed)
+        if _is_optional_dependency_error(exc_type, exc_value):
+            return _trace_blaxel_exceptions
+
+        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 init_sentry() -> None:
+    """Initialize the lightweight Sentry client for SDK error tracking."""
+    global _sentry_initialized, _sentry_config, _handlers_registered
+    try:
+        dsn = settings.sentry_dsn
+        if not dsn:
+            return
+
+        # Parse DSN
+        _sentry_config = _parse_dsn(dsn)
+        if not _sentry_config:
+            return
+
+        # Only allow dev/prod environments
+        if settings.env not in ("dev", "prod"):
+            return
+
+        _sentry_initialized = True
+
+        # Register handlers only once
+        if not _handlers_registered:
+            _handlers_registered = True
+
+            # 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 Sentry.
+    Only errors originating from SDK code will be captured.
+    """
+    if not _sentry_initialized or not _sentry_config or exception is None:
+        return
+
+    try:
+        # Generate unique key to prevent duplicate captures
+        exc_key = f"{type(exception).__name__}:{str(exception)}"
+        if exc_key in _captured_exceptions:
+            return
+
+        _captured_exceptions.add(exc_key)
+
+        # Clean up old exception keys to prevent memory leak
+        if len(_captured_exceptions) > 1000:
+            _captured_exceptions.clear()
+
+        # Convert error to Sentry event and queue it
+        event = _error_to_sentry_event(exception)
+        with _flush_lock:
+            _pending_events.append(event)
+
+        # Send immediately (fire and forget)
+        _send_to_sentry(event)
+
+    except Exception:
+        # Silently fail - error capturing should never break the SDK
+        pass
+
+
+def flush_sentry(timeout: float = 2.0) -> None:
+    """Flush pending Sentry events."""
+    if not _sentry_initialized:
+        return
+
+    with _flush_lock:
+        if not _pending_events:
+            return
+
+        events_to_send = _pending_events.copy()
+        _pending_events.clear()
+
+    # Send all pending events
+    for event in events_to_send:
+        try:
+            _send_to_sentry(event)
+        except Exception:
+            # Silently fail
+            pass
+
+
+def is_sentry_initialized() -> bool:
+    """Check if Sentry is initialized and available."""
+    return _sentry_initialized

{blaxel-0.2.32 → blaxel-0.2.34}/src/blaxel/core/sandbox/default/process.py

@@ -184,55 +184,170 @@ class SandboxProcess(SandboxAction):
     ) -> Union[ProcessResponse, ProcessResponseWithLog]:
         """Execute a process in the sandbox."""
         on_log = None
+        on_stdout = None
+        on_stderr = None
+
         if isinstance(process, ProcessRequestWithLog):
             on_log = process.on_log
+            on_stdout = process.on_stdout
+            on_stderr = process.on_stderr
             process = process.to_dict()
 
         if isinstance(process, dict):
             if "on_log" in process:
                 on_log = process["on_log"]
                 del process["on_log"]
+            if "on_stdout" in process:
+                on_stdout = process["on_stdout"]
+                del process["on_stdout"]
+            if "on_stderr" in process:
+                on_stderr = process["on_stderr"]
+                del process["on_stderr"]
             process = ProcessRequest.from_dict(process)
 
         # Store original wait_for_completion setting
         should_wait_for_completion = process.wait_for_completion
 
-        # Always start process without wait_for_completion to avoid server-side blocking
-        if should_wait_for_completion and on_log is not None:
-            process.wait_for_completion = False
-
-        client = self.get_client()
-        response = await client.post("/process", json=process.to_dict())
-        try:
-            content_bytes = await response.aread()
-            self.handle_response_error(response)
-            import json
-
-            response_data = json.loads(content_bytes) if content_bytes else None
-            result = ProcessResponse.from_dict(response_data)
-        finally:
-            await response.aclose()
-
-        # Handle wait_for_completion with parallel log streaming
-        if should_wait_for_completion and on_log is not None:
-            stream_control = self._stream_logs(result.pid, {"on_log": on_log})
+        # When waiting for completion with streaming callbacks, use streaming endpoint
+        if should_wait_for_completion and (on_log or on_stdout or on_stderr):
+            return await self._exec_with_streaming(
+                process, on_log=on_log, on_stdout=on_stdout, on_stderr=on_stderr
+            )
+        else:
+            client = self.get_client()
+            response = await client.post("/process", json=process.to_dict())
             try:
-                # Wait for process completion
-                result = await self.wait(result.pid, interval=500, max_wait=1000 * 60 * 60)
+                content_bytes = await response.aread()
+                self.handle_response_error(response)
+                import json
+
+                response_data = json.loads(content_bytes) if content_bytes else None
+                result = ProcessResponse.from_dict(response_data)
             finally:
-                # Clean up log streaming
-                if stream_control:
-                    stream_control["close"]()
-        else:
-            # For non-blocking execution, set up log streaming immediately if requested
-            if on_log is not None:
-                stream_control = self._stream_logs(result.pid, {"on_log": on_log})
+                await response.aclose()
+
+            if on_log or on_stdout or on_stderr:
+                stream_control = self._stream_logs(
+                    result.pid, {"on_log": on_log, "on_stdout": on_stdout, "on_stderr": on_stderr}
+                )
                 return ProcessResponseWithLog(
                     result,
                     lambda: stream_control["close"]() if stream_control else None,
                 )
 
-        return result
+            return result
+
+    async def _exec_with_streaming(
+        self,
+        process_request: ProcessRequest,
+        on_log: Callable[[str], None] | None = None,
+        on_stdout: Callable[[str], None] | None = None,
+        on_stderr: Callable[[str], None] | None = None,
+    ) -> ProcessResponseWithLog:
+        """Execute a process with streaming response handling for NDJSON."""
+        import json
+
+        headers = (
+            self.sandbox_config.headers
+            if self.sandbox_config.force_url
+            else {**settings.headers, **self.sandbox_config.headers}
+        )
+
+        async with httpx.AsyncClient() as client_instance:
+            async with client_instance.stream(
+                "POST",
+                f"{self.url}/process",
+                headers={
+                    **headers,
+                    "Content-Type": "application/json",
+                    "Accept": "text/event-stream",
+                },
+                json=process_request.to_dict(),
+                timeout=None,
+            ) as response:
+                if response.status_code >= 400:
+                    error_text = await response.aread()
+                    raise Exception(f"Failed to execute process: {error_text}")
+
+                content_type = response.headers.get("Content-Type", "")
+                is_streaming = "application/x-ndjson" in content_type
+
+                # Fallback: server doesn't support streaming, use legacy approach
+                if not is_streaming:
+                    content = await response.aread()
+                    data = json.loads(content)
+                    result = ProcessResponse.from_dict(data)
+
+                    # If process already completed (server waited), emit logs through callbacks
+                    if result.status == "completed" or result.status == "failed":
+                        if result.stdout:
+                            for line in result.stdout.split("\n"):
+                                if line:
+                                    if on_stdout:
+                                        on_stdout(line)
+                        if result.stderr:
+                            for line in result.stderr.split("\n"):
+                                if line:
+                                    if on_stderr:
+                                        on_stderr(line)
+                        if result.logs:
+                            for line in result.logs.split("\n"):
+                                if line:
+                                    if on_log:
+                                        on_log(line)
+
+                    return ProcessResponseWithLog(result, lambda: None)
+
+                # Streaming response handling
+                buffer = ""
+                result = None
+
+                async for chunk in response.aiter_text():
+                    buffer += chunk
+                    lines = buffer.split("\n")
+                    buffer = lines.pop()
+
+                    for line in lines:
+                        if not line.strip():
+                            continue
+                        try:
+                            parsed = json.loads(line)
+                            parsed_type = parsed.get("type", "")
+                            parsed_data = parsed.get("data", "")
+
+                            if parsed_type == "stdout":
+                                if parsed_data:
+                                    if on_stdout:
+                                        on_stdout(parsed_data)
+                                    if on_log:
+                                        on_log(parsed_data)
+                            elif parsed_type == "stderr":
+                                if parsed_data:
+                                    if on_stderr:
+                                        on_stderr(parsed_data)
+                                    if on_log:
+                                        on_log(parsed_data)
+                            elif parsed_type == "result":
+                                try:
+                                    result = ProcessResponse.from_dict(json.loads(parsed_data))
+                                except Exception:
+                                    raise Exception(f"Failed to parse result JSON: {parsed_data}")
+                        except json.JSONDecodeError:
+                            continue
+
+                # Process any remaining buffer
+                if buffer.strip():
+                    if buffer.startswith("result:"):
+                        json_str = buffer[7:]
+                        try:
+                            result = ProcessResponse.from_dict(json.loads(json_str))
+                        except Exception:
+                            raise Exception(f"Failed to parse result JSON: {json_str}")
+
+                if not result:
+                    raise Exception("No result received from streaming response")
+
+                return ProcessResponseWithLog(result, lambda: None)
 
     async def wait(
         self, identifier: str, max_wait: int = 60000, interval: int = 1000