monocle-apptrace 0.3.0b6__py3-none-any.whl → 0.3.1b1__py3-none-any.whl

monocle_apptrace/instrumentation/common/instrumentor.py

@@ -17,13 +17,13 @@ from opentelemetry.trace import get_tracer
 from wrapt import wrap_function_wrapper
 from opentelemetry.trace.propagation import set_span_in_context, _SPAN_KEY
 from monocle_apptrace.exporters.monocle_exporters import get_monocle_exporter
-from monocle_apptrace.instrumentation.common.span_handler import SpanHandler
+from monocle_apptrace.instrumentation.common.span_handler import SpanHandler, NonFrameworkSpanHandler
 from monocle_apptrace.instrumentation.common.wrapper_method import (
     DEFAULT_METHODS_LIST,
     WrapperMethod,
     MONOCLE_SPAN_HANDLERS
 )
-from monocle_apptrace.instrumentation.common.wrapper import scope_wrapper, ascope_wrapper
+from monocle_apptrace.instrumentation.common.wrapper import scope_wrapper, ascope_wrapper, wrapper_processor
 from monocle_apptrace.instrumentation.common.utils import (
     set_scope, remove_scope, http_route_handler, load_scopes, async_wrapper, http_async_route_handler
 )
@@ -65,13 +65,11 @@ class MonocleInstrumentor(BaseInstrumentor):
         def instrumented_endpoint_invoke(to_wrap,wrapped, span_name, instance,fn):
             @wraps(fn)
             def with_instrumentation(*args, **kwargs):
-                handler = SpanHandler()
-                with tracer.start_as_current_span(span_name) as span:
-                    response = fn(*args, **kwargs)
-                    handler.hydrate_span(to_wrap, wrapped=wrapped, instance=instance, args=args, kwargs=kwargs,
-                                         result=response, span=span)
-                    return response
-
+                async_task = inspect.iscoroutinefunction(fn)
+                boto_method_to_wrap = to_wrap.copy()
+                boto_method_to_wrap['skip_span'] = False
+                return wrapper_processor(async_task, tracer, NonFrameworkSpanHandler(),
+                            boto_method_to_wrap, fn, instance, args, kwargs)
             return with_instrumentation
         return instrumented_endpoint_invoke
 
@@ -158,6 +156,24 @@ def setup_monocle_telemetry(
         span_handlers: Dict[str,SpanHandler] = None,
         wrapper_methods: List[Union[dict,WrapperMethod]] = None,
         union_with_default_methods: bool = True) -> None:
+    """
+    Set up Monocle telemetry for the application.
+
+    Parameters
+    ----------
+    workflow_name : str
+        The name of the workflow to be used as the service name in telemetry.
+    span_processors : List[SpanProcessor], optional
+        Custom span processors to use instead of the default ones. If None, 
+        BatchSpanProcessors with Monocle exporters will be used.
+    span_handlers : Dict[str, SpanHandler], optional
+        Dictionary of span handlers to be used by the instrumentor, mapping handler names to handler objects.
+    wrapper_methods : List[Union[dict, WrapperMethod]], optional
+        Custom wrapper methods for instrumentation. If None, default methods will be used.
+    union_with_default_methods : bool, default=True
+        If True, combine the provided wrapper_methods with the default methods.
+        If False, only use the provided wrapper_methods.
+    """
     resource = Resource(attributes={
         SERVICE_NAME: workflow_name
     })
@@ -196,6 +212,16 @@ def set_context_properties(properties: dict) -> None:
     attach(set_value(SESSION_PROPERTIES_KEY, properties))
 
 def start_trace():
+    """
+    Starts a new trace. All the spans created after this call will be part of the same trace. 
+    Returns:
+        Token: A token representing the attached context for the workflow span.
+                      This token is to be used later to stop the current trace.
+                      Returns None if tracing fails.
+    
+    Raises:
+        Exception: The function catches all exceptions internally and logs a warning.
+    """
     try:
         tracer = get_tracer(instrumenting_module_name= MONOCLE_INSTRUMENTOR, tracer_provider= get_tracer_provider())
         span = tracer.start_span(name = "workflow")
@@ -209,6 +235,14 @@ def start_trace():
         return None
 
 def stop_trace(token) -> None:
+    """
+    Stop the active trace and detach workflow type if token is provided. All the spans created after this will not be part of the trace.
+    Args:
+        token: The token that was returned when the trace was started. Used to detach 
+               workflow type. Can be None in which case only the span is ended.
+    Returns:
+        None
+    """
     try:
         _parent_span_context = get_current()
         if _parent_span_context is not None:
@@ -229,32 +263,67 @@ def is_valid_trace_id_uuid(traceId: str) -> bool:
     return False
 
 def start_scope(scope_name: str, scope_value:str = None) -> object:
+    """
+    Start a new scope with the given name and and optional value. If no value is provided, a random UUID will be generated.
+    All the spans, across traces created after this call will have the scope attached until the scope is stopped.
+    Args:
+        scope_name: The name of the scope.
+        scope_value: Optional value of the scope. If None, a random UUID will be generated.
+    Returns:
+        Token: A token representing the attached context for the scope. This token is to be used later to stop the current scope.
+    """
     return set_scope(scope_name, scope_value)
 
 def stop_scope(token:object) -> None:
+    """
+    Stop the active scope. All the spans created after this will not have the scope attached.
+    Args:
+        token: The token that was returned when the scope was started.
+    Returns:
+        None
+    """
     remove_scope(token)
     return
 
+@contextmanager
+def monocle_trace():
+    """
+    Context manager to start and stop a scope. All the spans, across traces created within the encapsulated code will have same trace ID
+    """
+    token = start_trace()
+    try:
+        yield
+    finally:
+        stop_trace(token)
+
 @contextmanager
 def monocle_trace_scope(scope_name: str, scope_value:str = None):
+    """
+    Context manager to start and stop a scope. All the spans, across traces created within the encapsulated code will have the scope attached.
+    Args:
+        scope_name: The name of the scope.
+        scope_value: Optional value of the scope. If None, a random UUID will be generated."""
     token = start_scope(scope_name, scope_value)
     try:
         yield
     finally:
         stop_scope(token)
     
-def monocle_trace_scope_method(scope_name: str):
+def monocle_trace_scope_method(scope_name: str, scope_value:str=None):
+    """
+    Decorator to start and stop a scope for a method. All the spans, across traces created in the method will have the scope attached.
+    """
     def decorator(func):
         if inspect.iscoroutinefunction(func):
             @wraps(func)
             async def wrapper(*args, **kwargs):
-                result = async_wrapper(func, scope_name, None, *args, **kwargs)
+                result = async_wrapper(func, scope_name, scope_value, None, *args, **kwargs)
                 return result
             return wrapper
         else:
             @wraps(func)
             def wrapper(*args, **kwargs):
-                token = start_scope(scope_name)
+                token = start_scope(scope_name, scope_value)
                 try:
                     result = func(*args, **kwargs)
                     return result
@@ -264,6 +333,10 @@ def monocle_trace_scope_method(scope_name: str):
     return decorator
 
 def monocle_trace_http_route(func):
+    """
+    Decorator to start and stop a continue traces and scope for a http route. It will also initiate new scopes from the http headers if configured in ``monocle_scopes.json``
+    All the spans, across traces created in the route will have the scope attached.
+    """
     if inspect.iscoroutinefunction(func):
         @wraps(func)
         async def wrapper(*args, **kwargs):
@@ -286,3 +359,4 @@ class FixedIdGenerator(id_generator.IdGenerator):
 
     def generate_trace_id(self) -> int:
         return self.trace_id
+

monocle_apptrace/instrumentation/common/span_handler.py

@@ -3,14 +3,14 @@ import os
 from importlib.metadata import version
 from opentelemetry.context import get_value, set_value, attach, detach
 from opentelemetry.sdk.trace import Span
-
+from opentelemetry.trace.status import Status, StatusCode
 from monocle_apptrace.instrumentation.common.constants import (
     QUERY,
     service_name_map,
     service_type_map,
     MONOCLE_SDK_VERSION
 )
-from monocle_apptrace.instrumentation.common.utils import set_attribute, get_scopes
+from monocle_apptrace.instrumentation.common.utils import set_attribute, get_scopes, MonocleSpanException
 from monocle_apptrace.instrumentation.common.constants import WORKFLOW_TYPE_KEY, WORKFLOW_TYPE_GENERIC
 
 logger = logging.getLogger(__name__)
@@ -64,9 +64,12 @@ class SpanHandler:
         """ Set attributes of workflow if this is a root span"""
         SpanHandler.set_workflow_attributes(to_wrap, span)
         SpanHandler.set_app_hosting_identifier_attribute(span)
+        span.set_status(StatusCode.OK)
 
-    def post_task_processing(self, to_wrap, wrapped, instance, args, kwargs, result, span):
-        pass
+
+    def post_task_processing(self, to_wrap, wrapped, instance, args, kwargs, result, span:Span):
+        if span.status.status_code == StatusCode.UNSET:
+            span.set_status(StatusCode.OK)
 
     def hydrate_span(self, to_wrap, wrapped, instance, args, kwargs, result, span):
         self.hydrate_attributes(to_wrap, wrapped, instance, args, kwargs, result, span)
@@ -95,6 +98,8 @@ class SpanHandler:
                                 result = accessor(arguments)
                                 if result and isinstance(result, (str, list)):
                                     span.set_attribute(attribute_name, result)
+                            except MonocleSpanException as e:
+                                span.set_status(StatusCode.ERROR, e.message)
                             except Exception as e:
                                 logger.debug(f"Error processing accessor: {e}")
                         else:
@@ -131,6 +136,8 @@ class SpanHandler:
                                     event_attributes[attribute_key] = accessor(arguments)
                                 else:
                                     event_attributes.update(accessor(arguments))
+                            except MonocleSpanException as e:
+                                span.set_status(StatusCode.ERROR, e.message)
                             except Exception as e:
                                 logger.debug(f"Error evaluating accessor for attribute '{attribute_key}': {e}")
                     span.add_event(name=event_name, attributes=event_attributes)

monocle_apptrace/instrumentation/common/utils.py

@@ -21,6 +21,21 @@ embedding_model_context = {}
 scope_id_generator = id_generator.RandomIdGenerator()
 http_scopes:dict[str:str] = {}
 
+class MonocleSpanException(Exception):
+    def __init__(self, err_message:str):
+        """
+        Monocle exeption to indicate error in span processing.        
+        Parameters:
+        - err_message (str): Error message.
+        - status (str): Status code
+        """
+        super().__init__(err_message)
+        self.message = err_message
+
+    def __str__(self):
+        """String representation of the exception."""
+        return f"[Monocle Span Error: {self.message} {self.status}"
+
 def set_tracer_provider(tracer_provider: TracerProvider):
     global monocle_tracer_provider
     monocle_tracer_provider = tracer_provider
@@ -252,35 +267,49 @@ async def http_async_route_handler(func, *args, **kwargs):
         headers = kwargs['req'].headers
     else:
         headers = None
-    return async_wrapper(func, None, headers, *args, **kwargs)
+    return async_wrapper(func, None, None, headers, *args, **kwargs)
 
-def run_async_with_scope(method, scope_name, headers, *args, **kwargs):
+def run_async_with_scope(method, current_context, exceptions, *args, **kwargs):
     token = None
-    if scope_name:
-        token = set_scope(scope_name)
-    elif headers:
-        token = extract_http_headers(headers)
     try:
+        if current_context:
+            token = attach(current_context)
         return asyncio.run(method(*args, **kwargs))
+    except Exception as e:
+        exceptions['exception'] = e
+        raise e
     finally:
         if token:
-            remove_scope(token)
+            detach(token)
 
-def async_wrapper(method, scope_name=None, headers=None, *args, **kwargs):
+def async_wrapper(method, scope_name=None, scope_value=None, headers=None, *args, **kwargs):
     try:
         run_loop = asyncio.get_running_loop()
     except RuntimeError:
         run_loop = None
 
-    if run_loop and run_loop.is_running():
-        results = []
-        thread = threading.Thread(target=lambda: results.append(run_async_with_scope(method, scope_name, headers, *args, **kwargs)))
-        thread.start()
-        thread.join()
-        return_value = results[0] if len(results) > 0 else None
-        return return_value
-    else:
-        return run_async_with_scope(method, scope_name, headers, *args, **kwargs)
+    token = None
+    exceptions = {}
+    if scope_name:
+        token = set_scope(scope_name, scope_value)
+    elif headers:
+        token = extract_http_headers(headers)
+    current_context = get_current()
+    try:
+        if run_loop and run_loop.is_running():
+            results = []
+            thread = threading.Thread(target=lambda: results.append(run_async_with_scope(method, current_context, exceptions, *args, **kwargs)))
+            thread.start()
+            thread.join()
+            if 'exception' in exceptions:
+                raise exceptions['exception']
+            return_value = results[0] if len(results) > 0 else None
+            return return_value
+        else:
+            return run_async_with_scope(method, None, exceptions, *args, **kwargs)
+    finally:
+        if token:
+            remove_scope(token)
 
 class Option(Generic[T]):
     def __init__(self, value: Optional[T]):

monocle_apptrace/instrumentation/common/wrapper.py

@@ -31,10 +31,11 @@ def wrapper_processor(async_task: bool, tracer: Tracer, handler: SpanHandler, to
     try:
         handler.pre_tracing(to_wrap, wrapped, instance, args, kwargs)
         skip_scan:bool = to_wrap.get('skip_span') or handler.skip_span(to_wrap, wrapped, instance, args, kwargs)
-        token = SpanHandler.attach_workflow_type(to_wrap=to_wrap)
+        if not to_wrap.get('skip_span'):
+            token = SpanHandler.attach_workflow_type(to_wrap=to_wrap)
         if skip_scan:
             if async_task:
-                return_value = async_wrapper(wrapped, None, None, *args, **kwargs)
+                return_value = async_wrapper(wrapped, None, None, None, *args, **kwargs)
             else:
                 return_value = wrapped(*args, **kwargs)
         else:
@@ -58,7 +59,7 @@ def span_processor(name: str, async_task: bool, tracer: Tracer, handler: SpanHan
         else:
             handler.pre_task_processing(to_wrap, wrapped, instance, args, kwargs, span)
             if async_task:
-                return_value = async_wrapper(wrapped, None, None, *args, **kwargs)
+                return_value = async_wrapper(wrapped, None, None, None, *args, **kwargs)
             else:                    
                 return_value = wrapped(*args, **kwargs)
             handler.hydrate_span(to_wrap, wrapped, instance, args, kwargs, return_value, span)
@@ -86,5 +87,6 @@ def scope_wrapper(tracer: Tracer, handler: SpanHandler, to_wrap, wrapped, instan
 @with_tracer_wrapper
 async def ascope_wrapper(tracer: Tracer, handler: SpanHandler, to_wrap, wrapped, instance, args, kwargs):
     scope_name = to_wrap.get('scope_name', None)
-    return_value = async_wrapper(wrapped, scope_name, None, *args, **kwargs)
+    scope_value = to_wrap.get('scope_value', None)
+    return_value = async_wrapper(wrapped, scope_name, scope_value, None, *args, **kwargs)
     return return_value

monocle_apptrace/instrumentation/common/wrapper_method.py

@@ -15,6 +15,8 @@ from monocle_apptrace.instrumentation.metamodel.flask.methods import (FLASK_METH
 from monocle_apptrace.instrumentation.metamodel.flask._helper import FlaskSpanHandler
 from monocle_apptrace.instrumentation.metamodel.requests.methods import (REQUESTS_METHODS, )
 from monocle_apptrace.instrumentation.metamodel.requests._helper import RequestSpanHandler
+from monocle_apptrace.instrumentation.metamodel.teamsai.methods import (TEAMAI_METHODS, )
+from monocle_apptrace.instrumentation.metamodel.anthropic.methods import (ANTHROPIC_METHODS, )
 
 class WrapperMethod:
     def __init__(
@@ -61,7 +63,7 @@ class WrapperMethod:
     def get_span_handler(self) -> SpanHandler:
         return self.span_handler()
 
-DEFAULT_METHODS_LIST = LANGCHAIN_METHODS + LLAMAINDEX_METHODS + HAYSTACK_METHODS + BOTOCORE_METHODS + FLASK_METHODS + REQUESTS_METHODS + LANGGRAPH_METHODS + OPENAI_METHODS
+DEFAULT_METHODS_LIST = LANGCHAIN_METHODS + LLAMAINDEX_METHODS + HAYSTACK_METHODS + BOTOCORE_METHODS + FLASK_METHODS + REQUESTS_METHODS + LANGGRAPH_METHODS + OPENAI_METHODS + TEAMAI_METHODS + ANTHROPIC_METHODS
 
 MONOCLE_SPAN_HANDLERS: Dict[str, SpanHandler] = {
     "default": SpanHandler(),

monocle_apptrace/instrumentation/metamodel/anthropic/_helper.py

@@ -0,0 +1,64 @@
+"""
+This module provides utility functions for extracting system, user,
+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,
+)
+
+
+logger = logging.getLogger(__name__)
+
+def extract_provider_name(instance):
+    provider_url: Option[str] = try_option(getattr, instance._client.base_url, 'host')
+    return provider_url.unwrap_or(None)
+
+def extract_inference_endpoint(instance):
+    inference_endpoint: Option[str] = try_option(getattr, instance._client, 'base_url').map(str)
+    if inference_endpoint.is_none() and "meta" in instance.client.__dict__:
+        inference_endpoint = try_option(getattr, instance.client.meta, 'endpoint_url').map(str)
+
+    return inference_endpoint.unwrap_or(extract_provider_name(instance))
+
+def extract_messages(kwargs):
+    """Extract system and user messages"""
+    try:
+        messages = []
+        if 'messages' in kwargs and len(kwargs['messages']) >0:
+            for msg in kwargs['messages']:
+                if msg.get('content') and msg.get('role'):
+                    messages.append({msg['role']: msg['content']})
+
+        return [str(message) for message in messages]
+    except Exception as e:
+        logger.warning("Warning: Error occurred in extract_messages: %s", str(e))
+        return []
+
+
+def extract_assistant_message(response):
+    try:
+        if response is not None and hasattr(response,"content") and len(response.content) >0:
+            if hasattr(response.content[0],"text"):
+                return response.content[0].text
+    except (IndexError, AttributeError) as e:
+        logger.warning("Warning: Error occurred in extract_assistant_message: %s", str(e))
+        return None
+
+def update_span_from_llm_response(response):
+    meta_dict = {}
+    if response is not None and hasattr(response, "usage"):
+        if hasattr(response, "usage") and response.usage is not None:
+            token_usage = response.usage
+        else:
+            response_metadata = response.response_metadata
+            token_usage = response_metadata.get("token_usage")
+        if token_usage is not None:
+            meta_dict.update({"completion_tokens": getattr(response.usage, "output_tokens", 0)})
+            meta_dict.update({"prompt_tokens": getattr(response.usage, "input_tokens", 0)})
+            meta_dict.update({"total_tokens": getattr(response.usage, "input_tokens", 0)+getattr(response.usage, "output_tokens", 0)})
+    return meta_dict

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

@@ -0,0 +1,72 @@
+from monocle_apptrace.instrumentation.metamodel.anthropic import (
+    _helper,
+)
+from monocle_apptrace.instrumentation.common.utils import resolve_from_alias, get_llm_type
+
+INFERENCE = {
+    "type": "inference",
+    "attributes": [
+        [
+            {
+                "_comment": "provider type ,name , deployment , inference_endpoint",
+                "attribute": "type",
+                "accessor": lambda arguments: 'inference.' + (get_llm_type(arguments['instance']) or 'generic')
+
+            },
+            {
+                "attribute": "provider_name",
+                "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'])
+            },
+            {
+                "attribute": "inference_endpoint",
+                "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'])
+            },
+            {
+                "attribute": "type",
+                "accessor": lambda arguments: 'model.llm.' + resolve_from_alias(arguments['kwargs'], ['model', 'model_name', 'endpoint_name', 'deployment_name'])
+            }
+        ]
+    ],
+    "events": [
+        {"name": "data.input",
+         "attributes": [
+
+             {
+                 "_comment": "this is instruction and user query to LLM",
+                 "attribute": "input",
+                 "accessor": lambda arguments: _helper.extract_messages(arguments['kwargs'])
+             }
+         ]
+         },
+        {
+            "name": "data.output",
+            "attributes": [
+                {
+                    "_comment": "this is result from LLM",
+                    "attribute": "response",
+                    "accessor": lambda arguments: _helper.extract_assistant_message(arguments['result'])
+                }
+            ]
+        },
+        {
+            "name": "metadata",
+            "attributes": [
+                {
+                    "_comment": "this is metadata usage from LLM",
+                    "accessor": lambda arguments: _helper.update_span_from_llm_response(arguments['result'])
+                }
+            ]
+        }
+    ]
+}

monocle_apptrace/instrumentation/metamodel/anthropic/methods.py

@@ -0,0 +1,22 @@
+from monocle_apptrace.instrumentation.common.wrapper import atask_wrapper, task_wrapper
+from monocle_apptrace.instrumentation.metamodel.anthropic.entities.inference import (
+    INFERENCE,
+)
+
+ANTHROPIC_METHODS = [
+    {
+        "package": "anthropic.resources.messages.messages",
+        "object": "Messages",
+        "method": "create",
+        "wrapper_method": task_wrapper,
+        "output_processor": INFERENCE
+    },
+    {
+        "package": "anthropic.resources.messages.messages",
+        "object": "AsyncMessages",
+        "method": "create",
+        "wrapper_method": atask_wrapper,
+        "output_processor": INFERENCE
+    },
+
+]

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

@@ -1,7 +1,7 @@
 from monocle_apptrace.instrumentation.metamodel.botocore import (
     _helper,
 )
-
+from monocle_apptrace.instrumentation.common.utils import get_llm_type
 INFERENCE = {
     "type": "inference",
     "attributes": [
@@ -9,7 +9,7 @@ INFERENCE = {
             {
                 "_comment": "provider type  , inference_endpoint",
                 "attribute": "type",
-                "accessor": lambda arguments: 'inference.aws_sagemaker'
+                "accessor": lambda arguments: 'inference.'+(get_llm_type(arguments['instance']) or 'generic')
             },
             {
                 "attribute": "inference_endpoint",

monocle_apptrace/instrumentation/metamodel/botocore/handlers/botocore_span_handler.py

@@ -1,3 +1,4 @@
+from opentelemetry.context import get_value, set_value, attach, detach
 from monocle_apptrace.instrumentation.common.span_handler import SpanHandler
 
 class BotoCoreSpanHandler(SpanHandler):
@@ -22,4 +23,4 @@ class BotoCoreSpanHandler(SpanHandler):
     def post_tracing(self, to_wrap, wrapped, instance, args, kwargs, return_value):
         self._botocore_processor(to_wrap=to_wrap, wrapped=wrapped, instance=instance, return_value=return_value, args=args,
                                  kwargs=kwargs)
-        return super().pre_tracing(to_wrap, wrapped, instance, args, kwargs)
+        return super().post_tracing(to_wrap, wrapped, instance, args, kwargs,return_value)

monocle_apptrace/instrumentation/metamodel/openai/_helper.py

@@ -19,6 +19,10 @@ def extract_messages(kwargs):
     """Extract system and user messages"""
     try:
         messages = []
+        if 'instructions' in kwargs:
+            messages.append({'instructions': kwargs.get('instructions', {})})
+        if 'input' in kwargs:
+            messages.append({'input': kwargs.get('input', {})})
         if 'messages' in kwargs and len(kwargs['messages']) >0:
             for msg in kwargs['messages']:
                 if msg.get('content') and msg.get('role'):
@@ -32,6 +36,8 @@ def extract_messages(kwargs):
 
 def extract_assistant_message(response):
     try:
+        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:
             if hasattr(response.choices[0],"message"):
                 return response.choices[0].message.content
@@ -85,10 +91,9 @@ def update_span_from_llm_response(response):
             response_metadata = response.response_metadata
             token_usage = response_metadata.get("token_usage")
         if token_usage is not None:
-            meta_dict.update(
-                {"completion_tokens": getattr(response.usage, "completion_tokens", None)})
-            meta_dict.update({"prompt_tokens": getattr(response.usage, "prompt_tokens", None)})
-            meta_dict.update({"total_tokens": getattr(response.usage, "total_tokens", None)})
+            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")})
     return meta_dict
 
 def extract_vector_input(vector_input: dict):

monocle_apptrace/instrumentation/metamodel/openai/methods.py

@@ -40,6 +40,22 @@ OPENAI_METHODS = [
         "span_name": "openai_embeddings",
         "span_handler": "non_framework_handler",
         "output_processor": RETRIEVAL
+    },
+    {
+        "package": "openai.resources.responses",
+        "object": "Responses",
+        "method": "create",
+        "wrapper_method": task_wrapper,
+        "span_handler": "non_framework_handler",
+        "output_processor": INFERENCE
+    },
+    {
+        "package": "openai.resources.responses",
+        "object": "AsyncResponses",
+        "method": "create",
+        "wrapper_method": atask_wrapper,
+        "span_handler": "non_framework_handler",
+        "output_processor": INFERENCE
     }
 
 ]