rasa-pro 3.8.18__py3-none-any.whl → 3.9.15__py3-none-any.whl

rasa/telemetry.py

@@ -32,6 +32,7 @@ from rasa.constants import (
     CONFIG_TELEMETRY_ENABLED,
     CONFIG_TELEMETRY_ID,
 )
+from rasa.shared.constants import PROMPT_CONFIG_KEY, PROMPT_TEMPLATE_CONFIG_KEY
 from rasa.engine.storage.local_model_storage import LocalModelStorage
 from rasa.shared.constants import DOCS_URL_TELEMETRY, UTTER_ASK_PREFIX
 from rasa.shared.core.flows import Flow
@@ -43,7 +44,6 @@ from rasa.shared.core.flows.steps import (
 )
 from rasa.shared.exceptions import RasaException
 from rasa.utils import common as rasa_utils
-from rasa.utils.licensing import property_of_active_license, get_license_hash
 
 if typing.TYPE_CHECKING:
     from rasa.core.brokers.broker import EventBroker
@@ -53,7 +53,7 @@ if typing.TYPE_CHECKING:
     from rasa.shared.nlu.training_data.training_data import TrainingData
     from rasa.shared.importers.importer import TrainingDataImporter
     from rasa.core.utils import AvailableEndpoints
-    from rasa.e2e_test.e2e_test_case import TestCase, Fixture
+    from rasa.e2e_test.e2e_test_case import TestCase, Fixture, Metadata
 
 logger = logging.getLogger(__name__)
 
@@ -93,7 +93,8 @@ CI_ENVIRONMENT_TELL = [
 ]
 
 # If updating or creating a new event, remember to update
-# https://rasa.com/docs/rasa/telemetry
+# https://rasa.com/docs/rasa-pro/telemetry/telemetry OR
+# https://rasa.com/docs/rasa-pro/telemetry/reference
 TRAINING_STARTED_EVENT = "Training Started"
 TRAINING_COMPLETED_EVENT = "Training Completed"
 TELEMETRY_DISABLED_EVENT = "Telemetry Disabled"
@@ -124,6 +125,18 @@ TELEMETRY_INTENTLESS_POLICY_PREDICT_EVENT = "Intentless Policy Predicted"
 TELEMETRY_LLM_INTENT_PREDICT_EVENT = "LLM Intent Predicted"
 TELEMETRY_LLM_INTENT_TRAIN_COMPLETED_EVENT = "LLM Intent Training Completed"
 TELEMETRY_E2E_TEST_RUN_STARTED_EVENT = "E2E Test Run Started"
+TELEMETRY_ENTERPRISE_SEARCH_POLICY_TRAINING_STARTED_EVENT = (
+    "Enterprise Search Policy Training Started"
+)
+TELEMETRY_ENTERPRISE_SEARCH_POLICY_TRAINING_COMPLETED_EVENT = (
+    "Enterprise Search Policy Training Completed"
+)
+TELEMETRY_ENTERPRISE_SEARCH_POLICY_PREDICT_EVENT = "Enterprise Search Policy Predicted"
+
+# licensing events
+TELEMETRY_CONVERSATION_COUNT = "Conversation Count"
+TELEMETRY_CONVERSATION_SOFT_LIMIT_REACHED = "Conversation Soft Limit Reached"
+TELEMETRY_CONVERSATION_HARD_LIMIT_REACHED = "Conversation Hard Limit Reached"
 
 # used to calculate the context on the first call and cache it afterwards
 TELEMETRY_CONTEXT = None
@@ -147,6 +160,12 @@ NUM_CALL_STEPS = "num_call_steps"
 NUM_SHARED_SLOTS_BETWEEN_FLOWS = "num_shared_slots_between_flows"
 LLM_COMMAND_GENERATOR_MODEL_NAME = "llm_command_generator_model_name"
 LLM_COMMAND_GENERATOR_CUSTOM_PROMPT_USED = "llm_command_generator_custom_prompt_used"
+MULTI_STEP_LLM_COMMAND_GENERATOR_HANDLE_FLOWS_PROMPT_USED = (
+    "multi_step_llm_command_generator_custom_handle_flows_prompt_used"
+)
+MULTI_STEP_LLM_COMMAND_GENERATOR_FILL_SLOTS_PROMPT_USED = (
+    "multi_step_llm_command_generator_custom_fill_slots_prompt_used"
+)
 FLOW_RETRIEVAL_ENABLED = "flow_retrieval_enabled"
 FLOW_RETRIEVAL_EMBEDDING_MODEL_NAME = "flow_retrieval_embedding_model_name"
 TRACING_BACKEND = "tracing_backend"
@@ -158,7 +177,7 @@ def print_telemetry_reporting_info() -> None:
     """Print telemetry information to std out."""
     message = textwrap.dedent(
         f"""
-        Rasa Open Source reports anonymous usage telemetry to help improve the product
+        Rasa Pro reports anonymous usage telemetry to help improve the product
         for all its users.
 
         If you'd like to opt-out, you can use `rasa telemetry disable`.
@@ -225,6 +244,12 @@ def is_telemetry_enabled() -> bool:
     Returns:
         `True`, if telemetry is enabled, `False` otherwise.
     """
+    from rasa.utils import licensing
+
+    if licensing.is_champion_server_license():
+        logger.debug("Telemetry is enabled for developer licenses.")
+        return True
+
     telemetry_environ = os.environ.get(TELEMETRY_ENABLED_ENVIRONMENT_VARIABLE)
 
     if telemetry_environ is not None:
@@ -336,7 +361,7 @@ def telemetry_write_key() -> Optional[Text]:
     """Read the Segment write key from the segment key text file.
 
     The segment key text file should by present only in wheel/sdist packaged
-    versions of Rasa Open Source. This avoids running telemetry locally when
+    versions of Rasa Pro. This avoids running telemetry locally when
     developing on Rasa or when running CI builds.
 
     In local development, this should always return `None` to avoid logging telemetry.
@@ -542,7 +567,7 @@ def _is_docker() -> bool:
 
 
 def with_default_context_fields(
-    context: Optional[Dict[Text, Any]] = None
+    context: Optional[Dict[Text, Any]] = None,
 ) -> Dict[Text, Any]:
     """Return a new context dictionary with default and provided field values merged.
 
@@ -565,6 +590,8 @@ def _default_context_fields() -> Dict[Text, Any]:
     Return:
         A new context containing information about the runtime environment.
     """
+    from rasa.utils.licensing import property_of_active_license, get_license_hash
+
     global TELEMETRY_CONTEXT
 
     if not TELEMETRY_CONTEXT:
@@ -600,7 +627,7 @@ def _track(
 
     It is OK to use this function from outside telemetry.py, but note that it
     is recommended to create a new track_xyz() function for complex telemetry
-    events, or events that are generated from many parts of the Rasa Open Source code.
+    events, or events that are generated from many parts of the Rasa Pro code.
 
     Args:
         event_name: Name of the event.
@@ -714,6 +741,8 @@ def get_telemetry_id() -> Optional[Text]:
     Returns:
         The identifier, if it is configured correctly.
     """
+    from rasa.utils.licensing import property_of_active_license
+
     return property_of_active_license(lambda active_license: active_license.jti)
 
 
@@ -1043,12 +1072,25 @@ def _collect_flow_statistics(flows: List[Flow]) -> Dict[str, Any]:
 
 
 def _get_llm_command_generator_config(config: Dict[str, Any]) -> Optional[Dict]:
-    """Returns the configuration for the LLMCommandGenerator including the model name,
-    whether a custom prompt is used, whether flow retrieval is enabled, and flow
-    retrieval embedding model.
+    """Returns the configuration for the LLMCommandGenerator.
+
+    Includes the model name, whether a custom prompt is used, whether flow
+    retrieval is enabled, and flow retrieval embedding model.
     """
-    from rasa.dialogue_understanding.generator import LLMCommandGenerator
-    from rasa.dialogue_understanding.generator.llm_command_generator import (
+    from rasa.shared.constants import (
+        MODEL_CONFIG_KEY,
+        MODEL_NAME_CONFIG_KEY,
+    )
+    from rasa.dialogue_understanding.generator import (
+        LLMCommandGenerator,
+        SingleStepLLMCommandGenerator,
+        MultiStepLLMCommandGenerator,
+    )
+    from rasa.dialogue_understanding.generator.multi_step.multi_step_llm_command_generator import (  # noqa: E501
+        HANDLE_FLOWS_KEY,
+        FILL_SLOTS_KEY,
+    )
+    from rasa.dialogue_understanding.generator.constants import (
         LLM_CONFIG_KEY,
         DEFAULT_LLM_CONFIG,
         FLOW_RETRIEVAL_KEY,
@@ -1060,15 +1102,21 @@ def _get_llm_command_generator_config(config: Dict[str, Any]) -> Optional[Dict]:
     def find_command_generator_component(pipeline: List) -> Optional[Dict]:
         """Finds the LLMCommandGenerator component in the pipeline."""
         for component in pipeline:
-            if component["name"] == LLMCommandGenerator.__name__:
+            if component["name"] in [
+                LLMCommandGenerator.__name__,
+                SingleStepLLMCommandGenerator.__name__,
+                MultiStepLLMCommandGenerator.__name__,
+            ]:
                 return component
         return None
 
     def extract_settings(component: Dict) -> Dict:
         """Extracts the settings from the command generator component."""
-        custom_prompt_used = "prompt" in component
-        llm_model_name = component.get(LLM_CONFIG_KEY, {}).get(
-            "model_name", DEFAULT_LLM_CONFIG["model_name"]
+        llm_config = component.get(LLM_CONFIG_KEY, {})
+        llm_model_name = (
+            llm_config.get(MODEL_CONFIG_KEY)
+            or llm_config.get(MODEL_NAME_CONFIG_KEY)
+            or DEFAULT_LLM_CONFIG[MODEL_NAME_CONFIG_KEY]
         )
         flow_retrieval_config = component.get(FLOW_RETRIEVAL_KEY, {})
         flow_retrieval_enabled = flow_retrieval_config.get("active", True)
@@ -1081,7 +1129,12 @@ def _get_llm_command_generator_config(config: Dict[str, Any]) -> Optional[Dict]:
         )
         return {
             LLM_COMMAND_GENERATOR_MODEL_NAME: llm_model_name,
-            LLM_COMMAND_GENERATOR_CUSTOM_PROMPT_USED: custom_prompt_used,
+            LLM_COMMAND_GENERATOR_CUSTOM_PROMPT_USED: PROMPT_CONFIG_KEY in component
+            or PROMPT_TEMPLATE_CONFIG_KEY in component,
+            MULTI_STEP_LLM_COMMAND_GENERATOR_HANDLE_FLOWS_PROMPT_USED: HANDLE_FLOWS_KEY
+            in component.get("prompt_templates", {}),
+            MULTI_STEP_LLM_COMMAND_GENERATOR_FILL_SLOTS_PROMPT_USED: FILL_SLOTS_KEY
+            in component.get("prompt_templates", {}),
             FLOW_RETRIEVAL_ENABLED: flow_retrieval_enabled,
             FLOW_RETRIEVAL_EMBEDDING_MODEL_NAME: flow_retrieval_embedding_model_name,
         }
@@ -1089,6 +1142,8 @@ def _get_llm_command_generator_config(config: Dict[str, Any]) -> Optional[Dict]:
     command_generator_config = {
         LLM_COMMAND_GENERATOR_MODEL_NAME: None,
         LLM_COMMAND_GENERATOR_CUSTOM_PROMPT_USED: None,
+        MULTI_STEP_LLM_COMMAND_GENERATOR_HANDLE_FLOWS_PROMPT_USED: None,
+        MULTI_STEP_LLM_COMMAND_GENERATOR_FILL_SLOTS_PROMPT_USED: None,
         FLOW_RETRIEVAL_ENABLED: None,
         FLOW_RETRIEVAL_EMBEDDING_MODEL_NAME: None,
     }
@@ -1230,19 +1285,19 @@ def track_server_start(
             "number_of_workers": number_of_workers,
             "endpoints_nlg": endpoints.nlg.type if endpoints.nlg else None,
             "endpoints_nlu": endpoints.nlu.type if endpoints.nlu else None,
-            "endpoints_action_server": (
-                endpoints.action.type if endpoints.action else None
-            ),
+            "endpoints_action_server": endpoints.action.type
+            if endpoints.action
+            else None,
             "endpoints_model_server": endpoints.model.type if endpoints.model else None,
-            "endpoints_tracker_store": (
-                endpoints.tracker_store.type if endpoints.tracker_store else None
-            ),
-            "endpoints_lock_store": (
-                endpoints.lock_store.type if endpoints.lock_store else None
-            ),
-            "endpoints_event_broker": (
-                endpoints.event_broker.type if endpoints.event_broker else None
-            ),
+            "endpoints_tracker_store": endpoints.tracker_store.type
+            if endpoints.tracker_store
+            else None,
+            "endpoints_lock_store": endpoints.lock_store.type
+            if endpoints.lock_store
+            else None,
+            "endpoints_event_broker": endpoints.event_broker.type
+            if endpoints.event_broker
+            else None,
             "project": project_fingerprint_from_model(model_directory),
         },
     )
@@ -1386,7 +1441,9 @@ def track_markers_parsed_count(
 
 @ensure_telemetry_enabled
 def track_e2e_test_run(
-    input_test_cases: List["TestCase"], input_fixtures: List["Fixture"]
+    input_test_cases: List["TestCase"],
+    input_fixtures: List["Fixture"],
+    input_metadata: List["Metadata"],
 ) -> None:
     """Track an end-to-end test run."""
     _track(
@@ -1395,6 +1452,8 @@ def track_e2e_test_run(
             "number_of_test_cases": len(input_test_cases),
             "number_of_fixtures": len(input_fixtures),
             "uses_fixtures": len(input_fixtures) > 0,
+            "uses_metadata": len(input_metadata) > 0,
+            "number_of_metadata": len(input_metadata),
         },
     )
 
@@ -1574,10 +1633,105 @@ def append_anonymization_trait(
         endpoints_file, KEY_ANONYMIZATION_RULES
     )
 
-    traits[
-        KEY_ANONYMIZATION_RULES
-    ] = rasa.anonymization.utils.extract_anonymization_traits(
-        anonymization_config, KEY_ANONYMIZATION_RULES
+    traits[KEY_ANONYMIZATION_RULES] = (
+        rasa.anonymization.utils.extract_anonymization_traits(
+            anonymization_config, KEY_ANONYMIZATION_RULES
+        )
     )
 
     return traits
+
+
+@ensure_telemetry_enabled
+def track_enterprise_search_policy_train_started() -> None:
+    """Track when a user starts training Enterprise Search policy."""
+    _track(TELEMETRY_ENTERPRISE_SEARCH_POLICY_TRAINING_STARTED_EVENT)
+
+
+@ensure_telemetry_enabled
+def track_enterprise_search_policy_train_completed(
+    vector_store_type: Optional[str],
+    embeddings_type: Optional[str],
+    embeddings_model: Optional[str],
+    llm_type: Optional[str],
+    llm_model: Optional[str],
+    citation_enabled: Optional[bool],
+) -> None:
+    """Track when a user completes training Enterprise Search policy."""
+    _track(
+        TELEMETRY_ENTERPRISE_SEARCH_POLICY_TRAINING_COMPLETED_EVENT,
+        {
+            "vector_store_type": vector_store_type,
+            "embeddings_type": embeddings_type,
+            "embeddings_model": embeddings_model,
+            "llm_type": llm_type,
+            "llm_model": llm_model,
+            "citation_enabled": citation_enabled,
+        },
+    )
+
+
+@ensure_telemetry_enabled
+def track_enterprise_search_policy_predict(
+    vector_store_type: Optional[str],
+    embeddings_type: Optional[str],
+    embeddings_model: Optional[str],
+    llm_type: Optional[str],
+    llm_model: Optional[str],
+    citation_enabled: Optional[bool],
+) -> None:
+    """Track when a user predicts the next action using Enterprise Search policy."""
+    _track(
+        TELEMETRY_ENTERPRISE_SEARCH_POLICY_PREDICT_EVENT,
+        {
+            "vector_store_type": vector_store_type,
+            "embeddings_type": embeddings_type,
+            "embeddings_model": embeddings_model,
+            "llm_type": llm_type,
+            "llm_model": llm_model,
+            "citation_enabled": citation_enabled,
+        },
+    )
+
+
+@ensure_telemetry_enabled
+def track_conversation_count_hard_limit(
+    conversation_count: int, tracked_month: datetime
+) -> None:
+    """Track when the number of conversations reaches the hard limit."""
+    _track(
+        TELEMETRY_CONVERSATION_HARD_LIMIT_REACHED,
+        {
+            "conversation_count": conversation_count,
+            "year": tracked_month.year,
+            "month": tracked_month.month,
+        },
+    )
+
+
+@ensure_telemetry_enabled
+def track_conversation_count_soft_limit(
+    conversation_count: int, tracked_month: datetime
+) -> None:
+    """Track when the number of conversations reaches the soft limit."""
+    _track(
+        TELEMETRY_CONVERSATION_SOFT_LIMIT_REACHED,
+        {
+            "conversation_count": conversation_count,
+            "year": tracked_month.year,
+            "month": tracked_month.month,
+        },
+    )
+
+
+@ensure_telemetry_enabled
+def track_conversation_count(conversation_count: int, tracked_month: datetime) -> None:
+    """Track the number of conversations."""
+    _track(
+        TELEMETRY_CONVERSATION_COUNT,
+        {
+            "conversation_count": conversation_count,
+            "year": tracked_month.year,
+            "month": tracked_month.month,
+        },
+    )

rasa/tracing/config.py

@@ -16,6 +16,11 @@ from opentelemetry.sdk.resources import SERVICE_NAME, Resource
 from opentelemetry.sdk.trace import TracerProvider
 from opentelemetry.sdk.trace.export import BatchSpanProcessor
 
+from rasa.core.actions.custom_action_executor import (
+    CustomActionExecutor,
+    RetryCustomActionExecutor,
+)
+from rasa.core.actions.grpc_custom_action_executor import GRPCCustomActionExecutor
 from rasa.core.agent import Agent
 from rasa.core.processor import MessageProcessor
 from rasa.core.tracker_store import TrackerStore
@@ -23,8 +28,10 @@ from rasa.dialogue_understanding.commands import (
     Command,
     FreeFormAnswerCommand,
 )
-from rasa.dialogue_understanding.generator.llm_command_generator import (
+from rasa.dialogue_understanding.generator import (
     LLMCommandGenerator,
+    SingleStepLLMCommandGenerator,
+    MultiStepLLMCommandGenerator,
 )
 from rasa.dialogue_understanding.generator.nlu_command_adapter import NLUCommandAdapter
 from rasa.engine.graph import GraphNode
@@ -38,11 +45,10 @@ from rasa.tracing.constants import (
     ENDPOINTS_ROOT_CERTIFICATES_KEY,
     ENDPOINTS_METRICS_KEY,
 )
+from rasa.tracing.instrumentation import instrumentation
 from rasa.tracing.metric_instrument_provider import MetricInstrumentProvider
 from rasa.utils.endpoints import EndpointConfig, read_endpoint_config
 
-from rasa.tracing.instrumentation import instrumentation
-
 TRACING_SERVICE_NAME = os.environ.get("TRACING_SERVICE_NAME", "rasa")
 
 logger = logging.getLogger(__name__)
@@ -82,6 +88,11 @@ def configure_tracing(tracer_provider: Optional[TracerProvider]) -> None:
         for vector_store_class in InformationRetrieval.__subclasses__()
     ]
 
+    custom_action_executor_subclasses = []
+    for custom_action_executor_class in CustomActionExecutor.__subclasses__():
+        if custom_action_executor_class != RetryCustomActionExecutor:
+            custom_action_executor_subclasses.append(custom_action_executor_class)
+
     instrumentation.instrument(
         tracer_provider=tracer_provider,
         agent_class=Agent,
@@ -96,6 +107,10 @@ def configure_tracing(tracer_provider: Optional[TracerProvider]) -> None:
         vector_store_subclasses=vector_store_subclasses,
         nlu_command_adapter_class=NLUCommandAdapter,
         endpoint_config_class=EndpointConfig,
+        grpc_custom_action_executor_class=GRPCCustomActionExecutor,
+        single_step_llm_command_generator_class=SingleStepLLMCommandGenerator,
+        multi_step_llm_command_generator_class=MultiStepLLMCommandGenerator,
+        custom_action_executor_subclasses=custom_action_executor_subclasses,
     )
 
 

rasa/tracing/constants.py

@@ -9,7 +9,7 @@ ENDPOINTS_OTLP_BACKEND_TYPE = "otlp"
 
 # tracing attributes
 PROMPT_TOKEN_LENGTH_ATTRIBUTE_NAME = "len_prompt_tokens"
-ENDPOINT_REQUEST_BODY_SIZE_IN_BYTES_ATTRIBUTE_NAME = "request_body_size_in_bytes"
+REQUEST_BODY_SIZE_IN_BYTES_ATTRIBUTE_NAME = "request_body_size_in_bytes"
 
 # metrics constants
 LLM_COMMAND_GENERATOR_CPU_USAGE_METRIC_NAME = "llm_command_generator_cpu_usage"
@@ -20,6 +20,30 @@ LLM_COMMAND_GENERATOR_PROMPT_TOKEN_USAGE_METRIC_NAME = (
 LLM_COMMAND_GENERATOR_LLM_RESPONSE_DURATION_METRIC_NAME = (
     "llm_command_generator_llm_response_duration"
 )
+SINGLE_STEP_LLM_COMMAND_GENERATOR_CPU_USAGE_METRIC_NAME = (
+    "single_step_llm_command_generator_cpu_usage"
+)
+SINGLE_STEP_LLM_COMMAND_GENERATOR_MEMORY_USAGE_METRIC_NAME = (
+    "single_step_llm_command_generator_memory_usage"
+)
+SINGLE_STEP_LLM_COMMAND_GENERATOR_PROMPT_TOKEN_USAGE_METRIC_NAME = (
+    "single_step_llm_command_generator_prompt_token_usage"
+)
+SINGLE_STEP_LLM_COMMAND_GENERATOR_LLM_RESPONSE_DURATION_METRIC_NAME = (
+    "single_step_llm_command_generator_llm_response_duration"
+)
+MULTI_STEP_LLM_COMMAND_GENERATOR_CPU_USAGE_METRIC_NAME = (
+    "multi_step_llm_command_generator_cpu_usage"
+)
+MULTI_STEP_LLM_COMMAND_GENERATOR_MEMORY_USAGE_METRIC_NAME = (
+    "multi_step_llm_command_generator_memory_usage"
+)
+MULTI_STEP_LLM_COMMAND_GENERATOR_PROMPT_TOKEN_USAGE_METRIC_NAME = (
+    "multi_step_llm_command_generator_prompt_token_usage"
+)
+MULTI_STEP_LLM_COMMAND_GENERATOR_LLM_RESPONSE_DURATION_METRIC_NAME = (
+    "multi_step_llm_command_generator_llm_response_duration"
+)
 
 ENTERPRISE_SEARCH_POLICY_LLM_RESPONSE_DURATION_METRIC_NAME = (
     "enterprise_search_policy_llm_response_duration"
@@ -34,5 +58,5 @@ CONTEXTUAL_RESPONSE_REPHRASER_LLM_RESPONSE_DURATION_METRIC_NAME = (
 RASA_CLIENT_REQUEST_DURATION_METRIC_NAME = "rasa_client_request_duration"
 RASA_CLIENT_REQUEST_BODY_SIZE_METRIC_NAME = "rasa_client_request_body_size"
 
-LLM_COMMAND_GENERATOR_CPU_MEMORY_USAGE_UNIT_NAME = "percentage"
+LLM_BASED_COMMAND_GENERATOR_CPU_MEMORY_USAGE_UNIT_NAME = "percentage"
 DURATION_UNIT_NAME = "ms"

rasa/tracing/instrumentation/attribute_extractors.py

@@ -1,46 +1,48 @@
 import json
 import logging
 from pathlib import Path
-from typing import Any, Dict, List, Optional, TYPE_CHECKING, Text, Tuple
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Text, Tuple, Union
 
 import tiktoken
 from numpy import ndarray
+from rasa_sdk.grpc_py import action_webhook_pb2
 
+from rasa.core.actions.grpc_custom_action_executor import GRPCCustomActionExecutor
+from rasa.core.actions.http_custom_action_executor import HTTPCustomActionExecutor
 from rasa.core.agent import Agent
 from rasa.core.brokers.broker import EventBroker
 from rasa.core.channels import UserMessage
-from rasa.core.nlg.contextual_response_rephraser import ContextualResponseRephraser
 from rasa.core.lock_store import LOCK_LIFETIME, LockStore
+from rasa.core.nlg.contextual_response_rephraser import ContextualResponseRephraser
 from rasa.core.processor import MessageProcessor
 from rasa.core.tracker_store import TrackerStore
 from rasa.dialogue_understanding.commands import Command
-from rasa.dialogue_understanding.generator.llm_command_generator import (
-    LLMCommandGenerator,
-)
 from rasa.dialogue_understanding.stack.dialogue_stack import DialogueStack
-from rasa.engine.graph import GraphModelConfiguration, GraphNode, ExecutionContext
+from rasa.engine.graph import ExecutionContext, GraphModelConfiguration, GraphNode
 from rasa.engine.training.graph_trainer import GraphTrainer
 from rasa.shared.core.constants import REQUESTED_SLOT
 from rasa.shared.core.domain import Domain
 from rasa.shared.core.events import DialogueStackUpdated, Event
-from rasa.shared.core.flows import Flow, FlowStep, FlowsList
+from rasa.shared.core.flows import Flow, FlowsList, FlowStep
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.importers.importer import TrainingDataImporter
-from rasa.shared.nlu.constants import INTENT_NAME_KEY
+from rasa.shared.nlu.constants import INTENT_NAME_KEY, SET_SLOT_COMMAND
 from rasa.shared.utils.llm import combine_custom_and_default_config
 from rasa.tracing.constants import (
     PROMPT_TOKEN_LENGTH_ATTRIBUTE_NAME,
-    ENDPOINT_REQUEST_BODY_SIZE_IN_BYTES_ATTRIBUTE_NAME,
+    REQUEST_BODY_SIZE_IN_BYTES_ATTRIBUTE_NAME,
 )
-from rasa.utils.endpoints import concat_url
 
 if TYPE_CHECKING:
     from langchain.llms.base import BaseLLM
+
     from rasa.core.policies.enterprise_search_policy import EnterpriseSearchPolicy
     from rasa.core.policies.intentless_policy import IntentlessPolicy
     from rasa.core.policies.policy import PolicyPrediction
-    from rasa.dialogue_understanding.generator.command_generator import CommandGenerator
-    from rasa.utils.endpoints import EndpointConfig
+    from rasa.dialogue_understanding.generator import (
+        CommandGenerator,
+        LLMBasedCommandGenerator,
+    )
 
 # This file contains all attribute extractors for tracing instrumentation.
 # These are functions that are applied to the arguments of the wrapped function to be
@@ -84,7 +86,7 @@ def extract_llm_command_generator_attrs(
         command_name = command.get("command")
         commands_list.append(command_name)
 
-        if command_name == "set slot":
+        if command_name == SET_SLOT_COMMAND:
             attributes["slot_name"] = command.get("name")
 
         if command_name == "start flow":
@@ -247,7 +249,10 @@ def extract_attrs_for_graph_trainer(
     }
 
 
-def extract_headers(message: UserMessage, **kwargs: Any) -> Any:
+def extract_headers(
+    message: UserMessage,
+    **kwargs: Any,
+) -> Any:
     """Extract the headers from the `UserMessage`."""
     if message.headers:
         return message.headers
@@ -269,7 +274,7 @@ def extract_intent_name_and_slots(
             slots[slot_name] = slot_value.value
             break
     return {
-        "intent_name": str(tracker.latest_message.intent.get(INTENT_NAME_KEY)),  # type: ignore[union-attr]  # noqa: E501
+        "intent_name": str(tracker.latest_message.intent.get(INTENT_NAME_KEY)),  # type: ignore[union-attr]
         **slots,
     }
 
@@ -315,11 +320,11 @@ def extract_llm_config(self: Any, default_llm_config: Dict[str, Any]) -> Dict[st
     return attributes
 
 
-def extract_attrs_for_llm_command_generator(
-    self: LLMCommandGenerator,
+def extract_attrs_for_llm_based_command_generator(
+    self: "LLMBasedCommandGenerator",
     prompt: str,
 ) -> Dict[str, Any]:
-    from rasa.dialogue_understanding.generator.llm_command_generator import (
+    from rasa.dialogue_understanding.generator.constants import (
         DEFAULT_LLM_CONFIG,
     )
 
@@ -382,7 +387,7 @@ def extract_attrs_for_validate_state_of_commands(
         command_type = command.command()
         command_as_dict = command.as_dict()
 
-        if command_type == "set slot":
+        if command_type == SET_SLOT_COMMAND:
             command_as_dict.pop("value", None)
 
         if command_type == "correct slot":
@@ -414,7 +419,7 @@ def extract_attrs_for_clean_up_commands(
         command_type = command.command()
         command_as_dict = command.as_dict()
 
-        if command_type == "set slot":
+        if command_type == SET_SLOT_COMMAND:
             command_as_dict.pop("value", None)
 
         commands_list.append(command_as_dict)
@@ -467,7 +472,7 @@ def extract_attrs_for_check_commands_against_startable_flows(
         command_as_dict = command.as_dict()
         command_type = command.command()
 
-        if command_type == "set slot":
+        if command_type == SET_SLOT_COMMAND:
             slot_value = command_as_dict.pop("value", None)
             command_as_dict["is_slot_value_missing_or_none"] = slot_value is None
 
@@ -523,7 +528,6 @@ def extract_attrs_for_policy_prediction(
     diagnostic_data: Optional[Dict[Text, Any]] = None,
     action_metadata: Optional[Dict[Text, Any]] = None,
 ) -> Dict[str, Any]:
-
     # diagnostic_data can contain ndarray type values which need to be converted
     # into a list since the returning values have to be JSON serializable.
     if isinstance(diagnostic_data, dict):
@@ -638,26 +642,31 @@ def extend_attributes_with_prompt_tokens_length(
     return attributes
 
 
-def extract_attrs_for_endpoint_config(
-    self: "EndpointConfig",
-    method: Text = "post",
-    subpath: Optional[Text] = None,
-    content_type: Optional[Text] = "application/json",
-    compress: bool = False,
-    **kwargs: Any,
+def extract_attrs_for_custom_action_executor_run(
+    self: Union[HTTPCustomActionExecutor, GRPCCustomActionExecutor],
+    tracker: DialogueStateTracker,
+    domain: Domain,
+    include_domain: bool = False,
 ) -> Dict[str, Any]:
-    request_body = kwargs.get("json")
-    attrs: Dict[str, Any] = {"url": concat_url(self.url, subpath)}
+    attrs: Dict[str, Any] = {
+        "class_name": self.__class__.__name__,
+        "action_name": self.action_name if hasattr(self, "action_name") else "None",
+        "sender_id": tracker.sender_id,
+        "url": self.action_endpoint.url if hasattr(self, "action_endpoint") else "None",
+    }
+    return attrs
 
-    if not request_body:
-        attrs.update({ENDPOINT_REQUEST_BODY_SIZE_IN_BYTES_ATTRIBUTE_NAME: 0})
-    else:
-        attrs.update(
-            {
-                ENDPOINT_REQUEST_BODY_SIZE_IN_BYTES_ATTRIBUTE_NAME: len(
-                    json.dumps(request_body).encode("utf-8")
-                )
-            }
-        )
+
+def extract_attrs_for_grpc_custom_action_executor_request(
+    self: GRPCCustomActionExecutor,
+    request: action_webhook_pb2.WebhookRequest,
+) -> Dict[str, Any]:
+    attrs: Dict[str, Any] = {"url": self.action_endpoint.url}
+
+    attrs.update(
+        {
+            REQUEST_BODY_SIZE_IN_BYTES_ATTRIBUTE_NAME: request.ByteSize(),
+        }
+    )
 
     return attrs