"""真实 OpenTelemetry SDK，内存导出器；未验证 OTLP 后端。"""
from contextvars import ContextVar
import json
import logging
import sqlite3
import time

from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import SimpleSpanProcessor
from opentelemetry.sdk.trace.export.in_memory_span_exporter import InMemorySpanExporter
from opentelemetry.sdk.metrics import MeterProvider
from opentelemetry.sdk.metrics.export import InMemoryMetricReader
from opentelemetry.trace import Status, StatusCode


request_id = ContextVar("request_id", default="-")


class JsonHandler(logging.Handler):
    def __init__(self):
        super().__init__()
        self.records = []

    def emit(self, record):
        context = trace.get_current_span().get_span_context()
        entry = {"request_id": request_id.get(), "trace_id": format(context.trace_id, "032x"),
                 "event": record.getMessage(), "level": record.levelname}
        self.records.append(entry)
        print(json.dumps(entry, sort_keys=True))


def main():
    exporter = InMemorySpanExporter()
    traces = TracerProvider()
    traces.add_span_processor(SimpleSpanProcessor(exporter))
    tracer = traces.get_tracer("series.observability")
    reader = InMemoryMetricReader()
    meters = MeterProvider(metric_readers=[reader])
    meter = meters.get_meter("series.observability")
    requests = meter.create_counter("requests", unit="1")
    latency = meter.create_histogram("request.duration", unit="s")
    handler = JsonHandler()
    logger = logging.getLogger("series.observability")
    logger.setLevel(logging.INFO)
    logger.propagate = False
    logger.addHandler(handler)
    connection = sqlite3.connect(":memory:", autocommit=True)
    connection.execute("CREATE TABLE events(id INTEGER PRIMARY KEY)")
    connection.execute("INSERT INTO events VALUES(1)")
    # 教学注入：SQLite 用户函数休眠，不把它称为真实锁等待。
    connection.create_function("training_delay", 0, lambda: time.sleep(0.02) or 1)
    try:
        for number in range(3):
            token = request_id.set(f"request-{number}")
            start = time.monotonic()
            status = "200"
            try:
                with tracer.start_as_current_span("GET /counts") as root:
                    root.set_attribute("http.route", "/counts")
                    logger.info("request.start")
                    try:
                        with tracer.start_as_current_span("database.query") as database:
                            database.set_attribute("db.system.name", "sqlite")
                            if number == 1:
                                connection.execute("SELECT training_delay() FROM events").fetchall()
                            elif number == 2:
                                connection.execute("SELECT * FROM missing_table").fetchall()
                            else:
                                connection.execute("SELECT * FROM events").fetchall()
                        logger.info("request.success")
                    except sqlite3.OperationalError:
                        status = "500"
                        root.set_status(Status(StatusCode.ERROR, "database operation failed"))
                        logger.error("request.database_failed")
                    root.set_attribute("http.response.status_code", int(status))
            finally:
                attributes = {"http.route": "/counts", "status": status}
                requests.add(1, attributes)
                latency.record(time.monotonic() - start, attributes)
                request_id.reset(token)
        spans = exporter.get_finished_spans()
        roots = [span for span in spans if span.name == "GET /counts"]
        children = [span for span in spans if span.name == "database.query"]
        assert len(roots) == len(children) == 3
        for root in roots:
            child = next(span for span in children if span.context.trace_id == root.context.trace_id)
            assert child.parent.span_id == root.context.span_id
            related = [entry for entry in handler.records if entry["trace_id"] == format(root.context.trace_id, "032x")]
            assert len(related) == 2
            assert related[0]["request_id"] == related[1]["request_id"]
        assert len({entry["trace_id"] for entry in handler.records}) == 3
        data = reader.get_metrics_data()
        points = [point for resource in data.resource_metrics for scope in resource.scope_metrics
                  for metric in scope.metrics if metric.name == "requests" for point in metric.data.data_points]
        assert sum(point.value for point in points) == 3
        assert all("request_id" not in point.attributes for point in points)
        slow = max(children, key=lambda span: span.end_time - span.start_time)
        assert slow.status.status_code != StatusCode.ERROR
        print("spans:", len(spans), "requests:", sum(point.value for point in points))
        print("slow candidate:", slow.name, "duration ns:", slow.end_time - slow.start_time)
    finally:
        connection.close()
        logger.removeHandler(handler)
        traces.shutdown()
        meters.shutdown()


if __name__ == "__main__":
    main()
