import httpx
import anthropic

async def analyze_profile(app_name: str, from_ts: int, until_ts: int):
    client = anthropic.Anthropic()

    # Fetch profile from Pyroscope API
    profile_data = httpx.get(
        "http://localhost:4040/render",
        params={
            "query": f"{app_name}.cpu",
            "from": from_ts,
            "until": until_ts,
            "format": "json",
            "max-nodes": 50
        }
    ).json()

    # Extract top hot paths
    nodes = sorted(profile_data.get('flamebearer', {}).get('names', []),
                   key=lambda x: x.get('self', 0), reverse=True)[:20]

    response = client.messages.create(
        model="claude-sonnet-4-5",
        max_tokens=1024,
        messages=[{
            "role": "user",
            "content": f"""Analyze this CPU profile from a Python web application.
The data shows the top 20 hottest stack frames by self CPU time.

Profile data:
{profile_data}

Identify:
1. The top performance bottleneck and why it's slow
2. Which frames suggest fixable inefficiencies vs expected overhead
3. Specific optimization recommendations with code examples
4. Whether this looks like CPU-bound or I/O-bound work"""
        }]
    )

    return response.content[0].text

import psycopg2
import anthropic

def analyze_slow_query(query: str, connection_string: str) -> str:
    client = anthropic.Anthropic()

    # Get the execution plan
    with psycopg2.connect(connection_string) as conn:
        with conn.cursor() as cur:
            cur.execute(f"EXPLAIN (ANALYZE, BUFFERS, FORMAT JSON) {query}")
            plan = cur.fetchone()[0]

    response = client.messages.create(
        model="claude-sonnet-4-5",
        max_tokens=1024,
        messages=[{
            "role": "user",
            "content": f"""Analyze this PostgreSQL query execution plan and explain the performance issues.

Query:
{query}

Execution Plan (JSON):
{plan}

Provide:
1. The main performance bottleneck (sequential scan, hash join, etc.)
2. Why it's slow (missing index, bad cardinality estimate, etc.)
3. The exact index to create, with the CREATE INDEX statement
4. Estimated improvement after the fix"""
        }]
    )

    return response.content[0].text

# Example usage
analysis = analyze_slow_query(
    """
    SELECT u.name, COUNT(o.id) as order_count, SUM(o.total) as revenue
    FROM users u
    LEFT JOIN orders o ON o.user_id = u.id
    WHERE u.created_at > '2025-01-01'
    GROUP BY u.id, u.name
    ORDER BY revenue DESC
    LIMIT 50
    """,
    "postgresql://localhost/myapp"
)
print(analysis)

# Webhook handler for Datadog alerts
from flask import Flask, request
import anthropic

app = Flask(__name__)
client = anthropic.Anthropic()

@app.route('/webhook/perf-alert', methods=['POST'])
def handle_alert():
    alert = request.json

    if alert['metric'] != 'p99_latency':
        return 'ok'

    # Fetch recent trace data
    traces = fetch_recent_traces(alert['service'], minutes=15)

    response = client.messages.create(
        model='claude-haiku-4-5',
        max_tokens=512,
        messages=[{
            'role': 'user',
            'content': f"""P99 latency alert for {alert['service']}.
Current: {alert['current_value']}ms, threshold: {alert['threshold']}ms.

Recent slow traces:
{traces}

What's the most likely cause? Is this a gradual degradation or a sudden spike?"""
        }]
    )

    # Post to Slack
    post_to_slack(f"AI triage for {alert['service']} alert:\n{response.content[0].text}")
    return 'ok'