lmnr 0.5.1__py3-none-any.whl → 0.5.1a0__py3-none-any.whl

lmnr/openllmetry_sdk/tracing/tracing.py

@@ -4,8 +4,6 @@ import logging
 import uuid
 
 from contextvars import Context
-from lmnr.sdk.client.asynchronous.async_client import AsyncLaminarClient
-from lmnr.sdk.client.synchronous.sync_client import LaminarClient
 from lmnr.sdk.log import VerboseColorfulFormatter
 from lmnr.openllmetry_sdk.instruments import Instruments
 from lmnr.openllmetry_sdk.tracing.attributes import (
@@ -27,8 +25,8 @@ from opentelemetry.exporter.otlp.proto.http.trace_exporter import (
 from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import (
     OTLPSpanExporter as GRPCExporter,
 )
+from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
 from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import Compression
-from opentelemetry.instrumentation.threading import ThreadingInstrumentor
 from opentelemetry.context import get_value, attach, get_current, set_value
 from opentelemetry.propagate import set_global_textmap
 from opentelemetry.propagators.textmap import TextMapPropagator
@@ -39,7 +37,7 @@ from opentelemetry.sdk.trace.export import (
     SimpleSpanProcessor,
     BatchSpanProcessor,
 )
-from opentelemetry.trace import get_tracer_provider, ProxyTracerProvider
+from opentelemetry.trace import ProxyTracerProvider
 
 from typing import Dict, Optional, Set
 
@@ -71,22 +69,14 @@ EXCLUDED_URLS = """
     openaipublic.blob.core.windows.net"""
 
 MAX_EVENTS_OR_ATTRIBUTES_PER_SPAN = 5000
+instrumentors: dict[str, BaseInstrumentor] = {}
 
 
 class TracerWrapper(object):
-    resource_attributes: dict = {}
-    enable_content_tracing: bool = True
-    endpoint: str = None
-    headers: Dict[str, str] = {}
     __tracer_provider: TracerProvider = None
-    __logger: logging.Logger = None
-    __span_id_to_path: dict[int, list[str]] = {}
-    __span_id_lists: dict[int, list[str]] = {}
-    __client: LaminarClient = None
-    __async_client: AsyncLaminarClient = None
-
-    def __new__(
-        cls,
+
+    def __init__(
+        self,
         disable_batch=False,
         processor: Optional[SpanProcessor] = None,
         propagator: Optional[TextMapPropagator] = None,
@@ -96,84 +86,73 @@ class TracerWrapper(object):
         base_http_url: Optional[str] = None,
         project_api_key: Optional[str] = None,
         max_export_batch_size: Optional[int] = None,
-    ) -> "TracerWrapper":
-        cls._initialize_logger(cls)
-        if not hasattr(cls, "instance"):
-            obj = cls.instance = super(TracerWrapper, cls).__new__(cls)
-            if not TracerWrapper.endpoint:
-                return obj
-
-            obj.__client = LaminarClient(
-                base_url=base_http_url,
-                project_api_key=project_api_key,
-            )
-            obj.__async_client = AsyncLaminarClient(
-                base_url=base_http_url,
-                project_api_key=project_api_key,
-            )
+        resource_attributes: dict = {},
+        enable_content_tracing: bool = True,
+        endpoint: str = None,
+        headers: Dict[str, str] = {},
+    ) -> None:
+        self.resource_attributes = resource_attributes
+        self.enable_content_tracing = enable_content_tracing
+        self.endpoint = endpoint
+        self.headers = headers
+        self.__logger = logging.getLogger(__name__)
+        console_log_handler = logging.StreamHandler()
+        console_log_handler.setFormatter(VerboseColorfulFormatter())
+        console_log_handler.setLevel(logging.INFO)
+        self.__logger.addHandler(console_log_handler)
+        self.__span_id_to_path = {}
+        self.__span_id_lists = {}
+
+        if not self.endpoint:
+            return
 
-            obj.__resource = Resource(attributes=TracerWrapper.resource_attributes)
-            obj.__tracer_provider = init_tracer_provider(resource=obj.__resource)
-            if processor:
-                obj.__spans_processor: SpanProcessor = processor
-                obj.__spans_processor_original_on_start = processor.on_start
+        self.__resource = Resource(attributes=self.resource_attributes)
+        self.__tracer_provider = init_tracer_provider(resource=self.__resource)
+        if processor:
+            self.__spans_processor = processor
+            self.__spans_processor_original_on_start = processor.on_start
+        else:
+            self.__spans_exporter = (
+                exporter
+                if exporter
+                else init_spans_exporter(self.endpoint, self.headers)
+            )
+            if disable_batch or is_notebook():
+                self.__spans_processor = SimpleSpanProcessor(self.__spans_exporter)
             else:
-                obj.__spans_exporter: SpanExporter = (
-                    exporter
-                    if exporter
-                    else init_spans_exporter(
-                        TracerWrapper.endpoint, TracerWrapper.headers
-                    )
+                self.__spans_processor = BatchSpanProcessor(
+                    self.__spans_exporter,
+                    max_export_batch_size=max_export_batch_size,
                 )
-                if disable_batch or is_notebook():
-                    obj.__spans_processor: SpanProcessor = SimpleSpanProcessor(
-                        obj.__spans_exporter
-                    )
-                else:
-                    obj.__spans_processor: SpanProcessor = BatchSpanProcessor(
-                        obj.__spans_exporter,
-                        max_export_batch_size=max_export_batch_size,
-                    )
-                obj.__spans_processor_original_on_start = None
-
-            obj.__spans_processor.on_start = obj._span_processor_on_start
-            obj.__tracer_provider.add_span_processor(obj.__spans_processor)
-
-            if propagator:
-                set_global_textmap(propagator)
-
-            # this makes sure otel context is propagated so we always want it
-            ThreadingInstrumentor().instrument()
-
-            instrument_set = init_instrumentations(
-                should_enrich_metrics,
-                instruments,
-                client=obj.__client,
-                async_client=obj.__async_client,
-            )
+            self.__spans_processor_original_on_start = None
 
-            if not instrument_set:
-                cls.__logger.info(
-                    "No instruments set through Laminar. "
-                    "Only enabling basic OpenTelemetry tracing."
-                )
+        self.__spans_processor.on_start = self._span_processor_on_start
+        self.__tracer_provider.add_span_processor(self.__spans_processor)
 
-            obj.__content_allow_list = ContentAllowList()
+        if propagator:
+            set_global_textmap(propagator)
 
-            # Force flushes for debug environments (e.g. local development)
-            atexit.register(obj.exit_handler)
+        instrument_set = init_instrumentations(
+            should_enrich_metrics,
+            instruments,
+            tracer_provider=self.__tracer_provider,
+            project_api_key=project_api_key,
+            base_http_url=base_http_url,
+        )
 
-        return cls.instance
+        if not instrument_set:
+            self.__logger.info(
+                "No instruments set through Laminar. "
+                "Only enabling basic OpenTelemetry tracing."
+            )
 
-    def exit_handler(self):
-        self.__span_id_to_path = {}
-        self.flush()
+        self.__content_allow_list = ContentAllowList()
 
-    def _initialize_logger(self):
-        self.__logger = logging.getLogger(__name__)
-        console_log_handler = logging.StreamHandler()
-        console_log_handler.setFormatter(VerboseColorfulFormatter())
-        self.__logger.addHandler(console_log_handler)
+        # Force flushes for debug environments (e.g. local development)
+        atexit.register(self.exit_handler)
+
+    def exit_handler(self):
+        self.shutdown()
 
     def _span_processor_on_start(
         self, span: Span, parent_context: Optional[Context] = None
@@ -214,32 +193,24 @@ class TracerWrapper(object):
         if self.__spans_processor_original_on_start:
             self.__spans_processor_original_on_start(span, parent_context)
 
-    @staticmethod
-    def set_static_params(
-        resource_attributes: dict,
-        enable_content_tracing: bool,
-        endpoint: str,
-        headers: Dict[str, str],
-    ) -> None:
-        TracerWrapper.resource_attributes = resource_attributes
-        TracerWrapper.enable_content_tracing = enable_content_tracing
-        TracerWrapper.endpoint = endpoint
-        TracerWrapper.headers = headers
-
-    @classmethod
-    def verify_initialized(cls) -> bool:
-        return hasattr(cls, "instance")
-
-    @classmethod
-    def clear(cls):
+    def clear_state(self):
         # Any state cleanup. Now used in between tests
-        cls.__span_id_to_path = {}
-        cls.__span_id_lists = {}
+        self.__span_id_to_path = {}
+        self.__span_id_lists = {}
 
     def shutdown(self):
-        self.__spans_processor.force_flush()
+        global instrumentors
+        self.__spans_processor.force_flush(timeout_millis=30000)
+        for v in instrumentors.values():
+            try:
+                v.uninstrument()
+            except Exception:
+                self.__logger.debug("Error uninstrumenting instrumentor", exc_info=True)
+        instrumentors = {}
         self.__spans_processor.shutdown()
-        self.__tracer_provider.shutdown()
+
+        # Clean up attributes
+        self.clear_state()
 
     def flush(self):
         return self.__spans_processor.force_flush()
@@ -314,11 +285,9 @@ def init_spans_exporter(api_endpoint: str, headers: Dict[str, str]) -> SpanExpor
         )
 
 
-# TODO: check if it's safer to use the default tracer provider obtained from
-# get_tracer_provider()
 def init_tracer_provider(resource: Resource) -> TracerProvider:
     provider: TracerProvider = None
-    default_provider: TracerProvider = get_tracer_provider()
+    default_provider: TracerProvider = trace.get_tracer_provider()
 
     if isinstance(default_provider, ProxyTracerProvider):
         provider = TracerProvider(resource=resource)
@@ -338,8 +307,9 @@ def init_instrumentations(
     should_enrich_metrics: bool,
     instruments: Optional[Set[Instruments]] = None,
     block_instruments: Optional[Set[Instruments]] = None,
-    client: Optional[LaminarClient] = None,
-    async_client: Optional[AsyncLaminarClient] = None,
+    tracer_provider: Optional[TracerProvider] = None,
+    project_api_key: Optional[str] = None,
+    base_http_url: Optional[str] = None,
 ):
     block_instruments = block_instruments or set()
     # These libraries are not instrumented by default,
@@ -365,97 +335,109 @@ def init_instrumentations(
     instrument_set = False
     for instrument in instruments:
         if instrument == Instruments.ALEPHALPHA:
-            if init_alephalpha_instrumentor():
+            if init_alephalpha_instrumentor(tracer_provider=tracer_provider):
                 instrument_set = True
         elif instrument == Instruments.ANTHROPIC:
-            if init_anthropic_instrumentor(should_enrich_metrics):
+            if init_anthropic_instrumentor(
+                should_enrich_metrics, tracer_provider=tracer_provider
+            ):
                 instrument_set = True
         elif instrument == Instruments.BEDROCK:
-            if init_bedrock_instrumentor(should_enrich_metrics):
+            if init_bedrock_instrumentor(
+                should_enrich_metrics, tracer_provider=tracer_provider
+            ):
                 instrument_set = True
         elif instrument == Instruments.CHROMA:
-            if init_chroma_instrumentor():
+            if init_chroma_instrumentor(tracer_provider=tracer_provider):
                 instrument_set = True
         elif instrument == Instruments.COHERE:
-            if init_cohere_instrumentor():
+            if init_cohere_instrumentor(tracer_provider=tracer_provider):
                 instrument_set = True
         elif instrument == Instruments.GOOGLE_GENERATIVEAI:
-            if init_google_generativeai_instrumentor():
+            if init_google_generativeai_instrumentor(tracer_provider=tracer_provider):
                 instrument_set = True
         elif instrument == Instruments.GROQ:
-            if init_groq_instrumentor():
+            if init_groq_instrumentor(tracer_provider=tracer_provider):
                 instrument_set = True
         elif instrument == Instruments.HAYSTACK:
-            if init_haystack_instrumentor():
+            if init_haystack_instrumentor(tracer_provider=tracer_provider):
                 instrument_set = True
         elif instrument == Instruments.LANCEDB:
-            if init_lancedb_instrumentor():
+            if init_lancedb_instrumentor(tracer_provider=tracer_provider):
                 instrument_set = True
         elif instrument == Instruments.LANGCHAIN:
-            if init_langchain_instrumentor():
+            if init_langchain_instrumentor(tracer_provider=tracer_provider):
                 instrument_set = True
         elif instrument == Instruments.LLAMA_INDEX:
-            if init_llama_index_instrumentor():
+            if init_llama_index_instrumentor(tracer_provider=tracer_provider):
                 instrument_set = True
         elif instrument == Instruments.MARQO:
-            if init_marqo_instrumentor():
+            if init_marqo_instrumentor(tracer_provider=tracer_provider):
                 instrument_set = True
         elif instrument == Instruments.MILVUS:
-            if init_milvus_instrumentor():
+            if init_milvus_instrumentor(tracer_provider=tracer_provider):
                 instrument_set = True
         elif instrument == Instruments.MISTRAL:
-            if init_mistralai_instrumentor():
+            if init_mistralai_instrumentor(tracer_provider=tracer_provider):
                 instrument_set = True
         elif instrument == Instruments.OLLAMA:
-            if init_ollama_instrumentor():
+            if init_ollama_instrumentor(tracer_provider=tracer_provider):
                 instrument_set = True
         elif instrument == Instruments.OPENAI:
-            if init_openai_instrumentor(should_enrich_metrics):
+            if init_openai_instrumentor(
+                should_enrich_metrics, tracer_provider=tracer_provider
+            ):
                 instrument_set = True
         elif instrument == Instruments.PINECONE:
-            if init_pinecone_instrumentor():
+            if init_pinecone_instrumentor(tracer_provider=tracer_provider):
                 instrument_set = True
         elif instrument == Instruments.PYMYSQL:
-            if init_pymysql_instrumentor():
+            if init_pymysql_instrumentor(tracer_provider=tracer_provider):
                 instrument_set = True
         elif instrument == Instruments.QDRANT:
-            if init_qdrant_instrumentor():
+            if init_qdrant_instrumentor(tracer_provider=tracer_provider):
                 instrument_set = True
         elif instrument == Instruments.REDIS:
-            if init_redis_instrumentor():
+            if init_redis_instrumentor(tracer_provider=tracer_provider):
                 instrument_set = True
         elif instrument == Instruments.REPLICATE:
-            if init_replicate_instrumentor():
+            if init_replicate_instrumentor(tracer_provider=tracer_provider):
                 instrument_set = True
         elif instrument == Instruments.REQUESTS:
-            if init_requests_instrumentor():
+            if init_requests_instrumentor(tracer_provider=tracer_provider):
                 instrument_set = True
         elif instrument == Instruments.SAGEMAKER:
-            if init_sagemaker_instrumentor(should_enrich_metrics):
+            if init_sagemaker_instrumentor(
+                should_enrich_metrics, tracer_provider=tracer_provider
+            ):
                 instrument_set = True
         elif instrument == Instruments.TOGETHER:
-            if init_together_instrumentor():
+            if init_together_instrumentor(tracer_provider=tracer_provider):
                 instrument_set = True
         elif instrument == Instruments.TRANSFORMERS:
-            if init_transformers_instrumentor():
+            if init_transformers_instrumentor(tracer_provider=tracer_provider):
                 instrument_set = True
         elif instrument == Instruments.URLLIB3:
-            if init_urllib3_instrumentor():
+            if init_urllib3_instrumentor(tracer_provider=tracer_provider):
                 instrument_set = True
         elif instrument == Instruments.VERTEXAI:
-            if init_vertexai_instrumentor():
+            if init_vertexai_instrumentor(tracer_provider=tracer_provider):
                 instrument_set = True
         elif instrument == Instruments.WATSONX:
-            if init_watsonx_instrumentor():
+            if init_watsonx_instrumentor(tracer_provider=tracer_provider):
                 instrument_set = True
         elif instrument == Instruments.WEAVIATE:
-            if init_weaviate_instrumentor():
+            if init_weaviate_instrumentor(tracer_provider=tracer_provider):
                 instrument_set = True
         elif instrument == Instruments.PLAYWRIGHT:
-            if init_playwright_instrumentor(client, async_client):
+            if init_playwright_instrumentor(
+                tracer_provider=tracer_provider,
+                project_api_key=project_api_key,
+                base_http_url=base_http_url,
+            ):
                 instrument_set = True
         elif instrument == Instruments.BROWSER_USE:
-            if init_browser_use_instrumentor():
+            if init_browser_use_instrumentor(tracer_provider=tracer_provider):
                 instrument_set = True
         else:
             module_logger.warning(
@@ -470,35 +452,38 @@ def init_instrumentations(
     return instrument_set
 
 
-def init_browser_use_instrumentor():
+def init_browser_use_instrumentor(**kwargs):
+    global instrumentors
     try:
         if is_package_installed("browser-use"):
             from lmnr.sdk.browser.browser_use_otel import BrowserUseInstrumentor
 
             instrumentor = BrowserUseInstrumentor()
-            instrumentor.instrument()
+            instrumentor.instrument(**kwargs)
+            instrumentors["browser_use"] = instrumentor
         return True
     except Exception as e:
         module_logger.error(f"Error initializing BrowserUse instrumentor: {e}")
         return False
 
 
-def init_playwright_instrumentor(
-    client: LaminarClient, async_client: AsyncLaminarClient
-):
+def init_playwright_instrumentor(**kwargs):
+    global instrumentors
     try:
         if is_package_installed("playwright"):
             from lmnr.sdk.browser.playwright_otel import PlaywrightInstrumentor
 
-            instrumentor = PlaywrightInstrumentor(client, async_client)
-            instrumentor.instrument()
+            instrumentor = PlaywrightInstrumentor()
+            instrumentor.instrument(**kwargs)
+            instrumentors["playwright"] = instrumentor
         return True
     except Exception as e:
         module_logger.error(f"Error initializing Playwright instrumentor: {e}")
         return False
 
 
-def init_openai_instrumentor(should_enrich_metrics: bool):
+def init_openai_instrumentor(should_enrich_metrics: bool, **kwargs):
+    global instrumentors
     try:
         if is_package_installed("openai") and is_package_installed(
             "opentelemetry-instrumentation-openai"
@@ -514,7 +499,8 @@ def init_openai_instrumentor(should_enrich_metrics: bool):
                 upload_base64_image=None,
             )
             if not instrumentor.is_instrumented_by_opentelemetry:
-                instrumentor.instrument()
+                instrumentor.instrument(**kwargs)
+            instrumentors["openai"] = instrumentor
         return True
 
     except Exception as e:
@@ -522,7 +508,8 @@ def init_openai_instrumentor(should_enrich_metrics: bool):
         return False
 
 
-def init_anthropic_instrumentor(should_enrich_metrics: bool):
+def init_anthropic_instrumentor(should_enrich_metrics: bool, **kwargs):
+    global instrumentors
     try:
         if is_package_installed("anthropic") and is_package_installed(
             "opentelemetry-instrumentation-anthropic"
@@ -534,14 +521,16 @@ def init_anthropic_instrumentor(should_enrich_metrics: bool):
                 upload_base64_image=None,
             )
             if not instrumentor.is_instrumented_by_opentelemetry:
-                instrumentor.instrument()
+                instrumentor.instrument(**kwargs)
+            instrumentors["anthropic"] = instrumentor
         return True
     except Exception as e:
         module_logger.error(f"Error initializing Anthropic instrumentor: {e}")
         return False
 
 
-def init_cohere_instrumentor():
+def init_cohere_instrumentor(**kwargs):
+    global instrumentors
     try:
         if is_package_installed("cohere") and is_package_installed(
             "opentelemetry-instrumentation-cohere"
@@ -550,14 +539,16 @@ def init_cohere_instrumentor():
 
             instrumentor = CohereInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
-                instrumentor.instrument()
+                instrumentor.instrument(**kwargs)
+            instrumentors["cohere"] = instrumentor
         return True
     except Exception as e:
         module_logger.error(f"Error initializing Cohere instrumentor: {e}")
         return False
 
 
-def init_pinecone_instrumentor():
+def init_pinecone_instrumentor(**kwargs):
+    global instrumentors
     try:
         if is_package_installed("pinecone") and is_package_installed(
             "opentelemetry-instrumentation-pinecone"
@@ -566,14 +557,16 @@ def init_pinecone_instrumentor():
 
             instrumentor = PineconeInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
-                instrumentor.instrument()
+                instrumentor.instrument(**kwargs)
+            instrumentors["pinecone"] = instrumentor
         return True
     except Exception as e:
         module_logger.error(f"Error initializing Pinecone instrumentor: {e}")
         return False
 
 
-def init_qdrant_instrumentor():
+def init_qdrant_instrumentor(**kwargs):
+    global instrumentors
     try:
         if is_package_installed("qdrant_client") and is_package_installed(
             "opentelemetry-instrumentation-qdrant"
@@ -582,13 +575,16 @@ def init_qdrant_instrumentor():
 
             instrumentor = QdrantInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
-                instrumentor.instrument()
+                instrumentor.instrument(**kwargs)
+            instrumentors["qdrant"] = instrumentor
+        return True
     except Exception as e:
         module_logger.error(f"Error initializing Qdrant instrumentor: {e}")
         return False
 
 
-def init_chroma_instrumentor():
+def init_chroma_instrumentor(**kwargs):
+    global instrumentors
     try:
         if is_package_installed("chromadb") and is_package_installed(
             "opentelemetry-instrumentation-chromadb"
@@ -597,14 +593,16 @@ def init_chroma_instrumentor():
 
             instrumentor = ChromaInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
-                instrumentor.instrument()
+                instrumentor.instrument(**kwargs)
+            instrumentors["chroma"] = instrumentor
         return True
     except Exception as e:
         module_logger.error(f"Error initializing Chroma instrumentor: {e}")
         return False
 
 
-def init_google_generativeai_instrumentor():
+def init_google_generativeai_instrumentor(**kwargs):
+    global instrumentors
     try:
         if is_package_installed("google-generativeai") and is_package_installed(
             "opentelemetry-instrumentation-google-generativeai"
@@ -615,14 +613,16 @@ def init_google_generativeai_instrumentor():
 
             instrumentor = GoogleGenerativeAiInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
-                instrumentor.instrument()
+                instrumentor.instrument(**kwargs)
+            instrumentors["google_generativeai"] = instrumentor
         return True
     except Exception as e:
         module_logger.error(f"Error initializing Gemini instrumentor: {e}")
         return False
 
 
-def init_haystack_instrumentor():
+def init_haystack_instrumentor(**kwargs):
+    global instrumentors
     try:
         if is_package_installed("haystack") and is_package_installed(
             "opentelemetry-instrumentation-haystack"
@@ -631,14 +631,16 @@ def init_haystack_instrumentor():
 
             instrumentor = HaystackInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
-                instrumentor.instrument()
+                instrumentor.instrument(**kwargs)
+            instrumentors["haystack"] = instrumentor
         return True
     except Exception as e:
         module_logger.error(f"Error initializing Haystack instrumentor: {e}")
         return False
 
 
-def init_langchain_instrumentor():
+def init_langchain_instrumentor(**kwargs):
+    global instrumentors
     try:
         if is_package_installed("langchain") and is_package_installed(
             "opentelemetry-instrumentation-langchain"
@@ -648,6 +650,7 @@ def init_langchain_instrumentor():
             instrumentor = LangchainInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
                 instrumentor.instrument()
+            instrumentors["langchain"] = instrumentor
         return True
     except Exception as e:
         # FIXME: silencing this error temporarily, it appears to not be critical
@@ -656,7 +659,8 @@ def init_langchain_instrumentor():
         return False
 
 
-def init_mistralai_instrumentor():
+def init_mistralai_instrumentor(**kwargs):
+    global instrumentors
     try:
         if is_package_installed("mistralai") and is_package_installed(
             "opentelemetry-instrumentation-mistralai"
@@ -665,14 +669,16 @@ def init_mistralai_instrumentor():
 
             instrumentor = MistralAiInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
-                instrumentor.instrument()
+                instrumentor.instrument(**kwargs)
+            instrumentors["mistralai"] = instrumentor
         return True
     except Exception as e:
         module_logger.error(f"Error initializing MistralAI instrumentor: {e}")
         return False
 
 
-def init_ollama_instrumentor():
+def init_ollama_instrumentor(**kwargs):
+    global instrumentors
     try:
         if is_package_installed("ollama") and is_package_installed(
             "opentelemetry-instrumentation-ollama"
@@ -681,14 +687,16 @@ def init_ollama_instrumentor():
 
             instrumentor = OllamaInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
-                instrumentor.instrument()
+                instrumentor.instrument(**kwargs)
+            instrumentors["ollama"] = instrumentor
         return True
     except Exception as e:
         module_logger.error(f"Error initializing Ollama instrumentor: {e}")
         return False
 
 
-def init_transformers_instrumentor():
+def init_transformers_instrumentor(**kwargs):
+    global instrumentors
     try:
         if is_package_installed("transformers") and is_package_installed(
             "opentelemetry-instrumentation-transformers"
@@ -699,14 +707,16 @@ def init_transformers_instrumentor():
 
             instrumentor = TransformersInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
-                instrumentor.instrument()
+                instrumentor.instrument(**kwargs)
+            instrumentors["transformers"] = instrumentor
         return True
     except Exception as e:
         module_logger.error(f"Error initializing Transformers instrumentor: {e}")
         return False
 
 
-def init_together_instrumentor():
+def init_together_instrumentor(**kwargs):
+    global instrumentors
     try:
         if is_package_installed("together") and is_package_installed(
             "opentelemetry-instrumentation-together"
@@ -715,14 +725,16 @@ def init_together_instrumentor():
 
             instrumentor = TogetherAiInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
-                instrumentor.instrument()
+                instrumentor.instrument(**kwargs)
+            instrumentors["together"] = instrumentor
         return True
     except Exception as e:
         module_logger.error(f"Error initializing TogetherAI instrumentor: {e}")
         return False
 
 
-def init_llama_index_instrumentor():
+def init_llama_index_instrumentor(**kwargs):
+    global instrumentors
     try:
         if (
             is_package_installed("llama-index") or is_package_installed("llama_index")
@@ -731,14 +743,16 @@ def init_llama_index_instrumentor():
 
             instrumentor = LlamaIndexInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
-                instrumentor.instrument()
+                instrumentor.instrument(**kwargs)
+            instrumentors["llama_index"] = instrumentor
         return True
     except Exception as e:
         module_logger.error(f"Error initializing LlamaIndex instrumentor: {e}")
         return False
 
 
-def init_milvus_instrumentor():
+def init_milvus_instrumentor(**kwargs):
+    global instrumentors
     try:
         if is_package_installed("pymilvus") and is_package_installed(
             "opentelemetry-instrumentation-milvus"
@@ -747,56 +761,64 @@ def init_milvus_instrumentor():
 
             instrumentor = MilvusInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
-                instrumentor.instrument()
+                instrumentor.instrument(**kwargs)
+            instrumentors["milvus"] = instrumentor
         return True
     except Exception as e:
         module_logger.error(f"Error initializing Milvus instrumentor: {e}")
         return False
 
 
-def init_requests_instrumentor():
+def init_requests_instrumentor(**kwargs):
+    global instrumentors
     try:
         if is_package_installed("requests"):
             from opentelemetry.instrumentation.requests import RequestsInstrumentor
 
             instrumentor = RequestsInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
-                instrumentor.instrument(excluded_urls=EXCLUDED_URLS)
+                instrumentor.instrument(excluded_urls=EXCLUDED_URLS, **kwargs)
+            instrumentors["requests"] = instrumentor
         return True
     except Exception as e:
         module_logger.error(f"Error initializing Requests instrumentor: {e}")
         return False
 
 
-def init_urllib3_instrumentor():
+def init_urllib3_instrumentor(**kwargs):
+    global instrumentors
     try:
         if is_package_installed("urllib3"):
             from opentelemetry.instrumentation.urllib3 import URLLib3Instrumentor
 
             instrumentor = URLLib3Instrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
-                instrumentor.instrument(excluded_urls=EXCLUDED_URLS)
+                instrumentor.instrument(excluded_urls=EXCLUDED_URLS, **kwargs)
+            instrumentors["urllib3"] = instrumentor
         return True
     except Exception as e:
         module_logger.error(f"Error initializing urllib3 instrumentor: {e}")
         return False
 
 
-def init_pymysql_instrumentor():
+def init_pymysql_instrumentor(**kwargs):
+    global instrumentors
     try:
         if is_package_installed("sqlalchemy"):
             from opentelemetry.instrumentation.sqlalchemy import SQLAlchemyInstrumentor
 
             instrumentor = SQLAlchemyInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
-                instrumentor.instrument()
+                instrumentor.instrument(**kwargs)
+            instrumentors["sqlalchemy"] = instrumentor
         return True
     except Exception as e:
         module_logger.error(f"Error initializing SQLAlchemy instrumentor: {e}")
         return False
 
 
-def init_bedrock_instrumentor(should_enrich_metrics: bool):
+def init_bedrock_instrumentor(should_enrich_metrics: bool, **kwargs):
+    global instrumentors
     try:
         if is_package_installed("boto3") and is_package_installed(
             "opentelemetry-instrumentation-bedrock"
@@ -807,14 +829,16 @@ def init_bedrock_instrumentor(should_enrich_metrics: bool):
                 enrich_token_usage=should_enrich_metrics,
             )
             if not instrumentor.is_instrumented_by_opentelemetry:
-                instrumentor.instrument()
+                instrumentor.instrument(**kwargs)
+            instrumentors["bedrock"] = instrumentor
         return True
     except Exception as e:
         module_logger.error(f"Error initializing Bedrock instrumentor: {e}")
         return False
 
 
-def init_replicate_instrumentor():
+def init_replicate_instrumentor(**kwargs):
+    global instrumentors
     try:
         if is_package_installed("replicate") and is_package_installed(
             "opentelemetry-instrumentation-replicate"
@@ -823,14 +847,16 @@ def init_replicate_instrumentor():
 
             instrumentor = ReplicateInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
-                instrumentor.instrument()
+                instrumentor.instrument(**kwargs)
+            instrumentors["replicate"] = instrumentor
         return True
     except Exception as e:
         module_logger.error(f"Error initializing Replicate instrumentor: {e}")
         return False
 
 
-def init_vertexai_instrumentor():
+def init_vertexai_instrumentor(**kwargs):
+    global instrumentors
     try:
         if is_package_installed("vertexai") and is_package_installed(
             "opentelemetry-instrumentation-vertexai"
@@ -839,14 +865,16 @@ def init_vertexai_instrumentor():
 
             instrumentor = VertexAIInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
-                instrumentor.instrument()
+                instrumentor.instrument(**kwargs)
+            instrumentors["vertexai"] = instrumentor
         return True
     except Exception as e:
         module_logger.warning(f"Error initializing Vertex AI instrumentor: {e}")
         return False
 
 
-def init_watsonx_instrumentor():
+def init_watsonx_instrumentor(**kwargs):
+    global instrumentors
     try:
         if (
             is_package_installed("ibm-watsonx-ai")
@@ -856,14 +884,16 @@ def init_watsonx_instrumentor():
 
             instrumentor = WatsonxInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
-                instrumentor.instrument()
+                instrumentor.instrument(**kwargs)
+            instrumentors["watsonx"] = instrumentor
         return True
     except Exception as e:
         module_logger.warning(f"Error initializing Watsonx instrumentor: {e}")
         return False
 
 
-def init_weaviate_instrumentor():
+def init_weaviate_instrumentor(**kwargs):
+    global instrumentors
     try:
         if is_package_installed("weaviate") and is_package_installed(
             "opentelemetry-instrumentation-weaviate"
@@ -872,14 +902,16 @@ def init_weaviate_instrumentor():
 
             instrumentor = WeaviateInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
-                instrumentor.instrument()
+                instrumentor.instrument(**kwargs)
+            instrumentors["weaviate"] = instrumentor
         return True
     except Exception as e:
         module_logger.warning(f"Error initializing Weaviate instrumentor: {e}")
         return False
 
 
-def init_alephalpha_instrumentor():
+def init_alephalpha_instrumentor(**kwargs):
+    global instrumentors
     try:
         if is_package_installed("aleph_alpha_client") and is_package_installed(
             "opentelemetry-instrumentation-alephalpha"
@@ -888,14 +920,16 @@ def init_alephalpha_instrumentor():
 
             instrumentor = AlephAlphaInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
-                instrumentor.instrument()
+                instrumentor.instrument(**kwargs)
+            instrumentors["alephalpha"] = instrumentor
         return True
     except Exception as e:
         module_logger.error(f"Error initializing Aleph Alpha instrumentor: {e}")
         return False
 
 
-def init_marqo_instrumentor():
+def init_marqo_instrumentor(**kwargs):
+    global instrumentors
     try:
         if is_package_installed("marqo") and is_package_installed(
             "opentelemetry-instrumentation-marqo"
@@ -904,14 +938,16 @@ def init_marqo_instrumentor():
 
             instrumentor = MarqoInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
-                instrumentor.instrument()
+                instrumentor.instrument(**kwargs)
+            instrumentors["marqo"] = instrumentor
         return True
     except Exception as e:
         module_logger.error(f"Error initializing marqo instrumentor: {e}")
         return False
 
 
-def init_lancedb_instrumentor():
+def init_lancedb_instrumentor(**kwargs):
+    global instrumentors
     try:
         if is_package_installed("lancedb") and is_package_installed(
             "opentelemetry-instrumentation-lancedb"
@@ -920,13 +956,16 @@ def init_lancedb_instrumentor():
 
             instrumentor = LanceInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
-                instrumentor.instrument()
+                instrumentor.instrument(**kwargs)
+            instrumentors["lancedb"] = instrumentor
         return True
     except Exception as e:
         module_logger.error(f"Error initializing LanceDB instrumentor: {e}")
+        return False
 
 
-def init_redis_instrumentor():
+def init_redis_instrumentor(**kwargs):
+    global instrumentors
     try:
         if is_package_installed("redis") and is_package_installed(
             "opentelemetry-instrumentation-redis"
@@ -935,14 +974,16 @@ def init_redis_instrumentor():
 
             instrumentor = RedisInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
-                instrumentor.instrument(excluded_urls=EXCLUDED_URLS)
+                instrumentor.instrument(excluded_urls=EXCLUDED_URLS, **kwargs)
+            instrumentors["redis"] = instrumentor
         return True
     except Exception as e:
         module_logger.error(f"Error initializing redis instrumentor: {e}")
         return False
 
 
-def init_groq_instrumentor():
+def init_groq_instrumentor(**kwargs):
+    global instrumentors
     try:
         if is_package_installed("groq") and is_package_installed(
             "opentelemetry-instrumentation-groq"
@@ -951,14 +992,16 @@ def init_groq_instrumentor():
 
             instrumentor = GroqInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
-                instrumentor.instrument()
+                instrumentor.instrument(**kwargs)
+            instrumentors["groq"] = instrumentor
         return True
     except Exception as e:
         module_logger.error(f"Error initializing Groq instrumentor: {e}")
         return False
 
 
-def init_sagemaker_instrumentor(should_enrich_metrics: bool):
+def init_sagemaker_instrumentor(should_enrich_metrics: bool, **kwargs):
+    global instrumentors
     try:
         if is_package_installed("boto3") and is_package_installed(
             "opentelemetry-instrumentation-sagemaker"
@@ -969,7 +1012,8 @@ def init_sagemaker_instrumentor(should_enrich_metrics: bool):
                 enrich_token_usage=should_enrich_metrics,
             )
             if not instrumentor.is_instrumented_by_opentelemetry:
-                instrumentor.instrument()
+                instrumentor.instrument(**kwargs)
+            instrumentors["sagemaker"] = instrumentor
         return True
     except Exception as e:
         module_logger.error(f"Error initializing SageMaker instrumentor: {e}")