Comprehensive comparison for Observability technology in AI applications

import os
import uuid
from datetime import datetime
from arize.pandas.logger import Client, Schema
from arize.utils.types import ModelTypes, Environments
import pandas as pd
import openai
from typing import Dict, Any, Optional

# Initialize Arize client
arize_client = Client(
    space_key=os.environ.get('ARIZE_SPACE_KEY'),
    api_key=os.environ.get('ARIZE_API_KEY')
)

MODEL_ID = 'customer-support-chatbot'
MODEL_VERSION = 'v2.1.0'

class CustomerSupportBot:
    """Production chatbot with Arize observability integration."""
    
    def __init__(self):
        self.client = openai.OpenAI(api_key=os.environ.get('OPENAI_API_KEY'))
    
    def generate_response(self, user_message: str, context: Dict[str, Any]) -> Dict[str, Any]:
        """Generate chatbot response with full observability logging."""
        prediction_id = str(uuid.uuid4())
        timestamp = datetime.now().timestamp()
        
        try:
            # Call LLM
            response = self.client.chat.completions.create(
                model='gpt-4',
                messages=[
                    {'role': 'system', 'content': 'You are a helpful customer support agent.'},
                    {'role': 'user', 'content': user_message}
                ],
                temperature=0.7,
                max_tokens=500
            )
            
            bot_response = response.choices[0].message.content
            
            # Log to Arize
            self._log_to_arize(
                prediction_id=prediction_id,
                timestamp=timestamp,
                user_message=user_message,
                bot_response=bot_response,
                context=context,
                latency_ms=response.usage.total_tokens * 10  # Approximate
            )
            
            return {
                'prediction_id': prediction_id,
                'response': bot_response,
                'success': True
            }
            
        except Exception as e:
            # Log error case to Arize
            self._log_error_to_arize(prediction_id, timestamp, user_message, str(e))
            return {
                'prediction_id': prediction_id,
                'response': 'I apologize, but I encountered an error. Please try again.',
                'success': False,
                'error': str(e)
            }
    
    def _log_to_arize(self, prediction_id: str, timestamp: float, 
                      user_message: str, bot_response: str, 
                      context: Dict[str, Any], latency_ms: int):
        """Log prediction data to Arize for observability."""
        
        df = pd.DataFrame([{
            'prediction_id': prediction_id,
            'prediction_timestamp': timestamp,
            'user_message': user_message,
            'bot_response': bot_response,
            'user_id': context.get('user_id', 'unknown'),
            'session_id': context.get('session_id', 'unknown'),
            'user_sentiment': context.get('sentiment', 'neutral'),
            'conversation_length': context.get('conversation_length', 1),
            'latency_ms': latency_ms,
            'model_version': MODEL_VERSION
        }])
        
        schema = Schema(
            prediction_id_column_name='prediction_id',
            timestamp_column_name='prediction_timestamp',
            prompt_column_names=['user_message'],
            response_column_names=['bot_response'],
            tag_column_names=['user_id', 'session_id', 'user_sentiment', 'model_version'],
            feature_column_names=['conversation_length', 'latency_ms']
        )
        
        response = arize_client.log(
            dataframe=df,
            model_id=MODEL_ID,
            model_version=MODEL_VERSION,
            model_type=ModelTypes.GENERATIVE_LLM,
            environment=Environments.PRODUCTION,
            schema=schema
        )
        
        if response.status_code != 200:
            print(f'Arize logging failed: {response.text}')
    
    def _log_error_to_arize(self, prediction_id: str, timestamp: float, 
                            user_message: str, error: str):
        """Log error cases for monitoring."""
        df = pd.DataFrame([{
            'prediction_id': prediction_id,
            'prediction_timestamp': timestamp,
            'user_message': user_message,
            'bot_response': 'ERROR',
            'error_message': error,
            'model_version': MODEL_VERSION
        }])
        
        schema = Schema(
            prediction_id_column_name='prediction_id',
            timestamp_column_name='prediction_timestamp',
            prompt_column_names=['user_message'],
            response_column_names=['bot_response'],
            tag_column_names=['error_message', 'model_version']
        )
        
        arize_client.log(
            dataframe=df,
            model_id=MODEL_ID,
            model_version=MODEL_VERSION,
            model_type=ModelTypes.GENERATIVE_LLM,
            environment=Environments.PRODUCTION,
            schema=schema
        )

# Usage example
if __name__ == '__main__':
    bot = CustomerSupportBot()
    result = bot.generate_response(
        user_message='How do I reset my password?',
        context={
            'user_id': 'user_12345',
            'session_id': 'sess_67890',
            'sentiment': 'neutral',
            'conversation_length': 3
        }
    )
    print(f"Response: {result['response']}")