genai-otel-instrument 0.1.14__py3-none-any.whl → 0.1.17__py3-none-any.whl

genai_otel/__version__.py

@@ -1,34 +1,34 @@
-# file generated by setuptools-scm
-# don't change, don't track in version control
-
-__all__ = [
-    "__version__",
-    "__version_tuple__",
-    "version",
-    "version_tuple",
-    "__commit_id__",
-    "commit_id",
-]
-
-TYPE_CHECKING = False
-if TYPE_CHECKING:
-    from typing import Tuple
-    from typing import Union
-
-    VERSION_TUPLE = Tuple[Union[int, str], ...]
-    COMMIT_ID = Union[str, None]
-else:
-    VERSION_TUPLE = object
-    COMMIT_ID = object
-
-version: str
-__version__: str
-__version_tuple__: VERSION_TUPLE
-version_tuple: VERSION_TUPLE
-commit_id: COMMIT_ID
-__commit_id__: COMMIT_ID
-
-__version__ = version = '0.1.14'
-__version_tuple__ = version_tuple = (0, 1, 14)
-
-__commit_id__ = commit_id = None
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
+else:
+    VERSION_TUPLE = object
+    COMMIT_ID = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
+
+__version__ = version = '0.1.17'
+__version_tuple__ = version_tuple = (0, 1, 17)
+
+__commit_id__ = commit_id = None

genai_otel/auto_instrument.py

@@ -186,13 +186,8 @@ def setup_auto_instrumentation(config: OTelConfig):
 
     logger.debug(f"OTelConfig endpoint: {config.endpoint}")
     if config.endpoint:
-        # Convert timeout to float safely
-        timeout_str = os.getenv("OTEL_EXPORTER_OTLP_TIMEOUT", "10.0")
-        try:
-            timeout = float(timeout_str)
-        except (ValueError, TypeError):
-            logger.warning(f"Invalid timeout value '{timeout_str}', using default 10.0")
-            timeout = 10.0
+        # Use timeout from config (already validated as int)
+        timeout = config.exporter_timeout
 
         # CRITICAL FIX: Set endpoint in environment variable so exporters can append correct paths
         # The exporters only call _append_trace_path() when reading from env vars
@@ -221,7 +216,7 @@ def setup_auto_instrumentation(config: OTelConfig):
         os.environ["OTEL_PYTHON_REQUESTS_EXCLUDED_URLS"] = ",".join(excluded_urls)
         logger.info(f"Excluded OTLP endpoints from instrumentation: {base_url}")
 
-        # Set timeout in environment variable
+        # Set timeout in environment variable as integer string (OTLP exporters expect int)
         os.environ["OTEL_EXPORTER_OTLP_TIMEOUT"] = str(timeout)
 
         # Create exporters WITHOUT passing endpoint (let them read from env vars)

genai_otel/config.py

@@ -62,6 +62,22 @@ def _get_enabled_instrumentors() -> List[str]:
     return DEFAULT_INSTRUMENTORS
 
 
+def _get_exporter_timeout() -> int:
+    """
+    Gets the OTLP exporter timeout from environment variable.
+    Returns default of 60 seconds if not set or invalid.
+    """
+    timeout_str = os.getenv("OTEL_EXPORTER_OTLP_TIMEOUT", "60")
+    try:
+        return int(timeout_str)
+    except ValueError:
+        logger.warning(
+            f"Invalid timeout value '{timeout_str}' in OTEL_EXPORTER_OTLP_TIMEOUT. "
+            f"Using default of 60 seconds."
+        )
+        return 60
+
+
 @dataclass
 class OTelConfig:
     """Configuration for OpenTelemetry instrumentation.
@@ -97,9 +113,7 @@ class OTelConfig:
     enable_co2_tracking: bool = field(
         default_factory=lambda: os.getenv("GENAI_ENABLE_CO2_TRACKING", "false").lower() == "true"
     )
-    exporter_timeout: float = field(
-        default_factory=lambda: float(os.getenv("OTEL_EXPORTER_OTLP_TIMEOUT", "60.0"))
-    )
+    exporter_timeout: int = field(default_factory=_get_exporter_timeout)
     carbon_intensity: float = field(
         default_factory=lambda: float(os.getenv("GENAI_CARBON_INTENSITY", "475.0"))
     )  # gCO2e/kWh

genai_otel/instrumentors/langchain_instrumentor.py

@@ -1,11 +1,13 @@
 """OpenTelemetry instrumentor for the LangChain framework.
 
 This instrumentor automatically traces various components within LangChain,
-including chains and agents, capturing relevant attributes for observability.
+including chains, agents, and chat models, capturing relevant attributes for observability.
 """
 
+import asyncio
+import functools
 import logging
-from typing import Dict, Optional
+from typing import Any, Dict, Optional
 
 from ..config import OTelConfig
 from .base import BaseInstrumentor
@@ -20,6 +22,7 @@ class LangChainInstrumentor(BaseInstrumentor):
         """Initialize the instrumentor."""
         super().__init__()
         self._langchain_available = False
+        self._langchain_core_available = False
         self._check_availability()
 
     def _check_availability(self):
@@ -33,13 +36,35 @@ class LangChainInstrumentor(BaseInstrumentor):
             logger.debug("langchain library not installed, instrumentation will be skipped")
             self._langchain_available = False
 
+        # Check for langchain_core (required for chat model instrumentation)
+        try:
+            import langchain_core
+
+            self._langchain_core_available = True
+            logger.debug("langchain_core library detected and available for instrumentation")
+        except ImportError:
+            logger.debug(
+                "langchain_core library not installed, chat model instrumentation will be skipped"
+            )
+            self._langchain_core_available = False
+
     def instrument(self, config: OTelConfig):
-        """Instrument  langchain available if available."""
+        """Instrument langchain components if available."""
         if not self._langchain_available:
             logger.debug("Skipping instrumentation - library not available")
             return
 
         self.config = config
+
+        # Instrument chains and agents
+        self._instrument_chains_and_agents()
+
+        # Instrument chat models if langchain_core is available
+        if self._langchain_core_available:
+            self._instrument_chat_models()
+
+    def _instrument_chains_and_agents(self):
+        """Instrument LangChain chains and agents."""
         try:
             from langchain.agents.agent import AgentExecutor
             from langchain.chains.base import Chain
@@ -67,9 +92,247 @@ class LangChainInstrumentor(BaseInstrumentor):
                     return result
 
             AgentExecutor.__call__ = wrapped_agent_call
+            logger.debug("Chains and agents instrumentation completed")
 
         except ImportError:
-            pass
+            logger.debug("Could not import chains or agents, skipping instrumentation")
+
+    def _instrument_chat_models(self):
+        """Instrument LangChain chat models."""
+        try:
+            from langchain_core.language_models.chat_models import BaseChatModel
+
+            # Instrument invoke method
+            original_invoke = BaseChatModel.invoke
+
+            @functools.wraps(original_invoke)
+            def wrapped_invoke(instance, *args, **kwargs):
+                model_name = self._get_model_name(instance)
+                with self.tracer.start_as_current_span("langchain.chat_model.invoke") as span:
+                    self._set_chat_attributes(span, instance, args, kwargs, model_name)
+
+                    result = original_invoke(instance, *args, **kwargs)
+
+                    # Extract and record usage information
+                    self._extract_and_record_usage(span, result, model_name)
+
+                    return result
+
+            BaseChatModel.invoke = wrapped_invoke
+
+            # Instrument ainvoke (async invoke) method
+            original_ainvoke = BaseChatModel.ainvoke
+
+            @functools.wraps(original_ainvoke)
+            async def wrapped_ainvoke(instance, *args, **kwargs):
+                model_name = self._get_model_name(instance)
+                with self.tracer.start_as_current_span("langchain.chat_model.ainvoke") as span:
+                    self._set_chat_attributes(span, instance, args, kwargs, model_name)
+
+                    result = await original_ainvoke(instance, *args, **kwargs)
+
+                    # Extract and record usage information
+                    self._extract_and_record_usage(span, result, model_name)
+
+                    return result
+
+            BaseChatModel.ainvoke = wrapped_ainvoke
+
+            # Instrument batch method
+            original_batch = BaseChatModel.batch
+
+            @functools.wraps(original_batch)
+            def wrapped_batch(instance, *args, **kwargs):
+                model_name = self._get_model_name(instance)
+                with self.tracer.start_as_current_span("langchain.chat_model.batch") as span:
+                    span.set_attribute("langchain.chat_model.name", model_name)
+                    span.set_attribute("langchain.chat_model.operation", "batch")
+
+                    # Get batch size
+                    if args and len(args) > 0:
+                        batch_size = len(args[0]) if hasattr(args[0], "__len__") else 1
+                        span.set_attribute("langchain.chat_model.batch_size", batch_size)
+
+                    result = original_batch(instance, *args, **kwargs)
+
+                    return result
+
+            BaseChatModel.batch = wrapped_batch
+
+            # Instrument abatch (async batch) method
+            original_abatch = BaseChatModel.abatch
+
+            @functools.wraps(original_abatch)
+            async def wrapped_abatch(instance, *args, **kwargs):
+                model_name = self._get_model_name(instance)
+                with self.tracer.start_as_current_span("langchain.chat_model.abatch") as span:
+                    span.set_attribute("langchain.chat_model.name", model_name)
+                    span.set_attribute("langchain.chat_model.operation", "abatch")
+
+                    # Get batch size
+                    if args and len(args) > 0:
+                        batch_size = len(args[0]) if hasattr(args[0], "__len__") else 1
+                        span.set_attribute("langchain.chat_model.batch_size", batch_size)
+
+                    result = await original_abatch(instance, *args, **kwargs)
+
+                    return result
+
+            BaseChatModel.abatch = wrapped_abatch
+
+            logger.info("LangChain chat models instrumentation completed")
+
+        except ImportError as e:
+            logger.debug(f"Could not import langchain_core chat models: {e}")
+        except Exception as e:
+            logger.error(f"Error instrumenting chat models: {e}", exc_info=True)
+
+    def _get_model_name(self, instance: Any) -> str:
+        """Extract model name from chat model instance."""
+        # Try common attribute names for model name
+        for attr in ["model_name", "model", "model_id"]:
+            if hasattr(instance, attr):
+                value = getattr(instance, attr)
+                if value:
+                    return str(value)
+
+        # Fallback to class name
+        return instance.__class__.__name__
+
+    def _set_chat_attributes(self, span, instance: Any, args: tuple, kwargs: dict, model_name: str):
+        """Set span attributes for chat model invocations."""
+        span.set_attribute("langchain.chat_model.name", model_name)
+        span.set_attribute("langchain.chat_model.operation", "invoke")
+
+        # Try to extract provider from class name or module
+        provider = self._extract_provider(instance)
+        if provider:
+            span.set_attribute("langchain.chat_model.provider", provider)
+
+        # Count messages if available
+        if args and len(args) > 0:
+            messages = args[0]
+            if hasattr(messages, "__len__"):
+                span.set_attribute("langchain.chat_model.message_count", len(messages))
+
+    def _extract_provider(self, instance: Any) -> Optional[str]:
+        """Extract provider name from chat model instance."""
+        class_name = instance.__class__.__name__.lower()
+        module_name = instance.__class__.__module__.lower()
+
+        # Map class names to providers
+        provider_mapping = {
+            "openai": "openai",
+            "anthropic": "anthropic",
+            "google": "google",
+            "ollama": "ollama",
+            "bedrock": "bedrock",
+            "cohere": "cohere",
+            "groq": "groq",
+            "mistral": "mistral",
+        }
+
+        # Check class name
+        for key, value in provider_mapping.items():
+            if key in class_name:
+                return value
+
+        # Check module name
+        for key, value in provider_mapping.items():
+            if key in module_name:
+                return value
+
+        return None
+
+    def _extract_and_record_usage(self, span, result: Any, model_name: str):
+        """Extract usage information from LangChain response."""
+        try:
+            # LangChain responses may have usage_metadata or response_metadata
+            usage_data = None
+
+            # Check for usage_metadata (newer LangChain versions)
+            if hasattr(result, "usage_metadata") and result.usage_metadata:
+                usage_data = result.usage_metadata
+
+            # Check for response_metadata (older versions)
+            elif hasattr(result, "response_metadata") and result.response_metadata:
+                metadata = result.response_metadata
+                if "token_usage" in metadata:
+                    usage_data = metadata["token_usage"]
+                elif "usage" in metadata:
+                    usage_data = metadata["usage"]
+
+            if usage_data:
+                # Extract token counts (handle both dict and object)
+                if isinstance(usage_data, dict):
+                    prompt_tokens = usage_data.get("input_tokens") or usage_data.get(
+                        "prompt_tokens"
+                    )
+                    completion_tokens = usage_data.get("output_tokens") or usage_data.get(
+                        "completion_tokens"
+                    )
+                    total_tokens = usage_data.get("total_tokens")
+                else:
+                    prompt_tokens = getattr(usage_data, "input_tokens", None) or getattr(
+                        usage_data, "prompt_tokens", None
+                    )
+                    completion_tokens = getattr(usage_data, "output_tokens", None) or getattr(
+                        usage_data, "completion_tokens", None
+                    )
+                    total_tokens = getattr(usage_data, "total_tokens", None)
+
+                # Set span attributes
+                if prompt_tokens:
+                    span.set_attribute("gen_ai.usage.prompt_tokens", int(prompt_tokens))
+                if completion_tokens:
+                    span.set_attribute("gen_ai.usage.completion_tokens", int(completion_tokens))
+                if total_tokens:
+                    span.set_attribute("gen_ai.usage.total_tokens", int(total_tokens))
+                elif prompt_tokens and completion_tokens:
+                    span.set_attribute(
+                        "gen_ai.usage.total_tokens", int(prompt_tokens) + int(completion_tokens)
+                    )
+
+        except Exception as e:
+            logger.debug(f"Could not extract usage information: {e}")
 
     def _extract_usage(self, result) -> Optional[Dict[str, int]]:
+        """Extract usage information for BaseInstrumentor compatibility."""
+        try:
+            usage_data = None
+
+            if hasattr(result, "usage_metadata") and result.usage_metadata:
+                usage_data = result.usage_metadata
+            elif hasattr(result, "response_metadata") and result.response_metadata:
+                metadata = result.response_metadata
+                if "token_usage" in metadata:
+                    usage_data = metadata["token_usage"]
+                elif "usage" in metadata:
+                    usage_data = metadata["usage"]
+
+            if usage_data:
+                if isinstance(usage_data, dict):
+                    prompt_tokens = usage_data.get("input_tokens") or usage_data.get(
+                        "prompt_tokens"
+                    )
+                    completion_tokens = usage_data.get("output_tokens") or usage_data.get(
+                        "completion_tokens"
+                    )
+                else:
+                    prompt_tokens = getattr(usage_data, "input_tokens", None) or getattr(
+                        usage_data, "prompt_tokens", None
+                    )
+                    completion_tokens = getattr(usage_data, "output_tokens", None) or getattr(
+                        usage_data, "completion_tokens", None
+                    )
+
+                if prompt_tokens or completion_tokens:
+                    return {
+                        "prompt_tokens": int(prompt_tokens) if prompt_tokens else 0,
+                        "completion_tokens": int(completion_tokens) if completion_tokens else 0,
+                        "total_tokens": int(prompt_tokens or 0) + int(completion_tokens or 0),
+                    }
+        except Exception:
+            pass
+
         return None