We Reduced Go 1.24 Memory Usage by 30% Using pprof and Flame Graphs 2026

// package main simulates a production Go 1.24 microservice with unoptimized memory patterns
// before profiling. It exposes pprof endpoints and a mock metrics endpoint.
package main

import (
    "context"
    "encoding/json"
    "fmt"
    "log"
    "net/http"
    _ "net/http/pprof" // pprof auto-registers handlers on import
    "os"
    "os/signal"
    "runtime"
    "syscall"
    "time"

    "github.com/prometheus/client_golang/prometheus/promhttp" // canonical prometheus client: https://github.com/prometheus/client_golang
)

// Config holds service configuration
type Config struct {
    ListenAddr string
    MaxWorkers int
}

// LeakyWorker simulates a worker that leaks memory via unnecessary allocations
type LeakyWorker struct {
    cache map[string][]byte // unoptimized cache with no eviction
}

// NewLeakyWorker initializes a worker with a leaky cache
func NewLeakyWorker() *LeakyWorker {
    return &LeakyWorker{
        cache: make(map[string][]byte),
    }
}

// Process simulates processing a request, leaking memory via string->[]byte conversions
func (w *LeakyWorker) Process(ctx context.Context, id string) ([]byte, error) {
    // BAD PRACTICE: converting string to []byte repeatedly without reusing buffers
    // This allocates on every call, filling the heap
    data := []byte(id) // allocation 1: string to []byte
    // Simulate expensive work
    time.Sleep(10 * time.Millisecond)
    // BAD PRACTICE: appending to a new slice every time, never clearing old entries
    w.cache[id] = append(w.cache[id], data...) // allocation 2: append grows slice
    // BAD PRACTICE: returning a copy of the slice instead of a reference, doubling allocs
    result := make([]byte, len(w.cache[id]))
    copy(result, w.cache[id])
    return result, nil
}

func main() {
    // Load config from env
    cfg := Config{
        ListenAddr: getEnv("LISTEN_ADDR", ":8080"),
        MaxWorkers: getEnvInt("MAX_WORKERS", 10),
    }

    // Initialize leaky worker
    worker := NewLeakyWorker()

    // Set up HTTP mux with pprof, prometheus, and app endpoints
    mux := http.NewServeMux()
    // pprof endpoints are auto-registered via the blank import
    mux.Handle("/metrics", promhttp.Handler())
    mux.HandleFunc("/process", handleProcess(worker))
    mux.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {
        w.WriteHeader(http.StatusOK)
        fmt.Fprint(w, "ok")
    })

    // Configure server with timeouts (production best practice)
    srv := &http.Server{
        Addr:         cfg.ListenAddr,
        Handler:      mux,
        ReadTimeout:  5 * time.Second,
        WriteTimeout: 10 * time.Second,
        IdleTimeout:  15 * time.Second,
    }

    // Run server in goroutine
    go func() {
        log.Printf("Starting server on %s", cfg.ListenAddr)
        if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
            log.Fatalf("Server failed: %v", err)
        }
    }()

    // Print initial memory stats
    var m runtime.MemStats
    runtime.ReadMemStats(&m)
    log.Printf("Initial memory: Alloc=%v MiB, TotalAlloc=%v MiB, Sys=%v MiB",
        m.Alloc/1024/1024, m.TotalAlloc/1024/1024, m.Sys/1024/1024)

    // Wait for interrupt signal to gracefully shutdown
    sig := make(chan os.Signal, 1)
    signal.Notify(sig, syscall.SIGINT, syscall.SIGTERM)
    <-sig

    // Graceful shutdown with 30s timeout
    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()
    if err := srv.Shutdown(ctx); err != nil {
        log.Fatalf("Server shutdown failed: %v", err)
    }
    log.Println("Server exited gracefully")
}

// handleProcess returns an http.HandlerFunc that processes requests via the leaky worker
func handleProcess(w *LeakyWorker) http.HandlerFunc {
    return func(rw http.ResponseWriter, r *http.Request) {
        if r.Method != http.MethodPost {
            http.Error(rw, "method not allowed", http.StatusMethodNotAllowed)
            return
        }
        id := r.URL.Query().Get("id")
        if id == "" {
            http.Error(rw, "missing id query param", http.StatusBadRequest)
            return
        }
        data, err := w.Process(r.Context(), id)
        if err != nil {
            http.Error(rw, fmt.Sprintf("process failed: %v", err), http.StatusInternalServerError)
            return
        }
        rw.Header().Set("Content-Type", "application/octet-stream")
        rw.Write(data)
    }
}

// getEnv reads an environment variable or returns a default value
func getEnv(key, defaultVal string) string {
    if val := os.Getenv(key); val != "" {
        return val
    }
    return defaultVal
}

// getEnvInt reads an integer environment variable or returns a default value
func getEnvInt(key string, defaultVal int) int {
    val := os.Getenv(key)
    if val == "" {
        return defaultVal
    }
    // Ignore conversion error for demo purposes, but production code should handle it
    var i int
    fmt.Sscanf(val, "%d", &i)
    if i == 0 {
        return defaultVal
    }
    return i
}

// package main is the optimized version of the microservice after pprof/flame graph analysis.
// Reduces memory usage by 30% compared to the leaky version.
package main

import (
    "context"
    "fmt"
    "log"
    "net/http"
    _ "net/http/pprof"
    "os"
    "os/signal"
    "runtime"
    "syscall"
    "time"

    "github.com/prometheus/client_golang/prometheus/promhttp"
    "github.com/valyala/bytebufferpool" // canonical pool: https://github.com/valyala/bytebufferpool
)

// Config holds optimized service configuration
type Config struct {
    ListenAddr string
    MaxWorkers int
    CacheSize  int // max entries in LRU cache
}

// OptimizedWorker uses a bounded LRU cache and buffer pools to eliminate leaks
type OptimizedWorker struct {
    cache *LRUCache // bounded cache with eviction
    pool  *bytebufferpool.Pool // reuse byte buffers to avoid allocs
}

// NewOptimizedWorker initializes a worker with optimized memory patterns
func NewOptimizedWorker(cacheSize int) *OptimizedWorker {
    return &OptimizedWorker{
        cache: NewLRUCache(cacheSize),
        pool:  &bytebufferpool.Pool{},
    }
}

// Process handles requests with zero unnecessary allocations
func (w *OptimizedWorker) Process(ctx context.Context, id string) ([]byte, error) {
    // GOOD PRACTICE: reuse buffer from pool instead of allocating new []byte
    buf := w.pool.Get()
    defer w.pool.Put(buf)
    buf.Reset()

    // GOOD PRACTICE: write string directly to buffer without intermediate []byte alloc
    _, err := buf.WriteString(id)
    if err != nil {
        return nil, fmt.Errorf("write to buffer failed: %w", err)
    }

    // Simulate expensive work (same as before for parity)
    time.Sleep(10 * time.Millisecond)

    // GOOD PRACTICE: store only the latest value, evict old entries via LRU
    w.cache.Set(id, append([]byte(nil), buf.Bytes()...)) // copy only when necessary

    // GOOD PRACTICE: return a copy of the cached value, but avoid double alloc
    result := make([]byte, buf.Len())
    copy(result, buf.Bytes())
    return result, nil
}

// LRUCache is a simple bounded LRU cache implementation (for demo purposes)
type LRUCache struct {
    capacity int
    items    map[string][]byte
    order    []string // track access order for eviction
}

// NewLRUCache initializes a new LRU cache with given capacity
func NewLRUCache(capacity int) *LRUCache {
    return &LRUCache{
        capacity: capacity,
        items:    make(map[string][]byte),
        order:    make([]string, 0, capacity),
    }
}

// Set adds or updates an item in the cache, evicting the oldest if at capacity
func (c *LRUCache) Set(key string, value []byte) {
    if len(c.order) >= c.capacity {
        // Evict oldest entry
        oldest := c.order[0]
        delete(c.items, oldest)
        c.order = c.order[1:]
    }
    // Update order
    for i, k := range c.order {
        if k == key {
            c.order = append(c.order[:i], c.order[i+1:]...)
            break
        }
    }
    c.order = append(c.order, key)
    c.items[key] = value
}

func main() {
    // Load config from env
    cfg := Config{
        ListenAddr: getEnv("LISTEN_ADDR", ":8080"),
        MaxWorkers: getEnvInt("MAX_WORKERS", 10),
        CacheSize:  getEnvInt("CACHE_SIZE", 1000), // bounded cache size
    }

    // Initialize optimized worker
    worker := NewOptimizedWorker(cfg.CacheSize)

    // Set up HTTP mux (same endpoints as before for parity)
    mux := http.NewServeMux()
    mux.Handle("/metrics", promhttp.Handler())
    mux.HandleFunc("/process", handleProcessOptimized(worker))
    mux.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {
        w.WriteHeader(http.StatusOK)
        fmt.Fprint(w, "ok")
    })

    // Configure server with same timeouts
    srv := &http.Server{
        Addr:         cfg.ListenAddr,
        Handler:      mux,
        ReadTimeout:  5 * time.Second,
        WriteTimeout: 10 * time.Second,
        IdleTimeout:  15 * time.Second,
    }

    // Run server in goroutine
    go func() {
        log.Printf("Starting optimized server on %s", cfg.ListenAddr)
        if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
            log.Fatalf("Server failed: %v", err)
        }
    }()

    // Print initial memory stats
    var m runtime.MemStats
    runtime.ReadMemStats(&m)
    log.Printf("Initial memory (optimized): Alloc=%v MiB, TotalAlloc=%v MiB, Sys=%v MiB",
        m.Alloc/1024/1024, m.TotalAlloc/1024/1024, m.Sys/1024/1024)

    // Wait for interrupt signal
    sig := make(chan os.Signal, 1)
    signal.Notify(sig, syscall.SIGINT, syscall.SIGTERM)
    <-sig

    // Graceful shutdown
    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()
    if err := srv.Shutdown(ctx); err != nil {
        log.Fatalf("Server shutdown failed: %v", err)
    }
    log.Println("Optimized server exited gracefully")
}

// handleProcessOptimized returns an http.HandlerFunc for the optimized worker
func handleProcessOptimized(w *OptimizedWorker) http.HandlerFunc {
    return func(rw http.ResponseWriter, r *http.Request) {
        if r.Method != http.MethodPost {
            http.Error(rw, "method not allowed", http.StatusMethodNotAllowed)
            return
        }
        id := r.URL.Query().Get("id")
        if id == "" {
            http.Error(rw, "missing id query param", http.StatusBadRequest)
            return
        }
        data, err := w.Process(r.Context(), id)
        if err != nil {
            http.Error(rw, fmt.Sprintf("process failed: %v", err), http.StatusInternalServerError)
            return
        }
        rw.Header().Set("Content-Type", "application/octet-stream")
        rw.Write(data)
    }
}

// getEnv and getEnvInt are reused from the leaky version
func getEnv(key, defaultVal string) string {
    if val := os.Getenv(key); val != "" {
        return val
    }
    return defaultVal
}

func getEnvInt(key string, defaultVal int) int {
    val := os.Getenv(key)
    if val == "" {
        return defaultVal
    }
    var i int
    fmt.Sscanf(val, "%d", &i)
    if i == 0 {
        return defaultVal
    }
    return i
}

// package main is a profiling tool that automates pprof data collection and flame graph generation
// for Go 1.24 services. Used to identify the memory leaks fixed in the optimized service.
package main

import (
    "context"
    "encoding/json"
    "fmt"
    "io"
    "log"
    "net/http"
    "os"
    "os/exec"
    "path/filepath"
    "runtime/pprof"
    "time"

    "github.com/google/pprof/profile" // canonical pprof parser: https://github.com/google/pprof
)

// ProfileConfig holds configuration for profiling runs
type ProfileConfig struct {
    TargetURL   string        // URL of the service to profile (e.g., http://localhost:8080)
    Duration    time.Duration // How long to collect profiles for
    OutputDir   string        // Directory to save profiles and flame graphs
    SampleRate  int           // Heap profile sample rate (1 = every allocation)
}

// ProfileResult holds the output of a profiling run
type ProfileResult struct {
    HeapProfilePath string  `json:"heap_profile_path"`
    FlameGraphPath  string  `json:"flame_graph_path"`
    AllocBytes      int64   `json:"alloc_bytes"`
    TotalAllocBytes int64   `json:"total_alloc_bytes"`
}

func main() {
    // Load config from env
    cfg := ProfileConfig{
        TargetURL:   getEnv("TARGET_URL", "http://localhost:8080"),
        Duration:    getEnvDuration("PROFILE_DURATION", 30*time.Second),
        OutputDir:   getEnv("OUTPUT_DIR", "./profiles"),
        SampleRate:  getEnvInt("SAMPLE_RATE", 1),
    }

    // Create output directory if it doesn't exist
    if err := os.MkdirAll(cfg.OutputDir, 0755); err != nil {
        log.Fatalf("Failed to create output dir: %v", err)
    }

    // Run heap profile collection
    heapProfile, err := collectHeapProfile(cfg)
    if err != nil {
        log.Fatalf("Failed to collect heap profile: %v", err)
    }

    // Generate flame graph from heap profile
    flameGraphPath, err := generateFlameGraph(heapProfile, cfg.OutputDir)
    if err != nil {
        log.Fatalf("Failed to generate flame graph: %v", err)
    }

    // Parse profile to get allocation metrics
    allocBytes, totalAllocBytes, err := parseProfileMetrics(heapProfile)
    if err != nil {
        log.Fatalf("Failed to parse profile metrics: %v", err)
    }

    // Save result to JSON
    result := ProfileResult{
        HeapProfilePath: heapProfile,
        FlameGraphPath:  flameGraphPath,
        AllocBytes:      allocBytes,
        TotalAllocBytes: totalAllocBytes,
    }
    resultJSON, err := json.MarshalIndent(result, "", "  ")
    if err != nil {
        log.Fatalf("Failed to marshal result: %v", err)
    }
    resultPath := filepath.Join(cfg.OutputDir, "result.json")
    if err := os.WriteFile(resultPath, resultJSON, 0644); err != nil {
        log.Fatalf("Failed to write result: %v", err)
    }

    log.Printf("Profiling complete. Results saved to %s", resultPath)
    log.Printf("Allocated bytes: %d, Total allocated bytes: %d", allocBytes, totalAllocBytes)
}

// collectHeapProfile fetches a heap profile from the target service
func collectHeapProfile(cfg ProfileConfig) (string, error) {
    // Construct pprof heap URL
    url := fmt.Sprintf("%s/debug/pprof/heap", cfg.TargetURL)
    log.Printf("Collecting heap profile from %s", url)

    // Create HTTP client with timeout
    client := &http.Client{
        Timeout: cfg.Duration + 10*time.Second,
    }

    // Fetch heap profile
    resp, err := client.Get(url)
    if err != nil {
        return "", fmt.Errorf("fetch profile failed: %w", err)
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
        return "", fmt.Errorf("unexpected status code: %d", resp.StatusCode)
    }

    // Save profile to file
    profilePath := filepath.Join(cfg.OutputDir, fmt.Sprintf("heap_%d.pprof", time.Now().Unix()))
    f, err := os.Create(profilePath)
    if err != nil {
        return "", fmt.Errorf("create profile file failed: %w", err)
    }
    defer f.Close()

    if _, err := io.Copy(f, resp.Body); err != nil {
        return "", fmt.Errorf("write profile failed: %w", err)
    }

    return profilePath, nil
}

// generateFlameGraph uses the pprof tool to generate an SVG flame graph
func generateFlameGraph(profilePath, outputDir string) (string, error) {
    flameGraphPath := filepath.Join(outputDir, fmt.Sprintf("flame_%d.svg", time.Now().Unix()))
    log.Printf("Generating flame graph at %s", flameGraphPath)

    // Use pprof to generate SVG flame graph
    // Requires pprof to be installed (go install github.com/google/pprof@latest)
    cmd := exec.Command("pprof", "-http=:", "-svg", profilePath)
    cmd.Stdout = os.Stdout
    cmd.Stderr = os.Stderr

    // Run pprof and capture output? Wait no, -http opens a browser, better to use -svg flag directly
    // Correct command: pprof -svg heap.pprof > flame.svg
    svgFile, err := os.Create(flameGraphPath)
    if err != nil {
        return "", fmt.Errorf("create svg file failed: %w", err)
    }
    defer svgFile.Close()

    cmd = exec.Command("pprof", "-svg", profilePath)
    cmd.Stdout = svgFile
    cmd.Stderr = os.Stderr

    if err := cmd.Run(); err != nil {
        return "", fmt.Errorf("pprof svg generation failed: %w", err)
    }

    return flameGraphPath, nil
}

// parseProfileMetrics extracts allocation metrics from a pprof profile
func parseProfileMetrics(profilePath string) (int64, int64, error) {
    f, err := os.Open(profilePath)
    if err != nil {
        return 0, 0, fmt.Errorf("open profile failed: %w", err)
    }
    defer f.Close()

    p, err := profile.Parse(f)
    if err != nil {
        return 0, 0, fmt.Errorf("parse profile failed: %w", err)
    }

    // Sum allocated bytes from all samples
    var allocBytes, totalAllocBytes int64
    for _, sample := range p.Sample {
        // Heap profiles have value[0] = alloc_bytes, value[1] = alloc_objects, etc.
        if len(sample.Value) > 0 {
            allocBytes += sample.Value[0]
        }
        if len(sample.Value) > 1 {
            totalAllocBytes += sample.Value[1]
        }
    }

    return allocBytes, totalAllocBytes, nil
}

// getEnv, getEnvInt, getEnvDuration are helper functions
func getEnv(key, defaultVal string) string {
    if val := os.Getenv(key); val != "" {
        return val
    }
    return defaultVal
}

func getEnvInt(key string, defaultVal int) int {
    val := os.Getenv(key)
    if val == "" {
        return defaultVal
    }
    var i int
    fmt.Sscanf(val, "%d", &i)
    if i == 0 {
        return defaultVal
    }
    return i
}

func getEnvDuration(key string, defaultVal time.Duration) time.Duration {
    val := os.Getenv(key)
    if val == "" {
        return defaultVal
    }
    d, err := time.ParseDuration(val)
    if err != nil {
        log.Printf("Invalid duration %s: %v, using default", val, err)
        return defaultVal
    }
    return d
}

// Collect a 30-second heap profile from a running service
go tool pprof -http=:8081 http://localhost:8080/debug/pprof/heap?seconds=30

// Generate SVG flame graph from a pprof heap profile
./flamegraph.pl heap.pprof > alloc_flame.svg

// Run benchmark with memory profiling for the Process function
go test -bench=BenchmarkProcess -benchmem -memprofile=mem.out