monocle-apptrace 0.1.1__py3-none-any.whl → 0.3.0__py3-none-any.whl

monocle_apptrace/instrumentation/common/utils.py

@@ -0,0 +1,356 @@
+import logging, json
+import os
+from typing import Callable, Generic, Optional, TypeVar, Mapping
+import threading, asyncio
+
+from opentelemetry.context import attach, detach, get_current, get_value, set_value, Context
+from opentelemetry.trace import NonRecordingSpan, Span, get_tracer
+from opentelemetry.trace.propagation import _SPAN_KEY
+from opentelemetry.sdk.trace import id_generator, TracerProvider
+from opentelemetry.propagate import inject, extract
+from opentelemetry import baggage
+from monocle_apptrace.instrumentation.common.constants import MONOCLE_SCOPE_NAME_PREFIX, SCOPE_METHOD_FILE, SCOPE_CONFIG_PATH, llm_type_map
+
+T = TypeVar('T')
+U = TypeVar('U')
+
+logger = logging.getLogger(__name__)
+
+monocle_tracer_provider: TracerProvider = None
+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
+
+def get_tracer_provider() -> TracerProvider:
+    global monocle_tracer_provider
+    return monocle_tracer_provider
+
+def set_span_attribute(span, name, value):
+    if value is not None:
+        if value != "":
+            span.set_attribute(name, value)
+
+def dont_throw(func):
+    """
+    A decorator that wraps the passed in function and logs exceptions instead of throwing them.
+
+    @param func: The function to wrap
+    @return: The wrapper function
+    """
+    # Obtain a logger specific to the function's module
+    logger = logging.getLogger(func.__module__)
+
+    # pylint: disable=inconsistent-return-statements
+    def wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except Exception as ex:
+            logger.warning("Failed to execute %s, error: %s", func.__name__, str(ex))
+
+    return wrapper
+
+def with_tracer_wrapper(func):
+    """Helper for providing tracer for wrapper functions."""
+
+    def _with_tracer(tracer, handler, to_wrap):
+        def wrapper(wrapped, instance, args, kwargs):
+            try:
+                # get and log the parent span context if injected by the application
+                # This is useful for debugging and tracing of Azure functions
+                _parent_span_context = get_current()
+                if _parent_span_context is not None and _parent_span_context.get(_SPAN_KEY, None):
+                    parent_span: Span = _parent_span_context.get(_SPAN_KEY, None)
+                    is_span = isinstance(parent_span, NonRecordingSpan)
+                    if is_span:
+                        logger.debug(
+                            f"Parent span is found with trace id {hex(parent_span.get_span_context().trace_id)}")
+            except Exception as e:
+                logger.error("Exception in attaching parent context: %s", e)
+
+            val = func(tracer, handler, to_wrap, wrapped, instance, args, kwargs)
+            return val
+
+        return wrapper
+
+    return _with_tracer
+
+def resolve_from_alias(my_map, alias):
+    """Find a alias that is not none from list of aliases"""
+
+    for i in alias and my_map[i] is not None:
+        if i in my_map.keys():
+            return my_map[i]
+    return None
+
+def set_embedding_model(model_name: str):
+    """
+    Sets the embedding model in the global context.
+
+    @param model_name: The name of the embedding model to set
+    """
+    embedding_model_context['embedding_model'] = model_name
+
+def get_embedding_model() -> str:
+    """
+    Retrieves the embedding model from the global context.
+
+    @return: The name of the embedding model, or 'unknown' if not set
+    """
+    return embedding_model_context.get('embedding_model', 'unknown')
+
+def set_attribute(key: str, value: str):
+    """
+    Set a value in the global context for a given key.
+
+    Args:
+        key: The key for the context value to set.
+        value: The value to set for the given key.
+    """
+    attach(set_value(key, value))
+
+def get_attribute(key: str) -> str:
+    """
+    Retrieve a value from the global context for a given key.
+
+    Args:
+        key: The key for the context value to retrieve.
+
+    Returns:
+        The value associated with the given key.
+    """
+    return get_value(key)
+
+def flatten_dict(d, parent_key='', sep='_'):
+    items = []
+    for k, v in d.items():
+        new_key = f"{parent_key}{sep}{k}" if parent_key else k
+        if isinstance(v, dict):
+            items.extend(flatten_dict(v, new_key, sep=sep).items())
+        else:
+            items.append((new_key, v))
+    return dict(items)
+
+def get_fully_qualified_class_name(instance):
+    if instance is None:
+        return None
+    module_name = instance.__class__.__module__
+    qualname = instance.__class__.__qualname__
+    return f"{module_name}.{qualname}"
+
+# returns json path like key probe in a dictionary
+def get_nested_value(data, keys):
+    for key in keys:
+        if isinstance(data, dict) and key in data:
+            data = data[key]
+        elif hasattr(data, key):
+            data = getattr(data, key)
+        else:
+            return None
+    return data
+
+
+def get_keys_as_tuple(dictionary, *keys):
+    return tuple(next((value for key, value in dictionary.items() if key.endswith(k) and value is not None), None) for k in keys)
+
+def load_scopes() -> dict:
+    methods_data = []
+    scope_methods = []
+    try:
+        scope_config_file_path = os.environ.get(SCOPE_CONFIG_PATH, 
+                                        os.path.join(os.getcwd(), SCOPE_METHOD_FILE))
+        with open(scope_config_file_path) as f:
+            methods_data = json.load(f)
+            for method in methods_data:
+                if method.get('http_header'):
+                    http_scopes[method.get('http_header')] = method.get('scope_name')
+                else:
+                    scope_methods.append(method)
+    except Exception as e:
+        logger.debug(f"Error loading scope methods from file: {e}")
+    return scope_methods
+
+def __generate_scope_id() -> str:
+    global scope_id_generator
+    return f"{hex(scope_id_generator.generate_trace_id())}"
+
+def set_scope(scope_name: str, scope_value:str = None) -> object:
+    return set_scopes({scope_name: scope_value})
+
+def set_scopes(scopes:dict[str, object], baggage_context:Context = None) -> object:
+    if baggage_context is None:
+        baggage_context:Context = get_current()
+    for scope_name, scope_value in scopes.items():
+        if scope_value is None:
+            scope_value = __generate_scope_id()
+        baggage_context = baggage.set_baggage(f"{MONOCLE_SCOPE_NAME_PREFIX}{scope_name}", scope_value, baggage_context)
+        
+    token:object = attach(baggage_context)
+    return token
+
+def remove_scope(token:object) -> None:
+    remove_scopes(token)
+
+def remove_scopes(token:object) -> None:
+    if token is not None:
+        detach(token)
+
+def get_scopes() -> dict[str, object]:
+    monocle_scopes:dict[str, object] = {}
+    for key, val in baggage.get_all().items():
+        if key.startswith(MONOCLE_SCOPE_NAME_PREFIX):
+            monocle_scopes[key[len(MONOCLE_SCOPE_NAME_PREFIX):]] = val
+    return monocle_scopes
+
+def get_baggage_for_scopes():
+    baggage_context:Context = None
+    for scope_key, scope_value in get_scopes():
+        monocle_scope_name = f"{MONOCLE_SCOPE_NAME_PREFIX}{scope_key}"
+        baggage_context = baggage.set_baggage(monocle_scope_name, scope_value, context=baggage_context)
+    return baggage_context
+
+def set_scopes_from_baggage(baggage_context:Context):
+    for scope_key, scope_value in baggage.get_all(baggage_context):
+        if scope_key.startswith(MONOCLE_SCOPE_NAME_PREFIX):
+            scope_name = scope_key[len(MONOCLE_SCOPE_NAME_PREFIX):]
+            set_scope(scope_name, scope_value)
+
+def extract_http_headers(headers) -> object:
+    global http_scopes
+    trace_context:Context = extract(headers, context=get_current())
+    imported_scope:dict[str, object] = {}
+    for http_header, http_scope in http_scopes.items():
+        if http_header in headers:
+            imported_scope[http_scope] = f"{http_header}: {headers[http_header]}"
+    token = set_scopes(imported_scope, trace_context)
+    return token
+
+def clear_http_scopes(token:object) -> None:
+    global http_scopes
+    remove_scopes(token)
+
+def http_route_handler(func, *args, **kwargs):
+    if 'req' in kwargs and hasattr(kwargs['req'], 'headers'):
+        headers = kwargs['req'].headers
+    else:
+        headers = None
+    token = None
+    if headers is not None:
+        token = extract_http_headers(headers)
+    try:
+        result = func(*args, **kwargs)
+        return result
+    finally:
+        if token is not None:
+            clear_http_scopes(token)
+
+async def http_async_route_handler(func, *args, **kwargs):
+    if 'req' in kwargs and hasattr(kwargs['req'], 'headers'):
+        headers = kwargs['req'].headers
+    else:
+        headers = None
+    return async_wrapper(func, None, None, headers, *args, **kwargs)
+
+def run_async_with_scope(method, current_context, exceptions, *args, **kwargs):
+    token = None
+    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:
+            detach(token)
+
+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
+
+    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]):
+        self.value = value
+
+    def is_some(self) -> bool:
+        return self.value is not None
+
+    def is_none(self) -> bool:
+        return self.value is None
+
+    def unwrap_or(self, default: T) -> T:
+        return self.value if self.is_some() else default
+
+    def map(self, func: Callable[[T], U]) -> 'Option[U]':
+        if self.is_some():
+            return Option(func(self.value))
+        return Option(None)
+
+    def and_then(self, func: Callable[[T], 'Option[U]']) -> 'Option[U]':
+        if self.is_some():
+            return func(self.value)
+        return Option(None)
+
+# Example usage
+def try_option(func: Callable[..., T], *args, **kwargs) -> Option[T]:
+    try:
+        return Option(func(*args, **kwargs))
+    except Exception:
+        return Option(None)
+
+def get_llm_type(instance):
+    try:
+        llm_type = llm_type_map.get(type(instance).__name__.lower())
+        return llm_type
+    except:
+        pass
+
+def resolve_from_alias(my_map, alias):
+    """Find a alias that is not none from list of aliases"""
+    for i in alias:
+        if i in my_map.keys():
+            return my_map[i]
+    return None

monocle_apptrace/instrumentation/common/wrapper.py

@@ -0,0 +1,92 @@
+# pylint: disable=protected-access
+import logging
+from opentelemetry.trace import Tracer
+from opentelemetry.context import set_value, attach, detach, get_value
+
+from monocle_apptrace.instrumentation.common.span_handler import SpanHandler
+from monocle_apptrace.instrumentation.common.utils import (
+    get_fully_qualified_class_name,
+    with_tracer_wrapper,
+    set_scope,
+    remove_scope,
+    async_wrapper
+)
+from monocle_apptrace.instrumentation.common.constants import WORKFLOW_TYPE_KEY
+logger = logging.getLogger(__name__)
+
+def wrapper_processor(async_task: bool, tracer: Tracer, handler: SpanHandler, to_wrap, wrapped, instance, args, kwargs):
+    # Some Langchain objects are wrapped elsewhere, so we ignore them here
+    if instance.__class__.__name__ in ("AgentExecutor"):
+        return wrapped(*args, **kwargs)
+
+    if hasattr(instance, "name") and instance.name:
+        name = f"{to_wrap.get('span_name')}.{instance.name.lower()}"
+    elif to_wrap.get("span_name"):
+        name = to_wrap.get("span_name")
+    else:
+        name = get_fully_qualified_class_name(instance)
+
+    return_value = None
+    token = None
+    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)
+        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, None, *args, **kwargs)
+            else:
+                return_value = wrapped(*args, **kwargs)
+        else:
+            return_value = span_processor(name, async_task, tracer, handler, to_wrap, wrapped, instance, args, kwargs)
+        return return_value
+    finally:
+        handler.detach_workflow_type(token)
+        handler.post_tracing(to_wrap, wrapped, instance, args, kwargs, return_value)
+
+def span_processor(name: str, async_task: bool, tracer: Tracer, handler: SpanHandler, to_wrap, wrapped, instance, args, kwargs):
+    # For singleton spans, eg OpenAI inference generate a workflow span to format the workflow specific attributes
+    return_value = None
+    with tracer.start_as_current_span(name) as span:
+        # Since Spanhandler can be overridden, ensure we set default monocle attributes.
+        SpanHandler.set_default_monocle_attributes(span)
+        if SpanHandler.is_root_span(span):
+            SpanHandler.set_workflow_properties(span, to_wrap)
+        if handler.is_non_workflow_root_span(span, to_wrap):
+            # This is a direct API call of a non-framework type, call the span_processor recursively for the actual span
+            return_value = span_processor(name, async_task, tracer, handler, to_wrap, wrapped, instance, args, kwargs)
+        else:
+            handler.pre_task_processing(to_wrap, wrapped, instance, args, kwargs, span)
+            if async_task:
+                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)
+            handler.post_task_processing(to_wrap, wrapped, instance, args, kwargs, return_value, span)
+    return return_value
+
+@with_tracer_wrapper
+def task_wrapper(tracer: Tracer, handler: SpanHandler, to_wrap, wrapped, instance, args, kwargs):
+    return wrapper_processor(False, tracer, handler, to_wrap, wrapped, instance, args, kwargs)
+
+@with_tracer_wrapper
+async def atask_wrapper(tracer: Tracer, handler: SpanHandler, to_wrap, wrapped, instance, args, kwargs):
+    return wrapper_processor(True, tracer, handler, to_wrap, wrapped, instance, args, kwargs)
+
+@with_tracer_wrapper
+def scope_wrapper(tracer: Tracer, handler: SpanHandler, to_wrap, wrapped, instance, args, kwargs):
+    scope_name = to_wrap.get('scope_name', None)
+    if scope_name:
+        token = set_scope(scope_name)
+    return_value = wrapped(*args, **kwargs)
+    if scope_name:
+        remove_scope(token)
+    return return_value
+
+@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)
+    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

@@ -0,0 +1,72 @@
+# pylint: disable=too-few-public-methods
+from typing import Any, Dict
+from monocle_apptrace.instrumentation.common.wrapper import task_wrapper, scope_wrapper
+from monocle_apptrace.instrumentation.common.span_handler import SpanHandler, NonFrameworkSpanHandler
+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.langchain.methods import (
+    LANGCHAIN_METHODS,
+)
+from monocle_apptrace.instrumentation.metamodel.llamaindex.methods import (LLAMAINDEX_METHODS, )
+from monocle_apptrace.instrumentation.metamodel.haystack.methods import (HAYSTACK_METHODS, )
+from monocle_apptrace.instrumentation.metamodel.openai.methods import (OPENAI_METHODS,)
+from monocle_apptrace.instrumentation.metamodel.langgraph.methods import LANGGRAPH_METHODS
+from monocle_apptrace.instrumentation.metamodel.flask.methods import (FLASK_METHODS, )
+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
+
+class WrapperMethod:
+    def __init__(
+            self,
+            package: str,
+            object_name: str,
+            method: str,
+            span_name: str = None,
+            output_processor : str = None,
+            wrapper_method = task_wrapper,
+            span_handler = 'default',
+            scope_name: str = None,
+            span_type: str = None
+            ):
+        self.package = package
+        self.object = object_name
+        self.method = method
+        self.span_name = span_name
+        self.output_processor=output_processor
+        self.span_type = span_type
+
+        self.span_handler:SpanHandler.__class__ = span_handler
+        self.scope_name = scope_name
+        if scope_name:
+            self.wrapper_method = scope_wrapper
+        else:
+            self.wrapper_method = wrapper_method
+
+    def to_dict(self) -> dict:
+        # Create a dictionary representation of the instance
+        instance_dict = {
+            'package': self.package,
+            'object': self.object,
+            'method': self.method,
+            'span_name': self.span_name,
+            'output_processor': self.output_processor,
+            'wrapper_method': self.wrapper_method,
+            'span_handler': self.span_handler,
+            'scope_name': self.scope_name,
+            'span_type': self.span_type
+        }
+        return instance_dict
+
+    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
+
+MONOCLE_SPAN_HANDLERS: Dict[str, SpanHandler] = {
+    "default": SpanHandler(),
+    "botocore_handler": BotoCoreSpanHandler(),
+    "flask_handler": FlaskSpanHandler(),
+    "request_handler": RequestSpanHandler(),
+    "non_framework_handler": NonFrameworkSpanHandler()
+}

monocle_apptrace/instrumentation/metamodel/botocore/_helper.py

@@ -0,0 +1,95 @@
+"""
+This module provides utility functions for extracting system, user,
+and assistant messages from various input formats.
+"""
+
+import logging
+import json
+from io import BytesIO
+from functools import wraps
+from monocle_apptrace.instrumentation.common.span_handler import SpanHandler
+
+logger = logging.getLogger(__name__)
+
+
+def extract_messages(args):
+    """Extract system and user messages"""
+    try:
+        messages = []
+        if args and isinstance(args, dict) and len(args) > 0:
+            if 'Body' in args and isinstance(args['Body'], str):
+                data = json.loads(args['Body'])
+                question = data.get("question")
+                messages.append(question)
+            if 'messages' in args and isinstance(args['messages'], list):
+                role = args['messages'][0]['role']
+                user_message = extract_query_from_content(args['messages'][0]['content'][0]['text'])
+                messages.append({role: user_message})
+        return [str(d) for d 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 "Body" in response and hasattr(response['Body'], "_raw_stream"):
+            raw_stream = getattr(response['Body'], "_raw_stream")
+            if hasattr(raw_stream, "data"):
+                response_bytes = getattr(raw_stream, "data")
+                response_str = response_bytes.decode('utf-8')
+                response_dict = json.loads(response_str)
+                response['Body'] = BytesIO(response_bytes)
+                return [response_dict["answer"]]
+        if "output" in response:
+            output = response.get("output", {})
+            message = output.get("message", {})
+            content = message.get("content", [])
+            if isinstance(content, list) and len(content) > 0 and "text" in content[0]:
+                reply = content[0]["text"]
+                return [reply]
+    except Exception as e:
+        logger.warning("Warning: Error occurred in extract_assistant_message: %s", str(e))
+        return []
+
+
+def extract_query_from_content(content):
+    try:
+        query_prefix = "Query:"
+        answer_prefix = "Answer:"
+        query_start = content.find(query_prefix)
+        if query_start == -1:
+            return None
+
+        query_start += len(query_prefix)
+        answer_start = content.find(answer_prefix, query_start)
+        if answer_start == -1:
+            query = content[query_start:].strip()
+        else:
+            query = content[query_start:answer_start].strip()
+        return query
+    except Exception as e:
+        logger.warning("Warning: Error occurred in extract_query_from_content: %s", str(e))
+        return ""
+
+
+def resolve_from_alias(my_map, alias):
+    """Find a alias that is not none from list of aliases"""
+
+    for i in alias:
+        if i in my_map.keys():
+            return my_map[i]
+    return None
+
+def update_span_from_llm_response(response, instance):
+    meta_dict = {}
+    if response is not None and isinstance(response, dict) and "usage" in response:
+        token_usage = response["usage"]
+
+        if token_usage is not None:
+            temperature = instance.__dict__.get("temperature", None)
+            meta_dict.update({"temperature": temperature})
+            meta_dict.update({"completion_tokens": resolve_from_alias(token_usage,["completion_tokens","output_tokens","outputTokens"])})
+            meta_dict.update({"prompt_tokens": resolve_from_alias(token_usage,["prompt_tokens","input_tokens","inputTokens"])})
+            meta_dict.update({"total_tokens": resolve_from_alias(token_usage,["total_tokens","totalTokens"])})
+    return meta_dict

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

@@ -0,0 +1,65 @@
+from monocle_apptrace.instrumentation.metamodel.botocore import (
+    _helper,
+)
+
+INFERENCE = {
+    "type": "inference",
+    "attributes": [
+        [
+            {
+                "_comment": "provider type  , inference_endpoint",
+                "attribute": "type",
+                "accessor": lambda arguments: 'inference.aws_sagemaker'
+            },
+            {
+                "attribute": "inference_endpoint",
+                "accessor": lambda arguments: arguments['instance'].meta.endpoint_url
+            }
+        ],
+        [
+            {
+                "_comment": "LLM Model",
+                "attribute": "name",
+                "accessor": lambda arguments: _helper.resolve_from_alias(arguments['kwargs'],
+                                                                         ['EndpointName', 'modelId'])
+            },
+            {
+                "attribute": "type",
+                "accessor": lambda arguments: 'model.llm.' + _helper.resolve_from_alias(arguments['kwargs'],
+                                                                                        ['EndpointName', 'modelId'])
+            }
+        ]
+    ],
+    "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 response 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'],
+                                                                                        arguments['instance'])
+                }
+            ]
+        }
+    ]
+}