ethyca-fides 2.69.1rc0__py2.py3-none-any.whl → 2.76.0rc2__py2.py3-none-any.whl

fides/api/service/connectors/saas_connector.py

@@ -10,8 +10,10 @@ from requests import Response
 from sqlalchemy.orm import Session
 from starlette.status import HTTP_204_NO_CONTENT
 
+from fides.api.api.deps import get_autoclose_db_session as get_db
 from fides.api.common_exceptions import (
-    AwaitingAsyncTask,
+    ClientUnsuccessfulException,
+    ConnectionException,
     FidesopsException,
     PostProcessingException,
     SkippingConsentPropagation,
@@ -27,7 +29,6 @@ from fides.api.schemas.consentable_item import (
 from fides.api.schemas.limiter.rate_limit_config import RateLimitConfig
 from fides.api.schemas.policy import ActionType
 from fides.api.schemas.saas.saas_config import (
-    AsyncStrategy,
     ClientConfig,
     ConsentRequestMap,
     ParamValue,
@@ -38,6 +39,10 @@ from fides.api.schemas.saas.shared_schemas import (
     ConsentPropagationStatus,
     SaaSRequestParams,
 )
+from fides.api.service.async_dsr.strategies.async_dsr_strategy import AsyncDSRStrategy
+from fides.api.service.async_dsr.strategies.async_dsr_strategy_factory import (
+    get_strategy,
+)
 from fides.api.service.connectors.base_connector import BaseConnector
 from fides.api.service.connectors.query_configs.saas_query_config import SaaSQueryConfig
 from fides.api.service.connectors.saas.authenticated_client import AuthenticatedClient
@@ -64,7 +69,9 @@ from fides.api.util.logger_context_utils import (
 from fides.api.util.saas_util import (
     ALL_OBJECT_FIELDS,
     CUSTOM_PRIVACY_REQUEST_FIELDS,
+    PRIVACY_REQUEST_OBJECT,
     assign_placeholders,
+    check_dataset_missing_reference_values,
     map_param_values,
 )
 
@@ -215,17 +222,14 @@ class SaaSConnector(BaseConnector[AuthenticatedClient], Contextualizable):
         request_task: RequestTask,
         input_data: Dict[str, List[Any]],
     ) -> List[Row]:
-        """Retrieve data from SaaS APIs"""
+        """
+        Retrieve data from SaaS APIs.
+
+        Handles sync requests directly and delegates async requests to external handlers.
+        """
 
         # pylint: disable=too-many-branches
         self.set_privacy_request_state(privacy_request, node, request_task)
-        if request_task.callback_succeeded:
-            # If this is True, we assume we've received results from a third party
-            # asynchronously and we can proceed to the next node.
-            logger.info(
-                "Access callback succeeded for request task '{}'", request_task.id
-            )
-            return request_task.get_access_data()
         query_config: SaaSQueryConfig = self.query_config(node)
 
         # generate initial set of requests if read request is defined, otherwise raise an exception
@@ -263,25 +267,32 @@ class SaaSConnector(BaseConnector[AuthenticatedClient], Contextualizable):
         if custom_privacy_request_fields:
             input_data[CUSTOM_PRIVACY_REQUEST_FIELDS] = [custom_privacy_request_fields]
 
-        rows: List[Row] = []
-        awaiting_async_callback: bool = False
+        input_data[PRIVACY_REQUEST_OBJECT] = [privacy_request.to_safe_dict()]
+        # check all the values specified by param_values are provided in input_data
         for read_request in read_requests:
-            self.set_saas_request_state(read_request)
-            if (
-                read_request.async_config
-                and read_request.async_config.strategy == AsyncStrategy.callback
-                and request_task.id  # Only supported in DSR 3.0
-            ):
-                # Asynchronous read request detected. We will exit below and put the
-                # Request Task in an "awaiting_processing" status.
-                awaiting_async_callback = True
-
-            # check all the values specified by param_values are provided in input_data
             if self._missing_dataset_reference_values(
                 input_data, read_request.param_values
             ):
                 return []
 
+        # Delegate async requests
+        with get_db() as db:
+            # Guard clause to ensure we only run async access requests for access requests
+            if self.guard_access_request(policy):
+                if async_dsr_strategy := _get_async_dsr_strategy(
+                    db, request_task, query_config, ActionType.access
+                ):
+                    return async_dsr_strategy.async_retrieve_data(
+                        client=self.create_client(),
+                        request_task_id=request_task.id,
+                        query_config=query_config,
+                        input_data=input_data,
+                    )
+
+        rows: List[Row] = []
+        for read_request in read_requests:
+            self.set_saas_request_state(read_request)
+
             # hook for user-provided request override functions
             if read_request.request_override:
                 return self._invoke_read_request_override(
@@ -297,7 +308,12 @@ class SaaSConnector(BaseConnector[AuthenticatedClient], Contextualizable):
             # if a path is provided, it means we want to generate HTTP requests from the config
             if read_request.path:
                 prepared_requests: List[Tuple[SaaSRequestParams, Dict[str, Any]]] = (
-                    query_config.generate_requests(input_data, policy, read_request)
+                    query_config.generate_requests(
+                        input_data,
+                        policy,
+                        read_request,
+                        privacy_request=privacy_request,
+                    )
                 )
 
                 # Iterates through initial list of prepared requests and through subsequent
@@ -321,7 +337,7 @@ class SaaSConnector(BaseConnector[AuthenticatedClient], Contextualizable):
             # This allows us to build an output object even if we didn't generate and execute
             # any HTTP requests. This is useful if we just want to select specific input_data
             # values to provide as row data to the mask_data function
-            elif read_request.output:
+            elif not read_request.path and read_request.output:
                 rows.extend(
                     self._apply_output_template(
                         query_config.generate_param_value_maps(
@@ -332,14 +348,21 @@ class SaaSConnector(BaseConnector[AuthenticatedClient], Contextualizable):
                 )
 
         self.unset_connector_state()
-        if awaiting_async_callback:
-            # If a read request was marked to expect async results, original response data here is ignored.
-            # We'll instead use the data received in the callback URL later.
-            # Raising an AwaitingAsyncTask to put this task in an awaiting_processing state
-            raise AwaitingAsyncTask()
-
         return rows
 
+    def guard_access_request(self, policy: Policy) -> bool:
+        """
+        Guard clause to ensure we only run async access requests
+        if the access request is enabled and we are in an Access Request
+        """
+        if (
+            self.configuration.enabled_actions is None
+            or ActionType.access in self.configuration.enabled_actions
+        ):
+            if policy.get_rules_for_action(ActionType.access):
+                return True
+        return False
+
     def _apply_output_template(
         self,
         param_value_maps: List[Dict[str, Any]],
@@ -369,29 +392,15 @@ class SaaSConnector(BaseConnector[AuthenticatedClient], Contextualizable):
         return result
 
     def _missing_dataset_reference_values(
-        self, input_data: Dict[str, Any], param_values: Optional[List[ParamValue]]
+        self, input_data: Dict[str, List[Any]], param_values: Optional[List[ParamValue]]
     ) -> List[str]:
         """Return a list of dataset reference values that are not found in the input_data map"""
-
-        # get the list of param_value references
-        required_param_value_references = [
-            param_value.name
-            for param_value in param_values or []
-            if param_value.references
-        ]
-
-        # extract the keys from inside the fides_grouped_inputs and append them the other input_data keys
-        provided_input_keys = (
-            list(input_data.get("fidesops_grouped_inputs")[0].keys())  # type: ignore
-            if input_data.get("fidesops_grouped_inputs")
-            else []
-        ) + list(input_data.keys())
-
-        # find the missing values
-        missing_dataset_reference_values = list(
-            set(required_param_value_references) - set(provided_input_keys)
+        missing_dataset_reference_values = check_dataset_missing_reference_values(
+            input_data, param_values
+        )
+        logger.info(
+            f"Missing dataset reference values: {missing_dataset_reference_values}"
         )
-
         if missing_dataset_reference_values:
             logger.info(
                 "The '{}' request of {} is missing the following dataset reference values [{}], skipping traversal",
@@ -518,22 +527,27 @@ class SaaSConnector(BaseConnector[AuthenticatedClient], Contextualizable):
         rows: List[Row],
         input_data: Optional[Dict[str, List[Any]]] = None,
     ) -> int:
-        """Execute a masking request. Return the number of rows that have been updated."""
-        self.set_privacy_request_state(privacy_request, node, request_task)
-        if request_task.callback_succeeded:
-            # If this is True, we assume the data was masked
-            # asynchronously and we can proceed to the next node.
-            logger.info(
-                "Masking callback succeeded for request task '{}'", request_task.id
-            )
-            # If we've received the callback for this node, return rows_masked directly
-            return request_task.rows_masked or 0
+        """
+        Execute masking requests.
 
+        Handles synchronous requests directly and delegates async requests to external handlers.
+        """
         self.set_privacy_request_state(privacy_request, node, request_task)
+
         query_config = self.query_config(node)
 
-        session = Session.object_session(privacy_request)
-        masking_request = query_config.get_masking_request(session)
+        # Delegate async requests
+        with get_db() as db:
+            if async_dsr_strategy := _get_async_dsr_strategy(
+                db, request_task, query_config, ActionType.erasure
+            ):
+                return async_dsr_strategy.async_mask_data(
+                    client=self.create_client(),
+                    request_task_id=request_task.id,
+                    query_config=query_config,
+                    rows=rows,
+                )
+        masking_request = query_config.get_masking_request()
         rows_updated = 0
 
         if not masking_request:
@@ -578,7 +592,7 @@ class SaaSConnector(BaseConnector[AuthenticatedClient], Contextualizable):
         for row in rows:
             try:
                 prepared_request = query_config.generate_update_stmt(
-                    row, policy, privacy_request
+                    row, policy, privacy_request, input_data
                 )
             except ValueError as exc:
                 if masking_request.skip_missing_param_values:
@@ -630,18 +644,6 @@ class SaaSConnector(BaseConnector[AuthenticatedClient], Contextualizable):
                 )
 
         self.unset_connector_state()
-
-        awaiting_async_callback: bool = bool(
-            masking_request.async_config
-            and masking_request.async_config.strategy == AsyncStrategy.callback
-        ) and bool(
-            request_task.id
-        )  # Only supported in DSR 3.0
-        if awaiting_async_callback:
-            # Asynchronous masking request detected in saas config.
-            # If the masking request was marked to expect async results, original responses are ignored
-            # and we raise an AwaitingAsyncTask to put this task in an awaiting_processing state.
-            raise AwaitingAsyncTask()
         return rows_updated
 
     @staticmethod
@@ -949,6 +951,9 @@ class SaaSConnector(BaseConnector[AuthenticatedClient], Contextualizable):
                 client,
                 secrets,
             )  # type: ignore
+        except (ConnectionException, ClientUnsuccessfulException):
+            # Re-raise these exceptions as-is so the connection service can handle them properly
+            raise
         except Exception as exc:
             logger.error(
                 "Encountered error executing override test function '{}'",
@@ -1094,3 +1099,38 @@ class SaaSConnector(BaseConnector[AuthenticatedClient], Contextualizable):
             return []
 
         return consent_requests.opt_in if opt_in else consent_requests.opt_out  # type: ignore
+
+
+def _get_async_dsr_strategy(
+    session: Session,
+    request_task: RequestTask,
+    query_config: SaaSQueryConfig,
+    action_type: ActionType,
+) -> Optional[AsyncDSRStrategy]:
+    """
+    Returns the async DSR strategy if any of the read or masking requests have an async_config.
+    """
+
+    # Async processing is only supported for DSR 3.0.
+    # A request task with an ID of None is an indicator that the request is not DSR 3.0.
+    if request_task.id is None:
+        return None
+
+    if action_type == ActionType.access:
+        read_requests = query_config.get_read_requests_by_identity()
+        for request in read_requests:
+            if request.async_config is not None:
+                return get_strategy(
+                    request.async_config.strategy,
+                    session,
+                    request.async_config.configuration,
+                )
+    elif action_type == ActionType.erasure:
+        masking_request = query_config.get_masking_request()
+        if masking_request is not None and masking_request.async_config is not None:
+            return get_strategy(
+                masking_request.async_config.strategy,
+                session,
+                masking_request.async_config.configuration,
+            )
+    return None

fides/api/service/connectors/sql_connector.py

@@ -345,7 +345,7 @@ class SQLConnector(BaseConnector[Engine]):
 
                 # For simple table names
                 if "." not in qualified_table_name:
-                    return inspector.has_table(qualified_table_name)
+                    return self._check_table_exists(inspector, qualified_table_name)
 
                 # For qualified names like schema.table or database.schema.table
                 parts = qualified_table_name.split(".")
@@ -353,15 +353,15 @@ class SQLConnector(BaseConnector[Engine]):
                 if len(parts) == 2:
                     # schema.table format
                     schema_name, table_name = parts
-                    return inspector.has_table(table_name, schema=schema_name)
+                    return self._check_table_exists(inspector, table_name, schema_name)
 
                 if len(parts) >= 3:
                     # database.schema.table format (use schema.table)
                     schema_name, table_name = parts[-2], parts[-1]
-                    return inspector.has_table(table_name, schema=schema_name)
+                    return self._check_table_exists(inspector, table_name, schema_name)
 
                 # Fallback for unexpected format
-                return inspector.has_table(qualified_table_name)
+                return self._check_table_exists(inspector, qualified_table_name)
 
         except Exception as exc:
             # Graceful fallback - if we can't check, assume table exists
@@ -369,6 +369,16 @@ class SQLConnector(BaseConnector[Engine]):
             logger.error("Unable to check if table exists, assuming it does: {}", exc)
             return True
 
+    def _check_table_exists(
+        self, inspector: Any, table_name: str, schema: Optional[str] = None
+    ) -> bool:
+        """Helper method to check table existence and log if not found."""
+        table_exists = inspector.has_table(table_name, schema=schema)
+        if not table_exists:
+            qualified_name = f"{schema}.{table_name}" if schema else table_name
+            logger.error("Table '{}' does not exist", qualified_name)
+        return table_exists
+
     def handle_table_not_found(
         self,
         node: ExecutionNode,

fides/api/service/deps.py

@@ -1,13 +1,18 @@
 from fastapi import Depends
+from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import Session
 
 from fides.api.api.deps import get_config, get_config_proxy, get_db
+from fides.api.db.ctl_session import get_async_db
 from fides.config import FidesConfig
 from fides.config.config_proxy import ConfigProxy
+from fides.service.connection.connection_service import ConnectionService
 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
 from fides.service.taxonomy.taxonomy_service import TaxonomyService
 from fides.service.user.user_service import UserService
 
@@ -44,5 +49,23 @@ 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_connection_service(
+    db: Session = Depends(get_db),
+    event_audit_service: EventAuditService = Depends(get_event_audit_service),
+) -> ConnectionService:
+    return ConnectionService(db, event_audit_service)
+
+
+def get_system_service(db: AsyncSession = Depends(get_async_db)) -> SystemService:
+    return SystemService(db)

fides/api/service/messaging/message_dispatch_service.py

@@ -6,6 +6,7 @@ from typing import Any, Callable, Dict, List, Optional, Union
 import requests
 import sendgrid
 from loguru import logger
+from requests.exceptions import RequestException, Timeout
 from sendgrid.helpers.mail import Content, Email, Mail, Personalization, TemplateId, To
 from sqlalchemy.orm import Session
 from twilio.base.exceptions import TwilioRestException
@@ -28,6 +29,7 @@ from fides.api.schemas.messaging.messaging import (
     ErrorNotificationBodyParams,
     ExternalUserWelcomeBodyParams,
     FidesopsMessage,
+    ManualTaskDigestBodyParams,
     MessagingActionType,
     MessagingMethod,
     MessagingServiceDetails,
@@ -44,7 +46,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
@@ -53,7 +54,18 @@ EMAIL_JOIN_STRING = ", "
 EMAIL_TEMPLATE_NAME = "fides"
 
 
-@celery_app.task(base=DatabaseTask, bind=True)
+@celery_app.task(
+    base=DatabaseTask,
+    bind=True,
+    autoretry_for=(
+        Timeout,
+        RequestException,
+        TwilioRestException,
+    ),
+    retry_kwargs={"max_retries": 3},
+    retry_backoff=2,
+    retry_jitter=True,
+)
 def dispatch_message_task(
     self: DatabaseTask,
     message_meta: Dict[str, Any],
@@ -62,7 +74,14 @@ def dispatch_message_task(
     property_id: Optional[str],
 ) -> None:
     """
-    A wrapper function to dispatch a message task into the Celery queues
+    A wrapper function to dispatch a message task into the Celery queues.
+
+    This task will automatically retry up to 3 times on transient network failures
+    (timeouts, connection errors, temporary service unavailability) with exponential
+    backoff (2s, 4s, 8s) and jitter to prevent thundering herd issues.
+
+    Permanent errors (missing config, invalid identities, etc.) will fail immediately
+    without retry to provide fast feedback and avoid wasting worker resources.
     """
     schema = FidesopsMessage.model_validate(message_meta)
     with self.get_new_session() as db:
@@ -178,6 +197,7 @@ def dispatch_message(
             UserInviteBodyParams,
             ErrorNotificationBodyParams,
             ExternalUserWelcomeBodyParams,
+            ManualTaskDigestBodyParams,
         ]
     ] = None,
     subject_override: Optional[str] = None,
@@ -353,7 +373,7 @@ def _render(template_str: str, variables: Optional[Dict] = None) -> str:
     return template_str
 
 
-def _build_email(  # pylint: disable=too-many-return-statements, too-many-branches
+def _build_email(  # pylint: disable=too-many-return-statements, too-many-branches, too-many-statements
     config_proxy: ConfigProxy,
     action_type: MessagingActionType,
     body_params: Any,
@@ -466,7 +486,6 @@ def _build_email(  # pylint: disable=too-many-return-statements, too-many-branch
             ),
         )
     if action_type == MessagingActionType.EXTERNAL_USER_WELCOME:
-        base_template = get_email_template(action_type)
         # Generate display name for personalization
         display_name = body_params.username
         if body_params.first_name:
@@ -489,8 +508,61 @@ def _build_email(  # pylint: disable=too-many-return-statements, too-many-branch
             "access_token": body_params.access_token,
         }
 
+        # Start with default subject
+        subject = "Welcome to our Privacy Center"
+
+        # If messaging template exists, extract customizable content
+        if messaging_template:
+            # Use custom subject if provided
+            if "subject" in messaging_template.content:
+                subject = _render(messaging_template.content["subject"], variables)
+
+            # Use custom body content to replace the intro text in HTML template
+            custom_body = messaging_template.content.get("body", "")
+            if custom_body.strip():
+                # Replace the default intro text with the custom body content
+                rendered_custom_body = _render(custom_body, variables)
+                variables["custom_intro"] = rendered_custom_body
+
+        # Always use the HTML template
+        base_template = get_email_template(action_type)
+        return EmailForActionType(
+            subject=subject,
+            body=base_template.render(variables),
+            template_variables=variables,
+        )
+
+    if action_type == MessagingActionType.MANUAL_TASK_DIGEST:
+        variables = {
+            "vendor_contact_name": body_params.vendor_contact_name,
+            "organization_name": body_params.organization_name,
+            "portal_url": body_params.portal_url,
+            "imminent_task_count": body_params.imminent_task_count,
+            "upcoming_task_count": body_params.upcoming_task_count,
+            "total_task_count": body_params.total_task_count,
+            "company_logo_url": body_params.company_logo_url,
+        }
+
+        # Start with default subject
+        subject = f"Weekly DSR Summary from {body_params.organization_name}"
+
+        # If messaging template exists, extract customizable content
+        if messaging_template:
+            # Use custom subject if provided
+            if "subject" in messaging_template.content:
+                subject = _render(messaging_template.content["subject"], variables)
+
+            # Use custom body content to replace the intro text in HTML template
+            custom_body = messaging_template.content.get("body", "")
+            if custom_body.strip():
+                # Replace the default intro text with the custom body content
+                rendered_custom_body = _render(custom_body, variables)
+                variables["intro_text"] = rendered_custom_body
+
+        # Always use the HTML template
+        base_template = get_email_template(action_type)
         return EmailForActionType(
-            subject="Welcome to our Privacy Center",
+            subject=subject,
             body=base_template.render(variables),
             template_variables=variables,
         )
@@ -564,6 +636,7 @@ def _mailchimp_transactional_dispatcher(
         "https://mandrillapp.com/api/1.0/messages/send",
         headers={"Content-Type": "application/json"},
         data=data,
+        timeout=10,
     )
     if not response.ok:
         logger.error("Email failed to send with status code: %s", response.status_code)
@@ -611,6 +684,7 @@ def _mailgun_dispatcher(
                 "api",
                 messaging_config.secrets[MessagingServiceSecrets.MAILGUN_API_KEY.value],
             ),
+            timeout=10,
         )
 
         data = {
@@ -635,6 +709,7 @@ def _mailgun_dispatcher(
                     ],
                 ),
                 data=data,
+                timeout=10,
             )
 
             if not response.ok:
@@ -655,6 +730,7 @@ def _mailgun_dispatcher(
                     ],
                 ),
                 data=data,
+                timeout=10,
             )
             if not response.ok:
                 logger.error(
@@ -663,9 +739,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 +783,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 +829,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 +845,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,
     )