AdamThomasandClaude Sonnet 5
fcc42c8d43
En cherchant pourquoi les logs d'envoi d'email semblaient invisibles, on a
plutôt trouvé un problème RGPD : `SMTPRecipientsRefused` embarque l'adresse
du destinataire dans ses `args` (`{adresse: (code, message)}`), et
`logger.error(..., exc)` la journalisait telle quelle via `str(exc)` — en
violation directe de la règle « pas de log des noms/emails/téléphones ».
`_smtp_error_summary()` n'en extrait que les codes/messages serveur.
Constaté au passage (pas un bug) : le mécanisme de logs lui-même fonctionne
bien — `docker compose logs -f backend` affiche bien les lignes `app.email`
dès qu'une vraie requête HTTP déclenche l'envoi (testé en direct sur
l'édition de démo).
Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017uUsRg7XzopkCPWimwg9ZM
121 lines
4.1 KiB
Python
121 lines
4.1 KiB
Python
"""Construction et remise des emails.
|
|
|
|
`deliver_many` est le point d'injection unique (remplacé dans les tests).
|
|
La remise est « best effort » : une erreur SMTP est journalisée (le message du
|
|
serveur, pas de PII) et ne remonte pas — l'appel HTTP n'échoue pas pour ça.
|
|
Pour diagnostiquer : `python -m app.email.check <destinataire>`."""
|
|
|
|
import logging
|
|
import smtplib
|
|
import ssl
|
|
from collections.abc import Iterable
|
|
from email.message import EmailMessage
|
|
|
|
from app.config import Settings, get_settings
|
|
|
|
logger = logging.getLogger("app.email")
|
|
|
|
|
|
def _smtp_error_summary(exc: smtplib.SMTPException) -> str:
|
|
"""Résumé RGPD-safe d'une erreur SMTP : codes/messages serveur seulement.
|
|
|
|
Certaines exceptions de `smtplib` embarquent l'adresse du destinataire
|
|
dans leurs `args` (notamment `SMTPRecipientsRefused.recipients`, un
|
|
`{adresse: (code, message)}`) — `str(exc)` les journaliserait telles
|
|
quelles. On n'en garde que les codes/messages, jamais les adresses.
|
|
"""
|
|
if isinstance(exc, smtplib.SMTPRecipientsRefused):
|
|
codes = sorted({code for code, _msg in exc.recipients.values()})
|
|
return f"destinataire(s) refusé(s), code(s) {codes}"
|
|
if isinstance(exc, smtplib.SMTPResponseException):
|
|
return f"{exc.smtp_code} {exc.smtp_error!r}"
|
|
return exc.__class__.__name__
|
|
|
|
|
|
def build_message(to: str, subject: str, body: str) -> EmailMessage:
|
|
message = EmailMessage()
|
|
message["From"] = get_settings().smtp_from
|
|
message["To"] = to
|
|
message["Subject"] = subject
|
|
message.set_content(body)
|
|
return message
|
|
|
|
|
|
def open_smtp(settings: Settings) -> smtplib.SMTP:
|
|
"""Ouvre une session SMTP authentifiée. Lève en cas d'échec."""
|
|
use_ssl = settings.smtp_ssl
|
|
use_starttls = settings.smtp_starttls
|
|
if settings.smtp_port == 465 and not use_ssl:
|
|
# Le port 465 (SMTPS, RFC 8314) parle TLS d'emblée : STARTTLS échoue.
|
|
logger.info("Port 465 → SSL implicite (SMTP_SSL/STARTTLS ignorés).")
|
|
use_ssl, use_starttls = True, False
|
|
|
|
context = ssl.create_default_context()
|
|
if use_ssl:
|
|
smtp: smtplib.SMTP = smtplib.SMTP_SSL(
|
|
settings.smtp_host, settings.smtp_port, timeout=30, context=context
|
|
)
|
|
else:
|
|
smtp = smtplib.SMTP(settings.smtp_host, settings.smtp_port, timeout=30)
|
|
if use_starttls:
|
|
smtp.starttls(context=context)
|
|
if settings.smtp_user:
|
|
smtp.login(settings.smtp_user, settings.smtp_password)
|
|
return smtp
|
|
|
|
|
|
def deliver_many(messages: list[EmailMessage]) -> None:
|
|
settings = get_settings()
|
|
if not settings.email_enabled:
|
|
# RGPD : ni destinataire ni corps dans les logs.
|
|
logger.info(
|
|
"Emails non envoyés (EMAIL_ENABLED=false) — %d message(s)",
|
|
len(messages),
|
|
)
|
|
return
|
|
if not messages:
|
|
return
|
|
|
|
try:
|
|
smtp = open_smtp(settings)
|
|
except (OSError, smtplib.SMTPException) as exc:
|
|
logger.error(
|
|
"SMTP indisponible (%s:%s, ssl=%s starttls=%s) : %s",
|
|
settings.smtp_host,
|
|
settings.smtp_port,
|
|
settings.smtp_ssl,
|
|
settings.smtp_starttls,
|
|
exc,
|
|
)
|
|
return
|
|
|
|
sent = 0
|
|
with smtp:
|
|
for message in messages:
|
|
try:
|
|
smtp.send_message(message)
|
|
sent += 1
|
|
except smtplib.SMTPException as exc:
|
|
# Ex. « 550 sender not authorized », « 535 auth failed ».
|
|
logger.error(
|
|
"Email refusé par le serveur (From=%s) : %s",
|
|
message["From"],
|
|
_smtp_error_summary(exc),
|
|
)
|
|
# RGPD : ni destinataire ni corps, seulement le compte et le sujet.
|
|
logger.info(
|
|
"Emails remis : %d/%d — sujet=%r",
|
|
sent,
|
|
len(messages),
|
|
messages[0]["Subject"],
|
|
)
|
|
|
|
|
|
def send(to: str, subject: str, body: str) -> None:
|
|
deliver_many([build_message(to, subject, body)])
|
|
|
|
|
|
def send_many(items: Iterable[tuple[str, str, str]]) -> None:
|
|
"""`items` = itérable de `(destinataire, sujet, corps)`."""
|
|
deliver_many([build_message(*item) for item in items])
|