Files
mtusi2026lab6/app/observability/runtime.py

118 lines
4.9 KiB
Python

from __future__ import annotations
import logging
import os
import socket
import sys
from dataclasses import dataclass
from opentelemetry import metrics, trace
from opentelemetry._logs import set_logger_provider
from opentelemetry.exporter.otlp.proto.http._log_exporter import OTLPLogExporter
from opentelemetry.exporter.otlp.proto.http.metric_exporter import OTLPMetricExporter
from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
from opentelemetry.sdk._logs import LoggerProvider, LoggingHandler
from opentelemetry.sdk._logs.export import BatchLogRecordProcessor
from opentelemetry.sdk.metrics import MeterProvider
from opentelemetry.sdk.metrics.export import PeriodicExportingMetricReader
from opentelemetry.sdk.metrics.view import ExplicitBucketHistogramAggregation, View
from opentelemetry.sdk.resources import Resource
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from .config import load_observability_settings
from .logging import JsonFormatter
from .metrics import HTTP_BUCKETS, JOB_BUCKETS, READY_BUCKETS
@dataclass(slots=True)
class ObservabilityRuntime:
tracer_provider: TracerProvider | None = None
meter_provider: MeterProvider | None = None
logger_provider: LoggerProvider | None = None
def shutdown(self) -> None:
if self.logger_provider is not None:
self.logger_provider.shutdown()
if self.meter_provider is not None:
self.meter_provider.shutdown()
if self.tracer_provider is not None:
self.tracer_provider.shutdown()
_runtime: ObservabilityRuntime | None = None
def initialize_observability(default_service_name: str) -> ObservabilityRuntime:
global _runtime
if _runtime is not None:
return _runtime
settings = load_observability_settings(default_service_name)
console = logging.StreamHandler(sys.stdout)
console.setFormatter(JsonFormatter())
handlers: list[logging.Handler] = [console]
runtime = ObservabilityRuntime()
if settings.enabled:
resource = Resource.create({
'service.name': settings.service_name,
'service.version': settings.service_version,
'service.instance.id': os.getenv(
'INSTANCE_ID', f'{socket.gethostname()}:{os.getpid()}'
),
'deployment.environment.name': settings.environment,
})
timeout = settings.export_timeout_seconds
tracer_provider = TracerProvider(resource=resource)
tracer_provider.add_span_processor(BatchSpanProcessor(
OTLPSpanExporter(endpoint=f'{settings.endpoint}/v1/traces', timeout=timeout),
max_queue_size=settings.span_queue_size,
max_export_batch_size=min(512, settings.span_queue_size),
schedule_delay_millis=1000,
export_timeout_millis=timeout * 1000,
))
trace.set_tracer_provider(tracer_provider)
metric_reader = PeriodicExportingMetricReader(
OTLPMetricExporter(endpoint=f'{settings.endpoint}/v1/metrics', timeout=timeout),
export_interval_millis=settings.metric_export_interval_ms,
export_timeout_millis=timeout * 1000,
)
meter_provider = MeterProvider(
resource=resource,
metric_readers=[metric_reader],
views=[
View(
instrument_name='http.server.request.duration',
aggregation=ExplicitBucketHistogramAggregation(HTTP_BUCKETS),
),
View(
instrument_name='messenger.job.processing.duration',
aggregation=ExplicitBucketHistogramAggregation(JOB_BUCKETS),
),
View(
instrument_name='messenger.attachment.time_to_ready',
aggregation=ExplicitBucketHistogramAggregation(READY_BUCKETS),
),
],
)
metrics.set_meter_provider(meter_provider)
logger_provider = LoggerProvider(resource=resource)
logger_provider.add_log_record_processor(BatchLogRecordProcessor(
OTLPLogExporter(endpoint=f'{settings.endpoint}/v1/logs', timeout=timeout),
max_queue_size=settings.log_queue_size,
max_export_batch_size=min(512, settings.log_queue_size),
schedule_delay_millis=1000,
export_timeout_millis=timeout * 1000,
))
set_logger_provider(logger_provider)
otlp_handler = LoggingHandler(level=logging.NOTSET, logger_provider=logger_provider)
otlp_handler.setFormatter(JsonFormatter())
handlers.append(otlp_handler)
runtime = ObservabilityRuntime(tracer_provider, meter_provider, logger_provider)
logging.basicConfig(
level=os.getenv('LOG_LEVEL', 'info').upper(), handlers=handlers, force=True
)
_runtime = runtime
return runtime