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

genai_otel/__version__.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.1.16'
-__version_tuple__ = version_tuple = (0, 1, 16)
+__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

{genai_otel_instrument-0.1.16.dist-info → genai_otel_instrument-0.1.17.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: genai-otel-instrument
-Version: 0.1.16
+Version: 0.1.17
 Summary: Comprehensive OpenTelemetry auto-instrumentation for LLM/GenAI applications
 Author-email: Kshitij Thakkar <kshitijthakkar@rocketmail.com>
 License: AGPL-3.0-or-later
@@ -529,7 +529,8 @@ GENAI_ENABLE_MCP_INSTRUMENTATION=true
 GENAI_GPU_COLLECTION_INTERVAL=5  # GPU metrics collection interval in seconds (default: 5)
 OTEL_SERVICE_INSTANCE_ID=instance-1 # Optional service instance id
 OTEL_ENVIRONMENT=production # Optional environment
-OTEL_EXPORTER_OTLP_TIMEOUT=10.0 # Optional timeout for OTLP exporter
+OTEL_EXPORTER_OTLP_TIMEOUT=60 # Timeout for OTLP exporter in seconds (default: 60)
+OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf # Protocol: "http/protobuf" (default) or "grpc"
 
 # Semantic conventions (NEW)
 OTEL_SEMCONV_STABILITY_OPT_IN=gen_ai  # "gen_ai" for new conventions only, "gen_ai/dup" for dual emission

{genai_otel_instrument-0.1.16.dist-info → genai_otel_instrument-0.1.17.dist-info}/RECORD

@@ -1,8 +1,8 @@
 genai_otel/__init__.py,sha256=SXh49Ndu2KozUfZxD7AGHCewlUsUz43agsL7-HbeyE0,4476
-genai_otel/__version__.py,sha256=Fs2Vm6Mr4ZbSKXw60jeeSx9iEU9elx4fQcMl_5xXMJI,706
-genai_otel/auto_instrument.py,sha256=uHJGTlSI4UO-sdFtWgxSmNkhd1_GTWvr3S-rY8MQ4E4,16513
+genai_otel/__version__.py,sha256=TtVjjQ5FSnY_MX0ZAPLaNmAfTJWa0sEMBdMs65ngXMM,706
+genai_otel/auto_instrument.py,sha256=MjV-BEiHKCIj6foU5YtGz9bSQoIJkGmL4MObzdXJfho,16340
 genai_otel/cli.py,sha256=mbhaTU0WIAkvPKdIing-guIxPDjEKQftChWQUtPFzkY,3170
-genai_otel/config.py,sha256=2CIbZH8WKkVzr73y9AOWmscvEW-kUwMLSAyOy9BFqGI,7871
+genai_otel/config.py,sha256=VEtk-Iwyj4eLgXD4-c72UIHs9VpFaUqDO8jiwV-rW94,8296
 genai_otel/cost_calculator.py,sha256=BOW-TC41lJ1GcL4hIGZ4NySyV8aro4_juMOe2IqtJ-A,18115
 genai_otel/cost_enriching_exporter.py,sha256=iED7njK21UBKlxRElGfqSs66gMkzDCr8fm-4ZkJBiLU,7874
 genai_otel/cost_enrichment_processor.py,sha256=fQoVosBUgshD9ZRxWpwqqPWYnyhrvKBTJAW0S2H7t1E,7090
@@ -22,7 +22,7 @@ genai_otel/instrumentors/cohere_instrumentor.py,sha256=fsKvHaWvMRAGRbOtybVJVVz-F
 genai_otel/instrumentors/google_ai_instrumentor.py,sha256=ExNo0_OxfCxaRpuUXYU8UZ-ClQRHRLUvf7-kMC6zdc8,2984
 genai_otel/instrumentors/groq_instrumentor.py,sha256=bCm7IDmDyvg0-XuzcCSO5xf9QvDlQGwb7bdQ_ooS6QI,3398
 genai_otel/instrumentors/huggingface_instrumentor.py,sha256=wvolJZnq9YKfJsvNvUnoOpL1tbeGy0DuxVmmmI1_BoA,17815
-genai_otel/instrumentors/langchain_instrumentor.py,sha256=002ZrKP04l7VaYxo7nAAwl-uvMVwpzVehO2oS23ed-o,2685
+genai_otel/instrumentors/langchain_instrumentor.py,sha256=utAPhHXQeYEupDSqQaKdJaKr0PXDLD_VALSfXtXgupk,14037
 genai_otel/instrumentors/llamaindex_instrumentor.py,sha256=zZ1J7W4yQo1Ur6Y5y0UXpDdEx9oDnmsqNIin5Jrv9os,1206
 genai_otel/instrumentors/mistralai_instrumentor.py,sha256=Blo8X4WV-xQe-xF-jhkaGPavkgayANf1F3zCTzuhuL0,12478
 genai_otel/instrumentors/ollama_instrumentor.py,sha256=lv45qf8Cqe_HmF7BIMojZcBFK8AA13uUrCVOKAFhN0k,5286
@@ -38,9 +38,9 @@ genai_otel/mcp_instrumentors/kafka_instrumentor.py,sha256=QJYJC1rvo_zZAIaw-cp_Ic
 genai_otel/mcp_instrumentors/manager.py,sha256=1Pj5lkEOL8Yq1Oeud4ZExN6k6NLIVtTzKnFLNiFdJvw,5895
 genai_otel/mcp_instrumentors/redis_instrumentor.py,sha256=KUbs0dMyfMzU4T0SS8u43I5fvr09lcBBM92I3KCsYUw,943
 genai_otel/mcp_instrumentors/vector_db_instrumentor.py,sha256=2vhnk4PGpfYKr-XlRbnCIOap4BPKHOn--fh-ai2YXlM,9994
-genai_otel_instrument-0.1.16.dist-info/licenses/LICENSE,sha256=upRpn6Eg5iN_1y_TrvgUKxNQdoYy7OY2KybhHTOwTMc,35375
-genai_otel_instrument-0.1.16.dist-info/METADATA,sha256=Tu_ntkx3fiu_RI81QRb7KsuWm64UMtxrdTc_Vj4oJ6w,39510
-genai_otel_instrument-0.1.16.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-genai_otel_instrument-0.1.16.dist-info/entry_points.txt,sha256=E9UqoHA_fq69yNGAY3SRYf5HH94sZT5DiDueiU1v0KM,57
-genai_otel_instrument-0.1.16.dist-info/top_level.txt,sha256=cvCm8PUwvYUSQKruk-x6S-_YuDyhOBk8gD910XICcbg,11
-genai_otel_instrument-0.1.16.dist-info/RECORD,,
+genai_otel_instrument-0.1.17.dist-info/licenses/LICENSE,sha256=upRpn6Eg5iN_1y_TrvgUKxNQdoYy7OY2KybhHTOwTMc,35375
+genai_otel_instrument-0.1.17.dist-info/METADATA,sha256=mP1d8ckN77UgzST7fndQC9VNMa9Ea04RqPuWPYiWug0,39614
+genai_otel_instrument-0.1.17.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+genai_otel_instrument-0.1.17.dist-info/entry_points.txt,sha256=E9UqoHA_fq69yNGAY3SRYf5HH94sZT5DiDueiU1v0KM,57
+genai_otel_instrument-0.1.17.dist-info/top_level.txt,sha256=cvCm8PUwvYUSQKruk-x6S-_YuDyhOBk8gD910XICcbg,11
+genai_otel_instrument-0.1.17.dist-info/RECORD,,