from fastapi import FastAPI, Request
import palantyra

app = FastAPI()

@app.on_event("startup")
async def startup_event():
    palantyra.initialize(
        project_api_key="your-api-key",
        service_name="fastapi-ai-service"
    )

@app.middleware("http")
async def trace_requests(request: Request, call_next):
    with palantyra.start_as_current_span(
        name=f"{request.method} {request.url.path}",
        metadata={
            "method": request.method,
            "path": request.url.path,
            "client_ip": request.client.host
        }
    ):
        response = await call_next(request)
        palantyra.set_span_attributes({
            "status_code": response.status_code
        })
        return response

@app.post("/chat")
async def chat_endpoint(message: str):
    with palantyra.start_as_current_span(name="Chat Handler"):
        response = await async_client.chat.completions.create(
            model="gpt-4",
            messages=[{"role": "user", "content": message}]
        )
        return {"response": response.choices[0].message.content}

# settings.py
MIDDLEWARE = [
    'myapp.middleware.PalantyraMiddleware',
    # ... other middleware
]

# middleware.py
import palantyra
from django.utils.deprecation import MiddlewareMixin

class PalantyraMiddleware(MiddlewareMixin):
    def __init__(self, get_response):
        self.get_response = get_response
        palantyra.initialize(
            project_api_key="your-api-key",
            service_name="django-ai-app"
        )
    
    def __call__(self, request):
        with palantyra.start_as_current_span(
            name=f"{request.method} {request.path}",
            metadata={
                "method": request.method,
                "path": request.path,
                "user": str(request.user) if request.user else None
            }
        ):
            response = self.get_response(request)
            palantyra.set_span_attributes({
                "status_code": response.status_code
            })
            return response

# views.py
from django.http import JsonResponse
import palantyra

@palantyra.observe(name="Chat View")
def chat_view(request):
    message = request.POST.get('message')
    response = client.chat.completions.create(
        model="gpt-4",
        messages=[{"role": "user", "content": message}]
    )
    return JsonResponse({
        "response": response.choices[0].message.content
    })

from flask import Flask, request, jsonify, g
import palantyra

app = Flask(__name__)

# Initialize on startup
palantyra.initialize(
    project_api_key="your-api-key",
    service_name="flask-ai-service"
)

@app.before_request
def before_request():
    g.trace_span = palantyra.start_as_current_span(
        name=f"{request.method} {request.path}",
        metadata={
            "method": request.method,
            "path": request.path
        }
    ).__enter__()

@app.after_request
def after_request(response):
    if hasattr(g, 'trace_span'):
        palantyra.set_span_attributes({
            "status_code": response.status_code
        })
        g.trace_span.__exit__(None, None, None)
    return response

@app.route('/chat', methods=['POST'])
@palantyra.observe(name="Chat Endpoint")
def chat():
    message = request.json.get('message')
    response = client.chat.completions.create(
        model="gpt-4",
        messages=[{"role": "user", "content": message}]
    )
    return jsonify({
        "response": response.choices[0].message.content
    })