import json import logging from datetime import datetime, timezone from io import StringIO import unittest from uuid import UUID from typing import Any from plba.logging import TechnicalJsonFormatter, create_stdout_handler from plba.tracing import ( BusinessTraceContext, BusinessTraceMessage, BusinessTraceWriteError, PostgresBusinessTraceWriter, business_trace_context, ) class FakeTraceConnection: def __init__(self, error: Exception | None = None) -> None: self.calls: list[tuple[str, tuple[object, ...]]] = [] self.error = error async def execute(self, query: str, *parameters: object) -> str: self.calls.append((query, parameters)) if self.error: raise self.error return "INSERT 0 1" class FakeAcquire: def __init__(self, connection: FakeTraceConnection) -> None: self.connection = connection async def __aenter__(self) -> FakeTraceConnection: return self.connection async def __aexit__(self, *_: object) -> None: return None class FakeTracePool: def __init__(self, connection: FakeTraceConnection) -> None: self.connection = connection def acquire(self) -> FakeAcquire: return FakeAcquire(self.connection) class BusinessTraceAdapterTests(unittest.IsolatedAsyncioTestCase): async def test_adapter_adds_application_id_to_context_and_message(self) -> None: connection = FakeTraceConnection() writer = PostgresBusinessTraceWriter(FakeTracePool(connection), "orders", "app-42") trace_id = UUID("12345678-1234-4234-8234-123456789abc") event_time = datetime.now(timezone.utc) await writer.write_context( BusinessTraceContext( trace_id, "order", "create", event_time, {"application_id": "spoofed"} ) ) await writer.write_message( BusinessTraceMessage(trace_id, event_time, "reserve", "ok", "info", "stock reserved") ) self.assertEqual(len(connection.calls), 2) context_query, context_params = connection.calls[0] message_query, message_params = connection.calls[1] self.assertIn('"orders".trace_contexts', context_query) self.assertIn('"orders".trace_messages', message_query) self.assertEqual(json.loads(context_params[-1]), {"application_id": "app-42"}) self.assertEqual(json.loads(message_params[-1]), {"application_id": "app-42"}) async def test_database_failure_is_passed_without_retry(self) -> None: connection = FakeTraceConnection(RuntimeError("database unavailable")) writer = PostgresBusinessTraceWriter(FakeTracePool(connection), "orders", "app-42") trace_id = UUID("12345678-1234-4234-8234-123456789abc") message = BusinessTraceMessage( trace_id, datetime.now(timezone.utc), "step", "failed", "error", "failed" ) with self.assertRaises(BusinessTraceWriteError): await writer.write_message(message) self.assertEqual(len(connection.calls), 1) class TechnicalLoggingTests(unittest.TestCase): def test_formatter_emits_contract_and_async_context_trace_id(self) -> None: trace_id = UUID("12345678-1234-4234-8234-123456789abc") stream = StringIO() logger = logging.getLogger("plba.test.structured") logger.handlers.clear() logger.propagate = False logger.setLevel(logging.INFO) handler = logging.StreamHandler(stream) handler.setFormatter(TechnicalJsonFormatter("app-42")) logger.addHandler(handler) try: with business_trace_context(trace_id): logger.info("reservation completed", extra={"attributes": {"order_id": 81}}) logger.info("outside trace") finally: logger.removeHandler(handler) records = [json.loads(line) for line in stream.getvalue().splitlines()] self.assertEqual( set(records[0]), { "timestamp", "level", "logger", "message", "application_id", "attributes", "business_trace_id", }, ) self.assertTrue(records[0]["timestamp"].endswith("Z")) self.assertEqual(records[0]["application_id"], "app-42") self.assertEqual(records[0]["business_trace_id"], str(trace_id)) self.assertNotIn("business_trace_id", records[1]) def test_stdout_helper_uses_a_standard_stream_handler(self) -> None: handler = create_stdout_handler("app-42", StringIO()) self.assertIsInstance(handler, logging.StreamHandler) self.assertIsInstance(handler.formatter, TechnicalJsonFormatter) if __name__ == "__main__": unittest.main()