monocle-apptrace 0.3.0b5__py3-none-any.whl → 0.3.0b6__py3-none-any.whl

monocle_apptrace/exporters/azure/blob_exporter.py

@@ -11,6 +11,7 @@ from opentelemetry.sdk.trace.export import SpanExporter, SpanExportResult
 from typing import Sequence
 from monocle_apptrace.exporters.base_exporter import SpanExporterBase
 import json
+from monocle_apptrace.instrumentation.common.constants import MONOCLE_SDK_VERSION
 logger = logging.getLogger(__name__)
 
 class AzureBlobSpanExporter(SpanExporterBase):
@@ -72,6 +73,12 @@ class AzureBlobSpanExporter(SpanExporterBase):
         """The actual async export logic is run here."""
         # Add spans to the export queue
         for span in spans:
+            # Azure blob library has a check to generate it's own span if OpenTelemetry is loaded and Azure trace package is installed (just pip install azure-trace-opentelemetry)
+            # With Monocle,OpenTelemetry is always loaded. If the Azure trace package is installed, then it triggers the blob trace generation on every blob operation.
+            # Thus, the Monocle span write ends up generating a blob span which again comes back to the exporter .. and would result in an infinite loop.
+            # To avoid this, we check if the span has the Monocle SDK version attribute and skip it if it doesn't. That way the blob span genearted by Azure library are not exported.
+            if not span.attributes.get(MONOCLE_SDK_VERSION):
+                continue # TODO: All exporters to use same base class and check it there
             self.export_queue.append(span)
             if len(self.export_queue) >= self.max_batch_size:
                 await self.__export_spans()

monocle_apptrace/exporters/okahu/okahu_exporter.py

@@ -83,7 +83,7 @@ class OkahuSpanExporter(SpanExporter):
                         result.text,
                     )
                     return SpanExportResult.FAILURE
-                logger.warning("spans successfully exported to okahu")
+                logger.debug("spans successfully exported to okahu")
                 return SpanExportResult.SUCCESS
             except ReadTimeout as e:
                 logger.warning("Trace export timed out: %s", str(e))

monocle_apptrace/instrumentation/common/constants.py

@@ -37,6 +37,19 @@ service_name_map = {
     GITHUB_CODESPACE_SERVICE_NAME: GITHUB_CODESPACE_IDENTIFIER_ENV_NAME
 }
 
+
+llm_type_map = {
+    "sagemakerendpoint": "aws_sagemaker",
+    "azureopenai": "azure_openai",
+    "openai": "openai",
+    "chatopenai": "openai",
+    "azurechatopenai": "azure_openai",
+    "bedrock": "aws_bedrock",
+    "sagemakerllm": "aws_sagemaker",
+    "chatbedrock": "aws_bedrock",
+    "openaigenerator": "openai",
+}
+
 MONOCLE_INSTRUMENTOR = "monocle_apptrace"
 WORKFLOW_TYPE_KEY = "workflow_type"
 DATA_INPUT_KEY = "data.input"
@@ -52,3 +65,7 @@ MONOCLE_SCOPE_NAME_PREFIX = "monocle.scope."
 SCOPE_METHOD_LIST = 'MONOCLE_SCOPE_METHODS'
 SCOPE_METHOD_FILE = 'monocle_scopes.json'
 SCOPE_CONFIG_PATH = 'MONOCLE_SCOPE_CONFIG_PATH'
+TRACE_PROPOGATION_URLS = "MONOCLE_TRACE_PROPAGATATION_URLS"
+WORKFLOW_TYPE_KEY = "monocle.workflow_type"
+WORKFLOW_TYPE_GENERIC = "workflow.generic"
+MONOCLE_SDK_VERSION = "monocle_apptrace.version"

monocle_apptrace/instrumentation/common/instrumentor.py

@@ -1,4 +1,5 @@
 import logging
+import inspect
 from typing import Collection, Dict, List, Union
 import random
 import uuid
@@ -14,7 +15,7 @@ from opentelemetry.sdk.trace import Span, TracerProvider
 from opentelemetry.sdk.trace.export import BatchSpanProcessor, SpanProcessor
 from opentelemetry.trace import get_tracer
 from wrapt import wrap_function_wrapper
-from opentelemetry.trace.propagation import set_span_in_context
+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.wrapper_method import (
@@ -22,11 +23,11 @@ from monocle_apptrace.instrumentation.common.wrapper_method import (
     WrapperMethod,
     MONOCLE_SPAN_HANDLERS
 )
-from monocle_apptrace.instrumentation.common.wrapper import scope_wrapper
+from monocle_apptrace.instrumentation.common.wrapper import scope_wrapper, ascope_wrapper
 from monocle_apptrace.instrumentation.common.utils import (
-    set_scope, remove_scope, http_route_handler, load_scopes
+    set_scope, remove_scope, http_route_handler, load_scopes, async_wrapper, http_async_route_handler
 )
-from monocle_apptrace.instrumentation.common.constants import MONOCLE_INSTRUMENTOR
+from monocle_apptrace.instrumentation.common.constants import MONOCLE_INSTRUMENTOR, WORKFLOW_TYPE_KEY
 from functools import wraps
 logger = logging.getLogger(__name__)
 
@@ -67,8 +68,8 @@ class MonocleInstrumentor(BaseInstrumentor):
                 handler = SpanHandler()
                 with tracer.start_as_current_span(span_name) as span:
                     response = fn(*args, **kwargs)
-                    handler.hydrate_span(to_wrap, span=span, wrapped=wrapped, instance=instance, args=args, kwargs=kwargs,
-                                         result=response)
+                    handler.hydrate_span(to_wrap, wrapped=wrapped, instance=instance, args=args, kwargs=kwargs,
+                                         result=response, span=span)
                     return response
 
             return with_instrumentation
@@ -93,7 +94,10 @@ class MonocleInstrumentor(BaseInstrumentor):
                 final_method_list.append(method.to_dict())
 
         for method in load_scopes():
-            method['wrapper_method'] = scope_wrapper
+            if method.get('async', False):
+                method['wrapper_method'] = ascope_wrapper
+            else:
+                method['wrapper_method'] = scope_wrapper
             final_method_list.append(method)
         
         for method_config in final_method_list:
@@ -191,40 +195,30 @@ def on_processor_start(span: Span, parent_context):
 def set_context_properties(properties: dict) -> None:
     attach(set_value(SESSION_PROPERTIES_KEY, properties))
 
-
-def propagate_trace_id(traceId = "", use_trace_context = False):
+def start_trace():
     try:
-        if traceId.startswith("0x"):
-            traceId = traceId.lstrip("0x")
         tracer = get_tracer(instrumenting_module_name= MONOCLE_INSTRUMENTOR, tracer_provider= get_tracer_provider())
-        initial_id_generator = tracer.id_generator
-        _parent_span_context = get_current() if use_trace_context else None
-        if traceId and is_valid_trace_id_uuid(traceId):
-            tracer.id_generator = FixedIdGenerator(uuid.UUID(traceId).int)
-
-        span = tracer.start_span(name = "parent_placeholder_span", context= _parent_span_context)
-        updated_span_context = set_span_in_context(span=span, context= _parent_span_context)
-        updated_span_context = set_value("root_span_id", span.get_span_context().span_id, updated_span_context)
-        token = attach(updated_span_context)
-
-        span.end()
-        tracer.id_generator = initial_id_generator
+        span = tracer.start_span(name = "workflow")
+        updated_span_context = set_span_in_context(span=span)
+        SpanHandler.set_default_monocle_attributes(span)
+        SpanHandler.set_workflow_properties(span)
+        token = SpanHandler.attach_workflow_type(context=updated_span_context)
         return token
     except:
-        logger.warning("Failed to propagate trace id")
-    return
+        logger.warning("Failed to start trace")
+        return None
 
-
-def propagate_trace_id_from_traceparent():
-    propagate_trace_id(use_trace_context = True)
-
-
-def stop_propagate_trace_id(token) -> None:
+def stop_trace(token) -> None:
     try:
-        detach(token)
+        _parent_span_context = get_current()
+        if _parent_span_context is not None:
+            parent_span: Span = _parent_span_context.get(_SPAN_KEY, None)
+            if parent_span is not None:
+                parent_span.end()
+        if token is not None:
+            SpanHandler.detach_workflow_type(token)
     except:
-        logger.warning("Failed to stop propagating trace id")
-
+        logger.warning("Failed to stop trace")
 
 def is_valid_trace_id_uuid(traceId: str) -> bool:
     try:
@@ -248,23 +242,38 @@ def monocle_trace_scope(scope_name: str, scope_value:str = None):
         yield
     finally:
         stop_scope(token)
-
+    
 def monocle_trace_scope_method(scope_name: str):
     def decorator(func):
-        def wrapper(*args, **kwargs):
-            token = start_scope(scope_name)
-            try:
-                result = func(*args, **kwargs)
+        if inspect.iscoroutinefunction(func):
+            @wraps(func)
+            async def wrapper(*args, **kwargs):
+                result = async_wrapper(func, scope_name, None, *args, **kwargs)
                 return result
-            finally:
-                stop_scope(token)
-        return wrapper
+            return wrapper
+        else:
+            @wraps(func)
+            def wrapper(*args, **kwargs):
+                token = start_scope(scope_name)
+                try:
+                    result = func(*args, **kwargs)
+                    return result
+                finally:
+                    stop_scope(token)
+            return wrapper
     return decorator
 
 def monocle_trace_http_route(func):
-    def wrapper(req):
-        return http_route_handler(req.headers, func, req)
-    return wrapper
+    if inspect.iscoroutinefunction(func):
+        @wraps(func)
+        async def wrapper(*args, **kwargs):
+            return http_async_route_handler(func, *args, **kwargs)
+        return wrapper
+    else:
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            return http_route_handler(func, *args, **kwargs)
+        return wrapper
 
 class FixedIdGenerator(id_generator.IdGenerator):
     def __init__(

monocle_apptrace/instrumentation/common/span_handler.py

@@ -1,16 +1,17 @@
 import logging
 import os
 from importlib.metadata import version
-from opentelemetry.context import get_current
-from opentelemetry.context import get_value
+from opentelemetry.context import get_value, set_value, attach, detach
 from opentelemetry.sdk.trace import Span
 
 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.constants import WORKFLOW_TYPE_KEY, WORKFLOW_TYPE_GENERIC
 
 logger = logging.getLogger(__name__)
 
@@ -20,8 +21,6 @@ WORKFLOW_TYPE_MAP = {
     "haystack": "workflow.haystack"
 }
 
-
-
 class SpanHandler:
 
     def __init__(self,instrumentor=None):
@@ -40,18 +39,32 @@ class SpanHandler:
         pass
 
     def skip_span(self, to_wrap, wrapped, instance, args, kwargs) -> bool:
+        # If this is a workflow span type and a workflow span is already generated, then skip generating this span
+        if to_wrap.get('span_type') == "workflow" and self.is_workflow_span_active():
+            return True
         return False
 
     def pre_task_processing(self, to_wrap, wrapped, instance, args,kwargs, span):
-        if self.__is_root_span(span):
-            try:
-                sdk_version = version("monocle_apptrace")
-                span.set_attribute("monocle_apptrace.version", sdk_version)
-            except Exception as e:
-                logger.warning("Exception finding monocle-apptrace version.")
         if "pipeline" in to_wrap['package']:
             set_attribute(QUERY, args[0]['prompt_builder']['question'])
 
+    @staticmethod
+    def set_default_monocle_attributes(span: Span):
+        """ Set default monocle attributes for all spans """
+        try:
+            sdk_version = version("monocle_apptrace")
+            span.set_attribute(MONOCLE_SDK_VERSION, sdk_version)
+        except Exception as e:
+            logger.warning("Exception finding monocle-apptrace version.")
+        for scope_key, scope_value in get_scopes().items():
+            span.set_attribute(f"scope.{scope_key}", scope_value)
+
+    @staticmethod
+    def set_workflow_properties(span: Span, to_wrap = None):
+        """ Set attributes of workflow if this is a root span"""
+        SpanHandler.set_workflow_attributes(to_wrap, span)
+        SpanHandler.set_app_hosting_identifier_attribute(span)
+
     def post_task_processing(self, to_wrap, wrapped, instance, args, kwargs, result, span):
         pass
 
@@ -61,10 +74,8 @@ class SpanHandler:
 
     def hydrate_attributes(self, to_wrap, wrapped, instance, args, kwargs, result, span):
         span_index = 0
-        if self.__is_root_span(span):
-            span_index += self.set_workflow_attributes(to_wrap, span, span_index+1)
-            span_index += self.set_app_hosting_identifier_attribute(span, span_index+1)
-
+        if SpanHandler.is_root_span(span):
+            span_index = 2 # root span will have workflow and hosting entities pre-populated
         if 'output_processor' in to_wrap and to_wrap["output_processor"] is not None:    
             output_processor=to_wrap['output_processor']
             if 'type' in output_processor:
@@ -124,46 +135,79 @@ class SpanHandler:
                                 logger.debug(f"Error evaluating accessor for attribute '{attribute_key}': {e}")
                     span.add_event(name=event_name, attributes=event_attributes)
 
-
-
-    def set_workflow_attributes(self, to_wrap, span: Span, span_index):
-        return_value = 1
-        workflow_name = self.get_workflow_name(span=span)
+    @staticmethod
+    def set_workflow_attributes(to_wrap, span: Span):
+        span_index = 1
+        workflow_name = SpanHandler.get_workflow_name(span=span)
         if workflow_name:
             span.set_attribute("span.type", "workflow")
             span.set_attribute(f"entity.{span_index}.name", workflow_name)
-            # workflow type
-        package_name = to_wrap.get('package')
-        workflow_type_set = False
-        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)
-                workflow_type_set = True
-        if not workflow_type_set:
-            span.set_attribute(f"entity.{span_index}.type", "workflow.generic")
-        return return_value
-
-    def set_app_hosting_identifier_attribute(self, span, span_index):
-        return_value = 0
+        workflow_type = SpanHandler.get_workflow_type(to_wrap)
+        span.set_attribute(f"entity.{span_index}.type", workflow_type)
+
+    @staticmethod
+    def get_workflow_type(to_wrap):
+        # workflow type
+        workflow_type = WORKFLOW_TYPE_GENERIC
+        if to_wrap is not None:
+            package_name = to_wrap.get('package')
+            for (package, framework_workflow_type) in WORKFLOW_TYPE_MAP.items():
+                if (package_name is not None and package in package_name):
+                    workflow_type = framework_workflow_type
+                    break
+        return workflow_type
+
+    def set_app_hosting_identifier_attribute(span):
+        span_index = 2
         # Search env to indentify the infra service type, if found check env for service name if possible
+        span.set_attribute(f"entity.{span_index}.type", f"app_hosting.generic")
+        span.set_attribute(f"entity.{span_index}.name", "generic")
         for type_env, type_name in service_type_map.items():
             if type_env in os.environ:
-                return_value = 1
                 span.set_attribute(f"entity.{span_index}.type", f"app_hosting.{type_name}")
                 entity_name_env = service_name_map.get(type_name, "unknown")
                 span.set_attribute(f"entity.{span_index}.name", os.environ.get(entity_name_env, "generic"))
-        return return_value
 
-    def get_workflow_name(self, span: Span) -> str:
+    @staticmethod
+    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
 
-    def __is_root_span(self, curr_span: Span) -> bool:
+    @staticmethod
+    def is_root_span(curr_span: Span) -> bool:
         try:
             if curr_span is not None and hasattr(curr_span, "parent"):
-                return curr_span.parent is None or get_current().get("root_span_id") == curr_span.parent.span_id
+                return curr_span.parent is None
         except Exception as e:
             logger.warning(f"Error finding root span: {e}")
+
+    def is_non_workflow_root_span(self, curr_span: Span, to_wrap) -> bool:
+        return SpanHandler.is_root_span(curr_span) and to_wrap.get("span_type") != "workflow"
+    
+    def is_workflow_span_active(self):
+        return get_value(WORKFLOW_TYPE_KEY) is not None
+
+    @staticmethod
+    def attach_workflow_type(to_wrap=None, context=None): 
+        token = None
+        if to_wrap:
+            if to_wrap.get('span_type') == "workflow":
+                token = attach(set_value(WORKFLOW_TYPE_KEY,
+                                        SpanHandler.get_workflow_type(to_wrap), context))
+        else:
+            token = attach(set_value(WORKFLOW_TYPE_KEY, WORKFLOW_TYPE_GENERIC, context))
+        return token
+
+    @staticmethod
+    def detach_workflow_type(token):
+        if token:
+            return detach(token)
+
+class NonFrameworkSpanHandler(SpanHandler):
+
+    # If the language framework is being executed, then skip generating direct openAI spans
+    def skip_span(self, to_wrap, wrapped, instance, args, kwargs) -> bool:
+        return get_value(WORKFLOW_TYPE_KEY) in WORKFLOW_TYPE_MAP.values()

monocle_apptrace/instrumentation/common/utils.py

@@ -1,7 +1,7 @@
 import logging, json
 import os
 from typing import Callable, Generic, Optional, TypeVar, Mapping
-from threading import local
+import threading, asyncio
 
 from opentelemetry.context import attach, detach, get_current, get_value, set_value, Context
 from opentelemetry.trace import NonRecordingSpan, Span, get_tracer
@@ -9,7 +9,7 @@ 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
+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')
@@ -232,13 +232,55 @@ def clear_http_scopes(token:object) -> None:
     global http_scopes
     remove_scopes(token)
 
-def http_route_handler(headers, func, req):
-    token = extract_http_headers(headers)
+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(req)
+        result = func(*args, **kwargs)
         return result
     finally:
-        clear_http_scopes(token)
+        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, headers, *args, **kwargs)
+
+def run_async_with_scope(method, scope_name, headers, *args, **kwargs):
+    token = None
+    if scope_name:
+        token = set_scope(scope_name)
+    elif headers:
+        token = extract_http_headers(headers)
+    try:
+        return asyncio.run(method(*args, **kwargs))
+    finally:
+        if token:
+            remove_scope(token)
+
+def async_wrapper(method, scope_name=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)
 
 class Option(Generic[T]):
     def __init__(self, value: Optional[T]):
@@ -270,6 +312,13 @@ def try_option(func: Callable[..., T], *args, **kwargs) -> Option[T]:
     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:

monocle_apptrace/instrumentation/common/wrapper.py

@@ -1,21 +1,20 @@
 # 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
+    remove_scope,
+    async_wrapper
 )
+from monocle_apptrace.instrumentation.common.constants import WORKFLOW_TYPE_KEY
 logger = logging.getLogger(__name__)
 
-
-@with_tracer_wrapper
-def task_wrapper(tracer: Tracer, handler: SpanHandler, to_wrap, wrapped, instance, args, kwargs):
-
+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)
@@ -28,49 +27,51 @@ def task_wrapper(tracer: Tracer, handler: SpanHandler, to_wrap, wrapped, instanc
         name = get_fully_qualified_class_name(instance)
 
     return_value = None
+    token = None
     try:
         handler.pre_tracing(to_wrap, wrapped, instance, args, kwargs)
-        if to_wrap.get('skip_span') or handler.skip_span(to_wrap, wrapped, instance, args, kwargs):
-            return_value = wrapped(*args, **kwargs)
-        else:
-            with tracer.start_as_current_span(name) as span:
-                handler.pre_task_processing(to_wrap, wrapped, instance, args, kwargs, span)
+        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 skip_scan:
+            if async_task:
+                return_value = async_wrapper(wrapped, 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)
+        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)
 
-@with_tracer_wrapper
-async def atask_wrapper(tracer: Tracer, handler: SpanHandler, 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 = get_fully_qualified_class_name(instance)
-
+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
-    try:
-        handler.pre_tracing(to_wrap, wrapped, instance, args, kwargs)
-        if to_wrap.get('skip_span') or handler.skip_span(to_wrap, wrapped, instance, args, kwargs):
-            return_value = wrapped(*args, **kwargs)
+    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:
-            with tracer.start_as_current_span(name) as span:
-                handler.pre_task_processing(to_wrap, wrapped, instance, args, kwargs, span)
+            handler.pre_task_processing(to_wrap, wrapped, instance, args, kwargs, span)
+            if async_task:
+                return_value = async_wrapper(wrapped, 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
-    finally:
-        handler.post_tracing(to_wrap, wrapped, instance, args, kwargs, return_value)
+            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):
@@ -82,13 +83,8 @@ def scope_wrapper(tracer: Tracer, handler: SpanHandler, to_wrap, wrapped, instan
         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)
-    if scope_name:
-        token = set_scope(scope_name)
-    return_value = wrapped(*args, **kwargs)
-    if scope_name:
-        remove_scope(token)
+    return_value = async_wrapper(wrapped, scope_name, None, *args, **kwargs)
     return return_value

monocle_apptrace/instrumentation/common/wrapper_method.py

@@ -1,7 +1,7 @@
 # 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
+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 (
@@ -26,13 +26,15 @@ class WrapperMethod:
             output_processor : str = None,
             wrapper_method = task_wrapper,
             span_handler = 'default',
-            scope_name: str = None
+            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
@@ -51,7 +53,8 @@ class WrapperMethod:
             'output_processor': self.output_processor,
             'wrapper_method': self.wrapper_method,
             'span_handler': self.span_handler,
-            'scope_name': self.scope_name
+            'scope_name': self.scope_name,
+            'span_type': self.span_type
         }
         return instance_dict
 
@@ -64,5 +67,6 @@ MONOCLE_SPAN_HANDLERS: Dict[str, SpanHandler] = {
     "default": SpanHandler(),
     "botocore_handler": BotoCoreSpanHandler(),
     "flask_handler": FlaskSpanHandler(),
-    "request_handler": RequestSpanHandler()
+    "request_handler": RequestSpanHandler(),
+    "non_framework_handler": NonFrameworkSpanHandler()
 }

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

@@ -9,7 +9,7 @@ INFERENCE = {
             {
                 "_comment": "provider type ,name , deployment , inference_endpoint",
                 "attribute": "type",
-                "accessor": lambda arguments: 'inference.azure_oai'
+                "accessor": lambda arguments: 'inference.azure_openai'
             },
             {
                 "attribute": "provider_name",

monocle_apptrace/instrumentation/metamodel/haystack/methods.py

@@ -37,6 +37,7 @@ HAYSTACK_METHODS = [
         "package": "haystack.core.pipeline.pipeline",
         "object": "Pipeline",
         "method": "run",
-        "wrapper_method": task_wrapper
+        "wrapper_method": task_wrapper,
+        "span_type": "workflow"
     }
 ]

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

@@ -1,7 +1,7 @@
 from monocle_apptrace.instrumentation.metamodel.langchain import (
     _helper,
 )
-from monocle_apptrace.instrumentation.common.utils import resolve_from_alias
+from monocle_apptrace.instrumentation.common.utils import resolve_from_alias, get_llm_type
 
 INFERENCE = {
     "type": "inference",
@@ -10,7 +10,8 @@ INFERENCE = {
             {
                 "_comment": "provider type ,name , deployment , inference_endpoint",
                 "attribute": "type",
-                "accessor": lambda arguments: 'inference.azure_oai'
+                "accessor": lambda arguments: 'inference.' + (get_llm_type(arguments['instance']) or 'generic')
+
             },
             {
                 "attribute": "provider_name",

monocle_apptrace/instrumentation/metamodel/langchain/methods.py

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

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

@@ -1,7 +1,7 @@
 from monocle_apptrace.instrumentation.metamodel.llamaindex import (
     _helper,
 )
-from monocle_apptrace.instrumentation.common.utils import resolve_from_alias
+from monocle_apptrace.instrumentation.common.utils import resolve_from_alias, get_llm_type
 
 INFERENCE = {
     "type": "inference",
@@ -10,11 +10,13 @@ INFERENCE = {
             {
                 "_comment": "provider type ,name , deployment , inference_endpoint",
                 "attribute": "type",
-                "accessor": lambda arguments: 'inference.azure_oai'
+                "accessor": lambda arguments: 'inference.' + (get_llm_type(arguments['instance']) or 'generic')
+
             },
             {
                 "attribute": "provider_name",
-                "accessor": lambda arguments: _helper.extract_provider_name(arguments['instance'])
+                "accessor": lambda arguments: arguments['kwargs'].get('provider_name') or _helper.extract_provider_name(arguments['instance'])
+
             },
             {
                 "attribute": "deployment",

monocle_apptrace/instrumentation/metamodel/llamaindex/methods.py

@@ -30,14 +30,16 @@ LLAMAINDEX_METHODS = [
         "object": "BaseQueryEngine",
         "method": "query",
         "span_name": "llamaindex.query",
-        "wrapper_method": task_wrapper
+        "wrapper_method": task_wrapper,
+        "span_type": "workflow"
     },
     {
         "package": "llama_index.core.base.base_query_engine",
         "object": "BaseQueryEngine",
         "method": "aquery",
         "span_name": "llamaindex.query",
-        "wrapper_method": atask_wrapper
+        "wrapper_method": atask_wrapper,
+        "span_type": "workflow"
     },
     {
         "package": "llama_index.core.llms.custom",
@@ -53,7 +55,8 @@ LLAMAINDEX_METHODS = [
         "method": "achat",
         "span_name": "llamaindex.llmchat",
         "wrapper_method": atask_wrapper,
-        "output_processor": INFERENCE
+        "output_processor": INFERENCE,
+        
     },
     {
         "package": "llama_index.llms.openai.base",

monocle_apptrace/instrumentation/metamodel/openai/_helper.py

@@ -32,7 +32,7 @@ def extract_messages(kwargs):
 
 def extract_assistant_message(response):
     try:
-        if hasattr(response,"choices") and len(response.choices) >0:
+        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
     except (IndexError, AttributeError) as e:
@@ -60,15 +60,20 @@ def resolve_from_alias(my_map, alias):
     return None
 
 
-def update_input_span_events(args):
-    return args[0] if len(args) > 0 else ""
+def update_input_span_events(kwargs):
+    if 'input' in kwargs and isinstance(kwargs['input'], list):
+        query = ' '.join(kwargs['input'])
+        return query
 
 
 def update_output_span_events(results):
-    output_arg_text = " ".join([doc.page_content for doc in results if hasattr(doc, 'page_content')])
-    if len(output_arg_text) > 100:
-        output_arg_text = output_arg_text[:100] + "..."
-    return output_arg_text
+    if hasattr(results,'data') and isinstance(results.data, list):
+        embeddings = results.data
+        embedding_strings = [f"index={e.index}, embedding={e.embedding}" for e in embeddings]
+        output = '\n'.join(embedding_strings)
+        if len(output) > 100:
+            output = output[:100] + "..."
+        return output
 
 
 def update_span_from_llm_response(response):
@@ -86,3 +91,22 @@ def update_span_from_llm_response(response):
             meta_dict.update({"total_tokens": getattr(response.usage, "total_tokens", None)})
     return meta_dict
 
+def extract_vector_input(vector_input: dict):
+    if 'input' in vector_input:
+        return vector_input['input']
+    return ""
+
+def extract_vector_output(vector_output):
+    try:
+        if hasattr(vector_output, 'data') and len(vector_output.data) > 0:
+            return vector_output.data[0].embedding
+    except Exception as e:
+        pass
+    return ""
+
+def get_inference_type(instance):
+    inference_type: Option[str] = try_option(getattr, instance._client, '_api_version')
+    if inference_type.unwrap_or(None):
+        return 'azure_openai'
+    else:
+        return 'openai'

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

@@ -10,7 +10,7 @@ INFERENCE = {
             {
                 "_comment": "provider type ,name , deployment , inference_endpoint",
                 "attribute": "type",
-                "accessor": lambda arguments: 'inference.azure_oai'
+                "accessor": lambda arguments: 'inference.' + (_helper.get_inference_type(arguments['instance'])) or 'openai'
             },
             {
                 "attribute": "provider_name",

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

@@ -19,6 +19,25 @@ RETRIEVAL = {
         ]
     ],
     "events": [
-
+        {
+             "name": "data.input",
+             "attributes": [
+                 {
+                     "_comment": "this is instruction and user query to LLM",
+                     "attribute": "input",
+                     "accessor": lambda arguments: _helper.update_input_span_events(arguments['kwargs'])
+                 }
+         ]
+         },
+        {
+            "name": "data.output",
+            "attributes": [
+                {
+                    "_comment": "this is result from LLM",
+                    "attribute": "response",
+                    "accessor": lambda arguments: _helper.update_output_span_events(arguments['result'])
+                }
+            ]
+        }
     ]
 }

monocle_apptrace/instrumentation/metamodel/openai/methods.py

@@ -12,7 +12,15 @@ OPENAI_METHODS = [
         "object": "Completions",
         "method": "create",
         "wrapper_method": task_wrapper,
-        "span_name": "openai_inference",
+        "span_handler": "non_framework_handler",
+        "output_processor": INFERENCE
+    },
+    {
+        "package": "openai.resources.chat.completions",
+        "object": "AsyncCompletions",
+        "method": "create",
+        "wrapper_method": atask_wrapper,
+        "span_handler": "non_framework_handler",
         "output_processor": INFERENCE
     },
     {
@@ -20,6 +28,18 @@ OPENAI_METHODS = [
         "object": "Embeddings",
         "method": "create",
         "wrapper_method": task_wrapper,
+        "span_name": "openai_embeddings",
+        "span_handler": "non_framework_handler",
+        "output_processor": RETRIEVAL
+    },
+    {
+        "package": "openai.resources.embeddings",
+        "object": "AsyncEmbeddings",
+        "method": "create",
+        "wrapper_method": atask_wrapper,
+        "span_name": "openai_embeddings",
+        "span_handler": "non_framework_handler",
         "output_processor": RETRIEVAL
     }
+
 ]

monocle_apptrace/instrumentation/metamodel/requests/__init__.py

@@ -1,2 +1,4 @@
 from os import environ
-allowed_urls = environ.get('MONOCLE_TRACE_PROPAGATATION_URLS', ' ').split(',')
+from monocle_apptrace.instrumentation.common.constants import TRACE_PROPOGATION_URLS
+allowed_url_str = environ.get(TRACE_PROPOGATION_URLS, "")
+allowed_urls:list[str] = [] if allowed_url_str == "" else allowed_url_str.split(',')

{monocle_apptrace-0.3.0b5.dist-info → monocle_apptrace-0.3.0b6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: monocle_apptrace
-Version: 0.3.0b5
+Version: 0.3.0b6
 Summary: package with monocle genAI tracing
 Project-URL: Homepage, https://github.com/monocle2ai/monocle
 Project-URL: Issues, https://github.com/monocle2ai/monocle/issues

{monocle_apptrace-0.3.0b5.dist-info → monocle_apptrace-0.3.0b6.dist-info}/RECORD

@@ -7,17 +7,17 @@ monocle_apptrace/exporters/file_exporter.py,sha256=gN9pJ_X5pcstVVsyivgHsjWhr443e
 monocle_apptrace/exporters/monocle_exporters.py,sha256=AxhZsTHjz2ZTuI-QOw1zk_bCKD899_EYyiEtCyAb1GA,2210
 monocle_apptrace/exporters/aws/s3_exporter.py,sha256=JMxtox61J6gUoEFsM1PJisBJPySMpm_U2Uv68WioKtE,7146
 monocle_apptrace/exporters/aws/s3_exporter_opendal.py,sha256=FvyW0KkAz0W_1g16C_ERmamg4fSreT-UXgLaN9URTVQ,5057
-monocle_apptrace/exporters/azure/blob_exporter.py,sha256=m7Hsw3OXlP2GOCQcdxf8LM6Fe12fZmih45x82Z12dbI,5597
+monocle_apptrace/exporters/azure/blob_exporter.py,sha256=9wIGeKe8slUx69MFqj_Bl2xupNuUB_mCw9lu5g1i77A,6514
 monocle_apptrace/exporters/azure/blob_exporter_opendal.py,sha256=h5xv7JU6YEXL4AKT2B1op3YsHoA0rNnLCGq8seoVRWs,6114
-monocle_apptrace/exporters/okahu/okahu_exporter.py,sha256=p2rjStwo0OMEdHWQt_QvREpUWXbDm5jGx3qXeYai4_M,4407
+monocle_apptrace/exporters/okahu/okahu_exporter.py,sha256=ENPcP2UB4DhM-2cKNWEqmPtcAkWB8mFmVBKVfkA8IuI,4405
 monocle_apptrace/instrumentation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 monocle_apptrace/instrumentation/common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-monocle_apptrace/instrumentation/common/constants.py,sha256=5h3UHq-5Wz9wmwETZi950XMHnV3rSH18yTDUTlQZnyw,2158
-monocle_apptrace/instrumentation/common/instrumentor.py,sha256=mHiNA2Lcb3S0tiXjI78bHYZUpzCZziw98Y-n2x1E1Ck,11100
-monocle_apptrace/instrumentation/common/span_handler.py,sha256=vvKZkrXuFXqo0JDljLgv1nlrSWg8huFamqUoUl-e9Hw,7784
-monocle_apptrace/instrumentation/common/utils.py,sha256=PiqvYlBaxoxTlJ48iW5Uw3RJ9DERVxMxIL7c6tcsiJc,9463
-monocle_apptrace/instrumentation/common/wrapper.py,sha256=jPIiPIecTQXsnR6SVs7KtPfjq37MuBi5CeeZLPVz03w,3860
-monocle_apptrace/instrumentation/common/wrapper_method.py,sha256=_j1JZ-K7Fo5UMuRypNui14n6Fc8zAMTS1zqslAfods4,2996
+monocle_apptrace/instrumentation/common/constants.py,sha256=6H5oLxGUD0Gd4bvEGq-fKm-W-ULWQ0bMOQs4puz5--I,2676
+monocle_apptrace/instrumentation/common/instrumentor.py,sha256=PiLOOArvLotnuhVqD5BIkZkY2cMJw2u8jSZYpi1_Wp0,11578
+monocle_apptrace/instrumentation/common/span_handler.py,sha256=tH4FKh2RAbAqzuoKwxgY8CO6f8WydoxTv4zRdHEeJCA,9741
+monocle_apptrace/instrumentation/common/utils.py,sha256=z-m_lR2zwIng76ewWVOHfpGF8olB5n-7pxInPOOEXh8,11064
+monocle_apptrace/instrumentation/common/wrapper.py,sha256=_1iUi9UOp579BB_o76Om_OIlr8RNbrIEn2Vlxfg-RII,4353
+monocle_apptrace/instrumentation/common/wrapper_method.py,sha256=7k_rHOzbFRfeW40CMfa78wwyPVfSgcXiyDsgezjDcaA,3188
 monocle_apptrace/instrumentation/metamodel/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 monocle_apptrace/instrumentation/metamodel/botocore/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 monocle_apptrace/instrumentation/metamodel/botocore/_helper.py,sha256=JIYtaN57OXKO9zPuxMZzDycJbgHgAQaQUkwuCI_SzF8,3744
@@ -30,15 +30,15 @@ monocle_apptrace/instrumentation/metamodel/flask/_helper.py,sha256=AcQ5F6_IDmu9P
 monocle_apptrace/instrumentation/metamodel/flask/methods.py,sha256=QkWHX4wKQf_GiJBHmiS9_JD2CiKMTCWMcig2dxAiKgU,340
 monocle_apptrace/instrumentation/metamodel/haystack/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 monocle_apptrace/instrumentation/metamodel/haystack/_helper.py,sha256=VgTrKn7rZMcv4OVdVEBI76G-5B0Rux4guiI6Nsso14s,4833
-monocle_apptrace/instrumentation/metamodel/haystack/methods.py,sha256=4WwhZoPQBkV42TpBvn-rXu37xtaBRrw7_VZB3MGrfxE,1434
+monocle_apptrace/instrumentation/metamodel/haystack/methods.py,sha256=1XpEfU8-cczTiH2KbxGgSm-27V7xk1j5LxVciWfNuJo,1467
 monocle_apptrace/instrumentation/metamodel/haystack/entities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-monocle_apptrace/instrumentation/metamodel/haystack/entities/inference.py,sha256=PkCaaar5hbZH7YGtWisq8dUJqBINsFGmtaUgt11UDa4,3019
+monocle_apptrace/instrumentation/metamodel/haystack/entities/inference.py,sha256=bCAp8qpw2GGt1RRZcrucOGqP_Z9gkN8iCCQh6Mlf_Z0,3022
 monocle_apptrace/instrumentation/metamodel/haystack/entities/retrieval.py,sha256=nq3lsk2qFxXqwrAHsBt8zrh4ZVGAJABkPtylrjUCCqc,2357
 monocle_apptrace/instrumentation/metamodel/langchain/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 monocle_apptrace/instrumentation/metamodel/langchain/_helper.py,sha256=g88Hz4n25ALJnjYFhdbdoIlSFUJUkN-8gho8ru7txEQ,4910
-monocle_apptrace/instrumentation/metamodel/langchain/methods.py,sha256=xEWO4uSiOnR221cvXESnVgAfC6JeExsP46ZkbK8_Yqs,3027
+monocle_apptrace/instrumentation/metamodel/langchain/methods.py,sha256=hlLR43KXwiwYshvgoBrlqMOemFifhpgeR7smTb4zkCc,3225
 monocle_apptrace/instrumentation/metamodel/langchain/entities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-monocle_apptrace/instrumentation/metamodel/langchain/entities/inference.py,sha256=wjW9hb1Qwr_aqY0lPehdPftyHtuvHinGxVmy0TVj5xo,2705
+monocle_apptrace/instrumentation/metamodel/langchain/entities/inference.py,sha256=2CNHloheb4LG7rPEUIF3E3M1cuc8CWVZf9J6l_hvK1E,2764
 monocle_apptrace/instrumentation/metamodel/langchain/entities/retrieval.py,sha256=r4UqTCT5vOfkbz9lwoTRoiMkUUJtPMwqOYbqo53A6K8,2039
 monocle_apptrace/instrumentation/metamodel/langgraph/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 monocle_apptrace/instrumentation/metamodel/langgraph/_helper.py,sha256=-XmAbhkgqwaunFZa-BP0zWZ3e-uD-ihSszbn5Cz75yc,2043
@@ -47,22 +47,22 @@ monocle_apptrace/instrumentation/metamodel/langgraph/entities/__init__.py,sha256
 monocle_apptrace/instrumentation/metamodel/langgraph/entities/inference.py,sha256=OaPeQ8pkyEP5j6ad537MTPp0BdDI7nabxf60u66Dzbk,1659
 monocle_apptrace/instrumentation/metamodel/llamaindex/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 monocle_apptrace/instrumentation/metamodel/llamaindex/_helper.py,sha256=5nqG-bSW3-ZEADZcwlHXIhhGZoTZu2a5Sc3Lo_AByeo,6199
-monocle_apptrace/instrumentation/metamodel/llamaindex/methods.py,sha256=r-o2zz9_ATfgKjUmIiaeSFQ774Vy4wGYueoVc-TqGMI,3061
+monocle_apptrace/instrumentation/metamodel/llamaindex/methods.py,sha256=3Lr7C3GPQMScLX7gQTrPxU7hs8TTIYFTXApAGyB2yjU,3137
 monocle_apptrace/instrumentation/metamodel/llamaindex/entities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 monocle_apptrace/instrumentation/metamodel/llamaindex/entities/agent.py,sha256=g7IEwFMLjYvxljX7iHoYSPJW6k-wC7Z3i_y2qlNEZcs,1338
-monocle_apptrace/instrumentation/metamodel/llamaindex/entities/inference.py,sha256=585hJXbdN2kFOnABv12vlzFkCbDExZln5ISvQI71EHw,2623
+monocle_apptrace/instrumentation/metamodel/llamaindex/entities/inference.py,sha256=Hich1AoEHnCUvh0MIISNOjbH9t71eex_IsY_4j3JN5U,2727
 monocle_apptrace/instrumentation/metamodel/llamaindex/entities/retrieval.py,sha256=QBF1nrqog5KHh925jiY2V-kejL6iVLKUowZmqUDoiJ4,1870
 monocle_apptrace/instrumentation/metamodel/openai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-monocle_apptrace/instrumentation/metamodel/openai/_helper.py,sha256=nQSV8B000AfWjaIAKqkA5ZD5e-ozx3KIVTEBOYvoYxA,3066
-monocle_apptrace/instrumentation/metamodel/openai/methods.py,sha256=Ahmi0wo6UUHcOXz-6U_6EPZ2bEKXnu5o8NUVrikz0w0,759
+monocle_apptrace/instrumentation/metamodel/openai/_helper.py,sha256=VDjpKRXXbOTma3clD54SYG1TaMXr-To0S3yotp7_9aY,3877
+monocle_apptrace/instrumentation/metamodel/openai/methods.py,sha256=bQ0cW_9Ry5bKKsYGzatys-R6wBW3kpYha5QX328AWLM,1420
 monocle_apptrace/instrumentation/metamodel/openai/entities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-monocle_apptrace/instrumentation/metamodel/openai/entities/inference.py,sha256=yu0a9DyBqGOGRQFcPgl1fOSCKu6Jc41Dxx9N0QuwVR0,2659
-monocle_apptrace/instrumentation/metamodel/openai/entities/retrieval.py,sha256=QICL56xZF0R84rCpf_Wj_1pMUOt6M8UzLRaICJnEQ7Y,755
-monocle_apptrace/instrumentation/metamodel/requests/__init__.py,sha256=A9M_SrBoVqjo2HENM9VtAdOzIme82lsoGt361bBKW84,101
+monocle_apptrace/instrumentation/metamodel/openai/entities/inference.py,sha256=Egpx7ROZvwH6E3hqDWXa1gCXiNijnH3LD0HqQWhfspg,2716
+monocle_apptrace/instrumentation/metamodel/openai/entities/retrieval.py,sha256=LU7aec302ZqPrs9MzFWU-JTnhK8OpYfgQKMmktlD6-8,1457
+monocle_apptrace/instrumentation/metamodel/requests/__init__.py,sha256=mg04UgoPzzcH-cPOahYUqN9T-TolZyOZipnBwDg5TP8,250
 monocle_apptrace/instrumentation/metamodel/requests/_helper.py,sha256=lKU7py-M0eweHA_LWatwdyWbSGSlQNhScGZ43Xko7us,1115
 monocle_apptrace/instrumentation/metamodel/requests/methods.py,sha256=OJtosy_07xy01o5Qv-53--aCLQLkr82NZtyi2t6ZDEM,326
-monocle_apptrace-0.3.0b5.dist-info/METADATA,sha256=Tr4V0KMOc7nfKDTNDDE_OKc559DGJPULoacZEiG7EZE,6314
-monocle_apptrace-0.3.0b5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-monocle_apptrace-0.3.0b5.dist-info/licenses/LICENSE,sha256=ay9trLiP5I7ZsFXo6AqtkLYdRqe5S9r-DrPOvsNlZrg,9136
-monocle_apptrace-0.3.0b5.dist-info/licenses/NOTICE,sha256=9jn4xtwM_uUetJMx5WqGnhrR7MIhpoRlpokjSTlyt8c,112
-monocle_apptrace-0.3.0b5.dist-info/RECORD,,
+monocle_apptrace-0.3.0b6.dist-info/METADATA,sha256=nJZcCp2923tMJsL-UyHaNCj7VLs1tYcb02pp5gIqJ4I,6314
+monocle_apptrace-0.3.0b6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+monocle_apptrace-0.3.0b6.dist-info/licenses/LICENSE,sha256=ay9trLiP5I7ZsFXo6AqtkLYdRqe5S9r-DrPOvsNlZrg,9136
+monocle_apptrace-0.3.0b6.dist-info/licenses/NOTICE,sha256=9jn4xtwM_uUetJMx5WqGnhrR7MIhpoRlpokjSTlyt8c,112
+monocle_apptrace-0.3.0b6.dist-info/RECORD,,