monocle-apptrace 0.5.2__py3-none-any.whl → 0.6.0__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)
@@ -50,6 +55,9 @@ class FileSpanExporter(SpanExporterBase):
         else:
             return self._process_spans(spans, is_root_span=is_root_span)
 
+    def set_service_name(self, service_name: str) -> None:
+        self.service_name = service_name
+
     def _cleanup_expired_handles(self) -> None:
         """Close and remove file handles that have exceeded the timeout."""
         current_time = datetime.now()
@@ -96,6 +104,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)."""
@@ -123,7 +133,10 @@ class FileSpanExporter(SpanExporterBase):
         
         # Process spans for each trace
         for trace_id, trace_spans in spans_by_trace.items():
-            service_name = trace_spans[0].resource.attributes.get(SERVICE_NAME, "unknown")
+            if self.service_name is not None:
+                service_name = self.service_name
+            else:
+                service_name = trace_spans[0].resource.attributes.get(SERVICE_NAME, "unknown")
             handle, file_path, is_first_span = self._get_or_create_handle(trace_id, service_name)
             
             if handle is None:

monocle_apptrace/instrumentation/common/instrumentor.py

@@ -165,7 +165,7 @@ def setup_monocle_telemetry(
         span_handlers: Dict[str,SpanHandler] = None,
         wrapper_methods: List[Union[dict,WrapperMethod]] = None,
         union_with_default_methods: bool = True,
-        monocle_exporters_list:str = None) -> None:
+        monocle_exporters_list:str = None) -> MonocleInstrumentor:
     """
     Set up Monocle telemetry for the application.
 

monocle_apptrace/instrumentation/common/span_handler.py

@@ -26,6 +26,8 @@ WORKFLOW_TYPE_MAP = {
     "anthropic": "workflow.anthropic",
     "gemini": "workflow.gemini",
     "litellm": "workflow.litellm",
+    "mistralai": "workflow.mistral",
+    "huggingface_hub": "workflow.huggingface"
 }
 
 FRAMEWORK_WORKFLOW_LIST = [
@@ -185,7 +187,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 +200,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

@@ -5,6 +5,7 @@ from monocle_apptrace.instrumentation.common.span_handler import SpanHandler, No
 from monocle_apptrace.instrumentation.metamodel.azureaiinference.methods import AZURE_AI_INFERENCE_METHODS
 from monocle_apptrace.instrumentation.metamodel.botocore.methods import BOTOCORE_METHODS
 from monocle_apptrace.instrumentation.metamodel.botocore.handlers.botocore_span_handler import BotoCoreSpanHandler
+from monocle_apptrace.instrumentation.metamodel.hugging_face.methods import HUGGING_FACE_METHODS
 from monocle_apptrace.instrumentation.metamodel.langchain.methods import (
     LANGCHAIN_METHODS,
 )
@@ -37,6 +38,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 +109,9 @@ DEFAULT_METHODS_LIST = (
     MCP_METHODS + 
     A2A_CLIENT_METHODS +
     LITELLM_METHODS +
-    ADK_METHODS
+    ADK_METHODS +
+    MISTRAL_METHODS +
+    HUGGING_FACE_METHODS
 )
 
 MONOCLE_SPAN_HANDLERS: Dict[str, SpanHandler] = {

monocle_apptrace/instrumentation/metamodel/adk/_helper.py

@@ -82,7 +82,7 @@ def extract_agent_input(arguments: Dict[str, Any]) -> Any:
     Returns:
         Any: The extracted input data
     """
-    return arguments['args'][0].user_content.parts[0].text
+    return [arguments['args'][0].user_content.parts[0].text]
 
 def extract_agent_request_input(arguments: Dict[str, Any]) -> Any:
     """
@@ -94,7 +94,7 @@ def extract_agent_request_input(arguments: Dict[str, Any]) -> Any:
     Returns:
         Any: The extracted input data
     """
-    return arguments['kwargs']['new_message'].parts[0].text if 'new_message' in arguments['kwargs'] else None
+    return [arguments['kwargs']['new_message'].parts[0].text] if 'new_message' in arguments['kwargs'] else []
 
 def extract_agent_response(result: Any) -> Any:
     """
@@ -107,7 +107,9 @@ def extract_agent_response(result: Any) -> Any:
         Any: The extracted response data
     """
     if result:
-        return result.content.parts[0].text
+        return str(result.content.parts[0].text)
+    else:
+        return ""
 
 def get_tool_name(instance: Any) -> str:
     """
@@ -179,7 +181,7 @@ def extract_tool_input(arguments: Dict[str, Any]) -> Any:
     Returns:
         Any: The extracted input data
     """
-    return str(arguments['kwargs'].get('args'))
+    return [str(arguments['kwargs'].get('args'))]
 
 def extract_tool_response(result: Any) -> Any:
     """

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

@@ -1,5 +1,7 @@
 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
+from monocle_apptrace.instrumentation.common.utils import get_error_message
 AGENT = {
       "type": SPAN_TYPES.AGENTIC_INVOCATION,
       "subtype": SPAN_SUBTYPES.ROUTING,
@@ -33,7 +35,7 @@ AGENT = {
           "attributes": [
             {
                 "_comment": "this is Agent input",
-                "attribute": "query",
+                "attribute": "input",
                 "accessor": lambda arguments: _helper.extract_agent_input(arguments)
             }
           ]
@@ -41,10 +43,18 @@ AGENT = {
         {
           "name":"data.output",
           "attributes": [
+            {
+                    "attribute": "error_code",
+                    "accessor": lambda arguments: get_error_message(arguments)
+            },
             {
                 "_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 +118,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/_helper.py

@@ -50,21 +50,21 @@ def extract_agent_input(arguments):
         if len(arguments["args"]) > 1:
             input_data = arguments["args"][1]
             if isinstance(input_data, str):
-                return input_data
+                return [input_data]
             elif isinstance(input_data, list):
                 # Handle list of input items
-                return get_json_dumps(input_data)
+                return input_data
 
         # Fallback to kwargs
         if "original_input" in arguments["kwargs"]:
             input_data = arguments["kwargs"]["original_input"]
             if isinstance(input_data, str):
-                return input_data
+                return [input_data]
             elif isinstance(input_data, list):
-                return get_json_dumps(input_data)
+                return input_data
     except Exception as e:
         logger.warning("Warning: Error occurred in extract_agent_input: %s", str(e))
-    return None
+    return []
 
 
 def get_agent_name(arguments) -> str:

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

@@ -1,5 +1,7 @@
 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
+from monocle_apptrace.instrumentation.common.utils import get_error_message
 
 AGENT = {
     "type": SPAN_TYPES.AGENTIC_INVOCATION,
@@ -34,7 +36,7 @@ AGENT = {
             "attributes": [
                 {
                     "_comment": "this is Agent input",
-                    "attribute": "query",
+                    "attribute": "input",
                     "accessor": lambda arguments: _helper.extract_agent_input(
                         arguments
                     ),
@@ -44,12 +46,20 @@ AGENT = {
         {
             "name": "data.output",
             "attributes": [
+                {
+                    "attribute": "error_code",
+                    "accessor": lambda arguments: get_error_message(arguments)
+                },
                 {
                     "_comment": "this is response from Agent",
                     "attribute": "response",
                     "accessor": lambda arguments: _helper.extract_agent_response(
                         arguments["result"]
                     ),
+            },
+            {
+                "attribute": "error_code",
+                "accessor": lambda arguments: get_error_message(arguments)
                 }
             ],
         },
@@ -68,7 +78,7 @@ AGENT = {
 }
 
 AGENT_REQUEST = {
-    "type": AGENT_REQUEST_SPAN_NAME,
+    "type": SPAN_TYPES.AGENTIC_REQUEST,
     "subtype": SPAN_SUBTYPES.PLANNING,
     "attributes": [
         [
@@ -101,8 +111,11 @@ AGENT_REQUEST = {
                     "accessor": lambda arguments: _helper.extract_agent_response(
                         arguments["result"]
                     ),
-                }
-            ],
+            },
+            {
+                "attribute": "error_code",
+                "accessor": lambda arguments: get_error_message(arguments)
+            }],
         },
     ],
 }
@@ -151,7 +164,7 @@ TOOLS = {
             "attributes": [
                 {
                     "_comment": "this is Tool input",
-                    "attribute": "Inputs",
+                    "attribute": "input",
                     "accessor": lambda arguments: _helper.extract_tool_input(arguments),
                 },
             ],
@@ -165,6 +178,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",