monocle-apptrace 0.4.0b1__py3-none-any.whl → 0.4.0b3__py3-none-any.whl

monocle_apptrace/instrumentation/common/constants.py

@@ -14,10 +14,10 @@ GITHUB_CODESPACE_IDENTIFIER_ENV_NAME = "GITHUB_REPOSITORY"
 # Azure naming reference can be found here
 # https://learn.microsoft.com/en-us/azure/cloud-adoption-framework/ready/azure-best-practices/resource-abbreviations
 # https://docs.aws.amazon.com/resource-explorer/latest/userguide/supported-resource-types.html#services-lookoutmetrics
-AZURE_FUNCTION_NAME = "azure.func"
-AZURE_APP_SERVICE_NAME = "azure.asp"
-AZURE_ML_SERVICE_NAME = "azure.mlw"
-AWS_LAMBDA_SERVICE_NAME = "aws.lambda"
+AZURE_FUNCTION_NAME = "azure_func"
+AZURE_APP_SERVICE_NAME = "azure_webapp"
+AZURE_ML_SERVICE_NAME = "azure_ml"
+AWS_LAMBDA_SERVICE_NAME = "aws_lambda"
 GITHUB_CODESPACE_SERVICE_NAME = "github_codespace"
 
 # Env variables to identify infra service type

monocle_apptrace/instrumentation/common/span_handler.py

@@ -42,8 +42,17 @@ class SpanHandler:
     def skip_span(self, to_wrap, wrapped, instance, args, kwargs) -> bool:
         return False
 
-    def skip_processor(self, to_wrap, wrapped, instance, args, kwargs) -> bool:
-        return False
+    def skip_processor(self, to_wrap, wrapped, instance, span, args, kwargs) -> list[str]:
+        return []
+    
+    def set_span_type(self, to_wrap, wrapped, instance, output_processor, span:Span, args, kwargs) -> str:
+        span_type:str = None
+        if 'type' in output_processor:
+            span_type = output_processor['type']
+            span.set_attribute("span.type", span_type)
+        else:
+            logger.warning("type of span not found or incorrect written in entity json")
+        return span_type
 
     def pre_task_processing(self, to_wrap, wrapped, instance, args,kwargs, span):
         if "pipeline" in to_wrap['package']:
@@ -69,30 +78,32 @@ class SpanHandler:
         workflow_name = SpanHandler.get_workflow_name(span=span)
         if workflow_name:
             span.set_attribute("workflow.name", workflow_name)
+        span.set_attribute("span.type", "generic")
 
     def post_task_processing(self, to_wrap, wrapped, instance, args, kwargs, result, span:Span):
-        if span.status.status_code == StatusCode.UNSET:
-            span.set_status(StatusCode.OK)
+        pass
 
-    def hydrate_span(self, to_wrap, wrapped, instance, args, kwargs, result, span) -> bool:
-        detected_error_in_attribute = self.hydrate_attributes(to_wrap, wrapped, instance, args, kwargs, result, span)
-        detected_error_in_event = self.hydrate_events(to_wrap, wrapped, instance, args, kwargs, result, span)
-        if detected_error_in_attribute or detected_error_in_event:
-            span.set_attribute(MONOCLE_DETECTED_SPAN_ERROR, True)
+    def hydrate_span(self, to_wrap, wrapped, instance, args, kwargs, result, span, parent_span = None, ex:Exception = None) -> bool:
+        try:
+            detected_error_in_attribute = self.hydrate_attributes(to_wrap, wrapped, instance, args, kwargs, result, span)
+            detected_error_in_event = self.hydrate_events(to_wrap, wrapped, instance, args, kwargs, result, span, parent_span, ex)
+            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:
+                span.set_status(StatusCode.OK)
 
     def hydrate_attributes(self, to_wrap, wrapped, instance, args, kwargs, result, span:Span) -> bool:
         detected_error:bool = False
         span_index = 0
         if SpanHandler.is_root_span(span):
             span_index = 2 # root span will have workflow and hosting entities pre-populated
-        if not self.skip_processor(to_wrap, wrapped, instance, args, kwargs) and (
-                'output_processor' in to_wrap and to_wrap["output_processor"] is not None):
+        if 'output_processor' in to_wrap and to_wrap["output_processor"] is not None:
             output_processor=to_wrap['output_processor']
-            if 'type' in output_processor:
-                span.set_attribute("span.type", output_processor['type'])
-            else:
-                logger.warning("type of span not found or incorrect written in entity json")
-            if 'attributes' in 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:
                 for processors in output_processor["attributes"]:
                     for processor in processors:
                         attribute = processor.get('attribute')
@@ -113,10 +124,6 @@ class SpanHandler:
                         else:
                             logger.debug(f"{' and '.join([key for key in ['attribute', 'accessor'] if not processor.get(key)])} not found or incorrect in entity JSON")
                     span_index += 1
-            else:
-                logger.debug("attributes not found or incorrect written in entity json")
-        else:
-            span.set_attribute("span.type", "generic")
 
         # set scopes as attributes by calling get_scopes()
         # scopes is a Mapping[str:object], iterate directly with .items()
@@ -127,16 +134,21 @@ 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) -> bool:
+    def hydrate_events(self, to_wrap, wrapped, instance, args, kwargs, ret_result, span, parent_span=None, ex:Exception=None) -> bool:
         detected_error:bool = False
-        if not self.skip_processor(to_wrap, wrapped, instance, args, kwargs) and (
-                'output_processor' in to_wrap and to_wrap["output_processor"] is not None):
+        if 'output_processor' in to_wrap and to_wrap["output_processor"] is not None:
             output_processor=to_wrap['output_processor']
-            arguments = {"instance": instance, "args": args, "kwargs": kwargs, "result": ret_result}
-            if 'events' in output_processor:
+            skip_processors:list[str] = self.skip_processor(to_wrap, wrapped, instance, span, args, kwargs) or []
+
+            arguments = {"instance": instance, "args": args, "kwargs": kwargs, "result": ret_result, "exception":ex}
+            # 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):
                 events = output_processor['events']
                 for event in events:
                     event_name = event.get("name")
+                    if 'events.'+event_name in skip_processors and ex is None:
+                        continue
                     event_attributes = {}
                     attributes = event.get("attributes", [])
                     for attribute in attributes:
@@ -231,7 +243,7 @@ class SpanHandler:
 
     @staticmethod
     @contextmanager
-    def workflow_type(to_wrap=None):
+    def workflow_type(to_wrap=None, span:Span=None):
         token = SpanHandler.attach_workflow_type(to_wrap)
         try:
             yield
@@ -241,6 +253,20 @@ class SpanHandler:
 
 class NonFrameworkSpanHandler(SpanHandler):
 
+    def get_workflow_name_in_progress(self) -> str:
+        return get_value(WORKFLOW_TYPE_KEY)
+
+    def is_framework_span_in_progess(self) -> bool:
+        return self.get_workflow_name_in_progress() in WORKFLOW_TYPE_MAP.values()
+
     # If the language framework is being executed, then skip generating direct openAI attributes and events
-    def skip_processor(self, to_wrap, wrapped, instance, args, kwargs) -> bool:
-        return get_value(WORKFLOW_TYPE_KEY) in WORKFLOW_TYPE_MAP.values()
+    def skip_processor(self, to_wrap, wrapped, instance, span, args, kwargs) -> list[str]:
+        if self.is_framework_span_in_progess():
+            return ["attributes", "events"]
+    
+    def set_span_type(self, to_wrap, wrapped, instance, output_processor, span:Span, args, kwargs) -> str:
+        span_type = super().set_span_type(to_wrap, wrapped, instance, output_processor, span, args, kwargs)
+        if self.is_framework_span_in_progess() and span_type is not None:
+            span_type = span_type+".modelapi"
+            span.set_attribute("span.type", span_type)
+        return span_type

monocle_apptrace/instrumentation/common/utils.py

@@ -236,6 +236,13 @@ def set_scopes_from_baggage(baggage_context:Context):
             scope_name = scope_key[len(MONOCLE_SCOPE_NAME_PREFIX):]
             set_scope(scope_name, scope_value)
 
+def get_parent_span() -> Span:
+    parent_span: Span = None
+    _parent_span_context = get_current()
+    if _parent_span_context is not None and _parent_span_context.get(_SPAN_KEY, None):
+        parent_span = _parent_span_context.get(_SPAN_KEY, None)    
+    return parent_span
+
 def extract_http_headers(headers) -> object:
     global http_scopes
     trace_context:Context = extract(headers, context=get_current())
@@ -362,6 +369,27 @@ def get_llm_type(instance):
     except:
         pass
 
+def get_status(arguments):
+    if arguments['exception'] is not None:
+        return 'error'
+    else:
+        return 'success'
+
+def get_exception_status_code(arguments):
+    if arguments['exception'] is not None and hasattr(arguments['exception'], 'code'):
+        return arguments['exception'].code
+    else:
+        return 'error'
+
+def get_exception_message(arguments):
+    if arguments['exception'] is not None:
+        if hasattr(arguments['exception'], 'message'):
+            return arguments['exception'].message
+        else:
+            return arguments['exception'].__str__()
+    else:
+        return ''
+
 def patch_instance_method(obj, method_name, func):
     """
     Patch a special method (like __iter__) for a single instance.

monocle_apptrace/instrumentation/common/wrapper.py

@@ -9,7 +9,8 @@ from monocle_apptrace.instrumentation.common.utils import (
     set_scopes,
     with_tracer_wrapper,
     set_scope,
-    remove_scope
+    remove_scope,
+    get_parent_span
 )
 from monocle_apptrace.instrumentation.common.constants import WORKFLOW_TYPE_KEY, ADD_NEW_WORKFLOW
 logger = logging.getLogger(__name__)
@@ -30,12 +31,22 @@ def pre_process_span(name, tracer, handler, add_workflow_span, to_wrap, wrapped,
         SpanHandler.set_workflow_properties(span, to_wrap)
     else:
         SpanHandler.set_non_workflow_properties(span)
-        handler.pre_task_processing(to_wrap, wrapped, instance, args, kwargs, span)
+        try:
+            handler.pre_task_processing(to_wrap, wrapped, instance, args, kwargs, span)
+        except Exception as e:
+            logger.info(f"Warning: Error occurred in pre_task_processing: {e}")
 
-def post_process_span(handler, to_wrap, wrapped, instance, args, kwargs, return_value, span):
+def post_process_span(handler, to_wrap, wrapped, instance, args, kwargs, return_value, span, parent_span=None, ex = None):
     if not (SpanHandler.is_root_span(span) or get_value(ADD_NEW_WORKFLOW) == True):
-        handler.hydrate_span(to_wrap, wrapped, instance, args, kwargs, return_value, span)
-        handler.post_task_processing(to_wrap, wrapped, instance, args, kwargs, return_value, span)
+        try:
+            handler.hydrate_span(to_wrap, wrapped, instance, args, kwargs, return_value, span, parent_span, ex)
+        except Exception as e:
+            logger.info(f"Warning: Error occurred in hydrate_span: {e}")
+        
+        try:
+            handler.post_task_processing(to_wrap, wrapped, instance, args, kwargs, return_value, span)
+        except Exception as e:
+            logger.info(f"Warning: Error occurred in post_task_processing: {e}")
 
 def get_span_name(to_wrap, instance):
     if to_wrap.get("span_name"):
@@ -49,44 +60,45 @@ def monocle_wrapper_span_processor(tracer: Tracer, handler: SpanHandler, to_wrap
     name = get_span_name(to_wrap, instance)
     return_value = None
     span_status = None
-    if(get_auto_close_span(to_wrap, kwargs)):
-        with tracer.start_as_current_span(name) as span:
-            pre_process_span(name, tracer, handler, add_workflow_span, to_wrap, wrapped, instance, args, kwargs, span, source_path)
-            
-            if SpanHandler.is_root_span(span) or add_workflow_span:
-                # Recursive call for the actual span
-                return_value, span_status = monocle_wrapper_span_processor(tracer, handler, to_wrap, wrapped, instance, source_path, False, args, kwargs)
-                span.set_status(span_status)
-            else:
-                with SpanHandler.workflow_type(to_wrap):
-                    return_value = wrapped(*args, **kwargs)
-                post_process_span(handler, to_wrap, wrapped, instance, args, kwargs, return_value, span)
-                span_status = span.status
-    else:
-        span = tracer.start_span(name)
-        
+    auto_close_span = get_auto_close_span(to_wrap, kwargs)
+    parent_span = get_parent_span()
+    with tracer.start_as_current_span(name, end_on_exit=auto_close_span) as span:
         pre_process_span(name, tracer, handler, add_workflow_span, to_wrap, wrapped, instance, args, kwargs, span, source_path)
         
-        def post_process_span_internal(ret_val):
-            nonlocal handler, to_wrap, wrapped, instance, args, kwargs, span
-            post_process_span(handler, to_wrap, wrapped, instance, args, kwargs, ret_val, span)
-            span.end()
-                    
-        with SpanHandler.workflow_type(to_wrap):
-            return_value = wrapped(*args, **kwargs)
-        if to_wrap.get("output_processor") and to_wrap.get("output_processor").get("response_processor"):
-            # Process the stream
-            to_wrap.get("output_processor").get("response_processor")(to_wrap, return_value, post_process_span_internal)
-        else: 
-            span.end()
-        span_status = span.status
+        if SpanHandler.is_root_span(span) or add_workflow_span:
+            # Recursive call for the actual span
+            return_value, span_status = monocle_wrapper_span_processor(tracer, handler, to_wrap, wrapped, instance, source_path, False, args, kwargs)
+            span.set_status(span_status)
+            if not auto_close_span:
+                span.end()
+        else:
+            ex:Exception = None
+            try:
+                with SpanHandler.workflow_type(to_wrap, span):
+                    return_value = 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)
+                    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, return_value, post_process_span_internal)
+                else:
+                    post_process_span_internal(return_value)
+            span_status = span.status
     return return_value, span_status
 
 def monocle_wrapper(tracer: Tracer, handler: SpanHandler, to_wrap, wrapped, instance, source_path, args, kwargs):
     return_value = None
     token = None
     try:
-        handler.pre_tracing(to_wrap, wrapped, instance, args, kwargs)
+        try:
+            handler.pre_tracing(to_wrap, wrapped, instance, args, kwargs)
+        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):
             return_value = wrapped(*args, **kwargs)
         else:
@@ -98,45 +110,44 @@ def monocle_wrapper(tracer: Tracer, handler: SpanHandler, to_wrap, wrapped, inst
                 detach(token)
         return return_value
     finally:
-        handler.post_tracing(to_wrap, wrapped, instance, args, kwargs, return_value)
-
+        try:
+            handler.post_tracing(to_wrap, wrapped, instance, args, kwargs, return_value)
+        except Exception as e:
+            logger.info(f"Warning: Error occurred in post_tracing: {e}")
 
 async def amonocle_wrapper_span_processor(tracer: Tracer, handler: SpanHandler, to_wrap, wrapped, instance, source_path, add_workflow_span, args, kwargs):
     # Main span processing logic
     name = get_span_name(to_wrap, instance)
     return_value = None
     span_status = None
-    if(get_auto_close_span(to_wrap, kwargs)):
-        with tracer.start_as_current_span(name) as span:
-            pre_process_span(name, tracer, handler, add_workflow_span, to_wrap, wrapped, instance, args, kwargs, span, source_path)
-            
-            if SpanHandler.is_root_span(span) or add_workflow_span:
-                # Recursive call for the actual span
-                return_value, span_status = await amonocle_wrapper_span_processor(tracer, handler, to_wrap, wrapped, instance, source_path, False, args, kwargs)
-                span.set_status(span_status)
-            else:
-                with SpanHandler.workflow_type(to_wrap):
-                    return_value = await wrapped(*args, **kwargs)
-                span_status = span.status
-            post_process_span(handler, to_wrap, wrapped, instance, args, kwargs, return_value, span)
-    else:
-        span = tracer.start_span(name)
-        
+    auto_close_span = get_auto_close_span(to_wrap, kwargs)
+    parent_span = get_parent_span()
+    with tracer.start_as_current_span(name, end_on_exit=auto_close_span) as span:
         pre_process_span(name, tracer, handler, add_workflow_span, to_wrap, wrapped, instance, args, kwargs, span, source_path)
         
-        def post_process_span_internal(ret_val):
-            nonlocal handler, to_wrap, wrapped, instance, args, kwargs, span
-            post_process_span(handler, to_wrap, wrapped, instance, args, kwargs, ret_val, span)
-            span.end()
-
-        with SpanHandler.workflow_type(to_wrap):
-            return_value = await wrapped(*args, **kwargs)
-           
-        if to_wrap.get("output_processor") and to_wrap.get("output_processor").get("response_processor"):
-            # Process the stream
-            to_wrap.get("output_processor").get("response_processor")(to_wrap, return_value, post_process_span_internal)
-        else: 
-            span.end()
+        if SpanHandler.is_root_span(span) or add_workflow_span:
+            # Recursive call for the actual span
+            return_value, span_status = await amonocle_wrapper_span_processor(tracer, handler, to_wrap, wrapped, instance, source_path, False, args, kwargs)
+            span.set_status(span_status)
+            if not auto_close_span:
+                span.end()
+        else:
+            ex:Exception = None
+            try:
+                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)
+                    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, return_value, post_process_span_internal)
+                else:
+                    post_process_span_internal(return_value)
         span_status = span.status
     return return_value, span.status
 
@@ -144,7 +155,10 @@ async def amonocle_wrapper(tracer: Tracer, handler: SpanHandler, to_wrap, wrappe
     return_value = None
     token = None
     try:
-        handler.pre_tracing(to_wrap, wrapped, instance, args, kwargs)
+        try:
+            handler.pre_tracing(to_wrap, wrapped, instance, args, kwargs)
+        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):
             return_value = await wrapped(*args, **kwargs)
         else:
@@ -156,7 +170,10 @@ async def amonocle_wrapper(tracer: Tracer, handler: SpanHandler, to_wrap, wrappe
                 detach(token)
         return return_value
     finally:
-        handler.post_tracing(to_wrap, wrapped, instance, args, kwargs, return_value)
+        try:
+            handler.post_tracing(to_wrap, wrapped, instance, args, kwargs, return_value)
+        except Exception as e:
+            logger.info(f"Warning: Error occurred in post_tracing: {e}")
 
 @with_tracer_wrapper
 def task_wrapper(tracer: Tracer, handler: SpanHandler, to_wrap, wrapped, instance, source_path, args, kwargs):
@@ -193,7 +210,7 @@ async def ascope_wrapper(tracer: Tracer, handler: SpanHandler, to_wrap, wrapped,
 @with_tracer_wrapper
 def scopes_wrapper(tracer: Tracer, handler: SpanHandler, to_wrap, wrapped, instance, source_path, args, kwargs):
     scope_values = to_wrap.get('scope_values', None)
-    scope_values = evaluate_scope_values(args, kwargs, scope_values)
+    scope_values = evaluate_scope_values(args, kwargs, to_wrap, scope_values)
     token = None
     try:
         if scope_values:
@@ -207,7 +224,7 @@ def scopes_wrapper(tracer: Tracer, handler: SpanHandler, to_wrap, wrapped, insta
 @with_tracer_wrapper
 async def ascopes_wrapper(tracer: Tracer, handler: SpanHandler, to_wrap, wrapped, instance, source_path, args, kwargs):
     scope_values = to_wrap.get('scope_values', None)
-    scope_values = evaluate_scope_values(args, kwargs, scope_values)
+    scope_values = evaluate_scope_values(args, kwargs, to_wrap, scope_values)
     token = None
     try:
         if scope_values:
@@ -218,7 +235,7 @@ async def ascopes_wrapper(tracer: Tracer, handler: SpanHandler, to_wrap, wrapped
         if token:
             remove_scope(token)
 
-def evaluate_scope_values(args, kwargs, scope_values):
+def evaluate_scope_values(args, kwargs, to_wrap, scope_values):
     if callable(scope_values):
         try:
             scope_values = scope_values(args, kwargs)
@@ -227,5 +244,4 @@ def evaluate_scope_values(args, kwargs, scope_values):
             scope_values = None
     if isinstance(scope_values, dict):
         return scope_values
-    return None
-    
+    return None

monocle_apptrace/instrumentation/common/wrapper_method.py

@@ -10,6 +10,7 @@ from monocle_apptrace.instrumentation.metamodel.langchain.methods import (
 from monocle_apptrace.instrumentation.metamodel.llamaindex.methods import (LLAMAINDEX_METHODS, )
 from monocle_apptrace.instrumentation.metamodel.haystack.methods import (HAYSTACK_METHODS, )
 from monocle_apptrace.instrumentation.metamodel.openai.methods import (OPENAI_METHODS,)
+from monocle_apptrace.instrumentation.metamodel.openai._helper import OpenAISpanHandler
 from monocle_apptrace.instrumentation.metamodel.langgraph.methods import LANGGRAPH_METHODS
 from monocle_apptrace.instrumentation.metamodel.flask.methods import (FLASK_METHODS, )
 from monocle_apptrace.instrumentation.metamodel.flask._helper import FlaskSpanHandler, FlaskResponseSpanHandler
@@ -76,5 +77,6 @@ MONOCLE_SPAN_HANDLERS: Dict[str, SpanHandler] = {
     "flask_handler": FlaskSpanHandler(),
     "flask_response_handler": FlaskResponseSpanHandler(),
     "request_handler": RequestSpanHandler(),
-    "non_framework_handler": NonFrameworkSpanHandler()
+    "non_framework_handler": NonFrameworkSpanHandler(),
+    "openai_handler": OpenAISpanHandler(),
 }

monocle_apptrace/instrumentation/metamodel/flask/_helper.py

@@ -70,7 +70,7 @@ class FlaskResponseSpanHandler(SpanHandler):
             if _parent_span_context is not None:
                 parent_span: Span = _parent_span_context.get(_SPAN_KEY, None)
                 if parent_span is not None:
-                    self.hydrate_events(to_wrap, wrapped, instance, args, kwargs, return_value, parent_span)
+                    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)

monocle_apptrace/instrumentation/metamodel/haystack/_helper.py

@@ -121,7 +121,7 @@ def update_span_from_llm_response(response, instance):
     if response is not None and isinstance(response, dict):
         if "meta" in response:
             token_usage = response["meta"][0]["usage"]
-        if "replies" in response:
+        elif "replies" in response:  # and "meta" in response["replies"][0]:
             token_usage = response["replies"][0].meta["usage"]
         if token_usage is not None:
             temperature = instance.__dict__.get("temperature", None)

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

@@ -4,7 +4,7 @@ from monocle_apptrace.instrumentation.metamodel.haystack import (
 from monocle_apptrace.instrumentation.common.utils import get_llm_type
 
 INFERENCE = {
-    "type": "inference",
+    "type": "inference.framework",
     "attributes": [
         [
             {

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

@@ -4,7 +4,7 @@ from monocle_apptrace.instrumentation.metamodel.langchain import (
 from monocle_apptrace.instrumentation.common.utils import resolve_from_alias, get_llm_type
 
 INFERENCE = {
-    "type": "inference",
+    "type": "inference.framework",
     "attributes": [
         [
             {

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

@@ -4,7 +4,7 @@ from monocle_apptrace.instrumentation.metamodel.llamaindex import (
 from monocle_apptrace.instrumentation.common.utils import resolve_from_alias, get_llm_type
 
 INFERENCE = {
-    "type": "inference",
+    "type": "inference.framework",
     "attributes": [
         [
             {

monocle_apptrace/instrumentation/metamodel/openai/_helper.py

@@ -6,11 +6,11 @@ and assistant messages from various input formats.
 import logging
 from monocle_apptrace.instrumentation.common.utils import (
     Option,
-    get_keys_as_tuple,
-    get_nested_value,
     try_option,
+    get_exception_message,
+    get_parent_span
 )
-
+from monocle_apptrace.instrumentation.common.span_handler import NonFrameworkSpanHandler, WORKFLOW_TYPE_MAP
 
 logger = logging.getLogger(__name__)
 
@@ -34,8 +34,11 @@ def extract_messages(kwargs):
         return []
 
 
-def extract_assistant_message(response):
+def extract_assistant_message(arguments):
     try:
+        if arguments["exception"] is not None:
+            return get_exception_message(arguments)
+        response = arguments["result"]
         if hasattr(response,"output_text") and len(response.output_text):
             return response.output_text
         if response is not None and hasattr(response,"choices") and len(response.choices) >0:
@@ -114,4 +117,22 @@ def get_inference_type(instance):
     if inference_type.unwrap_or(None):
         return 'azure_openai'
     else:
-        return 'openai'
+        return 'openai'
+
+class OpenAISpanHandler(NonFrameworkSpanHandler):
+    def is_teams_span_in_progress(self) -> bool:
+        return self.is_framework_span_in_progess() and self.get_workflow_name_in_progress() == WORKFLOW_TYPE_MAP["teams.ai"]
+
+    # If openAI is being called by Teams AI SDK, then retain the metadata part of the span events
+    def skip_processor(self, to_wrap, wrapped, instance, span, args, kwargs) -> list[str]:
+        if self.is_teams_span_in_progress():
+            return ["attributes", "events.data.input", "events.data.output"]
+        else:
+            return super().skip_processor(to_wrap, wrapped, instance, span, args, kwargs)
+
+    def hydrate_events(self, to_wrap, wrapped, instance, args, kwargs, ret_result, span, parent_span=None, ex:Exception=None) -> bool:
+        # If openAI is being called by Teams AI SDK, then copy parent
+        if self.is_teams_span_in_progress() and ex is None:
+            return super().hydrate_events(to_wrap, wrapped, instance, args, kwargs, ret_result, span=parent_span, parent_span=None, ex=ex)
+
+        return super().hydrate_events(to_wrap, wrapped, instance, args, kwargs, ret_result, span, parent_span=parent_span, ex=ex)

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

@@ -8,6 +8,8 @@ from monocle_apptrace.instrumentation.metamodel.openai import (
 from monocle_apptrace.instrumentation.common.utils import (
     patch_instance_method,
     resolve_from_alias,
+    get_status,
+    get_exception_status_code
 )
 
 logger = logging.getLogger(__name__)
@@ -199,8 +201,16 @@ INFERENCE = {
                     "_comment": "this is result from LLM",
                     "attribute": "response",
                     "accessor": lambda arguments: _helper.extract_assistant_message(
-                        arguments["result"]
+                        arguments,
                     ),
+                },
+                {
+                    "attribute": "status",
+                    "accessor": lambda arguments: get_status(arguments)
+                },
+                {
+                    "attribute": "status_code",
+                    "accessor": lambda arguments: get_exception_status_code(arguments)
                 }
             ],
         },

monocle_apptrace/instrumentation/metamodel/openai/methods.py

@@ -12,7 +12,7 @@ OPENAI_METHODS = [
         "object": "Completions",
         "method": "create",
         "wrapper_method": task_wrapper,
-        "span_handler": "non_framework_handler",
+        "span_handler": "openai_handler",
         "output_processor": INFERENCE
     },
     {
@@ -20,7 +20,7 @@ OPENAI_METHODS = [
         "object": "AsyncCompletions",
         "method": "create",
         "wrapper_method": atask_wrapper,
-        "span_handler": "non_framework_handler",
+        "span_handler": "openai_handler",
         "output_processor": INFERENCE
     },
     {
@@ -28,7 +28,7 @@ OPENAI_METHODS = [
         "object": "Embeddings",
         "method": "create",
         "wrapper_method": task_wrapper,
-        "span_handler": "non_framework_handler",
+        "span_handler": "openai_handler",
         "output_processor": RETRIEVAL
     },
     {
@@ -36,7 +36,7 @@ OPENAI_METHODS = [
         "object": "AsyncEmbeddings",
         "method": "create",
         "wrapper_method": atask_wrapper,
-        "span_handler": "non_framework_handler",
+        "span_handler": "openai_handler",
         "output_processor": RETRIEVAL
     },
     {
@@ -44,7 +44,7 @@ OPENAI_METHODS = [
         "object": "Responses",
         "method": "create",
         "wrapper_method": task_wrapper,
-        "span_handler": "non_framework_handler",
+        "span_handler": "openai_handler",
         "output_processor": INFERENCE
     },
     {
@@ -52,7 +52,7 @@ OPENAI_METHODS = [
         "object": "AsyncResponses",
         "method": "create",
         "wrapper_method": atask_wrapper,
-        "span_handler": "non_framework_handler",
+        "span_handler": "openai_handler",
         "output_processor": INFERENCE
     }
 

monocle_apptrace/instrumentation/metamodel/teamsai/_helper.py

@@ -4,6 +4,8 @@ from monocle_apptrace.instrumentation.common.utils import (
     get_keys_as_tuple,
     get_nested_value,
     try_option,
+    get_exception_message,
+    get_exception_status_code
 )
 def capture_input(arguments):
     """
@@ -57,11 +59,41 @@ def capture_prompt_info(arguments):
     except Exception as e:
         return f"Error capturing prompt: {str(e)}"
 
-def status_check(arguments):
-    if hasattr(arguments["result"], "error") and arguments["result"].error is not None:
-        error_msg:str = arguments["result"].error
-        error_code:str = arguments["result"].status if hasattr(arguments["result"], "status") else "unknown"
-        raise MonocleSpanException(f"Error: {error_code} - {error_msg}")
+def get_status_code(arguments):
+    if arguments["exception"] is not None:
+        return get_exception_status_code(arguments)
+    elif hasattr(arguments["result"], "status"):
+        return arguments["result"].status
+    else:
+        return 'success'
+
+def get_status(arguments):
+    if arguments["exception"] is not None:
+        return 'error'
+    elif get_status_code(arguments) == 'success':
+        return 'success'
+    else:
+        return 'error'
+    
+def get_response(arguments) -> str:
+    status = get_status_code(arguments)
+    response:str = ""
+    if status == 'success':
+        if hasattr(arguments["result"], "message"):
+            response = arguments["result"].message.content 
+        else:
+            response = str(arguments["result"])
+    else:
+        if arguments["exception"] is not None:
+            response = get_exception_message(arguments)
+        elif hasattr(arguments["result"], "error"):
+            response = arguments["result"].error
+    return response
+
+def check_status(arguments):
+    status = get_status_code(arguments)
+    if status != 'success':
+        raise MonocleSpanException(f"{status}")   
 
 def extract_provider_name(instance):
     provider_url: Option[str] = try_option(getattr, instance._client.base_url, 'host')

monocle_apptrace/instrumentation/metamodel/teamsai/entities/inference/actionplanner_output_processor.py

@@ -28,42 +28,22 @@ ACTIONPLANNER_OUTPUT_PROCESSOR = {
             {
                 "attribute": "tokenizer",
                 "accessor": lambda arguments: arguments["instance"]._options.tokenizer.__class__.__name__ if hasattr(arguments["instance"], "_options") else "GPTTokenizer"
+            },
+            {
+                "attribute": "prompt_name",
+                "accessor": _helper.capture_prompt_info
+            },
+            {
+                "attribute": "validator",
+                "accessor": lambda arguments: arguments["kwargs"].get("validator").__class__.__name__ if arguments.get("kwargs", {}).get("validator") else "DefaultResponseValidator"
+            },
+            {
+                "attribute": "memory_type",
+                "accessor": lambda arguments: arguments["kwargs"].get("memory").__class__.__name__ if arguments.get("kwargs", {}).get("memory") else "unknown"
             }
         ]
     ],
     "events": [
-        {
-            "name": "data.input",
-            "_comment": "input configuration to ActionPlanner",
-            "attributes": [
-                {
-                    "attribute": "prompt_name",
-                    "accessor": _helper.capture_prompt_info
-                },
-                {
-                    "attribute": "validator",
-                    "accessor": lambda arguments: arguments["kwargs"].get("validator").__class__.__name__ if arguments.get("kwargs", {}).get("validator") else "DefaultResponseValidator"
-                },
-                {
-                    "attribute": "memory_type",
-                    "accessor": lambda arguments: arguments["kwargs"].get("memory").__class__.__name__ if arguments.get("kwargs", {}).get("memory") else "unknown"
-                }
-            ]
-        },
-        {
-            "name": "data.output",
-            "_comment": "output from ActionPlanner",
-            "attributes": [
-                {
-                    "attribute": "status",
-                    "accessor": lambda arguments: _helper.status_check(arguments)
-                },
-                {
-                    "attribute": "response",
-                    "accessor": lambda arguments: arguments["result"].message.content if hasattr(arguments["result"], "message") else str(arguments["result"])
-                }
-            ]
-        },
         {
             "name": "metadata",
             "attributes": [

monocle_apptrace/instrumentation/metamodel/teamsai/entities/inference/teamsai_output_processor.py

@@ -3,7 +3,7 @@ from monocle_apptrace.instrumentation.metamodel.teamsai import (
 )
 from monocle_apptrace.instrumentation.common.utils import get_llm_type
 TEAMAI_OUTPUT_PROCESSOR = {
-    "type": "inference",
+    "type": "inference.framework",
     "attributes": [
         [
             {
@@ -52,25 +52,23 @@ TEAMAI_OUTPUT_PROCESSOR = {
             "name": "data.output",
             "_comment": "output from Teams AI",
             "attributes": [
+                {
+                    "attribute": "status",
+                    "accessor": lambda arguments: _helper.get_status(arguments)
+                },
+                {
+                    "attribute": "status_code",
+                    "accessor": lambda arguments: _helper.get_status_code(arguments)
+                },
                 {
                     "attribute": "response",
-                    "accessor": lambda arguments: arguments["result"].message.content if hasattr(arguments["result"], "message") else str(arguments["result"])
+                    "accessor": lambda arguments: _helper.get_response(arguments)
+                },
+                {
+                    "attribute": "check_status",
+                    "accessor": lambda arguments: _helper.check_status(arguments)
                 }
             ]
         },
-        # {
-        #     "name": "metadata",
-        #     "attributes": [
-        #         {
-        #             "_comment": "metadata from Teams AI response",
-        #             "accessor": lambda arguments: {
-        #                 "prompt_tokens": arguments["result"].get("usage", {}).get("prompt_tokens", 0),
-        #                 "completion_tokens": arguments["result"].get("usage", {}).get("completion_tokens", 0),
-        #                 "total_tokens": arguments["result"].get("usage", {}).get("total_tokens", 0),
-        #                 "latency_ms": arguments.get("latency_ms")
-        #             }
-        #         }
-        #     ]
-        # }
     ]
 }

{monocle_apptrace-0.4.0b1.dist-info → monocle_apptrace-0.4.0b3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: monocle_apptrace
-Version: 0.4.0b1
+Version: 0.4.0b3
 Summary: package with monocle genAI tracing
 Project-URL: Homepage, https://github.com/monocle2ai/monocle
 Project-URL: Issues, https://github.com/monocle2ai/monocle/issues
@@ -16,40 +16,44 @@ Requires-Dist: opentelemetry-sdk>=1.21.0
 Requires-Dist: requests
 Requires-Dist: wrapt>=1.14.0
 Provides-Extra: aws
-Requires-Dist: boto3==1.35.19; extra == 'aws'
+Requires-Dist: boto3==1.37.24; extra == 'aws'
 Provides-Extra: azure
 Requires-Dist: azure-storage-blob==12.22.0; extra == 'azure'
 Provides-Extra: dev
-Requires-Dist: anthropic==0.49.0; extra == 'dev'
+Requires-Dist: anthropic-haystack; extra == 'dev'
+Requires-Dist: anthropic==0.52.0; extra == 'dev'
 Requires-Dist: azure-storage-blob==12.22.0; extra == 'dev'
-Requires-Dist: boto3==1.34.131; extra == 'dev'
-Requires-Dist: chromadb==0.4.22; extra == 'dev'
+Requires-Dist: boto3==1.37.24; extra == 'dev'
+Requires-Dist: chromadb==1.0.10; extra == 'dev'
 Requires-Dist: datasets==2.20.0; extra == 'dev'
 Requires-Dist: faiss-cpu==1.8.0; extra == 'dev'
 Requires-Dist: flask; extra == 'dev'
 Requires-Dist: haystack-ai==2.3.0; extra == 'dev'
 Requires-Dist: instructorembedding==1.0.1; extra == 'dev'
-Requires-Dist: langchain-aws==0.1.10; extra == 'dev'
-Requires-Dist: langchain-chroma==0.1.1; extra == 'dev'
-Requires-Dist: langchain-community==0.2.5; extra == 'dev'
-Requires-Dist: langchain-mistralai==0.1.13; extra == 'dev'
-Requires-Dist: langchain-openai==0.1.8; extra == 'dev'
-Requires-Dist: langchain==0.2.5; extra == 'dev'
+Requires-Dist: langchain-anthropic==0.3.13; extra == 'dev'
+Requires-Dist: langchain-aws==0.2.23; extra == 'dev'
+Requires-Dist: langchain-chroma==0.2.4; extra == 'dev'
+Requires-Dist: langchain-community==0.3.24; extra == 'dev'
+Requires-Dist: langchain-mistralai==0.2.10; extra == 'dev'
+Requires-Dist: langchain-openai==0.3.18; extra == 'dev'
+Requires-Dist: langchain==0.3.25; extra == 'dev'
 Requires-Dist: langchainhub==0.1.21; extra == 'dev'
 Requires-Dist: langgraph==0.2.68; extra == 'dev'
-Requires-Dist: llama-index-embeddings-huggingface==0.2.0; extra == 'dev'
-Requires-Dist: llama-index-llms-azure-openai==0.1.9; extra == 'dev'
-Requires-Dist: llama-index-llms-mistralai==0.1.20; extra == 'dev'
-Requires-Dist: llama-index-vector-stores-chroma==0.1.9; extra == 'dev'
-Requires-Dist: llama-index-vector-stores-opensearch==0.1.10; extra == 'dev'
-Requires-Dist: llama-index==0.10.30; extra == 'dev'
+Requires-Dist: llama-index-embeddings-huggingface==0.5.4; extra == 'dev'
+Requires-Dist: llama-index-llms-anthropic==0.6.19; extra == 'dev'
+Requires-Dist: llama-index-llms-azure-openai==0.3.2; extra == 'dev'
+Requires-Dist: llama-index-llms-mistralai==0.4.0; extra == 'dev'
+Requires-Dist: llama-index-vector-stores-chroma==0.4.1; extra == 'dev'
+Requires-Dist: llama-index-vector-stores-opensearch==0.5.4; extra == 'dev'
+Requires-Dist: llama-index==0.12.37; extra == 'dev'
 Requires-Dist: mistral-haystack==0.0.2; extra == 'dev'
 Requires-Dist: numpy==1.26.4; extra == 'dev'
 Requires-Dist: opendal==0.45.14; extra == 'dev'
 Requires-Dist: opensearch-haystack==1.2.0; extra == 'dev'
 Requires-Dist: opentelemetry-instrumentation-flask; extra == 'dev'
 Requires-Dist: parameterized==0.9.0; extra == 'dev'
-Requires-Dist: pytest==8.0.0; extra == 'dev'
+Requires-Dist: pytest-asyncio==0.26.0; extra == 'dev'
+Requires-Dist: pytest==8.3.5; extra == 'dev'
 Requires-Dist: requests-aws4auth==1.2.3; extra == 'dev'
 Requires-Dist: sentence-transformers==2.6.1; extra == 'dev'
 Requires-Dist: types-requests==2.31.0.20240106; extra == 'dev'

{monocle_apptrace-0.4.0b1.dist-info → monocle_apptrace-0.4.0b3.dist-info}/RECORD

@@ -12,13 +12,13 @@ monocle_apptrace/exporters/azure/blob_exporter_opendal.py,sha256=wQUtciyFMD28tpW
 monocle_apptrace/exporters/okahu/okahu_exporter.py,sha256=wFkHd87nOXzFMRejrUiO6N0mNIWkxAyRzob6o82lr_c,4765
 monocle_apptrace/instrumentation/__init__.py,sha256=oa412OuokRm9Vf3XlCJLqpZjz9ZcuxAKxnEBvOK7u2M,21
 monocle_apptrace/instrumentation/common/__init__.py,sha256=oNEcgw4N36_XzPeN1gc7wxhPjVg-Vhh8EjvUIQZ7pDM,224
-monocle_apptrace/instrumentation/common/constants.py,sha256=14-y6MpJ48NEjUickDlbeHPBXcBdxs2gBVei1aGuGUk,3206
+monocle_apptrace/instrumentation/common/constants.py,sha256=XxxPUg0tQGQLM12Z3yzLa-shgU8ZZwlAGsFg9MT7mao,3208
 monocle_apptrace/instrumentation/common/instrumentor.py,sha256=CwQT1oiPyzv_xe8HhdOH7Ucmd18r2Wk3ortOTx6bhpQ,16324
-monocle_apptrace/instrumentation/common/span_handler.py,sha256=9GOV8Q0xiG25qEOhA60K0kLESp8_jnRk8lsjnGKBlgg,11737
+monocle_apptrace/instrumentation/common/span_handler.py,sha256=Js6RBb6pT-GtlAYSlsVIQC2YBar7IKj6SPNF9cqOQ3U,13228
 monocle_apptrace/instrumentation/common/tracing.md,sha256=6Lr8QGxEFHKhj-mMvLV3xjFnplKSs6HEdwl0McPK47M,7577
-monocle_apptrace/instrumentation/common/utils.py,sha256=SVOQTnucdYiGbpSxeoY8Y6DXXmY58vEeL21OPVRjhPo,13032
-monocle_apptrace/instrumentation/common/wrapper.py,sha256=IK_Y3qOhAAGH_D1jWZClbvhb0x7SK1zlKTvO1ewahNU,10684
-monocle_apptrace/instrumentation/common/wrapper_method.py,sha256=tty1JdGGF8VnzWeo2rcwvh-ppUgNdNs-CbGOJn7sjN8,3881
+monocle_apptrace/instrumentation/common/utils.py,sha256=oPyUdfBwRCWuxapjtxTd-L4h1Mr6mCDvhSs3do8p0z8,13928
+monocle_apptrace/instrumentation/common/wrapper.py,sha256=NZC0xymn2q6_bFK0d91F0Z-W-YoCmIjOZEm1t1XKSY4,11409
+monocle_apptrace/instrumentation/common/wrapper_method.py,sha256=ig98if45QDU-N76uNAxcb1O7xL8YpwtxJLcb5Dh71bc,4013
 monocle_apptrace/instrumentation/metamodel/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 monocle_apptrace/instrumentation/metamodel/aiohttp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 monocle_apptrace/instrumentation/metamodel/aiohttp/_helper.py,sha256=h-zrif2vgPL9JbCf1eKHbKBYHAxMdHxOdY-soIDGti8,2361
@@ -36,20 +36,20 @@ monocle_apptrace/instrumentation/metamodel/botocore/entities/__init__.py,sha256=
 monocle_apptrace/instrumentation/metamodel/botocore/entities/inference.py,sha256=rAsvhRIR9XYGd8NHTFDJQuiQSTzFoZ4oKeA6kEhK0QQ,2363
 monocle_apptrace/instrumentation/metamodel/botocore/handlers/botocore_span_handler.py,sha256=8FSdoQSS6DuowF7KHhCRj5kpxYF-bBNR47W1tB-gVh0,1433
 monocle_apptrace/instrumentation/metamodel/flask/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-monocle_apptrace/instrumentation/metamodel/flask/_helper.py,sha256=Z0mBGDXP_-DccbCmcyYrXJe4m5JZ1Al-Kfg6582bCa4,3082
+monocle_apptrace/instrumentation/metamodel/flask/_helper.py,sha256=seLVsL5gE3GbjY3Yetgg1WnswhDzb0zEQR05fHf5xTM,3094
 monocle_apptrace/instrumentation/metamodel/flask/methods.py,sha256=dWCMEDk-HWHiD0vlMoAVYbIFclstmVkUpRrCtqDWyFE,739
 monocle_apptrace/instrumentation/metamodel/flask/entities/http.py,sha256=wIudpNk6-DY72k0p90XtvjKt8BilvOd-87Q2iqJnWa8,1525
 monocle_apptrace/instrumentation/metamodel/haystack/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-monocle_apptrace/instrumentation/metamodel/haystack/_helper.py,sha256=47dGZqz1HCe7jj15a-p4UAcRmq1JnzQ7Ijc_RNWMt6g,5396
+monocle_apptrace/instrumentation/metamodel/haystack/_helper.py,sha256=HjPZUA9K2dPUcQQNzMN3jX8UV0OHF9N7tQ6kSl1OvxM,5439
 monocle_apptrace/instrumentation/metamodel/haystack/methods.py,sha256=Zd70ycMQ5qWsjPXnQL6qoThNKrQA80P6t11sFyEbQR4,1585
 monocle_apptrace/instrumentation/metamodel/haystack/entities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-monocle_apptrace/instrumentation/metamodel/haystack/entities/inference.py,sha256=p8zemjFl4kNoDGlOj3PImHQ7imOOjqvYPkVRcQlIU5c,3207
+monocle_apptrace/instrumentation/metamodel/haystack/entities/inference.py,sha256=FzUg66WRYAcPbWqdq8iqfv7inkry9L_MrC1o5wd96bg,3217
 monocle_apptrace/instrumentation/metamodel/haystack/entities/retrieval.py,sha256=nq3lsk2qFxXqwrAHsBt8zrh4ZVGAJABkPtylrjUCCqc,2357
 monocle_apptrace/instrumentation/metamodel/langchain/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 monocle_apptrace/instrumentation/metamodel/langchain/_helper.py,sha256=CziW8KUmRqGCi_y2fcC9YMsP2wP11OMUitqKupSXStg,5315
 monocle_apptrace/instrumentation/metamodel/langchain/methods.py,sha256=sQLrji0NLuG8i8q5UdbgzPUjWh_WmromfvWL3pGZdCk,2941
 monocle_apptrace/instrumentation/metamodel/langchain/entities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-monocle_apptrace/instrumentation/metamodel/langchain/entities/inference.py,sha256=2CNHloheb4LG7rPEUIF3E3M1cuc8CWVZf9J6l_hvK1E,2764
+monocle_apptrace/instrumentation/metamodel/langchain/entities/inference.py,sha256=RrLPoYLfn3AB9-siwo1NFLT2aPDJtJm9Hgoj6ad2S7Y,2774
 monocle_apptrace/instrumentation/metamodel/langchain/entities/retrieval.py,sha256=r4UqTCT5vOfkbz9lwoTRoiMkUUJtPMwqOYbqo53A6K8,2039
 monocle_apptrace/instrumentation/metamodel/langgraph/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 monocle_apptrace/instrumentation/metamodel/langgraph/_helper.py,sha256=-XmAbhkgqwaunFZa-BP0zWZ3e-uD-ihSszbn5Cz75yc,2043
@@ -61,27 +61,27 @@ monocle_apptrace/instrumentation/metamodel/llamaindex/_helper.py,sha256=1Rq2sfoL
 monocle_apptrace/instrumentation/metamodel/llamaindex/methods.py,sha256=p2mDYF_Izgz9M919n3Do5tlc5XRAZt_rnkFRqqIO5yo,3001
 monocle_apptrace/instrumentation/metamodel/llamaindex/entities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 monocle_apptrace/instrumentation/metamodel/llamaindex/entities/agent.py,sha256=g7IEwFMLjYvxljX7iHoYSPJW6k-wC7Z3i_y2qlNEZcs,1338
-monocle_apptrace/instrumentation/metamodel/llamaindex/entities/inference.py,sha256=Hich1AoEHnCUvh0MIISNOjbH9t71eex_IsY_4j3JN5U,2727
+monocle_apptrace/instrumentation/metamodel/llamaindex/entities/inference.py,sha256=XJI6CbGdsogQLQC41KEJqkRe1THEN_vu8pA_H5RGNww,2737
 monocle_apptrace/instrumentation/metamodel/llamaindex/entities/retrieval.py,sha256=QBF1nrqog5KHh925jiY2V-kejL6iVLKUowZmqUDoiJ4,1870
 monocle_apptrace/instrumentation/metamodel/openai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-monocle_apptrace/instrumentation/metamodel/openai/_helper.py,sha256=G_2-FafJGjTY0lU5OXQFNGCP2Z7OmgUMbTgNa37AVec,4256
-monocle_apptrace/instrumentation/metamodel/openai/methods.py,sha256=gH8ZFN_x1nRM45F4FUVqoj9dao52247MSgOCxtzCpmA,1838
+monocle_apptrace/instrumentation/metamodel/openai/_helper.py,sha256=KmW1Xbrfw1aWsXrRGtF6bAd2TjblU5i2-X0KVMYHS5M,5682
+monocle_apptrace/instrumentation/metamodel/openai/methods.py,sha256=jpqZyfiJbzMz1r3W3fwMCGiQsbiDSkhqgADJextGxFQ,1796
 monocle_apptrace/instrumentation/metamodel/openai/entities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-monocle_apptrace/instrumentation/metamodel/openai/entities/inference.py,sha256=JV6favZumCWBx5GCgirQ-txACeOGzb8N_-SZdSY0nOE,7910
+monocle_apptrace/instrumentation/metamodel/openai/entities/inference.py,sha256=8UdUnKnQsWFPsrKnhNYVRM5ZAMFQl_PZlh67QC_wQ0k,8271
 monocle_apptrace/instrumentation/metamodel/openai/entities/retrieval.py,sha256=LU7aec302ZqPrs9MzFWU-JTnhK8OpYfgQKMmktlD6-8,1457
 monocle_apptrace/instrumentation/metamodel/requests/__init__.py,sha256=mg04UgoPzzcH-cPOahYUqN9T-TolZyOZipnBwDg5TP8,250
 monocle_apptrace/instrumentation/metamodel/requests/_helper.py,sha256=GS03VbT9LiGwt4Mz2DPHtxuWd3xhQL4liS9-dfpy9SE,1985
 monocle_apptrace/instrumentation/metamodel/requests/methods.py,sha256=O7lkglRvV97zqnCu6r2JwvW8WQqi4uvlpmNkAPpXigE,440
 monocle_apptrace/instrumentation/metamodel/requests/entities/http.py,sha256=TlY4NZtPleewbF5W0qV61L2ByDOf44EOZhKQgwzRIKc,1669
 monocle_apptrace/instrumentation/metamodel/teamsai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-monocle_apptrace/instrumentation/metamodel/teamsai/_helper.py,sha256=cfay3DXm_JuUgHTfXpJYnY-9xIMH6CURTiQLl9FfMzc,2970
+monocle_apptrace/instrumentation/metamodel/teamsai/_helper.py,sha256=mrN-AQ0Nn59_jKidyvibP76JI17SdVFAdpBw_ouuu2U,3821
 monocle_apptrace/instrumentation/metamodel/teamsai/methods.py,sha256=i0Rz6Gn_Skey9uuCtJftNfMjGBbMMhuMMQcx7TPYQXU,2214
 monocle_apptrace/instrumentation/metamodel/teamsai/entities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 monocle_apptrace/instrumentation/metamodel/teamsai/entities/inference/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-monocle_apptrace/instrumentation/metamodel/teamsai/entities/inference/actionplanner_output_processor.py,sha256=Xh7rRKllIMCvP6sMBZBXP-CP9ERm_Wg4KD2bVRif6vA,3166
-monocle_apptrace/instrumentation/metamodel/teamsai/entities/inference/teamsai_output_processor.py,sha256=nCCqR1H57wL5vuYA2IQQembQjXVGTiBOiom7MEp06dU,2987
-monocle_apptrace-0.4.0b1.dist-info/METADATA,sha256=s6ad8nexvx3FSZ55HSdPsJpnYBXamEvjMozxUYM2CfU,6363
-monocle_apptrace-0.4.0b1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-monocle_apptrace-0.4.0b1.dist-info/licenses/LICENSE,sha256=ay9trLiP5I7ZsFXo6AqtkLYdRqe5S9r-DrPOvsNlZrg,9136
-monocle_apptrace-0.4.0b1.dist-info/licenses/NOTICE,sha256=9jn4xtwM_uUetJMx5WqGnhrR7MIhpoRlpokjSTlyt8c,112
-monocle_apptrace-0.4.0b1.dist-info/RECORD,,
+monocle_apptrace/instrumentation/metamodel/teamsai/entities/inference/actionplanner_output_processor.py,sha256=6rb75bFKh_hvgD8dJzcIeXeJjLjhm9nXuxHI3F-icqo,2405
+monocle_apptrace/instrumentation/metamodel/teamsai/entities/inference/teamsai_output_processor.py,sha256=M5uPEbP5c57txrd7BDRXhK5rvRJfyNyvqavtkXuPjXU,2738
+monocle_apptrace-0.4.0b3.dist-info/METADATA,sha256=pJPcqamcOsIMTK6Zhv0JCm57OQu0cJ6gxfZ8HxLjhJs,6592
+monocle_apptrace-0.4.0b3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+monocle_apptrace-0.4.0b3.dist-info/licenses/LICENSE,sha256=ay9trLiP5I7ZsFXo6AqtkLYdRqe5S9r-DrPOvsNlZrg,9136
+monocle_apptrace-0.4.0b3.dist-info/licenses/NOTICE,sha256=9jn4xtwM_uUetJMx5WqGnhrR7MIhpoRlpokjSTlyt8c,112
+monocle_apptrace-0.4.0b3.dist-info/RECORD,,