monocle-apptrace 0.5.1b1__tar.gz → 0.5.3__tar.gz

{monocle_apptrace-0.5.1b1 → monocle_apptrace-0.5.3}/PKG-INFO

@@ -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 → monocle_apptrace-0.5.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "monocle_apptrace"
-version = "0.5.1b1"
+version = "0.5.3"
 authors = [
   { name="Okahu Inc.", email="okahu-pypi@okahu.ai" },
 ]

{monocle_apptrace-0.5.1b1 → monocle_apptrace-0.5.3}/src/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-0.5.1b1 → monocle_apptrace-0.5.3}/src/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-0.5.1b1 → monocle_apptrace-0.5.3}/src/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-0.5.1b1 → monocle_apptrace-0.5.3}/src/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-0.5.1b1 → monocle_apptrace-0.5.3}/src/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-0.5.1b1 → monocle_apptrace-0.5.3}/src/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-0.5.1b1 → monocle_apptrace-0.5.3}/src/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-0.5.1b1 → monocle_apptrace-0.5.3}/src/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-0.5.1b1 → monocle_apptrace-0.5.3}/src/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-0.5.1b1 → monocle_apptrace-0.5.3}/src/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-0.5.1b1 → monocle_apptrace-0.5.3}/src/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-0.5.1b1 → monocle_apptrace-0.5.3}/src/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-0.5.1b1 → monocle_apptrace-0.5.3}/src/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-0.5.3/src/monocle_apptrace/instrumentation/metamodel/fastapi/methods.py

@@ -0,0 +1,23 @@
+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": 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-0.5.1b1 → monocle_apptrace-0.5.3}/src/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-0.5.1b1 → monocle_apptrace-0.5.3}/src/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",