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

monocle_apptrace/instrumentation/metamodel/aiohttp/methods.py

@@ -0,0 +1,13 @@
+from monocle_apptrace.instrumentation.common.wrapper import atask_wrapper
+from monocle_apptrace.instrumentation.metamodel.aiohttp.entities.http import AIO_HTTP_PROCESSOR
+
+AIOHTTP_METHODS = [
+    {
+        "package": "aiohttp.web_app",
+        "object": "Application",
+        "method": "_handle",
+        "wrapper_method": atask_wrapper,
+        "span_handler": "aiohttp_handler",
+        "output_processor": AIO_HTTP_PROCESSOR
+    }
+]

monocle_apptrace/instrumentation/metamodel/flask/_helper.py

@@ -2,6 +2,8 @@ import logging
 from threading import local
 from monocle_apptrace.instrumentation.common.utils import extract_http_headers, clear_http_scopes
 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
 from urllib.parse import unquote
 from opentelemetry.context import get_current
 from opentelemetry.trace import Span, get_current_span
@@ -28,12 +30,15 @@ def get_body(args) -> dict:
 def extract_response(instance) -> str:
     if hasattr(instance, 'data') and hasattr(instance, 'content_length'):
         response = instance.data[0:max(instance.content_length, MAX_DATA_LENGTH)]
-    else:   
+    else:
         response = ""
     return response
 
 def extract_status(instance) -> str:
-    status = instance.status if hasattr(instance, 'status') else ""
+    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}")
     return status
 
 def flask_pre_tracing(args):
@@ -65,7 +70,7 @@ class FlaskResponseSpanHandler(SpanHandler):
             if _parent_span_context is not None:
                 parent_span: Span = _parent_span_context.get(_SPAN_KEY, None)
                 if parent_span is not None:
-                    self.hydrate_events(to_wrap, wrapped, instance, args, kwargs, return_value, parent_span)
+                    self.hydrate_events(to_wrap, wrapped, instance, args, kwargs, return_value, parent_span=parent_span)
         except Exception as e:
             logger.info(f"Failed to propogate flask response: {e}")
         super().post_tracing(to_wrap, wrapped, instance, args, kwargs, return_value)

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

@@ -18,7 +18,6 @@ FLASK_HTTP_PROCESSOR = {
 }
 
 FLASK_RESPONSE_PROCESSOR = {
-    "type": "http.process",
     "events": [
         {
             "name": "data.input",

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

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

monocle_apptrace/instrumentation/metamodel/haystack/methods.py

@@ -36,5 +36,12 @@ HAYSTACK_METHODS = [
         "object": "Pipeline",
         "method": "run",
         "wrapper_method": task_wrapper
-    }
+    },
+    {
+        "package": "haystack_integrations.components.generators.anthropic",
+        "object": "AnthropicChatGenerator",
+        "method": "run",
+        "wrapper_method": task_wrapper,
+        "output_processor": INFERENCE
+    },
 ]

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

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

monocle_apptrace/instrumentation/metamodel/llamaindex/_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

@@ -84,5 +84,19 @@ LLAMAINDEX_METHODS = [
         "method": "chat",
         "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"]
+                    ),
                 }
-            ]
-        }
-    ]
+            ],
+        },
+    ],
 }

monocle_apptrace/instrumentation/metamodel/openai/methods.py

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

monocle_apptrace/instrumentation/metamodel/requests/_helper.py

@@ -30,7 +30,7 @@ def extract_response(result) -> str:
     return result.text if hasattr(result, 'text') else str(result)
 
 def extract_status(result) -> str:
-    return f"{result.status_code} {result.reason}"
+    return f"{result.status_code}"
 
 
 def request_pre_task_processor(kwargs):

monocle_apptrace/instrumentation/metamodel/teamsai/_helper.py

@@ -1,4 +1,12 @@
 from monocle_apptrace.instrumentation.common.utils import MonocleSpanException
+from monocle_apptrace.instrumentation.common.utils import (
+    Option,
+    get_keys_as_tuple,
+    get_nested_value,
+    try_option,
+    get_exception_message,
+    get_exception_status_code
+)
 def capture_input(arguments):
     """
     Captures the input from Teams AI state.
@@ -51,8 +59,50 @@ def capture_prompt_info(arguments):
     except Exception as e:
         return f"Error capturing prompt: {str(e)}"
 
-def status_check(arguments):
-    if hasattr(arguments["result"], "error") and arguments["result"].error is not None:
-        error_msg:str = arguments["result"].error
-        error_code:str = arguments["result"].status if hasattr(arguments["result"], "status") else "unknown"
-        raise MonocleSpanException(f"Error: {error_code} - {error_msg}")
+def get_status_code(arguments):
+    if arguments["exception"] is not None:
+        return get_exception_status_code(arguments)
+    elif hasattr(arguments["result"], "status"):
+        return arguments["result"].status
+    else:
+        return 'success'
+
+def get_status(arguments):
+    if arguments["exception"] is not None:
+        return 'error'
+    elif get_status_code(arguments) == 'success':
+        return 'success'
+    else:
+        return 'error'
+    
+def get_response(arguments) -> str:
+    status = get_status_code(arguments)
+    response:str = ""
+    if status == 'success':
+        if hasattr(arguments["result"], "message"):
+            response = arguments["result"].message.content 
+        else:
+            response = str(arguments["result"])
+    else:
+        if arguments["exception"] is not None:
+            response = get_exception_message(arguments)
+        elif hasattr(arguments["result"], "error"):
+            response = arguments["result"].error
+    return response
+
+def check_status(arguments):
+    status = get_status_code(arguments)
+    if status != 'success':
+        raise MonocleSpanException(f"{status}")   
+
+def extract_provider_name(instance):
+    provider_url: Option[str] = try_option(getattr, instance._client.base_url, 'host')
+    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))