🔴 Advanced

Continuous Profiling & AI-Driven Observability

Continuous Profiling je prax neustáleho zbierania profilovacích dát z produkčných systémov s minimálnym overhead-om. V kombinácii s AI-driven observability (AIOps) umožňuje nielen vidieť, čo sa deje, ale aj automaticky identifikovať prečo a predpovedať budúce problémy.

Čo je Continuous Profiling?

Tradičný profiling sa robí ad-hoc — developer zapne profiler, reprodukuje problém lokálne a analyzuje výstup. Continuous Profiling tento prístup otáča: profily sa zbierajú nepretržite v produkcii, ukladajú sa a sú k dispozícii kedykoľvek.

Tradičný vs. Continuous Profiling

Aspekt Tradičný profiling Continuous Profiling
Kedy Ad-hoc, pri debugovaní Nepretržite, 24/7
Kde Lokálne, staging Produkcia
Overhead Vysoký (5-20%) Nízky (<1-2%)
Dáta Snapshot v čase Historické trendy
Prístup Reaktívny Proaktívny
Reprodukovateľnosť Nutná Nie je potrebná

Prečo profilovať v produkcii?

  • Produkcia ≠ staging — reálna záťaž, dáta a vzory správania sa nedajú simulovať
  • Intermitentné problémy — memory leaky a CPU spiky sa prejavujú až po hodinách/dňoch
  • Historická analýza — porovnanie profilov pred a po deployi
  • Cost optimization — identifikácia kódu, ktorý spotrebúva najviac zdrojov

Typy profilov

Continuous profiling zbiera rôzne typy profilov, každý odhaľuje iný druh problému:

CPU profil

Ukazuje, kde aplikácia trávi procesorový čas. Flame graph vizualizuje call stack a čas strávený v každej funkcii.

┌──────────────────────────────────────────────┐
│                  main()                       │
├──────────────────────┬───────────────────────┤
│   handleRequest()    │    processQueue()     │
├───────────┬──────────┤                       │
│ parseJSON │ queryDB  │                       │
│   15%     │   35%    │        40%            │
└───────────┴──────────┴───────────────────────┘

Memory (heap) profil

Identifikuje objekty, ktoré zaberajú najviac pamäte — kľúčové pre detekciu memory leakov.

Goroutine / Thread profil

Ukazuje počet a stav goroutines (Go) alebo threadov — odhaľuje goroutine leaky a deadlocky.

Lock Contention profil

Meria čas strávený čakaním na zámky (mutexes). Kritické pre vysoko-konkurentné aplikácie.

Off-CPU profil

Zachytáva čas, keď thread nečaká na CPU — čaká na I/O, sieť, disk alebo zámky. Dopĺňa CPU profil o kompletný obraz.

Wall-clock profil

Kombinuje CPU aj off-CPU čas — ukazuje celkový elapsed time vrátane všetkých čakaní.

Nástroje pre Continuous Profiling

Pyroscope (Grafana)

Pyroscope je open-source continuous profiling platforma, ktorú v roku 2023 akvizoval Grafana Labs. Je súčasťou Grafana LGTM stacku.

Kľúčové vlastnosti:

  • Natívna integrácia s Grafana dashboardmi
  • Pull aj push model zberu profilov
  • Podpora Go, Java, Python, Ruby, .NET, Rust, Node.js
  • Flame graph UI s diff režimom
  • Korelácia s traces cez Tempo

Nasadenie s Helm:

# values.yaml pre Pyroscope
pyroscope:
  replicaCount: 2
  resources:
    requests:
      cpu: 500m
      memory: 512Mi
  storage:
    backend: s3
    s3:
      bucket: pyroscope-profiles
      endpoint: s3.eu-central-1.amazonaws.com
  
  # Retenčná politika
  compactor:
    retention: 720h  # 30 dní

Go SDK integrácia:

package main

import (
    "os"
    "github.com/grafana/pyroscope-go"
)

func main() {
    pyroscope.Start(pyroscope.Config{
        ApplicationName: "api-server",
        ServerAddress:   "http://pyroscope:4040",
        Tags: map[string]string{
            "env":     "production",
            "version": os.Getenv("APP_VERSION"),
        },
        ProfileTypes: []pyroscope.ProfileType{
            pyroscope.ProfileCPU,
            pyroscope.ProfileAllocObjects,
            pyroscope.ProfileAllocSpace,
            pyroscope.ProfileInuseObjects,
            pyroscope.ProfileInuseSpace,
            pyroscope.ProfileGoroutines,
            pyroscope.ProfileMutexCount,
            pyroscope.ProfileMutexDuration,
            pyroscope.ProfileBlockCount,
            pyroscope.ProfileBlockDuration,
        },
    })
    defer pyroscope.Stop()

    // ... aplikačný kód
}

Parca

Open-source CNCF Sandbox projekt zameraný na continuous profiling s využitím eBPF.

Výhody:

  • eBPF-based agent — profiluje bez zmeny aplikačného kódu
  • Podpora pprof formátu
  • Efektívne ukladanie profilov (stĺpcový formát)
  • Natívna podpora pre Kubernetes
# Parca Agent DaemonSet
apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: parca-agent
spec:
  selector:
    matchLabels:
      app: parca-agent
  template:
    spec:
      containers:
        - name: parca-agent
          image: ghcr.io/parca-dev/parca-agent:latest
          securityContext:
            privileged: true
          args:
            - /bin/parca-agent
            - --store-address=parca-server:7070
            - --node=$(NODE_NAME)
          env:
            - name: NODE_NAME
              valueFrom:
                fieldRef:
                  fieldPath: spec.nodeName
          volumeMounts:
            - name: modules
              mountPath: /lib/modules
            - name: debugfs
              mountPath: /sys/kernel/debug
      volumes:
        - name: modules
          hostPath:
            path: /lib/modules
        - name: debugfs
          hostPath:
            path: /sys/kernel/debug

Google Cloud Profiler

Plne manažované riešenie pre GCP. Zero-config pre GKE workloady, minimálny overhead (~0.5%).

Datadog Continuous Profiler

Integrované do Datadog APM — automatická korelácia profilov s traces a infraštruktúrnymi metrikami.

Porovnanie nástrojov

Nástroj Typ eBPF Jazyky Ukladanie Cena
Pyroscope OSS / Cloud Áno 8+ S3, GCS, local Free / Grafana Cloud
Parca OSS Áno Všetky* Object storage Free
GCP Profiler SaaS Nie 4 Google Cloud Zahrnuté v GCP
Datadog SaaS Nie 8+ Datadog Per host pricing

* Parca s eBPF agentom profiluje na úrovni kernelu — nezávisí od jazyka

AI-Driven Observability (AIOps)

AIOps aplikuje strojové učenie a AI na observability dáta s cieľom automatizovať detekciu, diagnostiku a predikciu problémov.

Anomaly Detection

Tradičné statické thresholdy (CPU > 80%) generujú falošné alarmy a prepúšťajú reálne problémy. ML modely sa učia normálne vzory správania a detekujú odchýlky:

Normálny vzor (naučený):
  CPU: 20-40% (pracovné dni), 5-10% (víkendy)
  Latencia: 50-80ms (bežná), 100-150ms (peak hours)

Anomália detekovaná:
  CPU: 45% o 3:00 ráno (mimo naučeného vzoru)
  → Automatický alert s kontextom

Typy anomálií:

  • Spike — náhly nárast metriky
  • Level shift — trvalá zmena baseline
  • Trend — postupný drift metriky
  • Seasonal violation — odchýlka od sezónneho vzoru

Automated Root Cause Analysis (RCA)

AI-driven RCA automaticky koreluje anomálie naprieč metrikami, traces, logmi a profilmi:

Alert: Latencia API vzrástla o 300%
  │
  ├─ Trace analysis → pomalé DB queries
  │
  ├─ Profile analysis → lock contention na connection pool
  │
  ├─ Log korelácia → "connection pool exhausted" 
  │
  └─ Root cause: Deploy v10.2.3 zmenil pool size z 50 na 5
     → Odporúčanie: Rollback alebo fix konfigurácie

Predictive Alerting

Namiesto reagovania na problémy ich AI predpovedá:

  • Predikcia vyčerpania disku — na základe trendu rastu
  • Capacity forecasting — predpoveď potreby zdrojov
  • Performance degradation — detekcia postupného spomalenia pred SLO breach
  • Memory leak detection — identifikácia lineárneho rastu pamäte

Nástroje pre AIOps

Nástroj Zameranie Integrácie
Dynatrace Davis AI Full-stack AIOps Vlastný stack
Datadog Watchdog Anomaly detection Datadog ekosystém
New Relic AI Alert intelligence New Relic One
Moogsoft Event correlation Multi-vendor
Grafana ML Forecasting, anomálie Grafana Cloud
BigPanda Event correlation Multi-vendor

Integrácia s existujúcim stackom

OpenTelemetry prepojenie

Od verzie OTel Collector 0.103+ je profiling oficiálny signál v OpenTelemetry (OTEP 0239). Profily sa posielajú cez OTLP rovnako ako traces, metriky a logy.

# OTel Collector s profilmi
receivers:
  otlp:
    protocols:
      grpc:
        endpoint: 0.0.0.0:4317

connectors:
  spanmetrics:
    histogram:
      explicit:
        buckets: [5ms, 10ms, 50ms, 100ms, 500ms]

exporters:
  otlp/tempo:
    endpoint: tempo:4317
  otlp/pyroscope:
    endpoint: pyroscope:4040
  prometheus:
    endpoint: 0.0.0.0:8889

service:
  pipelines:
    traces:
      receivers: [otlp]
      exporters: [otlp/tempo]
    profiles:
      receivers: [otlp]
      exporters: [otlp/pyroscope]
    metrics:
      receivers: [otlp, spanmetrics]
      exporters: [prometheus]

Korelácia Traces ↔ Profiles

Najsilnejšia hodnota continuous profilingu je prepojenie s distributed traces:

  1. Span → Profile — z pomalého spanu prejdete priamo na flame graph danej funkcie
  2. Profile → Trace — z hot funkcie v profile nájdete konkrétne requesty, ktoré ju volali
// Pyroscope span integration v Go
import "github.com/grafana/pyroscope-go/godeltaprof/http/pprof"

// Automatické prepojenie span_id s profilom
pyroscope.Start(pyroscope.Config{
    // ...
    DisableGCRuns: true,
    Tags: map[string]string{
        "service": "api-server",
    },
})

V Grafane potom vidíte priamo v Tempo trace detaile tlačidlo "View Profile", ktoré otvorí Pyroscope flame graph pre daný span.

Grafana Dashboard — Unified View

┌─────────────────────────────────────────────────────┐
│                    Grafana                           │
├───────────┬──────────────┬──────────────┬───────────┤
│  Metrics  │    Traces    │    Logs      │ Profiles  │
│(Prometheus)│   (Tempo)   │   (Loki)     │(Pyroscope)│
├───────────┴──────────────┴──────────────┴───────────┤
│           Correlations (trace_id, span_id)          │
│         → Klikni na spike → vidíš trace             │
│         → Klikni na span → vidíš profil             │
│         → Klikni na error → vidíš logy              │
└─────────────────────────────────────────────────────┘

Cost-Aware Observability

Continuous profiling priamo prepája výkon s nákladmi — ak viete, ktorá funkcia spotrebúva 40% CPU, viete aj koľko to stojí.

Prepojenie s FinOps

Profiling insight:
  JSON parsing v handleRequest() = 35% CPU
  
FinOps kalkulácia:
  Cluster: 20 nodov × c5.2xlarge = $4,896/mesiac
  35% CPU na JSON parsing = $1,713/mesiac
  
Optimalizácia:
  Zmena z encoding/json na json-iterator = 3× rýchlejšie
  Úspora: ~$1,140/mesiac = $13,680/rok

Optimalizácia na základe profilov

  1. Identifikujte top consumers — zoraďte funkcie podľa CPU/memory spotreby
  2. Kvantifikujte náklady — prepočítajte na cloud spend
  3. Prioritizujte optimalizácie — najväčší ROI prvý
  4. Merajte dopad — porovnajte profily pred/po optimalizácii

Resource right-sizing na základe profilov

# Pred optimalizáciou (na základe odhadu)
resources:
  requests:
    cpu: 2000m
    memory: 4Gi
  limits:
    cpu: 4000m
    memory: 8Gi

# Po analýze profilov (reálna spotreba)
resources:
  requests:
    cpu: 800m
    memory: 1.5Gi
  limits:
    cpu: 1500m
    memory: 3Gi
# Úspora: 60% CPU, 62% memory → priamy dopad na cloud bill

Best Practices

Low-overhead profiling

  • Sampling rate — 100 Hz (100 vzoriek/s) je štandard, overhead <1%
  • Neprofilujte všetko — zapnite len potrebné typy profilov
  • eBPF pred SDK — kernel-level profiling má nižší overhead než in-process SDK
  • Testujte overhead — benchmarkujte s aj bez profilingu pred nasadením

Sampling stratégie

# Pyroscope - adaptívny sampling
pyroscope:
  scrape_configs:
    - job_name: production
      scrape_interval: 10s  # Produkcia: nižšia frekvencia
      profiles:
        - cpu
        - memory
    
    - job_name: staging  
      scrape_interval: 5s   # Staging: vyššia frekvencia
      profiles:
        - cpu
        - memory
        - goroutine
        - mutex
        - block

Alerting na performance regresie

Nastavte alerty na zmeny v profilovacích dátach po deployi:

# Grafana alert rule - CPU regression po deployi
apiVersion: 1
groups:
  - name: profiling-alerts
    rules:
      - alert: CPURegressionAfterDeploy
        expr: |
          (
            sum(rate(process_cpu_seconds_total{service="api"}[5m]))
            /
            sum(rate(process_cpu_seconds_total{service="api"}[5m] offset 1h))
          ) > 1.3
        for: 10m
        labels:
          severity: warning
        annotations:
          summary: "CPU usage vzrástol o >30% po poslednom deployi"
          description: "Skontrolujte Pyroscope diff view pre porovnanie profilov."

Retenčná stratégia

Granularita Retencia Účel
Raw profiles (10s) 7 dní Debugging aktuálnych problémov
Agregované (1h) 30 dní Trend analýza
Agregované (1d) 90 dní Kapacitné plánovanie
Deploy snapshots 1 rok Regression porovnanie

Checklist pre implementáciu

  • Vyberte nástroj (Pyroscope pre Grafana stack, Parca pre vendor-neutral)
  • Začnite s CPU a memory profilmi
  • Nastavte overhead monitoring (profiler by nemal pridať >2% CPU)
  • Prepojte s traces (span_id korelácia)
  • Nastavte diff alerts na deploye
  • Definujte retenčnú politiku
  • Integrujte s FinOps procesom (cost per function)
  • Školte tím na čítanie flame graphov

Continuous Profiling v kombinácii s AI-driven observability je ďalší evolučný krok — od "niečo je pomalé" k "táto funkcia na riadku 247 stojí $1,200/mesiac a po poslednom deployi spomalila o 40%".