rasa-pro 3.11.0rc1__py3-none-any.whl → 3.11.0rc2__py3-none-any.whl

rasa/dialogue_understanding/generator/single_step/single_step_llm_command_generator.py

@@ -23,7 +23,6 @@ from rasa.dialogue_understanding.generator.constants import (
     USER_INPUT_CONFIG_KEY,
     FLOW_RETRIEVAL_KEY,
     DEFAULT_LLM_CONFIG,
-    TRAINED_MODEL_NAME_CONFIG_KEY,
 )
 from rasa.dialogue_understanding.generator.flow_retrieval import (
     FlowRetrieval,
@@ -54,7 +53,6 @@ from rasa.shared.utils.llm import (
     sanitize_message_for_prompt,
     resolve_model_client_config,
 )
-from rasa.shared.utils.health_check import perform_inference_time_llm_health_check
 from rasa.utils.beta import ensure_beta_feature_is_enabled, BetaNotEnabledException
 from rasa.utils.log_utils import log_llm
 
@@ -64,6 +62,7 @@ DEFAULT_COMMAND_PROMPT_TEMPLATE = importlib.resources.read_text(
     "rasa.dialogue_understanding.generator.single_step",
     "command_prompt_template.jinja2",
 )
+SINGLE_STEP_LLM_COMMAND_GENERATOR_CONFIG_FILE = "config.json"
 
 structlogger = structlog.get_logger()
 
@@ -137,6 +136,16 @@ class SingleStepLLMCommandGenerator(LLMBasedCommandGenerator):
         **kwargs: Any,
     ) -> "SingleStepLLMCommandGenerator":
         """Loads trained component (see parent class for full docstring)."""
+
+        # Perform health check of the LLM API endpoint
+        llm_config = resolve_model_client_config(config.get(LLM_CONFIG_KEY, {}))
+        cls.perform_llm_health_check(
+            llm_config,
+            DEFAULT_LLM_CONFIG,
+            "single_step_llm_command_generator.load",
+            SingleStepLLMCommandGenerator.__name__,
+        )
+
         # load prompt template from the model storage.
         prompt_template = cls.load_prompt_template_from_model_storage(
             model_storage, resource, COMMAND_PROMPT_FILE_NAME
@@ -150,34 +159,28 @@ class SingleStepLLMCommandGenerator(LLMBasedCommandGenerator):
                 command_generator.config, model_storage, resource
             )
 
-        persisted_config = cls.load_config_from_model_storage(model_storage, resource)
-        train_model_name = (
-            persisted_config.get(TRAINED_MODEL_NAME_CONFIG_KEY, None)
-            if persisted_config
-            else None
-        )
-        perform_inference_time_llm_health_check(
-            command_generator.config.get(LLM_CONFIG_KEY),
-            DEFAULT_LLM_CONFIG,
-            train_model_name,
-            "single_step_llm_command_generator.load",
-            SingleStepLLMCommandGenerator.__name__,
-        )
-
         return command_generator
 
     def persist(self) -> None:
         """Persist this component to disk for future loading."""
-        # persist prompt template
-        super().persist()
+        self._persist_prompt_template()
+        self._persist_config()
+        if self.flow_retrieval is not None:
+            self.flow_retrieval.persist()
 
+    def _persist_prompt_template(self) -> None:
+        """Persist prompt template for future loading."""
         with self._model_storage.write_to(self._resource) as path:
             rasa.shared.utils.io.write_text_file(
                 self.prompt_template, path / COMMAND_PROMPT_FILE_NAME
             )
-        # persist flow retrieval
-        if self.flow_retrieval is not None:
-            self.flow_retrieval.persist()
+
+    def _persist_config(self) -> None:
+        """Persist config as a source of truth for resolved clients."""
+        with self._model_storage.write_to(self._resource) as path:
+            rasa.shared.utils.io.dump_obj_as_json_to_file(
+                path / SINGLE_STEP_LLM_COMMAND_GENERATOR_CONFIG_FILE, self.config
+            )
 
     async def predict_commands(
         self,

rasa/dialogue_understanding/processor/command_processor.py

@@ -8,6 +8,7 @@ from rasa.dialogue_understanding.commands import (
     Command,
     CorrectSlotsCommand,
     CorrectedSlot,
+    RepeatBotMessagesCommand,
     SetSlotCommand,
     StartFlowCommand,
     FreeFormAnswerCommand,
@@ -422,6 +423,9 @@ def clean_up_commands(
     elif not tracker.has_coexistence_routing_slot and len(clean_commands) > 1:
         clean_commands = filter_cannot_handle_command_for_skipped_slots(clean_commands)
 
+    clean_commands = ensure_max_number_of_command_type(
+        clean_commands, RepeatBotMessagesCommand, 1
+    )
     structlogger.debug(
         "command_processor.clean_up_commands.final_commands",
         command=clean_commands,
@@ -430,6 +434,22 @@ def clean_up_commands(
     return clean_commands
 
 
+def ensure_max_number_of_command_type(
+    commands: List[Command], command_type: Type[Command], n: int
+) -> List[Command]:
+    """Ensures that for a given command type only the first n stay in the list."""
+    filtered: List[Command] = []
+    count = 0
+    for c in commands:
+        if isinstance(c, command_type):
+            if count >= n:
+                continue
+            else:
+                count += 1
+        filtered.append(c)
+    return filtered
+
+
 def clean_up_clarify_command(
     commands_so_far: List[Command],
     all_commands: List[Command],
@@ -452,7 +472,7 @@ def clean_up_clarify_command(
         if not (isinstance(c, SetSlotCommand) and c.name == ROUTE_TO_CALM_SLOT)
     ]
 
-    # if there are multiple clarify commands, do add the first one
+    # if all commands are clarify commands, add the first one only, otherwise add none
     if all(
         isinstance(c, ClarifyCommand) for c in commands_without_route_to_calm_set_slot
     ):

rasa/e2e_test/e2e_test_case.py

@@ -1,8 +1,10 @@
-import logging
 from collections import OrderedDict
+from collections import defaultdict
 from dataclasses import dataclass
 from typing import Any, Dict, List, Optional, Text, Union
 
+import structlog
+
 from rasa.e2e_test.assertions import Assertion
 from rasa.e2e_test.constants import (
     KEY_ASSERTIONS,
@@ -20,10 +22,11 @@ from rasa.e2e_test.constants import (
     KEY_USER_INPUT,
 )
 from rasa.e2e_test.stub_custom_action import StubCustomAction
+from rasa.shared.constants import DOCS_BASE_URL
 from rasa.shared.core.events import BotUttered, SlotSet, UserUttered
 from rasa.shared.exceptions import RasaException
 
-logger = logging.getLogger(__name__)
+structlogger = structlog.get_logger(__name__)
 
 
 @dataclass(frozen=True)
@@ -343,9 +346,10 @@ class ActualStepOutput:
             try:
                 return self.user_uttered_events[0]
             except IndexError:
-                logger.debug(
-                    f"Could not find `UserUttered` event in the ActualStepOutput: "
-                    f"{self}"
+                structlogger.debug(
+                    "e2e_test_case.get_user_uttered_event.no_user_uttered_event",
+                    event_info=f"Could not find `UserUttered` event in the "
+                    f"ActualStepOutput: {self}",
                 )
                 return None
         return None
@@ -395,7 +399,7 @@ class TestCase:
             else:
                 steps.append(TestStep.from_dict(step))
 
-        return TestCase(
+        test_case = TestCase(
             name=input_test_case.get(KEY_TEST_CASE, "default"),
             steps=steps,
             file=file,
@@ -405,6 +409,81 @@ class TestCase:
             fixture_names=input_test_case.get(KEY_FIXTURES),
             metadata_name=input_test_case.get(KEY_METADATA),
         )
+        test_case.validate()
+        return test_case
+
+    def validate(self) -> None:
+        """Validates the test case.
+
+        This method calls all validation methods required for the test case.
+        """
+        if self.uses_assertions():
+            self.validate_duplicate_user_messages_metadata()
+
+    def validate_duplicate_user_messages_metadata(self) -> None:
+        """Validates that duplicate user messages use metadata correctly.
+
+        Ensures that each duplicate user message uses unique metadata.
+
+        Raises warnings if any issues are found.
+        """
+        docs_link = (
+            f"{DOCS_BASE_URL}/testing/e2e-testing-assertions/assertions-how-to-guide/"
+            "#how-to-handle-duplicate-user-text-messages-in-the-same-test-case"
+        )
+        no_metadata_event_info = (
+            "Test case '{name}' has duplicate user steps with text '{text}', "
+            "and user step at line {line} lacks metadata. When using "
+            "duplicate user messages, metadata should be set on each step to ensure "
+            f"correct processing. Please refer to the documentation: {docs_link}"
+        )
+        non_unique_metadata_event_info = (
+            "Test case '{name}' has duplicate user steps with text '{text}', "
+            "and user step at line {line} has duplicate metadata "
+            "name '{metadata_name}'. Metadata names should be unique for each user "
+            "step among duplicates. This may cause issues in processing "
+            f"user messages. Please refer to the documentation: {docs_link}"
+        )
+
+        # Use dict[str, list] structure to group steps by user message text to easily
+        # identify and validate instances with duplicate messages and their metadata.
+        message_steps = defaultdict(list)
+
+        # Collect user steps by text
+        for step in self.steps:
+            if step.actor == KEY_USER_INPUT and step.text:
+                message_steps[step.text].append(step)
+
+        # Check for duplicate messages
+        for text, steps in message_steps.items():
+            if len(steps) <= 1:
+                continue
+
+            metadata_names_used = set()
+            for step in steps:
+                if not step.metadata_name:
+                    structlogger.warning(
+                        "e2e_test_case.validate_duplicate_user_messages_metadata.no_metadata",
+                        event_info=no_metadata_event_info.format(
+                            name=self.name,
+                            text=text,
+                            line=step.line,
+                        ),
+                    )
+                    break
+                elif step.metadata_name in metadata_names_used:
+                    structlogger.warning(
+                        "e2e_test_case.validate_duplicate_user_messages_metadata.non_unique_metadata",
+                        event_info=non_unique_metadata_event_info.format(
+                            name=self.name,
+                            text=text,
+                            line=step.line,
+                            metadata_name=step.metadata_name,
+                        ),
+                    )
+                    break
+                else:
+                    metadata_names_used.add(step.metadata_name)
 
     def as_dict(self) -> Dict[Text, Any]:
         """Returns the test case as a dictionary."""

rasa/engine/validation.py

@@ -18,11 +18,10 @@ from typing import (
     List,
 )
 
+import rasa.utils.common
 import structlog
 import typing_utils
-
-import rasa.utils.common
-from rasa.core import IntentlessPolicy
+from rasa.core import IntentlessPolicy, ContextualResponseRephraser
 from rasa.core.policies.policy import PolicyPrediction
 from rasa.core.utils import AvailableEndpoints
 from rasa.dialogue_understanding.coexistence.constants import (
@@ -67,6 +66,7 @@ from rasa.shared.constants import (
     MODEL_GROUP_ID_CONFIG_KEY,
     ROUTER_CONFIG_KEY,
     MODELS_CONFIG_KEY,
+    MODEL_GROUP_CONFIG_KEY,
     ROUTER_STRATEGY_CONFIG_KEY,
     VALID_ROUTER_STRATEGIES,
     ROUTER_STRATEGIES_REQUIRING_REDIS_CACHE,
@@ -890,13 +890,13 @@ def _validate_component_model_client_config(
         # no llm configuration present
         return
 
-    if MODELS_CONFIG_KEY in component_config[key]:
+    if MODEL_GROUP_CONFIG_KEY in component_config[key]:
         model_group_syntax_used.append(True)
-        model_group_ids.append(component_config[key][MODELS_CONFIG_KEY])
+        model_group_ids.append(component_config[key][MODEL_GROUP_CONFIG_KEY])
 
         if len(component_config[key]) > 1:
             print_error_and_exit(
-                f"You specified a '{MODELS_CONFIG_KEY}' for the '{key}' "
+                f"You specified a '{MODEL_GROUP_CONFIG_KEY}' for the '{key}' "
                 f"config key for the component "
                 f"'{component_name or component_config['name']}'. "
                 "No other parameters are allowed under the "
@@ -908,10 +908,9 @@ def _validate_component_model_client_config(
         # check that api_key is not set in config
         if API_KEY in component_config[key]:
             print_error_and_exit(
-                f"You specified '{API_KEY}' in the config for"
-                f"{component_name or component_config['name']}, which "
-                "is not allowed. Set API keys through "
-                "environment variables."
+                f"You specified '{API_KEY}' in the config for "
+                f"'{component_name or component_config['name']}', which is not allowed."
+                " Set API keys through environment variables."
             )
 
 
@@ -936,34 +935,46 @@ def validate_model_client_configuration_setup(config: Dict[str, Any]) -> None:
     model_group_syntax_used: List[bool] = []
     model_group_ids: List[str] = []
 
-    if "pipeline" not in config:
-        return
-
-    for component in config["pipeline"]:
-        for key in [LLM_CONFIG_KEY, EMBEDDINGS_CONFIG_KEY]:
-            _validate_component_model_client_config(
-                component, key, model_group_syntax_used, model_group_ids
-            )
+    for outer_key in ["pipeline", "policies"]:
+        if outer_key not in config or config[outer_key] is None:
+            continue
 
-        # as flow retrieval is not a component itself, we need to
-        # check it separately
-        if FLOW_RETRIEVAL_KEY in component:
-            if EMBEDDINGS_CONFIG_KEY in component[FLOW_RETRIEVAL_KEY]:
+        for component in config[outer_key]:
+            for key in [LLM_CONFIG_KEY, EMBEDDINGS_CONFIG_KEY]:
                 _validate_component_model_client_config(
-                    component[FLOW_RETRIEVAL_KEY],
-                    EMBEDDINGS_CONFIG_KEY,
-                    model_group_syntax_used,
-                    model_group_ids,
-                    component["name"] + "." + FLOW_RETRIEVAL_KEY,
+                    component, key, model_group_syntax_used, model_group_ids
                 )
 
+            # as flow retrieval is not a component itself, we need to
+            # check it separately
+            if FLOW_RETRIEVAL_KEY in component:
+                if EMBEDDINGS_CONFIG_KEY in component[FLOW_RETRIEVAL_KEY]:
+                    _validate_component_model_client_config(
+                        component[FLOW_RETRIEVAL_KEY],
+                        EMBEDDINGS_CONFIG_KEY,
+                        model_group_syntax_used,
+                        model_group_ids,
+                        component["name"] + "." + FLOW_RETRIEVAL_KEY,
+                    )
+
+    # also include the ContextualResponseRephraser component
+    endpoints = AvailableEndpoints.get_instance()
+    if endpoints.nlg is not None:
+        _validate_component_model_client_config(
+            endpoints.nlg.kwargs,
+            LLM_CONFIG_KEY,
+            model_group_syntax_used,
+            model_group_ids,
+            ContextualResponseRephraser.__name__,
+        )
+
     if not is_uniform_bool_list(model_group_syntax_used):
         print_error_and_exit(
             "Some of your components refer to an LLM using the "
-            f"'{MODELS_CONFIG_KEY}' parameter, other components directly"
-            f"define the LLM under the '{LLM_CONFIG_KEY}' or the "
+            f"'{MODEL_GROUP_CONFIG_KEY}' parameter, other components directly"
+            f" define the LLM under the '{LLM_CONFIG_KEY}' or the "
             f"'{EMBEDDINGS_CONFIG_KEY}' key. You cannot use"
-            "a both types of definition. Please chose one syntax "
+            " both types of definitions. Please chose one syntax "
             "and update your config."
         )
 
@@ -1106,17 +1117,22 @@ def _validate_api_key_is_an_environment_variable(
     for model_group in model_groups:
         for model_config in model_group[MODELS_CONFIG_KEY]:
             for key, value in model_config.items():
-                if (
-                    key == API_KEY
-                    and isinstance(value, str)
-                    and not re.match(r"\${(\w+)}", value)
-                ):
-                    print_error_and_exit(
-                        f"You defined the '{API_KEY}' in model group "
-                        f"'{model_group[MODEL_GROUP_ID_CONFIG_KEY]}' as a string. "
-                        f"The '{API_KEY}' must be set as an environment variable. "
-                        f"Please update your config."
-                    )
+                if key == API_KEY:
+                    if isinstance(value, str):
+                        if not re.match(r"\${(\w+)}", value):
+                            print_error_and_exit(
+                                f"You defined the '{API_KEY}' in model group "
+                                f"'{model_group[MODEL_GROUP_ID_CONFIG_KEY]}' as a "
+                                f"string. The '{API_KEY}' must be set as an environment"
+                                f" variable. Please update your config."
+                            )
+                    else:
+                        print_error_and_exit(
+                            f"You should define the '{API_KEY}' in model group "
+                            f"'{model_group[MODEL_GROUP_ID_CONFIG_KEY]}' using the "
+                            f"environment variable syntax - ${{ENV_VARIABLE_NAME}}. "
+                            f"Please update your config."
+                        )
 
 
 def validate_model_group_configuration_setup() -> None:

rasa/model_service.py

@@ -14,6 +14,7 @@ import rasa.utils.licensing
 from urllib.parse import urlparse
 
 from rasa.utils.log_utils import configure_structlog
+from rasa.utils.sanic_error_handler import register_custom_sanic_error_handler
 
 structlogger = structlog.get_logger()
 
@@ -104,6 +105,8 @@ def main() -> None:
     # list all routes
     list_routes(app)
 
+    register_custom_sanic_error_handler(app)
+
     app.run(host="0.0.0.0", port=MODEL_SERVICE_PORT, legacy=True, motd=False)
 
 

rasa/nlu/tokenizers/whitespace_tokenizer.py

@@ -43,8 +43,6 @@ class WhitespaceTokenizer(Tokenizer):
     def __init__(self, config: Dict[Text, Any]) -> None:
         """Initialize the tokenizer."""
         super().__init__(config)
-        self.emoji_pattern = rasa.utils.io.get_emoji_regex()
-
         if "case_sensitive" in self._config:
             rasa.shared.utils.io.raise_warning(
                 "The option 'case_sensitive' was moved from the tokenizers to the "
@@ -64,18 +62,9 @@ class WhitespaceTokenizer(Tokenizer):
         # Path to the dictionaries on the local filesystem.
         return cls(config)
 
-    def remove_emoji(self, text: Text) -> Text:
-        """Remove emoji if the full text, aka token, matches the emoji regex."""
-        match = self.emoji_pattern.fullmatch(text)
-
-        if match is not None:
-            return ""
-
-        return text
-
     def tokenize(self, message: Message, attribute: Text) -> List[Token]:
-        text = message.get(attribute)
-
+        original_text = message.get(attribute)
+        text = rasa.utils.io.remove_emojis(original_text)
         # we need to use regex instead of re, because of
         # https://stackoverflow.com/questions/12746458/python-unicode-regular-expression-matching-failing-with-some-unicode-characters
 
@@ -94,11 +83,11 @@ class WhitespaceTokenizer(Tokenizer):
             text,
         ).split()
 
-        words = [self.remove_emoji(w) for w in words]
         words = [w for w in words if w]
 
         # if we removed everything like smiles `:)`, use the whole text as 1 token
         if not words:
+            text = original_text
             words = [text]
 
         tokens = self._convert_words_to_tokens(words, text)

rasa/server.py

@@ -78,6 +78,7 @@ from rasa.shared.utils.schemas.events import EVENTS_SCHEMA
 from rasa.shared.utils.yaml import validate_training_data
 from rasa.utils.common import TempDirectoryPath, get_temp_dir_name
 from rasa.utils.endpoints import EndpointConfig
+from rasa.utils.sanic_error_handler import register_custom_sanic_error_handler
 
 if TYPE_CHECKING:
     from ssl import SSLContext
@@ -528,7 +529,7 @@ def add_root_route(app: Sanic) -> None:
                 <p>Hello from Rasa: {rasa.__version__}</p>
                 <a href="./webhooks/inspector/inspect.html">Go to the inspector</a>
                 <script>
-                    window.location.replace("./webhooks/inspector/inspect.html");
+                    window.location.replace("./webhooks/socketio/inspect.html");
                 </script>
             </body>
         </html>
@@ -687,6 +688,7 @@ def create_app(
     app = Sanic("rasa_server")
     app.config.RESPONSE_TIMEOUT = response_timeout
     configure_cors(app, cors_origins)
+    register_custom_sanic_error_handler(app)
 
     # Reset Sanic warnings filter that allows the triggering of Sanic warnings
     warnings.filterwarnings("ignore", category=DeprecationWarning, module=r"sanic.*")

rasa/shared/core/flows/flows_list.py

@@ -234,12 +234,16 @@ class FlowsList:
             [f for f in self.underlying_flows if not f.is_startable_only_via_link()]
         )
 
-    def available_slot_names(self) -> Set[str]:
+    def available_slot_names(
+        self, ask_before_filling: Optional[bool] = None
+    ) -> Set[str]:
         """Get all slot names collected by flows."""
         return {
             step.collect
             for flow in self.underlying_flows
             for step in flow.get_collect_steps()
+            if ask_before_filling is None
+            or step.ask_before_filling == ask_before_filling
         }
 
     def available_custom_actions(self) -> Set[str]:

rasa/shared/providers/embedding/_base_litellm_embedding_client.py

@@ -6,6 +6,7 @@ import litellm
 import structlog
 from litellm import aembedding, embedding, validate_environment
 
+from rasa.shared.constants import API_BASE_CONFIG_KEY, API_KEY
 from rasa.shared.exceptions import (
     ProviderClientAPIException,
     ProviderClientValidationError,
@@ -81,11 +82,14 @@ class _BaseLiteLLMEmbeddingClient:
             ProviderClientValidationError if validation fails.
         """
         self._validate_environment_variables()
-        self._validate_api_key_not_in_config()
 
     def _validate_environment_variables(self) -> None:
         """Validate that the required environment variables are set."""
-        validation_info = validate_environment(self._litellm_model_name)
+        validation_info = validate_environment(
+            self._litellm_model_name,
+            api_key=self._litellm_extra_parameters.get(API_KEY),
+            api_base=self._litellm_extra_parameters.get(API_BASE_CONFIG_KEY),
+        )
         if missing_environment_variables := validation_info.get(
             _VALIDATE_ENVIRONMENT_MISSING_KEYS_KEY
         ):
@@ -100,18 +104,6 @@ class _BaseLiteLLMEmbeddingClient:
             )
             raise ProviderClientValidationError(event_info)
 
-    def _validate_api_key_not_in_config(self) -> None:
-        if "api_key" in self._litellm_extra_parameters:
-            event_info = (
-                "API Key is set through `api_key` extra parameter."
-                "Set API keys through environment variables."
-            )
-            structlogger.error(
-                "base_litellm_client.validate_api_key_not_in_config",
-                event_info=event_info,
-            )
-            raise ProviderClientValidationError(event_info)
-
     def validate_documents(self, documents: List[str]) -> None:
         """Validates a list of documents to ensure they are suitable for embedding.
 

rasa/shared/providers/llm/_base_litellm_client.py

@@ -9,6 +9,7 @@ from litellm import (
     validate_environment,
 )
 
+from rasa.shared.constants import API_BASE_CONFIG_KEY, API_KEY
 from rasa.shared.exceptions import (
     ProviderClientAPIException,
     ProviderClientValidationError,
@@ -101,7 +102,11 @@ class _BaseLiteLLMClient:
 
     def _validate_environment_variables(self) -> None:
         """Validate that the required environment variables are set."""
-        validation_info = validate_environment(self._litellm_model_name)
+        validation_info = validate_environment(
+            self._litellm_model_name,
+            api_key=self._litellm_extra_parameters.get(API_KEY),
+            api_base=self._litellm_extra_parameters.get(API_BASE_CONFIG_KEY),
+        )
         if missing_environment_variables := validation_info.get(
             _VALIDATE_ENVIRONMENT_MISSING_KEYS_KEY
         ):

rasa/shared/utils/health_check/embeddings_health_check_mixin.py

@@ -0,0 +1,31 @@
+from typing import Optional, Dict, Any
+
+
+class EmbeddingsHealthCheckMixin:
+    """Mixin class that provides methods for performing embeddings health checks during
+    training and inference within components.
+
+    This mixin offers static methods that wrap the following health check functions:
+    - `perform_embeddings_health_check`
+    """
+
+    @staticmethod
+    def perform_embeddings_health_check(
+        custom_embeddings_config: Optional[Dict[str, Any]],
+        default_embeddings_config: Dict[str, Any],
+        log_source_method: str,
+        log_source_component: str,
+    ) -> None:
+        """Wraps the `perform_embeddings_health_check` function to enable
+        tracing and instrumentation.
+        """
+        from rasa.shared.utils.health_check.health_check import (
+            perform_embeddings_health_check,
+        )
+
+        perform_embeddings_health_check(
+            custom_embeddings_config,
+            default_embeddings_config,
+            log_source_method,
+            log_source_component,
+        )