# tracing.py
from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor
from opentelemetry.instrumentation.sqlalchemy import SQLAlchemyInstrumentor
from opentelemetry.instrumentation.redis import RedisInstrumentor

def setup_telemetry(app):
    provider = TracerProvider()
    provider.add_span_processor(
        BatchSpanProcessor(OTLPSpanExporter(endpoint="http://otel-collector:4317"))
    )
    trace.set_tracer_provider(provider)
    
    FastAPIInstrumentor.instrument_app(app)
    SQLAlchemyInstrumentor().instrument()
    RedisInstrumentor().instrument()

from opentelemetry import trace

tracer = trace.get_tracer(__name__)

async def process_payment(order_id: str, amount: float, payment_method: str):
    with tracer.start_as_current_span("payment.process") as span:
        # Add business context to the span
        span.set_attribute("order.id", order_id)
        span.set_attribute("payment.amount", amount)
        span.set_attribute("payment.method", payment_method)
        
        try:
            # Validate
            with tracer.start_as_current_span("payment.validate"):
                await validate_payment_method(payment_method)
            
            # Charge
            with tracer.start_as_current_span("payment.charge") as charge_span:
                result = await charge_card(amount, payment_method)
                charge_span.set_attribute("payment.transaction_id", result.transaction_id)
            
            span.set_attribute("payment.status", "success")
            return result
            
        except PaymentDeclinedException as e:
            span.set_status(trace.StatusCode.ERROR, str(e))
            span.record_exception(e)
            span.set_attribute("payment.decline_reason", e.reason)
            raise

from opentelemetry import metrics

meter = metrics.get_meter(__name__)

# Counters
request_counter = meter.create_counter(
    "http.server.request.count",
    description="Total HTTP requests",
    unit="1"
)

# Histograms (for latency/size measurements)
request_duration = meter.create_histogram(
    "http.server.request.duration",
    description="HTTP request duration",
    unit="ms"
)

# Gauges (for current state)
active_connections = meter.create_observable_gauge(
    "db.client.connections.usage",
    callbacks=[lambda options: [metrics.Observation(get_active_db_connections())]],
    description="Active DB connections"
)

# Usage
def handle_request(method: str, path: str):
    start = time.time()
    status_code = 200
    
    try:
        result = process_request()
        return result
    except Exception as e:
        status_code = 500
        raise
    finally:
        duration_ms = (time.time() - start) * 1000
        labels = {"http.method": method, "http.route": path, "http.status_code": status_code}
        request_counter.add(1, labels)
        request_duration.record(duration_ms, labels)

import logging
import json
from opentelemetry import trace

class OTelLoggingHandler(logging.Handler):
    def emit(self, record):
        current_span = trace.get_current_span()
        ctx = current_span.get_span_context()
        
        log_entry = {
            "timestamp": self.formatTime(record),
            "level": record.levelname,
            "message": record.getMessage(),
            "logger": record.name,
        }
        
        # Inject trace context if we're in a span
        if ctx.is_valid:
            log_entry["trace_id"] = format(ctx.trace_id, '032x')
            log_entry["span_id"] = format(ctx.span_id, '016x')
            log_entry["trace_flags"] = ctx.trace_flags
        
        print(json.dumps(log_entry))

# Setup
logging.getLogger().addHandler(OTelLoggingHandler())