131 lines
4.7 KiB
Python
131 lines
4.7 KiB
Python
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()
|