rasa-pro 3.11.0a4.dev3__py3-none-any.whl → 3.11.0rc2__py3-none-any.whl

rasa/shared/utils/yaml.py

@@ -1,4 +1,5 @@
 import datetime
+import io
 import logging
 import os
 import re
@@ -8,19 +9,13 @@ from dataclasses import field
 from functools import lru_cache
 from io import StringIO
 from pathlib import Path
-from typing import Dict, List, Optional, Any, Callable, Tuple, Union
+from typing import Any, List, Optional, Tuple, Dict, Callable, Union
 
 import jsonschema
 from importlib_resources import files
 from packaging import version
 from pykwalify.core import Core
 from pykwalify.errors import SchemaError
-from ruamel import yaml as yaml
-from ruamel.yaml import RoundTripRepresenter, YAMLError
-from ruamel.yaml.constructor import DuplicateKeyError, BaseConstructor, ScalarNode
-from ruamel.yaml.comments import CommentedSeq, CommentedMap
-from ruamel.yaml.loader import SafeLoader
-
 from rasa.shared.constants import (
     ASSERTIONS_SCHEMA_EXTENSIONS_FILE,
     ASSERTIONS_SCHEMA_FILE,
@@ -31,8 +26,7 @@ from rasa.shared.constants import (
     LATEST_TRAINING_DATA_FORMAT_VERSION,
     SCHEMA_EXTENSIONS_FILE,
     RESPONSES_SCHEMA_FILE,
-    ORIGINAL_VALUE,
-    RESOLVED_VALUE,
+    API_KEY,
 )
 from rasa.shared.exceptions import (
     YamlException,
@@ -52,6 +46,11 @@ from rasa.shared.utils.io import (
     raise_warning,
     read_json_file,
 )
+from ruamel import yaml as yaml
+from ruamel.yaml import YAML, RoundTripRepresenter, YAMLError
+from ruamel.yaml.comments import CommentedSeq, CommentedMap
+from ruamel.yaml.constructor import DuplicateKeyError, BaseConstructor, ScalarNode
+from ruamel.yaml.loader import SafeLoader
 
 logger = logging.getLogger(__name__)
 
@@ -60,12 +59,22 @@ YAML_VERSION = (1, 2)
 READ_YAML_FILE_CACHE_MAXSIZE = os.environ.get(
     READ_YAML_FILE_CACHE_MAXSIZE_ENV_VAR, DEFAULT_READ_YAML_FILE_CACHE_MAXSIZE
 )
+SENSITIVE_DATA = [API_KEY]
 
 
 @dataclass
 class PathWithError:
+    """Represents a validation error at a specific location in the YAML content.
+
+    Attributes:
+        message (str): A description of the validation error.
+        path (List[str]): Path to the node where the error occurred.
+        key (Optional[str]): The specific key associated with the error, if any.
+    """
+
     message: str
     path: List[str] = field(default_factory=list)
+    key: Optional[str] = None
 
 
 def fix_yaml_loader() -> None:
@@ -86,11 +95,15 @@ def replace_environment_variables() -> None:
     env_var_pattern = re.compile(r"^(.*)\$\{(.*)\}(.*)$")
     yaml.Resolver.add_implicit_resolver("!env_var", env_var_pattern, None)
 
-    def env_var_constructor(
-        loader: BaseConstructor, node: ScalarNode
-    ) -> Union[dict, str]:
+    def env_var_constructor(loader: BaseConstructor, node: ScalarNode) -> str:
         """Process environment variables found in the YAML."""
         value = loader.construct_scalar(node)
+
+        # get key of current node
+        key_node = list(loader.constructed_objects)[-1]
+        if isinstance(key_node, ScalarNode) and key_node.value in SENSITIVE_DATA:
+            return value
+
         expanded_vars = os.path.expandvars(value)
         not_expanded = [
             w for w in expanded_vars.split() if w.startswith("$") and w in value
@@ -102,11 +115,6 @@ def replace_environment_variables() -> None:
                 f"Please make sure to also set these "
                 f"environment variables: '{not_expanded}'."
             )
-        if expanded_vars:
-            # if the environment variable is referenced using the ${} syntax
-            # then we return a dictionary with the original value and the resolved,
-            # value. So that the graph components can use the original value.
-            return {ORIGINAL_VALUE: value, RESOLVED_VALUE: expanded_vars}
         return expanded_vars
 
     yaml.SafeConstructor.add_constructor("!env_var", env_var_constructor)
@@ -147,21 +155,72 @@ class YamlValidationException(YamlException, ValueError):
         if self.validation_errors:
             unique_errors = {}
             for error in self.validation_errors:
-                line_number = self._line_number_for_path(self.content, error.path)
+                line_number = self._line_number_for_path(
+                    self.content, error.path, error.key
+                )
 
                 if line_number and self.filename:
-                    error_representation = f"  in {self.filename}:{line_number}:\n"
+                    error_location = f"  in {self.filename}:{line_number}:\n"
                 elif line_number:
-                    error_representation = f"  in Line {line_number}:\n"
+                    error_location = f"  in Line {line_number}:\n"
                 else:
-                    error_representation = ""
+                    error_location = ""
 
-                error_representation += f"      {error.message}"
-                unique_errors[error.message] = error_representation
+                code_snippet = self._get_code_snippet(line_number)
+                error_message = f"{error_location}\n{code_snippet}{error.message}\n"
+                unique_errors[error.message] = error_message
             error_msg = "\n".join(unique_errors.values())
             msg += f":\n{error_msg}"
         return msg
 
+    def _get_code_snippet(
+        self,
+        error_line: Optional[int],
+        context_lines: int = 2,
+    ) -> str:
+        """Extract code snippet from the YAML lines around the error.
+
+        Args:
+            error_line: Line number where the error occurred (1-based).
+            context_lines: Number of context lines before and after the error line.
+                Default is 2, balancing context and readability. Adjust as needed.
+
+        Returns:
+            A string containing the code snippet with the error highlighted.
+        """
+        yaml_lines = self._get_serialized_yaml_lines()
+        if not yaml_lines or error_line is None:
+            return ""
+
+        start = max(error_line - context_lines - 1, 0)
+        end = min(error_line + context_lines, len(yaml_lines))
+        snippet_lines = yaml_lines[start:end]
+        snippet = ""
+        for idx, line_content in enumerate(snippet_lines, start=start + 1):
+            prefix = ">>> " if idx == error_line else "    "
+            line_number_str = str(idx)
+            snippet += f"{prefix}{line_number_str} | {line_content}\n"
+        return snippet
+
+    def _get_serialized_yaml_lines(self) -> List[str]:
+        """Serialize the content back to YAML and return the lines."""
+        yaml_lines = []
+        try:
+            yaml = YAML()
+            yaml.default_flow_style = False
+            # Set width to 1000, so we don't break the lines of the original YAML file
+            yaml.width = 1000  # type: ignore[assignment]
+            yaml.indent(mapping=2, sequence=4, offset=2)
+            stream = io.StringIO()
+            yaml.dump(self.content, stream)
+            serialized_yaml = stream.getvalue()
+            yaml_lines = serialized_yaml.splitlines()
+            return yaml_lines
+        except Exception as exc:
+            logger.debug(f"Error serializing YAML content: {exc}")
+
+        return yaml_lines
+
     def _calculate_number_of_lines(
         self,
         current: Union[CommentedSeq, CommentedMap],
@@ -229,7 +288,9 @@ class YamlValidationException(YamlException, ValueError):
         # Return the calculated child offset and True indicating a line number was found
         return child_offset, True
 
-    def _line_number_for_path(self, current: Any, path: List[str]) -> Optional[int]:
+    def _line_number_for_path(
+        self, current: Any, path: List[str], key: Optional[str] = None
+    ) -> Optional[int]:
         """Get line number for a yaml path in the current content.
 
         Implemented using recursion: algorithm goes down the path navigating to the
@@ -238,6 +299,7 @@ class YamlValidationException(YamlException, ValueError):
         Args:
             current: current content
             path: path to traverse within the content
+            key: the key associated with the error, if any
 
         Returns:
             the line number of the path in the content.
@@ -248,6 +310,10 @@ class YamlValidationException(YamlException, ValueError):
         this_line = current.lc.line + 1 if hasattr(current, "lc") else None
 
         if not path:
+            if key and hasattr(current, "lc"):
+                if hasattr(current.lc, "data") and key in current.lc.data:
+                    key_line_no = current.lc.data[key][0] + 1
+                    return key_line_no
             return this_line
 
         head, tail = path[0], path[1:]
@@ -257,7 +323,7 @@ class YamlValidationException(YamlException, ValueError):
 
         if head:
             if isinstance(current, dict) and head in current:
-                line = self._line_number_for_path(current[head], tail)
+                line = self._line_number_for_path(current[head], tail, key)
                 if line is None:
                     line_offset, found_lc = self._calculate_number_of_lines(
                         current, head
@@ -267,10 +333,13 @@ class YamlValidationException(YamlException, ValueError):
                     return this_line + line_offset
                 return line
             elif isinstance(current, list) and head.isdigit():
-                return self._line_number_for_path(current[int(head)], tail) or this_line
+                return (
+                    self._line_number_for_path(current[int(head)], tail, key)
+                    or this_line
+                )
             else:
                 return this_line
-        return self._line_number_for_path(current, tail) or this_line
+        return self._line_number_for_path(current, tail, key) or this_line
 
 
 def read_schema_file(
@@ -332,13 +401,26 @@ def validate_yaml_content_using_schema(
     try:
         core.validate(raise_exception=True)
     except SchemaError:
+        # PyKwalify propagates each validation error up the data hierarchy, resulting
+        # in multiple redundant errors for a single issue. To present a clear message
+        # about the root cause, we use only the first error.
+        error = core.errors[0]
+
+        # Increment numeric indices by 1 to convert from 0-based to 1-based indexing
+        error_message = re.sub(
+            r"(/)(\d+)", lambda m: f"/{int(m.group(2)) + 1}", str(error)
+        )
+
         raise YamlValidationException(
             "Please make sure the file is correct and all "
             "mandatory parameters are specified. Here are the errors "
             "found during validation",
             [
-                PathWithError(message=str(e), path=e.path.split("/"))
-                for e in core.errors
+                PathWithError(
+                    message=error_message,
+                    path=error.path.removeprefix("/").split("/"),
+                    key=getattr(error, "key", None),
+                )
             ],
             content=yaml_content,
         )
@@ -425,47 +507,6 @@ def validate_raw_yaml_using_schema_file_with_responses(
     )
 
 
-def process_content(content: str) -> str:
-    """
-    Process the content to handle both Windows paths and emojis.
-    Windows paths are processed by escaping backslashes but emojis are left untouched.
-
-    Args:
-        content: yaml content to be processed
-    """
-    # Detect common Windows path patterns: e.g., C:\ or \\
-    UNESCAPED_WINDOWS_PATH_PATTERN = re.compile(
-        r"(?<!\w)[a-zA-Z]:(\\[a-zA-Z0-9_ -]+)*(\\)?(?!\\n)"
-    )
-    ESCAPED_WINDOWS_PATH_PATTERN = re.compile(
-        r"(?<!\w)[a-zA-Z]:(\\\\[a-zA-Z0-9_ -]+)+\\\\?(?!\\n)"
-    )
-
-    # Function to escape backslashes in Windows paths but leave other content as is
-    def escape_windows_paths(match: re.Match) -> str:
-        path = str(match.group(0))
-        return path.replace("\\", "\\\\")  # Escape backslashes only in Windows paths
-
-    def unescape_windows_paths(match: re.Match) -> str:
-        path = str(match.group(0))
-        return path.replace("\\\\", "\\")
-
-    # First, process Windows paths by escaping backslashes
-    content = re.sub(UNESCAPED_WINDOWS_PATH_PATTERN, escape_windows_paths, content)
-
-    # Ensure proper handling of emojis by decoding Unicode sequences
-    content = (
-        content.encode("utf-8")
-        .decode("raw_unicode_escape")
-        .encode("utf-16", "surrogatepass")
-        .decode("utf-16")
-    )
-
-    content = re.sub(ESCAPED_WINDOWS_PATH_PATTERN, unescape_windows_paths, content)
-
-    return content
-
-
 def read_yaml(
     content: str,
     reader_type: Union[str, List[str]] = "safe",
@@ -481,9 +522,6 @@ def read_yaml(
     Raises:
         ruamel.yaml.parser.ParserError: If there was an error when parsing the YAML.
     """
-    if _is_ascii(content):
-        content = process_content(content)
-
     custom_constructor = kwargs.get("custom_constructor", None)
 
     # Create YAML parser with custom constructor

rasa/studio/auth.py

@@ -23,12 +23,10 @@ from rasa.studio.results_logger import with_studio_error_handler, StudioResult
 class StudioAuth:
     """Handles the authentication with the Rasa Studio authentication server."""
 
-    def __init__(
-        self,
-        studio_config: StudioConfig,
-        verify: bool = True,
-    ) -> None:
+    def __init__(self, studio_config: StudioConfig) -> None:
         self.config = studio_config
+        verify = not studio_config.disable_verify
+
         self.keycloak_openid = KeycloakOpenID(
             server_url=studio_config.authentication_server_url,
             client_id=studio_config.client_id,

rasa/studio/config.py

@@ -2,13 +2,14 @@ from __future__ import annotations
 
 import os
 from dataclasses import dataclass
-from typing import Dict, Optional, Text
+from typing import Any, Dict, Optional, Text
 
 from rasa.utils.common import read_global_config_value, write_global_config_value
 
 from rasa.studio.constants import (
     RASA_STUDIO_AUTH_SERVER_URL_ENV,
     RASA_STUDIO_CLI_CLIENT_ID_KEY_ENV,
+    RASA_STUDIO_CLI_DISABLE_VERIFY_KEY_ENV,
     RASA_STUDIO_CLI_REALM_NAME_KEY_ENV,
     RASA_STUDIO_CLI_STUDIO_URL_ENV,
     STUDIO_CONFIG_KEY,
@@ -19,6 +20,7 @@ STUDIO_URL_KEY = "studio_url"
 CLIENT_ID_KEY = "client_id"
 REALM_NAME_KEY = "realm_name"
 CLIENT_SECRET_KEY = "client_secret"
+DISABLE_VERIFY = "disable_verify"
 
 
 @dataclass
@@ -27,13 +29,15 @@ class StudioConfig:
     studio_url: Optional[Text]
     client_id: Optional[Text]
     realm_name: Optional[Text]
+    disable_verify: bool = False
 
-    def to_dict(self) -> Dict[Text, Optional[Text]]:
+    def to_dict(self) -> Dict[Text, Optional[Any]]:
         return {
             AUTH_SERVER_URL_KEY: self.authentication_server_url,
             STUDIO_URL_KEY: self.studio_url,
             CLIENT_ID_KEY: self.client_id,
             REALM_NAME_KEY: self.realm_name,
+            DISABLE_VERIFY: self.disable_verify,
         }
 
     @classmethod
@@ -43,6 +47,7 @@ class StudioConfig:
             studio_url=data[STUDIO_URL_KEY],
             client_id=data[CLIENT_ID_KEY],
             realm_name=data[REALM_NAME_KEY],
+            disable_verify=data.get(DISABLE_VERIFY, False),
         )
 
     def write_config(self) -> None:
@@ -73,7 +78,7 @@ class StudioConfig:
         config = read_global_config_value(STUDIO_CONFIG_KEY, unavailable_ok=True)
 
         if config is None:
-            return StudioConfig(None, None, None, None)
+            return StudioConfig(None, None, None, None, False)
 
         if not isinstance(config, dict):
             raise ValueError(
@@ -83,7 +88,7 @@ class StudioConfig:
             )
 
         for key in config:
-            if not isinstance(config[key], str):
+            if not isinstance(config[key], str) and key != DISABLE_VERIFY:
                 raise ValueError(
                     "Invalid config file format. "
                     f"Key '{key}' is not a text value."
@@ -102,6 +107,9 @@ class StudioConfig:
             studio_url=StudioConfig._read_env_value(RASA_STUDIO_CLI_STUDIO_URL_ENV),
             client_id=StudioConfig._read_env_value(RASA_STUDIO_CLI_CLIENT_ID_KEY_ENV),
             realm_name=StudioConfig._read_env_value(RASA_STUDIO_CLI_REALM_NAME_KEY_ENV),
+            disable_verify=bool(
+                os.getenv(RASA_STUDIO_CLI_DISABLE_VERIFY_KEY_ENV, False)
+            ),
         )
 
     @staticmethod
@@ -124,4 +132,5 @@ class StudioConfig:
             studio_url=self.studio_url or other.studio_url,
             client_id=self.client_id or other.client_id,
             realm_name=self.realm_name or other.realm_name,
+            disable_verify=self.disable_verify or other.disable_verify,
         )

rasa/studio/constants.py

@@ -10,6 +10,7 @@ RASA_STUDIO_AUTH_SERVER_URL_ENV = "RASA_STUDIO_AUTH_SERVER_URL"
 RASA_STUDIO_CLI_STUDIO_URL_ENV = "RASA_STUDIO_CLI_STUDIO_URL"
 RASA_STUDIO_CLI_REALM_NAME_KEY_ENV = "RASA_STUDIO_CLI_REALM_NAME_KEY"
 RASA_STUDIO_CLI_CLIENT_ID_KEY_ENV = "RASA_STUDIO_CLI_CLIENT_ID_KEY"
+RASA_STUDIO_CLI_DISABLE_VERIFY_KEY_ENV = "RASA_STUDIO_CLI_DISABLE_VERIFY_KEY"
 
 STUDIO_NLU_FILENAME = "studio_nlu.yml"
 STUDIO_DOMAIN_FILENAME = "studio_domain.yml"

rasa/studio/data_handler.py

@@ -76,7 +76,9 @@ class StudioDataHandler:
 
         return request
 
-    def _make_request(self, GQL_req: Dict[Any, Any]) -> Dict[Any, Any]:
+    def _make_request(
+        self, GQL_req: Dict[Any, Any], verify: bool = True
+    ) -> Dict[Any, Any]:
         token = KeycloakTokenReader().get_token()
         if token.is_expired():
             token = self.refresh_token(token)
@@ -93,6 +95,7 @@ class StudioDataHandler:
                 "Authorization": f"{token.token_type} {token.access_token}",
                 "Content-Type": "application/json",
             },
+            verify=verify,
         )
 
         if res.status_code != 200:
@@ -128,7 +131,9 @@ class StudioDataHandler:
             The data from Rasa Studio.
         """
         GQL_req = self._build_request()
-        response = self._make_request(GQL_req)
+        verify = not self.studio_config.disable_verify
+
+        response = self._make_request(GQL_req, verify=verify)
         self._extract_data(response)
 
     def request_data(
@@ -145,7 +150,9 @@ class StudioDataHandler:
             The data from Rasa Studio.
         """
         GQL_req = self._build_request(intent_names, entity_names)
-        response = self._make_request(GQL_req)
+        verify = not self.studio_config.disable_verify
+
+        response = self._make_request(GQL_req, verify=verify)
         self._extract_data(response)
 
     def get_config(self) -> Optional[str]:

rasa/studio/upload.py

@@ -56,29 +56,37 @@ def _get_selected_entities_and_intents(
 
 def handle_upload(args: argparse.Namespace) -> None:
     """Uploads primitives to rasa studio."""
-    endpoint = StudioConfig.read_config().studio_url
+    studio_config = StudioConfig.read_config()
+    endpoint = studio_config.studio_url
+    verify = not studio_config.disable_verify
+
     if not endpoint:
         rasa.shared.utils.cli.print_error_and_exit(
             "No GraphQL endpoint found in config. Please run `rasa studio config`."
         )
-    else:
-        structlogger.info(
-            "rasa.studio.upload.loading_data", event_info="Loading data..."
-        )
+        return
 
-        args.domain = rasa.cli.utils.get_validated_path(
-            args.domain, "domain", DEFAULT_DOMAIN_PATHS
+    if not is_auth_working(endpoint, verify):
+        rasa.shared.utils.cli.print_error_and_exit(
+            "Authentication is invalid or expired. Please run `rasa studio login`."
         )
+        return
 
-        args.config = rasa.cli.utils.get_validated_path(
-            args.config, "config", DEFAULT_CONFIG_PATH
-        )
+    structlogger.info("rasa.studio.upload.loading_data", event_info="Loading data...")
 
-        # check safely if args.calm is set and not fail if not
-        if hasattr(args, "calm") and args.calm:
-            upload_calm_assistant(args, endpoint)
-        else:
-            upload_nlu_assistant(args, endpoint)
+    args.domain = rasa.cli.utils.get_validated_path(
+        args.domain, "domain", DEFAULT_DOMAIN_PATHS
+    )
+
+    args.config = rasa.cli.utils.get_validated_path(
+        args.config, "config", DEFAULT_CONFIG_PATH
+    )
+
+    # check safely if args.calm is set and not fail if not
+    if hasattr(args, "calm") and args.calm:
+        upload_calm_assistant(args, endpoint, verify=verify)
+    else:
+        upload_nlu_assistant(args, endpoint, verify=verify)
 
 
 config_keys = [
@@ -121,12 +129,18 @@ def _get_assistant_name(config: Dict[Text, Any]) -> str:
             ),
         )
 
-    structlogger.info(f"Uploading assistant with the name '{assistant_name}'.")
+    structlogger.info(
+        "rasa.studio.upload.name_selected",
+        event_info=f"Uploading assistant with the name '{assistant_name}'.",
+        assistant_name=assistant_name,
+    )
     return assistant_name
 
 
 @with_studio_error_handler
-def upload_calm_assistant(args: argparse.Namespace, endpoint: str) -> StudioResult:
+def upload_calm_assistant(
+    args: argparse.Namespace, endpoint: str, verify: bool = True
+) -> StudioResult:
     """Uploads the CALM assistant data to Rasa Studio.
 
     Args:
@@ -215,12 +229,16 @@ def upload_calm_assistant(args: argparse.Namespace, endpoint: str) -> StudioResu
         nlu_yaml=nlu_examples_yaml,
     )
 
-    structlogger.info("Uploading to Rasa Studio...")
-    return make_request(endpoint, graphql_req)
+    structlogger.info(
+        "rasa.studio.upload.calm", event_info="Uploading to Rasa Studio..."
+    )
+    return make_request(endpoint, graphql_req, verify)
 
 
 @with_studio_error_handler
-def upload_nlu_assistant(args: argparse.Namespace, endpoint: str) -> StudioResult:
+def upload_nlu_assistant(
+    args: argparse.Namespace, endpoint: str, verify: bool = True
+) -> StudioResult:
     """Uploads the classic (dm1) assistant data to Rasa Studio.
 
     Args:
@@ -230,10 +248,14 @@ def upload_nlu_assistant(args: argparse.Namespace, endpoint: str) -> StudioResul
             - intents: The intents to upload
             - entities: The entities to upload
         endpoint: The studio endpoint
+        verify: Whether to verify SSL
     Returns:
         None
     """
-    structlogger.info("Found DM1 assistant data, parsing...")
+    structlogger.info(
+        "rasa.studio.upload.nlu_data_read",
+        event_info="Found DM1 assistant data, parsing...",
+    )
     importer = TrainingDataImporter.load_from_dict(
         domain_path=args.domain, training_data_paths=args.data, config_path=args.config
     )
@@ -250,7 +272,9 @@ def upload_nlu_assistant(args: argparse.Namespace, endpoint: str) -> StudioResul
 
     assistant_name = _get_assistant_name(config)
 
-    structlogger.info("Validating data...")
+    structlogger.info(
+        "rasa.studio.upload.nlu_data_validate", event_info="Validating data..."
+    )
     _check_for_missing_primitives(
         intents, entities, intents_from_files, entities_from_files
     )
@@ -267,16 +291,41 @@ def upload_nlu_assistant(args: argparse.Namespace, endpoint: str) -> StudioResul
 
     graphql_req = build_request(assistant_name, nlu_examples_yaml, domain_yaml)
 
-    structlogger.info("Uploading to Rasa Studio...")
-    return make_request(endpoint, graphql_req)
+    structlogger.info(
+        "rasa.studio.upload.nlu", event_info="Uploading to Rasa Studio..."
+    )
+    return make_request(endpoint, graphql_req, verify)
+
+
+def is_auth_working(endpoint: str, verify: bool = True) -> bool:
+    """Send a test request to Studio to check if auth is working."""
+    result = make_request(
+        endpoint,
+        {
+            "operationName": "LicenseDetails",
+            "query": (
+                "query LicenseDetails {\n"
+                "  licenseDetails {\n"
+                "    valid\n"
+                "    scopes\n"
+                "    __typename\n"
+                "  }\n"
+                "}"
+            ),
+            "variables": {},
+        },
+        verify,
+    )
+    return result.was_successful
 
 
-def make_request(endpoint: str, graphql_req: Dict) -> StudioResult:
+def make_request(endpoint: str, graphql_req: Dict, verify: bool = True) -> StudioResult:
     """Makes a request to the studio endpoint to upload data.
 
     Args:
         endpoint: The studio endpoint
         graphql_req: The graphql request
+        verify: Whether to verify SSL
     """
     token = KeycloakTokenReader().get_token()
     res = requests.post(
@@ -286,6 +335,7 @@ def make_request(endpoint: str, graphql_req: Dict) -> StudioResult:
             "Authorization": f"{token.token_type} {token.access_token}",
             "Content-Type": "application/json",
         },
+        verify=verify,
     )
 
     if results_logger.response_has_errors(res.json()):
@@ -301,7 +351,12 @@ def _add_missing_entities(
     for entity in entities_from_intents:
         if entity not in entities:
             structlogger.warning(
-                f"Adding entity '{entity}' to upload since it is used in an intent."
+                "rasa.studio.upload.adding_missing_entity",
+                event_info=(
+                    f"Adding entity '{entity}' to upload "
+                    "since it is used in an intent."
+                ),
+                entity=entity,
             )
             all_entities.append(entity)
     return all_entities