monocle-apptrace 0.5.0b1__py3-none-any.whl → 0.5.1__py3-none-any.whl

monocle_apptrace/instrumentation/metamodel/haystack/_helper.py

@@ -9,6 +9,8 @@ from monocle_apptrace.instrumentation.common.utils import (
     get_exception_message,
     get_status_code,
 )
+from monocle_apptrace.instrumentation.metamodel.finish_types import map_haystack_finish_reason_to_finish_type
+
 logger = logging.getLogger(__name__)
 
 
@@ -153,3 +155,65 @@ def update_output_span_events(results):
     if len(output_arg_text) > 100:
         output_arg_text = output_arg_text[:100] + "..."
     return output_arg_text
+
+def extract_finish_reason(arguments):
+    """Extract finish_reason from Haystack response."""
+    try:
+        # Handle exception cases first
+        if arguments.get("exception") is not None:
+            return "error"
+
+        response = arguments.get("result")
+        if response is None:
+            return None
+
+        # Direct finish_reason attribute
+        if hasattr(response, "finish_reason") and response.finish_reason:
+            return response.finish_reason
+
+        if isinstance(response,dict) and 'meta' in response and response['meta'] and len(response['meta']) > 0:
+            metadata = response['meta'][0]
+            if isinstance(metadata, dict):
+                # Check for finish_reason in metadata
+                if "finish_reason" in metadata:
+                    return metadata["finish_reason"]
+
+        if isinstance(response,dict) and 'replies' in response and response['replies'] and len(response['replies']) > 0:
+            metadata = response['replies'][0]
+            if hasattr(metadata,'meta') and metadata.meta:
+                if "finish_reason" in metadata.meta:
+                    return metadata.meta["finish_reason"]
+
+        # Check if response has generation_info
+        if hasattr(response, "generation_info") and response.generation_info:
+            finish_reason = response.generation_info.get("finish_reason")
+            if finish_reason:
+                return finish_reason
+
+        # Check if response has llm_output (batch responses)
+        if hasattr(response, "llm_output") and response.llm_output:
+            finish_reason = response.llm_output.get("finish_reason")
+            if finish_reason:
+                return finish_reason
+
+        # For AIMessage responses, check additional_kwargs
+        if hasattr(response, "additional_kwargs") and response.additional_kwargs:
+            finish_reason = response.additional_kwargs.get("finish_reason")
+            if finish_reason:
+                return finish_reason
+
+        # For generation responses with choices (similar to OpenAI structure)
+        if hasattr(response, "choices") and response.choices:
+            choice = response.choices[0]
+            if hasattr(choice, "finish_reason"):
+                return choice.finish_reason
+
+        # Fallback: if no finish_reason found, default to "stop" (success)
+        return "stop"
+    except Exception as e:
+        logger.warning("Warning: Error occurred in extract_finish_reason: %s", str(e))
+        return None
+
+def map_finish_reason_to_finish_type(finish_reason):
+    """Map Haystack finish_reason to finish_type using Haystack mapping."""
+    return map_haystack_finish_reason_to_finish_type(finish_reason)

monocle_apptrace/instrumentation/metamodel/haystack/entities/inference.py

@@ -1,10 +1,11 @@
+from monocle_apptrace.instrumentation.common.constants import SPAN_TYPES
 from monocle_apptrace.instrumentation.metamodel.haystack import (
     _helper,
 )
 from monocle_apptrace.instrumentation.common.utils import get_error_message, get_llm_type
 
 INFERENCE = {
-    "type": "inference.framework",
+    "type": SPAN_TYPES.INFERENCE_FRAMEWORK,
     "attributes": [
         [
             {
@@ -75,6 +76,16 @@ INFERENCE = {
                     "_comment": "this is metadata usage from LLM",
                     "accessor": lambda arguments: _helper.update_span_from_llm_response(arguments['result'],
                                                                                         arguments['instance'])
+                },
+                {
+                    "attribute": "finish_reason",
+                    "accessor": lambda arguments: _helper.extract_finish_reason(arguments)
+                },
+                {
+                    "attribute": "finish_type",
+                    "accessor": lambda arguments: _helper.map_finish_reason_to_finish_type(
+                        _helper.extract_finish_reason(arguments)
+                    )
                 }
             ]
         }

monocle_apptrace/instrumentation/metamodel/haystack/entities/retrieval.py

@@ -1,8 +1,9 @@
+from monocle_apptrace.instrumentation.common.constants import SPAN_TYPES
 from monocle_apptrace.instrumentation.metamodel.haystack import (_helper, )
 from monocle_apptrace.instrumentation.common.utils import get_attribute
 
 RETRIEVAL = {
-    "type": "retrieval",
+    "type": SPAN_TYPES.RETRIEVAL,
     "attributes": [
         [
             {

monocle_apptrace/instrumentation/metamodel/lambdafunc/entities/http.py

@@ -1,6 +1,7 @@
+from monocle_apptrace.instrumentation.common.constants import SPAN_TYPES
 from monocle_apptrace.instrumentation.metamodel.lambdafunc import _helper
 LAMBDA_HTTP_PROCESSOR = {
-    "type": "http.process",
+    "type": SPAN_TYPES.HTTP_PROCESS,
     "attributes": [
         [
             {

monocle_apptrace/instrumentation/metamodel/langchain/_helper.py

@@ -4,6 +4,8 @@ and assistant messages from various input formats.
 """
 
 import logging
+from opentelemetry.context import get_value
+from monocle_apptrace.instrumentation.common.constants import AGENT_PREFIX_KEY, INFERENCE_AGENT_DELEGATION, INFERENCE_TURN_END, INFERENCE_TOOL_CALL
 from monocle_apptrace.instrumentation.common.utils import (
     Option,
     get_json_dumps,
@@ -44,6 +46,22 @@ def extract_messages(args):
     except Exception as e:
         logger.warning("Warning: Error occurred in extract_messages: %s", str(e))
         return []
+def agent_inference_type(arguments):
+    """Extract agent inference type from arguments."""
+    try:
+        if get_value(AGENT_PREFIX_KEY):
+            agent_prefix = get_value(AGENT_PREFIX_KEY)
+            if hasattr(arguments['result'], "tool_calls") and arguments['result'].tool_calls:
+                tool_call = arguments['result'].tool_calls[0] if arguments['result'].tool_calls else None
+                if tool_call and 'name' in tool_call and tool_call["name"].startswith(agent_prefix):
+                    return INFERENCE_AGENT_DELEGATION
+                else:
+                    return INFERENCE_TOOL_CALL
+        return INFERENCE_TURN_END
+            
+    except Exception as e:
+        logger.warning("Warning: Error occurred in agent_inference_type: %s", str(e))
+        return None
 
 def extract_assistant_message(arguments):
     status = get_status_code(arguments)

monocle_apptrace/instrumentation/metamodel/langchain/entities/inference.py

@@ -1,10 +1,11 @@
+from monocle_apptrace.instrumentation.common.constants import SPAN_TYPES
 from monocle_apptrace.instrumentation.metamodel.langchain import (
     _helper,
 )
 from monocle_apptrace.instrumentation.common.utils import get_error_message, resolve_from_alias, get_llm_type, get_status, get_status_code
 
 INFERENCE = {
-    "type": "inference.framework",
+    "type": SPAN_TYPES.INFERENCE_FRAMEWORK,
     "attributes": [
         [
             {
@@ -78,6 +79,10 @@ INFERENCE = {
                     "accessor": lambda arguments: _helper.map_finish_reason_to_finish_type(
                         _helper.extract_finish_reason(arguments)
                     )
+                },
+                {
+                    "attribute": "inference_sub_type",
+                    "accessor": lambda arguments: _helper.agent_inference_type(arguments)
                 }
             ]
         }

monocle_apptrace/instrumentation/metamodel/langchain/entities/retrieval.py

@@ -1,9 +1,10 @@
+from monocle_apptrace.instrumentation.common.constants import SPAN_TYPES
 from monocle_apptrace.instrumentation.metamodel.langchain import (
     _helper,
 )
 
 RETRIEVAL = {
-    "type": "retrieval",
+    "type": SPAN_TYPES.RETRIEVAL,
     "attributes": [
         [
             {

monocle_apptrace/instrumentation/metamodel/langgraph/_helper.py

@@ -76,6 +76,12 @@ def get_name(instance):
 def get_agent_name(instance) -> str:
     return get_name(instance)
 
+def get_tool_type(span):
+    if (span.attributes.get("is_mcp", False)):
+        return "tool.mcp"
+    else:
+        return "tool.langgraph"
+
 def get_tool_name(instance) -> str:
     return get_name(instance)
 

monocle_apptrace/instrumentation/metamodel/langgraph/entities/inference.py

@@ -1,9 +1,11 @@
+from monocle_apptrace.instrumentation.common.constants import AGENT_REQUEST_SPAN_NAME, SPAN_SUBTYPES, SPAN_TYPES
 from monocle_apptrace.instrumentation.metamodel.langgraph import (
     _helper
 )
 
 AGENT = {
-      "type": "agentic.invocation",
+      "type": SPAN_TYPES.AGENTIC_INVOCATION,
+      "subtype": SPAN_SUBTYPES.ROUTING,
       "attributes": [
         [
               {
@@ -48,7 +50,8 @@ AGENT = {
     }
 
 AGENT_REQUEST = {
-      "type": "agentic.request",
+      "type": AGENT_REQUEST_SPAN_NAME,
+      "subtype": SPAN_SUBTYPES.PLANNING,
       "attributes": [
         [
               {
@@ -83,13 +86,14 @@ AGENT_REQUEST = {
 }
 
 TOOLS = {
-      "type": "agentic.tool.invocation",
+      "type": SPAN_TYPES.AGENTIC_TOOL_INVOCATION,
+      "subtype": SPAN_SUBTYPES.ROUTING,
       "attributes": [
         [
               {
                 "_comment": "tool type",
                 "attribute": "type",
-                "accessor": lambda arguments:'tool.langgraph'
+                "accessor": lambda arguments: _helper.get_tool_type(arguments['span'])
               },
               {
                 "_comment": "name of the tool",
@@ -140,7 +144,8 @@ TOOLS = {
 }
 
 AGENT_DELEGATION = {
-      "type": "agentic.delegation",
+      "type": SPAN_TYPES.AGENTIC_DELEGATION,
+      "subtype": SPAN_SUBTYPES.ROUTING,
       "attributes": [
         [
               {

monocle_apptrace/instrumentation/metamodel/langgraph/langgraph_processor.py

@@ -1,16 +1,23 @@
-from opentelemetry.context import set_value, attach, detach
+from opentelemetry.context import set_value, attach, detach, get_value
+from monocle_apptrace.instrumentation.common.constants import AGENT_PREFIX_KEY, SCOPE_NAME
 from monocle_apptrace.instrumentation.common.span_handler import SpanHandler
 from monocle_apptrace.instrumentation.metamodel.langgraph._helper import (
-   get_name, is_root_agent_name, is_delegation_tool, LANGGRAPTH_AGENT_NAME_KEY
-
+   DELEGATION_NAME_PREFIX, get_name, is_root_agent_name, is_delegation_tool, LANGGRAPTH_AGENT_NAME_KEY
 )
 from monocle_apptrace.instrumentation.metamodel.langgraph.entities.inference import (
     AGENT_DELEGATION, AGENT_REQUEST
 )
+from monocle_apptrace.instrumentation.common.scope_wrapper import start_scope, stop_scope
 
 class LanggraphAgentHandler(SpanHandler):
     def pre_tracing(self, to_wrap, wrapped, instance, args, kwargs):
-        return attach(set_value(LANGGRAPTH_AGENT_NAME_KEY, get_name(instance)))
+        context = set_value(LANGGRAPTH_AGENT_NAME_KEY, get_name(instance))
+        context = set_value(AGENT_PREFIX_KEY, DELEGATION_NAME_PREFIX, context)
+        scope_name = AGENT_REQUEST.get("type")
+        if scope_name is not None and is_root_agent_name(instance) and get_value(scope_name, context) is None:
+            return start_scope(scope_name, scope_value=None, context=context)
+        else:
+            return attach(context)
 
     def post_tracing(self, to_wrap, wrapped, instance, args, kwargs, result, token):
         if token is not None:

monocle_apptrace/instrumentation/metamodel/langgraph/methods.py

@@ -1,38 +1,42 @@
 from monocle_apptrace.instrumentation.common.wrapper import task_wrapper, atask_wrapper
 from monocle_apptrace.instrumentation.metamodel.langgraph.entities.inference import (
-    AGENT, TOOLS
+    AGENT,
+    TOOLS,
 )
+
 LANGGRAPH_METHODS = [
     {
         "package": "langgraph.graph.state",
-         "object": "CompiledStateGraph",
-         "method": "invoke",
-         "wrapper_method": task_wrapper,
-        "span_handler":"langgraph_agent_handler",
-         "output_processor": AGENT
+        "object": "CompiledStateGraph",
+        "method": "invoke",
+        "wrapper_method": task_wrapper,
+        "span_handler": "langgraph_agent_handler",
+        "scope_name": "agent.invocation",
+        "output_processor": AGENT,
     },
     {
         "package": "langgraph.graph.state",
-         "object": "CompiledStateGraph",
-         "method": "ainvoke",
-         "wrapper_method": atask_wrapper,
-        "span_handler":"langgraph_agent_handler",
-         "output_processor": AGENT
+        "object": "CompiledStateGraph",
+        "method": "ainvoke",
+        "wrapper_method": atask_wrapper,
+        "span_handler": "langgraph_agent_handler",
+        "scope_name": "agent.invocation",
+        "output_processor": AGENT,
     },
     {
         "package": "langchain_core.tools.base",
-         "object": "BaseTool",
-         "method": "run",
-         "wrapper_method": task_wrapper,
-        "span_handler":"langgraph_tool_handler",
-         "output_processor": TOOLS
+        "object": "BaseTool",
+        "method": "run",
+        "wrapper_method": task_wrapper,
+        "span_handler": "langgraph_tool_handler",
+        "output_processor": TOOLS,
     },
     {
         "package": "langchain_core.tools.base",
-         "object": "BaseTool",
-         "method": "arun",
-         "wrapper_method": atask_wrapper,
-        "span_handler":"langgraph_tool_handler",
-         "output_processor": TOOLS
-    },    
-]
+        "object": "BaseTool",
+        "method": "arun",
+        "wrapper_method": atask_wrapper,
+        "span_handler": "langgraph_tool_handler",
+        "output_processor": TOOLS,
+    },
+]

monocle_apptrace/instrumentation/metamodel/litellm/_helper.py

@@ -0,0 +1,89 @@
+"""
+This module provides utility functions for extracting system, user,
+and assistant messages from various input formats.
+"""
+import json
+import logging
+from monocle_apptrace.instrumentation.common.utils import (
+    Option,
+    get_json_dumps,
+    try_option,
+    get_exception_message,
+    get_status_code,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def extract_messages(kwargs):
+    """Extract system and user messages"""
+    try:
+        messages = []
+        if 'messages' in kwargs and len(kwargs['messages']) > 0:
+            for msg in kwargs['messages']:
+                if msg.get('content') and msg.get('role'):
+                    messages.append({msg['role']: msg['content']})
+
+        return [get_json_dumps(message) for message in messages]
+    except Exception as e:
+        logger.warning("Warning: Error occurred in extract_messages: %s", str(e))
+        return []
+
+
+def extract_assistant_message(arguments):
+    try:
+        messages = []
+        status = get_status_code(arguments)
+        if status == 'success' or status == 'completed':
+            response = arguments["result"]
+            if (response is not None and hasattr(response, "choices") and len(response.choices) > 0):
+                if hasattr(response.choices[0], "message"):
+                    role = (
+                        response.choices[0].message.role
+                        if hasattr(response.choices[0].message, "role")
+                        else "assistant"
+                    )
+                    messages.append({role: response.choices[0].message.content})
+            return get_json_dumps(messages[0]) if messages else ""
+        else:
+            if arguments["exception"] is not None:
+                return get_exception_message(arguments)
+            elif hasattr(arguments["result"], "error"):
+                return arguments["result"].error
+
+    except (IndexError, AttributeError) as e:
+        logger.warning(
+            "Warning: Error occurred in extract_assistant_message: %s", str(e)
+        )
+        return None
+
+def extract_provider_name(url):
+    """Extract host from a URL string (e.g., https://api.openai.com/v1/ -> api.openai.com)"""
+    if not url:
+        return None
+    return url.split("//")[-1].split("/")[0]
+
+def resolve_from_alias(my_map, alias):
+    """Find a alias that is not none from list of aliases"""
+
+    for i in alias:
+        if i in my_map.keys():
+            return my_map[i]
+    return None
+
+
+def update_span_from_llm_response(response):
+    meta_dict = {}
+    token_usage = None
+    if response is not None:
+        if token_usage is None and hasattr(response, "usage") and response.usage is not None:
+            token_usage = response.usage
+        elif token_usage is None and hasattr(response, "response_metadata"):
+            token_usage = getattr(response.response_metadata, "token_usage", None) \
+                if hasattr(response.response_metadata, "token_usage") \
+                else response.response_metadata.get("token_usage", None)
+        if token_usage is not None:
+            meta_dict.update({"completion_tokens": getattr(token_usage, "completion_tokens", None) or getattr(token_usage, "output_tokens", None)})
+            meta_dict.update({"prompt_tokens": getattr(token_usage, "prompt_tokens", None) or getattr(token_usage, "input_tokens", None)})
+            meta_dict.update({"total_tokens": getattr(token_usage, "total_tokens")})
+    return meta_dict

monocle_apptrace/instrumentation/metamodel/litellm/entities/inference.py

@@ -0,0 +1,109 @@
+from monocle_apptrace.instrumentation.common.constants import SPAN_TYPES
+from monocle_apptrace.instrumentation.metamodel.litellm import (
+    _helper,
+)
+from monocle_apptrace.instrumentation.common.utils import (
+    get_error_message,
+    resolve_from_alias,
+    get_llm_type,
+)
+INFERENCE = {
+    "type": SPAN_TYPES.INFERENCE,
+    "attributes": [
+        [
+            {
+                "_comment": "provider type ,name , deployment , inference_endpoint",
+                "attribute": "type",
+                "accessor": lambda arguments: "inference."
+                + (get_llm_type(arguments['instance']) or 'generic')
+            },
+            {
+                "attribute": "provider_name",
+                "accessor": lambda arguments: _helper.extract_provider_name(
+                    resolve_from_alias(
+                        arguments["kwargs"],
+                        ["azure_endpoint", "api_base", "endpoint"],
+                    )
+                ),
+            },
+            {
+                "attribute": "deployment",
+                "accessor": lambda arguments: resolve_from_alias(
+                    arguments["kwargs"].__dict__,
+                    [
+                        "engine",
+                        "azure_deployment",
+                        "deployment_name",
+                        "deployment_id",
+                        "deployment",
+                    ],
+                ),
+            },
+            {
+                "attribute": "inference_endpoint",
+                "accessor": lambda arguments: resolve_from_alias(
+                    arguments["kwargs"],
+                    ["azure_endpoint", "api_base", "endpoint"],
+                )
+            },
+        ],
+        [
+            {
+                "_comment": "LLM Model",
+                "attribute": "name",
+                "accessor": lambda arguments: resolve_from_alias(
+                    arguments["kwargs"],
+                    ["model", "model_name", "endpoint_name", "deployment_name"],
+                ),
+            },
+            {
+                "attribute": "type",
+                "accessor": lambda arguments: "model.llm."
+                + resolve_from_alias(
+                    arguments["kwargs"],
+                    ["model", "model_name", "endpoint_name", "deployment_name"],
+                ),
+            },
+        ],
+    ],
+    "events": [
+        {
+            "name": "data.input",
+            "attributes": [
+                {
+                    "_comment": "this is instruction and user query to LLM",
+                    "attribute": "input",
+                    "accessor": lambda arguments: _helper.extract_messages(
+                        arguments["kwargs"]
+                    ),
+                }
+            ],
+        },
+        {
+            "name": "data.output",
+            "attributes": [
+
+                {
+                    "attribute": "error_code",
+                    "accessor": lambda arguments: get_error_message(arguments)
+                },
+                {
+                    "_comment": "this is result from LLM",
+                    "attribute": "response",
+                    "accessor": lambda arguments: _helper.extract_assistant_message(arguments),
+                }
+            ],
+        },
+        {
+            "name": "metadata",
+            "attributes": [
+                {
+                    "_comment": "this is metadata usage from LLM",
+                    "accessor": lambda arguments: _helper.update_span_from_llm_response(
+                        arguments["result"]
+                    ),
+                }
+            ],
+        },
+    ],
+}

monocle_apptrace/instrumentation/metamodel/litellm/methods.py

@@ -0,0 +1,19 @@
+from monocle_apptrace.instrumentation.common.wrapper import atask_wrapper, task_wrapper
+from monocle_apptrace.instrumentation.metamodel.litellm.entities.inference import INFERENCE
+
+LITELLM_METHODS = [
+    {
+        "package": "litellm.llms.openai.openai",
+        "object": "OpenAIChatCompletion",
+        "method": "completion",
+        "wrapper_method": task_wrapper,
+        "output_processor": INFERENCE
+    },
+    {
+        "package": "litellm.llms.azure.azure",
+        "object": "AzureChatCompletion",
+        "method": "completion",
+        "wrapper_method": task_wrapper,
+        "output_processor": INFERENCE
+    }
+]

monocle_apptrace/instrumentation/metamodel/llamaindex/entities/agent.py

@@ -1,9 +1,11 @@
+from monocle_apptrace.instrumentation.common.constants import AGENT_REQUEST_SPAN_NAME, SPAN_SUBTYPES, SPAN_TYPES
 from monocle_apptrace.instrumentation.metamodel.llamaindex import (
     _helper,
 )
 
 AGENT = {
-    "type": "agentic.invocation",
+    "type": SPAN_TYPES.AGENTIC_INVOCATION,
+    "subtype": SPAN_SUBTYPES.ROUTING,
     "attributes": [
         [
             {
@@ -49,7 +51,8 @@ AGENT = {
 } 
 
 AGENT_REQUEST = {
-    "type": "agentic.request",
+    "type": AGENT_REQUEST_SPAN_NAME,
+    "subtype": SPAN_SUBTYPES.PLANNING,
     "attributes": [
         [
               {
@@ -84,7 +87,8 @@ AGENT_REQUEST = {
 }
 
 TOOLS = {
-      "type": "agentic.tool.invocation",
+      "type": SPAN_TYPES.AGENTIC_TOOL_INVOCATION,
+      "subtype": SPAN_SUBTYPES.ROUTING,
       "attributes": [
         [
               {
@@ -141,7 +145,8 @@ TOOLS = {
 }
 
 AGENT_DELEGATION = {
-    "type": "agentic.delegation",
+    "type": SPAN_TYPES.AGENTIC_DELEGATION,
+    "subtype": SPAN_SUBTYPES.ROUTING,
       "attributes": [
         [
               {

monocle_apptrace/instrumentation/metamodel/llamaindex/entities/inference.py

@@ -1,10 +1,11 @@
+from monocle_apptrace.instrumentation.common.constants import SPAN_TYPES
 from monocle_apptrace.instrumentation.metamodel.llamaindex import (
     _helper,
 )
 from monocle_apptrace.instrumentation.common.utils import get_error_message, resolve_from_alias, get_llm_type, get_status, get_status_code
 
 INFERENCE = {
-    "type": "inference.framework",
+    "type": SPAN_TYPES.INFERENCE_FRAMEWORK,
     "attributes": [
         [
             {

monocle_apptrace/instrumentation/metamodel/llamaindex/entities/retrieval.py

@@ -1,9 +1,10 @@
+from monocle_apptrace.instrumentation.common.constants import SPAN_TYPES
 from monocle_apptrace.instrumentation.metamodel.llamaindex import (
     _helper,
 )
 
 RETRIEVAL = {
-    "type": "retrieval",
+    "type": SPAN_TYPES.RETRIEVAL,
     "attributes": [
         [
             {