blaxel 0.2.28__tar.gz → 0.2.30__tar.gz

{blaxel-0.2.28 → blaxel-0.2.30}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: blaxel
-Version: 0.2.28
+Version: 0.2.30
 Summary: Blaxel - AI development platform SDK
 Project-URL: Homepage, https://blaxel.ai
 Project-URL: Documentation, https://docs.blaxel.ai

{blaxel-0.2.28 → blaxel-0.2.30}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "blaxel"
-version = "0.2.28"
+version = "0.2.30"
 description = "Blaxel - AI development platform SDK"
 readme = "README.md"
 authors = [{ name = "cploujoux", email = "cploujoux@blaxel.ai" }]

{blaxel-0.2.28 → blaxel-0.2.30}/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.28"
-__commit__ = "a53662270aa3205b3eb563a4e41efc378999d612"
+__version__ = "0.2.30"
+__commit__ = "65a88e27efd0b99c49c23a5cc339865d3bafca2e"
 __sentry_dsn__ = "https://9711de13cd02b285ca4378c01de8dc30@o4508714045276160.ingest.us.sentry.io/4510461121462272"
 __all__ = ["autoload", "settings", "env"]
 

{blaxel-0.2.28 → blaxel-0.2.30}/src/blaxel/core/common/autoload.py

@@ -2,6 +2,7 @@ import atexit
 import logging
 import sys
 import threading
+from asyncio import CancelledError
 
 from sentry_sdk import Client, Hub
 
@@ -19,21 +20,72 @@ logger = logging.getLogger(__name__)
 _sentry_hub: Hub | None = None
 _captured_exceptions: set = set()  # Track already captured exceptions to avoid duplicates
 
+# 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',
+)
+
+
+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 _is_optional_dependency_error(exc_type, exc_value) -> bool:
+    """Check if the exception is an import error for an optional dependency."""
+    # ModuleNotFoundError is a subclass of ImportError, so checking ImportError covers both
+    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
-            exc_id = id(exc_value)
-            if exc_id not in _captured_exceptions:
-                _captured_exceptions.add(exc_id)
+            # 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 IDs to prevent memory leak
+                # Clean up old exception keys to prevent memory leak
                 if len(_captured_exceptions) > 1000:
                     _captured_exceptions.clear()
 

blaxel-0.2.30/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.30/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)

{blaxel-0.2.28 → blaxel-0.2.30}/src/blaxel/telemetry/manager.py

@@ -3,6 +3,8 @@ This module provides utilities for setting up and managing OpenTelemetry instrum
 It includes classes and functions for configuring tracers, meters, loggers, and integrating with FastAPI applications.
 """
 
+from __future__ import annotations
+
 import importlib
 import logging
 import os
@@ -10,27 +12,52 @@ import signal
 import time
 from typing import Any, Dict, List, Type
 
-from opentelemetry import metrics, trace
-from opentelemetry._logs import set_logger_provider
-from opentelemetry.metrics import NoOpMeterProvider
-from opentelemetry.sdk._logs import LoggerProvider, LoggingHandler
-from opentelemetry.sdk.metrics import MeterProvider
-from opentelemetry.sdk.metrics.export import PeriodicExportingMetricReader
-from opentelemetry.sdk.resources import Resource
-from opentelemetry.sdk.trace import TracerProvider
-from opentelemetry.sdk.trace.export import BatchSpanProcessor
-from opentelemetry.trace import NoOpTracerProvider
+try:
+    from opentelemetry import metrics, trace
+    from opentelemetry._logs import set_logger_provider
+    from opentelemetry.metrics import NoOpMeterProvider
+    from opentelemetry.sdk._logs import LoggerProvider, LoggingHandler
+    from opentelemetry.sdk.metrics import MeterProvider
+    from opentelemetry.sdk.metrics.export import PeriodicExportingMetricReader
+    from opentelemetry.sdk.resources import Resource
+    from opentelemetry.sdk.trace import TracerProvider
+    from opentelemetry.sdk.trace.export import BatchSpanProcessor
+    from opentelemetry.trace import NoOpTracerProvider
+
+    _OPENTELEMETRY_AVAILABLE = True
+except ImportError:
+    _OPENTELEMETRY_AVAILABLE = False
+    metrics = None
+    trace = None
+    set_logger_provider = None
+    NoOpMeterProvider = None
+    LoggerProvider = None
+    LoggingHandler = None
+    MeterProvider = None
+    PeriodicExportingMetricReader = None
+    Resource = None
+    TracerProvider = None
+    BatchSpanProcessor = None
+    NoOpTracerProvider = None
 
 from blaxel.core.common import Settings
 
-from .exporters import (
-    DynamicHeadersLogExporter,
-    DynamicHeadersMetricExporter,
-    DynamicHeadersSpanExporter,
-)
-from .instrumentation.map import MAPPINGS
-from .log.log import AsyncLogRecordProcessor
-from .span import DefaultAttributesSpanProcessor
+if _OPENTELEMETRY_AVAILABLE:
+    from .exporters import (
+        DynamicHeadersLogExporter,
+        DynamicHeadersMetricExporter,
+        DynamicHeadersSpanExporter,
+    )
+    from .instrumentation.map import MAPPINGS
+    from .log.log import AsyncLogRecordProcessor
+    from .span import DefaultAttributesSpanProcessor
+else:
+    DynamicHeadersLogExporter = None
+    DynamicHeadersMetricExporter = None
+    DynamicHeadersSpanExporter = None
+    MAPPINGS = {}
+    AsyncLogRecordProcessor = None
+    DefaultAttributesSpanProcessor = None
 
 logger = logging.getLogger(__name__)
 
@@ -46,6 +73,8 @@ class TelemetryManager:
 
     @property
     def enabled(self) -> bool:
+        if not _OPENTELEMETRY_AVAILABLE:
+            return False
         return (self.settings and self.settings.enable_opentelemetry) or False
 
     @property
@@ -127,6 +156,9 @@ class TelemetryManager:
     def initialize(self, settings: Settings):
         """Initialize the telemetry system."""
         self.settings = settings
+        if not _OPENTELEMETRY_AVAILABLE:
+            logger.debug("OpenTelemetry not available, telemetry disabled")
+            return
         if not self.enabled or self.initialized:
             return
 

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

@@ -1,6 +0,0 @@
-"""Blaxel telemetry module."""
-
-from .exporters import *  # noqa: F403, F401
-from .instrumentation import *  # noqa: F403, F401
-from .log import *  # noqa: F403, F401
-from .manager import *  # noqa: F403, F401

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

@@ -1,45 +0,0 @@
-from typing import Callable, Dict, Sequence
-
-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
-
-
-class DynamicHeadersSpanExporter(OTLPSpanExporter):
-    """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):
-    """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,
-        timeout_millis: float = 10_000,
-        **kwargs,
-    ) -> MetricExportResult:
-        self._session.headers.update(self._get_headers())
-        return super().export(metrics_data, timeout_millis, **kwargs)
-
-class DynamicHeadersLogExporter(OTLPLogExporter):
-    """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]):
-        self._session.headers.update(self._get_headers())
-        return super().export(batch)