// Production web server with tcmalloc profiling
class WebServerProfiler {
private:
    std::atomic<bool> profiling_enabled{false};
    std::string profile_base_path;
    
public:
    void initialize_profiling() {
        profile_base_path = "/var/log/webserver/heap_profile";
        
        // Start with conservative sampling
        setenv("HEAP_PROFILE_ALLOCATION_INTERVAL", "67108864", 1); // 64MB
        HeapProfilerStart(profile_base_path.c_str());
        profiling_enabled = true;
    }
    
    void periodic_health_check() {
        if (!profiling_enabled) return;
        
        // Check for memory growth patterns
        auto current_heap_size = get_heap_size();
        if (current_heap_size > memory_threshold) {
            HeapProfilerDump("growth_alert");
            send_alert("Memory growth detected");
        }
    }
};

#include <gperftools/heap-profiler.h>
#include <gperftools/malloc_extension.h>
#include <chrono>
#include <thread>

class MemoryLeakDetector {
private:
    size_t baseline_memory = 0;
    std::chrono::steady_clock::time_point start_time;
    const size_t LEAK_THRESHOLD = 50 * 1024 * 1024; // 50MB
    
public:
    void start_monitoring(const std::string& profile_path) {
        // Initialize heap profiler
        HeapProfilerStart(profile_path.c_str());
        
        // Record baseline
        MallocExtension::instance()->GetNumericProperty(
            "generic.current_allocated_bytes", &baseline_memory);
        start_time = std::chrono::steady_clock::now();
        
        // Start monitoring thread
        std::thread monitor_thread(&MemoryLeakDetector::monitor_loop, this);
        monitor_thread.detach();
    }
    
private:
    void monitor_loop() {
        while (true) {
            std::this_thread::sleep_for(std::chrono::minutes(5));
            
            size_t current_memory = 0;
            MallocExtension::instance()->GetNumericProperty(
                "generic.current_allocated_bytes", &current_memory);
            
            if (current_memory > baseline_memory + LEAK_THRESHOLD) {
                auto now = std::chrono::steady_clock::now();
                auto duration = std::chrono::duration_cast<std::chrono::minutes>(
                    now - start_time).count();
                
                std::string dump_name = "leak_detected_" + std::to_string(duration) + "min";
                HeapProfilerDump(dump_name.c_str());
                
                log_leak_alert(current_memory, baseline_memory, duration);
            }
        }
    }
    
    void log_leak_alert(size_t current, size_t baseline, long duration) {
        size_t leaked = current - baseline;
        double rate = static_cast<double>(leaked) / duration; // bytes per minute
        
        printf("MEMORY LEAK DETECTED:\n");
        printf("  Current allocation: %zu bytes\n", current);
        printf("  Baseline: %zu bytes\n", baseline);
        printf("  Leaked: %zu bytes\n", leaked);
        printf("  Rate: %.2f bytes/minute\n", rate);
        printf("  Profile dumped for analysis\n");
    }
};

#include <gperftools/malloc_extension.h>

// Configure sampling at runtime
void configure_heap_profiling() {
    // Set allocation sampling interval
    MallocExtension::instance()->SetNumericProperty(
        "tcmalloc.sampling_period_bytes", 1048576);
    
    // Configure release rate
    MallocExtension::instance()->SetNumericProperty(
        "tcmalloc.release_rate", 10.0);
    
    // Set maximum total thread cache size
    MallocExtension::instance()->SetNumericProperty(
        "tcmalloc.max_total_thread_cache_bytes", 33554432); // 32MB
}

// Query current settings
void print_malloc_stats() {
    size_t value;
    
    // Current heap size
    MallocExtension::instance()->GetNumericProperty(
        "generic.current_allocated_bytes", &value);
    printf("Current allocated: %zu bytes\n", value);
    
    // Peak heap size
    MallocExtension::instance()->GetNumericProperty(
        "generic.heap_size", &value);
    printf("Heap size: %zu bytes\n", value);
    
    // Thread cache usage
    MallocExtension::instance()->GetNumericProperty(
        "tcmalloc.current_total_thread_cache_bytes", &value);
    printf("Thread cache: %zu bytes\n", value);
}

#include <gperftools/malloc_extension.h>
#include <prometheus/counter.h>
#include <prometheus/gauge.h>

class TCMallocMetrics {
private:
    prometheus::Gauge& heap_size_gauge;
    prometheus::Gauge& allocated_bytes_gauge;
    prometheus::Counter& allocation_samples_counter;
    
public:
    TCMallocMetrics(prometheus::Registry& registry) :
        heap_size_gauge(prometheus::BuildGauge()
            .Name("tcmalloc_heap_size_bytes")
            .Help("Current heap size in bytes")
            .Register(registry).Add({})),
        allocated_bytes_gauge(prometheus::BuildGauge()
            .Name("tcmalloc_allocated_bytes")
            .Help("Currently allocated bytes")
            .Register(registry).Add({})),
        allocation_samples_counter(prometheus::BuildCounter()
            .Name("tcmalloc_allocation_samples_total")
            .Help("Total number of allocation samples")
            .Register(registry).Add({}))
    {
    }
    
    void update_metrics() {
        size_t heap_size, allocated_bytes;
        
        MallocExtension::instance()->GetNumericProperty(
            "generic.heap_size", &heap_size);
        MallocExtension::instance()->GetNumericProperty(
            "generic.current_allocated_bytes", &allocated_bytes);
        
        heap_size_gauge.Set(heap_size);
        allocated_bytes_gauge.Set(allocated_bytes);
    }
    
    void on_allocation_sample() {
        allocation_samples_counter.Increment();
    }
};

// Periodic metrics collection
void collect_tcmalloc_metrics(TCMallocMetrics& metrics) {
    while (true) {
        metrics.update_metrics();
        std::this_thread::sleep_for(std::chrono::seconds(10));
    }
}