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

monocle_apptrace/instrumentation/common/constants.py

@@ -92,6 +92,9 @@ CHILD_ERROR_CODE = "child.error.code"
 
 AGENT_PREFIX_KEY = "monocle.agent.prefix"
 
+MONOCLE_SKIP_EXECUTIONS = "monocle.skip_executions"
+SKIPPED_EXECUTION = "monocle.skipped_execution"
+
 # agentic sub types
 INFERENCE_AGENT_DELEGATION = "delegation"
 INFERENCE_TOOL_CALL = "tool_call"
@@ -178,3 +181,8 @@ MAP_ATTRIBUTES_TO_SPAN_SUBTYPE = {
     
     
 }
+
+PROVIDER_BASE_URLS = {
+    "deepseek": "https://api.deepseek.com",
+    # Add more providers here later
+}

monocle_apptrace/instrumentation/common/span_handler.py

@@ -1,6 +1,7 @@
 import logging
 import os
 from contextlib import contextmanager
+from typing import Union
 from opentelemetry.context import get_value, set_value, attach, detach
 from opentelemetry.sdk.trace import Span
 from opentelemetry.trace.status import Status, StatusCode
@@ -10,8 +11,8 @@ from monocle_apptrace.instrumentation.common.constants import (
     service_type_map,
     MONOCLE_SDK_VERSION, MONOCLE_SDK_LANGUAGE, MONOCLE_DETECTED_SPAN_ERROR
 )
-from monocle_apptrace.instrumentation.common.utils import set_attribute, get_scopes, MonocleSpanException, get_monocle_version
-from monocle_apptrace.instrumentation.common.constants import WORKFLOW_TYPE_KEY, WORKFLOW_TYPE_GENERIC, CHILD_ERROR_CODE
+from monocle_apptrace.instrumentation.common.utils import set_attribute, get_scopes, MonocleSpanException, get_monocle_version, replace_placeholders
+from monocle_apptrace.instrumentation.common.constants import WORKFLOW_TYPE_KEY, WORKFLOW_TYPE_GENERIC, CHILD_ERROR_CODE, MONOCLE_SKIP_EXECUTIONS, SKIPPED_EXECUTION
 
 logger = logging.getLogger(__name__)
 
@@ -49,7 +50,7 @@ class SpanHandler:
         pass
 
     def pre_tracing(self, to_wrap, wrapped, instance, args, kwargs):
-        pass
+        return None, None
 
     def post_tracing(self, to_wrap, wrapped, instance, args, kwargs, return_value, token=None):
         pass
@@ -67,8 +68,6 @@ class SpanHandler:
             span.set_attribute("span.type", span_type)
         else:
             logger.warning("type of span not found or incorrect written in entity json")
-        if "subtype" in output_processor:
-            span.set_attribute("span.subtype", output_processor["subtype"])
         return span_type
 
     def pre_task_processing(self, to_wrap, wrapped, instance, args,kwargs, span):
@@ -103,28 +102,32 @@ class SpanHandler:
     def post_task_processing(self, to_wrap, wrapped, instance, args, kwargs, result, ex, span:Span, parent_span:Span):
         pass
 
-    def should_skip(self, processor, instance, args, kwargs) -> bool:
+    def should_skip(self, processor, instance, span, parent_span, args, kwargs) -> bool:
         should_skip = False
         accessor = processor.get('should_skip')
         if accessor:
-            arguments = {"instance":instance, "args":args, "kwargs":kwargs}
-            should_skip = accessor(arguments)
-            if not isinstance(should_skip, bool):
-                logger.warning("Warning: 'should_skip' accessor did not return a boolean value")
-                return True
+            arguments = {"instance":instance, "span":span, "parent_span":parent_span, "args":args, "kwargs":kwargs}
+            try:
+                should_skip = accessor(arguments)
+                if not isinstance(should_skip, bool):
+                    logger.warning("Warning: 'should_skip' accessor did not return a boolean value")
+                    return False
+            except Exception as e:
+                logger.warning("Warning: Error occurred in 'should_skip' accessor: %s", str(e))
         return should_skip
 
-    def hydrate_span(self, to_wrap, wrapped, instance, args, kwargs, result, span, parent_span = None, ex:Exception = None) -> bool:
+    def hydrate_span(self, to_wrap, wrapped, instance, args, kwargs, result, span, parent_span = None,
+                    ex:Exception = None, is_post_exec:bool= False) -> bool:
         try:
-            detected_error_in_attribute = self.hydrate_attributes(to_wrap, wrapped, instance, args, kwargs, result, span, parent_span)
-            detected_error_in_event = self.hydrate_events(to_wrap, wrapped, instance, args, kwargs, result, span, parent_span, ex)
+            detected_error_in_attribute = self.hydrate_attributes(to_wrap, wrapped, instance, args, kwargs, result, span, parent_span, is_post_exec)
+            detected_error_in_event = self.hydrate_events(to_wrap, wrapped, instance, args, kwargs, result, span, parent_span, ex, is_post_exec)
             if detected_error_in_attribute or detected_error_in_event:
                 span.set_attribute(MONOCLE_DETECTED_SPAN_ERROR, True)
         finally:
-            if span.status.status_code == StatusCode.UNSET and ex is None:
+            if is_post_exec and span.status.status_code == StatusCode.UNSET and ex is None:
                 span.set_status(StatusCode.OK)
 
-    def hydrate_attributes(self, to_wrap, wrapped, instance, args, kwargs, result, span:Span, parent_span:Span) -> bool:
+    def hydrate_attributes(self, to_wrap, wrapped, instance, args, kwargs, result, span:Span, parent_span:Span, is_post_exec:bool) -> bool:
         detected_error:bool = False
         span_index = 0
         if SpanHandler.is_root_span(span):
@@ -133,7 +136,6 @@ class SpanHandler:
             output_processor=to_wrap['output_processor']
             self.set_span_type(to_wrap, wrapped, instance, output_processor, span, args, kwargs)
             skip_processors:list[str] = self.skip_processor(to_wrap, wrapped, instance, span, args, kwargs) or []
-
             if 'attributes' in output_processor and 'attributes' not in skip_processors:
                 arguments = {"instance":instance, "args":args, "kwargs":kwargs, "result":result, "parent_span":parent_span, "span":span}
                 for processors in output_processor["attributes"]:
@@ -144,9 +146,10 @@ class SpanHandler:
                         if attribute and accessor:
                             attribute_name = f"entity.{span_index+1}.{attribute}"
                             try:
-                                processor_result = accessor(arguments)
-                                if processor_result and isinstance(processor_result, (str, list)):
-                                    span.set_attribute(attribute_name, processor_result)
+                                if (not is_post_exec and processor.get('phase', '') != 'post_execution') or (is_post_exec and processor.get('phase', '') == 'post_execution'):
+                                    processor_result = accessor(arguments)
+                                    if processor_result and isinstance(processor_result, (str, list)):
+                                        span.set_attribute(attribute_name, processor_result)
                             except MonocleSpanException as e:
                                 span.set_status(StatusCode.ERROR, e.message)
                                 detected_error = True
@@ -165,13 +168,27 @@ class SpanHandler:
             span.set_attribute("entity.count", span_index)
         return detected_error
 
-    def hydrate_events(self, to_wrap, wrapped, instance, args, kwargs, ret_result, span: Span, parent_span=None, ex:Exception=None) -> bool:
+    def hydrate_events(self, to_wrap, wrapped, instance, args, kwargs, ret_result, span: Span, parent_span=None, ex:Exception=None,
+                       is_post_exec: bool = False) -> bool:
         detected_error:bool = False
         if 'output_processor' in to_wrap and to_wrap["output_processor"] is not None:
             output_processor=to_wrap['output_processor']
-            skip_processors:list[str] = self.skip_processor(to_wrap, wrapped, instance, span, args, kwargs) or []
-
+            if is_post_exec:
+                skip_events:list[str] = ['events.data.input']
+            else:
+                skip_events:list[str] = ['events.data.output', 'events.metadata']
+            skip_processors:list[str] = list(set(self.skip_processor(to_wrap, wrapped, instance, span, args, kwargs) or []).union(set(skip_events)))
             arguments = {"instance": instance, "args": args, "kwargs": kwargs, "result": ret_result, "exception":ex, "parent_span":parent_span, "span": span}
+            subtype = output_processor.get('subtype')
+            if subtype:
+                if callable(subtype):
+                    try:
+                        subtype_result = subtype(arguments)
+                        span.set_attribute("span.subtype", subtype_result)
+                    except Exception as e:
+                        logger.debug(f"Error processing subtype: {e}")
+                else:
+                    span.set_attribute("span.subtype", subtype)
             # Process events if they are defined in the output_processor.
             # In case of inference.modelapi skip the event processing unless the span has an exception
             if 'events' in output_processor and ('events' not in skip_processors or ex is not None):
@@ -200,6 +217,13 @@ class SpanHandler:
                                         event_attributes[attribute_key] = result
                                     else:
                                         event_attributes.update(result)
+                                if not is_post_exec and event_name == "data.input" and attribute_key == "input" and result:
+                                    # append memory to input if available
+                                    # update the result with new input
+                                    pass
+                                elif not detected_error and is_post_exec and event_name == "data.output" and attribute_key == "response" and result:
+                                    # capture memory
+                                    pass
                             except Exception as e:
                                 logger.debug(f"Error evaluating accessor for attribute '{attribute_key}': {e}")
                     matching_timestamp = getattr(ret_result, "timestamps", {}).get(event_name, None)
@@ -299,6 +323,32 @@ class SpanHandler:
         finally:
             SpanHandler.detach_workflow_type(token)
 
+    @staticmethod
+    def get_iput_entity_type(span: Span) -> str:
+        for event in span.events:
+            if event.name == "data.input":
+                return event.attributes.get("entity.type", "")
+
+    @staticmethod
+    def skip_execution(span:Span) -> tuple[bool, Union[dict, list, str, None]]:
+        skip_execs = get_value(MONOCLE_SKIP_EXECUTIONS)
+        if skip_execs is not None:
+            skip_exec_entity = skip_execs.get(span.attributes.get("entity.1.name", ""),{})
+            if ((span.attributes.get("span.type") is not None and skip_exec_entity.get("span.type", "") == span.attributes.get("span.type")) and
+                (span.attributes.get("entity.1.type") is not None and skip_exec_entity.get("entity.type", "") == span.attributes.get("entity.1.type"))):
+                span.set_attribute(SKIPPED_EXECUTION, True)
+                if skip_exec_entity.get("raise_error", False):
+                    raise MonocleSpanException(skip_exec_entity.get("error_message", ""))
+                response = skip_exec_entity.get("response", None)
+                response = replace_placeholders(response, span)
+                return True, response
+        return False, None
+
+    @staticmethod
+    def replace_placeholders_in_response(response: Union[dict, list, str], span:Span) -> Union[dict, list, str]:
+        if span.attributes.get(SKIPPED_EXECUTION, False):
+            return replace_placeholders(response, span)
+        return response
 
 class NonFrameworkSpanHandler(SpanHandler):
     # If the language framework is being executed, then skip generating direct openAI attributes and events

monocle_apptrace/instrumentation/common/utils.py

@@ -1,7 +1,8 @@
+import ast
 import logging, json
 import os
 import traceback
-from typing import Callable, Generic, Optional, TypeVar, Mapping
+from typing import Callable, Generic, Optional, TypeVar, Mapping, Union
 
 from opentelemetry.context import attach, detach, get_current, get_value, set_value, Context
 from opentelemetry.trace import NonRecordingSpan, Span
@@ -217,13 +218,16 @@ def remove_scopes(token:object) -> None:
     if token is not None:
         detach(token)
 
-def get_scopes() -> dict[str, object]:
+def get_scopes(scope_name: Optional[str] = None) -> dict[str, object]:
     monocle_scopes:dict[str, object] = {}
     for key, val in baggage.get_all().items():
-        if key.startswith(MONOCLE_SCOPE_NAME_PREFIX):
+        if key.startswith(MONOCLE_SCOPE_NAME_PREFIX) and (scope_name is None or key == f"{MONOCLE_SCOPE_NAME_PREFIX}{scope_name}"):
             monocle_scopes[key[len(MONOCLE_SCOPE_NAME_PREFIX):]] = val
     return monocle_scopes
 
+def is_scope_set(scepe_name: str) -> bool:
+    return len(get_scopes(scepe_name)) > 0
+
 def get_baggage_for_scopes():
     baggage_context:Context = None
     for scope_key, scope_value in get_scopes():
@@ -357,7 +361,7 @@ class Option(Generic[T]):
 
     def and_then(self, func: Callable[[T], 'Option[U]']) -> 'Option[U]':
         if self.is_some():
-            return func(self.value)
+            return Option(func(self.value))
         return Option(None)
 
 # Example usage
@@ -409,7 +413,7 @@ def get_error_message(arguments):
 
 
 def get_status_code(arguments):
-    if arguments["exception"] is not None:
+    if "exception" in arguments and arguments["exception"] is not None:
         return get_exception_status_code(arguments)
     elif hasattr(arguments["result"], "status"):
         return arguments["result"].status
@@ -467,4 +471,57 @@ def get_current_monocle_span(context: Optional[Context] = None) -> Span:
     span = get_value(_MONOCLE_SPAN_KEY, context=context)
     if span is None or not isinstance(span, Span):
         return INVALID_SPAN
-    return span
+    return span
+
+def get_input_event_from_span(events: list[dict], search_key:str) -> Optional[Mapping]:
+    """Extract the 'data.input' event from the span if it exists.
+
+    Args:
+        span: The Span to extract the event from.
+
+    Returns:
+        The 'data.input' event if it exists, None otherwise.
+    """
+    input_request = None
+    for event in events:
+        if event.name == "data.input":
+            try:
+                #load the input attribute as dictionary from string
+                try:
+                    input_dict = json.loads(event.attributes.get("input", "{}"))
+                except Exception as e:
+                    if isinstance(e, json.JSONDecodeError):
+                        input_dict = ast.literal_eval(event.attributes.get("input", {}))
+                    else:
+                        raise
+                if search_key in input_dict:
+                    input_request = input_dict[search_key]
+            except Exception as e:
+                logger.debug(f"Error parsing input event attribute: {e}")
+            break
+    return input_request
+
+def replace_placeholders(obj: Union[dict, list, str], span: Span) -> Union[dict, list, str]:
+    """Replace placeholders in strings with span context values."""
+    if isinstance(obj, dict):
+        return {k: replace_placeholders(v, span) for k, v in obj.items()}
+    elif isinstance(obj, list):
+        return [replace_placeholders(item, span) for item in obj]
+    elif isinstance(obj, str):
+        startIndex = 0
+        while True:
+            start = obj.find("{{", startIndex)
+            end = obj.find("}}", start + 2)
+            if start == -1 or end == -1:
+                break
+            key = obj[start + 2:end].strip()
+            value = get_input_event_from_span(span.events, key)
+            if value is not None:
+                obj = obj[:start] + str(value) + obj[end + 2:]
+            startIndex = start + len(str(value))
+            if startIndex >= len(obj):
+                break
+        return obj
+    else:
+        return obj
+

monocle_apptrace/instrumentation/common/wrapper.py

@@ -1,28 +1,35 @@
 # pylint: disable=protected-access
+import logging
+import os
 from contextlib import contextmanager
 import os
-from typing import AsyncGenerator, Iterator, Optional
+from typing import AsyncGenerator, Iterator
 import logging
 from opentelemetry.trace import Tracer
-from opentelemetry.trace.propagation import _SPAN_KEY, set_span_in_context, get_current_span
-from opentelemetry.trace import propagation
+from opentelemetry.trace.propagation import set_span_in_context, get_current_span
 from opentelemetry.context import set_value, attach, detach, get_value
-from opentelemetry.context import create_key, get_value, set_value
-from opentelemetry.context.context import Context
 from opentelemetry.trace.span import INVALID_SPAN, Span
 from opentelemetry.trace.status import StatusCode
 
+from monocle_apptrace.instrumentation.common.constants import (
+    ADD_NEW_WORKFLOW,
+    AGENTIC_SPANS,
+    WORKFLOW_TYPE_KEY,
+)
+from monocle_apptrace.instrumentation.common.scope_wrapper import monocle_trace_scope
 from monocle_apptrace.instrumentation.common.span_handler import SpanHandler
 from monocle_apptrace.instrumentation.common.utils import (
+    get_current_monocle_span,
+    remove_scope,
+    set_monocle_span_in_context,
+    set_scope,
     set_scopes,
     with_tracer_wrapper,
     set_scope,
     remove_scope,
     get_current_monocle_span,
-    set_monocle_span_in_context
+    set_monocle_span_in_context,
 )
-from monocle_apptrace.instrumentation.common.constants import WORKFLOW_TYPE_KEY, ADD_NEW_WORKFLOW, AGENTIC_SPANS
-from monocle_apptrace.instrumentation.common.scope_wrapper import monocle_trace_scope
 
 logger = logging.getLogger(__name__)
 ISOLATE_MONOCLE_SPANS = os.getenv("MONOCLE_ISOLATE_SPANS", "true").lower() == "true"
@@ -53,7 +60,9 @@ def post_process_span(handler, to_wrap, wrapped, instance, args, kwargs, return_
         try:
             if parent_span == INVALID_SPAN:
                 parent_span = None
-            handler.hydrate_span(to_wrap, wrapped, instance, args, kwargs, return_value, span, parent_span, ex)
+            handler.hydrate_span(to_wrap, wrapped, instance, args, kwargs, return_value, span, parent_span, ex,
+                    is_post_exec=True)
+            return_value = SpanHandler.replace_placeholders_in_response(return_value, span)
         except Exception as e:
             logger.info(f"Warning: Error occurred in hydrate_span: {e}")
         
@@ -61,6 +70,7 @@ def post_process_span(handler, to_wrap, wrapped, instance, args, kwargs, return_
             handler.post_task_processing(to_wrap, wrapped, instance, args, kwargs, return_value, ex, span, parent_span)
         except Exception as e:
             logger.info(f"Warning: Error occurred in post_task_processing: {e}")
+        return return_value
 
 def get_span_name(to_wrap, instance):
     if to_wrap.get("span_name"):
@@ -87,19 +97,32 @@ def monocle_wrapper_span_processor(tracer: Tracer, handler: SpanHandler, to_wrap
                 span.end()
         else:
             ex:Exception = None
-            to_wrap = get_wrapper_with_next_processor(to_wrap, handler, instance, args, kwargs)
+            to_wrap = get_wrapper_with_next_processor(to_wrap, handler, instance, span, parent_span, args, kwargs)
             if has_more_processors(to_wrap):
                 try:
-                    return_value, span_status = monocle_wrapper_span_processor(tracer, handler, to_wrap, wrapped, instance, source_path, False, args, kwargs)
+                    handler.hydrate_span(to_wrap, wrapped, instance, args, kwargs, None, span, parent_span, ex,
+                                is_post_exec=False)
+                except Exception as e:
+                    logger.info(f"Warning: Error occurred in hydrate_span pre_process_span: {e}")
+                try:
+                    with monocle_trace_scope(get_builtin_scope_names(to_wrap)):
+                        return_value, span_status = monocle_wrapper_span_processor(tracer, handler, to_wrap, wrapped, instance, source_path, False, args, kwargs)
                 except Exception as e:
                     ex = e
                     raise
                 finally:
-                    post_process_span_internal(return_value)
+                    return_value = post_process_span(handler, to_wrap, wrapped, instance, args, kwargs, return_value, span, parent_span ,ex)
             else:
                 try:
-                    with SpanHandler.workflow_type(to_wrap, span):
-                        return_value = wrapped(*args, **kwargs)
+                    handler.hydrate_span(to_wrap, wrapped, instance, args, kwargs, None, span, parent_span, ex,
+                                is_post_exec=False)
+                except Exception as e:
+                    logger.info(f"Warning: Error occurred in hydrate_span pre_process_span: {e}")
+                try:
+                    skip_execution, return_value = SpanHandler.skip_execution(span)
+                    if not skip_execution:
+                        with SpanHandler.workflow_type(to_wrap, span):
+                            return_value = wrapped(*args, **kwargs)
                 except Exception as e:
                     ex = e
                     raise
@@ -108,10 +131,11 @@ def monocle_wrapper_span_processor(tracer: Tracer, handler: SpanHandler, to_wrap
                         post_process_span(handler, to_wrap, wrapped, instance, args, kwargs, ret_val, span, parent_span ,ex)
                         if not auto_close_span:
                             span.end()
+                        return ret_val
                     if ex is None and not auto_close_span and to_wrap.get("output_processor") and to_wrap.get("output_processor").get("response_processor"):
                         to_wrap.get("output_processor").get("response_processor")(to_wrap, return_value, post_process_span_internal)
                     else:
-                        post_process_span_internal(return_value)
+                        return_value = post_process_span_internal(return_value)
             span_status = span.status
     return return_value, span_status
 
@@ -121,7 +145,9 @@ def monocle_wrapper(tracer: Tracer, handler: SpanHandler, to_wrap, wrapped, inst
     token = None
     try:
         try:
-            pre_trace_token = handler.pre_tracing(to_wrap, wrapped, instance, args, kwargs)
+            pre_trace_token, alternate_to_wrapp = handler.pre_tracing(to_wrap, wrapped, instance, args, kwargs)
+            if alternate_to_wrapp is not None:
+                to_wrap = alternate_to_wrapp
         except Exception as e:
             logger.info(f"Warning: Error occurred in pre_tracing: {e}")
         if to_wrap.get('skip_span', False) or handler.skip_span(to_wrap, wrapped, instance, args, kwargs):
@@ -160,31 +186,46 @@ async def amonocle_wrapper_span_processor(tracer: Tracer, handler: SpanHandler,
                 span.end()
         else:
             ex:Exception = None
-            to_wrap = get_wrapper_with_next_processor(to_wrap, handler, instance, args, kwargs)
+            to_wrap = get_wrapper_with_next_processor(to_wrap, handler, instance, span, parent_span,args, kwargs)
             if has_more_processors(to_wrap):
                 try:
-                    return_value, span_status = await amonocle_wrapper_span_processor(tracer, handler, to_wrap, wrapped, instance, source_path, False, args, kwargs)
+                    handler.hydrate_span(to_wrap, wrapped, instance, args, kwargs, None, span, parent_span, ex,
+                                    is_post_exec=False)
+                except Exception as e:
+                    logger.info(f"Warning: Error occurred in hydrate_span pre_process_span: {e}")
+
+                try:
+                    with monocle_trace_scope(get_builtin_scope_names(to_wrap)):
+                        return_value, span_status = await amonocle_wrapper_span_processor(tracer, handler, to_wrap, wrapped, instance, source_path, False, args, kwargs)
                 except Exception as e:
                     ex = e
                     raise
                 finally:
-                    post_process_span_internal(return_value)
+                    return_value = post_process_span(handler, to_wrap, wrapped, instance, args, kwargs, return_value, span, parent_span ,ex)
             else:
                 try:
-                    with SpanHandler.workflow_type(to_wrap, span):
-                        return_value = await wrapped(*args, **kwargs)
+                    handler.hydrate_span(to_wrap, wrapped, instance, args, kwargs, None, span, parent_span, ex,
+                                is_post_exec=False)
+                except Exception as e:
+                    logger.info(f"Warning: Error occurred in hydrate_span pre_process_span: {e}")
+                try:
+                    skip_execution, return_value = SpanHandler.skip_execution(span)
+                    if not skip_execution:
+                        with SpanHandler.workflow_type(to_wrap, span):
+                            return_value = await wrapped(*args, **kwargs)
                 except Exception as e:
                     ex = e
                     raise
                 finally:
                     def post_process_span_internal(ret_val):
-                        post_process_span(handler, to_wrap, wrapped, instance, args, kwargs, ret_val, span, parent_span, ex)
+                        ret_val = post_process_span(handler, to_wrap, wrapped, instance, args, kwargs, ret_val, span, parent_span, ex)
                         if not auto_close_span:
                             span.end()
+                        return ret_val
                     if ex is None and not auto_close_span and to_wrap.get("output_processor") and to_wrap.get("output_processor").get("response_processor"):
                         to_wrap.get("output_processor").get("response_processor")(to_wrap, return_value, post_process_span_internal)
                     else:
-                        post_process_span_internal(return_value)
+                        return_value = post_process_span_internal(return_value)
         span_status = span.status
     return return_value, span_status
 
@@ -208,35 +249,50 @@ async def amonocle_iter_wrapper_span_processor(tracer: Tracer, handler: SpanHand
                 span.end()
         else:
             ex:Exception = None
-            to_wrap = get_wrapper_with_next_processor(to_wrap, handler, instance, args, kwargs)
+            to_wrap = get_wrapper_with_next_processor(to_wrap, handler, span, parent_span, instance, args, kwargs)
             if has_more_processors(to_wrap):
                 try:
-                    async for item in amonocle_iter_wrapper_span_processor(tracer, handler, to_wrap, wrapped, instance, source_path, False, args, kwargs):
-                        last_item = item
-                        yield item
+                    handler.hydrate_span(to_wrap, wrapped, instance, args, kwargs, None, span, parent_span, ex,
+                                is_post_exec=False)
+                except Exception as e:
+                    logger.info(f"Warning: Error occurred in hydrate_span pre_process_span: {e}")
+                try:
+                    with monocle_trace_scope(get_builtin_scope_names(to_wrap)):
+                        async for item in amonocle_iter_wrapper_span_processor(tracer, handler, to_wrap, wrapped, instance, source_path, False, args, kwargs):
+                            last_item = item
+                            yield item
                 except Exception as e:
                     ex = e
                     raise
                 finally:
-                    post_process_span(handler, to_wrap, wrapped, instance, args, kwargs, last_item, span, parent_span, ex)
+                    last_item = post_process_span(handler, to_wrap, wrapped, instance, args, kwargs, last_item, span, parent_span, ex)
             else:
                 try:
-                    with SpanHandler.workflow_type(to_wrap, span):
-                        async for item in wrapped(*args, **kwargs):
-                            last_item = item
-                            yield item
+                    handler.hydrate_span(to_wrap, wrapped, instance, args, kwargs, None, span, parent_span, ex,
+                                is_post_exec=False)
+                except Exception as e:
+                    logger.info(f"Warning: Error occurred in hydrate_span pre_process_span: {e}")
+                try:
+                    skip_execution, last_item = SpanHandler.skip_execution(span)
+                    if not skip_execution:
+                        with SpanHandler.workflow_type(to_wrap, span):
+                            async for item in wrapped(*args, **kwargs):
+                                last_item = item
+                                yield item
+                    else:
+                        yield last_item
                 except Exception as e:
                     ex = e
                     raise
                 finally:
                     def post_process_span_internal(ret_val):
-                        post_process_span(handler, to_wrap, wrapped, instance, args, kwargs, ret_val, span, parent_span, ex)
+                        ret_val = post_process_span(handler, to_wrap, wrapped, instance, args, kwargs, ret_val, span, parent_span, ex)
                         if not auto_close_span:
                             span.end()
                     if ex is None and not auto_close_span and to_wrap.get("output_processor") and to_wrap.get("output_processor").get("response_processor"):
                         to_wrap.get("output_processor").get("response_processor")(to_wrap, None, post_process_span_internal)
                     else:
-                        post_process_span_internal(last_item)
+                        last_item = post_process_span_internal(last_item)
     return
 
 async def amonocle_wrapper(tracer: Tracer, handler: SpanHandler, to_wrap, wrapped, instance, source_path, args, kwargs):
@@ -245,7 +301,9 @@ async def amonocle_wrapper(tracer: Tracer, handler: SpanHandler, to_wrap, wrappe
     pre_trace_token = None
     try:
         try:
-            pre_trace_token = handler.pre_tracing(to_wrap, wrapped, instance, args, kwargs)
+            pre_trace_token, alternate_to_wrapp = handler.pre_tracing(to_wrap, wrapped, instance, args, kwargs)
+            if alternate_to_wrapp is not None:
+                to_wrap = alternate_to_wrapp
         except Exception as e:
             logger.info(f"Warning: Error occurred in pre_tracing: {e}")
         if to_wrap.get('skip_span', False) or handler.skip_span(to_wrap, wrapped, instance, args, kwargs):
@@ -271,7 +329,9 @@ async def amonocle_iter_wrapper(tracer: Tracer, handler: SpanHandler, to_wrap, w
     pre_trace_token = None
     try:
         try:
-            pre_trace_token = handler.pre_tracing(to_wrap, wrapped, instance, args, kwargs)
+            pre_trace_token, alternate_to_wrapp = handler.pre_tracing(to_wrap, wrapped, instance, args, kwargs)
+            if alternate_to_wrapp is not None:
+                to_wrap = alternate_to_wrapp
         except Exception as e:
             logger.info(f"Warning: Error occurred in pre_tracing: {e}")
         if to_wrap.get('skip_span', False) or handler.skip_span(to_wrap, wrapped, instance, args, kwargs):
@@ -373,13 +433,14 @@ def evaluate_scope_values(args, kwargs, to_wrap, scope_values):
 @contextmanager
 def start_as_monocle_span(tracer: Tracer, name: str, auto_close_span: bool) -> Iterator["Span"]:
     """ Wrapper to OTEL start_as_current_span to isolate monocle and non monocle spans.
-        This essentiall links monocle and non-monocle spans separately which is default behavior.
+        This essentially links monocle and non-monocle spans separately which is default behavior.
         It can be optionally overridden by setting the environment variable MONOCLE_ISOLATE_SPANS to false.
     """
     if not ISOLATE_MONOCLE_SPANS:
         # If not isolating, use the default start_as_current_span
         yield tracer.start_as_current_span(name, end_on_exit=auto_close_span)
         return
+    
     original_span = get_current_span()
     monocle_span_token = attach(set_span_in_context(get_current_monocle_span()))
     with tracer.start_as_current_span(name, end_on_exit=auto_close_span) as span:
@@ -391,18 +452,26 @@ def start_as_monocle_span(tracer: Tracer, name: str, auto_close_span: bool) -> I
     detach(monocle_span_token)
 
 def get_builtin_scope_names(to_wrap) -> str:
-    output_processor = to_wrap.get("output_processor", None)
-    span_type = output_processor.get("type", None) if output_processor else None
+    output_processor = None
+    if "output_processor" in to_wrap:
+        output_processor = to_wrap.get("output_processor", None)
+    if "output_processor_list" in to_wrap:
+        for processor in to_wrap["output_processor_list"]:
+            if processor.get("type", None) in AGENTIC_SPANS:
+                output_processor = processor
+                break
+
+    span_type = output_processor.get("type", None) if output_processor and isinstance(output_processor, dict) else None
     if span_type and span_type in AGENTIC_SPANS:
         return span_type
     return None
 
-def get_wrapper_with_next_processor(to_wrap, handler, instance, args, kwargs):
+def get_wrapper_with_next_processor(to_wrap, handler, instance, span, parent_span, args, kwargs):
     if has_more_processors(to_wrap):
         next_output_processor_list = to_wrap.get('output_processor_list',[]).copy()
         while len(next_output_processor_list) > 0:
             next_output_processor = next_output_processor_list.pop(0)
-            if handler.should_skip(next_output_processor, instance, args, kwargs):
+            if handler.should_skip(next_output_processor, instance, span, parent_span, args, kwargs):
                 next_output_processor = None
             else:
                 break
@@ -412,4 +481,4 @@ def get_wrapper_with_next_processor(to_wrap, handler, instance, args, kwargs):
     return to_wrap
 
 def has_more_processors(to_wrap) -> bool:
-    return len(to_wrap.get('output_processor_list', [])) > 0
+    return len(to_wrap.get('output_processor_list', [])) > 0

monocle_apptrace/instrumentation/common/wrapper_method.py

@@ -39,6 +39,7 @@ from monocle_apptrace.instrumentation.metamodel.a2a.methods import A2A_CLIENT_ME
 from monocle_apptrace.instrumentation.metamodel.litellm.methods import LITELLM_METHODS
 from monocle_apptrace.instrumentation.metamodel.adk.methods import ADK_METHODS
 from monocle_apptrace.instrumentation.metamodel.mistral.methods import MISTRAL_METHODS
+from monocle_apptrace.instrumentation.metamodel.strands.methods import STRAND_METHODS
 
 class WrapperMethod:
     def __init__(
@@ -111,7 +112,8 @@ DEFAULT_METHODS_LIST = (
     LITELLM_METHODS +
     ADK_METHODS +
     MISTRAL_METHODS +
-    HUGGING_FACE_METHODS
+    HUGGING_FACE_METHODS +
+    STRAND_METHODS
 )
 
 MONOCLE_SPAN_HANDLERS: Dict[str, SpanHandler] = {
@@ -133,5 +135,5 @@ MONOCLE_SPAN_HANDLERS: Dict[str, SpanHandler] = {
     "llamaindex_tool_handler": LlamaIndexToolHandler(),
     "llamaindex_agent_handler": LlamaIndexAgentHandler(),
     "llamaindex_single_agent_tool_handler": LlamaIndexSingleAgenttToolHandlerWrapper(),
-    "lambda_func_handler": lambdaSpanHandler(),
+    "lambda_func_handler": lambdaSpanHandler()
 }

monocle_apptrace/instrumentation/metamodel/a2a/methods.py

@@ -11,7 +11,7 @@ A2A_CLIENT_METHODS = [
     #     "output_processor": A2A_RESOLVE,
     # },
     {
-        "package": "a2a.client.client",
+        "package": "a2a.client",
         "object": "A2AClient",
         "method": "send_message",
         "wrapper_method": atask_wrapper,