lucidicai 1.3.2__py3-none-any.whl → 2.0.1__py3-none-any.whl

lucidicai/telemetry/otel_handlers.py

@@ -1,4 +1,7 @@
-"""OpenTelemetry-based handlers that maintain backward compatibility"""
+"""OpenTelemetry-based handlers that maintain backward compatibility
+
+Adds guards to avoid repeated monkey-patching under concurrent init.
+"""
 import logging
 from typing import Optional
 
@@ -7,6 +10,11 @@ from .otel_init import LucidicTelemetry
 
 logger = logging.getLogger("Lucidic")
 
+import threading
+
+_patch_lock = threading.Lock()
+_openai_patched = False
+_anthropic_patched = False
 
 class OTelOpenAIHandler(BaseProvider):
     """OpenAI handler using OpenTelemetry instrumentation"""
@@ -35,37 +43,27 @@ class OTelOpenAIHandler(BaseProvider):
             
             # Also patch OpenAI client to intercept images
             try:
-                import openai
-                from .utils.universal_image_interceptor import UniversalImageInterceptor, patch_openai_client
-                
-                # Create interceptor for OpenAI
-                interceptor = UniversalImageInterceptor.create_interceptor("openai")
-                
-                # Patch the module-level create method
-                if hasattr(openai, 'ChatCompletion'):
-                    # Old API
-                    original = openai.ChatCompletion.create
-                    openai.ChatCompletion.create = interceptor(original)
-                    
-                # Also patch any client instances that might be created
-                original_client_init = openai.OpenAI.__init__
-                def patched_init(self, *args, **kwargs):
-                    original_client_init(self, *args, **kwargs)
-                    # Patch this instance
-                    patch_openai_client(self)
-                
-                openai.OpenAI.__init__ = patched_init
-                
-                # Also patch AsyncOpenAI
-                if hasattr(openai, 'AsyncOpenAI'):
-                    original_async_init = openai.AsyncOpenAI.__init__
-                    def patched_async_init(self, *args, **kwargs):
-                        original_async_init(self, *args, **kwargs)
-                        # Patch this instance
-                        patch_openai_client(self)
-                    
-                    openai.AsyncOpenAI.__init__ = patched_async_init
-                
+                with _patch_lock:
+                    global _openai_patched
+                    if not _openai_patched:
+                        import openai
+                        from .utils.universal_image_interceptor import UniversalImageInterceptor, patch_openai_client
+                        interceptor = UniversalImageInterceptor.create_interceptor("openai")
+                        if hasattr(openai, 'ChatCompletion'):
+                            original = openai.ChatCompletion.create
+                            openai.ChatCompletion.create = interceptor(original)
+                        original_client_init = openai.OpenAI.__init__
+                        def patched_init(self, *args, **kwargs):
+                            original_client_init(self, *args, **kwargs)
+                            patch_openai_client(self)
+                        openai.OpenAI.__init__ = patched_init
+                        if hasattr(openai, 'AsyncOpenAI'):
+                            original_async_init = openai.AsyncOpenAI.__init__
+                            def patched_async_init(self, *args, **kwargs):
+                                original_async_init(self, *args, **kwargs)
+                                patch_openai_client(self)
+                            openai.AsyncOpenAI.__init__ = patched_async_init
+                        _openai_patched = True
             except Exception as e:
                 logger.warning(f"Could not patch OpenAI for image interception: {e}")
             
@@ -108,32 +106,25 @@ class OTelAnthropicHandler(BaseProvider):
             
             # Also patch Anthropic client to intercept images
             try:
-                import anthropic
-                from .utils.universal_image_interceptor import UniversalImageInterceptor, patch_anthropic_client
-                
-                # Create interceptors for Anthropic
-                interceptor = UniversalImageInterceptor.create_interceptor("anthropic")
-                async_interceptor = UniversalImageInterceptor.create_async_interceptor("anthropic")
-                
-                # Patch any client instances that might be created
-                original_client_init = anthropic.Anthropic.__init__
-                def patched_init(self, *args, **kwargs):
-                    original_client_init(self, *args, **kwargs)
-                    # Patch this instance
-                    patch_anthropic_client(self)
-                
-                anthropic.Anthropic.__init__ = patched_init
-                
-                # Also patch async client
-                if hasattr(anthropic, 'AsyncAnthropic'):
-                    original_async_init = anthropic.AsyncAnthropic.__init__
-                    def patched_async_init(self, *args, **kwargs):
-                        original_async_init(self, *args, **kwargs)
-                        # Patch this instance
-                        patch_anthropic_client(self)
-                    
-                    anthropic.AsyncAnthropic.__init__ = patched_async_init
-                
+                with _patch_lock:
+                    global _anthropic_patched
+                    if not _anthropic_patched:
+                        import anthropic
+                        from .utils.universal_image_interceptor import UniversalImageInterceptor, patch_anthropic_client
+                        interceptor = UniversalImageInterceptor.create_interceptor("anthropic")
+                        async_interceptor = UniversalImageInterceptor.create_async_interceptor("anthropic")
+                        original_client_init = anthropic.Anthropic.__init__
+                        def patched_init(self, *args, **kwargs):
+                            original_client_init(self, *args, **kwargs)
+                            patch_anthropic_client(self)
+                        anthropic.Anthropic.__init__ = patched_init
+                        if hasattr(anthropic, 'AsyncAnthropic'):
+                            original_async_init = anthropic.AsyncAnthropic.__init__
+                            def patched_async_init(self, *args, **kwargs):
+                                original_async_init(self, *args, **kwargs)
+                                patch_anthropic_client(self)
+                            anthropic.AsyncAnthropic.__init__ = patched_async_init
+                        _anthropic_patched = True
             except Exception as e:
                 logger.warning(f"Could not patch Anthropic for image interception: {e}")
             
@@ -356,4 +347,161 @@ class OTelLiteLLMHandler(BaseProvider):
             logger.info("[OTel LiteLLM Handler] Instrumentation disabled")
             
         except Exception as e:
-            logger.error(f"Error disabling LiteLLM instrumentation: {e}")
+            logger.error(f"Error disabling LiteLLM instrumentation: {e}")
+
+
+class OTelBedrockHandler(BaseProvider):
+    """AWS Bedrock handler using OpenTelemetry instrumentation"""
+    
+    def __init__(self):
+        super().__init__()
+        self._provider_name = "Bedrock"
+        self.telemetry = LucidicTelemetry()
+    
+    def handle_response(self, response, kwargs, session: Optional = None):
+        return response
+    
+    def override(self):
+        try:
+            from lucidicai.client import Client
+            client = Client()
+            if not self.telemetry.is_initialized():
+                self.telemetry.initialize(agent_id=client.agent_id)
+            self.telemetry.instrument_providers(["bedrock"])
+            logger.info("[OTel Bedrock Handler] Instrumentation enabled")
+        except Exception as e:
+            logger.error(f"Failed to enable Bedrock instrumentation: {e}")
+            raise
+    
+    def undo_override(self):
+        logger.info("[OTel Bedrock Handler] Instrumentation will be disabled on shutdown")
+
+
+class OTelGoogleGenerativeAIHandler(BaseProvider):
+    """Google Generative AI handler using OpenTelemetry instrumentation"""
+    
+    def __init__(self):
+        super().__init__()
+        self._provider_name = "Google Generative AI"
+        self.telemetry = LucidicTelemetry()
+    
+    def handle_response(self, response, kwargs, session: Optional = None):
+        return response
+    
+    def override(self):
+        try:
+            from lucidicai.client import Client
+            client = Client()
+            if not self.telemetry.is_initialized():
+                self.telemetry.initialize(agent_id=client.agent_id)
+            self.telemetry.instrument_providers(["google"])
+            # Best-effort image interception for Google clients where applicable
+            try:
+                from .utils.universal_image_interceptor import patch_google_client, patch_google_genai
+                _ = patch_google_client
+                patch_google_genai()
+            except Exception as e:
+                logger.debug(f"[OTel Google Handler] Image interception not applied: {e}")
+            logger.info("[OTel Google Handler] Instrumentation enabled")
+        except Exception as e:
+            logger.error(f"Failed to enable Google Generative AI instrumentation: {e}")
+            raise
+    
+    def undo_override(self):
+        logger.info("[OTel Google Handler] Instrumentation will be disabled on shutdown")
+
+
+class OTelVertexAIHandler(BaseProvider):
+    """Vertex AI handler using OpenTelemetry instrumentation"""
+    
+    def __init__(self):
+        super().__init__()
+        self._provider_name = "Vertex AI"
+        self.telemetry = LucidicTelemetry()
+    
+    def handle_response(self, response, kwargs, session: Optional = None):
+        return response
+    
+    def override(self):
+        try:
+            from lucidicai.client import Client
+            client = Client()
+            if not self.telemetry.is_initialized():
+                self.telemetry.initialize(agent_id=client.agent_id)
+            self.telemetry.instrument_providers(["vertexai"])
+            # Best-effort image interception for Vertex AI clients where applicable
+            try:
+                from .utils.universal_image_interceptor import patch_vertexai_client
+                _ = patch_vertexai_client
+            except Exception as e:
+                logger.debug(f"[OTel Vertex Handler] Image interception not applied: {e}")
+            logger.info("[OTel Vertex Handler] Instrumentation enabled")
+        except Exception as e:
+            logger.error(f"Failed to enable Vertex AI instrumentation: {e}")
+            raise
+    
+    def undo_override(self):
+        logger.info("[OTel Vertex Handler] Instrumentation will be disabled on shutdown")
+
+
+class OTelCohereHandler(BaseProvider):
+    """Cohere handler using OpenTelemetry instrumentation"""
+    
+    def __init__(self):
+        super().__init__()
+        self._provider_name = "Cohere"
+        self.telemetry = LucidicTelemetry()
+    
+    def handle_response(self, response, kwargs, session: Optional = None):
+        return response
+    
+    def override(self):
+        try:
+            from lucidicai.client import Client
+            client = Client()
+            if not self.telemetry.is_initialized():
+                self.telemetry.initialize(agent_id=client.agent_id)
+            self.telemetry.instrument_providers(["cohere"])
+            logger.info("[OTel Cohere Handler] Instrumentation enabled")
+        except Exception as e:
+            logger.error(f"Failed to enable Cohere instrumentation: {e}")
+            raise
+    
+    def undo_override(self):
+        logger.info("[OTel Cohere Handler] Instrumentation will be disabled on shutdown")
+
+
+class OTelGroqHandler(BaseProvider):
+    """Groq handler using OpenTelemetry instrumentation"""
+    
+    def __init__(self):
+        super().__init__()
+        self._provider_name = "Groq"
+        self.telemetry = LucidicTelemetry()
+    
+    def handle_response(self, response, kwargs, session: Optional = None):
+        return response
+    
+    def override(self):
+        try:
+            from lucidicai.client import Client
+            client = Client()
+            if not self.telemetry.is_initialized():
+                self.telemetry.initialize(agent_id=client.agent_id)
+            self.telemetry.instrument_providers(["groq"])
+            # Best-effort image interception for Groq (OpenAI-compatible)
+            try:
+                import groq  # noqa: F401
+                from .utils.universal_image_interceptor import UniversalImageInterceptor
+                # We cannot reliably patch class constructors here without instance; users calling Groq client
+                # will still have images captured via OpenLLMetry attributes; optional future improvement.
+                _ = UniversalImageInterceptor
+            except Exception as e:
+                logger.debug(f"[OTel Groq Handler] Image interception not applied: {e}")
+            logger.info("[OTel Groq Handler] Instrumentation enabled")
+        except Exception as e:
+            logger.error(f"Failed to enable Groq instrumentation: {e}")
+            raise
+    
+    def undo_override(self):
+        logger.info("[OTel Groq Handler] Instrumentation will be disabled on shutdown")

lucidicai/telemetry/otel_init.py

@@ -1,13 +1,15 @@
-"""OpenTelemetry initialization and configuration for Lucidic"""
+"""OpenTelemetry initialization and configuration for Lucidic
+
+Adds thread-safety and idempotence to avoid duplicate tracer provider
+registration and repeated instrumentation under concurrency.
+"""
 import logging
 from typing import List, Optional
 
 from opentelemetry import trace
 from opentelemetry.sdk.trace import TracerProvider
 from opentelemetry.sdk.resources import Resource
-from opentelemetry.instrumentation.openai import OpenAIInstrumentor
-from opentelemetry.instrumentation.anthropic import AnthropicInstrumentor
-from opentelemetry.instrumentation.langchain import LangchainInstrumentor
+# Instrumentors are imported lazily inside methods to avoid import errors
 
 from .lucidic_span_processor import LucidicSpanProcessor
 from .otel_provider import OpenTelemetryProvider
@@ -15,6 +17,10 @@ from lucidicai.client import Client
 
 logger = logging.getLogger("Lucidic")
 
+import threading
+
+
+_init_lock = threading.Lock()
 
 class LucidicTelemetry:
     """Manages OpenTelemetry initialization for Lucidic"""
@@ -37,59 +43,73 @@ class LucidicTelemetry:
     
     def initialize(self, agent_id: str, service_name: str = "lucidic-ai") -> None:
         """Initialize OpenTelemetry with Lucidic configuration"""
-        if self.tracer_provider:
-            logger.debug("OpenTelemetry already initialized")
-            return
-            
-        try:
-            # Create resource
-            resource = Resource.create({
-                "service.name": service_name,
-                "service.version": "1.0.0",
-                "lucidic.agent_id": agent_id,
-            })
-            
-            # Create tracer provider
-            self.tracer_provider = TracerProvider(resource=resource)
-            
-            # Add our custom span processor for real-time event handling
-            self.span_processor = LucidicSpanProcessor()
-            self.tracer_provider.add_span_processor(self.span_processor)
-            
-            # Set as global provider
-            trace.set_tracer_provider(self.tracer_provider)
-            
-            logger.info("[LucidicTelemetry] OpenTelemetry initialized")
-            
-        except Exception as e:
-            logger.error(f"Failed to initialize OpenTelemetry: {e}")
-            raise
+        with _init_lock:
+            if self.tracer_provider:
+                logger.debug("OpenTelemetry already initialized")
+                return
+            try:
+                resource = Resource.create({
+                    "service.name": service_name,
+                    "service.version": "1.0.0",
+                    "lucidic.agent_id": agent_id,
+                })
+                provider = TracerProvider(resource=resource)
+                processor = LucidicSpanProcessor()
+                provider.add_span_processor(processor)
+                try:
+                    trace.set_tracer_provider(provider)
+                except Exception as e:
+                    # Another provider may already be registered; proceed with ours as a local provider
+                    logger.debug(f"Global tracer provider already set: {e}")
+                self.tracer_provider = provider
+                self.span_processor = processor
+                logger.info("[LucidicTelemetry] OpenTelemetry initialized")
+            except Exception as e:
+                logger.error(f"Failed to initialize OpenTelemetry: {e}")
+                raise
     
     def instrument_providers(self, providers: List[str]) -> None:
         """Instrument specified providers"""
-        for provider in providers:
-            try:
-                if provider == "openai" and provider not in self.instrumentors:
-                    self._instrument_openai()
-                elif provider == "anthropic" and provider not in self.instrumentors:
-                    self._instrument_anthropic()
-                elif provider == "langchain" and provider not in self.instrumentors:
-                    self._instrument_langchain()
-                elif provider == "pydantic_ai":
-                    # Custom instrumentation needed
-                    logger.info(f"[LucidicTelemetry] Pydantic AI will use manual instrumentation")
-                elif provider == "openai_agents":
-                    # OpenAI Agents uses the same OpenAI instrumentation
-                    self._instrument_openai_agents()
-                elif provider == "litellm":
-                    # LiteLLM uses callbacks, not OpenTelemetry instrumentation
-                    logger.info(f"[LucidicTelemetry] LiteLLM will use callback-based instrumentation")
-            except Exception as e:
-                logger.error(f"Failed to instrument {provider}: {e}")
+        with _init_lock:
+            for provider in providers:
+                # Map synonyms to canonical names
+                canonical = provider
+                if provider in ("google_generativeai",):
+                    canonical = "google"
+                elif provider in ("vertex_ai",):
+                    canonical = "vertexai"
+                elif provider in ("aws_bedrock", "amazon_bedrock"):
+                    canonical = "bedrock"
+                try:
+                    if canonical == "openai" and canonical not in self.instrumentors:
+                        self._instrument_openai()
+                    elif canonical == "anthropic" and canonical not in self.instrumentors:
+                        self._instrument_anthropic()
+                    elif canonical == "langchain" and canonical not in self.instrumentors:
+                        self._instrument_langchain()
+                    elif canonical == "google" and canonical not in self.instrumentors:
+                        self._instrument_google_generativeai()
+                    elif canonical == "vertexai" and canonical not in self.instrumentors:
+                        self._instrument_vertexai()
+                    elif canonical == "bedrock" and canonical not in self.instrumentors:
+                        self._instrument_bedrock()
+                    elif canonical == "cohere" and canonical not in self.instrumentors:
+                        self._instrument_cohere()
+                    elif canonical == "groq" and canonical not in self.instrumentors:
+                        self._instrument_groq()
+                    elif canonical == "pydantic_ai":
+                        logger.info(f"[LucidicTelemetry] Pydantic AI will use manual instrumentation")
+                    elif canonical == "openai_agents":
+                        self._instrument_openai_agents()
+                    elif canonical == "litellm":
+                        logger.info(f"[LucidicTelemetry] LiteLLM will use callback-based instrumentation")
+                except Exception as e:
+                    logger.error(f"Failed to instrument {canonical}: {e}")
     
     def _instrument_openai(self) -> None:
         """Instrument OpenAI"""
         try:
+            from opentelemetry.instrumentation.openai import OpenAIInstrumentor
             # Get client for masking function
             client = Client()
             
@@ -125,6 +145,7 @@ class LucidicTelemetry:
     def _instrument_anthropic(self) -> None:
         """Instrument Anthropic"""
         try:
+            from opentelemetry.instrumentation.anthropic import AnthropicInstrumentor
             instrumentor = AnthropicInstrumentor()
             
             # Get client for context
@@ -153,6 +174,7 @@ class LucidicTelemetry:
     def _instrument_langchain(self) -> None:
         """Instrument LangChain"""
         try:
+            from opentelemetry.instrumentation.langchain import LangchainInstrumentor
             instrumentor = LangchainInstrumentor()
             instrumentor.instrument(tracer_provider=self.tracer_provider)
             
@@ -163,6 +185,73 @@ class LucidicTelemetry:
             logger.error(f"Failed to instrument LangChain: {e}")
             raise
 
+    def _instrument_google_generativeai(self) -> None:
+        """Instrument Google Generative AI"""
+        try:
+            from opentelemetry.instrumentation.google_generativeai import GoogleGenerativeAiInstrumentor
+            instrumentor = GoogleGenerativeAiInstrumentor(exception_logger=lambda e: logger.error(f"Google Generative AI error: {e}"))
+            instrumentor.instrument(tracer_provider=self.tracer_provider)
+            self.instrumentors["google"] = instrumentor
+            logger.info("[LucidicTelemetry] Instrumented Google Generative AI")
+        except Exception as e:
+            logger.error(f"Failed to instrument Google Generative AI: {e}")
+            raise
+
+    def _instrument_vertexai(self) -> None:
+        """Instrument Vertex AI"""
+        try:
+            from opentelemetry.instrumentation.vertexai import VertexAIInstrumentor
+            instrumentor = VertexAIInstrumentor(exception_logger=lambda e: logger.error(f"Vertex AI error: {e}"))
+            instrumentor.instrument(tracer_provider=self.tracer_provider)
+            self.instrumentors["vertexai"] = instrumentor
+            logger.info("[LucidicTelemetry] Instrumented Vertex AI")
+        except Exception as e:
+            logger.error(f"Failed to instrument Vertex AI: {e}")
+            raise
+
+    def _instrument_cohere(self) -> None:
+        """Instrument Cohere"""
+        try:
+            from opentelemetry.instrumentation.cohere import CohereInstrumentor
+            instrumentor = CohereInstrumentor(exception_logger=lambda e: logger.error(f"Cohere error: {e}"), use_legacy_attributes=True)
+            instrumentor.instrument(tracer_provider=self.tracer_provider)
+            self.instrumentors["cohere"] = instrumentor
+            logger.info("[LucidicTelemetry] Instrumented Cohere")
+        except Exception as e:
+            logger.error(f"Failed to instrument Cohere: {e}")
+            raise
+
+    def _instrument_bedrock(self) -> None:
+        """Instrument AWS Bedrock"""
+        try:
+            from opentelemetry.instrumentation.bedrock import BedrockInstrumentor
+            instrumentor = BedrockInstrumentor(enrich_token_usage=True, exception_logger=lambda e: logger.error(f"Bedrock error: {e}"))
+            instrumentor.instrument(tracer_provider=self.tracer_provider)
+            self.instrumentors["bedrock"] = instrumentor
+            logger.info("[LucidicTelemetry] Instrumented Bedrock")
+        except Exception as e:
+            logger.error(f"Failed to instrument Bedrock: {e}")
+            raise
+
+    def _instrument_groq(self) -> None:
+        """Instrument Groq"""
+        try:
+            from lucidicai.client import Client
+            client = Client()
+            def get_custom_attributes():
+                attrs = {}
+                if client.session and client.session.active_step:
+                    attrs["lucidic.step_id"] = client.session.active_step.step_id
+                return attrs
+            from opentelemetry.instrumentation.groq import GroqInstrumentor
+            instrumentor = GroqInstrumentor(exception_logger=lambda e: logger.error(f"Groq error: {e}"), use_legacy_attributes=True, get_common_metrics_attributes=get_custom_attributes)
+            instrumentor.instrument(tracer_provider=self.tracer_provider)
+            self.instrumentors["groq"] = instrumentor
+            logger.info("[LucidicTelemetry] Instrumented Groq")
+        except Exception as e:
+            logger.error(f"Failed to instrument Groq: {e}")
+            raise
+
     def _instrument_openai_agents(self) -> None:
         """Instrument OpenAI Agents SDK"""
         try:
@@ -197,4 +286,27 @@ class LucidicTelemetry:
             
     def is_initialized(self) -> bool:
         """Check if telemetry is initialized"""
-        return self.tracer_provider is not None
+        return self.tracer_provider is not None
+
+    def force_flush(self) -> None:
+        """Best-effort force flush of telemetry before shutdown.
+
+        Uses whichever force_flush hooks are available on the provider or span processor.
+        Swallows all exceptions to avoid interfering with process shutdown paths.
+        """
+        try:
+            provider = getattr(self, 'tracer_provider', None)
+            if provider and hasattr(provider, 'force_flush'):
+                try:
+                    provider.force_flush()
+                except Exception:
+                    pass
+            processor = getattr(self, 'span_processor', None)
+            if processor and hasattr(processor, 'force_flush'):
+                try:
+                    processor.force_flush()
+                except Exception:
+                    pass
+        except Exception:
+            # Never raise from force_flush
+            pass

lucidicai/telemetry/otel_provider.py

@@ -8,12 +8,11 @@ from opentelemetry.trace import Tracer, Span
 from opentelemetry.sdk.trace import TracerProvider
 from opentelemetry.sdk.trace.export import BatchSpanProcessor
 from opentelemetry.sdk.resources import Resource
-from opentelemetry.instrumentation.openai import OpenAIInstrumentor
-from opentelemetry.instrumentation.anthropic import AnthropicInstrumentor
-from opentelemetry.instrumentation.langchain import LangchainInstrumentor
+# Instrumentors are imported lazily inside methods to avoid import errors
 from opentelemetry.semconv_ai import SpanAttributes
 
 from .lucidic_exporter import LucidicSpanExporter
+from .lucidic_span_processor import LucidicSpanProcessor
 from .base_provider import BaseProvider
 from lucidicai.client import Client
 
@@ -47,9 +46,17 @@ class OpenTelemetryProvider(BaseProvider):
         lucidic_exporter = LucidicSpanExporter()
         span_processor = BatchSpanProcessor(lucidic_exporter)
         self.tracer_provider.add_span_processor(span_processor)
+        # Also add session-stamping processor to ensure correct attribution
+        try:
+            self.tracer_provider.add_span_processor(LucidicSpanProcessor())
+        except Exception:
+            pass
         
-        # Set as global provider
-        trace.set_tracer_provider(self.tracer_provider)
+        # Set as global provider (ignore if already set)
+        try:
+            trace.set_tracer_provider(self.tracer_provider)
+        except Exception:
+            pass
         
         # Get tracer
         self.tracer = trace.get_tracer(__name__)
@@ -93,6 +100,7 @@ class OpenTelemetryProvider(BaseProvider):
         """Instrument OpenAI with OpenLLMetry"""
         if "openai" not in self.instrumentors:
             try:
+                from opentelemetry.instrumentation.openai import OpenAIInstrumentor
                 instrumentor = OpenAIInstrumentor()
                 instrumentor.instrument(
                     tracer_provider=self.tracer_provider,
@@ -108,6 +116,7 @@ class OpenTelemetryProvider(BaseProvider):
         """Instrument Anthropic with OpenLLMetry"""
         if "anthropic" not in self.instrumentors:
             try:
+                from opentelemetry.instrumentation.anthropic import AnthropicInstrumentor
                 instrumentor = AnthropicInstrumentor()
                 instrumentor.instrument(
                     tracer_provider=self.tracer_provider,
@@ -122,6 +131,7 @@ class OpenTelemetryProvider(BaseProvider):
         """Instrument LangChain with OpenLLMetry"""
         if "langchain" not in self.instrumentors:
             try:
+                from opentelemetry.instrumentation.langchain import LangchainInstrumentor
                 instrumentor = LangchainInstrumentor()
                 instrumentor.instrument(tracer_provider=self.tracer_provider)
                 self.instrumentors["langchain"] = instrumentor