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

monocle_apptrace/instrumentation/common/utils.py

@@ -1,16 +1,33 @@
-import logging
-from typing import Callable, Generic, Optional, TypeVar
+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
-from opentelemetry.trace import NonRecordingSpan, Span
+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] = {}
+
+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:
@@ -139,6 +156,131 @@ def get_nested_value(data, keys):
 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, 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]):
@@ -168,4 +310,18 @@ def try_option(func: Callable[..., T], *args, **kwargs) -> Option[T]:
     try:
         return Option(func(*args, **kwargs))
     except Exception:
-        return Option(None)
+        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

@@ -1,20 +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,
+    async_wrapper
 )
-from monocle_apptrace.instrumentation.metamodel.botocore import _helper
+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)
@@ -26,44 +26,65 @@ def task_wrapper(tracer: Tracer, handler: SpanHandler, to_wrap, wrapped, instanc
     else:
         name = get_fully_qualified_class_name(instance)
 
-    handler.validate(to_wrap, wrapped, instance, args, kwargs)
-    handler.set_context_properties(to_wrap, wrapped, instance, args, kwargs)
-
-    if to_wrap.get('skip_span'):
-        return_value = wrapped(*args, **kwargs)
-        _helper.botocore_processor(tracer, to_wrap, wrapped, instance, args, kwargs, return_value)
+    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)
+        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)
+        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:
-        handler.pre_task_processing(to_wrap, wrapped, instance, args, span)
-        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)
-
+        # 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, *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):
-    """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)
-
-    handler.validate(to_wrap, wrapped, instance, args, kwargs)
-    handler.set_context_properties(to_wrap, wrapped, instance, args, kwargs)
-    with tracer.start_as_current_span(name) as span:
-        handler.pre_task_processing(to_wrap, wrapped, instance, args, span)
-        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 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)
+    return_value = async_wrapper(wrapped, scope_name, None, *args, **kwargs)
+    return return_value

monocle_apptrace/instrumentation/common/wrapper_method.py

@@ -1,12 +1,20 @@
 # pylint: disable=too-few-public-methods
-from monocle_apptrace.instrumentation.common.wrapper import task_wrapper
+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__(
@@ -17,16 +25,23 @@ class WrapperMethod:
             span_name: str = None,
             output_processor : str = None,
             wrapper_method = task_wrapper,
-            span_handler = 'default'
+            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_handler = span_handler
+        self.span_type = span_type
 
-        self.wrapper_method = wrapper_method
+        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
@@ -37,9 +52,21 @@ class WrapperMethod:
             'span_name': self.span_name,
             'output_processor': self.output_processor,
             'wrapper_method': self.wrapper_method,
-            'span_handler': self.span_handler
+            '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
 
-DEFAULT_METHODS_LIST = LANGCHAIN_METHODS + LLAMAINDEX_METHODS + HAYSTACK_METHODS + BOTOCORE_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

@@ -81,37 +81,6 @@ def resolve_from_alias(my_map, alias):
             return my_map[i]
     return None
 
-
-def botocore_processor(tracer, to_wrap, wrapped, instance, args, kwargs,return_value):
-    service_name = kwargs.get("service_name")
-    service_method_mapping = {
-        "sagemaker-runtime": "invoke_endpoint",
-        "bedrock-runtime": "converse",
-    }
-    if service_name in service_method_mapping:
-        method_name = service_method_mapping[service_name]
-        original_method = getattr(return_value, method_name, None)
-
-        if original_method:
-            instrumented_method = _instrumented_endpoint_invoke(
-                to_wrap, wrapped,return_value, original_method, tracer, service_name
-            )
-            setattr(return_value, method_name, instrumented_method)
-
-
-def _instrumented_endpoint_invoke(to_wrap,wrapped, instance, fn, tracer,service_name):
-    @wraps(fn)
-    def with_instrumentation(*args, **kwargs):
-        span_name="botocore-"+service_name+"-invoke-endpoint"
-        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)
-            return response
-
-    return with_instrumentation
-
-
 def update_span_from_llm_response(response, instance):
     meta_dict = {}
     if response is not None and isinstance(response, dict) and "usage" in response:

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

@@ -0,0 +1,25 @@
+from monocle_apptrace.instrumentation.common.span_handler import SpanHandler
+
+class BotoCoreSpanHandler(SpanHandler):
+
+    def _botocore_processor(self, to_wrap, wrapped, instance, args, kwargs, return_value):
+        service_name = kwargs.get("service_name")
+        service_method_mapping = {
+            "sagemaker-runtime": "invoke_endpoint",
+            "bedrock-runtime": "converse",
+        }
+        if service_name in service_method_mapping:
+            method_name = service_method_mapping[service_name]
+            original_method = getattr(return_value, method_name, None)
+            span_name = "botocore-" + service_name + "-invoke-endpoint"
+            # wrap_util(original_method, span_name)
+            if original_method:
+                instrumentor = self.instrumentor
+                if instrumentor:
+                    instrumented_method = instrumentor(to_wrap, wrapped, span_name, return_value, original_method)
+                    setattr(return_value, method_name, instrumented_method)
+
+    def post_tracing(self, to_wrap, wrapped, instance, args, kwargs, return_value):
+        self._botocore_processor(to_wrap=to_wrap, wrapped=wrapped, instance=instance, return_value=return_value, args=args,
+                                 kwargs=kwargs)
+        return super().pre_tracing(to_wrap, wrapped, instance, args, kwargs)

monocle_apptrace/instrumentation/metamodel/botocore/methods.py

@@ -3,14 +3,14 @@ from monocle_apptrace.instrumentation.metamodel.botocore.entities.inference impo
     INFERENCE,
 )
 
-BOTOCORE_METHODS = [{
-
+BOTOCORE_METHODS = [
+    {
       "package": "botocore.client",
       "object": "ClientCreator",
       "method": "create_client",
       "wrapper_method": task_wrapper,
-      "skip_span": True,
-      "output_processor": INFERENCE
-
-}
+      "span_handler":"botocore_handler",
+      "output_processor": INFERENCE,
+      "skip_span": True
+    }
 ]

monocle_apptrace/instrumentation/metamodel/flask/_helper.py

@@ -0,0 +1,29 @@
+from threading import local
+from monocle_apptrace.instrumentation.common.utils import extract_http_headers, clear_http_scopes
+from opentelemetry.propagate import extract
+from opentelemetry.context import Context, attach, detach
+from monocle_apptrace.instrumentation.common.span_handler import SpanHandler
+token_data = local()
+token_data.current_token = None
+
+def flask_pre_tracing(args):
+    headers = dict()
+    for key, value in args[0].items():
+        if key.startswith("HTTP_"):
+            new_key = key[5:].lower().replace("_", "-")
+            headers[new_key] = value
+    token_data.current_token = extract_http_headers(headers)
+
+def flask_post_tracing():
+    clear_http_scopes(token_data.current_token)
+    token_data.current_token = None
+
+class FlaskSpanHandler(SpanHandler):
+
+    def pre_tracing(self, to_wrap, wrapped, instance, args, kwargs):
+        flask_pre_tracing(args)
+        return super().pre_tracing(to_wrap, wrapped, instance, args, kwargs)
+    
+    def post_tracing(self, to_wrap, wrapped, instance, args, kwargs, return_value):
+        flask_post_tracing()
+        return super().post_tracing(to_wrap, wrapped, instance, args, kwargs, return_value)

monocle_apptrace/instrumentation/metamodel/flask/methods.py

@@ -0,0 +1,13 @@
+from monocle_apptrace.instrumentation.common.wrapper import task_wrapper
+
+FLASK_METHODS = [
+    {
+        "package": "flask.app",
+        "object": "Flask",
+        "method": "wsgi_app",
+        "span_name": "Flask.wsgi_app",
+        "wrapper_method": task_wrapper,
+        "span_handler": "flask_handler",
+        "skip_span": True
+    }
+]

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/_helper.py

@@ -22,6 +22,10 @@ def extract_messages(args):
         if args and isinstance(args, (list, tuple)) and hasattr(args[0], 'text'):
             return [args[0].text]
         if args and isinstance(args, (list, tuple)) and len(args) > 0:
+            if isinstance(args[0], list) and len(args[0]) > 0:
+                first_msg = args[0][0]
+                if hasattr(first_msg, 'content') and hasattr(first_msg, 'type') and first_msg.type == "human":
+                    return args[0][0].content
             if hasattr(args[0], "messages") and isinstance(args[0].messages, list):
                 for msg in args[0].messages:
                     if hasattr(msg, 'content') and hasattr(msg, 'type'):

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"
     }
 ]