genai-otel-instrument 0.1.4.dev0__py3-none-any.whl → 0.1.7.dev0__py3-none-any.whl

genai_otel/instrumentors/langchain_instrumentor.py

@@ -1,75 +1,75 @@
-"""OpenTelemetry instrumentor for the LangChain framework.
-
-This instrumentor automatically traces various components within LangChain,
-including chains and agents, capturing relevant attributes for observability.
-"""
-
-import logging
-from typing import Dict, Optional
-
-from ..config import OTelConfig
-from .base import BaseInstrumentor
-
-logger = logging.getLogger(__name__)
-
-
-class LangChainInstrumentor(BaseInstrumentor):
-    """Instrumentor for LangChain"""
-
-    def __init__(self):
-        """Initialize the instrumentor."""
-        super().__init__()
-        self._langchain_available = False
-        self._check_availability()
-
-    def _check_availability(self):
-        """Check if langchain library is available."""
-        try:
-            import langchain
-
-            self._langchain_available = True
-            logger.debug("langchain library detected and available for instrumentation")
-        except ImportError:
-            logger.debug("langchain library not installed, instrumentation will be skipped")
-            self._langchain_available = False
-
-    def instrument(self, config: OTelConfig):
-        """Instrument  langchain available if available."""
-        if not self._langchain_available:
-            logger.debug("Skipping instrumentation - library not available")
-            return
-
-        self.config = config
-        try:
-            from langchain.agents.agent import AgentExecutor
-            from langchain.chains.base import Chain
-
-            # Instrument Chains
-            original_call = Chain.__call__
-
-            def wrapped_call(instance, *args, **kwargs):
-                chain_type = instance.__class__.__name__
-                with self.tracer.start_as_current_span(f"langchain.chain.{chain_type}") as span:
-                    span.set_attribute("langchain.chain.type", chain_type)
-                    result = original_call(instance, *args, **kwargs)
-                    return result
-
-            Chain.__call__ = wrapped_call
-
-            # Instrument Agents
-            original_agent_call = AgentExecutor.__call__
-
-            def wrapped_agent_call(instance, *args, **kwargs):
-                with self.tracer.start_as_current_span("langchain.agent.execute") as span:
-                    agent_name = getattr(instance, "agent", {}).get("name", "unknown")
-                    span.set_attribute("langchain.agent.name", agent_name)
-                    result = original_agent_call(instance, *args, **kwargs)
-                    return result
-
-            AgentExecutor.__call__ = wrapped_agent_call
-
-        except ImportError:
-            pass
-
-    def _extract_usage(self, result) -> Optional[Dict[str, int]]:
-        return None
+"""OpenTelemetry instrumentor for the LangChain framework.
+
+This instrumentor automatically traces various components within LangChain,
+including chains and agents, capturing relevant attributes for observability.
+"""
+
+import logging
+from typing import Dict, Optional
+
+from ..config import OTelConfig
+from .base import BaseInstrumentor
+
+logger = logging.getLogger(__name__)
+
+
+class LangChainInstrumentor(BaseInstrumentor):
+    """Instrumentor for LangChain"""
+
+    def __init__(self):
+        """Initialize the instrumentor."""
+        super().__init__()
+        self._langchain_available = False
+        self._check_availability()
+
+    def _check_availability(self):
+        """Check if langchain library is available."""
+        try:
+            import langchain
+
+            self._langchain_available = True
+            logger.debug("langchain library detected and available for instrumentation")
+        except ImportError:
+            logger.debug("langchain library not installed, instrumentation will be skipped")
+            self._langchain_available = False
+
+    def instrument(self, config: OTelConfig):
+        """Instrument  langchain available if available."""
+        if not self._langchain_available:
+            logger.debug("Skipping instrumentation - library not available")
+            return
+
+        self.config = config
+        try:
+            from langchain.agents.agent import AgentExecutor
+            from langchain.chains.base import Chain
+
+            # Instrument Chains
+            original_call = Chain.__call__
+
+            def wrapped_call(instance, *args, **kwargs):
+                chain_type = instance.__class__.__name__
+                with self.tracer.start_as_current_span(f"langchain.chain.{chain_type}") as span:
+                    span.set_attribute("langchain.chain.type", chain_type)
+                    result = original_call(instance, *args, **kwargs)
+                    return result
+
+            Chain.__call__ = wrapped_call
+
+            # Instrument Agents
+            original_agent_call = AgentExecutor.__call__
+
+            def wrapped_agent_call(instance, *args, **kwargs):
+                with self.tracer.start_as_current_span("langchain.agent.execute") as span:
+                    agent_name = getattr(instance, "agent", {}).get("name", "unknown")
+                    span.set_attribute("langchain.agent.name", agent_name)
+                    result = original_agent_call(instance, *args, **kwargs)
+                    return result
+
+            AgentExecutor.__call__ = wrapped_agent_call
+
+        except ImportError:
+            pass
+
+    def _extract_usage(self, result) -> Optional[Dict[str, int]]:
+        return None

genai_otel/instrumentors/mistralai_instrumentor.py

@@ -32,9 +32,8 @@ class MistralAIInstrumentor(BaseInstrumentor):
             # In Mistral SDK v1.0+, structure is:
             # - Mistral client has .chat and .embeddings properties
             # - These are bound methods that call internal APIs
-
             # Store original methods at module level before any instances are created
-            if not hasattr(Mistral, '_genai_otel_instrumented'):
+            if not hasattr(Mistral, "_genai_otel_instrumented"):
                 self._wrap_mistral_methods(Mistral, wrapt)
                 Mistral._genai_otel_instrumented = True
                 logger.info("MistralAI instrumentation enabled (v1.0+ SDK)")
@@ -54,29 +53,21 @@ class MistralAIInstrumentor(BaseInstrumentor):
             from mistralai.embeddings import Embeddings
 
             # Wrap Chat.complete method
-            if hasattr(Chat, 'complete'):
+            if hasattr(Chat, "complete"):
                 wrapt.wrap_function_wrapper(
-                    'mistralai.chat',
-                    'Chat.complete',
-                    self._wrap_chat_complete
+                    "mistralai.chat", "Chat.complete", self._wrap_chat_complete
                 )
                 logger.debug("Wrapped Mistral Chat.complete")
 
             # Wrap Chat.stream method
-            if hasattr(Chat, 'stream'):
-                wrapt.wrap_function_wrapper(
-                    'mistralai.chat',
-                    'Chat.stream',
-                    self._wrap_chat_stream
-                )
+            if hasattr(Chat, "stream"):
+                wrapt.wrap_function_wrapper("mistralai.chat", "Chat.stream", self._wrap_chat_stream)
                 logger.debug("Wrapped Mistral Chat.stream")
 
             # Wrap Embeddings.create method
-            if hasattr(Embeddings, 'create'):
+            if hasattr(Embeddings, "create"):
                 wrapt.wrap_function_wrapper(
-                    'mistralai.embeddings',
-                    'Embeddings.create',
-                    self._wrap_embeddings_create
+                    "mistralai.embeddings", "Embeddings.create", self._wrap_embeddings_create
                 )
                 logger.debug("Wrapped Mistral Embeddings.create")
 
@@ -140,15 +131,11 @@ class MistralAIInstrumentor(BaseInstrumentor):
             stream = wrapped(*args, **kwargs)
 
             # Wrap the stream with our tracking wrapper
-            return self._StreamWrapper(
-                stream, span, self, model, start_time, span_name
-            )
+            return self._StreamWrapper(stream, span, self, model, start_time, span_name)
 
         except Exception as e:
             if self.error_counter:
-                self.error_counter.add(
-                    1, {"operation": span_name, "error.type": type(e).__name__}
-                )
+                self.error_counter.add(1, {"operation": span_name, "error.type": type(e).__name__})
             span.record_exception(e)
             span.end()
             raise
@@ -240,10 +227,7 @@ class MistralAIInstrumentor(BaseInstrumentor):
 
                         mock_response = MockResponse(self._usage)
                         self._instrumentor._record_result_metrics(
-                            self._span,
-                            mock_response,
-                            self._start_time,
-                            {"model": self._model}
+                            self._span, mock_response, self._start_time, {"model": self._model}
                         )
 
                 finally:
@@ -255,21 +239,21 @@ class MistralAIInstrumentor(BaseInstrumentor):
             """Process a streaming chunk to extract usage."""
             try:
                 # Mistral streaming chunks have: data.choices[0].delta.content
-                if hasattr(chunk, 'data'):
+                if hasattr(chunk, "data"):
                     data = chunk.data
-                    if hasattr(data, 'choices') and len(data.choices) > 0:
+                    if hasattr(data, "choices") and len(data.choices) > 0:
                         delta = data.choices[0].delta
-                        if hasattr(delta, 'content') and delta.content:
+                        if hasattr(delta, "content") and delta.content:
                             self._response_text += delta.content
 
                     # Extract usage if available on final chunk
-                    if hasattr(data, 'usage') and data.usage:
+                    if hasattr(data, "usage") and data.usage:
                         usage = data.usage
-                        if hasattr(usage, 'prompt_tokens'):
+                        if hasattr(usage, "prompt_tokens"):
                             self._usage["prompt_tokens"] = usage.prompt_tokens
-                        if hasattr(usage, 'completion_tokens'):
+                        if hasattr(usage, "completion_tokens"):
                             self._usage["completion_tokens"] = usage.completion_tokens
-                        if hasattr(usage, 'total_tokens'):
+                        if hasattr(usage, "total_tokens"):
                             self._usage["total_tokens"] = usage.total_tokens
 
             except Exception as e: