openlit 1.34.30__py3-none-any.whl → 1.34.31__py3-none-any.whl

openlit/instrumentation/langchain_community/__init__.py

@@ -1,4 +1,5 @@
 """Initializer of Auto Instrumentation of LangChain Community Functions"""
+
 from typing import Collection
 import importlib.metadata
 from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
@@ -40,6 +41,7 @@ WRAPPED_METHODS = [
     },
 ]
 
+
 class LangChainCommunityInstrumentor(BaseInstrumentor):
     """
     An instrumentor for LangChain Community client library.
@@ -66,8 +68,17 @@ class LangChainCommunityInstrumentor(BaseInstrumentor):
             wrap_function_wrapper(
                 wrap_package,
                 wrap_object,
-                wrapper(gen_ai_endpoint, version, environment, application_name,
-                       tracer, pricing_info, capture_message_content, metrics, disable_metrics),
+                wrapper(
+                    gen_ai_endpoint,
+                    version,
+                    environment,
+                    application_name,
+                    tracer,
+                    pricing_info,
+                    capture_message_content,
+                    metrics,
+                    disable_metrics,
+                ),
             )
 
     def _uninstrument(self, **kwargs):

openlit/instrumentation/langchain_community/async_langchain_community.py

@@ -12,8 +12,18 @@ from openlit.instrumentation.langchain_community.utils import process_general_re
 # 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):
+
+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.
     """
@@ -28,15 +38,23 @@ def async_general_wrap(gen_ai_endpoint, version, environment, application_name,
         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:
+        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
+                    response,
+                    gen_ai_endpoint,
+                    server_port,
+                    server_address,
+                    environment,
+                    application_name,
+                    span,
+                    version,
                 )
 
                 span.set_status(Status(StatusCode.OK))

openlit/instrumentation/langchain_community/langchain_community.py

@@ -12,8 +12,18 @@ from openlit.instrumentation.langchain_community.utils import process_general_re
 # 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):
+
+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.
     """
@@ -28,15 +38,23 @@ def general_wrap(gen_ai_endpoint, version, environment, application_name, tracer
         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:
+        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
+                    response,
+                    gen_ai_endpoint,
+                    server_port,
+                    server_address,
+                    environment,
+                    application_name,
+                    span,
+                    version,
                 )
 
                 span.set_status(Status(StatusCode.OK))

openlit/instrumentation/langchain_community/utils.py

@@ -5,8 +5,17 @@ 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"):
+
+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.
 
@@ -25,9 +34,14 @@ def process_general_response(response, gen_ai_endpoint, server_port, server_addr
     """
 
     # Set span attributes for general operations
-    span.set_attribute(SemanticConvention.GEN_AI_SYSTEM, SemanticConvention.GEN_AI_SYSTEM_LANGCHAIN)
+    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_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)
@@ -38,9 +52,13 @@ def process_general_response(response, gen_ai_endpoint, server_port, server_addr
             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):
+                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)
+                    span.set_attribute(
+                        SemanticConvention.GEN_AI_RETRIEVAL_SOURCE, source
+                    )
 
                 # Count number of documents loaded
                 span.set_attribute("gen_ai.retrieval.documents.count", len(response))
@@ -49,17 +67,25 @@ def process_general_response(response, gen_ai_endpoint, server_port, server_addr
             pass
 
     # For text splitting operations
-    elif gen_ai_endpoint and ("split_documents" in gen_ai_endpoint or "create_documents" in gen_ai_endpoint):
+    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"))
+                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)
+                    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

openlit/instrumentation/letta/__init__.py

@@ -6,12 +6,11 @@ import importlib.metadata
 from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
 from wrapt import wrap_function_wrapper
 
-from openlit.instrumentation.letta.letta import (
-    create_agent, send_message
-)
+from openlit.instrumentation.letta.letta import create_agent, send_message
 
 _instruments = ("letta >= 0.6.2",)
 
+
 class LettaInstrumentor(BaseInstrumentor):
     """
     An instrumentor for Letta's client library.
@@ -33,43 +32,97 @@ class LettaInstrumentor(BaseInstrumentor):
         wrap_function_wrapper(
             "letta.client.client",
             "LocalClient.create_agent",
-            create_agent("letta.create_agent", version, environment, application_name,
-                  tracer, pricing_info, capture_message_content, metrics, disable_metrics),
+            create_agent(
+                "letta.create_agent",
+                version,
+                environment,
+                application_name,
+                tracer,
+                pricing_info,
+                capture_message_content,
+                metrics,
+                disable_metrics,
+            ),
         )
 
         wrap_function_wrapper(
             "letta.client.client",
             "LocalClient.get_agent",
-            create_agent("letta.get_agent", version, environment, application_name,
-                  tracer, pricing_info, capture_message_content, metrics, disable_metrics),
+            create_agent(
+                "letta.get_agent",
+                version,
+                environment,
+                application_name,
+                tracer,
+                pricing_info,
+                capture_message_content,
+                metrics,
+                disable_metrics,
+            ),
         )
 
         wrap_function_wrapper(
             "letta.client.client",
             "LocalClient.send_message",
-            send_message("letta.send_message", version, environment, application_name,
-                  tracer, pricing_info, capture_message_content, metrics, disable_metrics),
+            send_message(
+                "letta.send_message",
+                version,
+                environment,
+                application_name,
+                tracer,
+                pricing_info,
+                capture_message_content,
+                metrics,
+                disable_metrics,
+            ),
         )
 
         wrap_function_wrapper(
             "letta.client.client",
             "RESTClient.create_agent",
-            create_agent("letta.create_agent", version, environment, application_name,
-                  tracer, pricing_info, capture_message_content, metrics, disable_metrics),
+            create_agent(
+                "letta.create_agent",
+                version,
+                environment,
+                application_name,
+                tracer,
+                pricing_info,
+                capture_message_content,
+                metrics,
+                disable_metrics,
+            ),
         )
 
         wrap_function_wrapper(
             "letta.client.client",
             "RESTClient.get_agent",
-            create_agent("letta.get_agent", version, environment, application_name,
-                  tracer, pricing_info, capture_message_content, metrics, disable_metrics),
+            create_agent(
+                "letta.get_agent",
+                version,
+                environment,
+                application_name,
+                tracer,
+                pricing_info,
+                capture_message_content,
+                metrics,
+                disable_metrics,
+            ),
         )
 
         wrap_function_wrapper(
             "letta.client.client",
             "RESTClient.send_message",
-            send_message("letta.send_message", version, environment, application_name,
-                  tracer, pricing_info, capture_message_content, metrics, disable_metrics),
+            send_message(
+                "letta.send_message",
+                version,
+                environment,
+                application_name,
+                tracer,
+                pricing_info,
+                capture_message_content,
+                metrics,
+                disable_metrics,
+            ),
         )
 
     def _uninstrument(self, **kwargs):

openlit/instrumentation/letta/letta.py

@@ -5,17 +5,29 @@ Module for monitoring Letta calls.
 
 import logging
 from opentelemetry.trace import SpanKind, Status, StatusCode
-from opentelemetry.sdk.resources import SERVICE_NAME, TELEMETRY_SDK_NAME, DEPLOYMENT_ENVIRONMENT
-from openlit.__helpers import (
-    handle_exception, get_chat_model_cost
+from opentelemetry.sdk.resources import (
+    SERVICE_NAME,
+    TELEMETRY_SDK_NAME,
+    DEPLOYMENT_ENVIRONMENT,
 )
+from openlit.__helpers import handle_exception, get_chat_model_cost
 from openlit.semcov import SemanticConvention
 
 # Initialize logger for logging potential issues and operations
 logger = logging.getLogger(__name__)
 
-def create_agent(gen_ai_endpoint, version, environment, application_name,
-                     tracer, pricing_info, capture_message_content, metrics, disable_metrics):
+
+def create_agent(
+    gen_ai_endpoint,
+    version,
+    environment,
+    application_name,
+    tracer,
+    pricing_info,
+    capture_message_content,
+    metrics,
+    disable_metrics,
+):
     """
     Generates a telemetry wrapper for chat completions to collect metrics.
 
@@ -50,34 +62,39 @@ def create_agent(gen_ai_endpoint, version, environment, application_name,
         """
 
         # pylint: disable=line-too-long
-        with tracer.start_as_current_span(gen_ai_endpoint, kind= SpanKind.CLIENT) as span:
+        with tracer.start_as_current_span(
+            gen_ai_endpoint, kind=SpanKind.CLIENT
+        ) as span:
             response = wrapped(*args, **kwargs)
 
             try:
                 # Set base span attribues
                 span.set_attribute(TELEMETRY_SDK_NAME, "openlit")
-                span.set_attribute(SemanticConvention.GEN_AI_SYSTEM,
-                                    SemanticConvention.GEN_AI_SYSTEM_LETTA)
-                span.set_attribute(SemanticConvention.GEN_AI_OPERATION,
-                                    SemanticConvention.GEN_AI_OPERATION_TYPE_AGENT)
-                span.set_attribute(SemanticConvention.GEN_AI_ENDPOINT,
-                                    gen_ai_endpoint)
-                span.set_attribute(SERVICE_NAME,
-                                    application_name)
-                span.set_attribute(DEPLOYMENT_ENVIRONMENT,
-                                    environment)
-                span.set_attribute(SemanticConvention.GEN_AI_AGENT_ID,
-                                    response.id)
-                span.set_attribute(SemanticConvention.GEN_AI_AGENT_ROLE,
-                                    response.name)
-                span.set_attribute(SemanticConvention.GEN_AI_AGENT_INSTRUCTIONS,
-                                    response.system)
-                span.set_attribute(SemanticConvention.GEN_AI_REQUEST_MODEL,
-                                    response.llm_config.model)
-                span.set_attribute(SemanticConvention.GEN_AI_AGENT_TYPE,
-                                    response.agent_type)
-                span.set_attribute(SemanticConvention.GEN_AI_AGENT_TOOLS,
-                                    response.tool_names)
+                span.set_attribute(
+                    SemanticConvention.GEN_AI_SYSTEM,
+                    SemanticConvention.GEN_AI_SYSTEM_LETTA,
+                )
+                span.set_attribute(
+                    SemanticConvention.GEN_AI_OPERATION,
+                    SemanticConvention.GEN_AI_OPERATION_TYPE_AGENT,
+                )
+                span.set_attribute(SemanticConvention.GEN_AI_ENDPOINT, gen_ai_endpoint)
+                span.set_attribute(SERVICE_NAME, application_name)
+                span.set_attribute(DEPLOYMENT_ENVIRONMENT, environment)
+                span.set_attribute(SemanticConvention.GEN_AI_AGENT_ID, response.id)
+                span.set_attribute(SemanticConvention.GEN_AI_AGENT_ROLE, response.name)
+                span.set_attribute(
+                    SemanticConvention.GEN_AI_AGENT_INSTRUCTIONS, response.system
+                )
+                span.set_attribute(
+                    SemanticConvention.GEN_AI_REQUEST_MODEL, response.llm_config.model
+                )
+                span.set_attribute(
+                    SemanticConvention.GEN_AI_AGENT_TYPE, response.agent_type
+                )
+                span.set_attribute(
+                    SemanticConvention.GEN_AI_AGENT_TOOLS, response.tool_names
+                )
 
                 span.set_status(Status(StatusCode.OK))
 
@@ -93,8 +110,18 @@ def create_agent(gen_ai_endpoint, version, environment, application_name,
 
     return wrapper
 
-def send_message(gen_ai_endpoint, version, environment, application_name,
-                     tracer, pricing_info, capture_message_content, metrics, disable_metrics):
+
+def send_message(
+    gen_ai_endpoint,
+    version,
+    environment,
+    application_name,
+    tracer,
+    pricing_info,
+    capture_message_content,
+    metrics,
+    disable_metrics,
+):
     """
     Generates a telemetry wrapper for chat completions to collect metrics.
 
@@ -129,47 +156,65 @@ def send_message(gen_ai_endpoint, version, environment, application_name,
         """
 
         # pylint: disable=line-too-long
-        with tracer.start_as_current_span(gen_ai_endpoint, kind= SpanKind.CLIENT) as span:
+        with tracer.start_as_current_span(
+            gen_ai_endpoint, kind=SpanKind.CLIENT
+        ) as span:
             response = wrapped(*args, **kwargs)
 
             try:
                 # Calculate cost of the operation
-                cost = get_chat_model_cost(kwargs.get("model", "gpt-4o"),
-                                            pricing_info, response.usage.prompt_tokens,
-                                            response.usage.completion_tokens)
+                cost = get_chat_model_cost(
+                    kwargs.get("model", "gpt-4o"),
+                    pricing_info,
+                    response.usage.prompt_tokens,
+                    response.usage.completion_tokens,
+                )
                 # Set base span attribues
                 span.set_attribute(TELEMETRY_SDK_NAME, "openlit")
-                span.set_attribute(SemanticConvention.GEN_AI_SYSTEM,
-                                    SemanticConvention.GEN_AI_SYSTEM_LETTA)
-                span.set_attribute(SemanticConvention.GEN_AI_OPERATION,
-                                    SemanticConvention.GEN_AI_OPERATION_TYPE_AGENT)
-                span.set_attribute(SemanticConvention.GEN_AI_ENDPOINT,
-                                    gen_ai_endpoint)
-                span.set_attribute(SERVICE_NAME,
-                                    application_name)
-                span.set_attribute(SemanticConvention.GEN_AI_AGENT_STEP_COUNT,
-                                    response.usage.step_count)
-                span.set_attribute(SemanticConvention.GEN_AI_USAGE_INPUT_TOKENS,
-                                    response.usage.prompt_tokens)
-                span.set_attribute(SemanticConvention.GEN_AI_USAGE_OUTPUT_TOKENS,
-                                    response.usage.completion_tokens)
-                span.set_attribute(SemanticConvention.GEN_AI_USAGE_TOTAL_TOKENS,
-                                    response.usage.total_tokens)
-                span.set_attribute(SemanticConvention.GEN_AI_USAGE_COST,
-                                    cost)
+                span.set_attribute(
+                    SemanticConvention.GEN_AI_SYSTEM,
+                    SemanticConvention.GEN_AI_SYSTEM_LETTA,
+                )
+                span.set_attribute(
+                    SemanticConvention.GEN_AI_OPERATION,
+                    SemanticConvention.GEN_AI_OPERATION_TYPE_AGENT,
+                )
+                span.set_attribute(SemanticConvention.GEN_AI_ENDPOINT, gen_ai_endpoint)
+                span.set_attribute(SERVICE_NAME, application_name)
+                span.set_attribute(
+                    SemanticConvention.GEN_AI_AGENT_STEP_COUNT,
+                    response.usage.step_count,
+                )
+                span.set_attribute(
+                    SemanticConvention.GEN_AI_USAGE_INPUT_TOKENS,
+                    response.usage.prompt_tokens,
+                )
+                span.set_attribute(
+                    SemanticConvention.GEN_AI_USAGE_OUTPUT_TOKENS,
+                    response.usage.completion_tokens,
+                )
+                span.set_attribute(
+                    SemanticConvention.GEN_AI_USAGE_TOTAL_TOKENS,
+                    response.usage.total_tokens,
+                )
+                span.set_attribute(SemanticConvention.GEN_AI_USAGE_COST, cost)
 
                 if capture_message_content:
                     span.add_event(
                         name=SemanticConvention.GEN_AI_CONTENT_PROMPT_EVENT,
                         attributes={
-                            SemanticConvention.GEN_AI_CONTENT_PROMPT: kwargs.get("message", ""),
+                            SemanticConvention.GEN_AI_CONTENT_PROMPT: kwargs.get(
+                                "message", ""
+                            ),
                         },
                     )
                     span.add_event(
                         name=SemanticConvention.GEN_AI_CONTENT_COMPLETION_EVENT,
                         # pylint: disable=line-too-long
                         attributes={
-                            SemanticConvention.GEN_AI_CONTENT_COMPLETION: str(response.messages),
+                            SemanticConvention.GEN_AI_CONTENT_COMPLETION: str(
+                                response.messages
+                            ),
                         },
                     )
 

openlit/instrumentation/litellm/__init__.py

@@ -5,15 +5,12 @@ import importlib.metadata
 from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
 from wrapt import wrap_function_wrapper
 
-from openlit.instrumentation.litellm.litellm import (
-    completion, embedding
-)
-from openlit.instrumentation.litellm.async_litellm import (
-   acompletion, aembedding
-)
+from openlit.instrumentation.litellm.litellm import completion, embedding
+from openlit.instrumentation.litellm.async_litellm import acompletion, aembedding
 
 _instruments = ("litellm >= 1.52.6",)
 
+
 class LiteLLMInstrumentor(BaseInstrumentor):
     """
     An instrumentor for LiteLLM client library.
@@ -36,32 +33,64 @@ class LiteLLMInstrumentor(BaseInstrumentor):
         wrap_function_wrapper(
             "litellm",
             "completion",
-            completion(version, environment, application_name,
-                  tracer, pricing_info, capture_message_content, metrics, disable_metrics),
+            completion(
+                version,
+                environment,
+                application_name,
+                tracer,
+                pricing_info,
+                capture_message_content,
+                metrics,
+                disable_metrics,
+            ),
         )
 
         # Async chat completions
         wrap_function_wrapper(
             "litellm",
             "acompletion",
-            acompletion(version, environment, application_name,
-                  tracer, pricing_info, capture_message_content, metrics, disable_metrics),
+            acompletion(
+                version,
+                environment,
+                application_name,
+                tracer,
+                pricing_info,
+                capture_message_content,
+                metrics,
+                disable_metrics,
+            ),
         )
 
         # Embeddings
         wrap_function_wrapper(
             "litellm",
             "embedding",
-            embedding(version, environment, application_name,
-                  tracer, pricing_info, capture_message_content, metrics, disable_metrics),
+            embedding(
+                version,
+                environment,
+                application_name,
+                tracer,
+                pricing_info,
+                capture_message_content,
+                metrics,
+                disable_metrics,
+            ),
         )
 
         # Async embeddings
         wrap_function_wrapper(
             "litellm",
             "aembedding",
-            aembedding(version, environment, application_name,
-                  tracer, pricing_info, capture_message_content, metrics, disable_metrics),
+            aembedding(
+                version,
+                environment,
+                application_name,
+                tracer,
+                pricing_info,
+                capture_message_content,
+                metrics,
+                disable_metrics,
+            ),
         )
 
     def _uninstrument(self, **kwargs):