Files
plba_v2/tests/test_observability.py
2026-10-10 19:36:32 +03:00

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()