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

monocle_apptrace/utils.py

@@ -1,172 +0,0 @@
-import logging
-import json
-from importlib import import_module
-import os
-from opentelemetry.trace import Span
-from opentelemetry.context import attach, set_value, get_value
-from monocle_apptrace.constants import azure_service_map, aws_service_map
-from json.decoder import JSONDecodeError
-logger = logging.getLogger(__name__)
-
-embedding_model_context = {}
-
-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, to_wrap):
-        def wrapper(wrapped, instance, args, kwargs):
-            return func(tracer, to_wrap, wrapped, instance, args, kwargs)
-
-        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:
-        if i in my_map.keys():
-            return my_map[i]
-    return None
-
-def load_output_processor(wrapper_method, attributes_config_base_path):
-    """Load the output processor from a file if the file path is provided and valid."""
-    logger = logging.getLogger()
-    output_processor_file_path = wrapper_method["output_processor"][0]
-    logger.info(f'Output processor file path is: {output_processor_file_path}')
-
-    if isinstance(output_processor_file_path, str) and output_processor_file_path:  # Combined condition
-        if not attributes_config_base_path:
-            absolute_file_path = os.path.abspath(output_processor_file_path)
-        else:
-            absolute_file_path = os.path.join(attributes_config_base_path, output_processor_file_path)
-
-        logger.info(f'Absolute file path is: {absolute_file_path}')
-        try:
-            with open(absolute_file_path, encoding='UTF-8') as op_file:
-                wrapper_method["output_processor"] = json.load(op_file)
-                logger.info('Output processor loaded successfully.')
-        except FileNotFoundError:
-            logger.error(f"Error: File not found at {absolute_file_path}.")
-        except JSONDecodeError:
-            logger.error(f"Error: Invalid JSON content in the file {absolute_file_path}.")
-        except Exception as e:
-            logger.error(f"Error: An unexpected error occurred: {e}")
-    else:
-        logger.error("Invalid or missing output processor file path.")
-
-def get_wrapper_methods_config(
-        wrapper_methods_config_path: str,
-        attributes_config_base_path: str = None
-):
-    parent_dir = os.path.dirname(os.path.join(os.path.dirname(__file__), '..'))
-    wrapper_methods_config = load_wrapper_methods_config_from_file(
-        wrapper_methods_config_path=os.path.join(parent_dir, wrapper_methods_config_path))
-    process_wrapper_method_config(
-        wrapper_methods_config=wrapper_methods_config,
-        attributes_config_base_path=attributes_config_base_path)
-    return wrapper_methods_config
-
-def load_wrapper_methods_config_from_file(
-        wrapper_methods_config_path: str):
-    json_data = {}
-
-    with open(wrapper_methods_config_path, encoding='UTF-8') as config_file:
-        json_data = json.load(config_file)
-
-    return json_data["wrapper_methods"]
-
-def process_wrapper_method_config(
-        wrapper_methods_config: str,
-        attributes_config_base_path: str = ""):
-    for wrapper_method in wrapper_methods_config:
-        if "wrapper_package" in wrapper_method and "wrapper_method" in wrapper_method:
-            wrapper_method["wrapper"] = get_wrapper_method(
-                wrapper_method["wrapper_package"], wrapper_method["wrapper_method"])
-            if "span_name_getter_method" in wrapper_method:
-                wrapper_method["span_name_getter"] = get_wrapper_method(
-                    wrapper_method["span_name_getter_package"],
-                    wrapper_method["span_name_getter_method"])
-        if "output_processor" in wrapper_method and wrapper_method["output_processor"]:
-            load_output_processor(wrapper_method, attributes_config_base_path)
-
-def get_wrapper_method(package_name: str, method_name: str):
-    wrapper_module = import_module("monocle_apptrace." + package_name)
-    return getattr(wrapper_module, method_name)
-
-def update_span_with_infra_name(span: Span, span_key: str):
-    for key, val in azure_service_map.items():
-        if key in os.environ:
-            span.set_attribute(span_key, val)
-    for key, val in aws_service_map.items():
-        if key in os.environ:
-            span.set_attribute(span_key, val)
-
-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 get_workflow_name(span: Span) -> str:
-    try:
-        return get_value("workflow_name") or span.resource.attributes.get("service.name")
-    except Exception as e:
-        logger.exception(f"Error getting workflow name: {e}")
-        return None

monocle_apptrace/wrap_common.py

@@ -1,417 +0,0 @@
-# pylint: disable=protected-access
-import logging
-import os
-import inspect
-from urllib.parse import urlparse
-from opentelemetry.trace import Span, Tracer
-from monocle_apptrace.utils import resolve_from_alias, update_span_with_infra_name, with_tracer_wrapper, get_embedding_model, get_attribute, get_workflow_name
-from monocle_apptrace.utils import set_attribute
-from opentelemetry.context import get_value, attach, set_value
-logger = logging.getLogger(__name__)
-WORKFLOW_TYPE_KEY = "workflow_type"
-DATA_INPUT_KEY = "data.input"
-DATA_OUTPUT_KEY = "data.output"
-PROMPT_INPUT_KEY = "data.input"
-PROMPT_OUTPUT_KEY = "data.output"
-QUERY = "question"
-RESPONSE = "response"
-SESSION_PROPERTIES_KEY = "session"
-INFRA_SERVICE_KEY = "infra_service_name"
-
-TYPE = "type"
-PROVIDER = "provider_name"
-EMBEDDING_MODEL = "embedding_model"
-VECTOR_STORE = 'vector_store'
-META_DATA = 'metadata'
-
-WORKFLOW_TYPE_MAP = {
-    "llama_index": "workflow.llamaindex",
-    "langchain": "workflow.langchain",
-    "haystack": "workflow.haystack"
-}
-
-def get_embedding_model_for_vectorstore(instance):
-    # Handle Langchain or other frameworks where vectorstore exists
-    if hasattr(instance, 'vectorstore'):
-        vectorstore_dict = instance.vectorstore.__dict__
-
-        # Use inspect to check if the embedding function is from Sagemaker
-        if 'embedding_func' in vectorstore_dict:
-            embedding_func = vectorstore_dict['embedding_func']
-            class_name = embedding_func.__class__.__name__
-            file_location = inspect.getfile(embedding_func.__class__)
-
-            # Check if the class is SagemakerEndpointEmbeddings
-            if class_name == 'SagemakerEndpointEmbeddings' and 'langchain_community' in file_location:
-                # Set embedding_model as endpoint_name if it's Sagemaker
-                if hasattr(embedding_func, 'endpoint_name'):
-                    return embedding_func.endpoint_name
-
-        # Default to the regular embedding model if not Sagemaker
-        return instance.vectorstore.embeddings.model
-
-    # Handle llama_index where _embed_model is present
-    if hasattr(instance, '_embed_model') and hasattr(instance._embed_model, 'model_name'):
-        return instance._embed_model.model_name
-
-    # Fallback if no specific model is found
-    return "Unknown Embedding Model"
-
-
-framework_vector_store_mapping = {
-    'langchain_core.retrievers': lambda instance: {
-        'provider': type(instance.vectorstore).__name__,
-        'embedding_model': get_embedding_model_for_vectorstore(instance),
-        'type': VECTOR_STORE,
-    },
-    'llama_index.core.indices.base_retriever': lambda instance: {
-        'provider': type(instance._vector_store).__name__,
-        'embedding_model': get_embedding_model_for_vectorstore(instance),
-        'type': VECTOR_STORE,
-    },
-    'haystack.components.retrievers.in_memory': lambda instance: {
-        'provider': instance.__dict__.get("document_store").__class__.__name__,
-        'embedding_model': get_embedding_model(),
-        'type': VECTOR_STORE,
-    },
-}
-
-
-@with_tracer_wrapper
-def task_wrapper(tracer: Tracer, to_wrap, wrapped, instance, args, kwargs):
-    """Instruments and calls every function defined in TO_WRAP."""
-
-    # 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 = f"langchain.task.{instance.__class__.__name__}"
-
-    with tracer.start_as_current_span(name) as span:
-        process_span(to_wrap, span, instance, args)
-        pre_task_processing(to_wrap, instance, args, span)
-        return_value = wrapped(*args, **kwargs)
-        post_task_processing(to_wrap, span, return_value)
-
-    return return_value
-
-
-def process_span(to_wrap, span, instance, args):
-    # Check if the output_processor is a valid JSON (in Python, that means it's a dictionary)
-    span_index = 1
-    if is_root_span(span):
-        workflow_name = get_workflow_name(span)
-        if workflow_name:
-            span.set_attribute(f"entity.{span_index}.name", workflow_name)
-        # workflow type
-        package_name = to_wrap.get('package')
-        for (package, workflow_type) in WORKFLOW_TYPE_MAP.items():
-            if (package_name is not None and package in package_name):
-                span.set_attribute(f"entity.{span_index}.type", workflow_type)
-        span_index += 1
-    if 'output_processor' in to_wrap:
-        output_processor=to_wrap['output_processor']
-        if isinstance(output_processor, dict) and len(output_processor) > 0:
-            if 'type' in output_processor:
-                span.set_attribute("span.type", output_processor['type'])
-            else:
-                logger.warning("type of span not found or incorrect written in entity json")
-            count = 0
-            if 'attributes' in output_processor:
-                count = len(output_processor["attributes"])
-                span.set_attribute("entity.count", count)
-                span_index = 1
-                for processors in output_processor["attributes"]:
-                    for processor in processors:
-                        attribute = processor.get('attribute')
-                        accessor = processor.get('accessor')
-
-                        if attribute and accessor:
-                            attribute_name = f"entity.{span_index}.{attribute}"
-                            try:
-                                result = eval(accessor)(instance, args)
-                                if result and isinstance(result, str):
-                                    span.set_attribute(attribute_name, result)
-                            except Exception as e:
-                                logger.error(f"Error processing accessor: {e}")
-                        else:
-                            logger.warning(f"{' and '.join([key for key in ['attribute', 'accessor'] if not processor.get(key)])} not found or incorrect in entity JSON")
-                    span_index += 1
-            else:
-                logger.warning("attributes not found or incorrect written in entity json")
-                span.set_attribute("span.count", count)
-
-        else:
-            logger.warning("empty or entities json is not in correct format")
-
-
-def post_task_processing(to_wrap, span, return_value):
-    try:
-        update_span_with_context_output(to_wrap=to_wrap, return_value=return_value, span=span)
-
-        if is_root_span(span):
-            update_span_with_prompt_output(to_wrap=to_wrap, wrapped_args=return_value, span=span)
-    except:
-        logger.exception("exception in post_task_processing")
-
-
-def pre_task_processing(to_wrap, instance, args, span):
-    try:
-        if is_root_span(span):
-            update_span_with_prompt_input(to_wrap=to_wrap, wrapped_args=args, span=span)
-            update_span_with_infra_name(span, INFRA_SERVICE_KEY)
-
-        update_span_with_context_input(to_wrap=to_wrap, wrapped_args=args, span=span)
-    except:
-        logger.exception("exception in pre_task_processing")
-
-
-@with_tracer_wrapper
-async def atask_wrapper(tracer, to_wrap, wrapped, instance, args, kwargs):
-    """Instruments and calls every function defined in TO_WRAP."""
-
-    # 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 = f"langchain.task.{instance.__class__.__name__}"
-    with tracer.start_as_current_span(name) as span:
-        process_span(to_wrap, span, instance, args)
-        pre_task_processing(to_wrap, instance, args, span)
-        return_value = await wrapped(*args, **kwargs)
-        post_task_processing(to_wrap, span, return_value)
-
-    return return_value
-
-
-@with_tracer_wrapper
-async def allm_wrapper(tracer, 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 callable(to_wrap.get("span_name_getter")):
-        name = to_wrap.get("span_name_getter")(instance)
-
-    elif 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 = f"langchain.task.{instance.__class__.__name__}"
-    with tracer.start_as_current_span(name) as span:
-        if 'haystack.components.retrievers' in to_wrap['package'] and 'haystack.retriever' in span.name:
-            input_arg_text = get_attribute(DATA_INPUT_KEY)
-            span.add_event(DATA_INPUT_KEY, {QUERY: input_arg_text})
-        provider_name, inference_endpoint = get_provider_name(instance)
-        instance_args = {"provider_name": provider_name, "inference_endpoint": inference_endpoint}
-
-        process_span(to_wrap, span, instance, instance_args)
-
-        return_value = await wrapped(*args, **kwargs)
-        if 'haystack.components.retrievers' in to_wrap['package'] and 'haystack.retriever' in span.name:
-            update_span_with_context_output(to_wrap=to_wrap, return_value=return_value, span=span)
-        update_span_from_llm_response(response=return_value, span=span, instance=instance)
-
-    return return_value
-
-
-@with_tracer_wrapper
-def llm_wrapper(tracer: Tracer, 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 callable(to_wrap.get("span_name_getter")):
-        name = to_wrap.get("span_name_getter")(instance)
-
-    elif 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 = f"langchain.task.{instance.__class__.__name__}"
-
-    with tracer.start_as_current_span(name) as span:
-        if 'haystack.components.retrievers' in to_wrap['package'] and 'haystack.retriever' in span.name:
-            input_arg_text = get_attribute(DATA_INPUT_KEY)
-            span.add_event(DATA_INPUT_KEY, {QUERY: input_arg_text})
-        provider_name, inference_endpoint = get_provider_name(instance)
-        instance_args = {"provider_name": provider_name, "inference_endpoint": inference_endpoint}
-
-        process_span(to_wrap, span, instance, instance_args)
-
-        return_value = wrapped(*args, **kwargs)
-        if 'haystack.components.retrievers' in to_wrap['package'] and 'haystack.retriever' in span.name:
-            update_span_with_context_output(to_wrap=to_wrap, return_value=return_value, span=span)
-        update_span_from_llm_response(response=return_value, span=span, instance=instance)
-
-    return return_value
-
-
-def update_llm_endpoint(curr_span: Span, instance):
-    # Lambda to set attributes if values are not None
-    __set_span_attribute_if_not_none = lambda span, **kwargs: [
-        span.set_attribute(k, v) for k, v in kwargs.items() if v is not None
-    ]
-
-    triton_llm_endpoint = os.environ.get("TRITON_LLM_ENDPOINT")
-    if triton_llm_endpoint is not None and len(triton_llm_endpoint) > 0:
-        curr_span.set_attribute("server_url", triton_llm_endpoint)
-    else:
-        # Get temperature if present
-        temp_val = instance.__dict__.get("temperature")
-
-        # Resolve values for model name, deployment, and inference endpoint
-        model_name = resolve_from_alias(instance.__dict__, ["model", "model_name"])
-        deployment_name = resolve_from_alias(instance.__dict__,
-                                             ["engine", "azure_deployment", "deployment_name", "deployment_id",
-                                              "deployment"])
-        inference_ep = resolve_from_alias(instance.__dict__, ["azure_endpoint", "api_base"])
-
-        # Use the lambda to set attributes conditionally
-        __set_span_attribute_if_not_none(
-            curr_span,
-            temperature=temp_val,
-            model_name=model_name,
-            az_openai_deployment=deployment_name,
-            inference_endpoint=inference_ep
-        )
-
-
-def get_provider_name(instance):
-    provider_url = ""
-    inference_endpoint = ""
-    try:
-        if isinstance(instance.client._client.base_url.host, str):
-            provider_url = instance.client._client.base_url.host
-        if isinstance(instance.client._client.base_url, str):
-            inference_endpoint = instance.client._client.base_url
-        else:
-            inference_endpoint = str(instance.client._client.base_url)
-    except:
-        pass
-
-    try:
-        if isinstance(instance.api_base, str):
-            provider_url = instance.api_base
-    except:
-        pass
-
-    try:
-        if len(provider_url) > 0:
-            parsed_provider_url = urlparse(provider_url)
-    except:
-        pass
-    return parsed_provider_url.hostname or provider_url,inference_endpoint
-
-
-def is_root_span(curr_span: Span) -> bool:
-    return curr_span.parent is None
-
-
-def get_input_from_args(chain_args):
-    if len(chain_args) > 0 and isinstance(chain_args[0], str):
-        return chain_args[0]
-    return ""
-
-
-def update_span_from_llm_response(response, span: Span, instance):
-    # extract token uasge from langchain openai
-    if (response is not None and hasattr(response, "response_metadata")):
-        response_metadata = response.response_metadata
-        token_usage = response_metadata.get("token_usage")
-        meta_dict = {}
-        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")})
-            meta_dict.update({"prompt_tokens": token_usage.get("prompt_tokens")})
-            meta_dict.update({"total_tokens": token_usage.get("total_tokens")})
-            span.add_event(META_DATA, meta_dict)
-    # extract token usage from llamaindex openai
-    if (response is not None and hasattr(response, "raw")):
-        try:
-            meta_dict = {}
-            if response.raw is not None:
-                token_usage = response.raw.get("usage") if isinstance(response.raw, dict) else getattr(response.raw,
-                                                                                                       "usage", None)
-                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")})
-                    span.add_event(META_DATA, meta_dict)
-        except AttributeError:
-            token_usage = None
-
-
-def update_workflow_type(to_wrap, span: Span):
-    package_name = to_wrap.get('package')
-
-    for (package, workflow_type) in WORKFLOW_TYPE_MAP.items():
-        if (package_name is not None and package in package_name):
-            span.set_attribute(WORKFLOW_TYPE_KEY, workflow_type)
-
-
-def update_span_with_context_input(to_wrap, wrapped_args, span: Span):
-    package_name: str = to_wrap.get('package')
-    input_arg_text = ""
-    if "langchain_core.retrievers" in package_name and len(wrapped_args) > 0:
-        input_arg_text += wrapped_args[0]
-    if "llama_index.core.indices.base_retriever" in package_name and len(wrapped_args) > 0:
-        input_arg_text += wrapped_args[0].query_str
-    if "haystack.components.retrievers.in_memory" in package_name:
-        input_arg_text += get_attribute(DATA_INPUT_KEY)
-    if input_arg_text:
-        span.add_event(DATA_INPUT_KEY, {QUERY: input_arg_text})
-
-
-def update_span_with_context_output(to_wrap, return_value, span: Span):
-    package_name: str = to_wrap.get('package')
-    output_arg_text = ""
-    if "langchain_core.retrievers" in package_name:
-        output_arg_text += " ".join([doc.page_content for doc in return_value if hasattr(doc, 'page_content')])
-        if len(output_arg_text) > 100:
-            output_arg_text = output_arg_text[:100] + "..."
-    if "llama_index.core.indices.base_retriever" in package_name and len(return_value) > 0:
-        output_arg_text += return_value[0].text
-    if "haystack.components.retrievers.in_memory" in package_name:
-        output_arg_text += " ".join([doc.content for doc in return_value['documents']])
-        if len(output_arg_text) > 100:
-            output_arg_text = output_arg_text[:100] + "..."
-    if output_arg_text:
-        span.add_event(DATA_OUTPUT_KEY, {RESPONSE: output_arg_text})
-
-
-def update_span_with_prompt_input(to_wrap, wrapped_args, span: Span):
-    input_arg_text = wrapped_args[0]
-
-    if isinstance(input_arg_text, dict):
-        span.add_event(PROMPT_INPUT_KEY, input_arg_text)
-    else:
-        span.add_event(PROMPT_INPUT_KEY, {QUERY: input_arg_text})
-
-
-def update_span_with_prompt_output(to_wrap, wrapped_args, span: Span):
-    package_name: str = to_wrap.get('package')
-    if isinstance(wrapped_args, str):
-        span.add_event(PROMPT_OUTPUT_KEY, {RESPONSE: wrapped_args})
-    if isinstance(wrapped_args, dict):
-        span.add_event(PROMPT_OUTPUT_KEY, wrapped_args)
-    if "llama_index.core.base.base_query_engine" in package_name:
-        span.add_event(PROMPT_OUTPUT_KEY, {RESPONSE: wrapped_args.response})

monocle_apptrace/wrapper.py

@@ -1,26 +0,0 @@
-
-from monocle_apptrace.haystack import HAYSTACK_METHODS
-from monocle_apptrace.langchain import LANGCHAIN_METHODS
-from monocle_apptrace.llamaindex import LLAMAINDEX_METHODS
-from monocle_apptrace.wrap_common import task_wrapper
-
-# pylint: disable=too-few-public-methods
-class WrapperMethod:
-    def __init__(
-            self,
-            package: str,
-            object_name: str,
-            method: str,
-            span_name: str = None,
-            output_processor : list[str] = None,
-            wrapper = task_wrapper
-            ):
-        self.package = package
-        self.object = object_name
-        self.method = method
-        self.span_name = span_name
-        self.output_processor=output_processor
-
-        self.wrapper = wrapper
-
-INBUILT_METHODS_LIST = LANGCHAIN_METHODS + LLAMAINDEX_METHODS + HAYSTACK_METHODS

monocle_apptrace-0.2.0.dist-info/RECORD

@@ -1,44 +0,0 @@
-monocle_apptrace/README.md,sha256=T5NFC01bF8VR0oVnAX_n0bhsEtttwqfTxDNAe5Y_ivE,3765
-monocle_apptrace/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-monocle_apptrace/constants.py,sha256=wjObbmMTFL201x-bf3EOXevYygwkFH_1ng5dDrpE3z0,810
-monocle_apptrace/instrumentor.py,sha256=FMQ8yVNYGRBTmyUjC2578G8RzSRpHY5HtVN5WK9ndVE,5291
-monocle_apptrace/utils.py,sha256=l-affXaMX6U_wG1rWRE2GPB6dDGtha7kL0MQK4PEptI,6395
-monocle_apptrace/wrap_common.py,sha256=ux2Ob7g1FYDtt1gF4g8XKQhl6Ed5X_iR4CP4GHX4upM,18178
-monocle_apptrace/wrapper.py,sha256=8bsMaCCCbaEJN8hW5YoYkn2XLJ7vFI1HJk6QHihbkto,830
-monocle_apptrace/exporters/base_exporter.py,sha256=1UvywEiKZ0nilcXiy-mZue012yVvYXgwib1x1qQvpBc,1647
-monocle_apptrace/exporters/exporter_processor.py,sha256=BTcBgMuFLHCdCgVvc9TKIo9y8g1BvShI0L4vX6Q-cmk,393
-monocle_apptrace/exporters/file_exporter.py,sha256=gN9pJ_X5pcstVVsyivgHsjWhr443eRa6Y6Hx1rGLQAM,2280
-monocle_apptrace/exporters/monocle_exporters.py,sha256=mvVoGr4itvUBuakH17zNEuXYpHtqRhq2CBH5JXhleoM,1418
-monocle_apptrace/exporters/aws/s3_exporter.py,sha256=S_w2OBkM8eEYK6bBDbfcRV4LdojU1QygOBqjdhcjAl4,6730
-monocle_apptrace/exporters/azure/blob_exporter.py,sha256=dtL8MPISyP1eKM0gGpSoqTUmFuGEfycqF9OCjFF6H6E,5716
-monocle_apptrace/exporters/okahu/okahu_exporter.py,sha256=p2rjStwo0OMEdHWQt_QvREpUWXbDm5jGx3qXeYai4_M,4407
-monocle_apptrace/haystack/__init__.py,sha256=zMvF6Dh1-vVIAQD__HC1ubT5bs-EupUghg7HNhDv7_c,448
-monocle_apptrace/haystack/wrap_node.py,sha256=IK07Wn3Lk1Os9URsyrmB1HXOH2FNdzK9fNLlR8TZdYc,908
-monocle_apptrace/haystack/wrap_openai.py,sha256=Yp916DhOl0WI6virRi3L43snfsQm7PhI28wlDsg19v8,1536
-monocle_apptrace/haystack/wrap_pipeline.py,sha256=yZAw7Hdv7FXe6rrM7gA2y5SjaZYQZCAi0q-R-uqUEvk,2254
-monocle_apptrace/langchain/__init__.py,sha256=3yhbdw1h9I1nVEfnOOPKz9yD5NqwdLSZsxtXbMplRkw,400
-monocle_apptrace/llamaindex/__init__.py,sha256=TgV1ZM8Cz113pZ2aAgpYwsCJyHA2aHOvNoW1QMBp0mM,709
-monocle_apptrace/metamodel/README.md,sha256=KYuuYqgA9PNbOjG0zYj2nAdvNEpyNN_Bk9M2tNdnZ_s,4598
-monocle_apptrace/metamodel/entities/README.md,sha256=dY7Q8QT_Ju-2ul65J-k0x6beDLvRirlbGufZN1Q0tpk,2068
-monocle_apptrace/metamodel/entities/app_hosting_types.json,sha256=MWeHUe77n4HvO1hm2PX8iWjbRONBuNy2I84vd-lymYk,568
-monocle_apptrace/metamodel/entities/entities.json,sha256=6eDoDm_6aPUgH_ROjI2H9Tk3J5Lj55VkX3Li-TJmaxg,1285
-monocle_apptrace/metamodel/entities/inference_types.json,sha256=Gkq7qNw5Qn91tuq-rBxHJ4BSzT-etCshNjT5_G4Bg8I,651
-monocle_apptrace/metamodel/entities/model_types.json,sha256=Oz9DzuX_ptpLEVTc1Epv4_Y80TrYxR7cyc9kM0Zk780,785
-monocle_apptrace/metamodel/entities/vector_store_types.json,sha256=EA0KayHMOG7wMIkec54en03_3yT1qpdGh5TiDrAoh4g,462
-monocle_apptrace/metamodel/entities/workflow_types.json,sha256=eD0W3_FocKrzrrW0bks0hIJb9Kj7w8c1dpXzxmGLOwk,386
-monocle_apptrace/metamodel/maps/haystack_methods.json,sha256=JmngkaKICAzOyrWNTWEOLYFrp99l5wcERYKE_SQRNxE,698
-monocle_apptrace/metamodel/maps/langchain_methods.json,sha256=lfU8nd6td5qzTI01glM063Vg0UoZM9HGPirwN4OZcKc,4285
-monocle_apptrace/metamodel/maps/llamaindex_methods.json,sha256=pZ4d1DS4D6Wgpz9EBOrEuJUFN58jtu75E8ELyGRBHyM,2636
-monocle_apptrace/metamodel/maps/attributes/inference/langchain_entities.json,sha256=E_K3eHv_e9Va2AcjNLHcXeAgePB1uolTMdRnkxxtNqU,1152
-monocle_apptrace/metamodel/maps/attributes/inference/llamaindex_entities.json,sha256=LuAa9ZKl3mO2VUiXMVGZNEfSHOZ0n5qsVQLqWRHczVM,1122
-monocle_apptrace/metamodel/maps/attributes/retrieval/langchain_entities.json,sha256=vSe2kbeJ7izmj5TBdQpX5pJ3hbjdY4SkcXvWPiam7oo,718
-monocle_apptrace/metamodel/maps/attributes/retrieval/llamaindex_entities.json,sha256=BtWeSXUPzKR9-vuhZUUhn2Gz9Y4SXBZoFC81K1q0XwQ,712
-monocle_apptrace/metamodel/spans/README.md,sha256=_uMkLLaWitQ_rPh7oQbW5Oe7uGSv2h_QA6YwxHRJi74,5433
-monocle_apptrace/metamodel/spans/span_example.json,sha256=7ZAUssL1UYXlbKHre8PfeNlIhHnM28e2CH9EyHDTOt8,4402
-monocle_apptrace/metamodel/spans/span_format.json,sha256=GhfioGgMhG7St0DeYA1fgNtMkbr9wiQ1L2hovekRQ24,1512
-monocle_apptrace/metamodel/spans/span_types.json,sha256=jwVyPbYMhEf2Ea6Egmb3m1Za28ap9dgZIpJDhdE1BlY,361
-monocle_apptrace-0.2.0.dist-info/METADATA,sha256=zaIOrJwa-RLX1bWeBEfTCfeBGC2cuNeXKwPHAYYNRT8,5364
-monocle_apptrace-0.2.0.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-monocle_apptrace-0.2.0.dist-info/licenses/LICENSE,sha256=ay9trLiP5I7ZsFXo6AqtkLYdRqe5S9r-DrPOvsNlZrg,9136
-monocle_apptrace-0.2.0.dist-info/licenses/NOTICE,sha256=9jn4xtwM_uUetJMx5WqGnhrR7MIhpoRlpokjSTlyt8c,112
-monocle_apptrace-0.2.0.dist-info/RECORD,,