lmnr 0.4.29b0__py3-none-any.whl → 0.4.29b1__py3-none-any.whl

lmnr/traceloop_sdk/instruments.py

@@ -4,27 +4,31 @@ from enum import Enum
 class Instruments(Enum):
     # The list of libraries which will be autoinstrumented
     # if no specific instruments are provided to initialize()
-    OPENAI = "openai"
+    ALEPHALPHA = "alephalpha"
     ANTHROPIC = "anthropic"
-    COHERE = "cohere"
-    PINECONE = "pinecone"
+    BEDROCK = "bedrock"
     CHROMA = "chroma"
+    COHERE = "cohere"
     GOOGLE_GENERATIVEAI = "google_generativeai"
+    GROQ = "groq"
+    HAYSTACK = "haystack"
+    LANCEDB = "lancedb"
     LANGCHAIN = "langchain"
-    MISTRAL = "mistral"
-    OLLAMA = "ollama"
     LLAMA_INDEX = "llama_index"
+    MARQO = "marqo"
     MILVUS = "milvus"
-    TRANSFORMERS = "transformers"
-    TOGETHER = "together"
-    BEDROCK = "bedrock"
+    MISTRAL = "mistral"
+    OLLAMA = "ollama"
+    OPENAI = "openai"
+    PINECONE = "pinecone"
+    QDRANT = "qdrant"
     REPLICATE = "replicate"
+    SAGEMAKER = "sagemaker"
+    TOGETHER = "together"
+    TRANSFORMERS = "transformers"
     VERTEXAI = "vertexai"
     WATSONX = "watsonx"
     WEAVIATE = "weaviate"
-    ALEPHALPHA = "alephalpha"
-    MARQO = "marqo"
-    LANCEDB = "lancedb"
 
     # The following libraries will not be autoinstrumented unless
     # specified explicitly in the initialize() call.

lmnr/traceloop_sdk/tracing/tracing.py

@@ -23,7 +23,6 @@ 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,
@@ -50,6 +49,7 @@ EXCLUDED_URLS = """
     posthog.com,
     sentry.io,
     bedrock-runtime,
+    sagemaker-runtime,
     googleapis.com,
     githubusercontent.com,
     openaipublic.blob.core.windows.net"""
@@ -79,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
@@ -126,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()
 
@@ -364,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,
             )
@@ -414,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,
             )
@@ -434,246 +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:
-        # FIXME: silence this error temporarily, it appears to not be critical
+        # 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}")
-        # Telemetry().log_exception(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
 
 
@@ -688,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
 
 
@@ -703,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
 
 
@@ -718,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
 
 
@@ -728,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:
@@ -736,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
 
 
@@ -781,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
@@ -877,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

{lmnr-0.4.29b0.dist-info → lmnr-0.4.29b1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lmnr
-Version: 0.4.29b0
+Version: 0.4.29b1
 Summary: Python SDK for Laminar AI
 License: Apache-2.0
 Author: lmnr.ai
@@ -39,6 +39,7 @@ Requires-Dist: opentelemetry-instrumentation-pinecone (>=0.33.5)
 Requires-Dist: opentelemetry-instrumentation-qdrant (>=0.33.5)
 Requires-Dist: opentelemetry-instrumentation-replicate (>=0.33.5)
 Requires-Dist: opentelemetry-instrumentation-requests (>=0.48b0,<0.49)
+Requires-Dist: opentelemetry-instrumentation-sagemaker (>=0.33.5)
 Requires-Dist: opentelemetry-instrumentation-sqlalchemy (>=0.48b0,<0.49)
 Requires-Dist: opentelemetry-instrumentation-threading (>=0.48b0,<0.49)
 Requires-Dist: opentelemetry-instrumentation-together (>=0.33.5)

{lmnr-0.4.29b0.dist-info → lmnr-0.4.29b1.dist-info}/RECORD

@@ -14,7 +14,7 @@ lmnr/traceloop_sdk/__init__.py,sha256=hp3q1OsFaGgaQCEanJrL38BJN32hWqCNVCSjYpndEs
 lmnr/traceloop_sdk/config/__init__.py,sha256=DliMGp2NjYAqRFLKpWQPUKjGMHRO8QsVfazBA1qENQ8,248
 lmnr/traceloop_sdk/decorators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lmnr/traceloop_sdk/decorators/base.py,sha256=SeImd8SAeqdC8LV1bvoQUq0d_TLkOLyd5HCe7vXKhNU,5559
-lmnr/traceloop_sdk/instruments.py,sha256=oMvIASueW3GeChpjIdH-DD9aFBVB8OtHZ0HawppTrlI,942
+lmnr/traceloop_sdk/instruments.py,sha256=CGGUEELldrXkQwAzAkDeAtDq07_pjhz7i14a92P7C_E,1036
 lmnr/traceloop_sdk/tests/__init__.py,sha256=RYnG0-8zbXL0-2Ste1mEBf5sN4d_rQjGTCgPBuaZC74,20
 lmnr/traceloop_sdk/tests/cassettes/test_association_properties/test_langchain_and_external_association_properties.yaml,sha256=26g0wRA0juicHg_XrhcE8H4vhs1lawDs0o0aLFn-I7w,3103
 lmnr/traceloop_sdk/tests/cassettes/test_association_properties/test_langchain_association_properties.yaml,sha256=FNlSWlYCsWc3w7UPZzfGjDnxS3gAOhL-kpsu4BTxsDE,3061
@@ -39,14 +39,14 @@ lmnr/traceloop_sdk/tracing/__init__.py,sha256=Ckq7zCM26VdJVB5tIZv0GTPyMZKyfso_KW
 lmnr/traceloop_sdk/tracing/attributes.py,sha256=QeqItpCCwUipkwgXG7J7swJCD0yk9uuI28aepPhemtE,1201
 lmnr/traceloop_sdk/tracing/content_allow_list.py,sha256=3feztm6PBWNelc8pAZUcQyEGyeSpNiVKjOaDk65l2ps,846
 lmnr/traceloop_sdk/tracing/context_manager.py,sha256=csVlB6kDmbgSPsROHwnddvGGblx55v6lJMRj0wsSMQM,304
-lmnr/traceloop_sdk/tracing/tracing.py,sha256=2Vyc0hUdTqXYlBzoW7YO6DlLaUKWouLv7eEvrVMZYOo,35680
+lmnr/traceloop_sdk/tracing/tracing.py,sha256=hFqTp7OGMCZnfxVtrmRq3wP3Ph5YvHq3fz9p00_Yk-Q,29433
 lmnr/traceloop_sdk/utils/__init__.py,sha256=pNhf0G3vTd5ccoc03i1MXDbricSaiqCbi1DLWhSekK8,604
 lmnr/traceloop_sdk/utils/in_memory_span_exporter.py,sha256=H_4TRaThMO1H6vUQ0OpQvzJk_fZH0OOsRAM1iZQXsR8,2112
 lmnr/traceloop_sdk/utils/json_encoder.py,sha256=dK6b_axr70IYL7Vv-bu4wntvDDuyntoqsHaddqX7P58,463
 lmnr/traceloop_sdk/utils/package_check.py,sha256=TZSngzJOpFhfUZLXIs38cpMxQiZSmp0D-sCrIyhz7BA,251
 lmnr/traceloop_sdk/version.py,sha256=OlatFEFA4ttqSSIiV8jdE-sq3KG5zu2hnC4B4mzWF3s,23
-lmnr-0.4.29b0.dist-info/LICENSE,sha256=67b_wJHVV1CBaWkrKFWU1wyqTPSdzH77Ls-59631COg,10411
-lmnr-0.4.29b0.dist-info/METADATA,sha256=ATL1IcRQIpALFB7apCO0TX0N2ve93ZxwytS61_vt_jA,10624
-lmnr-0.4.29b0.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-lmnr-0.4.29b0.dist-info/entry_points.txt,sha256=K1jE20ww4jzHNZLnsfWBvU3YKDGBgbOiYG5Y7ivQcq4,37
-lmnr-0.4.29b0.dist-info/RECORD,,
+lmnr-0.4.29b1.dist-info/LICENSE,sha256=67b_wJHVV1CBaWkrKFWU1wyqTPSdzH77Ls-59631COg,10411
+lmnr-0.4.29b1.dist-info/METADATA,sha256=DrDBNTFOlwaWITf_iVv8vSrKZX2-cxMje0y69jcyceU,10690
+lmnr-0.4.29b1.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+lmnr-0.4.29b1.dist-info/entry_points.txt,sha256=K1jE20ww4jzHNZLnsfWBvU3YKDGBgbOiYG5Y7ivQcq4,37
+lmnr-0.4.29b1.dist-info/RECORD,,