Same agent Smaller bill. The tools and infrastructure to get more work from your AI. Fewer tokens. Less compute. Lower cost.
TypeScript agent-harnessagent-harness-engineeringai-engineeringai-observabilityamd-gpuclaude-codeclickhousecodexcoding-agentcoding-agentscursorgenaigpu-monitoringllm-observabilityllmopsnvidia-smiobservabilityopen-sourceopenaiopentelemetry
[Feat]: Refactor Langchain OpenTelemetry Monitoring Instrumentation (#792)
Patcherd3491ecf6c38
diff --git a/sdk/python/pyproject.toml b/sdk/python/pyproject.tomlindex abcfbaef..2df00ada 100644--- a/sdk/python/pyproject.toml+++ b/sdk/python/pyproject.toml@@ -1,6 +1,6 @@[tool.poetry]name = "openlit"-version = "1.34.22"+version = "1.34.23"description = "OpenTelemetry-native Auto instrumentation library for monitoring LLM Applications and GPUs, facilitating the integration of observability into your GenAI-driven projects"authors = ["OpenLIT"]license = "Apache-2.0"diff --git a/sdk/python/src/openlit/__init__.py b/sdk/python/src/openlit/__init__.pyindex 2301f2dd..7c88870a 100644--- a/sdk/python/src/openlit/__init__.py+++ b/sdk/python/src/openlit/__init__.py@@ -42,6 +42,7 @@ from openlit.instrumentation.premai import PremAIInstrumentorfrom openlit.instrumentation.assemblyai import AssemblyAIInstrumentorfrom openlit.instrumentation.azure_ai_inference import AzureAIInferenceInstrumentorfrom openlit.instrumentation.langchain import LangChainInstrumentor+from openlit.instrumentation.langchain_community import LangChainCommunityInstrumentorfrom openlit.instrumentation.llamaindex import LlamaIndexInstrumentorfrom openlit.instrumentation.haystack import HaystackInstrumentorfrom openlit.instrumentation.embedchain import EmbedChainInstrumentor@@ -267,6 +268,7 @@ def init("google-ai-studio": "google.genai","azure-ai-inference": "azure.ai.inference","langchain": "langchain",+ "langchain_community": "langchain_community","llama_index": "llama_index","haystack": "haystack","embedchain": "embedchain",@@ -387,6 +389,7 @@ def init("google-ai-studio": GoogleAIStudioInstrumentor(),"azure-ai-inference": AzureAIInferenceInstrumentor(),"langchain": LangChainInstrumentor(),+ "langchain_community": LangChainCommunityInstrumentor(),"llama_index": LlamaIndexInstrumentor(),"haystack": HaystackInstrumentor(),"embedchain": EmbedChainInstrumentor(),diff --git a/sdk/python/src/openlit/instrumentation/langchain/__init__.py b/sdk/python/src/openlit/instrumentation/langchain/__init__.pyindex 9674f071..a136adbd 100644--- a/sdk/python/src/openlit/instrumentation/langchain/__init__.py+++ b/sdk/python/src/openlit/instrumentation/langchain/__init__.py@@ -1,4 +1,3 @@-# pylint: disable=useless-return, bad-staticmethod-argument, disable=duplicate-code"""Initializer of Auto Instrumentation of LangChain Functions"""from typing import Collectionimport importlib.metadata@@ -6,41 +5,17 @@ from opentelemetry.instrumentation.instrumentor import BaseInstrumentorfrom wrapt import wrap_function_wrapperfrom openlit.instrumentation.langchain.langchain import (- general_wrap,hub,chat)from openlit.instrumentation.langchain.async_langchain import (+ async_hub,async_chat)_instruments = ("langchain >= 0.1.20",)WRAPPED_METHODS = [- {- "package": "langchain_community.document_loaders.base",- "object": "BaseLoader.load",- "endpoint": "langchain.retrieve.load",- "wrapper": general_wrap,- },- {- "package": "langchain_community.document_loaders.base",- "object": "BaseLoader.aload",- "endpoint": "langchain.retrieve.load",- "wrapper": general_wrap,- },- {- "package": "langchain_text_splitters.base",- "object": "TextSplitter.split_documents",- "endpoint": "langchain.retrieve.split_documents",- "wrapper": general_wrap,- },- {- "package": "langchain_text_splitters.base",- "object": "TextSplitter.create_documents",- "endpoint": "langchain.retrieve.create_documents",- "wrapper": general_wrap,- },{"package": "langchain.hub","object": "pull",@@ -79,27 +54,29 @@ WRAPPED_METHODS = [},{"package": "langchain.chains.base",- "object": "Chain.invoke",+ "object": "Chain.ainvoke","endpoint": "langchain.chain.invoke","wrapper": async_chat,}]class LangChainInstrumentor(BaseInstrumentor):- """An instrumentor for Cohere's client library."""+ """+ An instrumentor for LangChain client library.+ """def instrumentation_dependencies(self) -> Collection[str]:return _instrumentsdef _instrument(self, **kwargs):- application_name = kwargs.get("application_name")- environment = kwargs.get("environment")+ version = importlib.metadata.version("langchain")+ 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")+ 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")- version = importlib.metadata.version("langchain")for wrapped_method in WRAPPED_METHODS:wrap_package = wrapped_method.get("package")@@ -110,9 +87,8 @@ class LangChainInstrumentor(BaseInstrumentor):wrap_package,wrap_object,wrapper(gen_ai_endpoint, version, environment, application_name,- tracer, pricing_info, capture_message_content, metrics, disable_metrics),+ tracer, pricing_info, capture_message_content, metrics, disable_metrics),)- @staticmethoddef _uninstrument(self, **kwargs):passdiff --git a/sdk/python/src/openlit/instrumentation/langchain/async_langchain.py b/sdk/python/src/openlit/instrumentation/langchain/async_langchain.pyindex 1803d510..45ef71f3 100644--- a/sdk/python/src/openlit/instrumentation/langchain/async_langchain.py+++ b/sdk/python/src/openlit/instrumentation/langchain/async_langchain.py@@ -1,245 +1,68 @@-# pylint: disable=duplicate-code, broad-exception-caught, too-many-statements, unused-argument, unused-import, too-many-function-args"""-Module for monitoring Langchain applications.+Module for monitoring LangChain API calls."""-import loggingimport time-from opentelemetry.trace import SpanKind, Status, StatusCode-from opentelemetry.sdk.resources import SERVICE_NAME, TELEMETRY_SDK_NAME, DEPLOYMENT_ENVIRONMENT+from opentelemetry.trace import SpanKindfrom openlit.__helpers import (- get_chat_model_cost,handle_exception,- general_tokens,- calculate_ttft,- calculate_tbt,- create_metrics_attributes,+ set_server_address_and_port+)+from openlit.instrumentation.langchain.utils import (+ get_model_from_instance,+ process_chat_response,+ process_hub_response,)from openlit.semcov import SemanticConvention-# Initialize logger for logging potential issues and operations-logger = logging.getLogger(__name__)--def get_attribute_from_instance_or_kwargs(instance, attribute_name, default=-1):- """Return attribute from instance or kwargs"""- # Attempt to retrieve model_kwargs from the instance- model_kwargs = getattr(instance, 'model_kwargs', None)-- # Check for attribute in model_kwargs if it exists- if model_kwargs and attribute_name in model_kwargs:- return model_kwargs[attribute_name]-- # Attempt to get the attribute directly from the instance- try:- return getattr(instance, attribute_name)- except AttributeError:- # Special handling for 'model' attribute to consider 'model_id'- if attribute_name == 'model':- return getattr(instance, 'model_id', 'default_model_id')-- # Default if the attribute isn't found in model_kwargs or the instance- return default--def async_general_wrap(gen_ai_endpoint, version, environment, application_name,- tracer, pricing_info, capture_message_content, metrics, disable_metrics):- """- Creates a wrapper around a function call to trace and log its execution metrics.-- This function wraps any given function to measure its execution time,- log its operation, and trace its execution using OpenTelemetry.-- Parameters:- - gen_ai_endpoint (str): A descriptor or name for the endpoint being traced.- - version (str): The version of the Langchain application.- - environment (str): The deployment environment (e.g., 'production', 'development').- - application_name (str): Name of the Langchain application.- - tracer (opentelemetry.trace.Tracer): The tracer object used for OpenTelemetry tracing.- - pricing_info (dict): Information about the pricing for internal metrics (currently not used).- - capture_message_content (bool): Flag indicating whether to trace the content of the response.-- Returns:- - function: A higher-order function that takes a function 'wrapped' and returns- a new function that wraps 'wrapped' with additional tracing and logging.- """-- async def wrapper(wrapped, instance, args, kwargs):- """- An inner wrapper function that executes the wrapped function, measures execution- time, and records trace data using OpenTelemetry.-- Parameters:- - wrapped (Callable): The original function that this wrapper will execute.- - instance (object): The instance to which the wrapped function belongs. This- is used for instance methods. For static and classmethods,- this may be None.- - args (tuple): Positional arguments passed to the wrapped function.- - kwargs (dict): Keyword arguments passed to the wrapped function.-- Returns:- - The result of the wrapped function call.-- The wrapper initiates a span with the provided tracer, sets various attributes- on the span based on the function's execution and response, and ensures- errors are handled and logged appropriately.- """- with tracer.start_as_current_span(gen_ai_endpoint, kind= SpanKind.CLIENT) as span:- response = await wrapped(*args, **kwargs)-- try:- span.set_attribute(TELEMETRY_SDK_NAME, "openlit")- 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(DEPLOYMENT_ENVIRONMENT,- environment)- span.set_attribute(SemanticConvention.GEN_AI_OPERATION,- SemanticConvention.GEN_AI_OPERATION_TYPE_FRAMEWORK)- span.set_attribute(SERVICE_NAME,- application_name)- span.set_attribute(SemanticConvention.GEN_AI_RETRIEVAL_SOURCE,- response[0].metadata["source"])- span.set_status(Status(StatusCode.OK))-- # Return original response- return response-- except Exception as e:- handle_exception(span, e)- logger.error("Error in trace creation: %s", e)-- # Return original response- return response-- return wrapper-def async_hub(gen_ai_endpoint, version, environment, application_name, tracer,- pricing_info, capture_message_content, metrics, disable_metrics):+ pricing_info, capture_message_content, metrics, disable_metrics):"""- Creates a wrapper around Langchain hub operations for tracing and logging.-- Similar to `general_wrap`, this function focuses on wrapping functions involved- in interacting with the Langchain hub, adding specific metadata relevant to- hub operations to the span attributes.-- Parameters:- - gen_ai_endpoint (str): A descriptor or name for the Langchain hub endpoint.- - version (str): The version of the Langchain application.- - environment (str): The deployment environment, such as 'production' or 'development'.- - application_name (str): Name of the Langchain application.- - tracer (opentelemetry.trace.Tracer): The tracer for OpenTelemetry tracing.- - pricing_info (dict): Pricing information for the operation (not currently used).- - capture_message_content (bool): Indicates if the content of the response should be traced.-- Returns:- - function: A new function that wraps the original hub operation call with added- logging, tracing, and metric calculation functionalities.+ Generates a telemetry wrapper for LangChain async hub operations."""async def wrapper(wrapped, instance, args, kwargs):"""- An inner wrapper specifically designed for Langchain hub operations,- providing tracing, logging, and execution metrics.-- Parameters:- - wrapped (Callable): The original hub operation function to be executed.- - instance (object): The instance of the class where the hub operation- method is defined. May be None for static or class methods.- - args (tuple): Positional arguments to pass to the hub operation function.- - kwargs (dict): Keyword arguments to pass to the hub operation function.-- Returns:- - The result of executing the hub operation function.-- This wrapper captures additional metadata relevant to Langchain hub operations,- creating spans with specific attributes and metrics that reflect the nature of- each hub call.+ Wraps the LangChain async hub operation call."""- with tracer.start_as_current_span(gen_ai_endpoint, kind= SpanKind.CLIENT) as span:+ server_address, server_port = set_server_address_and_port(instance, "langchain.com", 443)++ with tracer.start_as_current_span(gen_ai_endpoint, kind=SpanKind.CLIENT) as span:response = await wrapped(*args, **kwargs)try:- span.set_attribute(TELEMETRY_SDK_NAME, "openlit")- 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(DEPLOYMENT_ENVIRONMENT,- environment)- span.set_attribute(SemanticConvention.GEN_AI_OPERATION,- SemanticConvention.GEN_AI_OPERATION_TYPE_FRAMEWORK)- span.set_attribute(SERVICE_NAME,- application_name)- span.set_attribute(SemanticConvention.GEN_AI_HUB_OWNER,- response.metadata["lc_hub_owner"])- span.set_attribute(SemanticConvention.GEN_AI_HUB_REPO,- response.metadata["lc_hub_repo"])- span.set_status(Status(StatusCode.OK))-- return response+ response = process_hub_response(+ response=response,+ gen_ai_endpoint=gen_ai_endpoint,+ server_port=server_port,+ server_address=server_address,+ environment=environment,+ application_name=application_name,+ span=span,+ version=version+ )except Exception as e:handle_exception(span, e)- logger.error("Error in trace creation: %s", e)- # Return original response- return response+ return responsereturn wrapperdef async_chat(gen_ai_endpoint, version, environment, application_name,- tracer, pricing_info, capture_message_content, metrics, disable_metrics):+ tracer, pricing_info, capture_message_content, metrics, disable_metrics):"""- Creates a wrapper around a function call to trace and log its execution metrics.-- This function wraps any given function to measure its execution time,- log its operation, and trace its execution using OpenTelemetry.-- Parameters:- - version (str): The version of the Langchain application.- - environment (str): The deployment environment (e.g., 'production', 'development').- - application_name (str): Name of the Langchain application.- - tracer (opentelemetry.trace.Tracer): The tracer object used for OpenTelemetry tracing.- - pricing_info (dict): Information about the pricing for internal metrics (currently not used).- - capture_message_content (bool): Flag indicating whether to trace the content of the response.-- Returns:- - function: A higher-order function that takes a function 'wrapped' and returns- a new function that wraps 'wrapped' with additional tracing and logging.+ Generates a telemetry wrapper for LangChain async chat operations."""async def wrapper(wrapped, instance, args, kwargs):"""- An inner wrapper function that executes the wrapped function, measures execution- time, and records trace data using OpenTelemetry.-- Parameters:- - wrapped (Callable): The original function that this wrapper will execute.- - instance (object): The instance to which the wrapped function belongs. This- is used for instance methods. For static and classmethods,- this may be None.- - args (tuple): Positional arguments passed to the wrapped function.- - kwargs (dict): Keyword arguments passed to the wrapped function.-- Returns:- - The result of the wrapped function call.-- The wrapper initiates a span with the provided tracer, sets various attributes- on the span based on the function's execution and response, and ensures- errors are handled and logged appropriately.+ Wraps the LangChain async chat operation call."""- server_address, server_port = "NOT_FOUND", "NOT_FOUND"-- if hasattr(instance, "model_id"):- request_model = instance.model_id- elif hasattr(instance, "model"):- request_model = instance.model- elif hasattr(instance, "model_name"):- request_model = instance.model_name- else:- request_model = "NOT_FOUND"+ server_address, server_port = set_server_address_and_port(instance, "langchain.com", 443)+ request_model = get_model_from_instance(instance)span_name = f"{SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT} {request_model}"@@ -249,140 +72,31 @@ def async_chat(gen_ai_endpoint, version, environment, application_name,end_time = time.time()try:- # Format 'messages' into a single string- message_prompt = kwargs.get("messages", "") or args[0]- formatted_messages = []-- for message in message_prompt:- # Handle the case where message is a tuple- if isinstance(message, tuple) and len(message) == 2:- role, content = message- # Handle the case where message is a dictionary- elif isinstance(message, dict):- role = message["role"]- content = message["content"]- else:- continue-- # Check if the content is a list- if isinstance(content, list):- content_str = ", ".join(- f'{item["type"]}: {item["text"] if "text" in item else item["image_url"]}'- if "type" in item else f'text: {item["text"]}'- for item in content- )- formatted_messages.append(f"{role}: {content_str}")- else:- formatted_messages.append(f"{role}: {content}")-- # Join all formatted messages with newline- prompt = "\n".join(formatted_messages)-- input_tokens = general_tokens(str(prompt))- output_tokens = general_tokens(str(response))-- # Calculate cost of the operation- cost = get_chat_model_cost(- request_model,- pricing_info, input_tokens, output_tokens+ # Add instance to kwargs for processing+ kwargs["instance"] = instance++ response = process_chat_response(+ response=response,+ request_model=request_model,+ pricing_info=pricing_info,+ server_port=server_port,+ server_address=server_address,+ environment=environment,+ application_name=application_name,+ metrics=metrics,+ start_time=start_time,+ end_time=end_time,+ span=span,+ capture_message_content=capture_message_content,+ disable_metrics=disable_metrics,+ version=version,+ args=args,+ **kwargs)- try:- llm_response = response.content- except AttributeError:- llm_response = response-- # Set base span attribues (OTel Semconv)- span.set_attribute(TELEMETRY_SDK_NAME, "openlit")- span.set_attribute(SemanticConvention.GEN_AI_OPERATION,- SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT)- span.set_attribute(SemanticConvention.GEN_AI_SYSTEM,- SemanticConvention.GEN_AI_SYSTEM_LANGCHAIN)- span.set_attribute(SemanticConvention.GEN_AI_REQUEST_MODEL,- request_model)- span.set_attribute(SemanticConvention.GEN_AI_RESPONSE_MODEL,- request_model)- span.set_attribute(SemanticConvention.GEN_AI_REQUEST_TEMPERATURE,- str(getattr(instance, 'temperature', 1)))- span.set_attribute(SemanticConvention.GEN_AI_REQUEST_TOP_K,- str(getattr(instance, 'top_k', 1)))- span.set_attribute(SemanticConvention.GEN_AI_REQUEST_TOP_P,- str(getattr(instance, 'top_p', 1)))- span.set_attribute(SemanticConvention.GEN_AI_USAGE_INPUT_TOKENS,- input_tokens)- span.set_attribute(SemanticConvention.GEN_AI_USAGE_OUTPUT_TOKENS,- output_tokens)- span.set_attribute(SemanticConvention.SERVER_ADDRESS,- server_address)- span.set_attribute(SemanticConvention.SERVER_PORT,- server_port)-- # Set base span attribues (Extras)- span.set_attribute(DEPLOYMENT_ENVIRONMENT,- environment)- span.set_attribute(SERVICE_NAME,- application_name)- span.set_attribute(SemanticConvention.GEN_AI_REQUEST_IS_STREAM,- False)- span.set_attribute(SemanticConvention.GEN_AI_USAGE_TOTAL_TOKENS,- input_tokens + output_tokens)- span.set_attribute(SemanticConvention.GEN_AI_USAGE_COST,- cost)- span.set_attribute(SemanticConvention.GEN_AI_SERVER_TTFT,- end_time - start_time)- span.set_attribute(SemanticConvention.GEN_AI_SDK_VERSION,- version)-- if capture_message_content:- span.add_event(- name=SemanticConvention.GEN_AI_CONTENT_PROMPT_EVENT,- attributes={- SemanticConvention.GEN_AI_CONTENT_PROMPT: prompt,- },- )- span.add_event(- name=SemanticConvention.GEN_AI_CONTENT_COMPLETION_EVENT,- attributes={- SemanticConvention.GEN_AI_CONTENT_COMPLETION: llm_response,- },- )-- span.set_status(Status(StatusCode.OK))-- if disable_metrics is False:- attributes = create_metrics_attributes(- service_name=application_name,- deployment_environment=environment,- operation=SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT,- system=SemanticConvention.GEN_AI_SYSTEM_LANGCHAIN,- request_model=request_model,- server_address=server_address,- server_port=server_port,- response_model=request_model,- )-- metrics["genai_client_usage_tokens"].record(- input_tokens + output_tokens, attributes- )- metrics["genai_client_operation_duration"].record(- end_time - start_time, attributes- )- metrics["genai_server_ttft"].record(- end_time - start_time, attributes- )- metrics["genai_requests"].add(1, attributes)- metrics["genai_completion_tokens"].add(output_tokens, attributes)- metrics["genai_prompt_tokens"].add(input_tokens, attributes)- metrics["genai_cost"].record(cost, attributes)-- # Return original response- return response-except Exception as e:handle_exception(span, e)- logger.error("Error in trace creation: %s", e)- # Return original response- return response+ return responsereturn wrapperdiff --git a/sdk/python/src/openlit/instrumentation/langchain/langchain.py b/sdk/python/src/openlit/instrumentation/langchain/langchain.pyindex a1333f32..80b137ab 100644--- a/sdk/python/src/openlit/instrumentation/langchain/langchain.py+++ b/sdk/python/src/openlit/instrumentation/langchain/langchain.py@@ -1,246 +1,68 @@-# pylint: disable=duplicate-code, broad-exception-caught, too-many-statements, unused-argument, unused-import, too-many-function-args"""-Module for monitoring Langchain applications.+Module for monitoring LangChain API calls."""-import loggingimport time-from opentelemetry.trace import SpanKind, Status, StatusCode-from opentelemetry.sdk.resources import SERVICE_NAME, TELEMETRY_SDK_NAME, DEPLOYMENT_ENVIRONMENT+from opentelemetry.trace import SpanKindfrom openlit.__helpers import (- get_chat_model_cost,handle_exception,- general_tokens,- calculate_ttft,- calculate_tbt,- create_metrics_attributes,- extract_and_format_input,+ set_server_address_and_port+)+from openlit.instrumentation.langchain.utils import (+ get_model_from_instance,+ process_chat_response,+ process_hub_response,)from openlit.semcov import SemanticConvention-# Initialize logger for logging potential issues and operations-logger = logging.getLogger(__name__)--def get_attribute_from_instance_or_kwargs(instance, attribute_name, default=-1):- """Return attribute from instance or kwargs"""- # Attempt to retrieve model_kwargs from the instance- model_kwargs = getattr(instance, 'model_kwargs', None)-- # Check for attribute in model_kwargs if it exists- if model_kwargs and attribute_name in model_kwargs:- return model_kwargs[attribute_name]-- # Attempt to get the attribute directly from the instance- try:- return getattr(instance, attribute_name)- except AttributeError:- # Special handling for 'model' attribute to consider 'model_id'- if attribute_name == 'model':- return getattr(instance, 'model_id', 'default_model_id')-- # Default if the attribute isn't found in model_kwargs or the instance- return default--def general_wrap(gen_ai_endpoint, version, environment, application_name,- tracer, pricing_info, capture_message_content, metrics, disable_metrics):- """- Creates a wrapper around a function call to trace and log its execution metrics.-- This function wraps any given function to measure its execution time,- log its operation, and trace its execution using OpenTelemetry.-- Parameters:- - gen_ai_endpoint (str): A descriptor or name for the endpoint being traced.- - version (str): The version of the Langchain application.- - environment (str): The deployment environment (e.g., 'production', 'development').- - application_name (str): Name of the Langchain application.- - tracer (opentelemetry.trace.Tracer): The tracer object used for OpenTelemetry tracing.- - pricing_info (dict): Information about the pricing for internal metrics (currently not used).- - capture_message_content (bool): Flag indicating whether to trace the content of the response.-- Returns:- - function: A higher-order function that takes a function 'wrapped' and returns- a new function that wraps 'wrapped' with additional tracing and logging.- """-- def wrapper(wrapped, instance, args, kwargs):- """- An inner wrapper function that executes the wrapped function, measures execution- time, and records trace data using OpenTelemetry.-- Parameters:- - wrapped (Callable): The original function that this wrapper will execute.- - instance (object): The instance to which the wrapped function belongs. This- is used for instance methods. For static and classmethods,- this may be None.- - args (tuple): Positional arguments passed to the wrapped function.- - kwargs (dict): Keyword arguments passed to the wrapped function.-- Returns:- - The result of the wrapped function call.-- The wrapper initiates a span with the provided tracer, sets various attributes- on the span based on the function's execution and response, and ensures- errors are handled and logged appropriately.- """- with tracer.start_as_current_span(gen_ai_endpoint, kind= SpanKind.CLIENT) as span:- response = wrapped(*args, **kwargs)-- try:- span.set_attribute(TELEMETRY_SDK_NAME, "openlit")- 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(DEPLOYMENT_ENVIRONMENT,- environment)- span.set_attribute(SemanticConvention.GEN_AI_OPERATION,- SemanticConvention.GEN_AI_OPERATION_TYPE_FRAMEWORK)- span.set_attribute(SERVICE_NAME,- application_name)- span.set_attribute(SemanticConvention.GEN_AI_RETRIEVAL_SOURCE,- response[0].metadata["source"])- span.set_status(Status(StatusCode.OK))-- # Return original response- return response-- except Exception as e:- handle_exception(span, e)- logger.error("Error in trace creation: %s", e)-- # Return original response- return response-- return wrapper-def hub(gen_ai_endpoint, version, environment, application_name, tracer,pricing_info, capture_message_content, metrics, disable_metrics):"""- Creates a wrapper around Langchain hub operations for tracing and logging.-- Similar to `general_wrap`, this function focuses on wrapping functions involved- in interacting with the Langchain hub, adding specific metadata relevant to- hub operations to the span attributes.-- Parameters:- - gen_ai_endpoint (str): A descriptor or name for the Langchain hub endpoint.- - version (str): The version of the Langchain application.- - environment (str): The deployment environment, such as 'production' or 'development'.- - application_name (str): Name of the Langchain application.- - tracer (opentelemetry.trace.Tracer): The tracer for OpenTelemetry tracing.- - pricing_info (dict): Pricing information for the operation (not currently used).- - capture_message_content (bool): Indicates if the content of the response should be traced.-- Returns:- - function: A new function that wraps the original hub operation call with added- logging, tracing, and metric calculation functionalities.+ Generates a telemetry wrapper for LangChain hub operations."""def wrapper(wrapped, instance, args, kwargs):"""- An inner wrapper specifically designed for Langchain hub operations,- providing tracing, logging, and execution metrics.-- Parameters:- - wrapped (Callable): The original hub operation function to be executed.- - instance (object): The instance of the class where the hub operation- method is defined. May be None for static or class methods.- - args (tuple): Positional arguments to pass to the hub operation function.- - kwargs (dict): Keyword arguments to pass to the hub operation function.-- Returns:- - The result of executing the hub operation function.-- This wrapper captures additional metadata relevant to Langchain hub operations,- creating spans with specific attributes and metrics that reflect the nature of- each hub call.+ Wraps the LangChain hub operation call."""- with tracer.start_as_current_span(gen_ai_endpoint, kind= SpanKind.CLIENT) as span:+ server_address, server_port = set_server_address_and_port(instance, "langchain.com", 443)++ with tracer.start_as_current_span(gen_ai_endpoint, kind=SpanKind.CLIENT) as span:response = wrapped(*args, **kwargs)try:- span.set_attribute(TELEMETRY_SDK_NAME, "openlit")- 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(DEPLOYMENT_ENVIRONMENT,- environment)- span.set_attribute(SemanticConvention.GEN_AI_OPERATION,- SemanticConvention.GEN_AI_OPERATION_TYPE_FRAMEWORK)- span.set_attribute(SERVICE_NAME,- application_name)- span.set_attribute(SemanticConvention.GEN_AI_HUB_OWNER,- response.metadata["lc_hub_owner"])- span.set_attribute(SemanticConvention.GEN_AI_HUB_REPO,- response.metadata["lc_hub_repo"])- span.set_status(Status(StatusCode.OK))-- return response+ response = process_hub_response(+ response=response,+ gen_ai_endpoint=gen_ai_endpoint,+ server_port=server_port,+ server_address=server_address,+ environment=environment,+ application_name=application_name,+ span=span,+ version=version+ )except Exception as e:handle_exception(span, e)- logger.error("Error in trace creation: %s", e)- # Return original response- return response+ return responsereturn wrapperdef chat(gen_ai_endpoint, version, environment, application_name,- tracer, pricing_info, capture_message_content, metrics, disable_metrics):+ tracer, pricing_info, capture_message_content, metrics, disable_metrics):"""- Creates a wrapper around a function call to trace and log its execution metrics.-- This function wraps any given function to measure its execution time,- log its operation, and trace its execution using OpenTelemetry.-- Parameters:- - version (str): The version of the Langchain application.- - environment (str): The deployment environment (e.g., 'production', 'development').- - application_name (str): Name of the Langchain application.- - tracer (opentelemetry.trace.Tracer): The tracer object used for OpenTelemetry tracing.- - pricing_info (dict): Information about the pricing for internal metrics (currently not used).- - capture_message_content (bool): Flag indicating whether to trace the content of the response.-- Returns:- - function: A higher-order function that takes a function 'wrapped' and returns- a new function that wraps 'wrapped' with additional tracing and logging.+ Generates a telemetry wrapper for GenAI operations."""def wrapper(wrapped, instance, args, kwargs):"""- An inner wrapper function that executes the wrapped function, measures execution- time, and records trace data using OpenTelemetry.-- Parameters:- - wrapped (Callable): The original function that this wrapper will execute.- - instance (object): The instance to which the wrapped function belongs. This- is used for instance methods. For static and classmethods,- this may be None.- - args (tuple): Positional arguments passed to the wrapped function.- - kwargs (dict): Keyword arguments passed to the wrapped function.-- Returns:- - The result of the wrapped function call.-- The wrapper initiates a span with the provided tracer, sets various attributes- on the span based on the function's execution and response, and ensures- errors are handled and logged appropriately.+ Wraps the GenAI operation call."""- server_address, server_port = "NOT_FOUND", "NOT_FOUND"-- if hasattr(instance, "model_id"):- request_model = instance.model_id- elif hasattr(instance, "model"):- request_model = instance.model- elif hasattr(instance, "model_name"):- request_model = instance.model_name- else:- request_model = "NOT_FOUND"+ server_address, server_port = set_server_address_and_port(instance, "langchain.com", 443)+ request_model = get_model_from_instance(instance)span_name = f"{SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT} {request_model}"@@ -250,113 +72,31 @@ def chat(gen_ai_endpoint, version, environment, application_name,end_time = time.time()try:- prompt = str(kwargs.get('messages', '') or args[0])-- input_tokens = general_tokens(str(prompt))- output_tokens = general_tokens(str(response))-- # Calculate cost of the operation- cost = get_chat_model_cost(- request_model,- pricing_info, input_tokens, output_tokens+ # Add instance to kwargs for processing+ kwargs["instance"] = instance++ response = process_chat_response(+ response=response,+ request_model=request_model,+ pricing_info=pricing_info,+ server_port=server_port,+ server_address=server_address,+ environment=environment,+ application_name=application_name,+ metrics=metrics,+ start_time=start_time,+ end_time=end_time,+ span=span,+ capture_message_content=capture_message_content,+ disable_metrics=disable_metrics,+ version=version,+ args=args,+ **kwargs)- try:- llm_response = response.content- except AttributeError:- llm_response = response-- # Set base span attribues (OTel Semconv)- span.set_attribute(TELEMETRY_SDK_NAME, "openlit")- span.set_attribute(SemanticConvention.GEN_AI_OPERATION,- SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT)- span.set_attribute(SemanticConvention.GEN_AI_SYSTEM,- SemanticConvention.GEN_AI_SYSTEM_LANGCHAIN)- span.set_attribute(SemanticConvention.GEN_AI_REQUEST_MODEL,- request_model)- span.set_attribute(SemanticConvention.GEN_AI_RESPONSE_MODEL,- request_model)- span.set_attribute(SemanticConvention.GEN_AI_REQUEST_TEMPERATURE,- str(getattr(instance, 'temperature', 1)))- span.set_attribute(SemanticConvention.GEN_AI_REQUEST_TOP_K,- str(getattr(instance, 'top_k', 1)))- span.set_attribute(SemanticConvention.GEN_AI_REQUEST_TOP_P,- str(getattr(instance, 'top_p', 1)))- span.set_attribute(SemanticConvention.GEN_AI_USAGE_INPUT_TOKENS,- input_tokens)- span.set_attribute(SemanticConvention.GEN_AI_USAGE_OUTPUT_TOKENS,- output_tokens)- span.set_attribute(SemanticConvention.SERVER_ADDRESS,- server_address)- span.set_attribute(SemanticConvention.SERVER_PORT,- server_port)-- # Set base span attribues (Extras)- span.set_attribute(DEPLOYMENT_ENVIRONMENT,- environment)- span.set_attribute(SERVICE_NAME,- application_name)- span.set_attribute(SemanticConvention.GEN_AI_REQUEST_IS_STREAM,- False)- span.set_attribute(SemanticConvention.GEN_AI_USAGE_TOTAL_TOKENS,- input_tokens + output_tokens)- span.set_attribute(SemanticConvention.GEN_AI_USAGE_COST,- cost)- span.set_attribute(SemanticConvention.GEN_AI_SERVER_TTFT,- end_time - start_time)- span.set_attribute(SemanticConvention.GEN_AI_SDK_VERSION,- version)-- if capture_message_content:- span.add_event(- name=SemanticConvention.GEN_AI_CONTENT_PROMPT_EVENT,- attributes={- SemanticConvention.GEN_AI_CONTENT_PROMPT: prompt,- },- )- span.add_event(- name=SemanticConvention.GEN_AI_CONTENT_COMPLETION_EVENT,- attributes={- SemanticConvention.GEN_AI_CONTENT_COMPLETION: llm_response,- },- )-- span.set_status(Status(StatusCode.OK))-- if disable_metrics is False:- attributes = create_metrics_attributes(- service_name=application_name,- deployment_environment=environment,- operation=SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT,- system=SemanticConvention.GEN_AI_SYSTEM_LANGCHAIN,- request_model=request_model,- server_address=server_address,- server_port=server_port,- response_model=request_model,- )-- metrics["genai_client_usage_tokens"].record(- input_tokens + output_tokens, attributes- )- metrics["genai_client_operation_duration"].record(- end_time - start_time, attributes- )- metrics["genai_server_ttft"].record(- end_time - start_time, attributes- )- metrics["genai_requests"].add(1, attributes)- metrics["genai_completion_tokens"].add(output_tokens, attributes)- metrics["genai_prompt_tokens"].add(input_tokens, attributes)- metrics["genai_cost"].record(cost, attributes)-- # Return original response- return response-except Exception as e:handle_exception(span, e)- logger.error("Error in trace creation: %s", e)- # Return original response- return response+ return responsereturn wrapperdiff --git a/sdk/python/src/openlit/instrumentation/langchain/utils.py b/sdk/python/src/openlit/instrumentation/langchain/utils.pynew file mode 100644index 00000000..d206caa2--- /dev/null+++ b/sdk/python/src/openlit/instrumentation/langchain/utils.py@@ -0,0 +1,252 @@+"""+LangChain OpenTelemetry instrumentation utility functions+"""+import time++from opentelemetry.trace import Status, StatusCode++from openlit.__helpers import (+ get_chat_model_cost,+ general_tokens,+ record_completion_metrics,+ common_span_attributes,+)+from openlit.semcov import SemanticConvention++def format_content(messages):+ """+ Format the messages into a string for span events.+ """++ if not messages:+ return ""++ # Handle string input (simple case)+ if isinstance(messages, str):+ return messages++ # Handle list of messages+ formatted_messages = []+ for message in messages:+ # Handle the case where message is a tuple+ if isinstance(message, tuple) and len(message) == 2:+ role, content = message+ # Handle the case where message is a dictionary+ elif isinstance(message, dict):+ role = message.get("role", "user")+ content = message.get("content", "")+ else:+ continue++ # Check if the content is a list+ if isinstance(content, list):+ content_str = ", ".join(+ f'{item["type"]}: {item["text"] if "text" in item else item["image_url"]}'+ if "type" in item else f'text: {item["text"]}'+ for item in content+ )+ formatted_messages.append(f"{role}: {content_str}")+ else:+ formatted_messages.append(f"{role}: {content}")++ return "\n".join(formatted_messages)++def get_model_from_instance(instance):+ """+ Extract model name from LangChain instance.+ """+ if hasattr(instance, "model_id"):+ return instance.model_id+ elif hasattr(instance, "model"):+ return instance.model+ elif hasattr(instance, "model_name"):+ return instance.model_name+ else:+ return "langchain-model"++def get_attribute_from_instance(instance, attribute_name, default=-1):+ """+ Get attribute from instance, checking model_kwargs first.+ """+ # Attempt to retrieve model_kwargs from the instance+ model_kwargs = getattr(instance, "model_kwargs", None)++ # Check for attribute in model_kwargs if it exists+ if model_kwargs and attribute_name in model_kwargs:+ value = model_kwargs[attribute_name]+ return value if value is not None else default++ # Attempt to get the attribute directly from the instance+ try:+ value = getattr(instance, attribute_name)+ # Return default if value is None+ return value if value is not None else default+ except AttributeError:+ # Special handling for "model" attribute to consider "model_id"+ if attribute_name == "model":+ return getattr(instance, "model_id", "langchain-model")++ # Default if the attribute isnt found in model_kwargs or the instance+ return default++def common_chat_logic(scope, pricing_info, environment, application_name, metrics,+ capture_message_content, disable_metrics, version, is_stream):+ """+ Process chat request and generate Telemetry+ """++ scope._end_time = time.time()+ scope._tbt = 0 # LangChain doesnt support streaming yet+ scope._ttft = scope._end_time - scope._start_time++ # Extract prompt - check args[0] first (positional), then kwargs (keyword arguments)+ messages = None+ if scope._args and len(scope._args) > 0:+ messages = scope._args[0] # llm.invoke([("system", "..."), ("human", "...")])+ else:+ messages = scope._kwargs.get("messages", "") or scope._kwargs.get("input", "") # llm.invoke(messages=[...])++ formatted_messages = format_content(messages)+ request_model = scope._request_model++ # Use actual token counts from response if available, otherwise calculate them using general_tokens+ if (scope._input_tokens in [None, 0] or scope._output_tokens in [None, 0]):+ scope._input_tokens = general_tokens(str(formatted_messages))+ scope._output_tokens = general_tokens(str(scope._llmresponse))++ cost = get_chat_model_cost(request_model, pricing_info, scope._input_tokens, scope._output_tokens)++ # Common Span Attributes+ common_span_attributes(scope,+ SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT, SemanticConvention.GEN_AI_SYSTEM_LANGCHAIN,+ scope._server_address, scope._server_port, request_model, scope._response_model,+ environment, application_name, is_stream, scope._tbt, scope._ttft, version)++ # Span Attributes for Request parameters+ instance = scope._kwargs.get("instance")+ if instance:+ scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_TEMPERATURE,+ get_attribute_from_instance(instance, "temperature", 1.0))+ scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_TOP_K,+ get_attribute_from_instance(instance, "top_k", 1.0))+ scope._span.set_attribute(SemanticConvention.GEN_AI_REQUEST_TOP_P,+ get_attribute_from_instance(instance, "top_p", 1.0))++ # Span Attributes for Response parameters+ scope._span.set_attribute(SemanticConvention.GEN_AI_RESPONSE_ID, scope._response_id)+ scope._span.set_attribute(SemanticConvention.GEN_AI_RESPONSE_FINISH_REASON, [scope._finish_reason])+ scope._span.set_attribute(SemanticConvention.GEN_AI_OUTPUT_TYPE, "text" if isinstance(scope._llmresponse, str) else "json")++ # Span Attributes for Cost and Tokens+ scope._span.set_attribute(SemanticConvention.GEN_AI_USAGE_INPUT_TOKENS, scope._input_tokens)+ scope._span.set_attribute(SemanticConvention.GEN_AI_USAGE_OUTPUT_TOKENS, scope._output_tokens)+ scope._span.set_attribute(SemanticConvention.GEN_AI_CLIENT_TOKEN_USAGE, scope._input_tokens + scope._output_tokens)+ scope._span.set_attribute(SemanticConvention.GEN_AI_USAGE_COST, cost)++ # Span Attributes for Content+ if capture_message_content:+ scope._span.set_attribute(SemanticConvention.GEN_AI_CONTENT_PROMPT, formatted_messages)+ scope._span.set_attribute(SemanticConvention.GEN_AI_CONTENT_COMPLETION, scope._llmresponse)++ # To be removed once the change to span_attributes (from span events) is complete+ scope._span.add_event(+ name=SemanticConvention.GEN_AI_CONTENT_PROMPT_EVENT,+ attributes={+ SemanticConvention.GEN_AI_CONTENT_PROMPT: formatted_messages,+ },+ )+ scope._span.add_event(+ name=SemanticConvention.GEN_AI_CONTENT_COMPLETION_EVENT,+ attributes={+ SemanticConvention.GEN_AI_CONTENT_COMPLETION: scope._llmresponse,+ },+ )++ scope._span.set_status(Status(StatusCode.OK))++ # Record metrics+ if not disable_metrics:+ record_completion_metrics(metrics, SemanticConvention.GEN_AI_OPERATION_TYPE_CHAT, SemanticConvention.GEN_AI_SYSTEM_LANGCHAIN,+ scope._server_address, scope._server_port, request_model, scope._response_model, environment,+ application_name, scope._start_time, scope._end_time, scope._input_tokens, scope._output_tokens,+ cost, scope._tbt, scope._ttft)++def process_chat_response(response, request_model, pricing_info, server_port, server_address,+ environment, application_name, metrics, start_time, end_time,+ span, capture_message_content=False, disable_metrics=False,+ version="1.0.0", args=None, **kwargs):+ """+ Process chat response and generate telemetry.+ """++ # Create scope object+ scope = type("GenericScope", (), {})()++ scope._start_time = start_time+ scope._end_time = end_time+ scope._span = span+ scope._server_address = server_address+ scope._server_port = server_port+ scope._request_model = request_model+ scope._kwargs = kwargs+ scope._args = args or ()++ # Extract response content and metadata - only extract what comes from the response+ try:+ scope._llmresponse = response.content+ except AttributeError:+ scope._llmresponse = str(response)++ # Extract token information from usage_metadata if available+ usage_metadata = getattr(response, "usage_metadata", None)+ if usage_metadata:+ scope._input_tokens = usage_metadata.get("input_tokens", 0)+ scope._output_tokens = usage_metadata.get("output_tokens", 0)+ scope._total_tokens = usage_metadata.get("total_tokens", 0)+ else:+ # Will be calculated in common_chat_logic if not available+ scope._input_tokens = None+ scope._output_tokens = None+ scope._total_tokens = None++ # Extract response metadata+ response_metadata = getattr(response, "response_metadata", {})+ scope._response_model = response_metadata.get("model_name", request_model)+ scope._finish_reason = response_metadata.get("finish_reason", "stop")++ # Extract response ID+ scope._response_id = getattr(response, "id", "")++ common_chat_logic(scope, pricing_info, environment, application_name, metrics,+ capture_message_content, disable_metrics, version, is_stream=False)++ return response++++def process_hub_response(response, gen_ai_endpoint, server_port, server_address,+ environment, application_name, span, version="1.0.0"):+ """+ Process LangChain hub operations and generate telemetry.+ """++ # Set span attributes for hub 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 hub metadata+ try:+ span.set_attribute(SemanticConvention.GEN_AI_HUB_OWNER,+ response.metadata.get("lc_hub_owner", "unknown"))+ span.set_attribute(SemanticConvention.GEN_AI_HUB_REPO,+ response.metadata.get("lc_hub_repo", "unknown"))+ except (AttributeError, KeyError):+ pass++ span.set_status(Status(StatusCode.OK))++ return responsediff --git a/sdk/python/src/openlit/instrumentation/langchain_community/__init__.py b/sdk/python/src/openlit/instrumentation/langchain_community/__init__.pynew file mode 100644index 00000000..39a87363--- /dev/null+++ b/sdk/python/src/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):+ passdiff --git a/sdk/python/src/openlit/instrumentation/langchain_community/async_langchain_community.py b/sdk/python/src/openlit/instrumentation/langchain_community/async_langchain_community.pynew file mode 100644index 00000000..156ebb41--- /dev/null+++ b/sdk/python/src/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 wrapperdiff --git a/sdk/python/src/openlit/instrumentation/langchain_community/langchain_community.py b/sdk/python/src/openlit/instrumentation/langchain_community/langchain_community.pynew file mode 100644index 00000000..77d2ad88--- /dev/null+++ b/sdk/python/src/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 wrapperdiff --git a/sdk/python/src/openlit/instrumentation/langchain_community/utils.py b/sdk/python/src/openlit/instrumentation/langchain_community/utils.pynew file mode 100644index 00000000..e8bbea30--- /dev/null+++ b/sdk/python/src/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 responsediff --git a/sdk/python/tests/test_langchain.py b/sdk/python/tests/test_langchain.py.holdsimilarity index 73%rename from sdk/python/tests/test_langchain.pyrename to sdk/python/tests/test_langchain.py.holdindex 337a2fff..0ad47b42 100644--- a/sdk/python/tests/test_langchain.py+++ b/sdk/python/tests/test_langchain.py.hold@@ -12,7 +12,7 @@ prior to running these tests.import osimport bs4-from langchain_community.document_loaders import WebBaseLoader+# from langchain_community.document_loaders import WebBaseLoaderfrom langchain_text_splitters import RecursiveCharacterTextSplitterimport openlit@@ -42,16 +42,16 @@ def test_langchain():"""os.environ["LANGCHAIN_TRACING_V2"] = "false"- docs = WebBaseLoader(- web_paths=("https://lilianweng.github.io/posts/2023-06-23-agent/",),- bs_kwargs={- "parse_only": bs4.SoupStrainer(- class_=("post-content", "post-title", "post-header")- )- },- ).load()- assert docs[0].metadata["source"] == "https://lilianweng.github.io/posts/2023-06-23-agent/"-- texts = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)- splits = texts.split_documents(docs)- assert splits[0].metadata["source"] == "https://lilianweng.github.io/posts/2023-06-23-agent/"+ # docs = WebBaseLoader(+ # web_paths=("https://lilianweng.github.io/posts/2023-06-23-agent/",),+ # bs_kwargs={+ # "parse_only": bs4.SoupStrainer(+ # class_=("post-content", "post-title", "post-header")+ # )+ # },+ # ).load()+ # assert docs[0].metadata["source"] == "https://lilianweng.github.io/posts/2023-06-23-agent/"++ # texts = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)+ # splits = texts.split_documents(docs)+ # assert splits[0].metadata["source"] == "https://lilianweng.github.io/posts/2023-06-23-agent/"