rasa-pro 3.12.0.dev1__py3-none-any.whl

rasa/tracing/instrumentation/intentless_policy_instrumentation.py

@@ -0,0 +1,144 @@
+import functools
+import json
+import logging
+from typing import Callable, List, Optional, TYPE_CHECKING, Type
+
+from opentelemetry.trace import Tracer
+
+if TYPE_CHECKING:
+    from rasa.core.policies.intentless_policy import IntentlessPolicy
+
+logger = logging.getLogger(__name__)
+
+
+def _instrument_select_response_examples(
+    tracer: Tracer, policy_class: Type["IntentlessPolicy"]
+) -> None:
+    def tracing_select_response_examples_wrapper(fn: Callable) -> Callable:
+        @functools.wraps(fn)
+        def wrapper(
+            self: "IntentlessPolicy",
+            history: str,
+            number_of_samples: int,
+            max_number_of_tokens: int,
+        ) -> List[str]:
+            with tracer.start_as_current_span(
+                f"{self.__class__.__name__}.{fn.__name__}"
+            ) as span:
+                ai_response_examples = fn(
+                    self, history, number_of_samples, max_number_of_tokens
+                )
+                span.set_attributes(
+                    {
+                        "ai_response_examples": json.dumps(ai_response_examples),
+                    }
+                )
+                return ai_response_examples
+
+        return wrapper
+
+    policy_class.select_response_examples = tracing_select_response_examples_wrapper(  # type: ignore[assignment]
+        policy_class.select_response_examples
+    )
+
+    logger.debug(
+        f"Instrumented '{policy_class.__name__}.select_response_examples' method."
+    )
+
+
+def _instrument_select_few_shot_conversations(
+    tracer: Tracer, policy_class: Type["IntentlessPolicy"]
+) -> None:
+    def tracing_select_few_shot_conversations_wrapper(fn: Callable) -> Callable:
+        @functools.wraps(fn)
+        def wrapper(
+            self: "IntentlessPolicy",
+            history: str,
+            number_of_samples: int,
+            max_number_of_tokens: int,
+        ) -> List[str]:
+            with tracer.start_as_current_span(
+                f"{self.__class__.__name__}.{fn.__name__}"
+            ) as span:
+                conversation_samples = fn(
+                    self, history, number_of_samples, max_number_of_tokens
+                )
+                span.set_attributes(
+                    {
+                        "conversation_samples": json.dumps(conversation_samples),
+                    }
+                )
+                return conversation_samples
+
+        return wrapper
+
+    policy_class.select_few_shot_conversations = (  # type: ignore[assignment]
+        tracing_select_few_shot_conversations_wrapper(
+            policy_class.select_few_shot_conversations
+        )
+    )
+
+    logger.debug(
+        f"Instrumented '{policy_class.__name__}.select_few_shot_conversations' method."
+    )
+
+
+def _instrument_extract_ai_responses(
+    tracer: Tracer, policy_class: Type["IntentlessPolicy"]
+) -> None:
+    def tracing_extract_ai_responses_wrapper(fn: Callable) -> Callable:
+        @functools.wraps(fn)
+        def wrapper(
+            self: "IntentlessPolicy", conversation_samples: List[str]
+        ) -> List[str]:
+            with tracer.start_as_current_span(
+                f"{self.__class__.__name__}.{fn.__name__}"
+            ) as span:
+                ai_responses = fn(self, conversation_samples)
+                span.set_attributes(
+                    {
+                        "ai_responses": json.dumps(ai_responses),
+                    }
+                )
+                return ai_responses
+
+        return wrapper
+
+    policy_class.extract_ai_responses = tracing_extract_ai_responses_wrapper(  # type: ignore[assignment]
+        policy_class.extract_ai_responses
+    )
+
+    logger.debug(f"Instrumented '{policy_class.__name__}.extract_ai_responses' method.")
+
+
+def _instrument_generate_answer(
+    tracer: Tracer, policy_class: Type["IntentlessPolicy"]
+) -> None:
+    def tracing_generate_answer_wrapper(fn: Callable) -> Callable:
+        @functools.wraps(fn)
+        async def wrapper(
+            self: "IntentlessPolicy",
+            response_examples: List[str],
+            conversation_samples: List[str],
+            history: str,
+        ) -> Optional[str]:
+            with tracer.start_as_current_span(
+                f"{self.__class__.__name__}.{fn.__name__}"
+            ) as span:
+                llm_response = await fn(
+                    self, response_examples, conversation_samples, history
+                )
+                span.set_attributes(
+                    {
+                        "llm_response": json.dumps(llm_response),
+                    }
+                )
+                return llm_response
+
+        return wrapper
+
+    policy_class.generate_answer = tracing_generate_answer_wrapper(  # type: ignore[assignment]
+        policy_class.generate_answer
+    )
+
+    logger.debug(f"Instrumented '{policy_class.__name__}.generate_answer' method.")

rasa/tracing/instrumentation/metrics.py

@@ -0,0 +1,294 @@
+from typing import Dict, Any
+
+import psutil
+
+from rasa.core.nlg.contextual_response_rephraser import ContextualResponseRephraser
+from rasa.core.policies.enterprise_search_policy import EnterpriseSearchPolicy
+from rasa.core.policies.intentless_policy import IntentlessPolicy
+from rasa.dialogue_understanding.generator import (
+    LLMCommandGenerator,
+    SingleStepLLMCommandGenerator,
+    MultiStepLLMCommandGenerator,
+)
+from rasa.tracing.constants import (
+    LLM_COMMAND_GENERATOR_CPU_USAGE_METRIC_NAME,
+    LLM_COMMAND_GENERATOR_MEMORY_USAGE_METRIC_NAME,
+    LLM_COMMAND_GENERATOR_PROMPT_TOKEN_USAGE_METRIC_NAME,
+    SINGLE_STEP_LLM_COMMAND_GENERATOR_CPU_USAGE_METRIC_NAME,
+    SINGLE_STEP_LLM_COMMAND_GENERATOR_MEMORY_USAGE_METRIC_NAME,
+    SINGLE_STEP_LLM_COMMAND_GENERATOR_PROMPT_TOKEN_USAGE_METRIC_NAME,
+    SINGLE_STEP_LLM_COMMAND_GENERATOR_LLM_RESPONSE_DURATION_METRIC_NAME,
+    MULTI_STEP_LLM_COMMAND_GENERATOR_CPU_USAGE_METRIC_NAME,
+    MULTI_STEP_LLM_COMMAND_GENERATOR_MEMORY_USAGE_METRIC_NAME,
+    MULTI_STEP_LLM_COMMAND_GENERATOR_PROMPT_TOKEN_USAGE_METRIC_NAME,
+    MULTI_STEP_LLM_COMMAND_GENERATOR_LLM_RESPONSE_DURATION_METRIC_NAME,
+    PROMPT_TOKEN_LENGTH_ATTRIBUTE_NAME,
+    LLM_COMMAND_GENERATOR_LLM_RESPONSE_DURATION_METRIC_NAME,
+    ENTERPRISE_SEARCH_POLICY_LLM_RESPONSE_DURATION_METRIC_NAME,
+    INTENTLESS_POLICY_LLM_RESPONSE_DURATION_METRIC_NAME,
+    CONTEXTUAL_RESPONSE_REPHRASER_LLM_RESPONSE_DURATION_METRIC_NAME,
+    RASA_CLIENT_REQUEST_BODY_SIZE_METRIC_NAME,
+    RASA_CLIENT_REQUEST_DURATION_METRIC_NAME,
+    REQUEST_BODY_SIZE_IN_BYTES_ATTRIBUTE_NAME,
+)
+from rasa.tracing.metric_instrument_provider import MetricInstrumentProvider
+from rasa.utils.endpoints import EndpointConfig
+
+
+def record_llm_based_command_generator_cpu_usage(
+    metric_instrument_provider: MetricInstrumentProvider,
+    metric_name: str,
+) -> None:
+    """Record CPU usage as a percentage.
+
+    The recording is done by the opentelemetry.metrics.Histogram instrument.
+    This instrument is registered to the MetricInstrumentProvider internal singleton.
+
+    :param metric_instrument_provider: The MetricInstrumentProvider instance
+    :param metric_name: The name of the metric instrument
+    :return: None
+    """
+    metric_instrument = metric_instrument_provider.get_instrument(metric_name)
+    if not metric_instrument:
+        return None
+
+    cpu_usage = psutil.cpu_percent()
+    metric_instrument.record(amount=cpu_usage)
+
+
+def record_llm_based_command_generator_memory_usage(
+    metric_instrument_provider: MetricInstrumentProvider,
+    metric_name: str,
+) -> None:
+    """Record memory usage as a percentage.
+
+    The recording is done by the opentelemetry.metrics.Histogram instrument.
+    This instrument is registered to the MetricInstrumentProvider internal singleton.
+
+    :param metric_instrument_provider: The MetricInstrumentProvider instance
+    :param metric_name: The name of the metric instrument
+    :return: None
+    """
+    metric_instrument = metric_instrument_provider.get_instrument(metric_name)
+    if not metric_instrument:
+        return None
+
+    memory_usage = psutil.virtual_memory().percent
+    metric_instrument.record(amount=memory_usage)
+
+
+def record_llm_based_command_generator_prompt_token(
+    metric_instrument_provider: MetricInstrumentProvider,
+    attributes: Dict[str, Any],
+    metric_name: str,
+) -> None:
+    """
+    Record prompt token length.
+
+    The recording is done by the opentelemetry.metrics.Histogram instrument.
+    This instrument is registered to the MetricInstrumentProvider internal singleton.
+
+    :param metric_instrument_provider: The MetricInstrumentProvider instance
+    :param attributes: Extracted tracing attributes
+    :param metric_name: The name of the metric instrument
+    :return: None
+    """
+    if PROMPT_TOKEN_LENGTH_ATTRIBUTE_NAME not in attributes:
+        return None
+
+    metric_instrument = metric_instrument_provider.get_instrument(metric_name)
+    if not metric_instrument:
+        return None
+
+    prompt_tokens_len = attributes[PROMPT_TOKEN_LENGTH_ATTRIBUTE_NAME]
+
+    try:
+        prompt_tokens_len = int(prompt_tokens_len)
+    except ValueError:
+        return None
+
+    metric_instrument.record(
+        amount=prompt_tokens_len,
+    )
+
+
+def record_llm_command_generator_metrics(attributes: Dict[str, Any]) -> None:
+    """
+    Record measurements for LLMCommandGenerator specific metrics.
+
+    The recording is done by the opentelemetry.metrics.Histogram instruments.
+    These instruments are registered to the MetricInstrumentProvider internal singleton.
+
+    :param attributes: Extracted tracing attributes
+    :return: None
+    """
+    instrument_provider = MetricInstrumentProvider()
+
+    if not instrument_provider.instruments:
+        return None
+
+    record_llm_based_command_generator_cpu_usage(
+        instrument_provider, LLM_COMMAND_GENERATOR_CPU_USAGE_METRIC_NAME
+    )
+    record_llm_based_command_generator_memory_usage(
+        instrument_provider, LLM_COMMAND_GENERATOR_MEMORY_USAGE_METRIC_NAME
+    )
+    record_llm_based_command_generator_prompt_token(
+        instrument_provider,
+        attributes,
+        LLM_COMMAND_GENERATOR_PROMPT_TOKEN_USAGE_METRIC_NAME,
+    )
+
+
+def record_single_step_llm_command_generator_metrics(
+    attributes: Dict[str, Any],
+) -> None:
+    """
+    Record measurements for SingleStepLLMCommandGenerator specific metrics.
+
+    The recording is done by the opentelemetry.metrics.Histogram instruments.
+    These instruments are registered to the MetricInstrumentProvider internal singleton.
+
+    :param attributes: Extracted tracing attributes
+    :return: None
+    """
+    instrument_provider = MetricInstrumentProvider()
+
+    if not instrument_provider.instruments:
+        return None
+
+    record_llm_based_command_generator_cpu_usage(
+        instrument_provider, SINGLE_STEP_LLM_COMMAND_GENERATOR_CPU_USAGE_METRIC_NAME
+    )
+    record_llm_based_command_generator_memory_usage(
+        instrument_provider, SINGLE_STEP_LLM_COMMAND_GENERATOR_MEMORY_USAGE_METRIC_NAME
+    )
+    record_llm_based_command_generator_prompt_token(
+        instrument_provider,
+        attributes,
+        SINGLE_STEP_LLM_COMMAND_GENERATOR_PROMPT_TOKEN_USAGE_METRIC_NAME,
+    )
+
+
+def record_multi_step_llm_command_generator_metrics(attributes: Dict[str, Any]) -> None:
+    """
+    Record measurements for MultiStepLLMCommandGenerator specific metrics.
+
+    The recording is done by the opentelemetry.metrics.Histogram instruments.
+    These instruments are registered to the MetricInstrumentProvider internal singleton.
+
+    :param attributes: Extracted tracing attributes
+    :return: None
+    """
+    instrument_provider = MetricInstrumentProvider()
+
+    if not instrument_provider.instruments:
+        return None
+
+    record_llm_based_command_generator_cpu_usage(
+        instrument_provider, MULTI_STEP_LLM_COMMAND_GENERATOR_CPU_USAGE_METRIC_NAME
+    )
+    record_llm_based_command_generator_memory_usage(
+        instrument_provider, MULTI_STEP_LLM_COMMAND_GENERATOR_MEMORY_USAGE_METRIC_NAME
+    )
+    record_llm_based_command_generator_prompt_token(
+        instrument_provider,
+        attributes,
+        MULTI_STEP_LLM_COMMAND_GENERATOR_PROMPT_TOKEN_USAGE_METRIC_NAME,
+    )
+
+
+def record_callable_duration_metrics(
+    self: Any, start_time: int, end_time: int, **kwargs: Any
+) -> None:
+    """
+    Record duration of instrumented method calls invoked for the following components:
+    - LLMCommandGenerator
+    - SingleStepLLMCommandGenerator
+    - MultiStepLLMCommandGenerator
+    - EnterpriseSearchPolicy
+    - IntentlessPolicy
+    - ContextualResponseRephraser
+    - EndpointConfig
+
+    :param self: The instance on which the instrumented method is called on.
+    :param start_time: Start time measured by time.perf_counter_ns()
+    before the method is called.
+    :param end_time: End time measured by time.perf_counter_ns()
+    after the method is called.
+    :return: None
+    """
+    instrument_provider = MetricInstrumentProvider()
+    if not instrument_provider.instruments:
+        return None
+
+    metric_instrument = None
+    attributes = {}
+
+    if type(self) == LLMCommandGenerator:
+        metric_instrument = instrument_provider.get_instrument(
+            LLM_COMMAND_GENERATOR_LLM_RESPONSE_DURATION_METRIC_NAME
+        )
+
+    if type(self) == SingleStepLLMCommandGenerator:
+        metric_instrument = instrument_provider.get_instrument(
+            SINGLE_STEP_LLM_COMMAND_GENERATOR_LLM_RESPONSE_DURATION_METRIC_NAME
+        )
+
+    if type(self) == MultiStepLLMCommandGenerator:
+        metric_instrument = instrument_provider.get_instrument(
+            MULTI_STEP_LLM_COMMAND_GENERATOR_LLM_RESPONSE_DURATION_METRIC_NAME
+        )
+
+    if isinstance(self, EnterpriseSearchPolicy):
+        metric_instrument = instrument_provider.get_instrument(
+            ENTERPRISE_SEARCH_POLICY_LLM_RESPONSE_DURATION_METRIC_NAME
+        )
+
+    if isinstance(self, IntentlessPolicy):
+        metric_instrument = instrument_provider.get_instrument(
+            INTENTLESS_POLICY_LLM_RESPONSE_DURATION_METRIC_NAME
+        )
+
+    if isinstance(self, ContextualResponseRephraser):
+        metric_instrument = instrument_provider.get_instrument(
+            CONTEXTUAL_RESPONSE_REPHRASER_LLM_RESPONSE_DURATION_METRIC_NAME
+        )
+
+    if isinstance(self, EndpointConfig):
+        metric_instrument = instrument_provider.get_instrument(
+            RASA_CLIENT_REQUEST_DURATION_METRIC_NAME
+        )
+        attributes = {"url": kwargs.get("url")}
+
+    if not metric_instrument:
+        return None
+
+    timedelta_ms = (end_time - start_time) / 1000000
+    metric_instrument.record(amount=timedelta_ms, attributes=attributes)
+
+
+def record_request_size_in_bytes(attributes: Dict[str, Any]) -> None:
+    """
+    Record endpoint request size in bytes for EndpointConfig class.
+
+    The recording is done by the opentelemetry.metrics.Histogram instruments.
+    These instruments are registered to the MetricInstrumentProvider internal singleton.
+
+    :param attributes: Extracted tracing attributes
+    :return: None
+    """
+
+    metric_instrument_provider = MetricInstrumentProvider()
+
+    if not metric_instrument_provider.instruments:
+        return None
+
+    metric_instrument = metric_instrument_provider.get_instrument(
+        RASA_CLIENT_REQUEST_BODY_SIZE_METRIC_NAME
+    )
+    if not metric_instrument:
+        return None
+
+    request_body_size = attributes.pop(REQUEST_BODY_SIZE_IN_BYTES_ATTRIBUTE_NAME, 0)
+    metric_instrument.record(amount=request_body_size, attributes=attributes)

rasa/tracing/metric_instrument_provider.py

@@ -0,0 +1,205 @@
+from typing import ClassVar, Dict, Any
+
+from opentelemetry.metrics import get_meter_provider
+from opentelemetry.sdk.metrics import Meter
+
+from rasa.utils.singleton import Singleton
+from rasa.tracing.constants import (
+    LLM_COMMAND_GENERATOR_CPU_USAGE_METRIC_NAME,
+    LLM_COMMAND_GENERATOR_MEMORY_USAGE_METRIC_NAME,
+    LLM_COMMAND_GENERATOR_PROMPT_TOKEN_USAGE_METRIC_NAME,
+    LLM_COMMAND_GENERATOR_LLM_RESPONSE_DURATION_METRIC_NAME,
+    LLM_BASED_COMMAND_GENERATOR_CPU_MEMORY_USAGE_UNIT_NAME,
+    SINGLE_STEP_LLM_COMMAND_GENERATOR_CPU_USAGE_METRIC_NAME,
+    SINGLE_STEP_LLM_COMMAND_GENERATOR_MEMORY_USAGE_METRIC_NAME,
+    SINGLE_STEP_LLM_COMMAND_GENERATOR_PROMPT_TOKEN_USAGE_METRIC_NAME,
+    SINGLE_STEP_LLM_COMMAND_GENERATOR_LLM_RESPONSE_DURATION_METRIC_NAME,
+    MULTI_STEP_LLM_COMMAND_GENERATOR_CPU_USAGE_METRIC_NAME,
+    MULTI_STEP_LLM_COMMAND_GENERATOR_MEMORY_USAGE_METRIC_NAME,
+    MULTI_STEP_LLM_COMMAND_GENERATOR_PROMPT_TOKEN_USAGE_METRIC_NAME,
+    MULTI_STEP_LLM_COMMAND_GENERATOR_LLM_RESPONSE_DURATION_METRIC_NAME,
+    DURATION_UNIT_NAME,
+    ENTERPRISE_SEARCH_POLICY_LLM_RESPONSE_DURATION_METRIC_NAME,
+    INTENTLESS_POLICY_LLM_RESPONSE_DURATION_METRIC_NAME,
+    CONTEXTUAL_RESPONSE_REPHRASER_LLM_RESPONSE_DURATION_METRIC_NAME,
+    RASA_CLIENT_REQUEST_DURATION_METRIC_NAME,
+    RASA_CLIENT_REQUEST_BODY_SIZE_METRIC_NAME,
+)
+
+
+class MetricInstrumentProvider(metaclass=Singleton):
+    """Singleton provider class of metric instruments."""
+
+    instruments: ClassVar[Dict[str, Any]] = {}
+
+    def register_instruments(self) -> None:
+        """Update instruments class attribute.
+
+        The registered instruments are subclasses of the
+        opentelemetry.metrics._internal.instrument.Instrument interface.
+        """
+        meter = get_meter_provider().get_meter(__name__)
+
+        instruments = {
+            **self._create_llm_command_generator_instruments(meter),
+            **self._create_single_step_llm_command_generator_instruments(meter),
+            **self._create_multi_step_llm_command_generator_instruments(meter),
+            **self._create_llm_response_duration_instruments(meter),
+            **self._create_client_request_instruments(meter),
+        }
+
+        self.instruments.update(instruments)
+
+    def get_instrument(self, name: str) -> Any:
+        """Get the instrument mapped to the provided name."""
+        return self.instruments.get(name)
+
+    @staticmethod
+    def _create_llm_command_generator_instruments(meter: Meter) -> Dict[str, Any]:
+        llm_command_generator_cpu_usage = meter.create_histogram(
+            name=LLM_COMMAND_GENERATOR_CPU_USAGE_METRIC_NAME,
+            description="CPU percentage for LLMCommandGenerator",
+            unit=LLM_BASED_COMMAND_GENERATOR_CPU_MEMORY_USAGE_UNIT_NAME,
+        )
+
+        llm_command_generator_memory_usage = meter.create_histogram(
+            name=LLM_COMMAND_GENERATOR_MEMORY_USAGE_METRIC_NAME,
+            description="RAM memory usage for LLMCommandGenerator",
+            unit=LLM_BASED_COMMAND_GENERATOR_CPU_MEMORY_USAGE_UNIT_NAME,
+        )
+
+        llm_command_generator_prompt_token_usage = meter.create_histogram(
+            name=LLM_COMMAND_GENERATOR_PROMPT_TOKEN_USAGE_METRIC_NAME,
+            description="LLMCommandGenerator prompt token length",
+            unit="1",
+        )
+
+        llm_response_duration_llm_command_generator = meter.create_histogram(
+            name=LLM_COMMAND_GENERATOR_LLM_RESPONSE_DURATION_METRIC_NAME,
+            description="The duration of LLMCommandGenerator's LLM call",
+            unit=DURATION_UNIT_NAME,
+        )
+
+        return {
+            LLM_COMMAND_GENERATOR_CPU_USAGE_METRIC_NAME: llm_command_generator_cpu_usage,  # noqa: E501
+            LLM_COMMAND_GENERATOR_MEMORY_USAGE_METRIC_NAME: llm_command_generator_memory_usage,  # noqa: E501
+            LLM_COMMAND_GENERATOR_PROMPT_TOKEN_USAGE_METRIC_NAME: llm_command_generator_prompt_token_usage,  # noqa: E501
+            LLM_COMMAND_GENERATOR_LLM_RESPONSE_DURATION_METRIC_NAME: llm_response_duration_llm_command_generator,  # noqa: E501
+        }
+
+    @staticmethod
+    def _create_single_step_llm_command_generator_instruments(
+        meter: Meter,
+    ) -> Dict[str, Any]:
+        single_step_llm_command_generator_cpu_usage = meter.create_histogram(
+            name=SINGLE_STEP_LLM_COMMAND_GENERATOR_CPU_USAGE_METRIC_NAME,
+            description="CPU percentage for SingleStepLLMCommandGenerator",
+            unit=LLM_BASED_COMMAND_GENERATOR_CPU_MEMORY_USAGE_UNIT_NAME,
+        )
+
+        single_step_llm_command_generator_memory_usage = meter.create_histogram(
+            name=SINGLE_STEP_LLM_COMMAND_GENERATOR_MEMORY_USAGE_METRIC_NAME,
+            description="RAM memory usage for SingleStepLLMCommandGenerator",
+            unit=LLM_BASED_COMMAND_GENERATOR_CPU_MEMORY_USAGE_UNIT_NAME,
+        )
+
+        single_step_llm_command_generator_prompt_token_usage = meter.create_histogram(
+            name=SINGLE_STEP_LLM_COMMAND_GENERATOR_PROMPT_TOKEN_USAGE_METRIC_NAME,
+            description="SingleStepLLMCommandGenerator prompt token length",
+            unit="1",
+        )
+
+        single_step_llm_response_duration_llm_command_generator = meter.create_histogram(  # noqa: E501
+            name=SINGLE_STEP_LLM_COMMAND_GENERATOR_LLM_RESPONSE_DURATION_METRIC_NAME,
+            description="The duration of SingleStepLLMCommandGenerator's LLM call",
+            unit=DURATION_UNIT_NAME,
+        )
+
+        return {
+            SINGLE_STEP_LLM_COMMAND_GENERATOR_CPU_USAGE_METRIC_NAME: single_step_llm_command_generator_cpu_usage,  # noqa: E501
+            SINGLE_STEP_LLM_COMMAND_GENERATOR_MEMORY_USAGE_METRIC_NAME: single_step_llm_command_generator_memory_usage,  # noqa: E501
+            SINGLE_STEP_LLM_COMMAND_GENERATOR_PROMPT_TOKEN_USAGE_METRIC_NAME: single_step_llm_command_generator_prompt_token_usage,  # noqa: E501
+            SINGLE_STEP_LLM_COMMAND_GENERATOR_LLM_RESPONSE_DURATION_METRIC_NAME: single_step_llm_response_duration_llm_command_generator,  # noqa: E501
+        }
+
+    @staticmethod
+    def _create_multi_step_llm_command_generator_instruments(
+        meter: Meter,
+    ) -> Dict[str, Any]:
+        multi_step_llm_command_generator_cpu_usage = meter.create_histogram(
+            name=MULTI_STEP_LLM_COMMAND_GENERATOR_CPU_USAGE_METRIC_NAME,
+            description="CPU percentage for MultiStepLLMCommandGenerator",
+            unit=LLM_BASED_COMMAND_GENERATOR_CPU_MEMORY_USAGE_UNIT_NAME,
+        )
+
+        multi_step_llm_command_generator_memory_usage = meter.create_histogram(
+            name=MULTI_STEP_LLM_COMMAND_GENERATOR_MEMORY_USAGE_METRIC_NAME,
+            description="RAM memory usage for MultiStepLLMCommandGenerator",
+            unit=LLM_BASED_COMMAND_GENERATOR_CPU_MEMORY_USAGE_UNIT_NAME,
+        )
+
+        multi_step_llm_command_generator_prompt_token_usage = meter.create_histogram(
+            name=MULTI_STEP_LLM_COMMAND_GENERATOR_PROMPT_TOKEN_USAGE_METRIC_NAME,
+            description="MultiStepLLMCommandGenerator prompt token length",
+            unit="1",
+        )
+
+        multi_step_llm_response_duration_llm_command_generator = meter.create_histogram(
+            name=MULTI_STEP_LLM_COMMAND_GENERATOR_LLM_RESPONSE_DURATION_METRIC_NAME,
+            description="The duration of MultiStepLLMCommandGenerator's LLM call",
+            unit=DURATION_UNIT_NAME,
+        )
+
+        return {
+            MULTI_STEP_LLM_COMMAND_GENERATOR_CPU_USAGE_METRIC_NAME: multi_step_llm_command_generator_cpu_usage,  # noqa: E501
+            MULTI_STEP_LLM_COMMAND_GENERATOR_MEMORY_USAGE_METRIC_NAME: multi_step_llm_command_generator_memory_usage,  # noqa: E501
+            MULTI_STEP_LLM_COMMAND_GENERATOR_PROMPT_TOKEN_USAGE_METRIC_NAME: multi_step_llm_command_generator_prompt_token_usage,  # noqa: E501
+            MULTI_STEP_LLM_COMMAND_GENERATOR_LLM_RESPONSE_DURATION_METRIC_NAME: multi_step_llm_response_duration_llm_command_generator,  # noqa: E501
+        }
+
+    @staticmethod
+    def _create_llm_response_duration_instruments(meter: Meter) -> Dict[str, Any]:
+        llm_response_duration_enterprise_search = meter.create_histogram(
+            name=ENTERPRISE_SEARCH_POLICY_LLM_RESPONSE_DURATION_METRIC_NAME,
+            description="The duration of EnterpriseSearchPolicy's LLM call",
+            unit=DURATION_UNIT_NAME,
+        )
+
+        llm_response_duration_intentless = meter.create_histogram(
+            name=INTENTLESS_POLICY_LLM_RESPONSE_DURATION_METRIC_NAME,
+            description="The duration of IntentlessPolicy's LLM call",
+            unit=DURATION_UNIT_NAME,
+        )
+
+        llm_response_duration_contextual_nlg = meter.create_histogram(
+            name=CONTEXTUAL_RESPONSE_REPHRASER_LLM_RESPONSE_DURATION_METRIC_NAME,
+            description="The duration of ContextualResponseRephraser's LLM call",
+            unit=DURATION_UNIT_NAME,
+        )
+
+        return {
+            ENTERPRISE_SEARCH_POLICY_LLM_RESPONSE_DURATION_METRIC_NAME: llm_response_duration_enterprise_search,  # noqa: E501
+            INTENTLESS_POLICY_LLM_RESPONSE_DURATION_METRIC_NAME: llm_response_duration_intentless,  # noqa: E501
+            CONTEXTUAL_RESPONSE_REPHRASER_LLM_RESPONSE_DURATION_METRIC_NAME: llm_response_duration_contextual_nlg,  # noqa: E501
+        }
+
+    @staticmethod
+    def _create_client_request_instruments(
+        meter: Meter,
+    ) -> Dict[str, Any]:
+        client_request_duration = meter.create_histogram(
+            name=RASA_CLIENT_REQUEST_DURATION_METRIC_NAME,
+            description="The duration of the rasa client request",
+            unit=DURATION_UNIT_NAME,
+        )
+
+        client_request_body_size = meter.create_histogram(
+            name=RASA_CLIENT_REQUEST_BODY_SIZE_METRIC_NAME,
+            description="The rasa client request's body size",
+            unit="byte",
+        )
+
+        return {
+            RASA_CLIENT_REQUEST_DURATION_METRIC_NAME: client_request_duration,
+            RASA_CLIENT_REQUEST_BODY_SIZE_METRIC_NAME: client_request_body_size,
+        }