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

monocle_apptrace/instrumentation/common/wrapper.py

@@ -11,7 +11,7 @@ from monocle_apptrace.instrumentation.common.utils import (
     remove_scope,
     async_wrapper
 )
-from monocle_apptrace.instrumentation.common.constants import WORKFLOW_TYPE_KEY
+from monocle_apptrace.instrumentation.common.constants import WORKFLOW_TYPE_KEY, ADD_NEW_WORKFLOW
 logger = logging.getLogger(__name__)
 
 def wrapper_processor(async_task: bool, tracer: Tracer, handler: SpanHandler, to_wrap, wrapped, instance, args, kwargs):
@@ -19,9 +19,7 @@ def wrapper_processor(async_task: bool, tracer: Tracer, handler: SpanHandler, to
     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"):
+    if to_wrap.get("span_name"):
         name = to_wrap.get("span_name")
     else:
         name = get_fully_qualified_class_name(instance)
@@ -30,39 +28,44 @@ def wrapper_processor(async_task: bool, tracer: Tracer, handler: SpanHandler, to
     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 to_wrap.get('skip_span', False) or handler.skip_span(to_wrap, wrapped, instance, args, kwargs):
             if async_task:
-                return_value = async_wrapper(wrapped, None, None, *args, **kwargs)
+                return_value = async_wrapper(wrapped, None, None, None, *args, **kwargs)
             else:
                 return_value = wrapped(*args, **kwargs)
         else:
-            return_value = span_processor(name, async_task, tracer, handler, to_wrap, wrapped, instance, args, kwargs)
+            add_workflow_span = get_value(ADD_NEW_WORKFLOW) == True
+            token = attach(set_value(ADD_NEW_WORKFLOW, False))
+            try:
+                return_value = span_processor(name, async_task, tracer, handler, add_workflow_span,
+                                        to_wrap, wrapped, instance, args, kwargs)
+            finally:
+                detach(token)
         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):
+def span_processor(name: str, async_task: bool, tracer: Tracer, handler: SpanHandler, add_workflow_span:bool,
+                to_wrap, wrapped, instance, args, kwargs):
     # For singleton spans, eg OpenAI inference generate a workflow span to format the workflow specific attributes
     return_value = None
     with tracer.start_as_current_span(name) as span:
         # Since Spanhandler can be overridden, ensure we set default monocle attributes.
         SpanHandler.set_default_monocle_attributes(span)
-        if SpanHandler.is_root_span(span):
-            SpanHandler.set_workflow_properties(span, to_wrap)
-        if handler.is_non_workflow_root_span(span, to_wrap):
+        if SpanHandler.is_root_span(span) or add_workflow_span:
             # 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)
+            SpanHandler.set_workflow_properties(span, to_wrap)
+            return_value = span_processor(name, async_task, tracer, handler, False, 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)
+            with SpanHandler.workflow_type(to_wrap):
+                SpanHandler.set_non_workflow_properties(span)
+                handler.pre_task_processing(to_wrap, wrapped, instance, args, kwargs, span)
+                if async_task:
+                    return_value = async_wrapper(wrapped, None, None, None, *args, **kwargs)
+                else:                    
+                    return_value = wrapped(*args, **kwargs)
+                handler.hydrate_span(to_wrap, wrapped, instance, args, kwargs, return_value, span)
+                handler.post_task_processing(to_wrap, wrapped, instance, args, kwargs, return_value, span)
     return return_value
 
 @with_tracer_wrapper
@@ -86,5 +89,6 @@ def scope_wrapper(tracer: Tracer, handler: SpanHandler, to_wrap, wrapped, instan
 @with_tracer_wrapper
 async def ascope_wrapper(tracer: Tracer, handler: SpanHandler, to_wrap, wrapped, instance, args, kwargs):
     scope_name = to_wrap.get('scope_name', None)
-    return_value = async_wrapper(wrapped, scope_name, None, *args, **kwargs)
+    scope_value = to_wrap.get('scope_value', None)
+    return_value = async_wrapper(wrapped, scope_name, scope_value, None, *args, **kwargs)
     return return_value

monocle_apptrace/instrumentation/common/wrapper_method.py

@@ -12,9 +12,11 @@ from monocle_apptrace.instrumentation.metamodel.haystack.methods import (HAYSTAC
 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.flask._helper import FlaskSpanHandler, FlaskResponseSpanHandler
 from monocle_apptrace.instrumentation.metamodel.requests.methods import (REQUESTS_METHODS, )
 from monocle_apptrace.instrumentation.metamodel.requests._helper import RequestSpanHandler
+from monocle_apptrace.instrumentation.metamodel.teamsai.methods import (TEAMAI_METHODS, )
+from monocle_apptrace.instrumentation.metamodel.anthropic.methods import (ANTHROPIC_METHODS, )
 
 class WrapperMethod:
     def __init__(
@@ -61,12 +63,13 @@ class WrapperMethod:
     def get_span_handler(self) -> SpanHandler:
         return self.span_handler()
 
-DEFAULT_METHODS_LIST = LANGCHAIN_METHODS + LLAMAINDEX_METHODS + HAYSTACK_METHODS + BOTOCORE_METHODS + FLASK_METHODS + REQUESTS_METHODS + LANGGRAPH_METHODS + OPENAI_METHODS
+DEFAULT_METHODS_LIST = LANGCHAIN_METHODS + LLAMAINDEX_METHODS + HAYSTACK_METHODS + BOTOCORE_METHODS + FLASK_METHODS + REQUESTS_METHODS + LANGGRAPH_METHODS + OPENAI_METHODS + TEAMAI_METHODS + ANTHROPIC_METHODS
 
 MONOCLE_SPAN_HANDLERS: Dict[str, SpanHandler] = {
     "default": SpanHandler(),
     "botocore_handler": BotoCoreSpanHandler(),
     "flask_handler": FlaskSpanHandler(),
+    "flask_response_handler": FlaskResponseSpanHandler(),
     "request_handler": RequestSpanHandler(),
     "non_framework_handler": NonFrameworkSpanHandler()
 }

monocle_apptrace/instrumentation/metamodel/anthropic/_helper.py

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

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

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

monocle_apptrace/instrumentation/metamodel/anthropic/methods.py

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

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

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

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

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

monocle_apptrace/instrumentation/metamodel/flask/_helper.py

@@ -1,11 +1,41 @@
+import logging
 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
+from urllib.parse import unquote
+from opentelemetry.context import get_current
+from opentelemetry.trace import Span, get_current_span
+from opentelemetry.trace.propagation import _SPAN_KEY
+
+logger = logging.getLogger(__name__)
+MAX_DATA_LENGTH = 1000
 token_data = local()
 token_data.current_token = None
 
+def get_route(args) -> str:
+    return args[0]['PATH_INFO'] if 'PATH_INFO' in args[0] else ""
+
+def get_method(args) -> str:
+    return args[0]['REQUEST_METHOD'] if 'REQUEST_METHOD' in args[0] else ""
+
+def get_params(args) -> dict:
+    params = args[0]['QUERY_STRING'] if 'QUERY_STRING' in args[0] else ""
+    return unquote(params)
+
+def get_body(args) -> dict:
+    return ""
+
+def extract_response(instance) -> str:
+    if hasattr(instance, 'data') and hasattr(instance, 'content_length'):
+        response = instance.data[0:max(instance.content_length, MAX_DATA_LENGTH)]
+    else:   
+        response = ""
+    return response
+
+def extract_status(instance) -> str:
+    status = instance.status if hasattr(instance, 'status') else ""
+    return status
+
 def flask_pre_tracing(args):
     headers = dict()
     for key, value in args[0].items():
@@ -26,4 +56,16 @@ class FlaskSpanHandler(SpanHandler):
     
     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)
+        return super().post_tracing(to_wrap, wrapped, instance, args, kwargs, return_value)
+
+class FlaskResponseSpanHandler(SpanHandler):
+    def post_tracing(self, to_wrap, wrapped, instance, args, kwargs, return_value):
+        try:
+            _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:
+                    self.hydrate_events(to_wrap, wrapped, instance, args, kwargs, return_value, parent_span)
+        except Exception as e:
+            logger.info(f"Failed to propogate flask response: {e}")
+        super().post_tracing(to_wrap, wrapped, instance, args, kwargs, return_value)

monocle_apptrace/instrumentation/metamodel/flask/entities/http.py

@@ -0,0 +1,49 @@
+from monocle_apptrace.instrumentation.metamodel.flask import _helper
+FLASK_HTTP_PROCESSOR = {
+    "type": "http.process",
+    "attributes": [
+        [
+            {
+                "_comment": "request method, request URI",
+                "attribute": "method",
+                "accessor": lambda arguments: _helper.get_method(arguments['args'])
+            },
+            {
+                "_comment": "request method, request URI",
+                "attribute": "route",
+                "accessor": lambda arguments: _helper.get_route(arguments['args'])
+            },
+        ]
+    ]
+}
+
+FLASK_RESPONSE_PROCESSOR = {
+    "type": "http.process",
+    "events": [
+        {
+            "name": "data.input",
+            "attributes": [
+                {
+                    "_comment": "route params",
+                    "attribute": "params",
+                    "accessor": lambda arguments: _helper.get_params(arguments['args'])
+                }
+         ]
+         },
+        {
+            "name": "data.output",
+            "attributes": [
+                {
+                    "_comment": "status from HTTP response",
+                    "attribute": "status",
+                    "accessor": lambda arguments: _helper.extract_status(arguments['instance'])
+                },
+                {
+                    "_comment": "this is result from LLM",
+                    "attribute": "response",
+                    "accessor": lambda arguments: _helper.extract_response(arguments['instance'])
+                }
+            ]
+        }
+    ]
+}

monocle_apptrace/instrumentation/metamodel/flask/methods.py

@@ -1,13 +1,22 @@
 from monocle_apptrace.instrumentation.common.wrapper import task_wrapper
+from monocle_apptrace.instrumentation.metamodel.flask.entities.http import FLASK_HTTP_PROCESSOR, FLASK_RESPONSE_PROCESSOR
 
 FLASK_METHODS = [
     {
         "package": "flask.app",
         "object": "Flask",
         "method": "wsgi_app",
-        "span_name": "Flask.wsgi_app",
         "wrapper_method": task_wrapper,
         "span_handler": "flask_handler",
+        "output_processor": FLASK_HTTP_PROCESSOR,
+    },
+    {
+        "package": "werkzeug.wrappers.response",
+        "object": "Response",
+        "method": "__call__",
+        "wrapper_method": task_wrapper,
+        "span_handler": "flask_response_handler",
+        "output_processor": FLASK_RESPONSE_PROCESSOR,
         "skip_span": True
     }
 ]

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

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

monocle_apptrace/instrumentation/metamodel/haystack/methods.py

@@ -7,7 +7,6 @@ HAYSTACK_METHODS = [
         "package": "haystack.components.retrievers.in_memory",
         "object": "InMemoryEmbeddingRetriever",
         "method": "run",
-        "span_name": "haystack.retriever",
         "wrapper_method": task_wrapper,
         "output_processor": RETRIEVAL
     },
@@ -15,7 +14,6 @@ HAYSTACK_METHODS = [
         "package": "haystack_integrations.components.retrievers.opensearch",
         "object": "OpenSearchEmbeddingRetriever",
         "method": "run",
-        "span_name": "haystack.retriever",
         "wrapper_method": task_wrapper,
         "output_processor": RETRIEVAL
     },
@@ -37,7 +35,6 @@ HAYSTACK_METHODS = [
         "package": "haystack.core.pipeline.pipeline",
         "object": "Pipeline",
         "method": "run",
-        "wrapper_method": task_wrapper,
-        "span_type": "workflow"
+        "wrapper_method": task_wrapper
     }
 ]

monocle_apptrace/instrumentation/metamodel/langchain/_helper.py

@@ -50,14 +50,22 @@ def extract_assistant_message(response):
 
 
 def extract_provider_name(instance):
-    provider_url: Option[str] = try_option(getattr, instance.client._client.base_url, 'host')
+    provider_url: Option[str] = None
+    if hasattr(instance,'client'):
+        provider_url: Option[str] = try_option(getattr, instance.client._client.base_url, 'host')
+    if hasattr(instance, '_client'):
+        provider_url = try_option(getattr, instance._client.base_url, 'host')
     return provider_url.unwrap_or(None)
 
 
 def extract_inference_endpoint(instance):
-    inference_endpoint: Option[str] = try_option(getattr, instance.client._client, 'base_url').map(str)
-    if inference_endpoint.is_none() and "meta" in instance.client.__dict__:
-        inference_endpoint = try_option(getattr, instance.client.meta, 'endpoint_url').map(str)
+    inference_endpoint: Option[str] = None
+    if hasattr(instance,'client'):
+        inference_endpoint: Option[str] = try_option(getattr, instance.client._client, 'base_url').map(str)
+        if inference_endpoint.is_none() and "meta" in instance.client.__dict__:
+            inference_endpoint = try_option(getattr, instance.client.meta, 'endpoint_url').map(str)
+    if hasattr(instance,'_client'):
+        inference_endpoint = try_option(getattr, instance._client, 'base_url').map(str)
 
     return inference_endpoint.unwrap_or(extract_provider_name(instance))
 

monocle_apptrace/instrumentation/metamodel/langchain/methods.py

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