Comprehensive comparison for Observability technology in AI applications

import coralogix_logger
import openai
import time
import json
from flask import Flask, request, jsonify
from coralogix.handlers import CoralogixLogger

app = Flask(__name__)

# Initialize Coralogix logger
CORALOGIX_PRIVATE_KEY = "your-private-key"
CORALOGIX_APP_NAME = "ai-chatbot-service"
CORALOGIX_SUBSYSTEM = "openai-integration"

coralogix_handler = CoralogixLogger(
    CORALOGIX_PRIVATE_KEY,
    CORALOGIX_APP_NAME,
    CORALOGIX_SUBSYSTEM
)

@app.route('/api/chat', methods=['POST'])
def chat_completion():
    """AI chatbot endpoint with comprehensive Coralogix observability"""
    start_time = time.time()
    request_id = request.headers.get('X-Request-ID', 'unknown')
    
    try:
        # Log incoming request
        user_message = request.json.get('message', '')
        user_id = request.json.get('user_id', 'anonymous')
        model = request.json.get('model', 'gpt-3.5-turbo')
        
        coralogix_handler.log(
            "info",
            f"Chat request received",
            {
                "request_id": request_id,
                "user_id": user_id,
                "model": model,
                "message_length": len(user_message),
                "timestamp": time.time()
            }
        )
        
        # Validate input
        if not user_message or len(user_message) > 4000:
            coralogix_handler.log(
                "warning",
                "Invalid message length",
                {"request_id": request_id, "length": len(user_message)}
            )
            return jsonify({"error": "Invalid message length"}), 400
        
        # Call OpenAI API with observability
        try:
            response = openai.ChatCompletion.create(
                model=model,
                messages=[{"role": "user", "content": user_message}],
                temperature=0.7,
                max_tokens=500
            )
            
            ai_response = response.choices[0].message.content
            tokens_used = response.usage.total_tokens
            
            # Log successful AI response with metrics
            duration = time.time() - start_time
            coralogix_handler.log(
                "info",
                "AI response generated successfully",
                {
                    "request_id": request_id,
                    "user_id": user_id,
                    "model": model,
                    "tokens_used": tokens_used,
                    "prompt_tokens": response.usage.prompt_tokens,
                    "completion_tokens": response.usage.completion_tokens,
                    "duration_ms": duration * 1000,
                    "response_length": len(ai_response),
                    "finish_reason": response.choices[0].finish_reason
                }
            )
            
            return jsonify({
                "response": ai_response,
                "tokens_used": tokens_used,
                "request_id": request_id
            }), 200
            
        except openai.error.RateLimitError as e:
            coralogix_handler.log(
                "error",
                "OpenAI rate limit exceeded",
                {
                    "request_id": request_id,
                    "error": str(e),
                    "user_id": user_id
                }
            )
            return jsonify({"error": "Service temporarily unavailable"}), 429
            
        except openai.error.APIError as e:
            coralogix_handler.log(
                "error",
                "OpenAI API error",
                {
                    "request_id": request_id,
                    "error": str(e),
                    "model": model
                }
            )
            return jsonify({"error": "AI service error"}), 503
            
    except Exception as e:
        # Log unexpected errors
        coralogix_handler.log(
            "critical",
            "Unexpected error in chat endpoint",
            {
                "request_id": request_id,
                "error": str(e),
                "error_type": type(e).__name__,
                "duration_ms": (time.time() - start_time) * 1000
            }
        )
        return jsonify({"error": "Internal server error"}), 500

if __name__ == '__main__':
    app.run(debug=False, host='0.0.0.0', port=5000)