ethyca-fides 2.69.3b1__py2.py3-none-any.whl → 2.70.0rc0__py2.py3-none-any.whl

fides/api/models/event_audit.py

@@ -0,0 +1,68 @@
+"""EventAudit model and related enums for comprehensive audit logging."""
+
+from enum import Enum as EnumType
+
+from sqlalchemy import Column, String, Text
+from sqlalchemy.dialects.postgresql import JSONB
+from sqlalchemy.ext.declarative import declared_attr
+
+from fides.api.db.base_class import Base
+from fides.api.db.util import EnumColumn
+
+
+class EventAuditType(str, EnumType):
+    """Hierarchical event types for audit logging - variable depth as needed."""
+
+    # System
+    system_updated = "system.updated"
+
+    # System group
+    system_group_created = "system_group.created"
+    system_group_updated = "system_group.updated"
+    system_group_deleted = "system_group.deleted"
+
+    # Taxonomy
+    taxonomy_created = "taxonomy.created"
+    taxonomy_updated = "taxonomy.updated"
+    taxonomy_deleted = "taxonomy.deleted"
+    taxonomy_usage_updated = "taxonomy.usage.updated"
+    taxonomy_usage_deleted = "taxonomy.usage.deleted"
+    taxonomy_element_created = "taxonomy.element.created"
+    taxonomy_element_updated = "taxonomy.element.updated"
+    taxonomy_element_deleted = "taxonomy.element.deleted"
+
+
+class EventAuditStatus(str, EnumType):
+    """Status enum for event audit logging."""
+
+    succeeded = "succeeded"
+    failed = "failed"
+
+
+class EventAudit(Base):
+    """Audit log for significant business events across the Fides platform."""
+
+    @declared_attr
+    def __tablename__(cls) -> str:
+        return "event_audit"
+
+    # Uses EventAuditType values but left as String to avoid future migrations
+    event_type = Column(String, index=True, nullable=False)
+    user_id = Column(String, nullable=True, index=True)
+
+    # Resource information
+    resource_type = Column(String, nullable=True, index=True)
+    resource_identifier = Column(String, nullable=True, index=True)
+
+    # User-friendly description of event
+    description = Column(Text, nullable=True)
+
+    # Structured data about event
+    event_details = Column(JSONB, nullable=True)
+
+    # Status of the event
+    status = Column(
+        EnumColumn(EventAuditStatus),
+        index=True,
+        nullable=False,
+    )

fides/api/models/messaging.py

@@ -1,10 +1,11 @@
 from __future__ import annotations
 
+from datetime import datetime
 from typing import Dict, Optional, Type, Union
 
 from loguru import logger
 from pydantic import ValidationError
-from sqlalchemy import Column, Enum, String
+from sqlalchemy import Boolean, Column, DateTime, Enum, String
 from sqlalchemy.dialects.postgresql import JSONB
 from sqlalchemy.ext.mutable import MutableDict
 from sqlalchemy.orm import Session
@@ -18,17 +19,18 @@ from fides.api.db.base_class import Base, JSONTypeOverride
 from fides.api.schemas.messaging.messaging import (
     EMAIL_MESSAGING_SERVICES,
     SMS_MESSAGING_SERVICES,
-    SUPPORTED_MESSAGING_SERVICE_SECRETS,
+    MessagingConnectionTestStatus,
     MessagingMethod,
+    MessagingServiceType,
+)
+from fides.api.schemas.messaging.shared_schemas import (
+    SUPPORTED_MESSAGING_SERVICE_SECRETS,
     MessagingServiceSecretsAWS_SES,
     MessagingServiceSecretsMailchimpTransactional,
     MessagingServiceSecretsMailgun,
     MessagingServiceSecretsTwilioEmail,
     MessagingServiceSecretsTwilioSMS,
-    MessagingServiceType,
-)
-from fides.api.schemas.messaging.messaging_secrets_docs_only import (
-    possible_messaging_secrets,
+    PossibleMessagingSecrets,
 )
 from fides.api.util.logger import Pii
 from fides.config import CONFIG
@@ -48,7 +50,7 @@ def get_messaging_method(
 
 def get_schema_for_secrets(
     service_type: MessagingServiceType,
-    secrets: possible_messaging_secrets,
+    secrets: PossibleMessagingSecrets,
 ) -> SUPPORTED_MESSAGING_SERVICE_SECRETS:
     """
     Returns the secrets that pertain to `service_type` represented as a Pydantic schema
@@ -87,6 +89,8 @@ class MessagingConfig(Base):
         Enum(MessagingServiceType), index=True, unique=True, nullable=False
     )
     details = Column(MutableDict.as_mutable(JSONB), nullable=True)
+    last_test_timestamp = Column(DateTime(timezone=True))
+    last_test_succeeded = Column(Boolean)
     secrets = Column(
         MutableDict.as_mutable(
             StringEncryptedType(
@@ -136,7 +140,7 @@ class MessagingConfig(Base):
         self,
         *,
         db: Session,
-        messaging_secrets: possible_messaging_secrets,
+        messaging_secrets: PossibleMessagingSecrets,
     ) -> None:
         """Creates or updates secrets associated with a config id"""
 
@@ -185,6 +189,18 @@ class MessagingConfig(Base):
                 f"Unknown notification_service_type {active_default_messaging_type} configured"
             )
 
+    def update_test_status(
+        self, test_status: MessagingConnectionTestStatus, db: Session
+    ) -> None:
+        """
+        Updates last_test_timestamp and last_test_succeeded after an attempt to send a test message.
+        """
+        self.last_test_timestamp = datetime.now()
+        self.last_test_succeeded = (
+            test_status == MessagingConnectionTestStatus.succeeded
+        )
+        self.save(db)
+
 
 def default_messaging_config_name(service_type: str) -> str:
     """
@@ -192,7 +208,7 @@ def default_messaging_config_name(service_type: str) -> str:
 
     Returns a name to be used in a default messaging config for the given type.
     """
-    return f"Default Messaging Config [{service_type}]"
+    return MessagingServiceType(service_type).human_readable
 
 
 def default_messaging_config_key(service_type: str) -> str:
@@ -201,4 +217,8 @@ def default_messaging_config_key(service_type: str) -> str:
 
     Returns a key to be used in a default messaging config for the given type.
     """
-    return f"default_messaging_config_{service_type.lower()}"
+    # Historically, when a key was not supplied, the service type string itself
+    # was used as the key (e.g. "mailgun").  Reverting to that behaviour keeps
+    # backward-compatibility with existing tests and API consumers that may rely
+    # on this convention.
+    return service_type.lower()

fides/api/models/taxonomy.py

@@ -85,10 +85,17 @@ class Taxonomy(Base, FidesBase):
             raise ValidationError(
                 f"Cannot create taxonomy '{fides_key}'. This is a taxonomy managed by the system."
             )
-        applies_to = data.pop("applies_to", [])
+        applies_to = data.get("applies_to", [])
+
+        # Create a copy of data without applies_to to avoid modifying the input
+        data_without_applies_to = {
+            key: value for key, value in data.items() if key != "applies_to"
+        }
 
         # Create the taxonomy
-        taxonomy: Taxonomy = super().create(db=db, data=data, check_name=check_name)
+        taxonomy: Taxonomy = super().create(
+            db=db, data=data_without_applies_to, check_name=check_name
+        )
 
         # Reconcile allowed usages if applies_to was provided
         if applies_to:
@@ -98,10 +105,15 @@ class Taxonomy(Base, FidesBase):
 
     def update(self, db: Session, *, data: Dict[str, Any]) -> "Taxonomy":
         """Update a Taxonomy with proper handling of applies_to."""
-        applies_to = data.pop("applies_to", None)
+        applies_to = data.get("applies_to", None)
+
+        # Create a copy of data without applies_to to avoid modifying the input
+        data_without_applies_to = {
+            key: value for key, value in data.items() if key != "applies_to"
+        }
 
         # Update the base fields
-        super().update(db=db, data=data)
+        super().update(db=db, data=data_without_applies_to)
 
         # If applies_to was provided, reconcile allowed usages
         if applies_to is not None:

fides/api/schemas/application_config.py

@@ -53,8 +53,11 @@ class NotificationApplicationConfig(FidesSchema):
 
     @field_validator("notification_service_type", mode="before")
     @classmethod
-    def validate_notification_service_type(cls, value: str) -> Optional[str]:
+    def validate_notification_service_type(cls, value: Optional[str]) -> Optional[str]:
         """Ensure the provided type is a valid value."""
+        if value is None:
+            return None  # Allow None values for disabling messaging
+
         value = value.lower()  # force lowercase for safety
         try:
             MessagingServiceType[value]

fides/api/schemas/messaging/messaging.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from datetime import datetime
 from enum import Enum
 from typing import Any, Dict, List, Optional, Tuple, Type, Union
 
@@ -7,15 +8,14 @@ from fideslang.default_taxonomy import DEFAULT_TAXONOMY
 from fideslang.validation import FidesKey
 from pydantic import BaseModel, ConfigDict, Field, model_validator
 
-from fides.api.custom_types import PhoneNumber, SafeStr
+from fides.api.custom_types import SafeStr
 from fides.api.schemas import Msg
 from fides.api.schemas.api import BulkResponse, BulkUpdateFailed
-from fides.api.schemas.connection_configuration.connection_secrets_base_aws import (
-    BaseAWSSchema,
-)
+from fides.api.schemas.messaging.shared_schemas import PossibleMessagingSecrets
 from fides.api.schemas.privacy_preference import MinimalPrivacyPreferenceHistorySchema
 from fides.api.schemas.privacy_request import Consent
 from fides.api.schemas.property import MinimalProperty
+from fides.api.schemas.redis_cache import IdentityBase
 
 
 class MessagingMethod(Enum):
@@ -44,6 +44,25 @@ class MessagingServiceType(Enum):
                 return member
         return None
 
+    @property
+    def human_readable(self) -> str:
+        """
+        Human-readable mapping for MessagingServiceType
+        """
+        readable_mapping: Dict[str, str] = {
+            MessagingServiceType.mailgun.value: "Mailgun",
+            MessagingServiceType.twilio_text.value: "Twilio SMS",
+            MessagingServiceType.twilio_email.value: "Twilio Email",
+            MessagingServiceType.mailchimp_transactional.value: "Mailchimp Transactional",
+            MessagingServiceType.aws_ses.value: "AWS SES",
+        }
+        try:
+            return readable_mapping[self.value]
+        except KeyError:
+            raise NotImplementedError(
+                "Add new MessagingServiceType to human_readable mapping"
+            )
+
 
 EMAIL_MESSAGING_SERVICES: Tuple[str, ...] = (
     MessagingServiceType.mailgun.value,
@@ -85,6 +104,12 @@ CONFIGURABLE_MESSAGING_ACTION_TYPES: Tuple[str, ...] = (
 )
 
 
+class MessagingTestBodyParams(BaseModel):
+    """Body params required for testing messaging service"""
+
+    to_identity: IdentityBase
+
+
 class ErrorNotificationBodyParams(BaseModel):
     """Body params required for privacy request error notifications."""
 
@@ -339,56 +364,6 @@ class MessagingServiceSecrets(Enum):
     AWS_ASSUME_ROLE_ARN = "aws_assume_role_arn"
 
 
-class MessagingServiceSecretsMailchimpTransactional(BaseModel):
-    """The secrets required to connect to Mailchimp Transactional."""
-
-    mailchimp_transactional_api_key: str
-    model_config = ConfigDict(extra="forbid")
-
-
-class MessagingServiceSecretsMailgun(BaseModel):
-    """The secrets required to connect to Mailgun."""
-
-    mailgun_api_key: str
-    model_config = ConfigDict(extra="forbid")
-
-
-class MessagingServiceSecretsTwilioSMS(BaseModel):
-    """The secrets required to connect to Twilio SMS."""
-
-    twilio_account_sid: str
-    twilio_auth_token: str
-    twilio_messaging_service_sid: Optional[str] = None
-    twilio_sender_phone_number: Optional[PhoneNumber] = None
-    model_config = ConfigDict(extra="forbid")
-
-    @model_validator(mode="before")
-    @classmethod
-    def validate_fields(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        sender_phone = values.get("twilio_sender_phone_number")
-        if not values.get("twilio_messaging_service_sid") and not sender_phone:
-            raise ValueError(
-                "Either the twilio_messaging_service_sid or the twilio_sender_phone_number should be supplied."
-            )
-        return values
-
-
-class MessagingServiceSecretsTwilioEmail(BaseModel):
-    """The secrets required to connect to twilio email."""
-
-    twilio_api_key: str
-    model_config = ConfigDict(extra="forbid")
-
-
-class MessagingServiceSecretsAWS_SES(BaseAWSSchema):
-    """
-    The secrets required to connect to AWS SES.
-    Inherits basic AWS authentication schema.
-    """
-
-    model_config = ConfigDict(extra="forbid")
-
-
 class MessagingConfigBase(BaseModel):
     """Base model shared by messaging config related models"""
 
@@ -453,8 +428,9 @@ class MessagingConfigRequestBase(MessagingConfigBase):
 class MessagingConfigRequest(MessagingConfigRequestBase):
     """Messaging Config Request Schema"""
 
-    name: str
+    name: Optional[str] = None
     key: Optional[FidesKey] = None
+    secrets: Optional[PossibleMessagingSecrets] = None
 
 
 class MessagingConfigResponse(MessagingConfigBase):
@@ -462,16 +438,8 @@ class MessagingConfigResponse(MessagingConfigBase):
 
     name: str
     key: FidesKey
-    model_config = ConfigDict(from_attributes=True, use_enum_values=True)
-
-
-SUPPORTED_MESSAGING_SERVICE_SECRETS = Union[
-    MessagingServiceSecretsMailgun,
-    MessagingServiceSecretsTwilioSMS,
-    MessagingServiceSecretsTwilioEmail,
-    MessagingServiceSecretsMailchimpTransactional,
-    MessagingServiceSecretsAWS_SES,
-]
+    last_test_timestamp: Optional[datetime] = None
+    last_test_succeeded: Optional[bool] = None
 
 
 class MessagingConnectionTestStatus(Enum):
@@ -479,7 +447,6 @@ class MessagingConnectionTestStatus(Enum):
 
     succeeded = "succeeded"
     failed = "failed"
-    skipped = "skipped"
 
 
 class TestMessagingStatusMessage(Msg):

fides/api/schemas/messaging/messaging_secrets_docs_only.py

@@ -1,7 +1,7 @@
 from typing import Union
 
 from fides.api.schemas.base_class import NoValidationSchema
-from fides.api.schemas.messaging.messaging import (
+from fides.api.schemas.messaging.shared_schemas import (
     MessagingServiceSecretsAWS_SES,
     MessagingServiceSecretsMailchimpTransactional,
     MessagingServiceSecretsMailgun,

fides/api/schemas/messaging/shared_schemas.py

@@ -0,0 +1,102 @@
+from typing import Any, Dict, Optional, Union
+
+from pydantic import BaseModel, ConfigDict, model_validator
+
+from fides.api.custom_types import PhoneNumber
+from fides.api.schemas.base_class import NoValidationSchema
+from fides.api.schemas.connection_configuration.connection_secrets_base_aws import (
+    BaseAWSSchema,
+)
+
+
+class MessagingServiceSecretsMailgun(BaseModel):
+    """The secrets required to connect to Mailgun."""
+
+    mailgun_api_key: str
+    model_config = ConfigDict(extra="forbid")
+
+
+class MessagingServiceSecretsTwilioSMS(BaseModel):
+    """The secrets required to connect to Twilio SMS."""
+
+    twilio_account_sid: str
+    twilio_auth_token: str
+    twilio_messaging_service_sid: Optional[str] = None
+    twilio_sender_phone_number: Optional[PhoneNumber] = None
+    model_config = ConfigDict(extra="forbid")
+
+    @model_validator(mode="before")
+    @classmethod
+    def validate_fields(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        sender_phone = values.get("twilio_sender_phone_number")
+        if not values.get("twilio_messaging_service_sid") and not sender_phone:
+            raise ValueError(
+                "Either the twilio_messaging_service_sid or the twilio_sender_phone_number should be supplied."
+            )
+        return values
+
+
+class MessagingServiceSecretsTwilioEmail(BaseModel):
+    """The secrets required to connect to twilio email."""
+
+    twilio_api_key: str
+    model_config = ConfigDict(extra="forbid")
+
+
+class MessagingServiceSecretsMailchimpTransactional(BaseModel):
+    """The secrets required to connect to Mailchimp Transactional."""
+
+    mailchimp_transactional_api_key: str
+    model_config = ConfigDict(extra="forbid")
+
+
+class MessagingServiceSecretsMailchimpTransactionalDocs(
+    MessagingServiceSecretsMailchimpTransactional,
+    NoValidationSchema,
+):
+    """The secrets required to connect Mailchimp Transactional, for documentation"""
+
+
+class MessagingSecretsMailgunDocs(MessagingServiceSecretsMailgun, NoValidationSchema):
+    """The secrets required to connect to Mailgun, for documentation"""
+
+
+class MessagingSecretsTwilioSMSDocs(
+    MessagingServiceSecretsTwilioSMS, NoValidationSchema
+):
+    """The secrets required to connect to Twilio sms, for documentation"""
+
+
+class MessagingSecretsTwilioEmailDocs(
+    MessagingServiceSecretsTwilioEmail, NoValidationSchema
+):
+    """The secrets required to connect to Twilio email, for documentation"""
+
+
+class MessagingServiceSecretsAWS_SES(BaseAWSSchema):
+    """The secrets required to connect to AWS SES."""
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class MessagingServiceSecretsAWS_SESDocs(
+    MessagingServiceSecretsAWS_SES, NoValidationSchema
+):
+    """The secrets required to connect to AWS SES, for documentation"""
+
+
+SUPPORTED_MESSAGING_SERVICE_SECRETS = Union[
+    MessagingServiceSecretsMailgun,
+    MessagingServiceSecretsTwilioSMS,
+    MessagingServiceSecretsTwilioEmail,
+    MessagingServiceSecretsMailchimpTransactional,
+    MessagingServiceSecretsAWS_SES,
+]
+
+PossibleMessagingSecrets = Union[
+    MessagingSecretsMailgunDocs,
+    MessagingSecretsTwilioSMSDocs,
+    MessagingSecretsTwilioEmailDocs,
+    MessagingServiceSecretsMailchimpTransactionalDocs,
+    MessagingServiceSecretsAWS_SESDocs,
+]

fides/api/service/deps.py

@@ -8,6 +8,7 @@ from fides.config import FidesConfig
 from fides.config.config_proxy import ConfigProxy
 from fides.service.dataset.dataset_config_service import DatasetConfigService
 from fides.service.dataset.dataset_service import DatasetService
+from fides.service.event_audit_service import EventAuditService
 from fides.service.messaging.messaging_service import MessagingService
 from fides.service.privacy_request.privacy_request_service import PrivacyRequestService
 from fides.service.system.system_service import SystemService
@@ -47,8 +48,15 @@ def get_user_service(
     return UserService(db, config, config_proxy)
 
 
-def get_taxonomy_service(db: Session = Depends(get_db)) -> TaxonomyService:
-    return TaxonomyService(db)
+def get_event_audit_service(db: Session = Depends(get_db)) -> EventAuditService:
+    return EventAuditService(db)
+
+
+def get_taxonomy_service(
+    db: Session = Depends(get_db),
+    event_audit_service: EventAuditService = Depends(get_event_audit_service),
+) -> TaxonomyService:
+    return TaxonomyService(db, event_audit_service)
 
 
 def get_system_service(db: AsyncSession = Depends(get_async_db)) -> SystemService:

fides/api/service/messaging/message_dispatch_service.py

@@ -44,7 +44,6 @@ from fides.api.service.messaging.messaging_crud_service import (
     get_enabled_messaging_template_by_type_and_property,
 )
 from fides.api.tasks import DatabaseTask, celery_app
-from fides.api.util.logger import Pii
 from fides.config import CONFIG
 from fides.config.config_proxy import ConfigProxy
 from fides.service.messaging.aws_ses_service import AWS_SES_Service
@@ -663,9 +662,9 @@ def _mailgun_dispatcher(
                 raise MessageDispatchException(
                     f"Email failed to send with status code {response.status_code}"
                 )
-    except Exception as e:
-        logger.error("Email failed to send: {}", Pii(str(e)))
-        raise MessageDispatchException(f"Email failed to send due to: {Pii(e)}")
+    except Exception as exc:
+        logger.error("Email failed to send: {}", str(exc))
+        raise MessageDispatchException(f"Email failed to send due to: {str(exc)}")
 
 
 def _twilio_email_dispatcher(
@@ -707,14 +706,14 @@ def _twilio_email_dispatcher(
             logger.error(
                 "Email failed to send: %s: %s",
                 response.status_code,
-                Pii(str(response.body)),
+                str(response.body),
             )
             raise MessageDispatchException(
-                f"Email failed to send: {response.status_code}, {Pii(str(response.body))}"
+                f"Email failed to send: {response.status_code}, {str(response.body)}"
             )
-    except Exception as e:
-        logger.error("Email failed to send: {}", Pii(str(e)))
-        raise MessageDispatchException(f"Email failed to send due to: {Pii(e)}")
+    except Exception as exc:
+        logger.error("Email failed to send: {}", str(exc))
+        raise MessageDispatchException(f"Email failed to send due to: {str(exc)}")
 
 
 def _twilio_sms_dispatcher(
@@ -753,9 +752,9 @@ def _twilio_sms_dispatcher(
             raise MessageDispatchException(
                 "Message failed to send. Either sender phone number or messaging service sid must be provided."
             )
-    except TwilioRestException as e:
-        logger.error("Twilio SMS failed to send: {}", Pii(str(e)))
-        raise MessageDispatchException(f"Twilio SMS failed to send due to: {Pii(e)}")
+    except TwilioRestException as exc:
+        logger.error("Twilio SMS failed to send: {}", str(exc))
+        raise MessageDispatchException(f"Twilio SMS failed to send due to: {str(exc)}")
 
 
 def _aws_ses_dispatcher(
@@ -769,9 +768,11 @@ def _aws_ses_dispatcher(
 
     try:
         aws_ses_serivce.send_email(to, message.subject, message.body)
-    except Exception as e:
-        logger.error("Email failed to send: {}", Pii(str(e)))
-        raise MessageDispatchException(f"AWS SES email failed to send due to: {Pii(e)}")
+    except Exception as exc:
+        logger.error("Email failed to send: {}", str(exc))
+        raise MessageDispatchException(
+            f"AWS SES email failed to send due to: {str(exc)}"
+        )
 
 
 def _get_template_id_if_exists(

fides/api/service/messaging/messaging_crud_service.py

@@ -25,7 +25,7 @@ from fides.api.schemas.messaging.messaging import (
 
 def update_messaging_config(
     db: Session, key: FidesKey, config: MessagingConfigRequest
-) -> MessagingConfigResponse:
+) -> MessagingConfig:
     existing_config_with_key: Optional[MessagingConfig] = MessagingConfig.get_by(
         db=db, field="key", value=key
     )
@@ -38,7 +38,7 @@ def update_messaging_config(
 
 def create_or_update_messaging_config(
     db: Session, config: MessagingConfigRequest
-) -> MessagingConfigResponse:
+) -> MessagingConfig:
     data = {
         "key": config.key,
         "name": config.name,
@@ -46,16 +46,10 @@ def create_or_update_messaging_config(
     }
     if config.details:
         data["details"] = config.details.__dict__  # type: ignore
-    messaging_config: MessagingConfig = MessagingConfig.create_or_update(
+    return MessagingConfig.create_or_update(
         db=db,
         data=data,
     )
-    return MessagingConfigResponse(
-        name=messaging_config.name,
-        key=messaging_config.key,
-        service_type=messaging_config.service_type.value,  # type: ignore
-        details=messaging_config.details,
-    )
 
 
 def delete_messaging_config(db: Session, key: FidesKey) -> None:
@@ -84,6 +78,8 @@ def get_messaging_config_by_key(db: Session, key: FidesKey) -> MessagingConfigRe
         key=config.key,
         service_type=config.service_type.value,  # type: ignore[attr-defined]
         details=config.details,
+        last_test_timestamp=config.last_test_timestamp,
+        last_test_succeeded=config.last_test_succeeded,
     )
 
 

fides/api/service/privacy_request/request_runner_service.py

@@ -782,10 +782,28 @@ def run_privacy_request(
                                     privacy_request.property_id,
                                     privacy_request.id,
                                 )
+                                # Add success log for completion email
+                                privacy_request.add_success_execution_log(
+                                    session,
+                                    connection_key=None,
+                                    dataset_name="Privacy request completion email",
+                                    collection_name=None,
+                                    message="Privacy request completion email sent successfully.",
+                                    action_type=privacy_request.policy.get_action_type(),  # type: ignore
+                                )
                             except (
                                 IdentityNotFoundException,
                                 MessageDispatchException,
                             ) as e:
+                                # Add error log for completion email failure
+                                privacy_request.add_error_execution_log(
+                                    session,
+                                    connection_key=None,
+                                    dataset_name="Privacy request completion email",
+                                    collection_name=None,
+                                    message=f"Privacy request completion email failed: {str(e)}",
+                                    action_type=privacy_request.policy.get_action_type(),  # type: ignore
+                                )
                                 privacy_request.error_processing(db=session)
                                 # If dev mode, log traceback
                                 _log_exception(e, CONFIG.dev_mode)

fides/api/tasks/__init__.py

@@ -19,6 +19,7 @@ from fides.config import CONFIG, FidesConfig
 MESSAGING_QUEUE_NAME = "fidesops.messaging"
 PRIVACY_PREFERENCES_QUEUE_NAME = "fides.privacy_preferences"  # This queue is used in Fidesplus for saving privacy preferences and notices served
 DSR_QUEUE_NAME = "fides.dsr"  # This queue is used for running data subject requests
+CONSENT_WEBHOOK_QUEUE_NAME = "fidesplus.consent_webhooks"  # This queue is used for processing consent webhooks from 3rd-party APIs
 DISCOVERY_MONITORS_DETECTION_QUEUE_NAME = "fidesplus.discovery_monitors_detection"  # This queue is used for running discovery monitors detection tasks
 DISCOVERY_MONITORS_CLASSIFICATION_QUEUE_NAME = "fidesplus.discovery_monitors_classification"  # This queue is used for running discovery monitors classification tasks
 DISCOVERY_MONITORS_PROMOTION_QUEUE_NAME = "fidesplus.discovery_monitors_promotion"  # This queue is used for running discovery monitors promotion tasks