lmnr 0.4.27__py3-none-any.whl → 0.4.29__py3-none-any.whl

lmnr/traceloop_sdk/tracing/tracing.py

@@ -23,9 +23,12 @@ from opentelemetry.trace import get_tracer_provider, ProxyTracerProvider
 from opentelemetry.context import get_value, attach, set_value
 from opentelemetry.instrumentation.threading import ThreadingInstrumentor
 
-# from lmnr.traceloop_sdk import Telemetry
 from lmnr.traceloop_sdk.instruments import Instruments
-from lmnr.traceloop_sdk.tracing.attributes import ASSOCIATION_PROPERTIES, SPAN_PATH
+from lmnr.traceloop_sdk.tracing.attributes import (
+    ASSOCIATION_PROPERTIES,
+    SPAN_INSTRUMENTATION_SOURCE,
+    SPAN_PATH,
+)
 from lmnr.traceloop_sdk.tracing.content_allow_list import ContentAllowList
 from lmnr.traceloop_sdk.utils import is_notebook
 from lmnr.traceloop_sdk.utils.package_check import is_package_installed
@@ -46,6 +49,7 @@ EXCLUDED_URLS = """
     posthog.com,
     sentry.io,
     bedrock-runtime,
+    sagemaker-runtime,
     googleapis.com,
     githubusercontent.com,
     openaipublic.blob.core.windows.net"""
@@ -75,27 +79,9 @@ class TracerWrapper(object):
             obj.__resource = Resource(attributes=TracerWrapper.resource_attributes)
             obj.__tracer_provider = init_tracer_provider(resource=obj.__resource)
             if processor:
-                # Telemetry().capture("tracer:init", {"processor": "custom"})
                 obj.__spans_processor: SpanProcessor = processor
                 obj.__spans_processor_original_on_start = processor.on_start
             else:
-                # if exporter:
-                #     Telemetry().capture(
-                #         "tracer:init",
-                #         {
-                #             "exporter": "custom",
-                #             "processor": "simple" if disable_batch else "batch",
-                #         },
-                #     )
-                # else:
-                #     Telemetry().capture(
-                #         "tracer:init",
-                #         {
-                #             "exporter": TracerWrapper.endpoint,
-                #             "processor": "simple" if disable_batch else "batch",
-                #         },
-                #     )
-
                 obj.__spans_exporter: SpanExporter = (
                     exporter
                     if exporter
@@ -122,99 +108,16 @@ class TracerWrapper(object):
             # this makes sure otel context is propagated so we always want it
             ThreadingInstrumentor().instrument()
 
-            if instruments is None:
-                init_instrumentations(should_enrich_metrics)
-            else:
-                for instrument in instruments:
-                    if instrument == Instruments.OPENAI:
-                        if not init_openai_instrumentor(should_enrich_metrics):
-                            print("Warning: OpenAI library does not exist.")
-                    elif instrument == Instruments.ANTHROPIC:
-                        if not init_anthropic_instrumentor(should_enrich_metrics):
-                            print("Warning: Anthropic library does not exist.")
-                    elif instrument == Instruments.COHERE:
-                        if not init_cohere_instrumentor():
-                            print("Warning: Cohere library does not exist.")
-                    elif instrument == Instruments.PINECONE:
-                        if not init_pinecone_instrumentor():
-                            print("Warning: Pinecone library does not exist.")
-                    elif instrument == Instruments.CHROMA:
-                        if not init_chroma_instrumentor():
-                            print("Warning: Chroma library does not exist.")
-                    elif instrument == Instruments.GOOGLE_GENERATIVEAI:
-                        if not init_google_generativeai_instrumentor():
-                            print(
-                                "Warning: Google Generative AI library does not exist."
-                            )
-                    elif instrument == Instruments.LANGCHAIN:
-                        if not init_langchain_instrumentor():
-                            print("Warning: LangChain library does not exist.")
-                    elif instrument == Instruments.MISTRAL:
-                        if not init_mistralai_instrumentor():
-                            print("Warning: MistralAI library does not exist.")
-                    elif instrument == Instruments.OLLAMA:
-                        if not init_ollama_instrumentor():
-                            print("Warning: Ollama library does not exist.")
-                    elif instrument == Instruments.LLAMA_INDEX:
-                        if not init_llama_index_instrumentor():
-                            print("Warning: LlamaIndex library does not exist.")
-                    elif instrument == Instruments.MILVUS:
-                        if not init_milvus_instrumentor():
-                            print("Warning: Milvus library does not exist.")
-                    elif instrument == Instruments.TRANSFORMERS:
-                        if not init_transformers_instrumentor():
-                            print("Warning: Transformers library does not exist.")
-                    elif instrument == Instruments.TOGETHER:
-                        if not init_together_instrumentor():
-                            print("Warning: TogetherAI library does not exist.")
-                    elif instrument == Instruments.REQUESTS:
-                        if not init_requests_instrumentor():
-                            print("Warning: Requests library does not exist.")
-                    elif instrument == Instruments.URLLIB3:
-                        if not init_urllib3_instrumentor():
-                            print("Warning: urllib3 library does not exist.")
-                    elif instrument == Instruments.PYMYSQL:
-                        if not init_pymysql_instrumentor():
-                            print("Warning: PyMySQL library does not exist.")
-                    elif instrument == Instruments.BEDROCK:
-                        if not init_bedrock_instrumentor(should_enrich_metrics):
-                            print("Warning: Bedrock library does not exist.")
-                    elif instrument == Instruments.REPLICATE:
-                        if not init_replicate_instrumentor():
-                            print("Warning: Replicate library does not exist.")
-                    elif instrument == Instruments.VERTEXAI:
-                        if not init_vertexai_instrumentor():
-                            print("Warning: Vertex AI library does not exist.")
-                    elif instrument == Instruments.WATSONX:
-                        if not init_watsonx_instrumentor():
-                            print("Warning: Watsonx library does not exist.")
-                    elif instrument == Instruments.WEAVIATE:
-                        if not init_weaviate_instrumentor():
-                            print("Warning: Weaviate library does not exist.")
-                    elif instrument == Instruments.ALEPHALPHA:
-                        if not init_alephalpha_instrumentor():
-                            print("Warning: Aleph Alpha library does not exist.")
-                    elif instrument == Instruments.MARQO:
-                        if not init_marqo_instrumentor():
-                            print("Warning: marqo library does not exist.")
-                    elif instrument == Instruments.LANCEDB:
-                        if not init_lancedb_instrumentor():
-                            print("Warning: LanceDB library does not exist.")
-                    elif instrument == Instruments.REDIS:
-                        if not init_redis_instrumentor():
-                            print("Warning: redis library does not exist.")
-
-                    else:
-                        print(
-                            "Warning: "
-                            + instrument
-                            + " instrumentation does not exist."
-                        )
-                        print(
-                            "Usage:\n"
-                            + "from lmnr.traceloop_sdk.instruments import Instruments\n"
-                            + 'Traceloop.init(app_name="...", instruments=set([Instruments.OPENAI]))'
-                        )
+            instrument_set = init_instrumentations(
+                should_enrich_metrics,
+                instruments,
+            )
+
+            if not instrument_set:
+                logging.warning(
+                    "Warning: No valid instruments set. Remove 'instrument' "
+                    "argument to use all instruments, or set a valid instrument."
+                )
 
             obj.__content_allow_list = ContentAllowList()
 
@@ -235,6 +138,8 @@ class TracerWrapper(object):
             # the final part of the name to the span on the backend.
             span.set_attribute(SPAN_PATH, span_path)
 
+        span.set_attribute(SPAN_INSTRUMENTATION_SOURCE, "python")
+
         association_properties = get_value("association_properties")
         if association_properties is not None:
             _set_association_properties_attributes(span, association_properties)
@@ -266,10 +171,7 @@ class TracerWrapper(object):
         if hasattr(cls, "instance"):
             return True
 
-        if (os.getenv("TRACELOOP_SUPPRESS_WARNINGS") or "false").lower() == "true":
-            return False
-
-        print("Warning: Laminar not initialized, make sure to initialize")
+        logging.warning("Warning: Laminar not initialized, make sure to initialize")
         return False
 
     def flush(self):
@@ -361,47 +263,140 @@ def init_tracer_provider(resource: Resource) -> TracerProvider:
     return provider
 
 
-def init_instrumentations(should_enrich_metrics: bool):
-    init_openai_instrumentor(should_enrich_metrics)
-    init_anthropic_instrumentor(should_enrich_metrics)
-    init_cohere_instrumentor()
-    init_pinecone_instrumentor()
-    init_qdrant_instrumentor()
-    init_chroma_instrumentor()
-    init_google_generativeai_instrumentor()
-    init_haystack_instrumentor()
-    init_langchain_instrumentor()
-    init_mistralai_instrumentor()
-    init_ollama_instrumentor()
-    init_llama_index_instrumentor()
-    init_milvus_instrumentor()
-    init_transformers_instrumentor()
-    init_together_instrumentor()
-    init_bedrock_instrumentor(should_enrich_metrics)
-    init_replicate_instrumentor()
-    init_vertexai_instrumentor()
-    init_watsonx_instrumentor()
-    init_weaviate_instrumentor()
-    init_alephalpha_instrumentor()
-    init_marqo_instrumentor()
-    init_lancedb_instrumentor()
-    init_groq_instrumentor()
-
-    # These libraries are not instrumented by default, but if the user wants, he can manually specify them
-    # init_redis_instrumentor()
-    # init_requests_instrumentor()
-    # init_urllib3_instrumentor()
-    # init_pymysql_instrumentor()
+def init_instrumentations(
+    should_enrich_metrics: bool,
+    instruments: Optional[Set[Instruments]] = None,
+    block_instruments: Optional[Set[Instruments]] = None,
+):
+    block_instruments = block_instruments or set()
+    # These libraries are not instrumented by default,
+    # but if the user wants, they can manually specify them
+    default_off_instruments = set(
+        [
+            Instruments.REQUESTS,
+            Instruments.URLLIB3,
+            Instruments.REDIS,
+            Instruments.PYMYSQL,
+        ]
+    )
+
+    instruments = instruments or (set(Instruments) - default_off_instruments)
+
+    # Remove any instruments that were explicitly blocked
+    instruments = instruments - block_instruments
+
+    instrument_set = False
+    for instrument in instruments:
+        if instrument == Instruments.ALEPHALPHA:
+            if init_alephalpha_instrumentor():
+                instrument_set = True
+        elif instrument == Instruments.ANTHROPIC:
+            if init_anthropic_instrumentor(should_enrich_metrics):
+                instrument_set = True
+        elif instrument == Instruments.BEDROCK:
+            if init_bedrock_instrumentor(should_enrich_metrics):
+                instrument_set = True
+        elif instrument == Instruments.CHROMA:
+            if init_chroma_instrumentor():
+                instrument_set = True
+        elif instrument == Instruments.COHERE:
+            if init_cohere_instrumentor():
+                instrument_set = True
+        elif instrument == Instruments.GOOGLE_GENERATIVEAI:
+            if init_google_generativeai_instrumentor():
+                instrument_set = True
+        elif instrument == Instruments.GROQ:
+            if init_groq_instrumentor():
+                instrument_set = True
+        elif instrument == Instruments.HAYSTACK:
+            if init_haystack_instrumentor():
+                instrument_set = True
+        elif instrument == Instruments.LANCEDB:
+            if init_lancedb_instrumentor():
+                instrument_set = True
+        elif instrument == Instruments.LANGCHAIN:
+            if init_langchain_instrumentor():
+                instrument_set = True
+        elif instrument == Instruments.LLAMA_INDEX:
+            if init_llama_index_instrumentor():
+                instrument_set = True
+        elif instrument == Instruments.MARQO:
+            if init_marqo_instrumentor():
+                instrument_set = True
+        elif instrument == Instruments.MILVUS:
+            if init_milvus_instrumentor():
+                instrument_set = True
+        elif instrument == Instruments.MISTRAL:
+            if init_mistralai_instrumentor():
+                instrument_set = True
+        elif instrument == Instruments.OLLAMA:
+            if init_ollama_instrumentor():
+                instrument_set = True
+        elif instrument == Instruments.OPENAI:
+            if init_openai_instrumentor(should_enrich_metrics):
+                instrument_set = True
+        elif instrument == Instruments.PINECONE:
+            if init_pinecone_instrumentor():
+                instrument_set = True
+        elif instrument == Instruments.PYMYSQL:
+            if init_pymysql_instrumentor():
+                instrument_set = True
+        elif instrument == Instruments.QDRANT:
+            if init_qdrant_instrumentor():
+                instrument_set = True
+        elif instrument == Instruments.REDIS:
+            if init_redis_instrumentor():
+                instrument_set = True
+        elif instrument == Instruments.REPLICATE:
+            if init_replicate_instrumentor():
+                instrument_set = True
+        elif instrument == Instruments.REQUESTS:
+            if init_requests_instrumentor():
+                instrument_set = True
+        elif instrument == Instruments.SAGEMAKER:
+            if init_sagemaker_instrumentor(should_enrich_metrics):
+                instrument_set = True
+        elif instrument == Instruments.TOGETHER:
+            if init_together_instrumentor():
+                instrument_set = True
+        elif instrument == Instruments.TRANSFORMERS:
+            if init_transformers_instrumentor():
+                instrument_set = True
+        elif instrument == Instruments.URLLIB3:
+            if init_urllib3_instrumentor():
+                instrument_set = True
+        elif instrument == Instruments.VERTEXAI:
+            if init_vertexai_instrumentor():
+                instrument_set = True
+        elif instrument == Instruments.WATSONX:
+            if init_watsonx_instrumentor():
+                instrument_set = True
+        elif instrument == Instruments.WEAVIATE:
+            if init_weaviate_instrumentor():
+                instrument_set = True
+        else:
+            logging.warning(f"Warning: {instrument} instrumentation does not exist.")
+            logging.warning(
+                "Usage:\n"
+                "from lmnr import Laminar, Instruments\n"
+                "Laminar.init(instruments=set([Instruments.OPENAI]))"
+            )
+
+    if not instrument_set:
+        logging.warning(
+            "Warning: No valid instruments set. "
+            + "Specify instruments or remove 'instruments' argument to use all instruments."
+        )
+
+    return instrument_set
 
 
 def init_openai_instrumentor(should_enrich_metrics: bool):
     try:
         if is_package_installed("openai"):
-            # Telemetry().capture("instrumentation:openai:init")
             from opentelemetry.instrumentation.openai import OpenAIInstrumentor
 
             instrumentor = OpenAIInstrumentor(
-                # exception_logger=lambda e: Telemetry().log_exception(e),
                 enrich_assistant=should_enrich_metrics,
                 enrich_token_usage=should_enrich_metrics,
             )
@@ -411,18 +406,15 @@ def init_openai_instrumentor(should_enrich_metrics: bool):
 
     except Exception as e:
         logging.error(f"Error initializing OpenAI instrumentor: {e}")
-        # Telemetry().log_exception(e)
         return False
 
 
 def init_anthropic_instrumentor(should_enrich_metrics: bool):
     try:
         if is_package_installed("anthropic"):
-            # Telemetry().capture("instrumentation:anthropic:init")
             from opentelemetry.instrumentation.anthropic import AnthropicInstrumentor
 
             instrumentor = AnthropicInstrumentor(
-                # exception_logger=lambda e: Telemetry().log_exception(e),
                 enrich_token_usage=should_enrich_metrics,
                 upload_base64_image=None,
             )
@@ -431,244 +423,193 @@ def init_anthropic_instrumentor(should_enrich_metrics: bool):
         return True
     except Exception as e:
         logging.error(f"Error initializing Anthropic instrumentor: {e}")
-        # Telemetry().log_exception(e)
         return False
 
 
 def init_cohere_instrumentor():
     try:
         if is_package_installed("cohere"):
-            # Telemetry().capture("instrumentation:cohere:init")
             from opentelemetry.instrumentation.cohere import CohereInstrumentor
 
-            instrumentor = CohereInstrumentor(
-                # exception_logger=lambda e: Telemetry().log_exception(e),
-            )
+            instrumentor = CohereInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
                 instrumentor.instrument()
         return True
     except Exception as e:
         logging.error(f"Error initializing Cohere instrumentor: {e}")
-        # Telemetry().log_exception(e)
         return False
 
 
 def init_pinecone_instrumentor():
     try:
         if is_package_installed("pinecone"):
-            # Telemetry().capture("instrumentation:pinecone:init")
             from opentelemetry.instrumentation.pinecone import PineconeInstrumentor
 
-            instrumentor = PineconeInstrumentor(
-                # exception_logger=lambda e: Telemetry().log_exception(e),
-            )
+            instrumentor = PineconeInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
                 instrumentor.instrument()
         return True
     except Exception as e:
         logging.error(f"Error initializing Pinecone instrumentor: {e}")
-        # Telemetry().log_exception(e)
         return False
 
 
 def init_qdrant_instrumentor():
     try:
         if is_package_installed("qdrant_client"):
-            # Telemetry().capture("instrumentation:qdrant:init")
             from opentelemetry.instrumentation.qdrant import QdrantInstrumentor
 
-            instrumentor = QdrantInstrumentor(
-                # exception_logger=lambda e: Telemetry().log_exception(e),
-            )
+            instrumentor = QdrantInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
                 instrumentor.instrument()
     except Exception as e:
         logging.error(f"Error initializing Qdrant instrumentor: {e}")
-        # Telemetry().log_exception(e)
         return False
 
 
 def init_chroma_instrumentor():
     try:
         if is_package_installed("chromadb"):
-            # Telemetry().capture("instrumentation:chromadb:init")
             from opentelemetry.instrumentation.chromadb import ChromaInstrumentor
 
-            instrumentor = ChromaInstrumentor(
-                # exception_logger=lambda e: Telemetry().log_exception(e),
-            )
+            instrumentor = ChromaInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
                 instrumentor.instrument()
         return True
     except Exception as e:
         logging.error(f"Error initializing Chroma instrumentor: {e}")
-        # Telemetry().log_exception(e)
         return False
 
 
 def init_google_generativeai_instrumentor():
     try:
         if is_package_installed("google.generativeai"):
-            # Telemetry().capture("instrumentation:gemini:init")
             from opentelemetry.instrumentation.google_generativeai import (
                 GoogleGenerativeAiInstrumentor,
             )
 
-            instrumentor = GoogleGenerativeAiInstrumentor(
-                # exception_logger=lambda e: Telemetry().log_exception(e),
-            )
+            instrumentor = GoogleGenerativeAiInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
                 instrumentor.instrument()
         return True
     except Exception as e:
         logging.error(f"Error initializing Gemini instrumentor: {e}")
-        # Telemetry().log_exception(e)
         return False
 
 
 def init_haystack_instrumentor():
     try:
         if is_package_installed("haystack"):
-            # Telemetry().capture("instrumentation:haystack:init")
             from opentelemetry.instrumentation.haystack import HaystackInstrumentor
 
-            instrumentor = HaystackInstrumentor(
-                # exception_logger=lambda e: Telemetry().log_exception(e),
-            )
+            instrumentor = HaystackInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
                 instrumentor.instrument()
         return True
     except Exception as e:
         logging.error(f"Error initializing Haystack instrumentor: {e}")
-        # Telemetry().log_exception(e)
         return False
 
 
 def init_langchain_instrumentor():
     try:
         if is_package_installed("langchain"):
-            # Telemetry().capture("instrumentation:langchain:init")
             from opentelemetry.instrumentation.langchain import LangchainInstrumentor
 
-            instrumentor = LangchainInstrumentor(
-                # exception_logger=lambda e: Telemetry().log_exception(e),
-            )
+            instrumentor = LangchainInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
                 instrumentor.instrument()
         return True
     except Exception as e:
-        logging.error(f"Error initializing LangChain instrumentor: {e}")
-        # Telemetry().log_exception(e)
+        # FIXME: silencing this error temporarily, it appears to not be critical
+        if str(e) != "No module named 'langchain_community'":
+            logging.error(f"Error initializing LangChain instrumentor: {e}")
         return False
 
 
 def init_mistralai_instrumentor():
     try:
         if is_package_installed("mistralai"):
-            # Telemetry().capture("instrumentation:mistralai:init")
             from opentelemetry.instrumentation.mistralai import MistralAiInstrumentor
 
-            instrumentor = MistralAiInstrumentor(
-                # exception_logger=lambda e: Telemetry().log_exception(e),
-            )
+            instrumentor = MistralAiInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
                 instrumentor.instrument()
         return True
     except Exception as e:
         logging.error(f"Error initializing MistralAI instrumentor: {e}")
-        # Telemetry().log_exception(e)
         return False
 
 
 def init_ollama_instrumentor():
     try:
         if is_package_installed("ollama"):
-            # Telemetry().capture("instrumentation:ollama:init")
             from opentelemetry.instrumentation.ollama import OllamaInstrumentor
 
-            instrumentor = OllamaInstrumentor(
-                # exception_logger=lambda e: Telemetry().log_exception(e),
-            )
+            instrumentor = OllamaInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
                 instrumentor.instrument()
         return True
     except Exception as e:
         logging.error(f"Error initializing Ollama instrumentor: {e}")
-        # Telemetry().log_exception(e)
         return False
 
 
 def init_transformers_instrumentor():
     try:
         if is_package_installed("transformers"):
-            # Telemetry().capture("instrumentation:transformers:init")
             from opentelemetry.instrumentation.transformers import (
                 TransformersInstrumentor,
             )
 
-            instrumentor = TransformersInstrumentor(
-                # exception_logger=lambda e: Telemetry().log_exception(e),
-            )
+            instrumentor = TransformersInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
                 instrumentor.instrument()
         return True
     except Exception as e:
         logging.error(f"Error initializing Transformers instrumentor: {e}")
-        # Telemetry().log_exception(e)
         return False
 
 
 def init_together_instrumentor():
     try:
         if is_package_installed("together"):
-            # Telemetry().capture("instrumentation:together:init")
             from opentelemetry.instrumentation.together import TogetherAiInstrumentor
 
-            instrumentor = TogetherAiInstrumentor(
-                # exception_logger=lambda e: Telemetry().log_exception(e),
-            )
+            instrumentor = TogetherAiInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
                 instrumentor.instrument()
         return True
     except Exception as e:
         logging.error(f"Error initializing TogetherAI instrumentor: {e}")
-        # Telemetry().log_exception(e)
         return False
 
 
 def init_llama_index_instrumentor():
     try:
         if is_package_installed("llama-index") or is_package_installed("llama_index"):
-            # Telemetry().capture("instrumentation:llamaindex:init")
             from opentelemetry.instrumentation.llamaindex import LlamaIndexInstrumentor
 
-            instrumentor = LlamaIndexInstrumentor(
-                # exception_logger=lambda e: Telemetry().log_exception(e),
-            )
+            instrumentor = LlamaIndexInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
                 instrumentor.instrument()
         return True
     except Exception as e:
         logging.error(f"Error initializing LlamaIndex instrumentor: {e}")
-        # Telemetry().log_exception(e)
         return False
 
 
 def init_milvus_instrumentor():
     try:
         if is_package_installed("pymilvus"):
-            # Telemetry().capture("instrumentation:milvus:init")
             from opentelemetry.instrumentation.milvus import MilvusInstrumentor
 
-            instrumentor = MilvusInstrumentor(
-                # exception_logger=lambda e: Telemetry().log_exception(e),
-            )
+            instrumentor = MilvusInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
                 instrumentor.instrument()
         return True
     except Exception as e:
         logging.error(f"Error initializing Milvus instrumentor: {e}")
-        # Telemetry().log_exception(e)
         return False
 
 
@@ -683,7 +624,6 @@ def init_requests_instrumentor():
         return True
     except Exception as e:
         logging.error(f"Error initializing Requests instrumentor: {e}")
-        # Telemetry().log_exception(e)
         return False
 
 
@@ -698,7 +638,6 @@ def init_urllib3_instrumentor():
         return True
     except Exception as e:
         logging.error(f"Error initializing urllib3 instrumentor: {e}")
-        # Telemetry().log_exception(e)
         return False
 
 
@@ -713,7 +652,6 @@ def init_pymysql_instrumentor():
         return True
     except Exception as e:
         logging.error(f"Error initializing SQLAlchemy instrumentor: {e}")
-        # Telemetry().log_exception(e)
         return False
 
 
@@ -723,7 +661,6 @@ def init_bedrock_instrumentor(should_enrich_metrics: bool):
             from opentelemetry.instrumentation.bedrock import BedrockInstrumentor
 
             instrumentor = BedrockInstrumentor(
-                # exception_logger=lambda e: Telemetry().log_exception(e),
                 enrich_token_usage=should_enrich_metrics,
             )
             if not instrumentor.is_instrumented_by_opentelemetry:
@@ -731,43 +668,34 @@ def init_bedrock_instrumentor(should_enrich_metrics: bool):
         return True
     except Exception as e:
         logging.error(f"Error initializing Bedrock instrumentor: {e}")
-        # Telemetry().log_exception(e)
         return False
 
 
 def init_replicate_instrumentor():
     try:
         if is_package_installed("replicate"):
-            # Telemetry().capture("instrumentation:replicate:init")
             from opentelemetry.instrumentation.replicate import ReplicateInstrumentor
 
-            instrumentor = ReplicateInstrumentor(
-                # exception_logger=lambda e: Telemetry().log_exception(e),
-            )
+            instrumentor = ReplicateInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
                 instrumentor.instrument()
         return True
     except Exception as e:
         logging.error(f"Error initializing Replicate instrumentor: {e}")
-        # Telemetry().log_exception(e)
         return False
 
 
 def init_vertexai_instrumentor():
     try:
         if is_package_installed("vertexai"):
-            # Telemetry().capture("instrumentation:vertexai:init")
             from opentelemetry.instrumentation.vertexai import VertexAIInstrumentor
 
-            instrumentor = VertexAIInstrumentor(
-                # exception_logger=lambda e: Telemetry().log_exception(e),
-            )
+            instrumentor = VertexAIInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
                 instrumentor.instrument()
         return True
     except Exception as e:
         logging.warning(f"Error initializing Vertex AI instrumentor: {e}")
-        # Telemetry().log_exception(e)
         return False
 
 
@@ -776,84 +704,65 @@ def init_watsonx_instrumentor():
         if is_package_installed("ibm-watsonx-ai") or is_package_installed(
             "ibm-watson-machine-learning"
         ):
-            # Telemetry().capture("instrumentation:watsonx:init")
             from opentelemetry.instrumentation.watsonx import WatsonxInstrumentor
 
-            instrumentor = WatsonxInstrumentor(
-                # exception_logger=lambda e: Telemetry().log_exception(e),
-            )
+            instrumentor = WatsonxInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
                 instrumentor.instrument()
         return True
     except Exception as e:
         logging.warning(f"Error initializing Watsonx instrumentor: {e}")
-        # Telemetry().log_exception(e)
         return False
 
 
 def init_weaviate_instrumentor():
     try:
         if is_package_installed("weaviate"):
-            # Telemetry().capture("instrumentation:weaviate:init")
             from opentelemetry.instrumentation.weaviate import WeaviateInstrumentor
 
-            instrumentor = WeaviateInstrumentor(
-                # exception_logger=lambda e: Telemetry().log_exception(e),
-            )
+            instrumentor = WeaviateInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
                 instrumentor.instrument()
         return True
     except Exception as e:
         logging.warning(f"Error initializing Weaviate instrumentor: {e}")
-        # Telemetry().log_exception(e)
         return False
 
 
 def init_alephalpha_instrumentor():
     try:
         if is_package_installed("aleph_alpha_client"):
-            # Telemetry().capture("instrumentation:alephalpha:init")
             from opentelemetry.instrumentation.alephalpha import AlephAlphaInstrumentor
 
-            instrumentor = AlephAlphaInstrumentor(
-                # exception_logger=lambda e: Telemetry().log_exception(e),
-            )
+            instrumentor = AlephAlphaInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
                 instrumentor.instrument()
         return True
     except Exception as e:
         logging.error(f"Error initializing Aleph Alpha instrumentor: {e}")
-        # Telemetry().log_exception(e)
         return False
 
 
 def init_marqo_instrumentor():
     try:
         if is_package_installed("marqo"):
-            # Telemetry().capture("instrumentation:marqo:init")
             from opentelemetry.instrumentation.marqo import MarqoInstrumentor
 
-            instrumentor = MarqoInstrumentor(
-                # exception_logger=lambda e: Telemetry().log_exception(e),
-            )
+            instrumentor = MarqoInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
                 instrumentor.instrument()
         return True
     except Exception as e:
         logging.error(f"Error initializing marqo instrumentor: {e}")
-        # Telemetry().log_exception(e)
         return False
 
 
 def init_lancedb_instrumentor():
     try:
         if is_package_installed("lancedb"):
-            # Telemetry().capture("instrumentation:lancedb:init")
             from opentelemetry.instrumentation.lancedb import LanceInstrumentor
 
-            instrumentor = LanceInstrumentor(
-                # exception_logger=lambda e: Telemetry().log_exception(e),
-            )
+            instrumentor = LanceInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
                 instrumentor.instrument()
         return True
@@ -872,23 +781,34 @@ def init_redis_instrumentor():
         return True
     except Exception as e:
         logging.error(f"Error initializing redis instrumentor: {e}")
-        # Telemetry().log_exception(e)
         return False
 
 
 def init_groq_instrumentor():
     try:
         if is_package_installed("groq"):
-            # Telemetry().capture("instrumentation:groq:init")
             from opentelemetry.instrumentation.groq import GroqInstrumentor
 
-            instrumentor = GroqInstrumentor(
-                # exception_logger=lambda e: Telemetry().log_exception(e),
-            )
+            instrumentor = GroqInstrumentor()
             if not instrumentor.is_instrumented_by_opentelemetry:
                 instrumentor.instrument()
         return True
     except Exception as e:
         logging.error(f"Error initializing Groq instrumentor: {e}")
-        # Telemetry().log_exception(e)
+        return False
+
+
+def init_sagemaker_instrumentor(should_enrich_metrics: bool):
+    try:
+        if is_package_installed("boto3"):
+            from opentelemetry.instrumentation.sagemaker import SageMakerInstrumentor
+
+            instrumentor = SageMakerInstrumentor(
+                enrich_token_usage=should_enrich_metrics,
+            )
+            if not instrumentor.is_instrumented_by_opentelemetry:
+                instrumentor.instrument()
+        return True
+    except Exception as e:
+        logging.error(f"Error initializing SageMaker instrumentor: {e}")
         return False