rasa-pro 3.12.21__py3-none-any.whl → 3.13.0__py3-none-any.whl

rasa/studio/upload.py

@@ -2,11 +2,12 @@ import argparse
 import base64
 import re
 import sys
-from typing import Any, Dict, Iterable, List, Set, Text, Tuple, Union
+from typing import Any, Dict, Iterable, List, Optional, Set, Text, Tuple, Union
 
 import questionary
 import requests
 import structlog
+from pydantic import BaseModel, Field
 
 import rasa.cli.telemetry
 import rasa.cli.utils
@@ -30,14 +31,17 @@ from rasa.shared.nlu.training_data.formats.rasa_yaml import (
     RasaYAMLReader,
     RasaYAMLWriter,
 )
+from rasa.shared.utils.llm import collect_custom_prompts
 from rasa.shared.utils.yaml import (
     dump_obj_as_yaml_to_string,
+    read_yaml,
     read_yaml_file,
 )
 from rasa.studio import results_logger
 from rasa.studio.auth import KeycloakTokenReader
 from rasa.studio.config import StudioConfig
 from rasa.studio.results_logger import StudioResult, with_studio_error_handler
+from rasa.studio.utils import validate_argument_paths
 from rasa.telemetry import track_upload_to_studio_failed
 
 structlogger = structlog.get_logger()
@@ -64,6 +68,16 @@ DOMAIN_KEYS = [
 ]
 
 
+class CALMImportParts(BaseModel):
+    """All pieces that will be uploaded to Rasa Studio."""
+
+    flows: Dict[str, Any]
+    domain: Dict[str, Any]
+    config: Dict[str, Any]
+    endpoints: Dict[str, Any]
+    nlu: Dict[str, Any] = Field(default_factory=dict)
+
+
 def _get_selected_entities_and_intents(
     args: argparse.Namespace,
     intents_from_files: Set[Text],
@@ -103,7 +117,7 @@ def run_validation(args: argparse.Namespace) -> None:
 
     training_data_importer = TrainingDataImporter.load_from_dict(
         domain_path=args.domain,
-        training_data_paths=args.data,
+        training_data_paths=[args.data],
         config_path=args.config,
         expand_env_vars=False,
     )
@@ -130,6 +144,7 @@ def run_validation(args: argparse.Namespace) -> None:
 
 def handle_upload(args: argparse.Namespace) -> None:
     """Uploads primitives to rasa studio."""
+    validate_argument_paths(args)
     studio_config = StudioConfig.read_config()
     endpoint = studio_config.studio_url
     verify = not studio_config.disable_verify
@@ -154,15 +169,19 @@ def handle_upload(args: argparse.Namespace) -> None:
         args.config, "config", DEFAULT_CONFIG_PATH
     )
 
+    config = read_yaml_file(args.config, expand_env_vars=False)
+    assistant_name = args.assistant_name or _get_assistant_name(config)
+    args.assistant_name = assistant_name
+    if not _handle_existing_assistant(
+        assistant_name, studio_config.studio_url, verify, args
+    ):
+        return
+
     Domain.expand_env_vars = False
     RasaYAMLReader.expand_env_vars = False
     YAMLFlowsReader.expand_env_vars = False
 
-    # 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)
+    upload_calm_assistant(args, endpoint, verify=verify)
 
 
 config_keys = [
@@ -212,75 +231,95 @@ def _get_assistant_name(config: Dict[Text, Any]) -> str:
     return assistant_name
 
 
-@with_studio_error_handler
-def upload_calm_assistant(
-    args: argparse.Namespace, endpoint: str, verify: bool = True
-) -> StudioResult:
-    """Validates and uploads the CALM assistant data to Rasa Studio.
+def build_calm_import_parts(
+    data_path: Union[Text, List[Text]],
+    domain_path: Text,
+    config_path: Text,
+    endpoints_path: Optional[Text] = None,
+    assistant_name: Optional[Text] = None,
+) -> Tuple[str, CALMImportParts]:
+    """Builds the parts of the assistant to be uploaded to Studio.
 
     Args:
-        args: The command line arguments
-            - data: The path to the training data
-            - domain: The path to the domain
-            - flows: The path to the flows
-            - endpoints: The path to the endpoints
-            - config: The path to the config
-        endpoint: The studio endpoint
+        data_path: The path to the training data
+        domain_path: The path to the domain
+        config_path: The path to the config
+        endpoints_path: The path to the endpoints
+        assistant_name: The name of the assistant
+
     Returns:
-        None
+        The assistant name and the parts to be uploaded
     """
-    run_validation(args)
-
-    structlogger.info(
-        "rasa.studio.upload.loading_data", event_info="Parsing CALM assistant data..."
-    )
-
     importer = TrainingDataImporter.load_from_dict(
-        domain_path=args.domain,
-        config_path=args.config,
+        domain_path=domain_path,
+        config_path=config_path,
         expand_env_vars=False,
     )
 
-    # Prepare config and domain
-    config = importer.get_config()
-    assistant_name = _get_assistant_name(config)
-    config_from_files = read_yaml_file(args.config, expand_env_vars=False)
-    domain_from_files = importer.get_user_domain().as_dict()
+    config = read_yaml_file(config_path, expand_env_vars=False)
+    endpoints = read_yaml_file(endpoints_path, expand_env_vars=False)
+    assistant_name = assistant_name or _get_assistant_name(config)
 
-    # Extract domain and config values
+    domain_from_files = importer.get_user_domain().as_dict()
     domain = extract_values(domain_from_files, DOMAIN_KEYS)
 
-    # Prepare flows
     flow_importer = FlowSyncImporter.load_from_dict(
-        training_data_paths=args.data, expand_env_vars=False
+        training_data_paths=[str(data_path)], expand_env_vars=False
     )
+
     flows = list(flow_importer.get_user_flows())
+    flows_yaml = YamlFlowsWriter().dumps(flows)
+    flows = read_yaml(flows_yaml, expand_env_vars=False)
 
-    # We instantiate the TrainingDataImporter again on purpose to avoid
-    # adding patterns to domain's actions. More info https://t.ly/W8uuc
     nlu_importer = TrainingDataImporter.load_from_dict(
-        training_data_paths=args.data, expand_env_vars=False
+        training_data_paths=[str(data_path)], expand_env_vars=False
     )
     nlu_data = nlu_importer.get_nlu_data()
     nlu_examples = nlu_data.filter_training_examples(
         lambda ex: ex.get("intent") in nlu_data.intents
     )
     nlu_examples_yaml = RasaYAMLWriter().dumps(nlu_examples)
+    nlu = read_yaml(nlu_examples_yaml, expand_env_vars=False)
+
+    parts = CALMImportParts(
+        flows=flows,
+        domain=domain,
+        config=config,
+        endpoints=endpoints,
+        nlu=nlu,
+    )
+
+    return assistant_name, parts
+
+
+@with_studio_error_handler
+def upload_calm_assistant(
+    args: argparse.Namespace, endpoint: str, verify: bool = True
+) -> StudioResult:
+    def yaml_or_empty(part: Dict[Text, Any]) -> Optional[str]:
+        return dump_obj_as_yaml_to_string(part) if part else None
 
-    # Prepare endpoints
-    endpoints_from_files = read_yaml_file(args.endpoints, expand_env_vars=False)
-    endpoints_str = dump_obj_as_yaml_to_string(
-        endpoints_from_files, transform=remove_quotes
+    run_validation(args)
+    structlogger.info(
+        "rasa.studio.upload.loading_data", event_info="Parsing CALM assistant data..."
+    )
+    assistant_name, parts = build_calm_import_parts(
+        data_path=args.data,
+        domain_path=args.domain,
+        config_path=args.config,
+        endpoints_path=args.endpoints,
+        assistant_name=args.assistant_name,
     )
 
-    # Build GraphQL request
+    prompts_json = collect_custom_prompts(parts.config, parts.endpoints)
     graphql_req = build_import_request(
         assistant_name,
-        flows_yaml=YamlFlowsWriter().dumps(flows),
-        domain_yaml=dump_obj_as_yaml_to_string(domain),
-        config_yaml=dump_obj_as_yaml_to_string(config_from_files),
-        endpoints=endpoints_str,
-        nlu_yaml=nlu_examples_yaml,
+        flows_yaml=yaml_or_empty(parts.flows),
+        domain_yaml=yaml_or_empty(parts.domain),
+        config_yaml=yaml_or_empty(parts.config),
+        endpoints=yaml_or_empty(parts.endpoints),
+        nlu_yaml=yaml_or_empty(parts.nlu),
+        prompts_json=prompts_json,
     )
 
     structlogger.info(
@@ -312,7 +351,7 @@ def upload_nlu_assistant(
     )
     importer = TrainingDataImporter.load_from_dict(
         domain_path=args.domain,
-        training_data_paths=args.data,
+        training_data_paths=[args.data],
         config_path=args.config,
         expand_env_vars=False,
     )
@@ -395,7 +434,6 @@ def make_request(endpoint: str, graphql_req: Dict, verify: bool = True) -> Studi
         },
         verify=verify,
     )
-
     if results_logger.response_has_errors(res.json()):
         track_upload_to_studio_failed(res.json())
         return StudioResult.error(res.json())
@@ -423,39 +461,69 @@ def _add_missing_entities(
 
 def build_import_request(
     assistant_name: str,
-    flows_yaml: str,
-    domain_yaml: str,
-    config_yaml: str,
-    endpoints: str,
-    nlu_yaml: str = "",
+    flows_yaml: Optional[str] = None,
+    domain_yaml: Optional[str] = None,
+    config_yaml: Optional[str] = None,
+    endpoints: Optional[str] = None,
+    nlu_yaml: Optional[str] = None,
+    prompts_json: Optional[Dict[str, str]] = None,
 ) -> Dict:
-    # b64encode expects bytes and returns bytes so we need to decode to string
-    base64_domain = base64.b64encode(domain_yaml.encode("utf-8")).decode("utf-8")
-    base64_flows = base64.b64encode(flows_yaml.encode("utf-8")).decode("utf-8")
-    base64_config = base64.b64encode(config_yaml.encode("utf-8")).decode("utf-8")
-    base64_nlu = base64.b64encode(nlu_yaml.encode("utf-8")).decode("utf-8")
-    base64_endpoints = base64.b64encode(endpoints.encode("utf-8")).decode("utf-8")
+    """Builds the GraphQL request for uploading a modern assistant.
+
+    Args:
+        assistant_name: The name of the assistant
+        flows_yaml: The YAML representation of the flows
+        domain_yaml: The YAML representation of the domain
+        config_yaml: The YAML representation of the config
+        endpoints: The YAML representation of the endpoints
+        nlu_yaml: The YAML representation of the NLU data
+        prompts_json: The JSON representation of the prompts
+
+    Returns:
+        A dictionary representing the GraphQL request for uploading the assistant.
+    """
+    inputs_map = {
+        "domain": domain_yaml,
+        "flows": flows_yaml,
+        "config": config_yaml,
+        "endpoints": endpoints,
+        "nlu": nlu_yaml,
+    }
+
+    payload: Dict[Text, Any] = {
+        field: convert_string_to_base64(value)
+        for field, value in inputs_map.items()
+        if value is not None
+    }
+
+    if prompts_json:
+        payload["prompts"] = prompts_json
+
+    variables_input = {"assistantName": assistant_name, **payload}
 
     graphql_req = {
         "query": (
             "mutation UploadModernAssistant($input: UploadModernAssistantInput!)"
             "{\n  uploadModernAssistant(input: $input)\n}"
         ),
-        "variables": {
-            "input": {
-                "assistantName": assistant_name,
-                "domain": base64_domain,
-                "flows": base64_flows,
-                "nlu": base64_nlu,
-                "config": base64_config,
-                "endpoints": base64_endpoints,
-            }
-        },
+        "variables": {"input": variables_input},
     }
 
     return graphql_req
 
 
+def convert_string_to_base64(string: str) -> str:
+    """Converts a string to base64.
+
+    Args:
+        string: The string to convert
+
+    Returns:
+        The base64 encoded string
+    """
+    return base64.b64encode(string.encode("utf-8")).decode("utf-8")
+
+
 def build_request(
     assistant_name: str, nlu_examples_yaml: str, domain_yaml: str
 ) -> Dict:
@@ -563,3 +631,106 @@ def remove_quotes(node: Any) -> Any:
         return {k: remove_quotes(v) for k, v in node.items()}
     else:
         return node
+
+
+def check_if_assistant_already_exists(
+    assistant_name: str, endpoint: str, verify: bool = True
+) -> bool:
+    """Checks if the assistant already exists in Studio.
+
+    Args:
+        assistant_name: The name of the assistant
+        endpoint: The studio endpoint
+        verify: Whether to verify SSL
+
+    Returns:
+        bool: The upload confirmation
+    """
+    graphql_req = build_get_assistant_by_name_request(assistant_name)
+
+    structlogger.info(
+        "rasa.studio.upload.assistant_already_exists",
+        event_info="Checking if assistant already exists...",
+        assistant_name=assistant_name,
+    )
+
+    token = KeycloakTokenReader().get_token()
+    res = requests.post(
+        endpoint,
+        json=graphql_req,
+        headers={
+            "Authorization": f"{token.token_type} {token.access_token}",
+            "Content-Type": "application/json",
+        },
+        verify=verify,
+    )
+    response = res.json()["data"]["assistantByName"] or {}
+    if results_logger.response_has_id(response):
+        structlogger.info(
+            "rasa.studio.upload.assistant_already_exists",
+            event_info="Assistant already exists.",
+        )
+        return True
+
+    structlogger.info(
+        "rasa.studio.upload.assistant_already_exists", event_info="Assistant not found."
+    )
+    return False
+
+
+def build_get_assistant_by_name_request(
+    assistant_name: str,
+) -> Dict:
+    graphql_req = {
+        "query": (
+            "query AssistantByName($input: AssistantByNameInput!) {"
+            " assistantByName(input: $input) {"
+            " ... on Assistant { id name mode }"
+            " ... on AssistantByName_AssistantNotFound { _ }"
+            " }"
+            "}"
+        ),
+        "variables": {
+            "input": {
+                "assistantName": assistant_name,
+            }
+        },
+    }
+    return graphql_req
+
+
+def _handle_existing_assistant(
+    assistant_name: str,
+    endpoint: str,
+    verify: bool,
+    args: argparse.Namespace,
+) -> bool:
+    """Deal with the case that an assistant with the same name already exists.
+
+    Args:
+        assistant_name: The name of the assistant
+        endpoint: The studio endpoint
+        verify: Whether to verify SSL
+        args: The command line arguments
+
+    Returns:
+        bool: True if the assistant does not exist and can be created,
+              False if the assistant already exists and was linked.
+    """
+    from rasa.studio.link import handle_link
+
+    if not check_if_assistant_already_exists(assistant_name, endpoint, verify):
+        return True
+
+    should_link = questionary.confirm(
+        f"An assistant named {assistant_name} already exists in Studio. "
+        f"Would you like to link your local project to this existing assistant?"
+    ).ask()
+
+    if not should_link:
+        rasa.shared.utils.cli.print_error_and_exit("Upload cancelled.")
+        return False
+
+    args.assistant_name = assistant_name
+    handle_link(args)
+    return False

rasa/studio/utils.py

@@ -0,0 +1,33 @@
+import argparse
+from pathlib import Path
+
+import rasa.shared.utils.cli
+from rasa.shared.constants import (
+    DEFAULT_CONFIG_PATH,
+    DEFAULT_DATA_PATH,
+    DEFAULT_ENDPOINTS_PATH,
+)
+from rasa.studio.constants import DOMAIN_FILENAME
+
+
+def validate_argument_paths(args: argparse.Namespace) -> None:
+    """Validates the paths provided in the command line arguments.
+
+    Args:
+        args: The command line arguments containing paths to validate.
+    """
+
+    def validate_path(arg_name: str, default: str) -> None:
+        path_value = getattr(args, arg_name, None)
+        if path_value and path_value != default:
+            resolved_path = Path(path_value).resolve()
+            if not resolved_path.exists():
+                rasa.shared.utils.cli.print_error_and_exit(
+                    f"{arg_name.capitalize()} file or directory "
+                    f"'{path_value}' does not exist."
+                )
+
+    validate_path("domain", DOMAIN_FILENAME)
+    validate_path("config", DEFAULT_CONFIG_PATH)
+    validate_path("endpoints", DEFAULT_ENDPOINTS_PATH)
+    validate_path("data", DEFAULT_DATA_PATH)

rasa/telemetry.py

@@ -23,7 +23,6 @@ import structlog
 from terminaltables import SingleTable
 
 import rasa
-import rasa.anonymization.utils
 import rasa.shared.utils.io
 import rasa.utils.io
 from rasa import model
@@ -34,6 +33,7 @@ from rasa.constants import (
     CONFIG_TELEMETRY_ID,
 )
 from rasa.engine.storage.local_model_storage import LocalModelStorage
+from rasa.privacy.privacy_config import AnonymizationType, PrivacyConfig
 from rasa.shared.constants import (
     ASSISTANT_ID_KEY,
     CONFIG_LANGUAGE_KEY,
@@ -62,10 +62,10 @@ from rasa.utils import common as rasa_utils
 
 if typing.TYPE_CHECKING:
     from rasa.core.agent import Agent
+    from rasa.core.available_endpoints import AvailableEndpoints
     from rasa.core.brokers.broker import EventBroker
     from rasa.core.channels.channel import InputChannel
-    from rasa.core.tracker_store import TrackerStore
-    from rasa.core.utils import AvailableEndpoints
+    from rasa.core.tracker_stores.tracker_store import TrackerStore
     from rasa.e2e_test.e2e_test_case import Fixture, Metadata, TestCase
     from rasa.shared.importers.importer import TrainingDataImporter
     from rasa.shared.nlu.training_data.training_data import TrainingData
@@ -149,6 +149,7 @@ TELEMETRY_ENTERPRISE_SEARCH_POLICY_TRAINING_COMPLETED_EVENT = (
 TELEMETRY_ENTERPRISE_SEARCH_POLICY_PREDICT_EVENT = "Enterprise Search Policy Predicted"
 TELEMETRY_VALIDATION_ERROR_LOG_EVENT = "Validation Error Logged"
 TELEMETRY_UPLOAD_TO_STUDIO_FAILED_EVENT = "Upload to Studio Failed"
+TELEMETRY_PRIVACY_ENABLED_EVENT = "PII Management in CALM Enabled"
 
 # licensing events
 TELEMETRY_CONVERSATION_COUNT = "Conversation Count"
@@ -1129,6 +1130,7 @@ def _get_llm_command_generator_config(config: Dict[str, Any]) -> Optional[Dict]:
         LLMBasedCommandGenerator,
         LLMCommandGenerator,
         MultiStepLLMCommandGenerator,
+        SearchReadyLLMCommandGenerator,
         SingleStepLLMCommandGenerator,
     )
     from rasa.dialogue_understanding.generator.constants import (
@@ -1156,6 +1158,7 @@ def _get_llm_command_generator_config(config: Dict[str, Any]) -> Optional[Dict]:
                 SingleStepLLMCommandGenerator.__name__,
                 MultiStepLLMCommandGenerator.__name__,
                 CompactLLMCommandGenerator.__name__,
+                SearchReadyLLMCommandGenerator.__name__,
             ]:
                 return component
         return None
@@ -1167,6 +1170,7 @@ def _get_llm_command_generator_config(config: Dict[str, Any]) -> Optional[Dict]:
             SingleStepLLMCommandGenerator.__name__: SingleStepLLMCommandGenerator,
             MultiStepLLMCommandGenerator.__name__: MultiStepLLMCommandGenerator,
             CompactLLMCommandGenerator.__name__: CompactLLMCommandGenerator,
+            SearchReadyLLMCommandGenerator.__name__: SearchReadyLLMCommandGenerator,
         }
         llm_config = component.get(LLM_CONFIG_KEY, {})
         # Config at this stage is not yet resolved, so read from `model_group`
@@ -1353,7 +1357,7 @@ def track_server_start(
         number_of_workers: number of used Sanic workers
         is_api_enabled: whether the rasa API server is enabled
     """
-    from rasa.core.utils import AvailableEndpoints
+    from rasa.core.available_endpoints import AvailableEndpoints
 
     def project_fingerprint_and_assistant_id_from_model(
         _model_directory: Optional[Text],
@@ -1745,7 +1749,6 @@ def identify_endpoint_config_traits(
 
     traits = append_tracing_trait(traits, endpoints_file)
     traits = append_metrics_trait(traits, endpoints_file)
-    traits = append_anonymization_trait(traits, endpoints_file)
 
     _identify(traits, context)
 
@@ -1784,27 +1787,6 @@ def append_metrics_trait(
     return traits
 
 
-def append_anonymization_trait(
-    traits: Dict[str, Any], endpoints_file: Optional[str]
-) -> Dict[str, Any]:
-    """Append the anonymization trait to the traits dictionary."""
-    from rasa.anonymization.anonymisation_rule_yaml_reader import (
-        KEY_ANONYMIZATION_RULES,
-    )
-
-    anonymization_config = rasa.anonymization.utils.read_endpoint_config(
-        endpoints_file, 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."""
@@ -1821,6 +1803,7 @@ def track_enterprise_search_policy_train_completed(
     llm_model: Optional[str],
     llm_model_group_id: Optional[str],
     citation_enabled: Optional[bool],
+    relevancy_check_enabled: Optional[bool],
 ) -> None:
     """Track when a user completes training Enterprise Search policy."""
     _track(
@@ -1834,6 +1817,7 @@ def track_enterprise_search_policy_train_completed(
             "llm_model": llm_model,
             "llm_model_group_id": llm_model_group_id,
             "citation_enabled": citation_enabled,
+            "relevancy_check_enabled": relevancy_check_enabled,
         },
     )
 
@@ -1848,6 +1832,7 @@ def track_enterprise_search_policy_predict(
     llm_model: Optional[str],
     llm_model_group_id: Optional[str],
     citation_enabled: Optional[bool],
+    relevancy_check_enabled: Optional[bool],
 ) -> None:
     """Track when a user predicts the next action using Enterprise Search policy."""
     _track(
@@ -1861,6 +1846,7 @@ def track_enterprise_search_policy_predict(
             "llm_model": llm_model,
             "llm_model_group_id": llm_model_group_id,
             "citation_enabled": citation_enabled,
+            "relevancy_check_enabled": relevancy_check_enabled,
         },
     )
 
@@ -1946,3 +1932,74 @@ def track_upload_to_studio_failed(response_json: Dict[str, Any]) -> None:
         TELEMETRY_UPLOAD_TO_STUDIO_FAILED_EVENT,
         {"studio_response_json": response_json},
     )
+
+
+def _extract_privacy_enabled_event_properties(
+    privacy_config: "PrivacyConfig",
+    stream_pii: bool,
+) -> Dict[str, Any]:
+    """Extract properties when PII management is enabled."""
+    number_of_total_rules = len(privacy_config.anonymization_rules)
+    count_of_redact = sum(
+        1
+        for rule in privacy_config.anonymization_rules.values()
+        if rule.method_type == AnonymizationType.REDACT
+    )
+    count_of_mask = sum(
+        1
+        for rule in privacy_config.anonymization_rules.values()
+        if rule.method_type == AnonymizationType.MASK
+    )
+
+    tracker_store_anonymization_enabled = (
+        privacy_config.tracker_store_settings is not None
+        and privacy_config.tracker_store_settings.anonymization_policy is not None
+    )
+    anonymization_cron_trigger = (
+        privacy_config.tracker_store_settings.anonymization_policy.cron  # type: ignore[union-attr]
+        if tracker_store_anonymization_enabled
+        else None
+    )
+
+    tracker_store_deletion_enabled = (
+        privacy_config.tracker_store_settings is not None
+        and privacy_config.tracker_store_settings.deletion_policy is not None
+    )
+
+    deletion_cron_trigger = (
+        privacy_config.tracker_store_settings.deletion_policy.cron  # type: ignore[union-attr]
+        if tracker_store_deletion_enabled
+        else None
+    )
+
+    return {
+        "num_total_rules": number_of_total_rules,
+        "redact_count": count_of_redact,
+        "mask_count": count_of_mask,
+        "stream_pii": stream_pii,
+        "tracker_store_anonymization_enabled": tracker_store_anonymization_enabled,
+        "tracker_store_deletion_enabled": tracker_store_deletion_enabled,
+        "anonymization_cron_trigger": str(anonymization_cron_trigger),
+        "deletion_cron_trigger": str(deletion_cron_trigger),
+    }
+
+
+def _extract_stream_pii(event_broker: Optional["EventBroker"]) -> bool:
+    """Extract whether un-anonymized PII streaming is enabled for the event broker."""
+    return (
+        event_broker.stream_pii
+        if event_broker is not None and hasattr(event_broker, "stream_pii")
+        else False
+    )
+
+
+@ensure_telemetry_enabled
+def track_privacy_enabled(
+    privacy_config: "PrivacyConfig", event_broker: Optional["EventBroker"]
+) -> None:
+    """Track when PII management capability is enabled"""
+    stream_pii = _extract_stream_pii(event_broker)
+    privacy_properties = _extract_privacy_enabled_event_properties(
+        privacy_config, stream_pii
+    )
+    _track(TELEMETRY_PRIVACY_ENABLED_EVENT, privacy_properties)