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

lmnr/{openllmetry_sdk → opentelemetry_lib}/tracing/tracing.py

@@ -4,9 +4,11 @@ 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 (
+from lmnr.opentelemetry_lib.instruments import Instruments
+from lmnr.opentelemetry_lib.tracing.attributes import (
     ASSOCIATION_PROPERTIES,
     SPAN_IDS_PATH,
     SPAN_INSTRUMENTATION_SOURCE,
@@ -15,9 +17,9 @@ from lmnr.openllmetry_sdk.tracing.attributes import (
     SPAN_PATH,
     TRACING_LEVEL,
 )
-from lmnr.openllmetry_sdk.tracing.content_allow_list import ContentAllowList
-from lmnr.openllmetry_sdk.utils import is_notebook
-from lmnr.openllmetry_sdk.utils.package_check import is_package_installed
+from lmnr.opentelemetry_lib.tracing.content_allow_list import ContentAllowList
+from lmnr.opentelemetry_lib.utils import is_notebook
+from lmnr.opentelemetry_lib.utils.package_check import is_package_installed
 from opentelemetry import trace
 from opentelemetry.exporter.otlp.proto.http.trace_exporter import (
     OTLPSpanExporter as HTTPExporter,
@@ -25,8 +27,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
@@ -37,7 +39,7 @@ from opentelemetry.sdk.trace.export import (
     SimpleSpanProcessor,
     BatchSpanProcessor,
 )
-from opentelemetry.trace import ProxyTracerProvider
+from opentelemetry.trace import get_tracer_provider, ProxyTracerProvider
 
 from typing import Dict, Optional, Set
 
@@ -69,14 +71,24 @@ 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
-
-    def __init__(
-        self,
+    __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
+    __spans_processor: SpanProcessor = None
+    __spans_exporter: SpanExporter = None
+
+    def __new__(
+        cls,
         disable_batch=False,
         processor: Optional[SpanProcessor] = None,
         propagator: Optional[TextMapPropagator] = None,
@@ -86,73 +98,82 @@ class TracerWrapper(object):
         base_http_url: Optional[str] = None,
         project_api_key: Optional[str] = None,
         max_export_batch_size: Optional[int] = None,
-        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
-
-        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)
+    ) -> "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,
             )
-            if disable_batch or is_notebook():
-                self.__spans_processor = SimpleSpanProcessor(self.__spans_exporter)
+
+            obj.__resource = Resource(attributes=TracerWrapper.resource_attributes)
+            obj.__tracer_provider = init_tracer_provider(resource=obj.__resource)
+            if processor:
+                obj.__spans_processor = processor
+                obj.__spans_processor_original_on_start = processor.on_start
             else:
-                self.__spans_processor = BatchSpanProcessor(
-                    self.__spans_exporter,
-                    max_export_batch_size=max_export_batch_size,
+                obj.__spans_exporter = (
+                    exporter
+                    if exporter
+                    else init_spans_exporter(
+                        TracerWrapper.endpoint, TracerWrapper.headers
+                    )
                 )
-            self.__spans_processor_original_on_start = None
-
-        self.__spans_processor.on_start = self._span_processor_on_start
-        self.__tracer_provider.add_span_processor(self.__spans_processor)
-
-        if propagator:
-            set_global_textmap(propagator)
+                if disable_batch or is_notebook():
+                    obj.__spans_processor = SimpleSpanProcessor(obj.__spans_exporter)
+                else:
+                    obj.__spans_processor = 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,
+            )
 
-        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,
-        )
+            if not instrument_set:
+                cls.__logger.info(
+                    "No instruments set through Laminar. "
+                    "Only enabling basic OpenTelemetry tracing."
+                )
 
-        if not instrument_set:
-            self.__logger.info(
-                "No instruments set through Laminar. "
-                "Only enabling basic OpenTelemetry tracing."
-            )
+            obj.__content_allow_list = ContentAllowList()
 
-        self.__content_allow_list = ContentAllowList()
+            # Force flushes for debug environments (e.g. local development)
+            atexit.register(obj.exit_handler)
 
-        # Force flushes for debug environments (e.g. local development)
-        atexit.register(self.exit_handler)
+        return cls.instance
 
     def exit_handler(self):
-        self.shutdown()
+        self.__span_id_to_path = {}
+        self.flush()
+
+    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)
 
     def _span_processor_on_start(
         self, span: Span, parent_context: Optional[Context] = None
@@ -193,24 +214,30 @@ class TracerWrapper(object):
         if self.__spans_processor_original_on_start:
             self.__spans_processor_original_on_start(span, parent_context)
 
-    def clear_state(self):
+    @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):
         # Any state cleanup. Now used in between tests
-        self.__span_id_to_path = {}
-        self.__span_id_lists = {}
+        cls.__span_id_to_path = {}
+        cls.__span_id_lists = {}
 
     def shutdown(self):
-        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()
-
-        # Clean up attributes
-        self.clear_state()
+        self.__tracer_provider.shutdown()
 
     def flush(self):
         return self.__spans_processor.force_flush()
@@ -285,9 +312,11 @@ 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 = trace.get_tracer_provider()
+    default_provider: TracerProvider = get_tracer_provider()
 
     if isinstance(default_provider, ProxyTracerProvider):
         provider = TracerProvider(resource=resource)
@@ -307,9 +336,8 @@ def init_instrumentations(
     should_enrich_metrics: bool,
     instruments: Optional[Set[Instruments]] = None,
     block_instruments: Optional[Set[Instruments]] = None,
-    tracer_provider: Optional[TracerProvider] = None,
-    project_api_key: Optional[str] = None,
-    base_http_url: Optional[str] = None,
+    client: Optional[LaminarClient] = None,
+    async_client: Optional[AsyncLaminarClient] = None,
 ):
     block_instruments = block_instruments or set()
     # These libraries are not instrumented by default,
@@ -335,109 +363,103 @@ def init_instrumentations(
     instrument_set = False
     for instrument in instruments:
         if instrument == Instruments.ALEPHALPHA:
-            if init_alephalpha_instrumentor(tracer_provider=tracer_provider):
+            if init_alephalpha_instrumentor():
                 instrument_set = True
         elif instrument == Instruments.ANTHROPIC:
-            if init_anthropic_instrumentor(
-                should_enrich_metrics, tracer_provider=tracer_provider
-            ):
+            if init_anthropic_instrumentor(should_enrich_metrics):
                 instrument_set = True
         elif instrument == Instruments.BEDROCK:
-            if init_bedrock_instrumentor(
-                should_enrich_metrics, tracer_provider=tracer_provider
-            ):
+            if init_bedrock_instrumentor(should_enrich_metrics):
                 instrument_set = True
         elif instrument == Instruments.CHROMA:
-            if init_chroma_instrumentor(tracer_provider=tracer_provider):
+            if init_chroma_instrumentor():
                 instrument_set = True
         elif instrument == Instruments.COHERE:
-            if init_cohere_instrumentor(tracer_provider=tracer_provider):
+            if init_cohere_instrumentor():
                 instrument_set = True
         elif instrument == Instruments.GOOGLE_GENERATIVEAI:
-            if init_google_generativeai_instrumentor(tracer_provider=tracer_provider):
+            if init_google_generativeai_instrumentor():
+                instrument_set = True
+        elif instrument == Instruments.GOOGLE_GENAI:
+            if init_google_genai_instrumentor():
                 instrument_set = True
         elif instrument == Instruments.GROQ:
-            if init_groq_instrumentor(tracer_provider=tracer_provider):
+            if init_groq_instrumentor():
                 instrument_set = True
         elif instrument == Instruments.HAYSTACK:
-            if init_haystack_instrumentor(tracer_provider=tracer_provider):
+            if init_haystack_instrumentor():
                 instrument_set = True
         elif instrument == Instruments.LANCEDB:
-            if init_lancedb_instrumentor(tracer_provider=tracer_provider):
+            if init_lancedb_instrumentor():
                 instrument_set = True
         elif instrument == Instruments.LANGCHAIN:
-            if init_langchain_instrumentor(tracer_provider=tracer_provider):
+            if init_langchain_instrumentor():
                 instrument_set = True
         elif instrument == Instruments.LLAMA_INDEX:
-            if init_llama_index_instrumentor(tracer_provider=tracer_provider):
+            if init_llama_index_instrumentor():
                 instrument_set = True
         elif instrument == Instruments.MARQO:
-            if init_marqo_instrumentor(tracer_provider=tracer_provider):
+            if init_marqo_instrumentor():
                 instrument_set = True
         elif instrument == Instruments.MILVUS:
-            if init_milvus_instrumentor(tracer_provider=tracer_provider):
+            if init_milvus_instrumentor():
                 instrument_set = True
         elif instrument == Instruments.MISTRAL:
-            if init_mistralai_instrumentor(tracer_provider=tracer_provider):
+            if init_mistralai_instrumentor():
                 instrument_set = True
         elif instrument == Instruments.OLLAMA:
-            if init_ollama_instrumentor(tracer_provider=tracer_provider):
+            if init_ollama_instrumentor():
                 instrument_set = True
         elif instrument == Instruments.OPENAI:
-            if init_openai_instrumentor(
-                should_enrich_metrics, tracer_provider=tracer_provider
-            ):
+            if init_openai_instrumentor(should_enrich_metrics):
                 instrument_set = True
         elif instrument == Instruments.PINECONE:
-            if init_pinecone_instrumentor(tracer_provider=tracer_provider):
+            if init_pinecone_instrumentor():
                 instrument_set = True
         elif instrument == Instruments.PYMYSQL:
-            if init_pymysql_instrumentor(tracer_provider=tracer_provider):
+            if init_pymysql_instrumentor():
                 instrument_set = True
         elif instrument == Instruments.QDRANT:
-            if init_qdrant_instrumentor(tracer_provider=tracer_provider):
+            if init_qdrant_instrumentor():
                 instrument_set = True
         elif instrument == Instruments.REDIS:
-            if init_redis_instrumentor(tracer_provider=tracer_provider):
+            if init_redis_instrumentor():
                 instrument_set = True
         elif instrument == Instruments.REPLICATE:
-            if init_replicate_instrumentor(tracer_provider=tracer_provider):
+            if init_replicate_instrumentor():
                 instrument_set = True
         elif instrument == Instruments.REQUESTS:
-            if init_requests_instrumentor(tracer_provider=tracer_provider):
+            if init_requests_instrumentor():
                 instrument_set = True
         elif instrument == Instruments.SAGEMAKER:
-            if init_sagemaker_instrumentor(
-                should_enrich_metrics, tracer_provider=tracer_provider
-            ):
+            if init_sagemaker_instrumentor(should_enrich_metrics):
                 instrument_set = True
         elif instrument == Instruments.TOGETHER:
-            if init_together_instrumentor(tracer_provider=tracer_provider):
+            if init_together_instrumentor():
                 instrument_set = True
         elif instrument == Instruments.TRANSFORMERS:
-            if init_transformers_instrumentor(tracer_provider=tracer_provider):
+            if init_transformers_instrumentor():
                 instrument_set = True
         elif instrument == Instruments.URLLIB3:
-            if init_urllib3_instrumentor(tracer_provider=tracer_provider):
+            if init_urllib3_instrumentor():
                 instrument_set = True
         elif instrument == Instruments.VERTEXAI:
-            if init_vertexai_instrumentor(tracer_provider=tracer_provider):
+            if init_vertexai_instrumentor():
                 instrument_set = True
         elif instrument == Instruments.WATSONX:
-            if init_watsonx_instrumentor(tracer_provider=tracer_provider):
+            if init_watsonx_instrumentor():
                 instrument_set = True
         elif instrument == Instruments.WEAVIATE:
-            if init_weaviate_instrumentor(tracer_provider=tracer_provider):
+            if init_weaviate_instrumentor():
                 instrument_set = True
         elif instrument == Instruments.PLAYWRIGHT:
-            if init_playwright_instrumentor(
-                tracer_provider=tracer_provider,
-                project_api_key=project_api_key,
-                base_http_url=base_http_url,
-            ):
+            if init_playwright_instrumentor(client, async_client):
+                instrument_set = True
+        elif instrument == Instruments.PATCHRIGHT:
+            if init_patchright_instrumentor(client, async_client):
                 instrument_set = True
         elif instrument == Instruments.BROWSER_USE:
-            if init_browser_use_instrumentor(tracer_provider=tracer_provider):
+            if init_browser_use_instrumentor():
                 instrument_set = True
         else:
             module_logger.warning(
@@ -452,38 +474,50 @@ def init_instrumentations(
     return instrument_set
 
 
-def init_browser_use_instrumentor(**kwargs):
-    global instrumentors
+def init_browser_use_instrumentor():
     try:
         if is_package_installed("browser-use"):
             from lmnr.sdk.browser.browser_use_otel import BrowserUseInstrumentor
 
             instrumentor = BrowserUseInstrumentor()
-            instrumentor.instrument(**kwargs)
-            instrumentors["browser_use"] = instrumentor
+            instrumentor.instrument()
         return True
     except Exception as e:
         module_logger.error(f"Error initializing BrowserUse instrumentor: {e}")
         return False
 
 
-def init_playwright_instrumentor(**kwargs):
-    global instrumentors
+def init_playwright_instrumentor(
+    client: LaminarClient, async_client: AsyncLaminarClient
+):
     try:
         if is_package_installed("playwright"):
             from lmnr.sdk.browser.playwright_otel import PlaywrightInstrumentor
 
-            instrumentor = PlaywrightInstrumentor()
-            instrumentor.instrument(**kwargs)
-            instrumentors["playwright"] = instrumentor
+            instrumentor = PlaywrightInstrumentor(client, async_client)
+            instrumentor.instrument()
         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, **kwargs):
-    global instrumentors
+def init_patchright_instrumentor(
+    client: LaminarClient, async_client: AsyncLaminarClient
+):
+    try:
+        if is_package_installed("patchright"):
+            from lmnr.sdk.browser.patchright_otel import PatchrightInstrumentor
+
+            instrumentor = PatchrightInstrumentor(client, async_client)
+            instrumentor.instrument()
+        return True
+    except Exception as e:
+        module_logger.error(f"Error initializing patchright instrumentor: {e}")
+        return False
+
+
+def init_openai_instrumentor(should_enrich_metrics: bool):
     try:
         if is_package_installed("openai") and is_package_installed(
             "opentelemetry-instrumentation-openai"
@@ -499,8 +533,7 @@ def init_openai_instrumentor(should_enrich_metrics: bool, **kwargs):
                 upload_base64_image=None,
             )
             if not instrumentor.is_instrumented_by_opentelemetry:
-                instrumentor.instrument(**kwargs)
-            instrumentors["openai"] = instrumentor
+                instrumentor.instrument()
         return True
 
     except Exception as e:
@@ -508,8 +541,7 @@ def init_openai_instrumentor(should_enrich_metrics: bool, **kwargs):
         return False
 
 
-def init_anthropic_instrumentor(should_enrich_metrics: bool, **kwargs):
-    global instrumentors
+def init_anthropic_instrumentor(should_enrich_metrics: bool):
     try:
         if is_package_installed("anthropic") and is_package_installed(
             "opentelemetry-instrumentation-anthropic"
@@ -521,16 +553,14 @@ def init_anthropic_instrumentor(should_enrich_metrics: bool, **kwargs):
                 upload_base64_image=None,
             )
             if not instrumentor.is_instrumented_by_opentelemetry:
-                instrumentor.instrument(**kwargs)
-            instrumentors["anthropic"] = instrumentor
+                instrumentor.instrument()
         return True
     except Exception as e:
         module_logger.error(f"Error initializing Anthropic instrumentor: {e}")
         return False
 
 
-def init_cohere_instrumentor(**kwargs):
-    global instrumentors
+def init_cohere_instrumentor():
     try:
         if is_package_installed("cohere") and is_package_installed(
             "opentelemetry-instrumentation-cohere"
@@ -539,16 +569,14 @@ def init_cohere_instrumentor(**kwargs):
 
             instrumentor = CohereInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
-                instrumentor.instrument(**kwargs)
-            instrumentors["cohere"] = instrumentor
+                instrumentor.instrument()
         return True
     except Exception as e:
         module_logger.error(f"Error initializing Cohere instrumentor: {e}")
         return False
 
 
-def init_pinecone_instrumentor(**kwargs):
-    global instrumentors
+def init_pinecone_instrumentor():
     try:
         if is_package_installed("pinecone") and is_package_installed(
             "opentelemetry-instrumentation-pinecone"
@@ -557,16 +585,14 @@ def init_pinecone_instrumentor(**kwargs):
 
             instrumentor = PineconeInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
-                instrumentor.instrument(**kwargs)
-            instrumentors["pinecone"] = instrumentor
+                instrumentor.instrument()
         return True
     except Exception as e:
         module_logger.error(f"Error initializing Pinecone instrumentor: {e}")
         return False
 
 
-def init_qdrant_instrumentor(**kwargs):
-    global instrumentors
+def init_qdrant_instrumentor():
     try:
         if is_package_installed("qdrant_client") and is_package_installed(
             "opentelemetry-instrumentation-qdrant"
@@ -575,16 +601,13 @@ def init_qdrant_instrumentor(**kwargs):
 
             instrumentor = QdrantInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
-                instrumentor.instrument(**kwargs)
-            instrumentors["qdrant"] = instrumentor
-        return True
+                instrumentor.instrument()
     except Exception as e:
         module_logger.error(f"Error initializing Qdrant instrumentor: {e}")
         return False
 
 
-def init_chroma_instrumentor(**kwargs):
-    global instrumentors
+def init_chroma_instrumentor():
     try:
         if is_package_installed("chromadb") and is_package_installed(
             "opentelemetry-instrumentation-chromadb"
@@ -593,16 +616,14 @@ def init_chroma_instrumentor(**kwargs):
 
             instrumentor = ChromaInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
-                instrumentor.instrument(**kwargs)
-            instrumentors["chroma"] = instrumentor
+                instrumentor.instrument()
         return True
     except Exception as e:
         module_logger.error(f"Error initializing Chroma instrumentor: {e}")
         return False
 
 
-def init_google_generativeai_instrumentor(**kwargs):
-    global instrumentors
+def init_google_generativeai_instrumentor():
     try:
         if is_package_installed("google-generativeai") and is_package_installed(
             "opentelemetry-instrumentation-google-generativeai"
@@ -613,16 +634,35 @@ def init_google_generativeai_instrumentor(**kwargs):
 
             instrumentor = GoogleGenerativeAiInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
-                instrumentor.instrument(**kwargs)
-            instrumentors["google_generativeai"] = instrumentor
+                instrumentor.instrument()
         return True
     except Exception as e:
         module_logger.error(f"Error initializing Gemini instrumentor: {e}")
         return False
 
 
-def init_haystack_instrumentor(**kwargs):
-    global instrumentors
+def init_google_genai_instrumentor():
+    try:
+        if is_package_installed("google-genai"):
+            # TODO: uncomment this once we migrate to the contrib package
+            # and is_package_installed(
+            #     "opentelemetry-instrumentation-google-genai"
+            # ):
+            # from opentelemetry.instrumentation.google_genai import (
+            from ..opentelemetry.instrumentation.google_genai import (
+                GoogleGenAiSdkInstrumentor,
+            )
+
+            instrumentor = GoogleGenAiSdkInstrumentor()
+            if not instrumentor.is_instrumented_by_opentelemetry:
+                instrumentor.instrument()
+        return True
+    except Exception as e:
+        module_logger.error(f"Error initializing Google GenAI instrumentor: {e}")
+        return False
+
+
+def init_haystack_instrumentor():
     try:
         if is_package_installed("haystack") and is_package_installed(
             "opentelemetry-instrumentation-haystack"
@@ -631,16 +671,14 @@ def init_haystack_instrumentor(**kwargs):
 
             instrumentor = HaystackInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
-                instrumentor.instrument(**kwargs)
-            instrumentors["haystack"] = instrumentor
+                instrumentor.instrument()
         return True
     except Exception as e:
         module_logger.error(f"Error initializing Haystack instrumentor: {e}")
         return False
 
 
-def init_langchain_instrumentor(**kwargs):
-    global instrumentors
+def init_langchain_instrumentor():
     try:
         if is_package_installed("langchain") and is_package_installed(
             "opentelemetry-instrumentation-langchain"
@@ -650,7 +688,6 @@ def init_langchain_instrumentor(**kwargs):
             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
@@ -659,8 +696,7 @@ def init_langchain_instrumentor(**kwargs):
         return False
 
 
-def init_mistralai_instrumentor(**kwargs):
-    global instrumentors
+def init_mistralai_instrumentor():
     try:
         if is_package_installed("mistralai") and is_package_installed(
             "opentelemetry-instrumentation-mistralai"
@@ -669,16 +705,14 @@ def init_mistralai_instrumentor(**kwargs):
 
             instrumentor = MistralAiInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
-                instrumentor.instrument(**kwargs)
-            instrumentors["mistralai"] = instrumentor
+                instrumentor.instrument()
         return True
     except Exception as e:
         module_logger.error(f"Error initializing MistralAI instrumentor: {e}")
         return False
 
 
-def init_ollama_instrumentor(**kwargs):
-    global instrumentors
+def init_ollama_instrumentor():
     try:
         if is_package_installed("ollama") and is_package_installed(
             "opentelemetry-instrumentation-ollama"
@@ -687,16 +721,14 @@ def init_ollama_instrumentor(**kwargs):
 
             instrumentor = OllamaInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
-                instrumentor.instrument(**kwargs)
-            instrumentors["ollama"] = instrumentor
+                instrumentor.instrument()
         return True
     except Exception as e:
         module_logger.error(f"Error initializing Ollama instrumentor: {e}")
         return False
 
 
-def init_transformers_instrumentor(**kwargs):
-    global instrumentors
+def init_transformers_instrumentor():
     try:
         if is_package_installed("transformers") and is_package_installed(
             "opentelemetry-instrumentation-transformers"
@@ -707,16 +739,14 @@ def init_transformers_instrumentor(**kwargs):
 
             instrumentor = TransformersInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
-                instrumentor.instrument(**kwargs)
-            instrumentors["transformers"] = instrumentor
+                instrumentor.instrument()
         return True
     except Exception as e:
         module_logger.error(f"Error initializing Transformers instrumentor: {e}")
         return False
 
 
-def init_together_instrumentor(**kwargs):
-    global instrumentors
+def init_together_instrumentor():
     try:
         if is_package_installed("together") and is_package_installed(
             "opentelemetry-instrumentation-together"
@@ -725,16 +755,14 @@ def init_together_instrumentor(**kwargs):
 
             instrumentor = TogetherAiInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
-                instrumentor.instrument(**kwargs)
-            instrumentors["together"] = instrumentor
+                instrumentor.instrument()
         return True
     except Exception as e:
         module_logger.error(f"Error initializing TogetherAI instrumentor: {e}")
         return False
 
 
-def init_llama_index_instrumentor(**kwargs):
-    global instrumentors
+def init_llama_index_instrumentor():
     try:
         if (
             is_package_installed("llama-index") or is_package_installed("llama_index")
@@ -743,16 +771,14 @@ def init_llama_index_instrumentor(**kwargs):
 
             instrumentor = LlamaIndexInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
-                instrumentor.instrument(**kwargs)
-            instrumentors["llama_index"] = instrumentor
+                instrumentor.instrument()
         return True
     except Exception as e:
         module_logger.error(f"Error initializing LlamaIndex instrumentor: {e}")
         return False
 
 
-def init_milvus_instrumentor(**kwargs):
-    global instrumentors
+def init_milvus_instrumentor():
     try:
         if is_package_installed("pymilvus") and is_package_installed(
             "opentelemetry-instrumentation-milvus"
@@ -761,64 +787,56 @@ def init_milvus_instrumentor(**kwargs):
 
             instrumentor = MilvusInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
-                instrumentor.instrument(**kwargs)
-            instrumentors["milvus"] = instrumentor
+                instrumentor.instrument()
         return True
     except Exception as e:
         module_logger.error(f"Error initializing Milvus instrumentor: {e}")
         return False
 
 
-def init_requests_instrumentor(**kwargs):
-    global instrumentors
+def init_requests_instrumentor():
     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, **kwargs)
-            instrumentors["requests"] = instrumentor
+                instrumentor.instrument(excluded_urls=EXCLUDED_URLS)
         return True
     except Exception as e:
         module_logger.error(f"Error initializing Requests instrumentor: {e}")
         return False
 
 
-def init_urllib3_instrumentor(**kwargs):
-    global instrumentors
+def init_urllib3_instrumentor():
     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, **kwargs)
-            instrumentors["urllib3"] = instrumentor
+                instrumentor.instrument(excluded_urls=EXCLUDED_URLS)
         return True
     except Exception as e:
         module_logger.error(f"Error initializing urllib3 instrumentor: {e}")
         return False
 
 
-def init_pymysql_instrumentor(**kwargs):
-    global instrumentors
+def init_pymysql_instrumentor():
     try:
         if is_package_installed("sqlalchemy"):
             from opentelemetry.instrumentation.sqlalchemy import SQLAlchemyInstrumentor
 
             instrumentor = SQLAlchemyInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
-                instrumentor.instrument(**kwargs)
-            instrumentors["sqlalchemy"] = instrumentor
+                instrumentor.instrument()
         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, **kwargs):
-    global instrumentors
+def init_bedrock_instrumentor(should_enrich_metrics: bool):
     try:
         if is_package_installed("boto3") and is_package_installed(
             "opentelemetry-instrumentation-bedrock"
@@ -829,16 +847,14 @@ def init_bedrock_instrumentor(should_enrich_metrics: bool, **kwargs):
                 enrich_token_usage=should_enrich_metrics,
             )
             if not instrumentor.is_instrumented_by_opentelemetry:
-                instrumentor.instrument(**kwargs)
-            instrumentors["bedrock"] = instrumentor
+                instrumentor.instrument()
         return True
     except Exception as e:
         module_logger.error(f"Error initializing Bedrock instrumentor: {e}")
         return False
 
 
-def init_replicate_instrumentor(**kwargs):
-    global instrumentors
+def init_replicate_instrumentor():
     try:
         if is_package_installed("replicate") and is_package_installed(
             "opentelemetry-instrumentation-replicate"
@@ -847,16 +863,14 @@ def init_replicate_instrumentor(**kwargs):
 
             instrumentor = ReplicateInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
-                instrumentor.instrument(**kwargs)
-            instrumentors["replicate"] = instrumentor
+                instrumentor.instrument()
         return True
     except Exception as e:
         module_logger.error(f"Error initializing Replicate instrumentor: {e}")
         return False
 
 
-def init_vertexai_instrumentor(**kwargs):
-    global instrumentors
+def init_vertexai_instrumentor():
     try:
         if is_package_installed("vertexai") and is_package_installed(
             "opentelemetry-instrumentation-vertexai"
@@ -865,16 +879,14 @@ def init_vertexai_instrumentor(**kwargs):
 
             instrumentor = VertexAIInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
-                instrumentor.instrument(**kwargs)
-            instrumentors["vertexai"] = instrumentor
+                instrumentor.instrument()
         return True
     except Exception as e:
         module_logger.warning(f"Error initializing Vertex AI instrumentor: {e}")
         return False
 
 
-def init_watsonx_instrumentor(**kwargs):
-    global instrumentors
+def init_watsonx_instrumentor():
     try:
         if (
             is_package_installed("ibm-watsonx-ai")
@@ -884,16 +896,14 @@ def init_watsonx_instrumentor(**kwargs):
 
             instrumentor = WatsonxInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
-                instrumentor.instrument(**kwargs)
-            instrumentors["watsonx"] = instrumentor
+                instrumentor.instrument()
         return True
     except Exception as e:
         module_logger.warning(f"Error initializing Watsonx instrumentor: {e}")
         return False
 
 
-def init_weaviate_instrumentor(**kwargs):
-    global instrumentors
+def init_weaviate_instrumentor():
     try:
         if is_package_installed("weaviate") and is_package_installed(
             "opentelemetry-instrumentation-weaviate"
@@ -902,16 +912,14 @@ def init_weaviate_instrumentor(**kwargs):
 
             instrumentor = WeaviateInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
-                instrumentor.instrument(**kwargs)
-            instrumentors["weaviate"] = instrumentor
+                instrumentor.instrument()
         return True
     except Exception as e:
         module_logger.warning(f"Error initializing Weaviate instrumentor: {e}")
         return False
 
 
-def init_alephalpha_instrumentor(**kwargs):
-    global instrumentors
+def init_alephalpha_instrumentor():
     try:
         if is_package_installed("aleph_alpha_client") and is_package_installed(
             "opentelemetry-instrumentation-alephalpha"
@@ -920,16 +928,14 @@ def init_alephalpha_instrumentor(**kwargs):
 
             instrumentor = AlephAlphaInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
-                instrumentor.instrument(**kwargs)
-            instrumentors["alephalpha"] = instrumentor
+                instrumentor.instrument()
         return True
     except Exception as e:
         module_logger.error(f"Error initializing Aleph Alpha instrumentor: {e}")
         return False
 
 
-def init_marqo_instrumentor(**kwargs):
-    global instrumentors
+def init_marqo_instrumentor():
     try:
         if is_package_installed("marqo") and is_package_installed(
             "opentelemetry-instrumentation-marqo"
@@ -938,16 +944,14 @@ def init_marqo_instrumentor(**kwargs):
 
             instrumentor = MarqoInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
-                instrumentor.instrument(**kwargs)
-            instrumentors["marqo"] = instrumentor
+                instrumentor.instrument()
         return True
     except Exception as e:
         module_logger.error(f"Error initializing marqo instrumentor: {e}")
         return False
 
 
-def init_lancedb_instrumentor(**kwargs):
-    global instrumentors
+def init_lancedb_instrumentor():
     try:
         if is_package_installed("lancedb") and is_package_installed(
             "opentelemetry-instrumentation-lancedb"
@@ -956,16 +960,13 @@ def init_lancedb_instrumentor(**kwargs):
 
             instrumentor = LanceInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
-                instrumentor.instrument(**kwargs)
-            instrumentors["lancedb"] = instrumentor
+                instrumentor.instrument()
         return True
     except Exception as e:
         module_logger.error(f"Error initializing LanceDB instrumentor: {e}")
-        return False
 
 
-def init_redis_instrumentor(**kwargs):
-    global instrumentors
+def init_redis_instrumentor():
     try:
         if is_package_installed("redis") and is_package_installed(
             "opentelemetry-instrumentation-redis"
@@ -974,16 +975,14 @@ def init_redis_instrumentor(**kwargs):
 
             instrumentor = RedisInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
-                instrumentor.instrument(excluded_urls=EXCLUDED_URLS, **kwargs)
-            instrumentors["redis"] = instrumentor
+                instrumentor.instrument(excluded_urls=EXCLUDED_URLS)
         return True
     except Exception as e:
         module_logger.error(f"Error initializing redis instrumentor: {e}")
         return False
 
 
-def init_groq_instrumentor(**kwargs):
-    global instrumentors
+def init_groq_instrumentor():
     try:
         if is_package_installed("groq") and is_package_installed(
             "opentelemetry-instrumentation-groq"
@@ -992,16 +991,14 @@ def init_groq_instrumentor(**kwargs):
 
             instrumentor = GroqInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
-                instrumentor.instrument(**kwargs)
-            instrumentors["groq"] = instrumentor
+                instrumentor.instrument()
         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, **kwargs):
-    global instrumentors
+def init_sagemaker_instrumentor(should_enrich_metrics: bool):
     try:
         if is_package_installed("boto3") and is_package_installed(
             "opentelemetry-instrumentation-sagemaker"
@@ -1012,8 +1009,7 @@ def init_sagemaker_instrumentor(should_enrich_metrics: bool, **kwargs):
                 enrich_token_usage=should_enrich_metrics,
             )
             if not instrumentor.is_instrumented_by_opentelemetry:
-                instrumentor.instrument(**kwargs)
-            instrumentors["sagemaker"] = instrumentor
+                instrumentor.instrument()
         return True
     except Exception as e:
         module_logger.error(f"Error initializing SageMaker instrumentor: {e}")