monocle-apptrace 0.5.3__py3-none-any.whl → 0.6.6__py3-none-any.whl

monocle_apptrace/instrumentation/metamodel/finish_types.py

@@ -14,6 +14,7 @@ class FinishType(Enum):
     TOOL_CALL_ERROR = "tool_call_error"
     REFUSAL = "refusal"
     RATE_LIMITED = "rate_limited"
+    TOOL_CALL = "tool_call"
 
 # OpenAI finish reason mapping
 OPENAI_FINISH_REASON_MAPPING = {
@@ -274,6 +275,24 @@ HAYSTACK_FINISH_REASON_MAPPING = {
     "OTHER": FinishType.ERROR.value,
 }
 
+MISTRAL_FINISH_REASON_MAPPING = {
+    "stop": FinishType.SUCCESS.value,
+    "tool_calls": FinishType.TOOL_CALL.value,  # New category for tool calls
+    "length": FinishType.TRUNCATED.value,
+    # Mistral's API documentation does not explicitly mention other finish reasons like "content_filter" or "refusal".
+    # However, in case of an API-level error, the response itself would likely be an HTTP error rather than a
+    # successful response with a specific finish reason.
+}
+
+HUGGING_FACE_FINISH_REASON_MAPPING = {
+    "stop": FinishType.SUCCESS.value,
+    "tool_calls": FinishType.TOOL_CALL.value,  # New category for tool calls
+    "length": FinishType.TRUNCATED.value,
+    # Hugging Face's API documentation does not explicitly mention other finish reasons like "content_filter" or "refusal".
+    # However, in case of an API-level error, the response itself would likely be an HTTP error rather than a
+    # successful response with a specific finish reason.
+}
+
 ADK_FINISH_REASON_MAPPING = GEMINI_FINISH_REASON_MAPPING
 
 def map_openai_finish_reason_to_finish_type(finish_reason):
@@ -462,4 +481,16 @@ def map_adk_finish_reason_to_finish_type(finish_reason):
     """Map ADK finish_reason to standardized finish_type."""
     if not finish_reason:
         return None
-    return ADK_FINISH_REASON_MAPPING.get(finish_reason, None)
+    return ADK_FINISH_REASON_MAPPING.get(finish_reason, None)
+
+def map_mistral_finish_reason_to_finish_type(finish_reason):
+    """Map Mistral finish_reason to standardized finish_type."""
+    if not finish_reason:
+        return None
+    return MISTRAL_FINISH_REASON_MAPPING.get(finish_reason, None)
+
+def map_hf_finish_reason_to_finish_type(finish_reason):
+    """Map Hugging Face finish_reason to standardized finish_type."""
+    if not finish_reason:
+        return None
+    return HUGGING_FACE_FINISH_REASON_MAPPING.get(finish_reason, None)

monocle_apptrace/instrumentation/metamodel/flask/_helper.py

@@ -67,13 +67,13 @@ def flask_post_tracing(token):
 class FlaskSpanHandler(SpanHandler):
 
     def pre_tracing(self, to_wrap, wrapped, instance, args, kwargs):
-        return flask_pre_tracing(args)
+        return flask_pre_tracing(args), None
     
     def post_tracing(self, to_wrap, wrapped, instance, args, kwargs, return_value, token):
         flask_post_tracing(token)
 
 class FlaskResponseSpanHandler(SpanHandler):
-    def post_tracing(self, to_wrap, wrapped, instance, args, kwargs, return_value):
+    def post_tracing(self, to_wrap, wrapped, instance, args, kwargs, return_value, token):
         try:
             _parent_span_context = get_current()
             if _parent_span_context is not None:
@@ -82,4 +82,4 @@ class FlaskResponseSpanHandler(SpanHandler):
                     self.hydrate_events(to_wrap, wrapped, instance, args, kwargs, return_value, parent_span=parent_span)
         except Exception as e:
             logger.info(f"Failed to propogate flask response: {e}")
-        super().post_tracing(to_wrap, wrapped, instance, args, kwargs, return_value)
+        super().post_tracing(to_wrap, wrapped, instance, args, kwargs, return_value, token)

monocle_apptrace/instrumentation/metamodel/hugging_face/_helper.py

@@ -0,0 +1,138 @@
+import os
+import json
+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,
+    try_option,
+)
+
+from monocle_apptrace.instrumentation.metamodel.finish_types import map_hf_finish_reason_to_finish_type
+
+logger = logging.getLogger(__name__)
+
+def update_input_span_events(kwargs):
+    input_text = ""
+    print("DEBUG kwargs:", kwargs)
+    if "inputs" in kwargs:
+        if isinstance(kwargs["inputs"], list):
+            input_text = " | ".join(str(i) for i in kwargs["inputs"])
+        else:
+            input_text = str(kwargs["inputs"])
+    elif "messages" in kwargs:
+        input_text = json.dumps(kwargs["messages"])
+    return {"input": input_text}  # always a dict with 'input'
+
+
+
+def update_output_span_events(result):
+    try:
+        if hasattr(result, "choices") and result.choices:
+            output = [c.message for c in result.choices]
+            output_str = json.dumps(output)
+            return output_str[:200] + "..." if len(output_str) > 200 else output_str
+    except Exception as e:
+        logger.warning("Error in update_output_span_events: %s", str(e))
+    return ""
+
+def extract_messages(kwargs):
+    """Extract system and user messages"""
+    try:
+        messages = []
+        if "system" in kwargs and isinstance(kwargs["system"], str):
+            messages.append({"system": kwargs["system"]})
+        if 'messages' in kwargs and kwargs['messages']:
+            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):
+    """
+    Extract the assistant message from a Mistral response or stream chunks.
+    Returns a JSON string like {"assistant": "<text>"}.
+    """
+    try:
+        result = arguments.get("result") if isinstance(arguments, dict) else arguments
+        if result is None:
+            return ""
+
+        # Handle full response
+        if hasattr(result, "choices") and result.choices:
+            msg_obj = result.choices[0].message
+            return get_json_dumps({msg_obj.role: msg_obj.content})
+
+        # Handle streaming: result might be a list of CompletionEvent chunks
+        if isinstance(result, list):
+            content = []
+            for chunk in result:
+                if hasattr(chunk, "data") and hasattr(chunk.data, "choices") and chunk.data.choices:
+                    choice = chunk.data.choices[0]
+                    if hasattr(choice, "delta") and hasattr(choice.delta, "content"):
+                        content.append(choice.delta.content or "")
+            return get_json_dumps({"assistant": "".join(content)})
+
+        return ""
+
+    except Exception as e:
+        logger.warning("Warning in extract_assistant_message: %s", str(e))
+        return ""
+    
+def update_span_from_llm_response(result, include_token_counts=False):
+    tokens = {
+        "completion_tokens": getattr(result.usage, "completion_tokens", 0),
+        "prompt_tokens": getattr(result.usage, "prompt_tokens", 0),
+        "total_tokens": getattr(result.usage, "total_tokens", 0),
+    } if include_token_counts else {}
+    # Add other metadata fields like finish_reason, etc.
+    return {**tokens}
+
+
+def get_exception_status_code(exc):
+    if exc is None:
+        return "success"
+    code = getattr(exc, "status_code", None)
+    if code == 401:
+        return "unauthorized"
+    elif code == 403:
+        return "forbidden"
+    elif code == 404:
+        return "not_found"
+    return "error"
+
+def map_finish_reason_to_finish_type(finish_reason):
+    """Map Hugging Face finish_reason to finish_type, similar to OpenAI mapping."""
+    return map_hf_finish_reason_to_finish_type(finish_reason)
+
+
+def agent_inference_type(result):
+    """
+    Simple agent inference type logic: if message contains AGENT_PREFIX_KEY,
+    mark as delegation; otherwise it's a normal turn_end.
+    """
+    try:
+        assistant_msg = extract_assistant_message(result)
+        if assistant_msg and AGENT_PREFIX_KEY in assistant_msg:
+            return INFERENCE_AGENT_DELEGATION
+    except Exception as e:
+        logger.warning("Error in agent_inference_type: %s", str(e))
+    return INFERENCE_TURN_END
+
+
+def extract_finish_reason(result):
+    try:
+        return getattr(result, "finish_reason", None)
+    except Exception:
+        return None
+
+

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

@@ -0,0 +1,94 @@
+from monocle_apptrace.instrumentation.common.constants import SPAN_TYPES
+from monocle_apptrace.instrumentation.common.utils import get_error_message, resolve_from_alias
+from monocle_apptrace.instrumentation.metamodel.hugging_face import _helper
+
+
+INFERENCE = {
+    "type": SPAN_TYPES.INFERENCE,
+    "subtype": lambda arguments: _helper.agent_inference_type(arguments),
+    "attributes": [
+        [
+            {
+                "_comment": "provider type, name, deployment, inference_endpoint",
+                "attribute": "type",
+                "accessor": lambda arguments: "inference.huggingface"
+            },
+            {
+                "attribute": "provider_name",
+                "accessor": lambda arguments: "huggingface"
+            },
+            {
+                "attribute": "inference_endpoint",
+                "accessor": lambda arguments: "https://api-inference.huggingface.co/v1/"
+            }
+        ],
+        [
+            {
+                "_comment": "LLM Model (repo ID on Hugging Face hub)",
+                "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": "result from Hugging Face inference",
+                    "attribute": "response",
+                    "accessor": lambda arguments: _helper.extract_assistant_message(arguments)
+                }
+            ]
+        },
+        {
+            "name": "metadata",
+            "attributes": [
+                {
+                    "_comment": "this is metadata usage from LLM, includes token counts",
+                    "accessor": lambda arguments: _helper.update_span_from_llm_response(
+                        arguments.get("result"),
+                        include_token_counts=True  # new flag for streaming handling
+                    )
+                },
+                {
+                    "_comment": "finish reason from Hugging Face response",
+                    "attribute": "finish_reason",
+                    "accessor": lambda arguments: _helper.extract_finish_reason(arguments)
+                },
+                {
+                    "_comment": "finish type mapped from finish reason",
+                    "attribute": "finish_type",
+                    "accessor": lambda arguments: _helper.map_finish_reason_to_finish_type(_helper.extract_finish_reason(arguments))
+                }
+            ]
+        }
+    ]
+}

monocle_apptrace/instrumentation/metamodel/hugging_face/methods.py

@@ -0,0 +1,23 @@
+from monocle_apptrace.instrumentation.common.wrapper import atask_wrapper, task_wrapper
+from monocle_apptrace.instrumentation.metamodel.hugging_face.entities.inference import (
+    INFERENCE,
+)
+
+HUGGING_FACE_METHODS = [
+    {
+        "package": "huggingface_hub",
+        "object": "InferenceClient",
+        "method": "chat_completion",  # sync
+        "wrapper_method": task_wrapper,
+        "span_handler": "non_framework_handler",
+        "output_processor": INFERENCE,
+    },
+    {
+        "package": "huggingface_hub",
+        "object": "AsyncInferenceClient",
+        "method": "chat_completion",  # async
+        "wrapper_method": atask_wrapper,
+        "span_handler": "non_framework_handler",
+        "output_processor": INFERENCE,
+    },
+]

monocle_apptrace/instrumentation/metamodel/lambdafunc/_helper.py

@@ -83,7 +83,7 @@ def lambda_func_post_tracing(token):
 
 class lambdaSpanHandler(SpanHandler):
     def pre_tracing(self, to_wrap, wrapped, instance, args, kwargs):
-        return lambda_func_pre_tracing(kwargs)
+        return lambda_func_pre_tracing(kwargs), None
 
     def post_tracing(self, to_wrap, wrapped, instance, args, kwargs, return_value,token):
         lambda_func_post_tracing(token)

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

@@ -6,6 +6,7 @@ from monocle_apptrace.instrumentation.common.utils import get_error_message, res
 
 INFERENCE = {
     "type": SPAN_TYPES.INFERENCE_FRAMEWORK,
+    "subtype": lambda arguments: _helper.agent_inference_type(arguments),
     "attributes": [
         [
             {
@@ -79,10 +80,6 @@ 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/langgraph/_helper.py

@@ -22,13 +22,25 @@ def agent_instructions(arguments):
     else:
         return arguments['kwargs']['agent'].instructions
 
+def extract_request_agent_input(arguments):
+    if arguments['kwargs'] is not None and 'input' in arguments['kwargs']:
+        history = arguments['kwargs']['input']['messages']
+        messages = []
+        for message in history:
+            if 'content' in message and 'role' in message and message['role'] == "user":  # Check if the message is a UserMessage
+                messages.append(message['content'])
+        return messages
+    return []
+
 def extract_agent_input(arguments):
-    if arguments['result'] is not None and 'messages' in arguments['result']:
-        history = arguments['result']['messages']
+    if arguments['args'] is not None and len(arguments['args']) > 0 and 'messages' in arguments['args'][0]:
+        history = arguments['args'][0]['messages']
+        messages = []
         for message in history:
             if hasattr(message, 'content') and hasattr(message, 'type') and message.type == "human":  # Check if the message is a HumanMessage
-                return message.content
-    return None
+                messages.append(message.content)
+        return messages
+    return []
 
 def get_inference_endpoint(arguments):
     inference_endpoint = resolve_from_alias(arguments['instance'].client.__dict__, ['azure_endpoint', 'api_base', '_base_url'])
@@ -56,6 +68,10 @@ def update_span_from_llm_response(response):
 def extract_tool_response(result):
     if result is not None and hasattr(result, 'content'):
         return result.content
+    if isinstance(result, str):
+        return result
+    if isinstance(result[0], str):
+        return result[0]
     return None
 
 def get_status(result):
@@ -64,11 +80,21 @@ def get_status(result):
     return None
 
 def extract_tool_input(arguments):
-    tool_input = arguments['args'][0]
-    if isinstance(tool_input, str):
-        return [tool_input]
+    if arguments['args'] and len(arguments['args']) > 0:
+        tool_input = arguments['args'][0]
     else:
-        return list(tool_input.values())
+        tool_input:dict = arguments['kwargs'].copy()
+        tool_input.pop('run_manager', None)  # remove run_manager if exists
+        tool_input.pop('config', None)  # remove config if exists
+    return str(tool_input)
+
+    # if isinstance(tool_input, str):
+    #     return [tool_input]
+    # elif isinstance(tool_input, dict):
+    #     # return array of key value pairs
+    #     return [f"'{k}': '{str(v)}'" for k, v in tool_input.items()]
+    # else:
+    #     return [str(tool_input)]
 
 def get_name(instance):
     return instance.name if hasattr(instance, 'name') else ""

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

@@ -2,6 +2,7 @@ from monocle_apptrace.instrumentation.common.constants import AGENT_REQUEST_SPAN
 from monocle_apptrace.instrumentation.metamodel.langgraph import (
     _helper
 )
+from monocle_apptrace.instrumentation.common.utils import get_error_message
 
 AGENT = {
       "type": SPAN_TYPES.AGENTIC_INVOCATION,
@@ -31,7 +32,7 @@ AGENT = {
           "attributes": [
             {
                 "_comment": "this is Agent input",
-                "attribute": "query",
+                "attribute": "input",
                 "accessor": lambda arguments: _helper.extract_agent_input(arguments)
             }
           ]
@@ -39,6 +40,10 @@ AGENT = {
         {
           "name":"data.output",
           "attributes": [
+            {
+                    "attribute": "error_code",
+                    "accessor": lambda arguments: get_error_message(arguments)
+            },
             {
                 "_comment": "this is response from LLM",
                 "attribute": "response",
@@ -50,7 +55,7 @@ AGENT = {
     }
 
 AGENT_REQUEST = {
-      "type": AGENT_REQUEST_SPAN_NAME,
+      "type": SPAN_TYPES.AGENTIC_REQUEST,
       "subtype": SPAN_SUBTYPES.PLANNING,
       "attributes": [
         [
@@ -68,7 +73,7 @@ AGENT_REQUEST = {
             {
                 "_comment": "this is Agent input",
                 "attribute": "input",
-                "accessor": lambda arguments: _helper.extract_agent_input(arguments)
+                "accessor": lambda arguments: _helper.extract_request_agent_input(arguments)
             }
           ]
         },

monocle_apptrace/instrumentation/metamodel/langgraph/langgraph_processor.py

@@ -1,3 +1,4 @@
+import logging
 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
@@ -5,46 +6,114 @@ from monocle_apptrace.instrumentation.metamodel.langgraph._helper import (
    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
+    AGENT_DELEGATION, AGENT_REQUEST, AGENT
 )
 from monocle_apptrace.instrumentation.common.scope_wrapper import start_scope, stop_scope
+from monocle_apptrace.instrumentation.common.utils import is_scope_set
+try:
+    from langgraph.errors import ParentCommand
+except ImportError:
+    ParentCommand = None
+
+logger = logging.getLogger(__name__)
+
+class ParentCommandFilterSpan:
+    """A wrapper for spans that filters out ParentCommand exceptions from being recorded."""
+    
+    def __init__(self, span):
+        self.span = span
+        self.original_record_exception = span.record_exception
+        
+    def record_exception(self, exception, attributes=None, timestamp=None, escaped=False):
+        """Filter out ParentCommand exceptions before recording them."""
+        try:
+            # Check if this is a ParentCommand exception
+            if ParentCommand is not None and isinstance(exception, ParentCommand):
+                logger.debug("Filtering out ParentCommand exception from span recording")
+                return  # Don't record ParentCommand exceptions
+            
+            # For all other exceptions, use the original record_exception method
+            return self.original_record_exception(exception, attributes, timestamp, escaped)
+        except Exception as e:
+            logger.debug(f"Error in ParentCommand filtering: {e}")
+            # If filtering fails, fall back to original behavior
+            return self.original_record_exception(exception, attributes, timestamp, escaped)
 
 class LanggraphAgentHandler(SpanHandler):
     def pre_tracing(self, to_wrap, wrapped, instance, args, kwargs):
         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)
+        if not is_scope_set(scope_name):
+            agent_request_wrapper = to_wrap.copy()
+            agent_request_wrapper["output_processor"] = AGENT_REQUEST
+#            return start_scope(scope_name, scope_value=None, context=context)
+            return attach(context), agent_request_wrapper
         else:
-            return attach(context)
+            return attach(context), None
 
     def post_tracing(self, to_wrap, wrapped, instance, args, kwargs, result, token):
         if token is not None:
             detach(token)
 
+    def post_task_processing(self, to_wrap, wrapped, instance, args, kwargs, result, ex, span, parent_span):
+        """Apply ParentCommand filtering to the span before task execution."""
+        # Apply ParentCommand filtering to this span
+        self._apply_parent_command_filtering(span)
+        super().post_task_processing(to_wrap, wrapped, instance, args, kwargs, result, ex, span, parent_span)
+
+    def _apply_parent_command_filtering(self, span):
+        """Apply ParentCommand exception filtering to a span."""
+        try:
+            if hasattr(span, 'record_exception'):
+                # Create a filtered wrapper and replace the record_exception method
+                filter_wrapper = ParentCommandFilterSpan(span)
+                span.record_exception = filter_wrapper.record_exception
+                logger.debug("Applied ParentCommand filtering to LangGraph agent span")
+        except Exception as e:
+            logger.debug(f"Failed to apply ParentCommand filtering: {e}")
+
     # In multi agent scenarios, the root agent is the one that orchestrates the other agents. LangGraph generates an extra root level invoke()
     # call on top of the supervisor agent invoke().
     # This span handler resets the parent invoke call as generic type to avoid duplicate attributes/events in supervisor span and this root span.
-    def hydrate_span(self, to_wrap, wrapped, instance, args, kwargs, result, span, parent_span = None, ex:Exception = None) -> bool:
-        if is_root_agent_name(instance) and "parent.agent.span" in span.attributes:
-            agent_request_wrapper = to_wrap.copy()
-            agent_request_wrapper["output_processor"] = AGENT_REQUEST
-        else:
-            agent_request_wrapper = to_wrap
-            if hasattr(instance, 'name') and parent_span is not None and not SpanHandler.is_root_span(parent_span):
-                parent_span.set_attribute("parent.agent.span", True)
-        return super().hydrate_span(agent_request_wrapper, wrapped, instance, args, kwargs, result, span, parent_span, ex)
+
+    def hydrate_span(self, to_wrap, wrapped, instance, args, kwargs, result, span, parent_span = None, ex:Exception = None, is_post_exec:bool= False) -> bool:
+        # Filter out ParentCommand exceptions as they are LangGraph control flow mechanisms, not actual errors
+        if ParentCommand is not None and isinstance(ex, ParentCommand):
+            ex = None  # Suppress the ParentCommand exception from being recorded
+
+        return super().hydrate_span(to_wrap, wrapped, instance, args, kwargs, result, span, parent_span, ex, is_post_exec)
 
 class LanggraphToolHandler(SpanHandler):
-    # LangGraph uses an internal tool to initate delegation to other agents. The method is tool invoke() with tool name as `transfer_to_<agent_name>`.
-    # Hence we usea different output processor for tool invoke() to format the span as agentic.delegation.
-    def hydrate_span(self, to_wrap, wrapped, instance, args, kwargs, result, span, parent_span = None, ex:Exception = None) -> bool:
+    def pre_tracing(self, to_wrap, wrapped, instance, args, kwargs):
         if is_delegation_tool(instance):
             agent_request_wrapper = to_wrap.copy()
             agent_request_wrapper["output_processor"] = AGENT_DELEGATION
         else:
-            agent_request_wrapper = to_wrap
+            agent_request_wrapper = None
+        return None, agent_request_wrapper
+
+    # LangGraph uses an internal tool to initate delegation to other agents. The method is tool invoke() with tool name as `transfer_to_<agent_name>`.
+    # Hence we usea different output processor for tool invoke() to format the span as agentic.delegation.
+    def post_task_processing(self, to_wrap, wrapped, instance, args, kwargs, result, ex, span, parent_span):
+        """Apply ParentCommand filtering to the span before task execution."""
+        # Apply ParentCommand filtering to this span
+        self._apply_parent_command_filtering(span)
+        super().post_task_processing(to_wrap, wrapped, instance, args, kwargs, result, ex, span, parent_span)
+
+    def _apply_parent_command_filtering(self, span):
+        """Apply ParentCommand exception filtering to a span."""
+        try:
+            if hasattr(span, 'record_exception'):
+                # Create a filtered wrapper and replace the record_exception method
+                filter_wrapper = ParentCommandFilterSpan(span)
+                span.record_exception = filter_wrapper.record_exception
+                logger.debug("Applied ParentCommand filtering to LangGraph tool span")
+        except Exception as e:
+            logger.debug(f"Failed to apply ParentCommand filtering: {e}")
 
-        return super().hydrate_span(agent_request_wrapper, wrapped, instance, args, kwargs, result, span, parent_span, ex)
-    
+    def hydrate_span(self, to_wrap, wrapped, instance, args, kwargs, result, span, parent_span = None, ex:Exception = None, is_post_exec:bool= False) -> bool:
+        # Filter out ParentCommand exceptions as they are LangGraph control flow mechanisms, not actual errors
+        if ParentCommand is not None and isinstance(ex, ParentCommand):
+            ex = None  # Suppress the ParentCommand exception from being recorded
+        return super().hydrate_span(to_wrap, wrapped, instance, args, kwargs, result, span, parent_span, ex, is_post_exec)

monocle_apptrace/instrumentation/metamodel/langgraph/methods.py

@@ -24,17 +24,33 @@ LANGGRAPH_METHODS = [
         "output_processor": AGENT,
     },
     {
-        "package": "langchain_core.tools.base",
-        "object": "BaseTool",
-        "method": "run",
+        "package": "langchain_core.tools.simple",
+        "object": "Tool",
+        "method": "_run",
         "wrapper_method": task_wrapper,
         "span_handler": "langgraph_tool_handler",
         "output_processor": TOOLS,
     },
     {
-        "package": "langchain_core.tools.base",
-        "object": "BaseTool",
-        "method": "arun",
+        "package": "langchain_core.tools.structured",
+        "object": "StructuredTool",
+        "method": "_run",
+        "wrapper_method": task_wrapper,
+        "span_handler": "langgraph_tool_handler",
+        "output_processor": TOOLS,
+    },
+    {
+        "package": "langchain_core.tools.simple",
+        "object": "Tool",
+        "method": "_arun",
+        "wrapper_method": atask_wrapper,
+        "span_handler": "langgraph_tool_handler",
+        "output_processor": TOOLS,
+    },
+    {
+        "package": "langchain_core.tools.structured",
+        "object": "StructuredTool",
+        "method": "_arun",
         "wrapper_method": atask_wrapper,
         "span_handler": "langgraph_tool_handler",
         "output_processor": TOOLS,