Belajar Performance Test Engineer - Monitoring & Metrics

#Pendahuluan

Setelah di episode 8 kita memahami frontend performance, kini saatnya membahas komponen yang membuat performance testing benar-benar powerful: monitoring dan metrics. Load test tanpa monitoring hanya menghasilkan angka di terminal — angka yang memberitahu "berapa cepat" tetapi tidak "mengapa". Monitoring memberikan konteks: mengapa latency naik, di mana bottleneck muncul, dan resource mana yang kehabisan kapasitas.

Observability yang baik adalah senjata paling powerful seorang Performance Test Engineer. Di episode ini, kita akan membangun pemahaman tentang Grafana, Prometheus, distributed tracing, dan cara mengintegrasikan semuanya selama load test.

#The Three Pillars of Observability

#Metrics

Metrics adalah angka-angka yang diukur dari waktu ke waktu — CPU usage, memory consumption, request count, error rate, latency. Metrics menjawab pertanyaan: "Apa yang terjadi di sistem saya sekarang?" dan "Bagaimana trennya?".

#Logs

Logs adalah catatan peristiwa kronologis — setiap request, error, atau perubahan state mencetak log entry. Logs menjawab pertanyaan: "Mengapa sesuatu terjadi?" — tetapi sulit di-scale karena volume yang besar.

#Traces

Traces adalah jejak perjalanan satu request melalui seluruh sistem — dari client sampai database dan kembali. Traces menjawab pertanyaan: "Di mana delay terjadi dalam satu request?" — krusial untuk debugging latency di microservices.

#Prometheus

Prometheus adalah time-series database untuk metrics. Ia mengumpulkan metrics dari aplikasi, infrastructure, dan tools monitoring lainnya, lalu menyimpannya untuk query dan alerting.

#Install Prometheus

docker run -d --name prometheus \
  -p 9090:9090 \
  -v prometheus.yml:/etc/prometheus/prometheus.yml \
  prom/prometheus

#Metrics Types

#Querying Prometheus

# Request rate per detik
rate(http_requests_total[5m])
 
# Error rate
rate(http_requests_total{status=~"5.."}[5m]) / rate(http_requests_total[5m])
 
# p95 latency (dari histogram)
histogram_quantile(0.95, rate(http_request_duration_seconds_bucket[5m]))

#Grafana

Grafana adalah platform visualisasi yang menghubungkan Prometheus (metrics), Loki (logs), dan Tempo/Jaeger (traces) ke dashboard interaktif.

#Install Grafana

docker run -d --name grafana \
  -p 3000:3000 \
  -e GF_SECURITY_ADMIN_PASSWORD=admin \
  grafana/grafana

#Dashboard Performance Testing

Dashboard performance testing yang baik harus menampilkan:

1. Request metrics: throughput (req/s), error rate, latency percentiles
2. System metrics: CPU, memory, disk I/O, network
3. Application metrics: connection pool usage, thread count, GC activity
4. Database metrics: query time, active connections, lock wait

#Membuat Dashboard

# Grafana dashboard JSON (simplified)
{
  "panels": [
    {
      "title": "Request Rate",
      "type": "timeseries",
      "targets": [{
        "expr": "rate(http_requests_total[1m])",
        "legendFormat": "{{method}} {{status}}"
      }]
    },
    {
      "title": "p95 Latency",
      "type": "timeseries",
      "targets": [{
        "expr": "histogram_quantile(0.95, rate(http_request_duration_seconds_bucket[5m]))",
        "legendFormat": "p95"
      }]
    }
  ]
}

#Distributed Tracing

#Jaeger

Jaeger adalah distributed tracing system yang mengikuti perjalanan request melalui microservices. Setiap service mencetak span (unit kerja) yang terhubung dalam satu trace.

// Contoh tracing di k6 dengan ekstensi opentelemetry
import { Counter } from 'k6/metrics';
 
const requestCount = new Counter('requests');
 
export default function () {
  const res = http.get('https://api.example.com/products');
  requestCount.add(1);
  // Trace data dikirim ke Jaeger via OpenTelemetry exporter
}

#Tempo

Grafana Tempo adalah backend distributed tracing yang terintegrasi alami dengan Grafana. Jika kalian sudah menggunakan Grafana, Tempo adalah pilihan paling natural untuk traces.

#Mengintegrasikan Monitoring Selama Load Test

#Langkah-langkah

1. Setup monitoring stack: Prometheus + Grafana + application metrics endpoint
2. Configure k6 output: k6 bisa mengirim metrics ke Prometheus atau InfluxDB
3. Buka Grafana dashboard: real-time monitoring selama test
4. Observe: perhatikan pola — apakah CPU spike saat latency naik?

#k6 + Prometheus Integration

# k6 bisa mengirim metrics ke Prometheus via pushgateway
k6 run --out prometheus=http://localhost:9091 script.js

#System Monitoring

Di sisi server, pastikan system metrics terpantau:

# CPU, memory, disk I/O
htop          # Real-time system monitor
iostat -x 1   # Disk I/O per detik
sar -n DEV 1  # Network traffic per detik

#Common Patterns dalam Monitoring

#CPU-Bound Performance

Jika CPU usage tinggi (80-100%) dan latency naik → sistem CPU-bound. Solusi: optimize code, add CPU, atau cache hasil komputasi.

#Memory-Bound Performance

Jika memory usage naik terus selama test → indikasi memory leak. Solusi: profiling memory, perbaiki resource management.

#I/O-Bound Performance

Jika disk I/O atau network I/O menjadi bottleneck → sistem I/O-bound. Solusi: optimize queries, add caching, gunakan connection pooling.

#Database Lock Contention

Jika database shows high lock wait time → concurrent writes saling berebut lock. Solusi: optimize transactions, gunakan optimistic locking, atau sharding.

#Penutup

Di episode 9 ini kalian telah memahami monitoring & metrics untuk performance testing:

• Three pillars: metrics (Prometheus), logs (Loki), traces (Jaeger/Tempo).
• Prometheus: time-series database untuk metrics; PromQL untuk querying.
• Grafana: dashboard visualisasi yang menghubungkan semua data observability.
• Distributed tracing: mengikuti perjalanan request melalui microservices.
• Integrasi k6: kirim metrics dari k6 ke Prometheus selama test.

Di episode 10 selanjutnya, kita akan mempelajari Analysis & Bottleneck Detection — cara menganalisis hasil monitoring dan load test untuk menemukan bottleneck spesifik dan rekomendasi perbaikan. Siapkan data monitoring kalian!