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

monocle_apptrace/exporters/file_exporter.py

@@ -14,12 +14,13 @@ from monocle_apptrace.exporters.exporter_processor import ExportTaskProcessor
 DEFAULT_FILE_PREFIX:str = "monocle_trace_"
 DEFAULT_TIME_FORMAT:str = "%Y-%m-%d_%H.%M.%S"
 HANDLE_TIMEOUT_SECONDS: int = 60  # 1 minute timeout
+DEFAULT_TRACE_FOLDER = ".monocle"
 
 class FileSpanExporter(SpanExporterBase):
     def __init__(
         self,
         service_name: Optional[str] = None,
-        out_path:str = ".",
+        out_path:str = path.join(".", DEFAULT_TRACE_FOLDER),
         file_prefix = DEFAULT_FILE_PREFIX,
         time_format = DEFAULT_TIME_FORMAT,
         formatter: Callable[
@@ -34,12 +35,16 @@ class FileSpanExporter(SpanExporterBase):
         self.formatter = formatter
         self.service_name = service_name
         self.output_path = os.getenv("MONOCLE_TRACE_OUTPUT_PATH", out_path)
+        if not os.path.exists(self.output_path):
+            os.makedirs(self.output_path)
         self.file_prefix = file_prefix
         self.time_format = time_format
         self.task_processor = task_processor
         self.is_first_span_in_file = True  # Track if this is the first span in the current file
         if self.task_processor is not None:
             self.task_processor.start()
+        self.last_file_processed:str = None
+        self.last_trace_id = None
 
     def export(self, spans: Sequence[ReadableSpan]) -> SpanExportResult:
         is_root_span = any(not span.parent for span in spans)
@@ -96,6 +101,8 @@ class FileSpanExporter(SpanExporterBase):
                 print(f"Error closing file {file_path}: {e}")
             finally:
                 del self.file_handles[trace_id]
+                self.last_file_processed = file_path
+                self.last_trace_id = trace_id
 
     def _mark_span_written(self, trace_id: int) -> None:
         """Mark that a span has been written for this trace (no longer first span)."""

monocle_apptrace/instrumentation/common/span_handler.py

@@ -26,6 +26,7 @@ WORKFLOW_TYPE_MAP = {
     "anthropic": "workflow.anthropic",
     "gemini": "workflow.gemini",
     "litellm": "workflow.litellm",
+    "mistralai": "workflow.mistral"
 }
 
 FRAMEWORK_WORKFLOW_LIST = [
@@ -185,7 +186,12 @@ class SpanHandler:
                         accessor = attribute.get("accessor")
                         if accessor:
                             try:
-                                result = accessor(arguments)
+                                try:
+                                    result = accessor(arguments)
+                                except MonocleSpanException as e:
+                                    span.set_status(StatusCode.ERROR, e.message)
+                                    detected_error = True
+                                    result = e.get_err_code()
                                 if result and isinstance(result, dict):
                                     result = dict((key, value) for key, value in result.items() if value is not None)
                                 if result and isinstance(result, (int, str, list, dict)):
@@ -193,9 +199,6 @@ class SpanHandler:
                                         event_attributes[attribute_key] = result
                                     else:
                                         event_attributes.update(result)
-                            except MonocleSpanException as e:
-                                span.set_status(StatusCode.ERROR, e.message)
-                                detected_error = True
                             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)

monocle_apptrace/instrumentation/common/utils.py

@@ -30,7 +30,7 @@ except Exception as e:
     logger.warning("Exception finding monocle-apptrace version.")
 
 class MonocleSpanException(Exception):
-    def __init__(self, err_message:str):
+    def __init__(self, err_message:str, err_code:str = None):
         """
         Monocle exeption to indicate error in span processing.        
         Parameters:
@@ -39,10 +39,15 @@ class MonocleSpanException(Exception):
         """
         super().__init__(err_message)
         self.message = err_message
+        self.err_code = err_code
 
     def __str__(self):
         """String representation of the exception."""
-        return f"[Monocle Span Error: {self.message} {self.status}"
+        return f"[Monocle Span Error: {self.message}"
+
+    def get_err_code(self):
+        """Retrieve the error code."""
+        return self.err_code
 
 def set_span_attribute(span, name, value):
     if value is not None:
@@ -98,6 +103,7 @@ def with_tracer_wrapper(func):
 
     return _with_tracer
 
+
 def resolve_from_alias(my_map, alias):
     """Find a alias that is not none from list of aliases"""
 
@@ -393,6 +399,7 @@ def get_exception_message(arguments):
     else:
         return ''
 
+
 def get_error_message(arguments):
     status_code = get_status_code(arguments)
     if status_code == 'success':
@@ -400,6 +407,7 @@ def get_error_message(arguments):
     else:
         return status_code
 
+
 def get_status_code(arguments):
     if arguments["exception"] is not None:
         return get_exception_status_code(arguments)

monocle_apptrace/instrumentation/common/wrapper_method.py

@@ -37,6 +37,7 @@ from monocle_apptrace.instrumentation.metamodel.mcp.mcp_processor import MCPAgen
 from monocle_apptrace.instrumentation.metamodel.a2a.methods import A2A_CLIENT_METHODS
 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
 
 class WrapperMethod:
     def __init__(
@@ -107,7 +108,8 @@ DEFAULT_METHODS_LIST = (
     MCP_METHODS + 
     A2A_CLIENT_METHODS +
     LITELLM_METHODS +
-    ADK_METHODS
+    ADK_METHODS +
+    MISTRAL_METHODS
 )
 
 MONOCLE_SPAN_HANDLERS: Dict[str, SpanHandler] = {

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

@@ -1,4 +1,5 @@
 from monocle_apptrace.instrumentation.common.constants import SPAN_SUBTYPES, SPAN_TYPES
+from monocle_apptrace.instrumentation.common.utils import get_error_message
 from monocle_apptrace.instrumentation.metamodel.adk import _helper
 AGENT = {
       "type": SPAN_TYPES.AGENTIC_INVOCATION,
@@ -45,6 +46,10 @@ AGENT = {
                 "_comment": "this is response from LLM",
                 "attribute": "response",
                 "accessor": lambda arguments: _helper.extract_agent_response(arguments['result'])
+            },
+            {
+                "attribute": "error_code",
+                "accessor": lambda arguments: get_error_message(arguments)
             }
           ]
         }
@@ -108,4 +113,4 @@ DELEGATION = {
               }
         ]
       ]
-}
+}

monocle_apptrace/instrumentation/metamodel/adk/entities/tool.py

@@ -1,4 +1,5 @@
 from monocle_apptrace.instrumentation.common.constants import SPAN_SUBTYPES, SPAN_TYPES
+from monocle_apptrace.instrumentation.common.utils import get_error_message
 from monocle_apptrace.instrumentation.metamodel.adk import _helper
 TOOL = {
       "type": SPAN_TYPES.AGENTIC_TOOL_INVOCATION,
@@ -40,7 +41,7 @@ TOOL = {
           "attributes": [
             {
                 "_comment": "this is Tool input",
-                "attribute": "Inputs",
+                "attribute": "input",
                 "accessor": lambda arguments: _helper.extract_tool_input(arguments) 
             },
           ]
@@ -52,8 +53,12 @@ TOOL = {
                 "_comment": "this is response from Tool",
                 "attribute": "response",
                 "accessor": lambda arguments: _helper.extract_tool_response(arguments['result'])
-            }
+            },
+            {
+                "attribute": "error_code",
+                "accessor": lambda arguments: get_error_message(arguments)
+            },
           ]
         }
       ]
-}
+}

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

@@ -1,4 +1,5 @@
 from monocle_apptrace.instrumentation.common.constants import AGENT_REQUEST_SPAN_NAME, SPAN_SUBTYPES, SPAN_TYPES
+from monocle_apptrace.instrumentation.common.utils import get_error_message
 from monocle_apptrace.instrumentation.metamodel.agents import _helper
 
 AGENT = {
@@ -50,6 +51,10 @@ AGENT = {
                     "accessor": lambda arguments: _helper.extract_agent_response(
                         arguments["result"]
                     ),
+            },
+            {
+                "attribute": "error_code",
+                "accessor": lambda arguments: get_error_message(arguments)
                 }
             ],
         },
@@ -101,8 +106,11 @@ AGENT_REQUEST = {
                     "accessor": lambda arguments: _helper.extract_agent_response(
                         arguments["result"]
                     ),
-                }
-            ],
+            },
+            {
+                "attribute": "error_code",
+                "accessor": lambda arguments: get_error_message(arguments)
+            }],
         },
     ],
 }
@@ -151,7 +159,7 @@ TOOLS = {
             "attributes": [
                 {
                     "_comment": "this is Tool input",
-                    "attribute": "Inputs",
+                    "attribute": "input",
                     "accessor": lambda arguments: _helper.extract_tool_input(arguments),
                 },
             ],
@@ -165,6 +173,10 @@ TOOLS = {
                     "accessor": lambda arguments: _helper.extract_tool_response(
                         arguments["result"]
                     ),
+                },
+                {
+                "attribute": "error_code",
+                "accessor": lambda arguments: get_error_message(arguments)
                 }
             ],
         },

monocle_apptrace/instrumentation/metamodel/aiohttp/_helper.py

@@ -1,6 +1,6 @@
 import logging
 from threading import local
-from monocle_apptrace.instrumentation.common.utils import extract_http_headers, clear_http_scopes, try_option, Option, MonocleSpanException
+from monocle_apptrace.instrumentation.common.utils import extract_http_headers, clear_http_scopes, get_exception_status_code, try_option, Option, MonocleSpanException
 from monocle_apptrace.instrumentation.common.span_handler import SpanHandler
 from monocle_apptrace.instrumentation.common.constants import HTTP_SUCCESS_CODES
 from urllib.parse import unquote
@@ -8,7 +8,7 @@ from urllib.parse import unquote
 logger = logging.getLogger(__name__)
 MAX_DATA_LENGTH = 1000
 
-def get_route(args) -> str:
+def get_url(args) -> str:
     route_path: Option[str] = try_option(getattr, args[0], 'path')
     return route_path.unwrap_or("")
 
@@ -31,11 +31,17 @@ def extract_response(result) -> str:
         response = ""
     return response
 
-def extract_status(result) -> str:
-    status = f"{result.status}" if hasattr(result, 'status') else ""
-    if status not in HTTP_SUCCESS_CODES:
-        error_message = extract_response(result)
-        raise MonocleSpanException(f"error: {status} - {error_message}")
+def extract_status(arguments) -> str:
+    if arguments["exception"] is not None:
+        return get_exception_status_code(arguments)
+    result = arguments['result']
+    if hasattr(result, 'status'):
+        status = f"{result.status}"
+        if status not in HTTP_SUCCESS_CODES:
+            error_message = extract_response(result)
+            raise MonocleSpanException(f"error: {status} - {error_message}", status)
+    else:
+        status = "success"
     return status
 
 def aiohttp_pre_tracing(args):
@@ -49,6 +55,15 @@ def aiohttp_skip_span(args) -> bool:
         return True
     return False
 
+def get_route(args) -> str:
+    try:
+        return args[0].match_info.route.resource.canonical
+    except Exception as e:
+        return get_url(args)
+
+def get_function_name(args) -> str:
+    return args[0].match_info.handler.__name__
+
 class aiohttpSpanHandler(SpanHandler):
 
     def pre_tracing(self, to_wrap, wrapped, instance, args, kwargs):

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

@@ -1,5 +1,6 @@
 from monocle_apptrace.instrumentation.common.constants import SPAN_TYPES
 from monocle_apptrace.instrumentation.metamodel.aiohttp import _helper
+
 AIO_HTTP_PROCESSOR = {
     "type": SPAN_TYPES.HTTP_PROCESS,
     "attributes": [
@@ -14,11 +15,21 @@ AIO_HTTP_PROCESSOR = {
                 "attribute": "route",
                 "accessor": lambda arguments: _helper.get_route(arguments['args'])
             },
+            {
+                "_comment": "request method, request URI",
+                "attribute": "url",
+                "accessor": lambda arguments: _helper.get_url(arguments['args'])
+            },
+            {
+                "_comment": "request function name",
+                "attribute": "function_name",
+                "accessor": lambda arguments: _helper.get_function_name(arguments['args'])
+            },
             {
                 "_comment": "request method, request URI",
                 "attribute": "body",
                 "accessor": lambda arguments: _helper.get_body(arguments['args'])
-            },
+            }
         ]
     ],
     "events": [
@@ -37,8 +48,8 @@ AIO_HTTP_PROCESSOR = {
             "attributes": [
                 {
                     "_comment": "status from HTTP response",
-                    "attribute": "status",
-                    "accessor": lambda arguments: _helper.extract_status(arguments['result'])
+                    "attribute": "error_code",
+                    "accessor": lambda arguments: _helper.extract_status(arguments)
                 },
                 {
                     "_comment": "this is result from LLM",

monocle_apptrace/instrumentation/metamodel/azfunc/_helper.py

@@ -1,6 +1,6 @@
 import logging
 from threading import local
-from monocle_apptrace.instrumentation.common.utils import extract_http_headers, clear_http_scopes, try_option, Option, MonocleSpanException
+from monocle_apptrace.instrumentation.common.utils import extract_http_headers, clear_http_scopes, get_exception_status_code, try_option, Option, MonocleSpanException
 from monocle_apptrace.instrumentation.common.span_handler import SpanHandler
 from monocle_apptrace.instrumentation.common.constants import HTTP_SUCCESS_CODES
 from urllib.parse import unquote, urlparse, ParseResult
@@ -13,7 +13,7 @@ def get_url(kwargs) -> ParseResult:
     url_str = try_option(getattr, kwargs['req'], 'url')
     url = url_str.unwrap_or(None)
     if url is not None:
-        return urlparse(url)
+        return url
     else:
         return None
 
@@ -25,9 +25,11 @@ def get_function_name(kwargs) -> str:
     
 
 def get_route(kwargs) -> str:
-    url:ParseResult = get_url(kwargs)
-    if url is not None:
+    url_str = get_url(kwargs)
+    if url_str is not None:
+        url: ParseResult = urlparse(url_str)
         return url.path
+    return ""
 
 def get_method(kwargs) -> str:
 #    return args[0]['method'] if 'method' in args[0] else ""
@@ -35,9 +37,11 @@ def get_method(kwargs) -> str:
     return http_method.unwrap_or("")
 
 def get_params(kwargs) -> dict:
-    url:ParseResult = get_url(kwargs)
-    if url is not None:
+    url_str = get_url(kwargs)
+    if url_str is not None:
+        url: ParseResult = urlparse(url_str)
         return unquote(url.query)
+    return {}
 
 def get_body(kwargs) -> dict:
     if hasattr(kwargs['req'], 'get_body'):
@@ -57,11 +61,17 @@ def extract_response(result) -> str:
         response = ""
     return response
 
-def extract_status(result) -> str:
-    status = f"{result.status_code}" if hasattr(result, 'status_code') else ""
-    if status not in HTTP_SUCCESS_CODES:
-        error_message = extract_response(result)
-        raise MonocleSpanException(f"error: {status} - {error_message}")
+def extract_status(arguments) -> str:
+    if arguments["exception"] is not None:
+        return get_exception_status_code(arguments)
+    result = arguments['result']
+    if hasattr(result, 'status_code'):
+        status = f"{result.status_code}"
+        if status not in HTTP_SUCCESS_CODES:
+            error_message = extract_response(result)
+            raise MonocleSpanException(f"error: {status} - {error_message}", status)
+    else:
+        status = "success"
     return status
 
 def azure_func_pre_tracing(kwargs):

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

@@ -23,6 +23,11 @@ AZFUNC_HTTP_PROCESSOR = {
                 "_comment": "request function name",
                 "attribute": "function_name",
                 "accessor": lambda arguments: _helper.get_function_name(arguments['kwargs'])
+            },
+            {
+                "_comment": "request function name",
+                "attribute": "url",
+                "accessor": lambda arguments: _helper.get_url(arguments['kwargs'])
             }
         ]
     ],
@@ -42,8 +47,8 @@ AZFUNC_HTTP_PROCESSOR = {
             "attributes": [
                 {
                     "_comment": "status from HTTP response",
-                    "attribute": "status",
-                    "accessor": lambda arguments: _helper.extract_status(arguments['result'])
+                    "attribute": "error_code",
+                    "accessor": lambda arguments: _helper.extract_status(arguments)
                 },
                 {
                     "_comment": "this is result from LLM",

monocle_apptrace/instrumentation/metamodel/fastapi/_helper.py

@@ -1,6 +1,6 @@
 import logging
 from threading import local
-from monocle_apptrace.instrumentation.common.utils import extract_http_headers, clear_http_scopes
+from monocle_apptrace.instrumentation.common.utils import extract_http_headers, clear_http_scopes, get_exception_status_code
 from monocle_apptrace.instrumentation.common.span_handler import SpanHandler
 from monocle_apptrace.instrumentation.common.constants import HTTP_SUCCESS_CODES
 from monocle_apptrace.instrumentation.common.utils import MonocleSpanException
@@ -15,6 +15,13 @@ MAX_DATA_LENGTH = 1000
 token_data = local()
 token_data.current_token = None
 
+def get_url(args) -> str:
+    server = args.get('server', ('127.0.0.1', 80))
+    host, port = server
+    path = args.get('path', '/')
+    scheme = args.get('scheme', 'http')
+    return f"{scheme}://{host}:{port}{path}"
+
 def get_route(scope) -> str:
     return scope.get('path', '')
 
@@ -42,11 +49,17 @@ def extract_response(response) -> str:
         logger.warning(f"Error extracting response: {e}")
         return ""
 
-def extract_status(instance) -> str:
-    status = f"{instance.status_code}" if hasattr(instance, 'status_code') else ""
-    if status not in HTTP_SUCCESS_CODES:
-        error_message = extract_response(instance)
-        raise MonocleSpanException(f"error: {status} - {error_message}")
+def extract_status(arguments) -> str:
+    if arguments["exception"] is not None:
+        return get_exception_status_code(arguments)
+    instance = arguments['instance']
+    if hasattr(instance, 'status_code'):
+        status = f"{instance.status_code}"
+        if status not in HTTP_SUCCESS_CODES:
+            error_message = extract_response(instance)
+            raise MonocleSpanException(f"error: {status} - {error_message}", status)
+    else:
+        status = "success"
     return status
 
 def fastapi_pre_tracing(scope):

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

@@ -13,6 +13,10 @@ FASTAPI_HTTP_PROCESSOR = {
                 "attribute": "route",
                 "accessor": lambda arguments: _helper.get_route(arguments['args'][0])
             },
+        {
+                "attribute": "url",
+                "accessor": lambda arguments: _helper.get_url(arguments['args'][0])
+            },
         ]
     ]
 }
@@ -32,8 +36,8 @@ FASTAPI_RESPONSE_PROCESSOR = {
             "name": "data.output",
             "attributes": [
                 {
-                    "attribute": "status",
-                    "accessor": lambda arguments: _helper.extract_status(arguments['instance'])
+                    "attribute": "error_code",
+                    "accessor": lambda arguments: _helper.extract_status(arguments)
                 },
                 {
                     "attribute": "response",

monocle_apptrace/instrumentation/metamodel/fastapi/methods.py

@@ -1,23 +1,23 @@
-from monocle_apptrace.instrumentation.common.wrapper import atask_wrapper
+from monocle_apptrace.instrumentation.common.wrapper import atask_wrapper,task_wrapper
 from monocle_apptrace.instrumentation.metamodel.fastapi.entities.http import FASTAPI_HTTP_PROCESSOR, FASTAPI_RESPONSE_PROCESSOR
 
 FASTAPI_METHODS = [
-    # {
-    #     "package": "fastapi",
-    #     "object": "FastAPI",
-    #     "method": "__call__",
-    #     "wrapper_method": atask_wrapper,
-    #     "span_name": "fastapi.request",
-    #     "span_handler": "fastapi_handler",
-    #     "output_processor": FASTAPI_HTTP_PROCESSOR,
-    # },
-    # {
-    #     "package": "starlette.responses",
-    #     "object": "Response",
-    #     "method": "__call__",
-    #     "span_name": "fastapi.response",
-    #     "wrapper_method": atask_wrapper,
-    #     "span_handler": "fastapi_response_handler",
-    #     "output_processor": FASTAPI_RESPONSE_PROCESSOR
-    # }
+    {
+        "package": "fastapi",
+        "object": "FastAPI",
+        "method": "__call__",
+        "wrapper_method": task_wrapper,
+        "span_name": "fastapi.request",
+        "span_handler": "fastapi_handler",
+        "output_processor": FASTAPI_HTTP_PROCESSOR,
+    },
+    {
+        "package": "starlette.responses",
+        "object": "Response",
+        "method": "__call__",
+        "span_name": "fastapi.response",
+        "wrapper_method": task_wrapper,
+        "span_handler": "fastapi_response_handler",
+        "output_processor": FASTAPI_RESPONSE_PROCESSOR
+    }
 ]

monocle_apptrace/instrumentation/metamodel/flask/_helper.py

@@ -1,6 +1,6 @@
 import logging
 from threading import local
-from monocle_apptrace.instrumentation.common.utils import extract_http_headers, clear_http_scopes
+from monocle_apptrace.instrumentation.common.utils import extract_http_headers, clear_http_scopes, get_exception_status_code
 from monocle_apptrace.instrumentation.common.span_handler import SpanHandler
 from monocle_apptrace.instrumentation.common.constants import HTTP_SUCCESS_CODES
 from monocle_apptrace.instrumentation.common.utils import MonocleSpanException
@@ -22,6 +22,14 @@ def get_params(args) -> dict:
     params = args[0]['QUERY_STRING'] if 'QUERY_STRING' in args[0] else ""
     return unquote(params)
 
+def get_url(args) -> str:
+    url = ""
+    if len(args) > 1 or not isinstance(args[0], dict):
+        if 'HTTP_HOST' in args[0]:
+            url = f"http://{args[0]['HTTP_HOST']}{args[0].get('REQUEST_URI', '')}"
+
+    return url
+
 def get_body(args) -> dict:
     return ""
 
@@ -32,11 +40,17 @@ def extract_response(instance) -> str:
         response = ""
     return response
 
-def extract_status(instance) -> str:
-    status = f"{instance.status_code}" if hasattr(instance, 'status_code') else ""
-    if status not in HTTP_SUCCESS_CODES:
-        error_message = extract_response(instance)
-        raise MonocleSpanException(f"error: {status} - {error_message}")
+def extract_status(arguments) -> str:
+    if arguments["exception"] is not None:
+        return get_exception_status_code(arguments)
+    instance = arguments['instance']
+    if hasattr(instance, 'status_code'):
+        status = f"{instance.status_code}"
+        if status not in HTTP_SUCCESS_CODES:
+            error_message = extract_response(instance)
+            raise MonocleSpanException(f"error: {status} - {error_message}", status)
+    else:
+        status = "success"
     return status
 
 def flask_pre_tracing(args):

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

@@ -14,6 +14,11 @@ FLASK_HTTP_PROCESSOR = {
                 "attribute": "route",
                 "accessor": lambda arguments: _helper.get_route(arguments['args'])
             },
+            {
+                "_comment": "request method, request URI",
+                "attribute": "url",
+                "accessor": lambda arguments: _helper.get_url(arguments['args'])
+            },
         ]
     ]
 }
@@ -35,8 +40,8 @@ FLASK_RESPONSE_PROCESSOR = {
             "attributes": [
                 {
                     "_comment": "status from HTTP response",
-                    "attribute": "status",
-                    "accessor": lambda arguments: _helper.extract_status(arguments['instance'])
+                    "attribute": "error_code",
+                    "accessor": lambda arguments: _helper.extract_status(arguments)
                 },
                 {
                     "_comment": "this is result from LLM",

monocle_apptrace/instrumentation/metamodel/lambdafunc/_helper.py

@@ -1,6 +1,7 @@
 import logging
 from threading import local
-from monocle_apptrace.instrumentation.common.utils import extract_http_headers, clear_http_scopes, try_option, Option, \
+from unittest import result
+from monocle_apptrace.instrumentation.common.utils import extract_http_headers, clear_http_scopes, get_exception_status_code, try_option, Option, \
     MonocleSpanException
 from monocle_apptrace.instrumentation.common.span_handler import SpanHandler
 from monocle_apptrace.instrumentation.common.constants import HTTP_SUCCESS_CODES
@@ -11,13 +12,18 @@ MAX_DATA_LENGTH = 1000
 token_data = local()
 token_data.current_token = None
 
-def get_url(kwargs) -> ParseResult:
-    url_str = try_option(lambda k: k.get('path'), kwargs['event'])
-    url = url_str.unwrap_or(None)
-    if url is not None:
-        return urlparse(url)
-    else:
-        return None
+def get_url(args) -> str:
+    event = args[1]
+    host = event.get('headers', {}).get('Host', '')
+    stage = event.get('requestContext', {}).get('stage', '')
+    path = event.get('path', '')
+    query_params = event.get('queryStringParameters', {})
+    scheme = 'https' if event.get('headers', {}).get('X-Forwarded-Proto', 'http') == 'https' else 'http'
+    url = f"{scheme}://{host}/{stage}{path}"
+    if query_params:
+        from urllib.parse import urlencode
+        url += '?' + urlencode(query_params)
+    return url
 
 def get_route(args) -> str:
     event = args[1]
@@ -53,14 +59,19 @@ def extract_response(result) -> str:
     return response
 
 
-def extract_status(result) -> str:
-    status = f"{result['statusCode']}" if isinstance(result, dict) and 'statusCode' in result else ""
-    if status not in HTTP_SUCCESS_CODES:
-        error_message = extract_response(result)
-        raise MonocleSpanException(f"error: {status} - {error_message}")
+def extract_status(arguments) -> str:
+    if arguments["exception"] is not None:
+        return get_exception_status_code(arguments)
+    result = arguments['result']
+    if isinstance(result, dict) and 'statusCode' in result:
+        status = f"{result['statusCode']}"
+        if status not in HTTP_SUCCESS_CODES:
+            error_message = extract_response(result)
+            raise MonocleSpanException(f"error: {status} - {error_message}", status)
+    else:
+        status = "success"
     return status
 
-
 def lambda_func_pre_tracing(kwargs):
     headers = kwargs['event'].get('headers', {}) if 'event' in kwargs else {}
     return extract_http_headers(headers)

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

@@ -19,6 +19,11 @@ LAMBDA_HTTP_PROCESSOR = {
                 "attribute": "body",
                 "accessor": lambda arguments: _helper.get_body(arguments['args'])
             },
+        {
+                "_comment": "request method, request URI",
+                "attribute": "url",
+                "accessor": lambda arguments: _helper.get_url(arguments['args'])
+            },
         ]
     ],
     "events": [
@@ -37,8 +42,8 @@ LAMBDA_HTTP_PROCESSOR = {
             "attributes": [
                 {
                     "_comment": "status from HTTP response",
-                    "attribute": "status",
-                    "accessor": lambda arguments: _helper.extract_status(arguments['result'])
+                    "attribute": "error_code",
+                    "accessor": lambda arguments: _helper.extract_status(arguments)
                 },
                 {
                     "_comment": "this is result from LLM",

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

@@ -125,7 +125,7 @@ TOOLS = {
           "attributes": [
             {
                 "_comment": "this is Tool input",
-                "attribute": "Inputs",
+                "attribute": "input",
                 "accessor": lambda arguments: _helper.extract_tool_input(arguments) 
             },
           ]

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

@@ -126,7 +126,7 @@ TOOLS = {
           "attributes": [
             {
                 "_comment": "this is Tool input",
-                "attribute": "Inputs",
+                "attribute": "input",
                 "accessor": lambda arguments: _helper.extract_tool_args(arguments) 
             }
           ]

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

@@ -1,4 +1,5 @@
 from monocle_apptrace.instrumentation.common.constants import SPAN_SUBTYPES, SPAN_TYPES
+from monocle_apptrace.instrumentation.common.utils import get_error_message
 from monocle_apptrace.instrumentation.metamodel.mcp import _helper
 
 TOOLS = {
@@ -44,6 +45,10 @@ TOOLS = {
                     "attribute": "output",
                     "accessor": lambda arguments: _helper.get_output_text(arguments)
                 },
+                {
+                    "attribute": "error_code",
+                    "accessor": lambda arguments: get_error_message(arguments)
+                }
             ],
         },
     ],

monocle_apptrace/instrumentation/metamodel/mistral/_helper.py

@@ -0,0 +1,174 @@
+"""
+This module provides utility functions for extracting system, user,
+and assistant messages from various input formats.
+"""
+
+import json
+import logging
+from opentelemetry.context import get_value
+from monocle_apptrace.instrumentation.common.utils import (
+    Option,
+    get_json_dumps,
+    get_keys_as_tuple,
+    get_nested_value,
+    get_status_code,
+    try_option,
+    get_exception_message,
+)
+from monocle_apptrace.instrumentation.metamodel.finish_types import map_anthropic_finish_reason_to_finish_type
+from monocle_apptrace.instrumentation.common.constants import AGENT_PREFIX_KEY, INFERENCE_AGENT_DELEGATION, INFERENCE_TURN_END, INFERENCE_TOOL_CALL
+
+
+logger = logging.getLogger(__name__)
+
+def extract_provider_name(instance):
+    provider_url: Option[str] = try_option(getattr, instance._client.base_url, 'host')
+    return provider_url.unwrap_or(None)
+
+def extract_inference_endpoint(instance):
+    inference_endpoint: Option[str] = try_option(getattr, instance._client, 'base_url').map(str)
+    if inference_endpoint.is_none() and "meta" in instance.client.__dict__:
+        inference_endpoint = try_option(getattr, instance.client.meta, 'endpoint_url').map(str)
+
+    return inference_endpoint.unwrap_or(extract_provider_name(instance))
+
+def dummy_method(arguents):
+    pass
+
+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 len(kwargs['messages']) >0:
+            for msg in kwargs['messages']:
+                if msg.get('content') and msg.get('role'):
+                    messages.append({msg['role']: msg['content']})
+        return [get_json_dumps(message) for message in messages]
+    except Exception as e:
+        logger.warning("Warning: Error occurred in extract_messages: %s", str(e))
+        return []
+
+def get_exception_status_code(arguments):
+    exc = arguments.get("exception")
+    if exc is not None and hasattr(exc, "status_code"):
+        if exc.status_code == 401:
+            return "unauthorized"
+        elif exc.status_code == 403:
+            return "forbidden"
+        elif exc.status_code == 404:
+            return "not_found"
+        else:
+            return str(exc.status_code)
+    elif exc is not None:
+        return "error"
+    else:
+        return "success"
+
+
+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 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:
+                # Each chunk may have delta attribute
+                if hasattr(chunk, "delta") and hasattr(chunk.delta, "content"):
+                    content.append(chunk.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(response):
+    meta_dict = {}
+    if response is not None and hasattr(response, "usage"):
+        if hasattr(response, "usage") and response.usage is not None:
+            token_usage = response.usage
+        else:
+            response_metadata = response.response_metadata
+            token_usage = response_metadata.get("token_usage")
+        if token_usage is not None:
+            meta_dict.update({"completion_tokens": getattr(response.usage, "output_tokens", 0)})
+            meta_dict.update({"prompt_tokens": getattr(response.usage, "input_tokens", 0)})
+            meta_dict.update({"total_tokens": getattr(response.usage, "input_tokens", 0)+getattr(response.usage, "output_tokens", 0)})
+    return meta_dict
+
+def extract_finish_reason(arguments):
+    """Extract stop_reason from Anthropic response (Claude)."""
+    try:
+        # Arguments may be a dict with 'result' or just the response object
+        response = arguments.get("result") if isinstance(arguments, dict) else arguments
+        if response is not None and hasattr(response, "stop_reason"):
+            return response.stop_reason
+    except Exception as e:
+        logger.warning("Warning: Error occurred in extract_finish_reason: %s", str(e))
+        return None
+    return None
+
+def map_finish_reason_to_finish_type(finish_reason):
+    """Map Anthropic stop_reason to finish_type, similar to OpenAI mapping."""
+    return map_anthropic_finish_reason_to_finish_type(finish_reason)
+
+def agent_inference_type(arguments):
+    """Extract agent inference type from Anthropic response"""
+    try:
+        status = get_status_code(arguments)
+        if status == 'success' or status == 'completed':
+            response = arguments["result"]
+            
+            # Check if stop_reason indicates tool use
+            if hasattr(response, "stop_reason") and response.stop_reason == "tool_use":
+                # Check if this is agent delegation by looking at tool names
+                if hasattr(response, "content") and response.content:
+                    agent_prefix = get_value(AGENT_PREFIX_KEY)
+                    for content_block in response.content:
+                        if (hasattr(content_block, "type") and 
+                            content_block.type == "tool_use" and
+                            hasattr(content_block, "name")):
+                            tool_name = content_block.name
+                            if agent_prefix and tool_name.startswith(agent_prefix):
+                                return INFERENCE_AGENT_DELEGATION
+                    # If we found tool use but no agent delegation, it's a regular tool call
+                    return INFERENCE_TOOL_CALL
+            
+            # Fallback: check the extracted message for tool content
+            assistant_message = extract_assistant_message(arguments)
+            if assistant_message:
+                try:
+                    message = json.loads(assistant_message)
+                    if message and isinstance(message, dict):
+                        assistant_content = message.get("assistant", "")
+                        if assistant_content:
+                            agent_prefix = get_value(AGENT_PREFIX_KEY)
+                            if agent_prefix and agent_prefix in assistant_content:
+                                return INFERENCE_AGENT_DELEGATION
+                except (json.JSONDecodeError, TypeError):
+                    # If JSON parsing fails, fall back to string analysis
+                    agent_prefix = get_value(AGENT_PREFIX_KEY)
+                    if agent_prefix and agent_prefix in assistant_message:
+                        return INFERENCE_AGENT_DELEGATION
+        
+        return INFERENCE_TURN_END
+    except Exception as e:
+        logger.warning("Warning: Error occurred in agent_inference_type: %s", str(e))
+        return INFERENCE_TURN_END

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

@@ -0,0 +1,85 @@
+from monocle_apptrace.instrumentation.common.constants import SPAN_TYPES
+from monocle_apptrace.instrumentation.metamodel.mistral import _helper
+from monocle_apptrace.instrumentation.common.utils import get_error_message, resolve_from_alias
+
+MISTRAL_INFERENCE = {
+    "type": SPAN_TYPES.INFERENCE,
+    "attributes": [
+        [
+            {
+                "_comment": "provider type ,name , deployment , inference_endpoint",
+                "attribute": "type",
+                "accessor": lambda arguments: 'inference.mistral'
+
+            },
+            {
+                "attribute": "provider_name",
+                "accessor": lambda arguments: "mistral"
+            },
+            {
+                "attribute": "inference_endpoint",
+                "accessor": lambda arguments: "https://api.mistral.ai"
+            }
+        ],
+        [
+            {
+                "_comment": "LLM Model",
+                "attribute": "name",
+                "accessor": lambda arguments: resolve_from_alias(arguments['kwargs'], ['model', 'model_name', 'endpoint_name', 'deployment_name'])
+            },
+            {
+                "attribute": "type",
+                "accessor": lambda arguments: 'model.llm.' + resolve_from_alias(arguments['kwargs'], ['model', 'model_name', 'endpoint_name', 'deployment_name'])
+            }
+        ]
+    ],
+    "events": [
+        {
+            "name": "data.input",
+            "attributes": [
+                {
+                    "_comment": "this is instruction and user query to LLM",
+                    "attribute": "input",
+                    "accessor": lambda arguments: _helper.extract_messages(arguments['kwargs'])
+                }
+            ]
+        },
+        {
+            "name": "data.output",
+            "attributes": [
+                {
+                    "attribute": "error_code",
+                    "accessor": lambda arguments: get_error_message(arguments)
+                },
+                {
+                    "_comment": "this is result from LLM",
+                    "attribute": "response",
+                    "accessor": lambda arguments: _helper.extract_assistant_message(arguments)
+                }
+            ]
+        },
+        {
+            "name": "metadata",
+            "attributes": [
+                {
+                    "_comment": "this is metadata usage from LLM",
+                    "accessor": lambda arguments: _helper.update_span_from_llm_response(arguments['result'])
+                },
+                {
+                    "_comment": "finish reason from Anthropic 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))
+                },
+                {
+                    "attribute": "inference_sub_type",
+                    "accessor": lambda arguments: _helper.agent_inference_type(arguments)
+                }
+            ]
+        }
+    ]
+}

monocle_apptrace/instrumentation/metamodel/mistral/methods.py

@@ -0,0 +1,41 @@
+from monocle_apptrace.instrumentation.common.wrapper import task_wrapper, atask_wrapper
+from monocle_apptrace.instrumentation.metamodel.mistral.entities.inference import MISTRAL_INFERENCE
+
+MISTRAL_METHODS = [
+    {
+        "package": "mistralai.chat",          # where Chat is defined
+        "object": "Chat",                     # class name
+        "method": "complete",                 # the sync method
+        "span_handler": "non_framework_handler",
+        "wrapper_method": task_wrapper,
+        "output_processor": MISTRAL_INFERENCE
+    },
+    {
+        "package": "mistralai.chat",          # where Chat is defined
+        "object": "Chat",                     # class name
+        "method": "complete_async",           # the async method
+        "span_handler": "non_framework_handler",
+        "wrapper_method": atask_wrapper,
+        "output_processor": MISTRAL_INFERENCE
+    },
+    {
+        "package": "mistralai.chat",
+        "object": "Chat",
+        "method": "stream",              # sync streaming
+        "span_handler": "non_framework_handler",
+        "wrapper_method": task_wrapper,
+        "output_processor": MISTRAL_INFERENCE,
+    },
+    {
+        "package": "mistralai.chat",
+        "object": "Chat",
+        "method": "stream_async",        # async streaming
+        "span_handler": "non_framework_handler",
+        "wrapper_method": atask_wrapper,
+        "output_processor": MISTRAL_INFERENCE,
+    }
+]
+
+ 
+
+

monocle_apptrace/instrumentation/metamodel/teamsai/_helper.py

@@ -100,7 +100,7 @@ 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}")
+        raise MonocleSpanException(f"Error: {error_code} - {error_msg}", error_code)
 
 def get_prompt_template(arguments):
     pass
@@ -152,7 +152,7 @@ def extract_status_code(arguments):
 def check_status(arguments):
     status = get_status_code(arguments)
     if status != 'success' and arguments['exception'] is None:
-        raise MonocleSpanException(f"{status}")   
+        raise MonocleSpanException(f"{status}", status)
 
 def map_finish_reason_to_finish_type(finish_reason):
     """Map TeamsAI finish_reason to standardized finish_type."""

{monocle_apptrace-0.5.1b1.dist-info → monocle_apptrace-0.5.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: monocle_apptrace
-Version: 0.5.1b1
+Version: 0.5.3
 Summary: package with monocle genAI tracing
 Project-URL: Homepage, https://github.com/monocle2ai/monocle
 Project-URL: Issues, https://github.com/monocle2ai/monocle/issues

{monocle_apptrace-0.5.1b1.dist-info → monocle_apptrace-0.5.3.dist-info}/RECORD

@@ -4,7 +4,7 @@ monocle_apptrace/__main__.py,sha256=MLLPbC4YTp8O2wQrn8BROSZGvQpQd5brk_d1n_dWVWA,
 monocle_apptrace/mcp_server.py,sha256=X5NFOE1QHkIktykGlRH-bzOnLsby5E9sTRAT-4BOQx0,5591
 monocle_apptrace/exporters/base_exporter.py,sha256=xm2MkDjuVZc-vmSXBMMsNMyIoy4z0O4g6wOAyuEnHwo,2062
 monocle_apptrace/exporters/exporter_processor.py,sha256=-spCIJ_UfJ0fax_jE-ii3ODQBwtnHZgYIGVNd91Q718,6298
-monocle_apptrace/exporters/file_exporter.py,sha256=bqRo1h9ubuUltYTj7-LxHWtPwlevBV6dvRbnJXQEwqs,7873
+monocle_apptrace/exporters/file_exporter.py,sha256=eBfLKRsAtudHTFd0IRcov5rLK48r95TCL8cqRuj2EG4,8208
 monocle_apptrace/exporters/monocle_exporters.py,sha256=qo6S53dp2ko6EzMP-ICL2buqgmw8HZboy19j7iHp1Qk,2882
 monocle_apptrace/exporters/aws/s3_exporter.py,sha256=9GA2tiWOUBLtDdGIdLLyYJEdQ1jRC5SdxxVH3qqR8Qk,8260
 monocle_apptrace/exporters/aws/s3_exporter_opendal.py,sha256=0aEUxdMgJaDUwqjw0DqlCMr8kjl01KgwUt3_RRCVFds,5917
@@ -17,11 +17,11 @@ monocle_apptrace/instrumentation/common/constants.py,sha256=dAbIKrfI97oYMKNj5gdP
 monocle_apptrace/instrumentation/common/instrumentor.py,sha256=2mxnnxlnBpaJUpIhS2dihIfbmbUEbLN8H2hUtN34c9o,10849
 monocle_apptrace/instrumentation/common/method_wrappers.py,sha256=jC3G_R2YVD0JWCzxx1zNzJbe_BsNhsveVMegJRXA3IQ,10152
 monocle_apptrace/instrumentation/common/scope_wrapper.py,sha256=Ysr4zmb71sZm3R-fNabctnNJHnmLVL9FE-4EmQo3HxA,3927
-monocle_apptrace/instrumentation/common/span_handler.py,sha256=ZpFyw1YY6JtNjLB5HRdgVkugqOTx27Pe4lezDbBULpo,15084
+monocle_apptrace/instrumentation/common/span_handler.py,sha256=CbTQYkkT2TvzW5k8snOM8dULxp2A5GAoqzmaH3eCgD4,15235
 monocle_apptrace/instrumentation/common/tracing.md,sha256=6Lr8QGxEFHKhj-mMvLV3xjFnplKSs6HEdwl0McPK47M,7577
-monocle_apptrace/instrumentation/common/utils.py,sha256=TZmKMYCfHAGycMLQyqnrnto5llgBlKp-yPN0QtNKRfE,15621
+monocle_apptrace/instrumentation/common/utils.py,sha256=hsF1Opoa7kJA9eEWNzYAU88u3JFYMsNQlUilL8fcqiE,15761
 monocle_apptrace/instrumentation/common/wrapper.py,sha256=vbt2650Z3YNcxIvrT3odZ1RHIIeAHrrvYQOqFNUGXHQ,20285
-monocle_apptrace/instrumentation/common/wrapper_method.py,sha256=E_OWQ2I4AAthWAtSBWHrzicHs0ug7vMkZIWJlp6D-H8,6583
+monocle_apptrace/instrumentation/common/wrapper_method.py,sha256=Gohu3z74moELkhaXAonhQXYjn--2dfLdkiHPGvYTiB0,6692
 monocle_apptrace/instrumentation/metamodel/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 monocle_apptrace/instrumentation/metamodel/finish_types.py,sha256=ck-bWfMezrNIkUHy9QpW25cLCmNsjmceYzBzEydm92w,19267
 monocle_apptrace/instrumentation/metamodel/a2a/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -32,27 +32,27 @@ monocle_apptrace/instrumentation/metamodel/a2a/entities/inference.py,sha256=5v37
 monocle_apptrace/instrumentation/metamodel/adk/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 monocle_apptrace/instrumentation/metamodel/adk/_helper.py,sha256=mEs8AU1ti9ClWDdKzNGDYdOw_gMqKdbHc39hN7WxFKU,6417
 monocle_apptrace/instrumentation/metamodel/adk/methods.py,sha256=Wp6MJArvLotY2CIAf1PlwJzdcH8qBk7II1KPBRET7c0,917
-monocle_apptrace/instrumentation/metamodel/adk/entities/agent.py,sha256=qIdDqnsu1yiJS2UERhi7gfjnqogquOdr6ZRR1PDqMEs,3450
-monocle_apptrace/instrumentation/metamodel/adk/entities/tool.py,sha256=uKTOBbyJtP1nn-gI-zsF__MkhRY_Y7xgcQr6keG4VtA,1933
+monocle_apptrace/instrumentation/metamodel/adk/entities/agent.py,sha256=GCwvFyhAocvPzYr_lrQf9MfC9vEEnyg2EhOm2fBvdks,3674
+monocle_apptrace/instrumentation/metamodel/adk/entities/tool.py,sha256=EEZxYM9bdH7KCmO-jnTywXAiN45hel5eAqLyHKZ1BbU,2157
 monocle_apptrace/instrumentation/metamodel/agents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 monocle_apptrace/instrumentation/metamodel/agents/_helper.py,sha256=bHF3BaJyCli8VFgd-eRxaditoYT5UXLF7a1-zzMafik,7625
 monocle_apptrace/instrumentation/metamodel/agents/agents_processor.py,sha256=P95dNBh18M74Bw-BklwcN3wRfyi4vC3Q9EOcR8QBheg,6194
 monocle_apptrace/instrumentation/metamodel/agents/methods.py,sha256=l7KwBLm_olUfZsN9UxUVc_spvSGLNqBJzKh3cyX40-o,1758
 monocle_apptrace/instrumentation/metamodel/agents/entities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-monocle_apptrace/instrumentation/metamodel/agents/entities/inference.py,sha256=5drQmhd4fRVzKs7ossH3RmbdQRKXerEiqtq7xAKlpX8,6110
+monocle_apptrace/instrumentation/metamodel/agents/entities/inference.py,sha256=TYjZU_823EYjIirr9fmjaDzeZjslHj4tVeSgILXvXq0,6617
 monocle_apptrace/instrumentation/metamodel/aiohttp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-monocle_apptrace/instrumentation/metamodel/aiohttp/_helper.py,sha256=LjAYaZUUXw59dzol-NDTiz9uZNTZ2Mwu6WXggGpefd8,2088
+monocle_apptrace/instrumentation/metamodel/aiohttp/_helper.py,sha256=6wTmycVbETB0fOc99No2rePVgACKR3J6HCUkaedV0o8,2539
 monocle_apptrace/instrumentation/metamodel/aiohttp/methods.py,sha256=rcfGoRMLJeu-X2O9fGv6nhhjUrBJALKOJ-axiedavMI,435
-monocle_apptrace/instrumentation/metamodel/aiohttp/entities/http.py,sha256=8j5x6Mgkoq076_ZvOFP05zBpsGt5hmREk8IqVihwwYQ,1783
+monocle_apptrace/instrumentation/metamodel/aiohttp/entities/http.py,sha256=OC7qgaKLUD_otmtP5jNyWcR_D0GGSbBZAxNa6RtQXwE,2201
 monocle_apptrace/instrumentation/metamodel/anthropic/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 monocle_apptrace/instrumentation/metamodel/anthropic/_helper.py,sha256=fuILJFil-Gr2hIDIK-2xlHyibCwVXLbakFgJ2P9AKNE,8615
 monocle_apptrace/instrumentation/metamodel/anthropic/methods.py,sha256=WVXoN_i5h9hXjrJV5xF9wIQIpmP_gCN3P8HEPfAsfik,703
 monocle_apptrace/instrumentation/metamodel/anthropic/entities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 monocle_apptrace/instrumentation/metamodel/anthropic/entities/inference.py,sha256=6mwMs-ZYoS0B4mkUXwy1VFBzJQd8olEwhEqYgUSyVIc,3643
-monocle_apptrace/instrumentation/metamodel/azfunc/_helper.py,sha256=Syy5hvVBGdA_NUebidt_wzcCWDUx-eAaThclr-oHVsQ,2725
+monocle_apptrace/instrumentation/metamodel/azfunc/_helper.py,sha256=7c1yKH9coWdGku8BOAp83H0GtSkfZF3sHFv7uRWL8Yg,3041
 monocle_apptrace/instrumentation/metamodel/azfunc/methods.py,sha256=dCcptd9nLsXkkWtSgXBh7zRia-1g-A3rgiC4cqt5Tzo,916
 monocle_apptrace/instrumentation/metamodel/azfunc/wrapper.py,sha256=zssmQNWG-kn9cSfE1JYwqHsl1hU4zrN2xUcFbyos8oM,712
-monocle_apptrace/instrumentation/metamodel/azfunc/entities/http.py,sha256=UyZ88dLw_PMHsC6k-VbT_eCKVWcx8a1bZNSMvpcbloc,2013
+monocle_apptrace/instrumentation/metamodel/azfunc/entities/http.py,sha256=gWjUe5t4JWOGtzJDRFWbZqjPi8ER6hFa_2V43M8D2do,2208
 monocle_apptrace/instrumentation/metamodel/azureaiinference/__init__.py,sha256=zHdtJf4MZKSIi-4KPxdDR_dZdRAdZuy7Z8yDRa6cBps,44
 monocle_apptrace/instrumentation/metamodel/azureaiinference/_helper.py,sha256=j0f9ej0k0696kXrmOq_bmO4uQuxcgM5UsMCVDWXcbCI,11734
 monocle_apptrace/instrumentation/metamodel/azureaiinference/methods.py,sha256=PsxJPFSc9yp9uzdpwVUWUAd2PVwF7MYwf3I2_cqHSOk,810
@@ -64,14 +64,14 @@ monocle_apptrace/instrumentation/metamodel/botocore/entities/__init__.py,sha256=
 monocle_apptrace/instrumentation/metamodel/botocore/entities/inference.py,sha256=-YW5pBQ3fWy3TMbiRfBfJyDx_4bR4OgTjS2poG-hWoM,3073
 monocle_apptrace/instrumentation/metamodel/botocore/handlers/botocore_span_handler.py,sha256=aZ_jxngqjihxxTPFOqYH8rjoEdF_WVwE_3-TB57d_8I,1444
 monocle_apptrace/instrumentation/metamodel/fastapi/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-monocle_apptrace/instrumentation/metamodel/fastapi/_helper.py,sha256=3hdf-3oag50k5cPfknWwMrYJTS6Oo93WJHE4l-oLWzg,3205
-monocle_apptrace/instrumentation/metamodel/fastapi/methods.py,sha256=iOtZc-D5jSQuH9mPzhymuxe2wsx2QbwT1yLwef2hJ1A,841
+monocle_apptrace/instrumentation/metamodel/fastapi/_helper.py,sha256=6gObluSeIJgp4yoVF_tMoLe65DjtDiRQMpwI224k3WM,3643
+monocle_apptrace/instrumentation/metamodel/fastapi/methods.py,sha256=n2nAGaxrjC-E5UGJwVlriNkFlFRAG80RrxGK5yHoobY,816
 monocle_apptrace/instrumentation/metamodel/fastapi/entities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-monocle_apptrace/instrumentation/metamodel/fastapi/entities/http.py,sha256=Q2cyNNMenDU63tZBbL5dNKqEnu08NC8NmLp46SEusu8,1339
+monocle_apptrace/instrumentation/metamodel/fastapi/entities/http.py,sha256=HUH_lrxezw96t-9hCle-yALEZaHfZpOTEVB0kNkacv4,1476
 monocle_apptrace/instrumentation/metamodel/flask/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-monocle_apptrace/instrumentation/metamodel/flask/_helper.py,sha256=vvP1k3ArXfX7oMqnjaEE77rOYcl_ssAmjjknBRX8jlg,2821
+monocle_apptrace/instrumentation/metamodel/flask/_helper.py,sha256=gPrzlz9W3NY6DYQz9grMBnuYqiKuNvNMIpQwQboQlYE,3268
 monocle_apptrace/instrumentation/metamodel/flask/methods.py,sha256=dWCMEDk-HWHiD0vlMoAVYbIFclstmVkUpRrCtqDWyFE,739
-monocle_apptrace/instrumentation/metamodel/flask/entities/http.py,sha256=-4VAWx2vHEONIyG-JCVBadJt0F8eI_WliDCi5BjpAmo,1607
+monocle_apptrace/instrumentation/metamodel/flask/entities/http.py,sha256=bj_A7_tiz9oY-1nAXYL1V_Kj4g3Z6HLKqdCOdw4qgUc,1804
 monocle_apptrace/instrumentation/metamodel/gemini/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 monocle_apptrace/instrumentation/metamodel/gemini/_helper.py,sha256=qCjZGPYP_aidE4Eue4GK0x8RbTkh74ayJfJkFRLdhpg,5103
 monocle_apptrace/instrumentation/metamodel/gemini/methods.py,sha256=prvi1oY4n1DAefP6IJ7McfrtprHRlwmtGBb-R1kxlPQ,881
@@ -84,10 +84,10 @@ monocle_apptrace/instrumentation/metamodel/haystack/methods.py,sha256=fuICw7KVTA
 monocle_apptrace/instrumentation/metamodel/haystack/entities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 monocle_apptrace/instrumentation/metamodel/haystack/entities/inference.py,sha256=pykGCW_ucEdPkp_yshSyHeK7p2WxJpnzxHEPt7TONp0,3880
 monocle_apptrace/instrumentation/metamodel/haystack/entities/retrieval.py,sha256=bWagT0us1sGFlvHEToYlVk4PPDxFimQC0l_BJmrjnxc,2439
-monocle_apptrace/instrumentation/metamodel/lambdafunc/_helper.py,sha256=tA79BQtHoCmQrEhUdpwPvOXjM3IrCzR_9cLbds9xBgI,2496
+monocle_apptrace/instrumentation/metamodel/lambdafunc/_helper.py,sha256=mKD-IbylOUugK9GGuGv-S53AUei_8swQ4Ak8A5iwUxw,3043
 monocle_apptrace/instrumentation/metamodel/lambdafunc/methods.py,sha256=-b5dfI5oZVdRmBjfrVJgQuN910p7SUOu9Tc1AUhkz3A,934
 monocle_apptrace/instrumentation/metamodel/lambdafunc/wrapper.py,sha256=nxnfCwPftoRdHfjuRNrILEFOvB1e8oXqHRfPn-qxyZY,716
-monocle_apptrace/instrumentation/metamodel/lambdafunc/entities/http.py,sha256=QKROulDBLkzhWRdn0Aq-3JYhs9jwqegvTw0TU3fQc68,1789
+monocle_apptrace/instrumentation/metamodel/lambdafunc/entities/http.py,sha256=ws2tSnf77rHdJ2E0ER2SOB9U7EDp33d9yNh2O29yDRA,1984
 monocle_apptrace/instrumentation/metamodel/langchain/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 monocle_apptrace/instrumentation/metamodel/langchain/_helper.py,sha256=Xt-PRVLDMU6buiKLcUhw-IwL5sj1FF-etkp403HGRs0,12339
 monocle_apptrace/instrumentation/metamodel/langchain/methods.py,sha256=sQLrji0NLuG8i8q5UdbgzPUjWh_WmromfvWL3pGZdCk,2941
@@ -99,7 +99,7 @@ monocle_apptrace/instrumentation/metamodel/langgraph/_helper.py,sha256=O0x8fLwc5
 monocle_apptrace/instrumentation/metamodel/langgraph/langgraph_processor.py,sha256=0JZKLwWcdXTvp7QoBhCV6CoplohMoH3jdZ0EtfUNi2s,3156
 monocle_apptrace/instrumentation/metamodel/langgraph/methods.py,sha256=xu3BkxjupktwdAPAvavOd2_ZhjllqfYQQ3s1RWrhWlE,1295
 monocle_apptrace/instrumentation/metamodel/langgraph/entities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-monocle_apptrace/instrumentation/metamodel/langgraph/entities/inference.py,sha256=Md5IMxvqPu1FRSwMkxLE-9uJi3UuVafBFp7DgHHJvdw,5134
+monocle_apptrace/instrumentation/metamodel/langgraph/entities/inference.py,sha256=XfnEEmE02aLPXKNwocGjLMkUlRJJGPhPEblFBCoDUug,5133
 monocle_apptrace/instrumentation/metamodel/litellm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 monocle_apptrace/instrumentation/metamodel/litellm/_helper.py,sha256=Yo0RtiJ4WKDRuC9VqUmXmdQmRLduOsVGHMNwswwdcLk,3433
 monocle_apptrace/instrumentation/metamodel/litellm/methods.py,sha256=D3rT7bQKzPRxGIs3GxwPmjmmti8ndF7_5Cmz8ojfSJQ,627
@@ -110,7 +110,7 @@ monocle_apptrace/instrumentation/metamodel/llamaindex/_helper.py,sha256=-Vw215wW
 monocle_apptrace/instrumentation/metamodel/llamaindex/llamaindex_processor.py,sha256=BRZWUSY5M6cpU1YpsBjL2jBtrWD2suWLN04eDcL1xsM,3903
 monocle_apptrace/instrumentation/metamodel/llamaindex/methods.py,sha256=OQjFgyBC6ykHOrsV3otw81gHPtPiAV20UUT_-c9L-Vs,5166
 monocle_apptrace/instrumentation/metamodel/llamaindex/entities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-monocle_apptrace/instrumentation/metamodel/llamaindex/entities/agent.py,sha256=sSJBS6F7lmQGeRSSbud9UTQ0l0R7SkClnVrpSJWVV5k,5256
+monocle_apptrace/instrumentation/metamodel/llamaindex/entities/agent.py,sha256=toYHGAoBFqyQU94oejX_xtCKp9djkXbWFluf-NJlkmc,5255
 monocle_apptrace/instrumentation/metamodel/llamaindex/entities/inference.py,sha256=sWXR1-Vp6QxQVm9yYrrb3N6i8vS4vuR7G1MkS-DFY9o,3401
 monocle_apptrace/instrumentation/metamodel/llamaindex/entities/retrieval.py,sha256=z9jWZW_UCYL0fKCUKXEiIzloZeYi14kGkOPqewO4If8,1952
 monocle_apptrace/instrumentation/metamodel/mcp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -118,7 +118,12 @@ monocle_apptrace/instrumentation/metamodel/mcp/_helper.py,sha256=m67hrdAD_plMdMO
 monocle_apptrace/instrumentation/metamodel/mcp/mcp_processor.py,sha256=bCAEUYNudGcXhpS-U7GP6Zt917AhvxJWJpoykfjE044,377
 monocle_apptrace/instrumentation/metamodel/mcp/methods.py,sha256=rgd5lZG8Z8x4vGZ5JxZiPeAwBoaZp6wOuwO8uYzHRCs,685
 monocle_apptrace/instrumentation/metamodel/mcp/entities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-monocle_apptrace/instrumentation/metamodel/mcp/entities/inference.py,sha256=CcceJdDcBtAMu4Jlpchd6qQ37KXNLeVzvulkj3L77sQ,1545
+monocle_apptrace/instrumentation/metamodel/mcp/entities/inference.py,sha256=hd1K63T3DHInaTvcCHm8VO7IZsT5cV3todvOucWPL34,1783
+monocle_apptrace/instrumentation/metamodel/mistral/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+monocle_apptrace/instrumentation/metamodel/mistral/_helper.py,sha256=XKMv7y9KKukduF3XveGAhUL14XPMxS0X9FSU4Rd4kHg,7392
+monocle_apptrace/instrumentation/metamodel/mistral/methods.py,sha256=G--5SBRNXXE-gRZAWxfEahnrZM40Nstc3cNUemWjioU,1441
+monocle_apptrace/instrumentation/metamodel/mistral/entities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+monocle_apptrace/instrumentation/metamodel/mistral/entities/inference.py,sha256=2W6IWvLSJYHdHJ30sQDdLkyitG8ZrGUPhKu2ULylooc,3243
 monocle_apptrace/instrumentation/metamodel/openai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 monocle_apptrace/instrumentation/metamodel/openai/_helper.py,sha256=Iy8bsvpMTXEj0Ay60aBZKT1u2h2fxllBCnj0zb7FLHc,14985
 monocle_apptrace/instrumentation/metamodel/openai/methods.py,sha256=jpqZyfiJbzMz1r3W3fwMCGiQsbiDSkhqgADJextGxFQ,1796
@@ -130,16 +135,16 @@ monocle_apptrace/instrumentation/metamodel/requests/_helper.py,sha256=GS03VbT9Li
 monocle_apptrace/instrumentation/metamodel/requests/methods.py,sha256=O7lkglRvV97zqnCu6r2JwvW8WQqi4uvlpmNkAPpXigE,440
 monocle_apptrace/instrumentation/metamodel/requests/entities/http.py,sha256=wM7HVf6GMnnso7sAO-YfRkYLWW21M_kLPMM8Ak9czLk,1751
 monocle_apptrace/instrumentation/metamodel/teamsai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-monocle_apptrace/instrumentation/metamodel/teamsai/_helper.py,sha256=9DJgmdHNEeTELnv4Qu0ZCbeknFFtTA8f0XsSOIsmETs,7195
+monocle_apptrace/instrumentation/metamodel/teamsai/_helper.py,sha256=0wX6HOdzjQecYnrzWmR0RBX3Bm_WWbq1bKJO8DUhfM4,7212
 monocle_apptrace/instrumentation/metamodel/teamsai/methods.py,sha256=5fPh2l8nSi524KwHGp-m6GVEy3lXmBG-97i7r0CpE2g,3453
 monocle_apptrace/instrumentation/metamodel/teamsai/sample.json,sha256=GnlzIad8rjugqkOh18bhKdxNlrJW77zSjwT6JEqDwyU,26003
 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=FRR9iBdDBXfYscP-lkORMNKl_lllflZN6gMlC7m_94w,3206
 monocle_apptrace/instrumentation/metamodel/teamsai/entities/inference/teamsai_output_processor.py,sha256=o9jrBIEqPDg3VfR6zexUCpkq3jlX0lQji8CKLUUK4Wk,3022
-monocle_apptrace-0.5.1b1.dist-info/METADATA,sha256=ScYyK_Mw2BqC9Eyet78MFcoV3b7CwtQ3GHkseNJQd2o,8013
-monocle_apptrace-0.5.1b1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-monocle_apptrace-0.5.1b1.dist-info/entry_points.txt,sha256=rxpPKb3klrgZEbSyOFQ2J6KRPO7ri9ES-zmC8Jtikx8,70
-monocle_apptrace-0.5.1b1.dist-info/licenses/LICENSE,sha256=ay9trLiP5I7ZsFXo6AqtkLYdRqe5S9r-DrPOvsNlZrg,9136
-monocle_apptrace-0.5.1b1.dist-info/licenses/NOTICE,sha256=9jn4xtwM_uUetJMx5WqGnhrR7MIhpoRlpokjSTlyt8c,112
-monocle_apptrace-0.5.1b1.dist-info/RECORD,,
+monocle_apptrace-0.5.3.dist-info/METADATA,sha256=Tg5j-g9XMePvDp0jbnZpYEvNhCfhQ4V4tXvaTj7H4jw,8011
+monocle_apptrace-0.5.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+monocle_apptrace-0.5.3.dist-info/entry_points.txt,sha256=rxpPKb3klrgZEbSyOFQ2J6KRPO7ri9ES-zmC8Jtikx8,70
+monocle_apptrace-0.5.3.dist-info/licenses/LICENSE,sha256=ay9trLiP5I7ZsFXo6AqtkLYdRqe5S9r-DrPOvsNlZrg,9136
+monocle_apptrace-0.5.3.dist-info/licenses/NOTICE,sha256=9jn4xtwM_uUetJMx5WqGnhrR7MIhpoRlpokjSTlyt8c,112
+monocle_apptrace-0.5.3.dist-info/RECORD,,