openlit 1.34.20__py3-none-any.whl → 1.34.23__py3-none-any.whl

openlit/instrumentation/langchain_community/__init__.py

@@ -0,0 +1,74 @@
+"""Initializer of Auto Instrumentation of LangChain Community Functions"""
+from typing import Collection
+import importlib.metadata
+from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
+from wrapt import wrap_function_wrapper
+
+from openlit.instrumentation.langchain_community.langchain_community import (
+    general_wrap,
+)
+from openlit.instrumentation.langchain_community.async_langchain_community import (
+    async_general_wrap,
+)
+
+_instruments = ("langchain-community >= 0.2.0",)
+
+WRAPPED_METHODS = [
+    {
+        "package": "langchain_community.document_loaders.base",
+        "object": "BaseLoader.load",
+        "endpoint": "langchain_community.retrieve.load",
+        "wrapper": general_wrap,
+    },
+    {
+        "package": "langchain_community.document_loaders.base",
+        "object": "BaseLoader.aload",
+        "endpoint": "langchain_community.retrieve.load",
+        "wrapper": async_general_wrap,
+    },
+    {
+        "package": "langchain_text_splitters.base",
+        "object": "TextSplitter.split_documents",
+        "endpoint": "langchain_community.retrieve.split_documents",
+        "wrapper": general_wrap,
+    },
+    {
+        "package": "langchain_text_splitters.base",
+        "object": "TextSplitter.create_documents",
+        "endpoint": "langchain_community.retrieve.create_documents",
+        "wrapper": general_wrap,
+    },
+]
+
+class LangChainCommunityInstrumentor(BaseInstrumentor):
+    """
+    An instrumentor for LangChain Community client library.
+    """
+
+    def instrumentation_dependencies(self) -> Collection[str]:
+        return _instruments
+
+    def _instrument(self, **kwargs):
+        version = importlib.metadata.version("langchain-community")
+        environment = kwargs.get("environment", "default")
+        application_name = kwargs.get("application_name", "default")
+        tracer = kwargs.get("tracer")
+        pricing_info = kwargs.get("pricing_info", {})
+        capture_message_content = kwargs.get("capture_message_content", False)
+        metrics = kwargs.get("metrics_dict")
+        disable_metrics = kwargs.get("disable_metrics")
+
+        for wrapped_method in WRAPPED_METHODS:
+            wrap_package = wrapped_method.get("package")
+            wrap_object = wrapped_method.get("object")
+            gen_ai_endpoint = wrapped_method.get("endpoint")
+            wrapper = wrapped_method.get("wrapper")
+            wrap_function_wrapper(
+                wrap_package,
+                wrap_object,
+                wrapper(gen_ai_endpoint, version, environment, application_name,
+                       tracer, pricing_info, capture_message_content, metrics, disable_metrics),
+            )
+
+    def _uninstrument(self, **kwargs):
+        pass

openlit/instrumentation/langchain_community/async_langchain_community.py

@@ -0,0 +1,49 @@
+"""
+Module for monitoring async LangChain Community operations.
+"""
+
+import logging
+from opentelemetry import trace
+from opentelemetry.trace import Status, StatusCode
+
+from openlit.__helpers import handle_exception
+from openlit.instrumentation.langchain_community.utils import process_general_response
+
+# Initialize logger for LangChain Community instrumentation
+logger = logging.getLogger(__name__)
+
+def async_general_wrap(gen_ai_endpoint, version, environment, application_name, tracer, pricing_info,
+    capture_message_content, metrics, disable_metrics):
+    """
+    Generates a telemetry wrapper for GenAI operations.
+    """
+
+    async def wrapper(wrapped, instance, args, kwargs):
+        """
+        Wraps the GenAI operation call.
+        """
+
+        # Prepare server address and port
+        server_address = "127.0.0.1"
+        server_port = "80"
+
+        # Get the parent span from the tracer
+        with tracer.start_as_current_span(gen_ai_endpoint, kind=trace.SpanKind.CLIENT) as span:
+            try:
+                # Call the original async function
+                response = await wrapped(*args, **kwargs)
+
+                # Process the response using the utility function
+                response = process_general_response(
+                    response, gen_ai_endpoint, server_port, server_address,
+                    environment, application_name, span, version
+                )
+
+                span.set_status(Status(StatusCode.OK))
+
+            except Exception as e:
+                handle_exception(span, e)
+
+            return response
+
+    return wrapper

openlit/instrumentation/langchain_community/langchain_community.py

@@ -0,0 +1,49 @@
+"""
+Module for monitoring LangChain Community operations.
+"""
+
+import logging
+from opentelemetry import trace
+from opentelemetry.trace import Status, StatusCode
+
+from openlit.__helpers import handle_exception
+from openlit.instrumentation.langchain_community.utils import process_general_response
+
+# Initialize logger for LangChain Community instrumentation
+logger = logging.getLogger(__name__)
+
+def general_wrap(gen_ai_endpoint, version, environment, application_name, tracer, pricing_info,
+    capture_message_content, metrics, disable_metrics):
+    """
+    Generates a telemetry wrapper for GenAI operations.
+    """
+
+    def wrapper(wrapped, instance, args, kwargs):
+        """
+        Wraps the GenAI operation call.
+        """
+
+        # Prepare server address and port
+        server_address = "127.0.0.1"
+        server_port = "80"
+
+        # Get the parent span from the tracer
+        with tracer.start_as_current_span(gen_ai_endpoint, kind=trace.SpanKind.CLIENT) as span:
+            try:
+                # Call the original function
+                response = wrapped(*args, **kwargs)
+
+                # Process the response using the utility function
+                response = process_general_response(
+                    response, gen_ai_endpoint, server_port, server_address,
+                    environment, application_name, span, version
+                )
+
+                span.set_status(Status(StatusCode.OK))
+
+            except Exception as e:
+                handle_exception(span, e)
+
+            return response
+
+    return wrapper

openlit/instrumentation/langchain_community/utils.py

@@ -0,0 +1,69 @@
+"""
+Utility functions for LangChain Community instrumentation.
+"""
+
+from opentelemetry.trace import Status, StatusCode
+from openlit.semcov import SemanticConvention
+
+def process_general_response(response, gen_ai_endpoint, server_port, server_address,
+                            environment, application_name, span, version="1.0.0"):
+    """
+    Process general LangChain Community operations (document loading, text splitting) and generate telemetry.
+    
+    Args:
+        response: The response object from the LangChain Community operation
+        gen_ai_endpoint: The endpoint identifier for the operation
+        server_port: Server port (empty for community operations)
+        server_address: Server address (empty for community operations)
+        environment: Environment name
+        application_name: Application name
+        span: OpenTelemetry span
+        version: Version string
+    
+    Returns:
+        The original response object
+    """
+
+    # Set span attributes for general operations
+    span.set_attribute(SemanticConvention.GEN_AI_SYSTEM, SemanticConvention.GEN_AI_SYSTEM_LANGCHAIN)
+    span.set_attribute(SemanticConvention.GEN_AI_ENDPOINT, gen_ai_endpoint)
+    span.set_attribute(SemanticConvention.GEN_AI_OPERATION, SemanticConvention.GEN_AI_OPERATION_TYPE_FRAMEWORK)
+    span.set_attribute(SemanticConvention.GEN_AI_SDK_VERSION, version)
+    span.set_attribute(SemanticConvention.GEN_AI_ENVIRONMENT, environment)
+    span.set_attribute(SemanticConvention.GEN_AI_APPLICATION_NAME, application_name)
+
+    # Try to extract source information for document loading operations
+    if gen_ai_endpoint and "retrieve.load" in gen_ai_endpoint:
+        try:
+            if hasattr(response, "__iter__") and len(response) > 0:
+                # For document loaders, try to get source from first document
+                first_doc = response[0]
+                if hasattr(first_doc, "metadata") and isinstance(first_doc.metadata, dict):
+                    source = first_doc.metadata.get("source", "unknown")
+                    span.set_attribute(SemanticConvention.GEN_AI_RETRIEVAL_SOURCE, source)
+
+                # Count number of documents loaded
+                span.set_attribute("gen_ai.retrieval.documents.count", len(response))
+        except (AttributeError, KeyError, IndexError, TypeError):
+            # If we cant extract metadata, just continue without it
+            pass
+
+    # For text splitting operations
+    elif gen_ai_endpoint and ("split_documents" in gen_ai_endpoint or "create_documents" in gen_ai_endpoint):
+        try:
+            if hasattr(response, "__iter__") and len(response) > 0:
+                # Count number of text chunks created
+                span.set_attribute("gen_ai.text_splitter.chunks.count", len(response))
+
+                # Try to get average chunk size
+                total_chars = sum(len(doc.page_content) for doc in response if hasattr(doc, "page_content"))
+                if total_chars > 0:
+                    avg_chunk_size = total_chars // len(response)
+                    span.set_attribute("gen_ai.text_splitter.avg_chunk_size", avg_chunk_size)
+        except (AttributeError, TypeError):
+            # If we cant extract chunk information, just continue without it
+            pass
+
+    span.set_status(Status(StatusCode.OK))
+
+    return response

openlit/instrumentation/openai/__init__.py

@@ -1,147 +1,142 @@
-# pylint: disable=useless-return, bad-staticmethod-argument, disable=duplicate-code
 """Initializer of Auto Instrumentation of OpenAI Functions"""
 from typing import Collection
 import importlib.metadata
 from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
 from wrapt import wrap_function_wrapper
 
-from openlit.instrumentation.openai.openai import chat_completions, embedding, responses, chat_completions_parse
-from openlit.instrumentation.openai.openai import image_generate, image_variatons, audio_create
-from openlit.instrumentation.openai.async_openai import (async_chat_completions, async_embedding,
-                                                         async_chat_completions_parse)
-from openlit.instrumentation.openai.async_openai import async_image_generate, async_image_variatons
-from openlit.instrumentation.openai.async_openai import async_audio_create, async_responses
+from openlit.instrumentation.openai.openai import (
+    chat_completions, embedding, responses, chat_completions_parse,
+    image_generate, image_variatons, audio_create
+)
+from openlit.instrumentation.openai.async_openai import (
+    async_chat_completions, async_embedding, async_chat_completions_parse,
+    async_image_generate, async_image_variations, async_audio_create, async_responses
+)
 
 _instruments = ("openai >= 1.92.0",)
 
 class OpenAIInstrumentor(BaseInstrumentor):
-    """An instrumentor for OpenAI's client library."""
+    """
+    An instrumentor for OpenAI client library.
+    """
 
     def instrumentation_dependencies(self) -> Collection[str]:
         return _instruments
 
     def _instrument(self, **kwargs):
-        application_name = kwargs.get("application_name")
-        environment = kwargs.get("environment")
+        version = importlib.metadata.version("openai")
+        environment = kwargs.get("environment", "default")
+        application_name = kwargs.get("application_name", "default")
         tracer = kwargs.get("tracer")
+        pricing_info = kwargs.get("pricing_info", {})
+        capture_message_content = kwargs.get("capture_message_content", False)
         metrics = kwargs.get("metrics_dict")
-        pricing_info = kwargs.get("pricing_info")
-        capture_message_content = kwargs.get("capture_message_content")
         disable_metrics = kwargs.get("disable_metrics")
-        version = importlib.metadata.version("openai")
 
+        # chat completions
         wrap_function_wrapper(
             "openai.resources.chat.completions",  
             "Completions.create",  
             chat_completions(version, environment, application_name,
-                         tracer, pricing_info, capture_message_content,
-                         metrics, disable_metrics),
+                tracer, pricing_info, capture_message_content, metrics, disable_metrics),
         )
 
         wrap_function_wrapper(
             "openai.resources.chat.completions",  
             "AsyncCompletions.create",  
             async_chat_completions(version, environment, application_name,
-                               tracer, pricing_info, capture_message_content,
-                               metrics, disable_metrics),
+                tracer, pricing_info, capture_message_content, metrics, disable_metrics),
         )
 
+        # chat completions parse
         wrap_function_wrapper(
-            "openai.resources.responses.responses",  
-            "Responses.create",  
-            responses(version, environment, application_name,
-                         tracer, pricing_info, capture_message_content,
-                         metrics, disable_metrics),
+            "openai.resources.chat.completions",
+            "Completions.parse",
+            chat_completions_parse(version, environment, application_name,
+                tracer, pricing_info, capture_message_content, metrics, disable_metrics),
         )
 
         wrap_function_wrapper(
-            "openai.resources.responses.responses",  
-            "AsyncResponses.create",  
-            async_responses(version, environment, application_name,
-                         tracer, pricing_info, capture_message_content,
-                         metrics, disable_metrics),
+            "openai.resources.chat.completions",
+            "AsyncCompletions.parse",
+            async_chat_completions_parse(version, environment, application_name,
+                tracer, pricing_info, capture_message_content, metrics, disable_metrics),
         )
 
+        # responses
         wrap_function_wrapper(
-            "openai.resources.images",  
-            "Images.generate",  
-            image_generate(version, environment, application_name,
-                                   tracer, pricing_info, capture_message_content,
-                                   metrics, disable_metrics),
+            "openai.resources.responses.responses",  
+            "Responses.create",  
+            responses(version, environment, application_name,
+                tracer, pricing_info, capture_message_content, metrics, disable_metrics),
         )
 
         wrap_function_wrapper(
-            "openai.resources.images",  
-            "AsyncImages.generate",  
-            async_image_generate(version, environment, application_name,
-                                         tracer, pricing_info, capture_message_content,
-                                         metrics, disable_metrics),
+            "openai.resources.responses.responses",  
+            "AsyncResponses.create",  
+            async_responses(version, environment, application_name,
+                tracer, pricing_info, capture_message_content, metrics, disable_metrics),
         )
 
+        # embeddings
         wrap_function_wrapper(
             "openai.resources.embeddings",  
             "Embeddings.create",  
             embedding(version, environment, application_name,
-                              tracer, pricing_info, capture_message_content,
-                              metrics, disable_metrics),
+                tracer, pricing_info, capture_message_content, metrics, disable_metrics),
         )
 
         wrap_function_wrapper(
             "openai.resources.embeddings",  
             "AsyncEmbeddings.create",  
             async_embedding(version, environment, application_name,
-                                    tracer, pricing_info, capture_message_content,
-                                    metrics, disable_metrics),
+                tracer, pricing_info, capture_message_content, metrics, disable_metrics),
+        )
+
+        # image generation
+        wrap_function_wrapper(
+            "openai.resources.images",  
+            "Images.generate",  
+            image_generate(version, environment, application_name,
+                tracer, pricing_info, capture_message_content, metrics, disable_metrics),
         )
 
+        wrap_function_wrapper(
+            "openai.resources.images",  
+            "AsyncImages.generate",  
+            async_image_generate(version, environment, application_name,
+                tracer, pricing_info, capture_message_content, metrics, disable_metrics),
+        )
+
+        # image variations
         wrap_function_wrapper(
             "openai.resources.images",  
             "Images.create_variation",  
-            image_variatons(version,
-                            environment, application_name,
-                            tracer, pricing_info, capture_message_content,
-                            metrics, disable_metrics),
+            image_variatons(version, environment, application_name,
+                tracer, pricing_info, capture_message_content, metrics, disable_metrics),
         )
 
         wrap_function_wrapper(
             "openai.resources.images",  
             "AsyncImages.create_variation",  
-            async_image_variatons(version,
-                                  environment, application_name,
-                                  tracer, pricing_info, capture_message_content,
-                                  metrics, disable_metrics),
+            async_image_variations(version, environment, application_name,
+                tracer, pricing_info, capture_message_content, metrics, disable_metrics),
         )
 
+        # audio generation
         wrap_function_wrapper(
             "openai.resources.audio.speech",  
             "Speech.create",  
             audio_create(version, environment, application_name,
-                         tracer, pricing_info, capture_message_content,
-                         metrics, disable_metrics),
+                tracer, pricing_info, capture_message_content, metrics, disable_metrics),
         )
 
         wrap_function_wrapper(
             "openai.resources.audio.speech",  
             "AsyncSpeech.create",  
             async_audio_create(version, environment, application_name,
-                               tracer, pricing_info, capture_message_content,
-                               metrics, disable_metrics),
-        )
-
-        wrap_function_wrapper(
-            "openai.resources.chat.completions",
-            "Completions.parse",
-            chat_completions_parse(version, environment, application_name, tracer, pricing_info,
-                                   capture_message_content, metrics, disable_metrics),
-        )
-
-        wrap_function_wrapper(
-            "openai.resources.chat.completions",
-            "AsyncCompletions.parse",
-            async_chat_completions_parse(version, environment, application_name, tracer, pricing_info,
-                                         capture_message_content, metrics, disable_metrics),
+                tracer, pricing_info, capture_message_content, metrics, disable_metrics),
         )
 
-    @staticmethod
     def _uninstrument(self, **kwargs):
         pass