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

openlit/instrumentation/julep/async_julep.py

@@ -5,15 +5,29 @@ Module for monitoring Julep.
 
 import logging
 from opentelemetry.trace import SpanKind, Status, StatusCode
-from opentelemetry.sdk.resources import SERVICE_NAME, TELEMETRY_SDK_NAME, DEPLOYMENT_ENVIRONMENT
+from opentelemetry.sdk.resources import (
+    SERVICE_NAME,
+    TELEMETRY_SDK_NAME,
+    DEPLOYMENT_ENVIRONMENT,
+)
 from openlit.__helpers import handle_exception
 from openlit.semcov import SemanticConvention
 
 # Initialize logger for logging potential issues and operations
 logger = logging.getLogger(__name__)
 
-def async_wrap_julep(gen_ai_endpoint, version, environment, application_name,
-                 tracer, pricing_info, capture_message_content, metrics, disable_metrics):
+
+def async_wrap_julep(
+    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.
 
@@ -55,44 +69,56 @@ def async_wrap_julep(gen_ai_endpoint, version, environment, application_name,
         errors are handled and logged appropriately.
         """
 
-        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 = await wrapped(*args, **kwargs)
 
             try:
                 span.set_attribute(TELEMETRY_SDK_NAME, "openlit")
-                span.set_attribute(SemanticConvention.GEN_AI_ENDPOINT,
-                                   gen_ai_endpoint)
-                span.set_attribute(SemanticConvention.GEN_AI_SYSTEM,
-                                   SemanticConvention.GEN_AI_SYSTEM_JULEP)
-                span.set_attribute(DEPLOYMENT_ENVIRONMENT,
-                                   environment)
-                span.set_attribute(SERVICE_NAME,
-                                   application_name)
-                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(
+                    SemanticConvention.GEN_AI_SYSTEM,
+                    SemanticConvention.GEN_AI_SYSTEM_JULEP,
+                )
+                span.set_attribute(DEPLOYMENT_ENVIRONMENT, environment)
+                span.set_attribute(SERVICE_NAME, application_name)
+                span.set_attribute(
+                    SemanticConvention.GEN_AI_OPERATION,
+                    SemanticConvention.GEN_AI_OPERATION_TYPE_AGENT,
+                )
 
                 if gen_ai_endpoint == "julep.agents_create":
-                    span.set_attribute(SemanticConvention.GEN_AI_AGENT_ID,
-                                    response.id)
-                    span.set_attribute(SemanticConvention.GEN_AI_AGENT_ROLE,
-                                    kwargs.get("name", ""))
-                    span.set_attribute(SemanticConvention.GEN_AI_REQUEST_MODEL,
-                                    kwargs.get("model", "gpt-4-turbo"))
-                    span.set_attribute(SemanticConvention.GEN_AI_AGENT_CONTEXT,
-                                    kwargs.get("about", ""))
+                    span.set_attribute(SemanticConvention.GEN_AI_AGENT_ID, response.id)
+                    span.set_attribute(
+                        SemanticConvention.GEN_AI_AGENT_ROLE, kwargs.get("name", "")
+                    )
+                    span.set_attribute(
+                        SemanticConvention.GEN_AI_REQUEST_MODEL,
+                        kwargs.get("model", "gpt-4-turbo"),
+                    )
+                    span.set_attribute(
+                        SemanticConvention.GEN_AI_AGENT_CONTEXT, kwargs.get("about", "")
+                    )
 
                 elif gen_ai_endpoint == "julep.task_create":
-                    span.set_attribute(SemanticConvention.GEN_AI_AGENT_TOOLS,
-                                    str(kwargs.get("tools", "")))
+                    span.set_attribute(
+                        SemanticConvention.GEN_AI_AGENT_TOOLS,
+                        str(kwargs.get("tools", "")),
+                    )
 
                 elif gen_ai_endpoint == "julep.execution_create":
-                    span.set_attribute(SemanticConvention.GEN_AI_AGENT_TASK_ID,
-                                    kwargs.get("task_id", ""))
+                    span.set_attribute(
+                        SemanticConvention.GEN_AI_AGENT_TASK_ID,
+                        kwargs.get("task_id", ""),
+                    )
                     if capture_message_content:
                         span.add_event(
                             name=SemanticConvention.GEN_AI_CONTENT_PROMPT_EVENT,
                             attributes={
-                             SemanticConvention.GEN_AI_CONTENT_PROMPT:str(kwargs.get("input", "")),
+                                SemanticConvention.GEN_AI_CONTENT_PROMPT: str(
+                                    kwargs.get("input", "")
+                                ),
                             },
                         )
 

openlit/instrumentation/julep/julep.py

@@ -5,15 +5,29 @@ Module for monitoring Julep.
 
 import logging
 from opentelemetry.trace import SpanKind, Status, StatusCode
-from opentelemetry.sdk.resources import SERVICE_NAME, TELEMETRY_SDK_NAME, DEPLOYMENT_ENVIRONMENT
+from opentelemetry.sdk.resources import (
+    SERVICE_NAME,
+    TELEMETRY_SDK_NAME,
+    DEPLOYMENT_ENVIRONMENT,
+)
 from openlit.__helpers import handle_exception
 from openlit.semcov import SemanticConvention
 
 # Initialize logger for logging potential issues and operations
 logger = logging.getLogger(__name__)
 
-def wrap_julep(gen_ai_endpoint, version, environment, application_name,
-                 tracer, pricing_info, capture_message_content, metrics, disable_metrics):
+
+def wrap_julep(
+    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.
 
@@ -55,48 +69,59 @@ def wrap_julep(gen_ai_endpoint, version, environment, application_name,
         errors are handled and logged appropriately.
         """
 
-        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:
                 span.set_attribute(TELEMETRY_SDK_NAME, "openlit")
-                span.set_attribute(SemanticConvention.GEN_AI_ENDPOINT,
-                                   gen_ai_endpoint)
-                span.set_attribute(SemanticConvention.GEN_AI_SYSTEM,
-                                   SemanticConvention.GEN_AI_SYSTEM_JULEP)
-                span.set_attribute(DEPLOYMENT_ENVIRONMENT,
-                                   environment)
-                span.set_attribute(SERVICE_NAME,
-                                   application_name)
-                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(
+                    SemanticConvention.GEN_AI_SYSTEM,
+                    SemanticConvention.GEN_AI_SYSTEM_JULEP,
+                )
+                span.set_attribute(DEPLOYMENT_ENVIRONMENT, environment)
+                span.set_attribute(SERVICE_NAME, application_name)
+                span.set_attribute(
+                    SemanticConvention.GEN_AI_OPERATION,
+                    SemanticConvention.GEN_AI_OPERATION_TYPE_AGENT,
+                )
 
                 if gen_ai_endpoint == "julep.agents_create":
-                    span.set_attribute(SemanticConvention.GEN_AI_AGENT_ID,
-                                    response.id)
-                    span.set_attribute(SemanticConvention.GEN_AI_AGENT_ROLE,
-                                    kwargs.get("name", ""))
-                    span.set_attribute(SemanticConvention.GEN_AI_REQUEST_MODEL,
-                                    kwargs.get("model", "gpt-4-turbo"))
-                    span.set_attribute(SemanticConvention.GEN_AI_AGENT_CONTEXT,
-                                    kwargs.get("about", ""))
+                    span.set_attribute(SemanticConvention.GEN_AI_AGENT_ID, response.id)
+                    span.set_attribute(
+                        SemanticConvention.GEN_AI_AGENT_ROLE, kwargs.get("name", "")
+                    )
+                    span.set_attribute(
+                        SemanticConvention.GEN_AI_REQUEST_MODEL,
+                        kwargs.get("model", "gpt-4-turbo"),
+                    )
+                    span.set_attribute(
+                        SemanticConvention.GEN_AI_AGENT_CONTEXT, kwargs.get("about", "")
+                    )
 
                 elif gen_ai_endpoint == "julep.task_create":
-                    span.set_attribute(SemanticConvention.GEN_AI_AGENT_TOOLS,
-                                    str(kwargs.get("tools", "")))
+                    span.set_attribute(
+                        SemanticConvention.GEN_AI_AGENT_TOOLS,
+                        str(kwargs.get("tools", "")),
+                    )
 
                 elif gen_ai_endpoint == "julep.execution_create":
-                    span.set_attribute(SemanticConvention.GEN_AI_AGENT_TASK_ID,
-                                    kwargs.get("task_id", ""))
+                    span.set_attribute(
+                        SemanticConvention.GEN_AI_AGENT_TASK_ID,
+                        kwargs.get("task_id", ""),
+                    )
                     if capture_message_content:
                         span.add_event(
                             name=SemanticConvention.GEN_AI_CONTENT_PROMPT_EVENT,
                             attributes={
-                             SemanticConvention.GEN_AI_CONTENT_PROMPT:str(kwargs.get("input", "")),
+                                SemanticConvention.GEN_AI_CONTENT_PROMPT: str(
+                                    kwargs.get("input", "")
+                                ),
                             },
                         )
 
-
                 span.set_status(Status(StatusCode.OK))
 
                 # Return original response

openlit/instrumentation/langchain/__init__.py

@@ -1,68 +1,47 @@
-"""Initializer of Auto Instrumentation of LangChain Functions"""
+"""
+OpenLIT LangChain Instrumentation - Callback-Based Hierarchical Spans
+"""
+
 from typing import Collection
 import importlib.metadata
 from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
 from wrapt import wrap_function_wrapper
 
-from openlit.instrumentation.langchain.langchain import (
-    hub,
-    chat
-)
-from openlit.instrumentation.langchain.async_langchain import (
-    async_hub,
-    async_chat
+from openlit.instrumentation.langchain.callback_handler import (
+    OpenLITLangChainCallbackHandler,
 )
 
 _instruments = ("langchain >= 0.1.20",)
 
-WRAPPED_METHODS = [
-    {
-        "package": "langchain.hub",
-        "object": "pull",
-        "endpoint": "langchain.retrieve.prompt",
-        "wrapper": hub,
-    },
-    {
-        "package": "langchain_core.language_models.llms",
-        "object": "BaseLLM.invoke",
-        "endpoint": "langchain.llm",
-        "wrapper": chat,
-    },
-    {
-        "package": "langchain_core.language_models.llms",
-        "object": "BaseLLM.ainvoke",
-        "endpoint": "langchain.llm",
-        "wrapper": async_chat,
-    },
-    {
-        "package": "langchain_core.language_models.chat_models",
-        "object": "BaseChatModel.invoke",
-        "endpoint": "langchain.chat_models",
-        "wrapper": chat,
-    },
-    {
-        "package": "langchain_core.language_models.chat_models",
-        "object": "BaseChatModel.ainvoke",
-        "endpoint": "langchain.chat_models",
-        "wrapper": async_chat,
-    },
-    {
-        "package": "langchain.chains.base",
-        "object": "Chain.invoke",
-        "endpoint": "langchain.chain.invoke",
-        "wrapper": chat,
-    },
-    {
-        "package": "langchain.chains.base",
-        "object": "Chain.ainvoke",
-        "endpoint": "langchain.chain.invoke",
-        "wrapper": async_chat,
-    }
-]
+
+class CallbackManagerWrapper:  # pylint: disable=too-few-public-methods
+    """Wrapper to inject OpenLIT callback handler into LangChain's callback system"""
+
+    def __init__(self, callback_handler: OpenLITLangChainCallbackHandler):
+        self.callback_handler = callback_handler
+
+    def __call__(self, wrapped, instance, args, kwargs):
+        """Inject OpenLIT callback handler when BaseCallbackManager is initialized"""
+
+        # Call original initialization
+        wrapped(*args, **kwargs)
+
+        # Check if our callback handler is already registered
+        for handler in instance.inheritable_handlers:
+            if isinstance(handler, type(self.callback_handler)):
+                break
+        else:
+            # Add our callback handler to the manager
+            instance.add_handler(self.callback_handler, True)
+
 
 class LangChainInstrumentor(BaseInstrumentor):
     """
-    An instrumentor for LangChain client library.
+    OpenLIT LangChain instrumentor using callback-based hierarchical span creation.
+
+    This approach hooks into LangChain's built-in callback system to create
+    proper parent-child span relationships automatically, providing superior
+    observability with OpenLIT's comprehensive business intelligence.
     """
 
     def instrumentation_dependencies(self) -> Collection[str]:
@@ -78,17 +57,49 @@ class LangChainInstrumentor(BaseInstrumentor):
         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")
+        # Create OpenLIT callback handler with all configuration
+        openlit_callback_handler = OpenLITLangChainCallbackHandler(
+            tracer=tracer,
+            version=version,
+            environment=environment,
+            application_name=application_name,
+            pricing_info=pricing_info,
+            capture_message_content=capture_message_content,
+            metrics=metrics,
+            disable_metrics=disable_metrics,
+        )
+
+        # Hook into LangChain's callback system
+        # This automatically provides hierarchical spans for:
+        # - RunnableSequence (workflow spans)
+        # - PromptTemplate (task spans)
+        # - ChatOpenAI (chat spans)
+        # - Tools, Retrievers, etc.
+        try:
             wrap_function_wrapper(
-                wrap_package,
-                wrap_object,
-                wrapper(gen_ai_endpoint, version, environment, application_name,
-                       tracer, pricing_info, capture_message_content, metrics, disable_metrics),
+                module="langchain_core.callbacks",
+                name="BaseCallbackManager.__init__",
+                wrapper=CallbackManagerWrapper(openlit_callback_handler),
             )
+        except Exception:
+            # Graceful degradation if callback system unavailable
+            pass
+
+        # === COMPETITIVE ADVANTAGE SUMMARY ===
+        # Callback-based approach provides:
+        # 1. ✅ Proper span hierarchy (like OpenLLMetry/OpenInference)
+        # 2. ✅ Comprehensive business intelligence (cost, tokens, performance)
+        # 3. ✅ Automatic operation coverage (no manual function wrapping)
+        # 4. ✅ Native LangChain integration (uses built-in callback system)
+        # 5. ✅ Superior observability depth and quality
+
+        # Result: Best of both worlds - hierarchy + business intelligence
 
     def _uninstrument(self, **kwargs):
-        pass
+        """Remove instrumentation"""
+        try:
+            from opentelemetry.instrumentation.utils import unwrap
+
+            unwrap("langchain_core.callbacks", "BaseCallbackManager.__init__")
+        except Exception:
+            pass