from opentelemetry import trace
from opentelemetry.trace import Status, StatusCode
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
import opentelemetry.propagate as propagate

# Initialize (usually in app startup)
provider = TracerProvider()
provider.add_span_processor(
    BatchSpanProcessor(OTLPSpanExporter(endpoint="otel-collector:4317"))
)
trace.set_tracer_provider(provider)
tracer = trace.get_tracer(__name__)

# Use in your code
async def process_order(order_id: str, items: list[dict]):
    with tracer.start_as_current_span("process_order") as span:
        span.set_attribute("order.id", order_id)
        span.set_attribute("order.item_count", len(items))
        
        try:
            # Nested span for the inventory check
            with tracer.start_as_current_span("check_inventory") as inv_span:
                inventory = await check_inventory(items)
                inv_span.set_attribute("inventory.all_available", inventory.all_available)
                
                if not inventory.all_available:
                    inv_span.set_attribute("inventory.missing_items", 
                                          str(inventory.missing))
                    raise InsufficientInventory(inventory.missing)
            
            # Nested span for payment processing
            with tracer.start_as_current_span("charge_payment") as pay_span:
                payment = await charge_payment(order_id)
                pay_span.set_attribute("payment.transaction_id", payment.transaction_id)
                pay_span.set_attribute("payment.amount", payment.amount)
            
            span.set_status(Status(StatusCode.OK))
            return {"order_id": order_id, "status": "confirmed"}
        
        except Exception as e:
            span.set_status(Status(StatusCode.ERROR, str(e)))
            span.record_exception(e)
            raise

from opentelemetry import metrics
from opentelemetry.sdk.metrics import MeterProvider
from opentelemetry.sdk.metrics.export import PeriodicExportingMetricReader
from opentelemetry.exporter.otlp.proto.grpc.metric_exporter import OTLPMetricExporter

# Initialize meter
meter_provider = MeterProvider(
    metric_readers=[
        PeriodicExportingMetricReader(
            OTLPMetricExporter(endpoint="otel-collector:4317"),
            export_interval_millis=30_000
        )
    ]
)
metrics.set_meter_provider(meter_provider)
meter = metrics.get_meter(__name__)

# Create instruments
order_counter = meter.create_counter(
    name="orders.total",
    description="Total number of orders processed",
    unit="1"
)

order_revenue = meter.create_counter(
    name="orders.revenue",
    description="Total revenue from orders",
    unit="USD"
)

order_latency = meter.create_histogram(
    name="orders.processing_latency",
    description="Time to process an order",
    unit="ms"
)

checkout_queue_depth = meter.create_observable_gauge(
    name="checkout.queue_depth",
    callbacks=[lambda: [(queue.qsize(), {})]],
    description="Current checkout queue depth"
)

# Use in your business logic
async def process_order(order: Order):
    start = time.time()
    
    try:
        result = await _process_order_internal(order)
        
        # Record success metrics with dimensions
        order_counter.add(1, {
            "status": "success",
            "region": order.region,
            "tier": order.customer_tier,
        })
        order_revenue.add(order.total_amount, {
            "region": order.region,
            "payment_method": order.payment_method,
        })
        return result
    
    except Exception as e:
        order_counter.add(1, {
            "status": "error",
            "error_type": type(e).__name__,
            "region": order.region,
        })
        raise
    
    finally:
        order_latency.record(
            (time.time() - start) * 1000,
            {"region": order.region}
        )

import logging
from opentelemetry import trace
from opentelemetry.instrumentation.logging import LoggingInstrumentor

# Enable OTel log instrumentation (automatically injects trace_id into logs)
LoggingInstrumentor().instrument(set_logging_format=True)

logger = logging.getLogger(__name__)

# Now every log call automatically includes trace_id and span_id
def handle_request(request_id: str):
    logger.info("Processing request", extra={
        "request_id": request_id,
        "user_id": get_current_user_id(),
    })
    # Log output: {"message": "Processing request", "trace_id": "abc123", 
    #              "span_id": "def456", "request_id": "req-789", ...}

from opentelemetry.sdk.trace.sampling import TraceIdRatioBased, ALWAYS_ON, ALWAYS_OFF, ParentBased

# Sample 10% of traces, but always sample if parent was sampled
sampler = ParentBased(
    root=TraceIdRatioBased(0.1),  # 10% of new traces
    remote_parent_sampled=ALWAYS_ON,    # Always continue sampled traces
    remote_parent_not_sampled=ALWAYS_OFF
)