55 Monitoring dan Observasi Dengan Prometheus: Panduan Lengkap Bagi Engineer

Observability telah menjadi kata kunci dalam dunia DevOps dan Site Reliability Engineering (SRE). Dengan semakin kompleksnya arsitektur aplikasi modern—mulai dari microservices, Kubernetes, hingga cloud-native—monitoring konvensional sudah tidak lagi memadai. Observasi bukan hanya soal mengumpulkan metrik, tapi juga memahami sistem melalui data, visualisasi, dan alarm yang dapat ditindaklanjuti. Salah satu tools open-source paling populer untuk kebutuhan ini adalah Prometheus.

Dalam artikel ini, saya akan membagikan 55 monitoring dan observasi yang dapat Anda lakukan dengan Prometheus, lengkap dengan contoh kode, simulasi, tabel, dan diagram alur. Tujuannya, agar Anda sebagai engineer bukan hanya sekedar ‘pasang alat monitoring’, tapi benar-benar mampu memahami dan mengendalikan sistem Anda secara proaktif.

Apa itu Prometheus?

Prometheus adalah sistem monitoring dan alerting open source yang dikembangkan oleh SoundCloud dan sekarang berada di bawah naungan CNCF. Prometheus berfokus pada penyimpanan time series data (metrik) yang dikumpulkan melalui HTTP pull (scraping)—cocok untuk kebutuhan aplikasi modern yang skalanya dinamis.

Arsitektur Prometheus secara garis besar adalah seperti berikut:

flowchart LR
    subgraph Data Sources
        A1[App 1]
        A2[App 2]
        A3[App N]
    end
    A1 --> Scrape[Prometheus Scraper]
    A2 --> Scrape
    A3 --> Scrape
    Scrape --> TSDB[(Time Series DB)]
    TSDB --> UI[Prometheus UI]
    TSDB --> Alert[Alertmanager]
    UI --> Dev[Engineer/SRE]
    Alert --> Pagerduty[(PagerDuty/Email/Slack)]

Mengapa Observability Penting?

Tanpa observasi yang memadai:

• Incident mudah terlewat.
• Root cause sulit ditemukan.
• Reliability sulit dikontrol dengan skalabilitas tinggi.

Dengan observasi berbasis Prometheus:

• Sistem proaktif dalam deteksi masalah.
• Data metriks yang rich dan query-able.
• Integrasi Alerts dan Dashboard (Grafana).

55 Metrik Monitoring dan Observasi Dengan Prometheus

Rangkuman metrik berikut dapat dibagi menjadi tiga kategori: Infrastruktur, Aplikasi, dan Bisnis.

Berikut list monitoring dan observasi populer yang bisa Anda implementasikan:

1. CPU Usage per Node
2. CPU Usage Container (Pod)
3. Memory Usage per Node
4. Memory Usage Container
5. Disk Usage
6. Disk IOPS
7. Network Receive/Transmit (Bytes/sec)
8. Network Packet Error Rate
9. Node Uptime
10. Process Count (Zombie, Running)
11. Heap Memory Consumption (Aplikasi Java)
12. Garbage Collection Time
13. Thread Count (Aplikasi)
14. HTTP Request Rate
15. HTTP Error Rate (4xx, 5xx)
16. HTTP Average Latency
17. HTTP P95/P99 Latency
18. Database Query per Second
19. Database Query Errors
20. Connection Pool Size
21. DB Locks
22. Redis Cache Hit/Miss Ratio
23. Message Queue Size
24. Queue Consumption Rate
25. Queue Failure Count
26. External API Call Rate
27. External API Call Latency
28. Job Scheduler Delay
29. Kube Pod Count (Running, Pending, Failed)
30. Kube Deployment Replicas Missed
31. Kubernetes Node NotReady Count
32. Container Restart Rate
33. Volume Attach Delay (Storage)
34. Cert Expiry Date
35. SSL Handshake Error
36. Ingress Traffic per Path
37. TLS Version Usage
38. CPU Throttling Events
39. OutOfMemory Killed Count
40. Disk Space Remaining
41. Service Discovery Changes
42. DNS Failures
43. Config Reload Events
44. Environment Variable Missed
45. Feature Flag State
46. Deployment Event Timestamps
47. Rolling Update Progress
48. Order Created per Second
49. Transaction Success Rate
50. Payment Failure Rate
51. Users Logged In
52. Active Sessions
53. Shopping Cart Add/Remove Event
54. Revenue per Minute
55. Business SLA Compliance (ex: <500ms resp)

Contoh Kode Implementasi Metrik Custom di Aplikasi

Library Prometheus Client untuk Python

Misal Anda membuat aplikasi web Python Flask, Anda bisa expose metrik custom berikut:

from prometheus_client import start_http_server, Summary, Counter
from flask import Flask

# Metric: Tracking HTTP request latency and error
REQUEST_LATENCY = Summary('http_request_latency_seconds', 'HTTP Request latency')
ERROR_COUNTER = Counter('http_error_count', 'Number of HTTP failed responses', ['code'])

app = Flask(__name__)

@app.route("/api")
@REQUEST_LATENCY.time()  # Otomatis track latency
def api():
    # Simulasi error
    if random.random() < 0.1:
        ERROR_COUNTER.labels(code='500').inc()
        return "Internal Error", 500
    return "OK"

if __name__ == "__main__":
    start_http_server(8000)  # expose metrics di /metrics
    app.run(host="0.0.0.0", port=8080)

Aplikasi akan expose endpoint /metrics yang dapat di-scrape oleh Prometheus.

Contoh Prometheus Scrape Config

Tambahkan service di prometheus.yml:

scrape_configs:
  - job_name: 'webapp'
    static_configs:
      - targets: ['webapp:8000']

Simulasi Dashboard di Grafana

Visualisasi dengan Grafana sangat penting untuk insight cepat. Anda bisa membuat query PromQL seperti:

• Error Rate:

  sum(rate(http_error_count[5m]))
  

• Average HTTP Latency:

  avg(rate(http_request_latency_seconds_sum[5m])) / avg(rate(http_request_latency_seconds_count[5m]))
  

Alarm/Alert Dengan Alertmanager

Contoh rule alert ketika error rate > 0.5/s selama 5 menit:

groups:
- name: webapp-alerts
  rules:
  - alert: HighErrorRate
    expr: sum(rate(http_error_count[5m])) > 0.5
    for: 5m
    labels:
      severity: critical
    annotations:
      summary: "High Error Rate Detected"
      description: "The average error rate exceeded 0.5/s for 5 minutes"

Studi Kasus Mini: Debug Lambatnya Checkout

Misal Anda temukan SLA checkout aplikasi e-commerce sering gagal, berikut pendekatan monitoring observability:

flowchart TD
    A[Customer Checkout Request] --> B[App HTTP Req]
    B --> C[Database Query]
    C --> D[Redis Fetch]
    D --> E[External Payment API]
    B -.metrics.-> F[Prometheus Collects: latency, errors, queue]
    E -.metrics.-> F

    F --> G[Grafana Dashboard]
    G --> H[Alertmanager (High Latency Detected)]
    H --> I[SRE Team Triage]

Hasil observasi metrik:

• P99 latency checkout naik signifikan,
• Error payment API meningkat,
• Redis cache miss melonjak.

Root cause bisa dianalisis dengan cepat, misal Redis down sehingga fallback ke DB lambat.

Kesimpulan

Monitoring dan observasi modern tak lagi soal “sekedar tahu server down”. Prometheus dengan ekosistemnya mampu menyatukan metrik infra, aplikasi, hingga bisnis dalam satu dashboard observasi terpusat. Setidaknya, ke-55 metrik utama di atas wajib Anda pertimbangkan untuk produksi skala besar. Dengan Prometheus, Anda bisa lebih proaktif, data-driven, dan sigap menghadapi masalah layanan.

“You can’t improve what you can’t measure.”
– Peter Drucker

Jika Anda ingin mendalami observability lebih lanjut, pastikan semua engineer di tim bisa membaca, menambah, hingga bereksperimen dengan metrik—karena pada akhirnya, observabilitas adalah kemampuan tim, bukan sekedar alat.

Bagikan pengalaman observability Anda di kolom komentar. Tools dan metrik apa yang menurut Anda paling krusial di environment production?