Comprehensive comparison for Observability technology in AI applications

import os
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.requests import RequestsInstrumentor
from opentelemetry.trace import Status, StatusCode
import openai
import time

# Initialize Dash0 OpenTelemetry tracing
trace.set_tracer_provider(TracerProvider())
tracer = trace.get_tracer(__name__)

# Configure OTLP exporter for Dash0
otlp_exporter = OTLPSpanExporter(
    endpoint=os.getenv("DASH0_ENDPOINT", "https://ingress.dash0.com:4317"),
    headers={"Authorization": f"Bearer {os.getenv('DASH0_AUTH_TOKEN')}"},
)
trace.get_tracer_provider().add_span_processor(BatchSpanProcessor(otlp_exporter))

# Auto-instrument HTTP requests
RequestsInstrumentor().instrument()

openai.api_key = os.getenv("OPENAI_API_KEY")

class CustomerSupportAgent:
    """AI-powered customer support with comprehensive observability"""
    
    def __init__(self):
        self.model = "gpt-4"
        self.max_tokens = 500
    
    def generate_response(self, customer_id: str, query: str, context: dict) -> dict:
        """Generate AI response with full tracing and error handling"""
        with tracer.start_as_current_span("customer_support.generate_response") as span:
            # Add customer context to span
            span.set_attribute("customer.id", customer_id)
            span.set_attribute("query.length", len(query))
            span.set_attribute("ai.model", self.model)
            span.set_attribute("ai.provider", "openai")
            
            try:
                # Build prompt with context
                with tracer.start_as_current_span("build_prompt") as prompt_span:
                    system_prompt = self._build_system_prompt(context)
                    prompt_span.set_attribute("prompt.tokens_estimate", len(system_prompt.split()))
                
                # Call OpenAI API
                with tracer.start_as_current_span("openai.chat_completion") as api_span:
                    start_time = time.time()
                    
                    response = openai.ChatCompletion.create(
                        model=self.model,
                        messages=[
                            {"role": "system", "content": system_prompt},
                            {"role": "user", "content": query}
                        ],
                        max_tokens=self.max_tokens,
                        temperature=0.7
                    )
                    
                    latency = time.time() - start_time
                    
                    # Record AI-specific metrics
                    api_span.set_attribute("ai.request.model", self.model)
                    api_span.set_attribute("ai.request.temperature", 0.7)
                    api_span.set_attribute("ai.request.max_tokens", self.max_tokens)
                    api_span.set_attribute("ai.response.tokens.prompt", response.usage.prompt_tokens)
                    api_span.set_attribute("ai.response.tokens.completion", response.usage.completion_tokens)
                    api_span.set_attribute("ai.response.tokens.total", response.usage.total_tokens)
                    api_span.set_attribute("ai.response.latency_ms", latency * 1000)
                    api_span.set_attribute("ai.response.finish_reason", response.choices[0].finish_reason)
                
                result = {
                    "response": response.choices[0].message.content,
                    "tokens_used": response.usage.total_tokens,
                    "latency_ms": latency * 1000
                }
                
                span.set_attribute("response.success", True)
                span.set_status(Status(StatusCode.OK))
                
                return result
                
            except openai.error.RateLimitError as e:
                span.set_status(Status(StatusCode.ERROR, "Rate limit exceeded"))
                span.record_exception(e)
                span.set_attribute("error.type", "rate_limit")
                raise
            except openai.error.InvalidRequestError as e:
                span.set_status(Status(StatusCode.ERROR, "Invalid request"))
                span.record_exception(e)
                span.set_attribute("error.type", "invalid_request")
                raise
            except Exception as e:
                span.set_status(Status(StatusCode.ERROR, str(e)))
                span.record_exception(e)
                span.set_attribute("error.type", "unknown")
                raise
    
    def _build_system_prompt(self, context: dict) -> str:
        """Build system prompt from customer context"""
        return f"""You are a helpful customer support agent. 
        Customer tier: {context.get('tier', 'standard')}
        Previous interactions: {context.get('interaction_count', 0)}
        Provide concise, helpful responses."""

# Example usage
if __name__ == "__main__":
    agent = CustomerSupportAgent()
    result = agent.generate_response(
        customer_id="cust_12345",
        query="How do I reset my password?",
        context={"tier": "premium", "interaction_count": 3}
    )