monocle-apptrace 0.3.1b1__py3-none-any.whl → 0.4.0__py3-none-any.whl

monocle_apptrace/instrumentation/metamodel/haystack/_helper.py

@@ -1,4 +1,5 @@
 import logging
+
 from monocle_apptrace.instrumentation.common.utils import (
     Option,
     get_keys_as_tuple,
@@ -11,13 +12,19 @@ logger = logging.getLogger(__name__)
 def extract_messages(kwargs):
     try:
         messages = []
+        system_message, user_message = None,None
         if isinstance(kwargs, dict):
             if 'system_prompt' in kwargs and kwargs['system_prompt']:
                 system_message = kwargs['system_prompt']
-                messages.append({"system" : system_message})
             if 'prompt' in kwargs and kwargs['prompt']:
                 user_message = extract_question_from_prompt(kwargs['prompt'])
+            if 'messages' in kwargs and len(kwargs['messages'])>1:
+                system_message = kwargs['messages'][0].text
+                user_message = kwargs['messages'][1].text
+            if system_message and user_message:
+                messages.append({"system": system_message})
                 messages.append({"user": user_message})
+
         return [str(message) for message in messages]
     except Exception as e:
         logger.warning("Warning: Error occurred in extract_messages: %s", str(e))
@@ -52,6 +59,8 @@ def extract_assistant_message(response):
             reply = response["replies"][0]
             if hasattr(reply, 'content'):
                 return [reply.content]
+            if hasattr(reply, 'text'):
+                return [reply.text]
             return [reply]
     except Exception as e:
         logger.warning("Warning: Error occurred in extract_assistant_message: %s", str(e))
@@ -108,15 +117,19 @@ def extract_embeding_model(instance):
 
 def update_span_from_llm_response(response, instance):
     meta_dict = {}
-    if response is not None and isinstance(response, dict) and "meta" in response:
-        token_usage = response["meta"][0]["usage"]
+    token_usage = None
+    if response is not None and isinstance(response, dict):
+        if "meta" in response:
+            token_usage = response["meta"][0]["usage"]
+        elif "replies" in response:  # and "meta" in response["replies"][0]:
+            token_usage = response["replies"][0].meta["usage"]
         if token_usage is not None:
             temperature = instance.__dict__.get("temperature", None)
             meta_dict.update({"temperature": temperature})
             meta_dict.update(
                 {"completion_tokens": token_usage.get("completion_tokens") or token_usage.get("output_tokens")})
             meta_dict.update({"prompt_tokens": token_usage.get("prompt_tokens") or token_usage.get("input_tokens")})
-            meta_dict.update({"total_tokens": token_usage.get("total_tokens")})
+            meta_dict.update({"total_tokens": token_usage.get("total_tokens") or token_usage.get("completion_tokens")+token_usage.get("prompt_tokens")})
     return meta_dict
 
 

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

@@ -1,15 +1,18 @@
 from monocle_apptrace.instrumentation.metamodel.haystack import (
     _helper,
 )
+from monocle_apptrace.instrumentation.common.utils import get_llm_type
 
 INFERENCE = {
-    "type": "inference",
+    "type": "inference.framework",
     "attributes": [
         [
             {
                 "_comment": "provider type ,name , deployment , inference_endpoint",
                 "attribute": "type",
-                "accessor": lambda arguments: 'inference.azure_openai'
+#                "accessor": lambda arguments: 'inference.azure_openai'
+                "accessor": lambda arguments: 'inference.' + (get_llm_type(arguments['instance']) or 'generic')
+
             },
             {
                 "attribute": "provider_name",

monocle_apptrace/instrumentation/metamodel/haystack/methods.py

@@ -7,7 +7,6 @@ HAYSTACK_METHODS = [
         "package": "haystack.components.retrievers.in_memory",
         "object": "InMemoryEmbeddingRetriever",
         "method": "run",
-        "span_name": "haystack.retriever",
         "wrapper_method": task_wrapper,
         "output_processor": RETRIEVAL
     },
@@ -15,7 +14,6 @@ HAYSTACK_METHODS = [
         "package": "haystack_integrations.components.retrievers.opensearch",
         "object": "OpenSearchEmbeddingRetriever",
         "method": "run",
-        "span_name": "haystack.retriever",
         "wrapper_method": task_wrapper,
         "output_processor": RETRIEVAL
     },
@@ -37,7 +35,13 @@ HAYSTACK_METHODS = [
         "package": "haystack.core.pipeline.pipeline",
         "object": "Pipeline",
         "method": "run",
+        "wrapper_method": task_wrapper
+    },
+    {
+        "package": "haystack_integrations.components.generators.anthropic",
+        "object": "AnthropicChatGenerator",
+        "method": "run",
         "wrapper_method": task_wrapper,
-        "span_type": "workflow"
-    }
+        "output_processor": INFERENCE
+    },
 ]

monocle_apptrace/instrumentation/metamodel/langchain/_helper.py

@@ -50,14 +50,22 @@ def extract_assistant_message(response):
 
 
 def extract_provider_name(instance):
-    provider_url: Option[str] = try_option(getattr, instance.client._client.base_url, 'host')
+    provider_url: Option[str] = None
+    if hasattr(instance,'client'):
+        provider_url: Option[str] = try_option(getattr, instance.client._client.base_url, 'host')
+    if hasattr(instance, '_client'):
+        provider_url = 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._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)
+    inference_endpoint: Option[str] = None
+    if hasattr(instance,'client'):
+        inference_endpoint: Option[str] = try_option(getattr, instance.client._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)
+    if hasattr(instance,'_client'):
+        inference_endpoint = try_option(getattr, instance._client, 'base_url').map(str)
 
     return inference_endpoint.unwrap_or(extract_provider_name(instance))
 

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

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

monocle_apptrace/instrumentation/metamodel/langchain/methods.py

@@ -11,15 +11,13 @@ LANGCHAIN_METHODS = [
         "package": "langchain.prompts.base",
         "object": "BasePromptTemplate",
         "method": "invoke",
-        "wrapper_method": task_wrapper,
-        "span_type": "workflow"
+        "wrapper_method": task_wrapper
     },
     {
         "package": "langchain.prompts.base",
         "object": "BasePromptTemplate",
         "method": "ainvoke",
-        "wrapper_method": atask_wrapper,
-        "span_type": "workflow"
+        "wrapper_method": atask_wrapper
     },
     {
         "package": "langchain.chat_models.base",
@@ -82,30 +80,24 @@ LANGCHAIN_METHODS = [
         "package": "langchain.schema",
         "object": "BaseOutputParser",
         "method": "invoke",
-        "wrapper_method": task_wrapper,
-        "span_type": "workflow"
+        "wrapper_method": task_wrapper
     },
     {
         "package": "langchain.schema",
         "object": "BaseOutputParser",
         "method": "ainvoke",
-        "wrapper_method": atask_wrapper,
-        "span_type": "workflow"
+        "wrapper_method": atask_wrapper
     },
     {
         "package": "langchain.schema.runnable",
         "object": "RunnableSequence",
         "method": "invoke",
-        "span_name": "langchain.workflow",
-        "wrapper_method": task_wrapper,
-        "span_type": "workflow"
+        "wrapper_method": task_wrapper
     },
     {
         "package": "langchain.schema.runnable",
         "object": "RunnableSequence",
         "method": "ainvoke",
-        "span_name": "langchain.workflow",
-        "wrapper_method": atask_wrapper,
-        "span_type": "workflow"
+        "wrapper_method": atask_wrapper
     }
 ]

monocle_apptrace/instrumentation/metamodel/llamaindex/_helper.py

@@ -96,12 +96,19 @@ def extract_query_from_content(content):
 
 
 def extract_provider_name(instance):
-    provider_url = try_option(getattr, instance, 'api_base').and_then(lambda url: urlparse(url).hostname)
-    return provider_url
+    if hasattr(instance,'api_base'):
+        provider_url: Option[str]= try_option(getattr, instance, 'api_base').and_then(lambda url: urlparse(url).hostname)
+    if hasattr(instance,'_client'):
+        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 = try_option(getattr, instance._client.sdk_configuration, 'server_url').map(str)
+    if hasattr(instance,'_client'):
+        if hasattr(instance._client,'sdk_configuration'):
+            inference_endpoint: Option[str] = try_option(getattr, instance._client.sdk_configuration, 'server_url').map(str)
+        if hasattr(instance._client,'base_url'):
+            inference_endpoint: Option[str] = try_option(getattr, instance._client, 'base_url').map(str)
     return inference_endpoint.unwrap_or(extract_provider_name(instance))
 
 
@@ -163,10 +170,7 @@ def update_span_from_llm_response(response, instance):
             if token_usage is not None:
                 temperature = instance.__dict__.get("temperature", None)
                 meta_dict.update({"temperature": temperature})
-                if getattr(token_usage, "completion_tokens", None):
-                    meta_dict.update({"completion_tokens": getattr(token_usage, "completion_tokens")})
-                if getattr(token_usage, "prompt_tokens", None):
-                    meta_dict.update({"prompt_tokens": getattr(token_usage, "prompt_tokens")})
-                if getattr(token_usage, "total_tokens", None):
-                    meta_dict.update({"total_tokens": getattr(token_usage, "total_tokens")})
+                meta_dict.update({"completion_tokens": getattr(token_usage, "completion_tokens",None) or getattr(token_usage,"output_tokens",None)})
+                meta_dict.update({"prompt_tokens": getattr(token_usage, "prompt_tokens",None) or getattr(token_usage,"input_tokens",None)})
+                meta_dict.update({"total_tokens": getattr(token_usage, "total_tokens",None) or getattr(token_usage,"output_tokens",None)+getattr(token_usage,"input_tokens",None)})
     return meta_dict

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

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

monocle_apptrace/instrumentation/metamodel/llamaindex/methods.py

@@ -13,7 +13,6 @@ LLAMAINDEX_METHODS = [
         "package": "llama_index.core.indices.base_retriever",
         "object": "BaseRetriever",
         "method": "retrieve",
-        "span_name": "llamaindex.retrieve",
         "wrapper_method": task_wrapper,
         "output_processor": RETRIEVAL
     },
@@ -21,7 +20,6 @@ LLAMAINDEX_METHODS = [
         "package": "llama_index.core.indices.base_retriever",
         "object": "BaseRetriever",
         "method": "aretrieve",
-        "span_name": "llamaindex.retrieve",
         "wrapper_method": atask_wrapper,
         "output_processor": RETRIEVAL
     },
@@ -29,23 +27,18 @@ LLAMAINDEX_METHODS = [
         "package": "llama_index.core.base.base_query_engine",
         "object": "BaseQueryEngine",
         "method": "query",
-        "span_name": "llamaindex.query",
-        "wrapper_method": task_wrapper,
-        "span_type": "workflow"
+        "wrapper_method": task_wrapper
     },
     {
         "package": "llama_index.core.base.base_query_engine",
         "object": "BaseQueryEngine",
         "method": "aquery",
-        "span_name": "llamaindex.query",
-        "wrapper_method": atask_wrapper,
-        "span_type": "workflow"
+        "wrapper_method": atask_wrapper
     },
     {
         "package": "llama_index.core.llms.custom",
         "object": "CustomLLM",
         "method": "chat",
-        "span_name": "llamaindex.llmchat",
         "wrapper_method": task_wrapper,
         "output_processor": INFERENCE
     },
@@ -53,7 +46,6 @@ LLAMAINDEX_METHODS = [
         "package": "llama_index.core.llms.custom",
         "object": "CustomLLM",
         "method": "achat",
-        "span_name": "llamaindex.llmchat",
         "wrapper_method": atask_wrapper,
         "output_processor": INFERENCE,
         
@@ -62,7 +54,6 @@ LLAMAINDEX_METHODS = [
         "package": "llama_index.llms.openai.base",
         "object": "OpenAI",
         "method": "chat",
-        "span_name": "llamaindex.openai",
         "wrapper_method": task_wrapper,
         "output_processor": INFERENCE
     },
@@ -70,7 +61,6 @@ LLAMAINDEX_METHODS = [
         "package": "llama_index.llms.openai.base",
         "object": "OpenAI",
         "method": "achat",
-        "span_name": "llamaindex.openai",
         "wrapper_method": atask_wrapper,
         "output_processor": INFERENCE
     },
@@ -78,7 +68,6 @@ LLAMAINDEX_METHODS = [
         "package": "llama_index.llms.mistralai.base",
         "object": "MistralAI",
         "method": "chat",
-        "span_name": "llamaindex.mistralai",
         "wrapper_method": task_wrapper,
         "output_processor": INFERENCE
     },
@@ -86,7 +75,6 @@ LLAMAINDEX_METHODS = [
         "package": "llama_index.llms.mistralai.base",
         "object": "MistralAI",
         "method": "achat",
-        "span_name": "llamaindex.mistralai",
         "wrapper_method": atask_wrapper,
         "output_processor": INFERENCE
     },
@@ -94,8 +82,21 @@ LLAMAINDEX_METHODS = [
         "package": "llama_index.core.agent",
         "object": "ReActAgent",
         "method": "chat",
-        "span_name": "react.agent",
         "wrapper_method": task_wrapper,
         "output_processor": AGENT
+    },
+    {
+        "package": "llama_index.llms.anthropic",
+        "object": "Anthropic",
+        "method": "chat",
+        "wrapper_method": task_wrapper,
+        "output_processor": INFERENCE
+    },
+    {
+        "package": "llama_index.llms.anthropic",
+        "object": "Anthropic",
+        "method": "achat",
+        "wrapper_method": atask_wrapper,
+        "output_processor": INFERENCE
     }
 ]

monocle_apptrace/instrumentation/metamodel/openai/_helper.py

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

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

@@ -1,71 +1,229 @@
+import logging
+import random
+import time
+from types import SimpleNamespace
 from monocle_apptrace.instrumentation.metamodel.openai import (
     _helper,
 )
-from monocle_apptrace.instrumentation.common.utils import resolve_from_alias
+from monocle_apptrace.instrumentation.common.utils import (
+    patch_instance_method,
+    resolve_from_alias,
+    get_status,
+    get_exception_status_code
+)
+
+logger = logging.getLogger(__name__)
+
+
+def process_stream(to_wrap, response, span_processor):
+    waiting_for_first_token = True
+    stream_start_time = time.time_ns()
+    first_token_time = stream_start_time
+    stream_closed_time = None
+    accumulated_response = ""
+    token_usage = None
+    accumulated_temp_list = []
+
+    if to_wrap and hasattr(response, "__iter__"):
+        original_iter = response.__iter__
+
+        def new_iter(self):
+            nonlocal waiting_for_first_token, first_token_time, stream_closed_time, accumulated_response, token_usage
+
+            for item in original_iter():
+                try:
+                    if (
+                        item.choices
+                        and item.choices[0].delta
+                        and item.choices[0].delta.content
+                    ):
+                        if waiting_for_first_token:
+                            waiting_for_first_token = False
+                            first_token_time = time.time_ns()
+
+                        accumulated_response += item.choices[0].delta.content
+                        # token_usage = item.usage
+                    elif item.object == "chat.completion.chunk" and item.usage:
+                        # Handle the case where the response is a chunk
+                        token_usage = item.usage
+                        stream_closed_time = time.time_ns()
+
+                except Exception as e:
+                    logger.warning(
+                        "Warning: Error occurred while processing item in new_iter: %s",
+                        str(e),
+                    )
+                finally:
+                    accumulated_temp_list.append(item)
+                    yield item
+
+            if span_processor:
+                ret_val = SimpleNamespace(
+                    type="stream",
+                    timestamps={
+                        "data.input": int(stream_start_time),
+                        "data.output": int(first_token_time),
+                        "metadata": int(stream_closed_time or time.time_ns()),
+                    },
+                    output_text=accumulated_response,
+                    usage=token_usage,
+                )
+                span_processor(ret_val)
+
+        patch_instance_method(response, "__iter__", new_iter)
+        
+    if to_wrap and hasattr(response, "__aiter__"):
+        original_iter = response.__aiter__
+
+        async def new_aiter(self):
+            nonlocal waiting_for_first_token, first_token_time, stream_closed_time, accumulated_response, token_usage
+
+            async for item in original_iter():
+                try:
+                    if (
+                        item.choices
+                        and item.choices[0].delta
+                        and item.choices[0].delta.content
+                    ):
+                        if waiting_for_first_token:
+                            waiting_for_first_token = False
+                            first_token_time = time.time_ns()
+
+                        accumulated_response += item.choices[0].delta.content
+                        # token_usage = item.usage
+                    elif item.object == "chat.completion.chunk" and item.usage:
+                        # Handle the case where the response is a chunk
+                        token_usage = item.usage
+                        stream_closed_time = time.time_ns()
+
+                except Exception as e:
+                    logger.warning(
+                        "Warning: Error occurred while processing item in new_aiter: %s",
+                        str(e),
+                    )
+                finally:
+                    accumulated_temp_list.append(item)
+                    yield item
+
+            if span_processor:
+                ret_val = SimpleNamespace(
+                    type="stream",
+                    timestamps={
+                        "data.input": int(stream_start_time),
+                        "data.output": int(first_token_time),
+                        "metadata": int(stream_closed_time or time.time_ns()),
+                    },
+                    output_text=accumulated_response,
+                    usage=token_usage,
+                )
+                span_processor(ret_val)
+
+        patch_instance_method(response, "__aiter__", new_aiter)
+
 
 INFERENCE = {
     "type": "inference",
+    "is_auto_close": lambda kwargs: kwargs.get("stream", False) is False,
+    "response_processor": process_stream,
     "attributes": [
         [
             {
                 "_comment": "provider type ,name , deployment , inference_endpoint",
                 "attribute": "type",
-                "accessor": lambda arguments: 'inference.' + (_helper.get_inference_type(arguments['instance'])) or 'openai'
+                "accessor": lambda arguments: "inference."
+                + (_helper.get_inference_type(arguments["instance"]))
+                or "openai",
             },
             {
                 "attribute": "provider_name",
-                "accessor": lambda arguments: _helper.extract_provider_name(arguments['instance'])
+                "accessor": lambda arguments: _helper.extract_provider_name(
+                    arguments["instance"]
+                ),
             },
             {
                 "attribute": "deployment",
-                "accessor": lambda arguments: resolve_from_alias(arguments['instance'].__dict__, ['engine', 'azure_deployment', 'deployment_name', 'deployment_id', 'deployment'])
+                "accessor": lambda arguments: resolve_from_alias(
+                    arguments["instance"].__dict__,
+                    [
+                        "engine",
+                        "azure_deployment",
+                        "deployment_name",
+                        "deployment_id",
+                        "deployment",
+                    ],
+                ),
             },
             {
                 "attribute": "inference_endpoint",
-                "accessor": lambda arguments: resolve_from_alias(arguments['instance'].__dict__, ['azure_endpoint', 'api_base', 'endpoint']) or _helper.extract_inference_endpoint(arguments['instance'])
-            }
+                "accessor": lambda arguments: resolve_from_alias(
+                    arguments["instance"].__dict__,
+                    ["azure_endpoint", "api_base", "endpoint"],
+                )
+                or _helper.extract_inference_endpoint(arguments["instance"]),
+            },
         ],
         [
             {
                 "_comment": "LLM Model",
                 "attribute": "name",
-                "accessor": lambda arguments: resolve_from_alias(arguments['kwargs'], ['model', 'model_name', 'endpoint_name', 'deployment_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'])
-            }
-        ]
+                "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.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": [
                 {
                     "_comment": "this is result from LLM",
                     "attribute": "response",
-                    "accessor": lambda arguments: _helper.extract_assistant_message(arguments['result'])
+                    "accessor": lambda arguments: _helper.extract_assistant_message(
+                        arguments,
+                    ),
+                },
+                {
+                    "attribute": "status",
+                    "accessor": lambda arguments: get_status(arguments)
+                },
+                {
+                    "attribute": "status_code",
+                    "accessor": lambda arguments: get_exception_status_code(arguments)
                 }
-            ]
+            ],
         },
         {
             "name": "metadata",
             "attributes": [
                 {
                     "_comment": "this is metadata usage from LLM",
-                    "accessor": lambda arguments: _helper.update_span_from_llm_response(arguments['result'])
+                    "accessor": lambda arguments: _helper.update_span_from_llm_response(
+                        arguments["result"]
+                    ),
                 }
-            ]
-        }
-    ]
+            ],
+        },
+    ],
 }