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

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

@@ -23,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
     }
 ]

monocle_apptrace/instrumentation/metamodel/llamaindex/methods.py

@@ -13,7 +13,6 @@ LLAMAINDEX_METHODS = [
         "package": "llama_index.core.indices.base_retriever",
         "object": "BaseRetriever",
         "method": "retrieve",
-        "span_name": "llamaindex.retrieve",
         "wrapper_method": task_wrapper,
         "output_processor": RETRIEVAL
     },
@@ -21,7 +20,6 @@ LLAMAINDEX_METHODS = [
         "package": "llama_index.core.indices.base_retriever",
         "object": "BaseRetriever",
         "method": "aretrieve",
-        "span_name": "llamaindex.retrieve",
         "wrapper_method": atask_wrapper,
         "output_processor": RETRIEVAL
     },
@@ -29,23 +27,18 @@ LLAMAINDEX_METHODS = [
         "package": "llama_index.core.base.base_query_engine",
         "object": "BaseQueryEngine",
         "method": "query",
-        "span_name": "llamaindex.query",
-        "wrapper_method": task_wrapper,
-        "span_type": "workflow"
+        "wrapper_method": task_wrapper
     },
     {
         "package": "llama_index.core.base.base_query_engine",
         "object": "BaseQueryEngine",
         "method": "aquery",
-        "span_name": "llamaindex.query",
-        "wrapper_method": atask_wrapper,
-        "span_type": "workflow"
+        "wrapper_method": atask_wrapper
     },
     {
         "package": "llama_index.core.llms.custom",
         "object": "CustomLLM",
         "method": "chat",
-        "span_name": "llamaindex.llmchat",
         "wrapper_method": task_wrapper,
         "output_processor": INFERENCE
     },
@@ -53,7 +46,6 @@ LLAMAINDEX_METHODS = [
         "package": "llama_index.core.llms.custom",
         "object": "CustomLLM",
         "method": "achat",
-        "span_name": "llamaindex.llmchat",
         "wrapper_method": atask_wrapper,
         "output_processor": INFERENCE,
         
@@ -62,7 +54,6 @@ LLAMAINDEX_METHODS = [
         "package": "llama_index.llms.openai.base",
         "object": "OpenAI",
         "method": "chat",
-        "span_name": "llamaindex.openai",
         "wrapper_method": task_wrapper,
         "output_processor": INFERENCE
     },
@@ -70,7 +61,6 @@ LLAMAINDEX_METHODS = [
         "package": "llama_index.llms.openai.base",
         "object": "OpenAI",
         "method": "achat",
-        "span_name": "llamaindex.openai",
         "wrapper_method": atask_wrapper,
         "output_processor": INFERENCE
     },
@@ -78,7 +68,6 @@ LLAMAINDEX_METHODS = [
         "package": "llama_index.llms.mistralai.base",
         "object": "MistralAI",
         "method": "chat",
-        "span_name": "llamaindex.mistralai",
         "wrapper_method": task_wrapper,
         "output_processor": INFERENCE
     },
@@ -86,7 +75,6 @@ LLAMAINDEX_METHODS = [
         "package": "llama_index.llms.mistralai.base",
         "object": "MistralAI",
         "method": "achat",
-        "span_name": "llamaindex.mistralai",
         "wrapper_method": atask_wrapper,
         "output_processor": INFERENCE
     },
@@ -94,7 +82,6 @@ LLAMAINDEX_METHODS = [
         "package": "llama_index.core.agent",
         "object": "ReActAgent",
         "method": "chat",
-        "span_name": "react.agent",
         "wrapper_method": task_wrapper,
         "output_processor": AGENT
     }

monocle_apptrace/instrumentation/metamodel/openai/_helper.py

@@ -19,6 +19,10 @@ def extract_messages(kwargs):
     """Extract system and user messages"""
     try:
         messages = []
+        if 'instructions' in kwargs:
+            messages.append({'instructions': kwargs.get('instructions', {})})
+        if 'input' in kwargs:
+            messages.append({'input': kwargs.get('input', {})})
         if 'messages' in kwargs and len(kwargs['messages']) >0:
             for msg in kwargs['messages']:
                 if msg.get('content') and msg.get('role'):
@@ -32,6 +36,8 @@ def extract_messages(kwargs):
 
 def extract_assistant_message(response):
     try:
+        if hasattr(response,"output_text") and len(response.output_text):
+            return response.output_text
         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
@@ -85,10 +91,9 @@ def update_span_from_llm_response(response):
             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, "completion_tokens", None)})
-            meta_dict.update({"prompt_tokens": getattr(response.usage, "prompt_tokens", None)})
-            meta_dict.update({"total_tokens": getattr(response.usage, "total_tokens", None)})
+            meta_dict.update({"completion_tokens": getattr(token_usage,"completion_tokens",None) or getattr(token_usage,"output_tokens",None)})
+            meta_dict.update({"prompt_tokens": getattr(token_usage, "prompt_tokens", None) or getattr(token_usage, "input_tokens", None)})
+            meta_dict.update({"total_tokens": getattr(token_usage,"total_tokens")})
     return meta_dict
 
 def extract_vector_input(vector_input: dict):

monocle_apptrace/instrumentation/metamodel/openai/methods.py

@@ -28,7 +28,6 @@ OPENAI_METHODS = [
         "object": "Embeddings",
         "method": "create",
         "wrapper_method": task_wrapper,
-        "span_name": "openai_embeddings",
         "span_handler": "non_framework_handler",
         "output_processor": RETRIEVAL
     },
@@ -37,9 +36,24 @@ OPENAI_METHODS = [
         "object": "AsyncEmbeddings",
         "method": "create",
         "wrapper_method": atask_wrapper,
-        "span_name": "openai_embeddings",
         "span_handler": "non_framework_handler",
         "output_processor": RETRIEVAL
+    },
+    {
+        "package": "openai.resources.responses",
+        "object": "Responses",
+        "method": "create",
+        "wrapper_method": task_wrapper,
+        "span_handler": "non_framework_handler",
+        "output_processor": INFERENCE
+    },
+    {
+        "package": "openai.resources.responses",
+        "object": "AsyncResponses",
+        "method": "create",
+        "wrapper_method": atask_wrapper,
+        "span_handler": "non_framework_handler",
+        "output_processor": INFERENCE
     }
 
 ]

monocle_apptrace/instrumentation/metamodel/requests/_helper.py

@@ -2,6 +2,36 @@ import os
 from  monocle_apptrace.instrumentation.metamodel.requests import allowed_urls
 from opentelemetry.propagate import inject
 from monocle_apptrace.instrumentation.common.span_handler import SpanHandler
+from monocle_apptrace.instrumentation.common.utils import add_monocle_trace_state
+from urllib.parse import urlparse, ParseResult
+
+
+def get_route(kwargs):
+    url:str = kwargs['url']
+    parsed_url:ParseResult = urlparse(url)
+    return f"{parsed_url.netloc}{parsed_url.path}"
+
+def get_method(kwargs) -> str:
+    return kwargs['method'] if 'method' in kwargs else 'GET'
+
+def get_params(kwargs) -> dict:
+    url:str = kwargs['url']
+    parsed_url:ParseResult = urlparse(url)
+    return parsed_url.query
+
+def get_headers(kwargs) -> dict:
+    return kwargs['headers'] if 'headers' in kwargs else {}
+
+def get_body(kwargs) -> dict:
+    body = {}
+    return body
+
+def extract_response(result) -> str:
+    return result.text if hasattr(result, 'text') else str(result)
+
+def extract_status(result) -> str:
+    return f"{result.status_code} {result.reason}"
+
 
 def request_pre_task_processor(kwargs):
     # add traceparent to the request headers in kwargs
@@ -9,6 +39,7 @@ def request_pre_task_processor(kwargs):
         headers = {}
     else:
         headers = kwargs['headers'].copy()
+    add_monocle_trace_state(headers)
     inject(headers)
     kwargs['headers'] = headers
 

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

@@ -0,0 +1,51 @@
+from monocle_apptrace.instrumentation.metamodel.requests import _helper
+REQUEST_HTTP_PROCESSOR = {
+    "type": "http.send",
+    "attributes": [
+        [
+            {
+                "_comment": "request method, request URI",
+                "attribute": "method",
+                "accessor": lambda arguments: _helper.get_method(arguments['kwargs'])
+            },
+            {
+                "_comment": "request method, request URI",
+                "attribute": "URL",
+                "accessor": lambda arguments: _helper.get_route(arguments['kwargs'])
+            }
+
+        ]
+    ],
+    "events": [
+        {"name": "data.input",
+         "attributes": [
+             {
+                 "_comment": "route params",
+                 "attribute": "http.params",
+                 "accessor": lambda arguments: _helper.get_params(arguments['kwargs'])
+             },
+             {
+                 "_comment": "route body",
+                 "attribute": "body",
+                 "accessor": lambda arguments: _helper.get_body(arguments['kwargs'])
+             },
+
+         ]
+         },
+        {
+            "name": "data.output",
+            "attributes": [
+                {
+                    "_comment": "status from HTTP response",
+                    "attribute": "status",
+                    "accessor": lambda arguments: _helper.extract_status(arguments['result'])
+                },
+                {
+                    "_comment": "this is result from LLM",
+                    "attribute": "response",
+                    "accessor": lambda arguments: _helper.extract_response(arguments['result'])
+                }
+            ]
+        }
+    ]
+}

monocle_apptrace/instrumentation/metamodel/requests/methods.py

@@ -1,12 +1,13 @@
 from monocle_apptrace.instrumentation.common.wrapper import task_wrapper
+from monocle_apptrace.instrumentation.metamodel.requests.entities.http import REQUEST_HTTP_PROCESSOR
 
 REQUESTS_METHODS = [
     {
         "package": "requests.sessions",
         "object": "Session",
         "method": "request",
-        "span_name": "http_requests",
         "wrapper_method": task_wrapper,
         "span_handler":"request_handler",
+        "output_processor": REQUEST_HTTP_PROCESSOR
     }
 ]