# requirements.txt
pyroscope-io

# main.py
import pyroscope

pyroscope.configure(
    application_name="myapp.python",
    server_address="http://pyroscope:4040",
    sample_rate=100,  # Hz
)

# Your Python code

# Automatic profiling with py-spy
pyroscope.configure(
    application_name="myapp.python",
    server_address="http://pyroscope:4040",
    detect_subprocesses=True,
    oncpu=True,
    gil_only=True,  # Only profile when GIL is held
)

# Automated memory leak detection
import pyroscope
import requests

def check_memory_growth():
    # Query memory profile growth over time
    response = requests.get(
        "http://pyroscope:4040/api/v1/query",
        params={
            "name": "myapp.alloc_space",
            "from": "now-24h",
            "until": "now",
            "max-nodes": 1024
        }
    )
    
    profile_data = response.json()
    # Analyze growth patterns
    return analyze_growth_trend(profile_data)

import pyroscope
import asyncio
from contextlib import contextmanager

# Configure Pyroscope
pyroscope.configure(
    application_name="myapp.python.async",
    server_address="http://pyroscope:4040",
    tags={
        "version": os.environ.get("APP_VERSION"),
        "environment": "production",
    }
)

@contextmanager
def profile_region(region_name):
    """Custom profiling context manager"""
    with pyroscope.tag_wrapper({"region": region_name}):
        yield

async def process_request():
    with profile_region("request_processing"):
        await do_async_work()
        
    with profile_region("database_query"):
        result = await query_database()
        
    return result

import requests
import json
from datetime import datetime, timedelta

class PyroscopeClient:
    def __init__(self, base_url):
        self.base_url = base_url
        
    def query_profile(self, app_name, from_time, to_time, tags=None, max_nodes=8192):
        """Query profile data with advanced filtering"""
        params = {
            "name": app_name,
            "from": from_time,
            "until": to_time,
            "max-nodes": max_nodes,
        }
        
        if tags:
            for key, value in tags.items():
                params[f"tag.{key}"] = value
                
        response = requests.get(
            f"{self.base_url}/api/v1/query",
            params=params
        )
        return response.json()
        
    def compare_profiles(self, app_name, baseline_period, comparison_period):
        """Compare two time periods"""
        baseline = self.query_profile(
            app_name, 
            baseline_period['from'], 
            baseline_period['to']
        )
        
        comparison = self.query_profile(
            app_name,
            comparison_period['from'],
            comparison_period['to']
        )
        
        return {
            "baseline": baseline,
            "comparison": comparison,
            "diff": self._calculate_diff(baseline, comparison)
        }
        
    def _calculate_diff(self, baseline, comparison):
        """Calculate performance difference between profiles"""
        # Implementation for profile comparison logic
        pass

# Usage
client = PyroscopeClient("http://pyroscope:4040")

# Query current performance
current_profile = client.query_profile(
    "myapp.cpu",
    from_time="now-1h",
    to_time="now",
    tags={"environment": "production", "version": "v1.2.3"}
)

# Compare with previous version
comparison = client.compare_profiles(
    "myapp.cpu",
    baseline_period={"from": "now-48h", "to": "now-24h"},
    comparison_period={"from": "now-24h", "to": "now"}
)

import numpy as np
from scipy import stats
import requests

class PerformanceAnalyzer:
    def __init__(self, pyroscope_url):
        self.pyroscope_url = pyroscope_url
        
    def detect_regressions(self, app_name, lookback_hours=24):
        """Detect performance regressions using statistical analysis"""
        
        # Get baseline data (previous week, same day/hour)
        baseline_data = self._get_profile_metrics(
            app_name,
            from_time=f"now-{7*24+lookback_hours}h",
            to_time=f"now-{7*24}h"
        )
        
        # Get current data
        current_data = self._get_profile_metrics(
            app_name,
            from_time=f"now-{lookback_hours}h",
            to_time="now"
        )
        
        # Statistical comparison
        statistic, p_value = stats.ttest_ind(
            baseline_data['cpu_samples'],
            current_data['cpu_samples']
        )
        
        regression_detected = p_value < 0.05 and statistic < -2.0
        
        return {
            "regression_detected": regression_detected,
            "confidence": 1.0 - p_value,
            "performance_change": self._calculate_change_percentage(
                baseline_data, current_data
            ),
            "top_functions": self._identify_regressed_functions(
                baseline_data, current_data
            )
        }
        
    def _get_profile_metrics(self, app_name, from_time, to_time):
        """Extract metrics from profile data"""
        response = requests.get(
            f"{self.pyroscope_url}/api/v1/query",
            params={
                "name": app_name,
                "from": from_time,
                "until": to_time,
                "format": "json"
            }
        )
        
        profile_data = response.json()
        return self._process_profile_data(profile_data)
        
    def _process_profile_data(self, profile_data):
        """Process raw profile data into metrics"""
        # Extract CPU samples, function call counts, etc.
        return {
            "cpu_samples": [],  # Processed sample data
            "function_calls": {},  # Function-level metrics
            "memory_allocations": []  # Memory allocation data
        }

class MemoryLeakDetector:
    def __init__(self, pyroscope_client):
        self.client = pyroscope_client
        
    def detect_memory_leaks(self, app_name, analysis_period_hours=24):
        """Detect memory leaks using trend analysis"""
        
        # Get memory allocation data
        alloc_data = self.client.query_profile(
            f"{app_name}.alloc_space",
            from_time=f"now-{analysis_period_hours}h",
            to_time="now",
            tags={"environment": "production"}
        )
        
        # Get memory usage data
        inuse_data = self.client.query_profile(
            f"{app_name}.inuse_space",
            from_time=f"now-{analysis_period_hours}h",
            to_time="now",
            tags={"environment": "production"}
        )
        
        # Analyze trends
        leak_indicators = self._analyze_memory_trends(alloc_data, inuse_data)
        
        return {
            "leak_probability": leak_indicators["probability"],
            "growth_rate": leak_indicators["growth_rate"],
            "suspected_functions": leak_indicators["functions"],
            "recommended_actions": self._generate_recommendations(leak_indicators)
        }
        
    def _analyze_memory_trends(self, alloc_data, inuse_data):
        """Analyze memory allocation and usage trends"""
        # Implementation for trend analysis
        return {
            "probability": 0.85,  # 85% probability of leak
            "growth_rate": "2.5MB/hour",
            "functions": ["process_request", "cache_handler"]
        }

# Custom alerting integration
import requests
from datetime import datetime, timedelta

class PyroscopeAlerting:
    def __init__(self, pyroscope_url, grafana_url, grafana_token):
        self.pyroscope_url = pyroscope_url
        self.grafana_url = grafana_url
        self.grafana_token = grafana_token
        
    def create_performance_alert(self, app_name, threshold_multiplier=1.5):
        """Create performance regression alert in Grafana"""
        
        alert_rule = {
            "uid": f"performance-{app_name}",
            "title": f"Performance Regression - {app_name}",
            "condition": "A",
            "data": [
                {
                    "refId": "A",
                    "queryType": "pyroscope",
                    "model": {
                        "expr": f"rate({app_name}.cpu[5m])",
                        "interval": "30s",
                    }
                }
            ],
            "intervalSeconds": 60,
            "maxDataPoints": 43200,
            "noDataState": "NoData",
            "execErrState": "Alerting"
        }
        
        response = requests.post(
            f"{self.grafana_url}/api/ruler/grafana/api/v1/rules/pyroscope",
            headers={
                "Authorization": f"Bearer {self.grafana_token}",
                "Content-Type": "application/json"
            },
            json=alert_rule
        )
        
        return response.status_code == 200

class BaselineComparator:
    def __init__(self, pyroscope_client):
        self.client = pyroscope_client
        
    def establish_baseline(self, app_name, baseline_period_days=7):
        """Establish performance baseline over specified period"""
        
        baseline_data = []
        
        for day in range(baseline_period_days):
            day_offset = day * 24
            daily_profile = self.client.query_profile(
                app_name,
                from_time=f"now-{day_offset + 24}h",
                to_time=f"now-{day_offset}h"
            )
            baseline_data.append(self._extract_key_metrics(daily_profile))
            
        baseline = {
            "cpu_percentile_95": np.percentile([d["cpu"] for d in baseline_data], 95),
            "memory_percentile_95": np.percentile([d["memory"] for d in baseline_data], 95),
            "top_functions": self._merge_function_data(baseline_data),
            "established_at": datetime.utcnow().isoformat()
        }
        
        return baseline
        
    def compare_to_baseline(self, app_name, baseline, current_period_hours=1):
        """Compare current performance to established baseline"""
        
        current_profile = self.client.query_profile(
            app_name,
            from_time=f"now-{current_period_hours}h",
            to_time="now"
        )
        
        current_metrics = self._extract_key_metrics(current_profile)
        
        comparison = {
            "cpu_deviation": (current_metrics["cpu"] - baseline["cpu_percentile_95"]) / baseline["cpu_percentile_95"],
            "memory_deviation": (current_metrics["memory"] - baseline["memory_percentile_95"]) / baseline["memory_percentile_95"],
            "new_hotspots": self._identify_new_hotspots(current_profile, baseline),
            "recommendation": self._generate_performance_recommendation(current_metrics, baseline)
        }
        
        return comparison

# Storage efficiency analysis
storage_comparison = {
    "pyroscope": {
        "compression_ratio": 0.95,  # 95% compression
        "storage_format": "columnar",
        "retention_scaling": "linear",
        "query_performance": "sub-second",
    },
    "parca": {
        "compression_ratio": 0.97,  # 97% compression
        "storage_format": "parquet",
        "retention_scaling": "linear",
        "query_performance": "sub-second",
    },
    "traditional_files": {
        "compression_ratio": 0.70,  # 70% compression
        "storage_format": "gzip",
        "retention_scaling": "exponential",
        "query_performance": "minutes",
    }
}