Rewrite every log call as an event name with typed fields

Prose f-strings become past-tense events with consistent field names
across services (account_id, transaction_id, amount_minor, risk_score,
status_code, consumer_group, message_id, chaos_flag). The orchestrator
and both consumers move from logging.getLogger to structlog so they can
pass fields.

New events cover what was silent before: the gateway's UpstreamFailure
path (transaction_failed, with the underlying cause), fraud's score and
sanctions' screening outcomes, and each successfully processed stream
message. holder_name is no longer logged at all.

"lookup" and "healthz" still appear in exactly one event each, so the
pathology tests' log-line counts are unchanged until they move to LogQL.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

services/fraud/app.py

@@ -43,7 +43,7 @@ async def root():
 @app.get("/healthz")
 async def healthz(request: Request):
     if request.headers.get("X-Ledgerline-Probe") == "chatty-health":
-        logger.info("received chatty-health healthz probe from gateway")
+        logger.info("healthz_probe_received", probe="chatty-health")
     return {"status": "ok", "service": SERVICE_NAME}
 
 
@@ -55,18 +55,23 @@ async def readyz():
         span = trace.get_current_span()
         span.record_exception(exc)
         span.set_status(StatusCode.ERROR, str(exc))
-        logger.exception(f"readyz check failed: {exc}")
+        logger.exception("readyz_check_failed")
         return JSONResponse(status_code=503, content={"status": "unavailable"})
     return {"status": "ok"}
 
 
 @app.post("/internal/score")
 async def score_transaction(body: ScoreRequest):
-    logger.info(f"scoring account {body.account_id}")
+    logger.info(
+        "score_requested",
+        account_id=body.account_id,
+        amount_minor=body.amount_minor,
+        category_id=body.category_id,
+    )
     await redis_client.incr("fraud:calls_total")
 
     if await chaos.blocking_event_loop_enabled():
-        logger.info(f"blocking_event_loop chaos engaged for account {body.account_id}")
+        logger.info("chaos_engaged", chaos_flag="blocking_event_loop", account_id=body.account_id)
         chaos.synchronous_cpu_work()
 
     with tracer.start_as_current_span(
@@ -87,20 +92,25 @@ async def score_transaction(body: ScoreRequest):
             except httpx.TimeoutException as exc:
                 span.record_exception(exc)
                 span.set_status(StatusCode.ERROR, "sanctions lookup timed out")
-                logger.exception(f"sanctions lookup timed out for account {body.account_id}")
+                logger.exception("sanctions_check_timed_out", account_id=body.account_id)
                 return JSONResponse(status_code=504, content={"error": "sanctions lookup timed out"})
             except httpx.RequestError as exc:
                 span.record_exception(exc)
                 span.set_status(StatusCode.ERROR, "sanctions lookup failed")
-                logger.exception(f"sanctions lookup failed for account {body.account_id}: {exc}")
+                logger.exception("sanctions_check_failed", account_id=body.account_id)
                 return JSONResponse(status_code=502, content={"error": "sanctions lookup failed"})
 
         if resp.status_code >= 300:
-            logger.info(f"sanctions returned {resp.status_code} for account {body.account_id}")
+            logger.warning(
+                "sanctions_check_failed", account_id=body.account_id, status_code=resp.status_code
+            )
             return JSONResponse(status_code=502, content={"error": "sanctions lookup failed"})
 
         matched = resp.json().get("matched", False)
         risk_score = score(body.category_id, matched)
         span.set_attribute("ledgerline.sanctions.matched", matched)
         span.set_attribute("ledgerline.risk.score", risk_score)
+        logger.info(
+            "transaction_scored", account_id=body.account_id, risk_score=risk_score, matched=matched
+        )
         return {"risk_score": risk_score, "matched": matched}