openlit 1.34.22__py3-none-any.whl → 1.34.24__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/pinecone/__init__.py

@@ -1,66 +1,174 @@
-# pylint: disable=useless-return, bad-staticmethod-argument, disable=duplicate-code
 """Initializer of Auto Instrumentation of Pinecone Functions"""
+
 from typing import Collection
 import importlib.metadata
 from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
 from wrapt import wrap_function_wrapper
 
 from openlit.instrumentation.pinecone.pinecone import general_wrap
+from openlit.instrumentation.pinecone.async_pinecone import async_general_wrap
 
-_instruments = ("pinecone-client >= 2.2.0",)
+_instruments = ("pinecone >= 7.3.0",)
 
 class PineconeInstrumentor(BaseInstrumentor):
-    """An instrumentor for Pinecone's client library."""
+    """
+    An instrumentor for Pinecone's 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("pinecone")
+        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("pinecone-client")
 
+        # Sync operations
         wrap_function_wrapper(
-            "pinecone.control.pinecone",  
+            "pinecone.pinecone",
             "Pinecone.create_index",
-            general_wrap("pinecone.create_index", version, environment, application_name,
-                 tracer, pricing_info, capture_message_content, metrics, disable_metrics),
+            general_wrap("pinecone.create_collection", version, environment, application_name,
+                tracer, pricing_info, capture_message_content, metrics, disable_metrics),
+        )
+
+        wrap_function_wrapper(
+            "pinecone.pinecone",
+            "Pinecone.create_index_for_model",
+            general_wrap("pinecone.create_collection", version, environment, application_name,
+                tracer, pricing_info, capture_message_content, metrics, disable_metrics),
         )
 
         wrap_function_wrapper(
-            "pinecone.data.index",  
+            "pinecone.db_data.index",
             "Index.upsert",
             general_wrap("pinecone.upsert", 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(
+            "pinecone.db_data.index",
+            "Index.upsert_records",
+            general_wrap("pinecone.upsert_records", version, environment, application_name,
+                tracer, pricing_info, capture_message_content, metrics, disable_metrics),
         )
 
         wrap_function_wrapper(
-            "pinecone.data.index",  
+            "pinecone.db_data.index",
             "Index.query",
             general_wrap("pinecone.query", 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(
+            "pinecone.db_data.index",
+            "Index.search",
+            general_wrap("pinecone.search", version, environment, application_name,
+                tracer, pricing_info, capture_message_content, metrics, disable_metrics),
         )
 
         wrap_function_wrapper(
-            "pinecone.data.index",  
+            "pinecone.db_data.index",
+            "Index.fetch",
+            general_wrap("pinecone.fetch", version, environment, application_name,
+                tracer, pricing_info, capture_message_content, metrics, disable_metrics),
+        )
+
+        wrap_function_wrapper(
+            "pinecone.db_data.index",
+            "Index.search_records",
+            general_wrap("pinecone.search_records", version, environment, application_name,
+                tracer, pricing_info, capture_message_content, metrics, disable_metrics),
+        )
+
+        wrap_function_wrapper(
+            "pinecone.db_data.index",
             "Index.update",
             general_wrap("pinecone.update", 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(
-            "pinecone.data.index",  
+            "pinecone.db_data.index",
             "Index.delete",
             general_wrap("pinecone.delete", version, environment, application_name,
-                 tracer, pricing_info, capture_message_content, metrics, disable_metrics),
+                tracer, pricing_info, capture_message_content, metrics, disable_metrics),
         )
 
+        # Async operations
+        wrap_function_wrapper(
+            "pinecone.pinecone_asyncio",
+            "PineconeAsyncio.create_index",
+            async_general_wrap("pinecone.create_index", version, environment, application_name,
+                tracer, pricing_info, capture_message_content, metrics, disable_metrics),
+        )
+
+        wrap_function_wrapper(
+            "pinecone.pinecone_asyncio",
+            "PineconeAsyncio.create_index_for_model",
+            async_general_wrap("pinecone.create_index", version, environment, application_name,
+                tracer, pricing_info, capture_message_content, metrics, disable_metrics),
+        )
+
+        wrap_function_wrapper(
+            "pinecone.db_data.index_asyncio",
+            "_IndexAsyncio.upsert",
+            async_general_wrap("pinecone.upsert", version, environment, application_name,
+                tracer, pricing_info, capture_message_content, metrics, disable_metrics),
+        )
+
+        wrap_function_wrapper(
+            "pinecone.db_data.index_asyncio",
+            "_IndexAsyncio.upsert_records",
+            async_general_wrap("pinecone.upsert_records", version, environment, application_name,
+                tracer, pricing_info, capture_message_content, metrics, disable_metrics),
+        )
+
+        wrap_function_wrapper(
+            "pinecone.db_data.index_asyncio",
+            "_IndexAsyncio.query",
+            async_general_wrap("pinecone.query", version, environment, application_name,
+                tracer, pricing_info, capture_message_content, metrics, disable_metrics),
+        )
+
+        wrap_function_wrapper(
+            "pinecone.db_data.index_asyncio",
+            "_IndexAsyncio.search",
+            async_general_wrap("pinecone.search", version, environment, application_name,
+                tracer, pricing_info, capture_message_content, metrics, disable_metrics),
+        )
+
+        wrap_function_wrapper(
+            "pinecone.db_data.index_asyncio",
+            "_IndexAsyncio.fetch",
+            async_general_wrap("pinecone.fetch", version, environment, application_name,
+                tracer, pricing_info, capture_message_content, metrics, disable_metrics),
+        )
+
+        wrap_function_wrapper(
+            "pinecone.db_data.index_asyncio",
+            "_IndexAsyncio.search_records",
+            async_general_wrap("pinecone.search_records", version, environment, application_name,
+                tracer, pricing_info, capture_message_content, metrics, disable_metrics),
+        )
+
+        wrap_function_wrapper(
+            "pinecone.db_data.index_asyncio",
+            "_IndexAsyncio.update",
+            async_general_wrap("pinecone.update", version, environment, application_name,
+                tracer, pricing_info, capture_message_content, metrics, disable_metrics),
+        )
+
+        wrap_function_wrapper(
+            "pinecone.db_data.index_asyncio",
+            "_IndexAsyncio.delete",
+            async_general_wrap("pinecone.delete", version, environment, application_name,
+                tracer, pricing_info, capture_message_content, metrics, disable_metrics),
+        )
 
-    @staticmethod
     def _uninstrument(self, **kwargs):
         pass

openlit/instrumentation/pinecone/async_pinecone.py

@@ -0,0 +1,59 @@
+"""
+Module for monitoring Pinecone async API calls.
+"""
+
+import time
+from opentelemetry.trace import SpanKind
+from opentelemetry import context as context_api
+from openlit.__helpers import (
+    handle_exception,
+    set_server_address_and_port,
+)
+from openlit.instrumentation.pinecone.utils import (
+    process_vectordb_response,
+    DB_OPERATION_MAP,
+)
+
+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 Pinecone async function calls.
+    """
+
+    async def wrapper(wrapped, instance, args, kwargs):
+        """
+        Wraps the Pinecone async function call.
+        """
+
+        if context_api.get_value(context_api._SUPPRESS_INSTRUMENTATION_KEY):
+            return await wrapped(*args, **kwargs)
+
+        # Get server address and port using the standard helper
+        server_address, server_port = set_server_address_and_port(instance, "pinecone.io", 443)
+
+        db_operation = DB_OPERATION_MAP.get(gen_ai_endpoint, "unknown")
+        if db_operation == "create_collection":
+            namespace = kwargs.get("name") or (args[0] if args else "unknown")
+        else:
+            namespace = kwargs.get("namespace") or (args[0] if args else "unknown")
+        span_name = f"{db_operation} {namespace}"
+
+        with tracer.start_as_current_span(span_name, kind=SpanKind.CLIENT) as span:
+            try:
+                start_time = time.time()
+                response = await wrapped(*args, **kwargs)
+
+                # Process response and generate telemetry
+                response = process_vectordb_response(
+                    response, db_operation, server_address, server_port,
+                    environment, application_name, metrics, start_time, span,
+                    capture_message_content, disable_metrics, version, instance, args, **kwargs
+                )
+
+                return response
+
+            except Exception as e:
+                handle_exception(span, e)
+                raise
+
+    return wrapper