forked from mtusi2026/mtusi2026lab6
Add the OpenTelemetry API and SDK, the OTLP over HTTP exporter and the FastAPI and asyncpg instrumentations to the lock, and a platform module that builds one resource per process (service.name, service.version, service.instance.id as hostname and pid, deployment.environment.name from OTEL_RESOURCE_ATTRIBUTES), batch processors for traces and logs, a periodic metric reader, PostgreSQL client spans and a bounded shutdown in a daemon thread instead of the 30 s flush of the SDK. The SDK stays off without a Collector address or with OTEL_SDK_DISABLED. The sampler lets only server, consumer and producer spans open a trace, so readiness probes, outbox polls and sweeps do not become one-span traces. Log records carry trace_id and span_id in stdout and go to OTLP through a handler that keeps only the allowlisted fields, and deferred event subscribers now run in the context the event was emitted in, so audit records stay linked to their request or job. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
126 lines
3.6 KiB
Python
126 lines
3.6 KiB
Python
import logging
|
|
import sys
|
|
from typing import Any
|
|
|
|
import orjson
|
|
import structlog
|
|
from opentelemetry import trace
|
|
from structlog.typing import EventDict, Processor, WrappedLogger
|
|
|
|
PLATFORM_FIELDS = frozenset(
|
|
{
|
|
"method",
|
|
"route",
|
|
"status",
|
|
"duration_ms",
|
|
"request_id",
|
|
"event_name",
|
|
"error",
|
|
"reason",
|
|
"limit",
|
|
"trace_id",
|
|
"span_id",
|
|
}
|
|
)
|
|
|
|
|
|
def render(obj: object, **_kwargs: object) -> str:
|
|
return orjson.dumps(obj).decode()
|
|
|
|
|
|
RESERVED = frozenset({"event", "level", "ts", "logger"})
|
|
|
|
FOREIGN_LOGGERS = (
|
|
"uvicorn",
|
|
"uvicorn.error",
|
|
"gunicorn",
|
|
"gunicorn.error",
|
|
"asyncio",
|
|
)
|
|
|
|
SILENCED_LOGGERS = ("uvicorn.access", "gunicorn.access")
|
|
|
|
|
|
def field_filter(allowed: frozenset[str]) -> Processor:
|
|
def drop_unlisted_fields(
|
|
_logger: WrappedLogger, _method: str, event_dict: EventDict
|
|
) -> EventDict:
|
|
return {
|
|
key: value
|
|
for key, value in event_dict.items()
|
|
if (key in RESERVED or key in allowed) and value is not None
|
|
}
|
|
|
|
return drop_unlisted_fields
|
|
|
|
|
|
def add_trace_context(_logger: WrappedLogger, _method: str, event_dict: EventDict) -> EventDict:
|
|
context = trace.get_current_span().get_span_context()
|
|
if context.is_valid:
|
|
event_dict["trace_id"] = trace.format_trace_id(context.trace_id)
|
|
event_dict["span_id"] = trace.format_span_id(context.span_id)
|
|
return event_dict
|
|
|
|
|
|
def configure(level: str = "INFO", allowed_fields: frozenset[str] = PLATFORM_FIELDS) -> None:
|
|
shared = [
|
|
structlog.contextvars.merge_contextvars,
|
|
structlog.processors.add_log_level,
|
|
structlog.processors.TimeStamper(fmt="iso", utc=True, key="ts"),
|
|
add_trace_context,
|
|
]
|
|
structlog.configure(
|
|
processors=[*shared, structlog.stdlib.ProcessorFormatter.wrap_for_formatter],
|
|
logger_factory=structlog.stdlib.LoggerFactory(),
|
|
wrapper_class=structlog.stdlib.BoundLogger,
|
|
cache_logger_on_first_use=False,
|
|
)
|
|
handler = logging.StreamHandler(sys.stdout)
|
|
handler.setFormatter(
|
|
structlog.stdlib.ProcessorFormatter(
|
|
foreign_pre_chain=shared,
|
|
processors=[
|
|
structlog.stdlib.ProcessorFormatter.remove_processors_meta,
|
|
field_filter(allowed_fields),
|
|
structlog.processors.JSONRenderer(serializer=render),
|
|
],
|
|
)
|
|
)
|
|
root = logging.getLogger()
|
|
for existing in list(root.handlers):
|
|
root.removeHandler(existing)
|
|
root.addHandler(handler)
|
|
root.setLevel(level.upper())
|
|
for name in FOREIGN_LOGGERS:
|
|
foreign = logging.getLogger(name)
|
|
for existing in list(foreign.handlers):
|
|
foreign.removeHandler(existing)
|
|
foreign.propagate = True
|
|
for name in SILENCED_LOGGERS:
|
|
silenced = logging.getLogger(name)
|
|
for existing in list(silenced.handlers):
|
|
silenced.removeHandler(existing)
|
|
silenced.propagate = False
|
|
|
|
|
|
class StructlogLogger:
|
|
__slots__ = ("_logger",)
|
|
|
|
def __init__(
|
|
self,
|
|
name: str = "messenger",
|
|
level: str = "INFO",
|
|
allowed_fields: frozenset[str] = PLATFORM_FIELDS,
|
|
) -> None:
|
|
configure(level, allowed_fields)
|
|
self._logger = structlog.get_logger(name)
|
|
|
|
def info(self, event: str, /, **fields: Any) -> None:
|
|
self._logger.info(event, **fields)
|
|
|
|
def warning(self, event: str, /, **fields: Any) -> None:
|
|
self._logger.warning(event, **fields)
|
|
|
|
def error(self, event: str, /, **fields: Any) -> None:
|
|
self._logger.error(event, **fields)
|