Add debug log statements

.pyproject_generation/pyproject_custom.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ns"
-version = "2.0.0"
+version = "2.0.1"
 description = "The Notification Service (NS) handles notification kafka events."
 dependencies = [
     "typer>=0.12",

README.md

@@ -33,21 +33,21 @@ We recommend using the provided Docker container.
 
 A pre-build version is available at [docker hub](https://hub.docker.com/repository/docker/ghga/notification-service):
 ```bash
-docker pull ghga/notification-service:2.0.0
+docker pull ghga/notification-service:2.0.1
 ```
 
 Or you can build the container yourself from the [`./Dockerfile`](./Dockerfile):
 ```bash
 # Execute in the repo's root dir:
-docker build -t ghga/notification-service:2.0.0 .
+docker build -t ghga/notification-service:2.0.1 .
 ```
 
 For production-ready deployment, we recommend using Kubernetes, however,
 for simple use cases, you could execute the service using docker
 on a single server:
 ```bash
 # The entrypoint is preconfigured:
-docker run -p 8080:8080 ghga/notification-service:2.0.0 --help
+docker run -p 8080:8080 ghga/notification-service:2.0.1 --help
 ```
 
 If you prefer not to use containers, you may install the service from source:

pyproject.toml

@@ -21,7 +21,7 @@ classifiers = [
     "Intended Audience :: Developers",
 ]
 name = "ns"
-version = "2.0.0"
+version = "2.0.1"
 description = "The Notification Service (NS) handles notification kafka events."
 dependencies = [
     "typer>=0.12",

src/ns/adapters/outbound/smtp_client.py

@@ -63,7 +63,7 @@ def __init__(self, *, config: SmtpClientConfig):
     @contextmanager
     def get_connection(self) -> Generator[SMTP, None, None]:
         """Establish a connection to the SMTP server"""
-        with SMTP(self._config.smtp_host, self._config.smtp_port) as server:
+        with SMTP(self._config.smtp_host, self._config.smtp_port, timeout=60) as server:
             yield server
 
     def send_email_message(self, message: EmailMessage):
@@ -74,14 +74,19 @@ def send_email_message(self, message: EmailMessage):
         In the case that username and password are `None`, authentication will not be
         performed.
         """
+        log.debug("Starting the 'send_email_message' function.")
         try:
             with self.get_connection() as server:
+                log.debug("Basic connection acquired with configured host and port.")
+
                 if self._config.use_starttls:
+                    log.debug("Using SSL")
                     # create ssl security context per Python's Security considerations
                     context = ssl.create_default_context()
                     server.starttls(context=context)
 
                 if self._config.smtp_auth:
+                    log.debug("Logging into SMTP with auth.")
                     username = self._config.smtp_auth.username
                     password = self._config.smtp_auth.password.get_secret_value()
                     try:
@@ -90,14 +95,19 @@ def send_email_message(self, message: EmailMessage):
                         login_error = self.FailedLoginError()
                         log.critical(login_error)
                         raise login_error from err
+                else:
+                    log.debug("Skipping auth for SMTP.")
 
                 # check for a connection
+                log.debug("Pinging server...")
                 if server.noop()[0] != 250:
                     connection_error = self.ConnectionError()
                     log.critical(connection_error)
                     raise connection_error
+                log.debug("Connected to SMTP server, sending message.")
 
                 server.send_message(msg=message)
+                log.debug("Message sent.")
         except SMTPException as exc:
             error = self.GeneralSmtpException(error_info=exc.args[0])
             log.error(error, extra={"error_info": exc.args[0]})

src/ns/core/notifier.py

@@ -75,6 +75,7 @@ def _create_notification_record(
         self, *, notification: event_schemas.Notification
     ) -> models.NotificationRecord:
         """Creates a notification record from a notification event and correlation ID."""
+        log.debug("Creating new notification record.")
         correlation_id = get_correlation_id()
         notification_str = json.dumps(notification.model_dump(), sort_keys=True)
         concatenated = correlation_id + notification_str
@@ -88,6 +89,7 @@ async def _has_been_sent(self, *, hash_sum: str) -> bool:
         - `False` if the notification **has not** been sent yet.
         - `True` if the notification **has** already been sent.
         """
+        log.debug("Checking if notification has been sent yet.")
         with suppress(ResourceNotFoundError):
             record = await self._notification_record_dao.get_by_id(id_=hash_sum)
             return record.sent
@@ -97,14 +99,17 @@ async def _register_new_notification(
         self, *, notification_record: models.NotificationRecord
     ):
         """Registers a new notification in the database"""
+        log.debug("Inserting record into database.")
         await self._notification_record_dao.upsert(dto=notification_record)
+        log.debug("Record successfully inserted into database.")
 
     async def send_notification(self, *, notification: event_schemas.Notification):
         """Sends notifications based on the channel info provided (e.g. email addresses)"""
         # Generate sha-256 hash of the notification payload
         notification_record = self._create_notification_record(
             notification=notification
         )
+        log.debug("Notification record created")
 
         # Abort if the notification has been sent already
         if await self._has_been_sent(hash_sum=notification_record.hash_sum):
@@ -114,12 +119,16 @@ async def send_notification(self, *, notification: event_schemas.Notification):
         # Add the notification to the database (with sent=False)
         await self._register_new_notification(notification_record=notification_record)
 
+        log.debug("Constructing email.")
         message = self._construct_email(notification=notification)
+        log.debug("Email constructed.")
         self._smtp_client.send_email_message(message)
 
         # update the notification record to show that the notification has been sent.
         notification_record.sent = True
+        log.debug("Notification sent! Updating database record with new status.")
         await self._notification_record_dao.update(dto=notification_record)
+        log.debug("Notification record successfully updated in the DB.")
 
     def _build_email_subtype(
         self, *, template_type: EmailTemplateType, email_vars: dict[str, str]