@@ -163,6 +163,7 @@ def _parse_long_header(payload: bytes) -> dict | None:
 
     version = int.from_bytes(payload[1:5], "big")
     if version != QUIC_V1:
+        logger.trace("_parse_long_header: version QUIC 0x{:08x} non geree, paquet ignore", version)
         return None  # seule la v1 (RFC 9001) est geree -- voir limites en tete de fichier
 
     i = 5
@@ -196,6 +197,7 @@ def _parse_long_header(payload: bytes) -> dict | None:
     pn_offset = i
 
     if pn_offset + remaining_len > len(payload) or remaining_len < 4:
+        logger.trace("_parse_long_header: longueur annoncee {} incoherente ({} octets)", remaining_len, len(payload))
         return None  # incoherent : pas assez de place pour PN(<=4)+charge utile+tag(16)
 
     return {
@@ -213,6 +215,7 @@ def _remove_header_protection(payload: bytearray, pn_offset: int, hp_key: bytes)
     -- c'est ce dernier qui fait foi (voir _decrypt_initial)."""
     sample_start = pn_offset + 4
     if sample_start + 16 > len(payload):
+        logger.trace("_remove_header_protection: echantillon hors du paquet ({} octets)", len(payload))
         return None
     sample = bytes(payload[sample_start : sample_start + 16])
     encryptor = Cipher(algorithms.AES(hp_key), modes.ECB()).encryptor()
@@ -259,7 +262,8 @@ def _decrypt_initial(payload: bytes, client_secret: bytes, header_info: dict) ->
     try:
         return AESGCM(key).decrypt(bytes(nonce), ciphertext, header)
     except InvalidTag:
-        logger.exception("erreur: InvalidTag")
+        # resultat normal (voir docstring), a chaque paquet : TRACE, sans traceback
+        logger.trace("_decrypt_initial: tag AEAD invalide, paquet {} non dechiffrable", packet_number)
         return None
 
 
@@ -286,10 +290,12 @@ def _extract_client_hello_from_crypto(plaintext: bytes) -> bytes | None:
             if i + length > len(plaintext):
                 return None
             if offset != 0:
+                logger.trace("_extract_client_hello_from_crypto: CRYPTO a l'offset {}, ClientHello fragmente", offset)
                 return None  # ClientHello fragmente sur plusieurs paquets : hors perimetre
             return plaintext[i : i + length]
         # autre type de frame (ACK, etc.) : pas de parseur generique pour
         # sauter son corps proprement, on s'arrete la plutot que deviner
+        logger.trace("_extract_client_hello_from_crypto: trame 0x{:02x} avant CRYPTO, arret", frame_type)
         return None
     return None
 
@@ -300,6 +306,7 @@ def _parse_tls_handshake_from_crypto(crypto_data: bytes) -> dict | None:
     body_len = int.from_bytes(crypto_data[1:4], "big")
     body = crypto_data[4 : 4 + body_len]
     if len(body) < body_len:
+        logger.trace("_parse_tls_handshake_from_crypto: ClientHello incomplet ({}/{} octets)", len(body), body_len)
         return None  # ClientHello incomplet dans ce paquet (fragmente) : hors perimetre
     return parse_client_hello(body)
 
@@ -311,6 +318,7 @@ def parse_quic_capture(label: str, path: str) -> list[QuicEvent]:
     cas, jamais de donnee inventee)."""
     events: list[QuicEvent] = []
     raw_packets = pcap_parser.parse_capture(path, raise_on_error=False)
+    logger.debug("parse_quic_capture: point {}, {} paquet(s) lus depuis {}", label, len(raw_packets), path)
 
     for raw in raw_packets:
         if raw.proto != "UDP" or not raw.payload:
@@ -357,6 +365,13 @@ def parse_quic_capture(label: str, path: str) -> list[QuicEvent]:
             )
         )
 
+    logger.debug(
+        "parse_quic_capture: point {}, {} Initial QUIC v1 dont {} non dechiffrable(s), {} avec SNI",
+        label,
+        len(events),
+        sum(1 for ev in events if not ev.decryptable),
+        sum(1 for ev in events if ev.sni),
+    )
     return events
 
 
@@ -377,7 +392,14 @@ def diagnose_quic(events: list[QuicEvent], points_order: list[str] | None = None
         if not e.decryptable:
             decrypt_failures[e.point] = decrypt_failures.get(e.point, 0) + 1
 
+    logger.debug(
+        "diagnose_quic: {} evenement(s), {} connexion(s) (DCID), echecs de dechiffrement {}",
+        len(events),
+        len(by_dcid),
+        decrypt_failures,
+    )
     if not points_order:
+        logger.debug("diagnose_quic: sans ordre des points, seuls les echecs de dechiffrement sont rapportes")
         for p, n in decrypt_failures.items():
             findings.append(
                 TlsFinding(
@@ -431,10 +453,12 @@ def diagnose_quic(events: list[QuicEvent], points_order: list[str] | None = None
             )
         )
 
+    logger.debug("diagnose_quic: {} constat(s)", len(findings))
     return findings
 
 
 def print_quic_diagnostics(findings) -> None:
+    logger.debug("print_quic_diagnostics: {} constat(s)", len(findings))
     print("=" * 70)
     print("DIAGNOSTIC QUIC/HTTP3 -- ClientHello vus par point (SNI)")
     print("=" * 70)
 
@@ -142,6 +142,7 @@ def parse_client_hello(body: bytes) -> dict:
     approximative en cas de doute.
     """
     if len(body) < 34:
+        logger.trace("parse_client_hello: corps trop court ({} octets), ignore", len(body))
         return {}
     version = _tls_version_str(body[0], body[1])
     i = 34  # client_version(2) + random(32)
@@ -159,6 +160,7 @@ def parse_client_hello(body: bytes) -> dict:
     i += 1 + comp_len
     ext_total_len = _read_u16(body, i)
     if ext_total_len is None:
+        logger.trace("parse_client_hello: ClientHello sans extensions, SNI inconnu")
         return {"tls_version": version}
     i += 2
     ext_end = min(i + ext_total_len, len(body))
@@ -180,6 +182,7 @@ def parse_client_hello(body: bytes) -> dict:
 def parse_server_hello(body: bytes) -> dict:
     """Extrait la version TLS negociee et le cipher suite choisi."""
     if len(body) < 35:
+        logger.trace("parse_server_hello: corps trop court ({} octets), ignore", len(body))
         return {}
     version = _tls_version_str(body[0], body[1])
     i = 34
@@ -193,6 +196,7 @@ def parse_server_hello(body: bytes) -> dict:
 
 def parse_alert(body: bytes) -> dict:
     if len(body) < 2:
+        logger.trace("parse_alert: alerte tronquee ({} octet(s))", len(body))
         return {}
     level = ALERT_LEVELS.get(body[0], f"unknown({body[0]})")
     desc = ALERT_DESCRIPTIONS.get(body[1], f"unknown({body[1]})")
@@ -210,13 +214,15 @@ def _iter_tls_records(
         content_type, major, minor = payload[i], payload[i + 1], payload[i + 2]
         length = int.from_bytes(payload[i + 3 : i + 5], "big")
         if content_type not in TLS_CONTENT_TYPES or major != 3:
+            logger.trace("_iter_tls_records: plus de TLS bien forme a l'offset {} (type {})", i, content_type)
             break
         body_start = i + 5
         body_end = body_start + length
         truncated = body_end > n
         body = payload[body_start : min(body_end, n)]
         yield content_type, major, minor, length, body, truncated
         if truncated:
+            logger.trace("_iter_tls_records: record de {} octets tronque a {}", length, len(body))
             break  # le reste est dans un segment suivant, pas de reassemblage ici
         i = body_end
 
@@ -233,6 +239,7 @@ def _iter_handshake_messages(body: bytes) -> Iterator[tuple[int, bytes, bool]]:
         msg_start = i + 4
         msg_end = msg_start + hlen
         if msg_end > n:
+            logger.trace("_iter_handshake_messages: message {} tronque ({}/{} octets)", htype, n - msg_start, hlen)
             yield htype, body[msg_start:n], True
             break
         yield htype, body[msg_start:msg_end], False
@@ -251,6 +258,8 @@ def parse_tls_capture(label: str, path: str) -> list[TlsEvent]:
     planter tout le run -- coherent avec le reste de netcross_core."""
     events: list[TlsEvent] = []
     raw_packets = pcap_parser.parse_capture(path, raise_on_error=False)
+    logger.debug("parse_tls_capture: point {}, {} paquet(s) lus depuis {}", label, len(raw_packets), path)
+    tls_segments = 0
 
     for raw in raw_packets:
         if raw.proto != "TCP" or not raw.payload:
@@ -259,6 +268,7 @@ def parse_tls_capture(label: str, path: str) -> list[TlsEvent]:
         payload = raw.payload
         if not _looks_like_tls(payload):
             continue
+        tls_segments += 1
 
         ts = raw.ts
         src, dst = raw.src, raw.dst
@@ -326,6 +336,13 @@ def parse_tls_capture(label: str, path: str) -> list[TlsEvent]:
                     )
                 )
 
+    logger.debug(
+        "parse_tls_capture: point {}, {} segment(s) TLS, {} evenement(s) dont {} tronque(s)",
+        label,
+        tls_segments,
+        len(events),
+        sum(1 for ev in events if ev.truncated),
+    )
     return events
 
 
@@ -388,6 +405,12 @@ def build_handshake_status(
         elif ev.record_type == "application_data":
             st.application_data_seen = True
 
+    logger.debug(
+        "build_handshake_status: {} evenement(s) -> {} flux sur {} point(s)",
+        len(events),
+        sum(len(per_point) for per_point in status.values()),
+        len(status),
+    )
     return status
 
 
@@ -413,6 +436,9 @@ def diagnose_tls(
     """
     findings: list[TlsFinding] = []
     points = points_order or sorted(status_by_point)
+    logger.debug(
+        "diagnose_tls: {} point(s), ordre {}", len(points), "fourni" if points_order else "alphabetique (par defaut)"
+    )
 
     # -- alertes fatales, un constat par point --
     for point in points:
@@ -439,6 +465,7 @@ def diagnose_tls(
             if st_b is None:
                 # flux pas vu au point suivant -- hors perimetre de ce module
                 # (voir netcross_core.analyse pour les pertes)
+                logger.trace("diagnose_tls: flux {} absent en {}, ignore", fid, b)
                 continue
             if st_a.verdict == "complete" and st_b.verdict != "complete":
                 broken_here.append((st_a, st_b))
@@ -478,10 +505,16 @@ def diagnose_tls(
             f.segment,
         )
     )
+    logger.debug(
+        "diagnose_tls: {} constat(s) dont {} anomalie(s)",
+        len(findings),
+        sum(1 for f in findings if f.severity == "anomalie"),
+    )
     return findings
 
 
 def print_tls_diagnostics(findings: list[TlsFinding]) -> None:
+    logger.debug("print_tls_diagnostics: {} constat(s)", len(findings))
     print("=" * 70)
     print("DIAGNOSTIC TLS -- etat des handshakes par point")
     print("=" * 70)
 
@@ -0,0 +1,47 @@
+"""#441, lot 5 : journalisation de tls_diagnostics et quic_diagnostics."""
+
+from __future__ import annotations
+
+import pytest
+from loguru import logger
+
+from netcross_core import quic_diagnostics as quic
+from netcross_core import tls_diagnostics as tls
+
+
+@pytest.fixture
+def journal():
+    logger.enable("netcross_core")
+    lignes: list[tuple[str, str]] = []
+    sink = logger.add(lambda m: lignes.append((m.record["level"].name, m.record["message"])), level="TRACE")
+    yield lignes
+    logger.remove(sink)
+
+
+def _vu(journal, niveau, fragment):
+    return any(n == niveau and fragment in m for n, m in journal)
+
+
+def test_cas_particuliers_tls_en_trace(journal):
+    assert tls.parse_alert(b"\x02") == {}
+    assert tls.parse_client_hello(b"\x03\x03") == {}
+    assert tls.parse_server_hello(b"") == {}
+    assert _vu(journal, "TRACE", "alerte tronquee")
+    assert _vu(journal, "TRACE", "parse_client_hello: corps trop court")
+    assert _vu(journal, "TRACE", "parse_server_hello: corps trop court")
+
+
+def test_resumes_tls_en_debug(journal):
+    status = tls.build_handshake_status([])
+    tls.diagnose_tls(status)
+    assert _vu(journal, "DEBUG", "build_handshake_status: 0 evenement(s)")
+    assert _vu(journal, "DEBUG", "ordre alphabetique")
+    assert _vu(journal, "DEBUG", "diagnose_tls: 0 constat(s)")
+
+
+def test_quic_version_non_geree_et_resume(journal):
+    paquet = bytes([0xC0]) + (2).to_bytes(4, "big") + b"\x00" * 10
+    assert quic._parse_long_header(paquet) is None
+    assert quic.diagnose_quic([]) == []
+    assert _vu(journal, "TRACE", "version QUIC 0x00000002 non geree")
+    assert _vu(journal, "DEBUG", "sans ordre des points")