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

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
 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,21 @@ class WrapperMethod:
             span_name: str = None,
             output_processor : str = None,
             wrapper_method = task_wrapper,
-            span_handler = 'default'
+            span_handler = 'default',
+            scope_name: 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.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 +50,19 @@ 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
         }
         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()
+}

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

@@ -19,7 +19,13 @@ def extract_messages(args):
     """Extract system and user messages"""
     try:
         messages = []
+        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/langgraph/_helper.py

@@ -0,0 +1,48 @@
+from monocle_apptrace.instrumentation.common.utils import resolve_from_alias
+import logging
+logger = logging.getLogger(__name__)
+
+def handle_openai_response(response):
+    try:
+        if 'messages' in response:
+            output = response["messages"][-1]
+            return str(output.content)
+    except Exception as e:
+        logger.warning("Warning: Error occurred in handle_openai_response: %s", str(e))
+        return ""
+
+def agent_instructions(arguments):
+    if callable(arguments['kwargs']['agent'].instructions):
+        return arguments['kwargs']['agent'].instructions(arguments['kwargs']['context_variables'])
+    else:
+        return arguments['kwargs']['agent'].instructions
+
+def extract_input(arguments):
+    history = arguments['result']['messages']
+    for message in history:
+        if hasattr(message, 'content') and hasattr(message, 'type') and message.type == "human":  # Check if the message is a HumanMessage
+            return message.content
+
+def get_inference_endpoint(arguments):
+    inference_endpoint = resolve_from_alias(arguments['instance'].client.__dict__, ['azure_endpoint', 'api_base', '_base_url'])
+    return str(inference_endpoint)
+
+def tools(instance):
+    if hasattr(instance,'nodes') and ('tools' in instance.nodes):
+        tools= instance.nodes['tools']
+        if hasattr(tools,'bound') and hasattr(tools.bound,'tools_by_name'):
+            return list(tools.bound.tools_by_name.keys())
+
+
+def update_span_from_llm_response(response):
+    meta_dict = {}
+    token_usage = None
+    if response is not None and "messages" in response:
+        token = response["messages"][-1]
+        if token.response_metadata is not None:
+            token_usage = token.response_metadata["token_usage"]
+        if token_usage is not None:
+            meta_dict.update({"completion_tokens": token_usage.get('completion_tokens')})
+            meta_dict.update({"prompt_tokens": token_usage.get('prompt_tokens')})
+            meta_dict.update({"total_tokens": token_usage.get('total_tokens')})
+    return meta_dict

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

@@ -0,0 +1,56 @@
+from monocle_apptrace.instrumentation.metamodel.langgraph import (
+    _helper
+)
+INFERENCE = {
+      "type": "agent",
+      "attributes": [
+        [
+              {
+                "_comment": "agent type",
+                "attribute": "type",
+                "accessor": lambda arguments:'agent.oai'
+              },
+              {
+                "_comment": "name of the agent",
+                "attribute": "name",
+                "accessor": lambda arguments:arguments['instance'].name
+              },
+              {
+                "_comment": "agent tools",
+                "attribute": "tools",
+                "accessor": lambda arguments: _helper.tools(arguments['instance'])
+              }
+        ]
+      ],
+      "events": [
+        {
+          "name":"data.input",
+          "attributes": [
+            {
+                "_comment": "this is LLM input",
+                "attribute": "query",
+                "accessor": lambda arguments: _helper.extract_input(arguments)
+            }
+          ]
+        },
+        {
+          "name":"data.output",
+          "attributes": [
+            {
+                "_comment": "this is response from LLM",
+                "attribute": "response",
+                "accessor": lambda arguments: _helper.handle_openai_response(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/langgraph/methods.py

@@ -0,0 +1,14 @@
+from monocle_apptrace.instrumentation.common.wrapper import task_wrapper
+from monocle_apptrace.instrumentation.metamodel.langgraph.entities.inference import (
+    INFERENCE,
+)
+LANGGRAPH_METHODS = [
+    {
+        "package": "langgraph.graph.state",
+         "object": "CompiledStateGraph",
+         "method": "invoke",
+         "span_name": "langgraph.graph.invoke",
+         "wrapper_method": task_wrapper,
+         "output_processor": INFERENCE
+    }
+]

monocle_apptrace/instrumentation/metamodel/llamaindex/_helper.py

@@ -16,34 +16,50 @@ from monocle_apptrace.instrumentation.common.utils import (
 logger = logging.getLogger(__name__)
 
 
+def extract_tools(instance):
+    tools = []
+    if not hasattr(instance, 'state') or not hasattr(instance.state, 'task_dict'):
+        return []
+    try:
+        data = next(iter(instance.state.task_dict.values())).task
+    except (AttributeError, StopIteration):
+        return []
+
+    if hasattr(data,'extra_state') and 'sources' in data.extra_state:
+        for tool_output in data.extra_state['sources']:
+            tool_name = tool_output.tool_name
+            if tool_name:
+                tools.append(tool_name)
+    return tools
+
+
 def extract_messages(args):
     """Extract system and user messages"""
     try:
         messages = []
-        if args and isinstance(args, (list, tuple)) and args[0]:
+
+        def process_message(msg):
+            """Processes a single message and extracts relevant information."""
+            if hasattr(msg, 'content') and hasattr(msg, 'role'):
+                role = getattr(msg.role, 'value', msg.role)
+                content = msg.content if role == "system" else extract_query_from_content(msg.content)
+                messages.append({role: content})
+
+        if isinstance(args, (list, tuple)) and args:
             for msg in args[0]:
-                if hasattr(msg, 'content') and hasattr(msg, 'role'):
-                    role = getattr(msg.role, 'value', msg.role)
-                    if role == "system":
-                        messages.append({role: msg.content})
-                    elif role in ["user", "human"]:
-                        user_message = extract_query_from_content(msg.content)
-                        messages.append({role: user_message})
-        if args and isinstance(args, dict):
+                process_message(msg)
+        if isinstance(args, dict):
             for msg in args.get("messages", []):
-                if hasattr(msg, 'content') and hasattr(msg, 'role'):
-                    role = getattr(msg.role, 'value', msg.role)
-                    if role == "system":
-                        messages.append({role: msg.content})
-                    elif role in ["user", "human"]:
-                        user_message = msg.content
-                        messages.append({role: user_message})
+                process_message(msg)
+        if args and isinstance(args, tuple):
+            messages.append(args[0])
+
         return [str(message) for message in messages]
+
     except Exception as e:
-        logger.warning("Warning: Error occurred in extract_messages: %s", str(e))
+        logger.warning("Error in extract_messages: %s", str(e))
         return []
 
-
 def extract_assistant_message(response):
     try:
         if isinstance(response, str):
@@ -52,6 +68,8 @@ def extract_assistant_message(response):
             return [response.content]
         if hasattr(response, "message") and hasattr(response.message, "content"):
             return [response.message.content]
+        if hasattr(response,"response") and isinstance(response.response, str):
+            return [response.response]
     except Exception as e:
         logger.warning("Warning: Error occurred in extract_assistant_message: %s", str(e))
         return []
@@ -63,7 +81,7 @@ def extract_query_from_content(content):
         answer_prefix = "Answer:"
         query_start = content.find(query_prefix)
         if query_start == -1:
-            return None
+            return content
 
         query_start += len(query_prefix)
         answer_start = content.find(answer_prefix, query_start)

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

@@ -0,0 +1,47 @@
+from monocle_apptrace.instrumentation.metamodel.llamaindex import (
+    _helper,
+)
+
+AGENT = {
+    "type": "agent",
+    "attributes": [
+        [
+            {
+                "_comment": "Agent name, type and Tools.",
+                "attribute": "name",
+                "accessor": lambda arguments: arguments['instance'].__class__.__name__
+            },
+            {
+                "attribute": "type",
+                "accessor": lambda arguments: 'Agent.oai'
+            },
+            {
+                "attribute": "tools",
+                "accessor": lambda arguments: _helper.extract_tools(arguments['instance'])
+            }
+        ]
+
+    ],
+    "events": [
+        {"name": "data.input",
+         "attributes": [
+
+             {
+                 "_comment": "this is instruction and user query to LLM",
+                 "attribute": "input",
+                 "accessor": lambda arguments: _helper.extract_messages(arguments['args'])
+             }
+         ]
+         },
+        {
+            "name": "data.output",
+            "attributes": [
+                {
+                    "_comment": "this is response from LLM",
+                    "attribute": "response",
+                    "accessor": lambda arguments: _helper.extract_assistant_message(arguments['result'])
+                }
+            ]
+        }
+    ]
+}

monocle_apptrace/instrumentation/metamodel/llamaindex/methods.py

@@ -2,6 +2,7 @@ from monocle_apptrace.instrumentation.common.wrapper import atask_wrapper, task_
 from monocle_apptrace.instrumentation.metamodel.llamaindex.entities.inference import (
     INFERENCE,
 )
+from monocle_apptrace.instrumentation.metamodel.llamaindex.entities.agent import AGENT
 from monocle_apptrace.instrumentation.metamodel.llamaindex.entities.retrieval import (
     RETRIEVAL,
 )
@@ -85,5 +86,13 @@ LLAMAINDEX_METHODS = [
         "span_name": "llamaindex.mistralai",
         "wrapper_method": atask_wrapper,
         "output_processor": INFERENCE
+    },
+    {
+        "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

@@ -0,0 +1,88 @@
+"""
+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_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 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:
+        logger.warning("Warning: Error occurred in extract_assistant_message: %s", str(e))
+        return None
+
+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 resolve_from_alias(my_map, alias):
+    """Find a alias that is not none from list of aliases"""
+
+    for i in alias:
+        if i in my_map.keys():
+            return my_map[i]
+    return None
+
+
+def update_input_span_events(args):
+    return args[0] if len(args) > 0 else ""
+
+
+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
+
+
+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, "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)})
+    return meta_dict
+

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

@@ -0,0 +1,71 @@
+from monocle_apptrace.instrumentation.metamodel.openai import (
+    _helper,
+)
+from monocle_apptrace.instrumentation.common.utils import resolve_from_alias
+
+INFERENCE = {
+    "type": "inference",
+    "attributes": [
+        [
+            {
+                "_comment": "provider type ,name , deployment , inference_endpoint",
+                "attribute": "type",
+                "accessor": lambda arguments: 'inference.azure_oai'
+            },
+            {
+                "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'])
+                }
+            ]
+        }
+    ]
+}