lmnr 0.5.3__py3-none-any.whl → 0.6.0__py3-none-any.whl

lmnr/opentelemetry_lib/tracing/_instrument_initializers.py

@@ -0,0 +1,398 @@
+import abc
+
+from typing import Optional
+from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
+
+from lmnr.opentelemetry_lib.utils.package_check import is_package_installed
+
+
+class InstrumentorInitializer(abc.ABC):
+    @abc.abstractmethod
+    def init_instrumentor(self, *args, **kwargs) -> Optional[BaseInstrumentor]:
+        pass
+
+
+class AlephAlphaInstrumentorInitializer(InstrumentorInitializer):
+    def init_instrumentor(self, *args, **kwargs) -> Optional[BaseInstrumentor]:
+        if not is_package_installed("aleph_alpha_client"):
+            return None
+        if not is_package_installed("opentelemetry-instrumentation-alephalpha"):
+            return None
+
+        from opentelemetry.instrumentation.alephalpha import AlephAlphaInstrumentor
+
+        return AlephAlphaInstrumentor()
+
+
+class AnthropicInstrumentorInitializer(InstrumentorInitializer):
+    def init_instrumentor(self, *args, **kwargs) -> Optional[BaseInstrumentor]:
+        if not is_package_installed("anthropic"):
+            return None
+        if not is_package_installed("opentelemetry-instrumentation-anthropic"):
+            return None
+
+        from opentelemetry.instrumentation.anthropic import AnthropicInstrumentor
+
+        return AnthropicInstrumentor(
+            upload_base64_image=None,
+        )
+
+
+class BedrockInstrumentorInitializer(InstrumentorInitializer):
+    def init_instrumentor(self, *args, **kwargs) -> Optional[BaseInstrumentor]:
+        if not is_package_installed("boto3"):
+            return None
+        if not is_package_installed("opentelemetry-instrumentation-bedrock"):
+            return None
+
+        from opentelemetry.instrumentation.bedrock import BedrockInstrumentor
+
+        return BedrockInstrumentor()
+
+
+class BrowserUseInstrumentorInitializer(InstrumentorInitializer):
+    def init_instrumentor(self, *args, **kwargs) -> Optional[BaseInstrumentor]:
+        if not is_package_installed("browser-use"):
+            return None
+
+        from lmnr.sdk.browser.browser_use_otel import BrowserUseInstrumentor
+
+        return BrowserUseInstrumentor()
+
+
+class ChromaInstrumentorInitializer(InstrumentorInitializer):
+    def init_instrumentor(self, *args, **kwargs) -> Optional[BaseInstrumentor]:
+        if not is_package_installed("chromadb"):
+            return None
+        if not is_package_installed("opentelemetry-instrumentation-chromadb"):
+            return None
+
+        from opentelemetry.instrumentation.chromadb import ChromaInstrumentor
+
+        return ChromaInstrumentor()
+
+
+class CohereInstrumentorInitializer(InstrumentorInitializer):
+    def init_instrumentor(self, *args, **kwargs) -> Optional[BaseInstrumentor]:
+        if not is_package_installed("cohere"):
+            return None
+        if not is_package_installed("opentelemetry-instrumentation-cohere"):
+            return None
+
+        from opentelemetry.instrumentation.cohere import CohereInstrumentor
+
+        return CohereInstrumentor()
+
+
+class CrewAIInstrumentorInitializer(InstrumentorInitializer):
+    def init_instrumentor(self, *args, **kwargs) -> Optional[BaseInstrumentor]:
+        if not is_package_installed("crewai"):
+            return None
+        if not is_package_installed("opentelemetry-instrumentation-crewai"):
+            return None
+
+        from opentelemetry.instrumentation.crewai import CrewAiInstrumentor
+
+        return CrewAiInstrumentor()
+
+
+class GoogleGenerativeAIInstrumentorInitializer(InstrumentorInitializer):
+    def init_instrumentor(self, *args, **kwargs) -> Optional[BaseInstrumentor]:
+        if not is_package_installed("google-generativeai"):
+            return None
+        if not is_package_installed(
+            "opentelemetry-instrumentation-google-generativeai"
+        ):
+            return None
+
+        from opentelemetry.instrumentation.google_generativeai import (
+            GoogleGenerativeAiInstrumentor,
+        )
+
+        return GoogleGenerativeAiInstrumentor()
+
+
+class GoogleGenAIInstrumentorInitializer(InstrumentorInitializer):
+    def init_instrumentor(self, *args, **kwargs) -> Optional[BaseInstrumentor]:
+        if not is_package_installed("google-genai"):
+            return None
+
+        from ..opentelemetry.instrumentation.google_genai import (
+            GoogleGenAiSdkInstrumentor,
+        )
+
+        return GoogleGenAiSdkInstrumentor()
+
+
+class GroqInstrumentorInitializer(InstrumentorInitializer):
+    def init_instrumentor(self, *args, **kwargs) -> Optional[BaseInstrumentor]:
+        if not is_package_installed("groq"):
+            return None
+        if not is_package_installed("opentelemetry-instrumentation-groq"):
+            return None
+
+        from opentelemetry.instrumentation.groq import GroqInstrumentor
+
+        return GroqInstrumentor()
+
+
+class HaystackInstrumentorInitializer(InstrumentorInitializer):
+    def init_instrumentor(self, *args, **kwargs) -> Optional[BaseInstrumentor]:
+        if not is_package_installed("haystack"):
+            return None
+        if not is_package_installed("opentelemetry-instrumentation-haystack"):
+            return None
+
+        from opentelemetry.instrumentation.haystack import HaystackInstrumentor
+
+        return HaystackInstrumentor()
+
+
+class LanceDBInstrumentorInitializer(InstrumentorInitializer):
+    def init_instrumentor(self, *args, **kwargs) -> Optional[BaseInstrumentor]:
+        if not is_package_installed("lancedb"):
+            return None
+        if not is_package_installed("opentelemetry-instrumentation-lancedb"):
+            return None
+
+        from opentelemetry.instrumentation.lancedb import LanceInstrumentor
+
+        return LanceInstrumentor()
+
+
+class LangchainInstrumentorInitializer(InstrumentorInitializer):
+    def init_instrumentor(self, *args, **kwargs) -> Optional[BaseInstrumentor]:
+        if not is_package_installed("langchain"):
+            return None
+        if not is_package_installed("opentelemetry-instrumentation-langchain"):
+            return None
+
+        from opentelemetry.instrumentation.langchain import LangchainInstrumentor
+
+        return LangchainInstrumentor()
+
+
+class LlamaIndexInstrumentorInitializer(InstrumentorInitializer):
+    def init_instrumentor(self, *args, **kwargs) -> Optional[BaseInstrumentor]:
+        if not (
+            is_package_installed("llama-index") or is_package_installed("llama_index")
+        ):
+            return None
+        if not is_package_installed("opentelemetry-instrumentation-llamaindex"):
+            return None
+
+        from opentelemetry.instrumentation.llamaindex import LlamaIndexInstrumentor
+
+        return LlamaIndexInstrumentor()
+
+
+class MarqoInstrumentorInitializer(InstrumentorInitializer):
+    def init_instrumentor(self, *args, **kwargs) -> Optional[BaseInstrumentor]:
+        if not is_package_installed("marqo"):
+            return None
+        if not is_package_installed("opentelemetry-instrumentation-marqo"):
+            return None
+
+        from opentelemetry.instrumentation.marqo import MarqoInstrumentor
+
+        return MarqoInstrumentor()
+
+
+class MCPInstrumentorInitializer(InstrumentorInitializer):
+    def init_instrumentor(self, *args, **kwargs) -> Optional[BaseInstrumentor]:
+        if not is_package_installed("mcp"):
+            return None
+        if not is_package_installed("opentelemetry-instrumentation-mcp"):
+            return None
+
+        from opentelemetry.instrumentation.mcp import MCPInstrumentor
+
+        return MCPInstrumentor()
+
+
+class MilvusInstrumentorInitializer(InstrumentorInitializer):
+    def init_instrumentor(self, *args, **kwargs) -> Optional[BaseInstrumentor]:
+        if not is_package_installed("pymilvus"):
+            return None
+        if not is_package_installed("opentelemetry-instrumentation-milvus"):
+            return None
+
+        from opentelemetry.instrumentation.milvus import MilvusInstrumentor
+
+        return MilvusInstrumentor()
+
+
+class MistralInstrumentorInitializer(InstrumentorInitializer):
+    def init_instrumentor(self, *args, **kwargs) -> Optional[BaseInstrumentor]:
+        if not is_package_installed("mistralai"):
+            return None
+        if not is_package_installed("opentelemetry-instrumentation-mistralai"):
+            return None
+
+        from opentelemetry.instrumentation.mistralai import MistralAiInstrumentor
+
+        return MistralAiInstrumentor()
+
+
+class OllamaInstrumentorInitializer(InstrumentorInitializer):
+    def init_instrumentor(self, *args, **kwargs) -> Optional[BaseInstrumentor]:
+        if not is_package_installed("ollama"):
+            return None
+        if not is_package_installed("opentelemetry-instrumentation-ollama"):
+            return None
+
+        from opentelemetry.instrumentation.ollama import OllamaInstrumentor
+
+        return OllamaInstrumentor()
+
+
+class OpenAIInstrumentorInitializer(InstrumentorInitializer):
+    def init_instrumentor(self, *args, **kwargs) -> Optional[BaseInstrumentor]:
+        if not is_package_installed("openai"):
+            return None
+        if not is_package_installed("opentelemetry-instrumentation-openai"):
+            return None
+
+        from opentelemetry.instrumentation.openai import OpenAIInstrumentor
+
+        return OpenAIInstrumentor(
+            # Default in the package provided is an empty function, which
+            # results in dropping the image data if we don't explicitly
+            # set it to None.
+            upload_base64_image=None,
+        )
+
+
+class PatchrightInstrumentorInitializer(InstrumentorInitializer):
+    def init_instrumentor(
+        self, client, async_client, *args, **kwargs
+    ) -> Optional[BaseInstrumentor]:
+        if not is_package_installed("patchright"):
+            return None
+
+        from lmnr.sdk.browser.patchright_otel import PatchrightInstrumentor
+
+        return PatchrightInstrumentor(client, async_client)
+
+
+class PineconeInstrumentorInitializer(InstrumentorInitializer):
+    def init_instrumentor(self, *args, **kwargs) -> Optional[BaseInstrumentor]:
+        if not is_package_installed("pinecone"):
+            return None
+        if not is_package_installed("opentelemetry-instrumentation-pinecone"):
+            return None
+
+        from opentelemetry.instrumentation.pinecone import PineconeInstrumentor
+
+        return PineconeInstrumentor()
+
+
+class PlaywrightInstrumentorInitializer(InstrumentorInitializer):
+    def init_instrumentor(
+        self, client, async_client, *args, **kwargs
+    ) -> Optional[BaseInstrumentor]:
+        if not is_package_installed("playwright"):
+            return None
+
+        from lmnr.sdk.browser.playwright_otel import PlaywrightInstrumentor
+
+        return PlaywrightInstrumentor(client, async_client)
+
+
+class QdrantInstrumentorInitializer(InstrumentorInitializer):
+    def init_instrumentor(self, *args, **kwargs) -> Optional[BaseInstrumentor]:
+        if not is_package_installed("qdrant_client"):
+            return None
+        if not is_package_installed("opentelemetry-instrumentation-qdrant"):
+            return None
+
+        from opentelemetry.instrumentation.qdrant import QdrantInstrumentor
+
+        return QdrantInstrumentor()
+
+
+class ReplicateInstrumentorInitializer(InstrumentorInitializer):
+    def init_instrumentor(self, *args, **kwargs) -> Optional[BaseInstrumentor]:
+        if not is_package_installed("replicate"):
+            return None
+        if not is_package_installed("opentelemetry-instrumentation-replicate"):
+            return None
+
+        from opentelemetry.instrumentation.replicate import ReplicateInstrumentor
+
+        return ReplicateInstrumentor()
+
+
+class SageMakerInstrumentorInitializer(InstrumentorInitializer):
+    def init_instrumentor(self, *args, **kwargs) -> Optional[BaseInstrumentor]:
+        if not is_package_installed("boto3"):
+            return None
+        if not is_package_installed("opentelemetry-instrumentation-sagemaker"):
+            return None
+
+        from opentelemetry.instrumentation.sagemaker import SageMakerInstrumentor
+
+        return SageMakerInstrumentor()
+
+
+class TogetherInstrumentorInitializer(InstrumentorInitializer):
+    def init_instrumentor(self, *args, **kwargs) -> Optional[BaseInstrumentor]:
+        if not is_package_installed("together"):
+            return None
+        if not is_package_installed("opentelemetry-instrumentation-together"):
+            return None
+
+        from opentelemetry.instrumentation.together import TogetherAiInstrumentor
+
+        return TogetherAiInstrumentor()
+
+
+class TransformersInstrumentorInitializer(InstrumentorInitializer):
+    def init_instrumentor(self, *args, **kwargs) -> Optional[BaseInstrumentor]:
+        if not is_package_installed("transformers"):
+            return None
+        if not is_package_installed("opentelemetry-instrumentation-transformers"):
+            return None
+
+        from opentelemetry.instrumentation.transformers import TransformersInstrumentor
+
+        return TransformersInstrumentor()
+
+
+class VertexAIInstrumentorInitializer(InstrumentorInitializer):
+    def init_instrumentor(self, *args, **kwargs) -> Optional[BaseInstrumentor]:
+        if not is_package_installed("vertexai"):
+            return None
+        if not is_package_installed("opentelemetry-instrumentation-vertexai"):
+            return None
+
+        from opentelemetry.instrumentation.vertexai import VertexAIInstrumentor
+
+        return VertexAIInstrumentor()
+
+
+class WatsonxInstrumentorInitializer(InstrumentorInitializer):
+    def init_instrumentor(self, *args, **kwargs) -> Optional[BaseInstrumentor]:
+        if not (
+            is_package_installed("ibm-watsonx-ai")
+            or is_package_installed("ibm-watson-machine-learning")
+        ):
+            return None
+        if not is_package_installed("opentelemetry-instrumentation-watsonx"):
+            return None
+
+        from opentelemetry.instrumentation.watsonx import WatsonxInstrumentor
+
+        return WatsonxInstrumentor()
+
+
+class WeaviateInstrumentorInitializer(InstrumentorInitializer):
+    def init_instrumentor(self, *args, **kwargs) -> Optional[BaseInstrumentor]:
+        if not is_package_installed("weaviate"):
+            return None
+        if not is_package_installed("opentelemetry-instrumentation-weaviate"):
+            return None
+
+        from opentelemetry.instrumentation.weaviate import WeaviateInstrumentor
+
+        return WeaviateInstrumentor()

lmnr/opentelemetry_lib/tracing/attributes.py

@@ -1,4 +1,12 @@
 from enum import Enum
+from opentelemetry.semconv._incubating.attributes.gen_ai_attributes import (
+    GEN_AI_SYSTEM,
+    GEN_AI_REQUEST_MODEL,
+    GEN_AI_RESPONSE_MODEL,
+    GEN_AI_USAGE_INPUT_TOKENS,
+    GEN_AI_USAGE_OUTPUT_TOKENS,
+    GEN_AI_RESPONSE_ID,
+)
 from opentelemetry.semconv_ai import SpanAttributes
 
 SPAN_INPUT = "lmnr.span.input"
@@ -21,14 +29,12 @@ TRACING_LEVEL = "tracing_level"
 class Attributes(Enum):
     # == This is the minimum set of attributes for a proper LLM span ==
     #
-    # not SpanAttributes.LLM_USAGE_PROMPT_TOKENS,
-    INPUT_TOKEN_COUNT = "gen_ai.usage.input_tokens"
-    # not SpanAttributes.LLM_USAGE_COMPLETION_TOKENS,
-    OUTPUT_TOKEN_COUNT = "gen_ai.usage.output_tokens"
+    INPUT_TOKEN_COUNT = GEN_AI_USAGE_INPUT_TOKENS
+    OUTPUT_TOKEN_COUNT = GEN_AI_USAGE_OUTPUT_TOKENS
     TOTAL_TOKEN_COUNT = SpanAttributes.LLM_USAGE_TOTAL_TOKENS
-    PROVIDER = SpanAttributes.LLM_SYSTEM
-    REQUEST_MODEL = SpanAttributes.LLM_REQUEST_MODEL
-    RESPONSE_MODEL = SpanAttributes.LLM_RESPONSE_MODEL
+    PROVIDER = GEN_AI_SYSTEM
+    REQUEST_MODEL = GEN_AI_REQUEST_MODEL
+    RESPONSE_MODEL = GEN_AI_RESPONSE_MODEL
     #
     ## == End of minimum set ==
     # == Additional attributes ==
@@ -36,5 +42,6 @@ class Attributes(Enum):
     INPUT_COST = "gen_ai.usage.input_cost"
     OUTPUT_COST = "gen_ai.usage.output_cost"
     TOTAL_COST = "gen_ai.usage.cost"
+    RESPONSE_ID = GEN_AI_RESPONSE_ID
     #
     # == End of additional attributes ==

lmnr/opentelemetry_lib/tracing/context_properties.py

@@ -0,0 +1,53 @@
+import copy
+from typing import Optional
+
+from lmnr.opentelemetry_lib.tracing.attributes import (
+    ASSOCIATION_PROPERTIES,
+    TRACING_LEVEL,
+)
+
+from opentelemetry.context import Context, attach, set_value, get_value
+from opentelemetry.trace import Span
+from opentelemetry import trace
+
+
+def set_association_properties(properties: dict) -> None:
+    attach(set_value("association_properties", properties))
+
+    span = trace.get_current_span()
+    _set_association_properties_attributes(span, properties)
+
+
+def get_association_properties(context: Optional[Context] = None) -> dict:
+    return get_value("association_properties", context) or {}
+
+
+def update_association_properties(
+    properties: dict,
+    set_on_current_span: bool = True,
+    context: Optional[Context] = None,
+) -> None:
+    """Only adds or updates properties that are not already present"""
+    association_properties = get_value("association_properties", context) or {}
+    association_properties.update(properties)
+
+    attach(set_value("association_properties", association_properties, context))
+
+    if set_on_current_span:
+        span = trace.get_current_span()
+        _set_association_properties_attributes(span, properties)
+
+
+def remove_association_properties(properties: dict) -> None:
+    props: dict = copy.copy(get_value("association_properties") or {})
+    for k in properties.keys():
+        props.pop(k, None)
+    set_association_properties(props)
+
+
+def _set_association_properties_attributes(span: Span, properties: dict) -> None:
+    for key, value in properties.items():
+        if key == TRACING_LEVEL:
+            span.set_attribute(f"lmnr.internal.{TRACING_LEVEL}", value)
+            continue
+        span.set_attribute(f"{ASSOCIATION_PROPERTIES}.{key}", value)

lmnr/opentelemetry_lib/tracing/exporter.py

@@ -0,0 +1,60 @@
+import grpc
+import re
+from opentelemetry.sdk.trace.export import SpanExporter, SpanExportResult
+from opentelemetry.sdk.trace import ReadableSpan
+from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import (
+    OTLPSpanExporter,
+)
+from opentelemetry.exporter.otlp.proto.http import Compression
+from opentelemetry.exporter.otlp.proto.http.trace_exporter import (
+    OTLPSpanExporter as HTTPOTLPSpanExporter,
+)
+from typing import Optional, Union
+
+from lmnr.sdk.utils import from_env
+
+
+class LaminarSpanExporter(SpanExporter):
+    instance: Union[OTLPSpanExporter, HTTPOTLPSpanExporter]
+
+    def __init__(
+        self,
+        base_url: Optional[str] = None,
+        port: Optional[int] = None,
+        api_key: Optional[str] = None,
+        timeout_seconds: int = 30,
+        force_http: bool = False,
+    ):
+        url = base_url or from_env("LMNR_BASE_URL") or "https://api.lmnr.ai"
+        url = url.rstrip("/")
+        if match := re.search(r":(\d{1,5})$", url):
+            url = url[: -len(match.group(0))]
+            if port is None:
+                port = int(match.group(1))
+        if port is None:
+            port = 443 if force_http else 8443
+        final_url = f"{url}:{port or 443}"
+        api_key = api_key or from_env("LMNR_PROJECT_API_KEY")
+        if force_http:
+            self.instance = HTTPOTLPSpanExporter(
+                endpoint=f"{final_url}/v1/traces",
+                headers={"Authorization": f"Bearer {api_key}"},
+                compression=Compression.Gzip,
+                timeout=timeout_seconds,
+            )
+        else:
+            self.instance = OTLPSpanExporter(
+                endpoint=final_url,
+                headers={"authorization": f"Bearer {api_key}"},
+                compression=grpc.Compression.Gzip,
+                timeout=timeout_seconds,
+            )
+
+    def export(self, spans: list[ReadableSpan]) -> SpanExportResult:
+        return self.instance.export(spans)
+
+    def shutdown(self) -> None:
+        return self.instance.shutdown()
+
+    def force_flush(self, timeout_millis: int = 30000) -> bool:
+        return self.instance.force_flush(timeout_millis)

lmnr/opentelemetry_lib/tracing/instruments.py

@@ -0,0 +1,121 @@
+import logging
+
+from enum import Enum
+from typing import Optional, Set, Dict
+
+from opentelemetry.trace import TracerProvider
+import lmnr.opentelemetry_lib.tracing._instrument_initializers as initializers
+from lmnr.sdk.client.synchronous.sync_client import LaminarClient
+from lmnr.sdk.client.asynchronous.async_client import AsyncLaminarClient
+
+module_logger = logging.getLogger(__name__)
+
+
+class Instruments(Enum):
+    # The list of libraries which will be autoinstrumented
+    # if no specific instruments are provided to initialize()
+    ALEPHALPHA = "alephalpha"
+    ANTHROPIC = "anthropic"
+    BEDROCK = "bedrock"
+    BROWSER_USE = "browser_use"
+    CHROMA = "chroma"
+    COHERE = "cohere"
+    CREWAI = "crewai"
+    GOOGLE_GENERATIVEAI = "google_generativeai"
+    GOOGLE_GENAI = "google_genai"
+    GROQ = "groq"
+    HAYSTACK = "haystack"
+    LANCEDB = "lancedb"
+    LANGCHAIN = "langchain"
+    LLAMA_INDEX = "llama_index"
+    MARQO = "marqo"
+    MCP = "mcp"
+    MILVUS = "milvus"
+    MISTRAL = "mistral"
+    OLLAMA = "ollama"
+    OPENAI = "openai"
+    PATCHRIGHT = "patchright"
+    PINECONE = "pinecone"
+    PLAYWRIGHT = "playwright"
+    QDRANT = "qdrant"
+    REPLICATE = "replicate"
+    SAGEMAKER = "sagemaker"
+    TOGETHER = "together"
+    TRANSFORMERS = "transformers"
+    VERTEXAI = "vertexai"
+    WATSONX = "watsonx"
+    WEAVIATE = "weaviate"
+
+
+INSTRUMENTATION_INITIALIZERS: Dict[
+    Instruments, initializers.InstrumentorInitializer
+] = {
+    Instruments.ALEPHALPHA: initializers.AlephAlphaInstrumentorInitializer(),
+    Instruments.ANTHROPIC: initializers.AnthropicInstrumentorInitializer(),
+    Instruments.BEDROCK: initializers.BedrockInstrumentorInitializer(),
+    Instruments.BROWSER_USE: initializers.BrowserUseInstrumentorInitializer(),
+    Instruments.CHROMA: initializers.ChromaInstrumentorInitializer(),
+    Instruments.COHERE: initializers.CohereInstrumentorInitializer(),
+    Instruments.CREWAI: initializers.CrewAIInstrumentorInitializer(),
+    Instruments.GOOGLE_GENERATIVEAI: initializers.GoogleGenerativeAIInstrumentorInitializer(),
+    Instruments.GOOGLE_GENAI: initializers.GoogleGenAIInstrumentorInitializer(),
+    Instruments.GROQ: initializers.GroqInstrumentorInitializer(),
+    Instruments.HAYSTACK: initializers.HaystackInstrumentorInitializer(),
+    Instruments.LANCEDB: initializers.LanceDBInstrumentorInitializer(),
+    Instruments.LANGCHAIN: initializers.LangchainInstrumentorInitializer(),
+    Instruments.LLAMA_INDEX: initializers.LlamaIndexInstrumentorInitializer(),
+    Instruments.MARQO: initializers.MarqoInstrumentorInitializer(),
+    Instruments.MCP: initializers.MCPInstrumentorInitializer(),
+    Instruments.MILVUS: initializers.MilvusInstrumentorInitializer(),
+    Instruments.MISTRAL: initializers.MistralInstrumentorInitializer(),
+    Instruments.OLLAMA: initializers.OllamaInstrumentorInitializer(),
+    Instruments.OPENAI: initializers.OpenAIInstrumentorInitializer(),
+    Instruments.PATCHRIGHT: initializers.PatchrightInstrumentorInitializer(),
+    Instruments.PINECONE: initializers.PineconeInstrumentorInitializer(),
+    Instruments.PLAYWRIGHT: initializers.PlaywrightInstrumentorInitializer(),
+    Instruments.QDRANT: initializers.QdrantInstrumentorInitializer(),
+    Instruments.REPLICATE: initializers.ReplicateInstrumentorInitializer(),
+    Instruments.SAGEMAKER: initializers.SageMakerInstrumentorInitializer(),
+    Instruments.TOGETHER: initializers.TogetherInstrumentorInitializer(),
+    Instruments.TRANSFORMERS: initializers.TransformersInstrumentorInitializer(),
+    Instruments.VERTEXAI: initializers.VertexAIInstrumentorInitializer(),
+    Instruments.WATSONX: initializers.WatsonxInstrumentorInitializer(),
+    Instruments.WEAVIATE: initializers.WeaviateInstrumentorInitializer(),
+}
+
+
+def init_instrumentations(
+    tracer_provider: TracerProvider,
+    instruments: Optional[Set[Instruments]] = None,
+    block_instruments: Optional[Set[Instruments]] = None,
+    client: Optional[LaminarClient] = None,
+    async_client: Optional[AsyncLaminarClient] = None,
+):
+    block_instruments = block_instruments or set()
+    if instruments is None:
+        instruments = set(Instruments)
+    if not isinstance(instruments, set):
+        instruments = set(instruments)
+
+    # Remove any instruments that were explicitly blocked
+    instruments = instruments - block_instruments
+
+    for instrument in instruments:
+        initializer = INSTRUMENTATION_INITIALIZERS.get(instrument)
+        if initializer is None:
+            module_logger.error(f"Invalid instrument: {instrument}")
+            continue
+
+        try:
+            instrumentor = initializer.init_instrumentor(client, async_client)
+            if instrumentor is None:
+                continue
+            if not instrumentor.is_instrumented_by_opentelemetry:
+                instrumentor.instrument(tracer_provider=tracer_provider)
+        except Exception as e:
+            if "No module named 'langchain_community'" in str(e):
+                # LangChain instrumentor does not require langchain_community,
+                # but throws this error if it's not installed.
+                continue
+            module_logger.error(f"Error initializing instrumentor: {e}")
+            continue