Prometheus + Grafana + Alertmanager

# Кількість запитів на секунду (за останні 5 хвилин)
rate(http_requests_total[5m])

# Кількість запитів за останні 5 хвилин (абсолютна кількість)
increase(http_requests_total[5m])

# Пряме використання — правильно для gauge:
node_memory_MemAvailable_bytes
node_load1
go_goroutines

# Обчислення % використання пам'яті:
(node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes) / node_memory_MemTotal_bytes * 100

# Тренд gauge за час (похідна):
deriv(node_load1[10m])   # чи зростає навантаження?
predict_linear(node_disk_free_bytes[1h], 4*3600)  # прогноз місця на диску через 4 години

# p50 (медіана) латентності за останні 5 хвилин
histogram_quantile(0.50, rate(http_request_duration_seconds_bucket[5m]))

# p95 — 95% запитів вклалися у це значення
histogram_quantile(0.95, rate(http_request_duration_seconds_bucket[5m]))

# p99 — "довгий хвіст", критично для SLA
histogram_quantile(0.99, rate(http_request_duration_seconds_bucket[5m]))

# Середнє значення (з суми та кількості):
rate(http_request_duration_seconds_sum[5m]) / rate(http_request_duration_seconds_count[5m])

# Приклад у Python (prometheus_client):
from prometheus_client import Histogram

REQUEST_LATENCY = Histogram(
    'http_request_duration_seconds',
    'HTTP request duration',
    buckets=[.005, .01, .025, .05, .1, .25, .5, 1.0, 2.5, 5.0, 10.0]
)

# Histogram — можна агрегувати по всіх інстансах:
histogram_quantile(0.95,
  sum(rate(http_request_duration_seconds_bucket[5m])) by (le)
)

# Summary — НЕ можна агрегувати квантилі по інстансах:
# avg(go_gc_duration_seconds{quantile="0.99"}) — математично НЕКОРЕКТНО!
# Середнє перцентилів ≠ перцентиль всієї вибірки

rate(http_requests_total[5m])

# rate(http_requests_total[5m]) = 2.3
# Означає: в середньому 2.3 запити/секунду за останні 5 хвилин

# Для отримання запитів/хвилину:
rate(http_requests_total[5m]) * 60

# Відсоток помилок:
rate(http_requests_total{status=~"5.."}[5m]) / rate(http_requests_total[5m]) * 100

increase(http_requests_total[1h])

# Кількість запитів за останню годину:
increase(http_requests_total[1h])

# Кількість 5xx помилок за останні 24 години:
increase(http_requests_total{status=~"5.."}[24h])

# Кількість failed jobs за останній день:
increase(batch_jobs_failed_total[24h])

irate(http_requests_total[5m])

# --- Агрегаційні оператори ---

# Сума по всіх інстансах:
sum(rate(http_requests_total[5m]))

# Сума, зберігаючи тільки label "job":
sum by (job) (rate(http_requests_total[5m]))

# Сума, прибираючи тільки label "instance":
sum without (instance) (rate(http_requests_total[5m]))

# Максимум по всіх інстансах:
max by (instance) (node_load1)

# Топ-5 найзавантаженіших хостів:
topk(5, node_load1)

# --- Функції часу ---

# Скільки секунд тому відбувся останній scrape (для виявлення "мертвих" таргетів):
time() - node_boot_time_seconds  # uptime в секундах

# Прогноз вільного місця (лінійна екстраполяція):
predict_linear(node_filesystem_free_bytes{mountpoint="/"}[6h], 24*3600)
# "Якщо тренд останніх 6h продовжиться — скільки байт буде через 24h"

# --- Зміна у часі ---

# Різниця між поточним і N секунд тому (для gauge):
delta(node_load1[10m])

# Похідна (trend):
deriv(node_load1[10m])

# --- Відбір по значенню ---

# Тільки інстанси з load > 2.0:
node_load1 > 2.0

# Тільки інстанси де є помилки (rate > 0):
rate(http_requests_total{status=~"5.."}[5m]) > 0

# Умовний вираз — якщо error rate > 0.01, повернути значення, інакше nothing:
rate(http_requests_total{status=~"5.."}[5m]) > 0.01

# Бінарні операції між метриками вимагають збігу labels

# Відсоток вільної пам'яті (обидві метрики мають label "instance"):
node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes * 100

# Якщо labels не збігаються — потрібен ignoring або on:
# Помилки на запит (метрики мають різні sets labels):
rate(http_errors_total[5m]) / ignoring(error_type) rate(http_requests_total[5m])

# group_left — many-to-one join (додати label з іншої метрики):
rate(http_requests_total[5m])
* on(instance) group_left(datacenter)
node_meta_info  # метрика з додатковим label "datacenter"

# Query A — успішні запити:
sum by (status) (rate(http_requests_total{job="my-api"}[5m]))

# Legend: {{status}}
# Visualization: Time series, Fill opacity: 20

sum(rate(http_requests_total{status=~"5.."}[5m]))
/
sum(rate(http_requests_total[5m]))
* 100

# Unit: Percent (0-100)
# Thresholds: 0=green, 1=yellow, 5=red

# Query A — p50:
histogram_quantile(0.50, sum by (le) (rate(http_request_duration_seconds_bucket{job="my-api"}[5m])))

# Query B — p95:
histogram_quantile(0.95, sum by (le) (rate(http_request_duration_seconds_bucket{job="my-api"}[5m])))

# Query C — p99:
histogram_quantile(0.99, sum by (le) (rate(http_request_duration_seconds_bucket{job="my-api"}[5m])))

# Legend: p{{quantile_label}}   (або задати вручну: p50, p95, p99)
# Unit: seconds (s)

# У Settings → Variables:
# Variable 1:
Name: instance
Type: Query
Query: label_values(node_cpu_seconds_total, instance)
# Тепер у запитах використовуємо: {instance="$instance"}

# Variable 2:
Name: interval
Type: Interval
Values: 1m,5m,10m,30m,1h
Default: 5m
# Використовуємо: rate(metric[$interval])

# З variables — динамічний запит:
rate(http_requests_total{instance="$instance", job="$job"}[$interval])

# Query для Heatmap панелі:
sum(rate(http_request_duration_seconds_bucket{job="my-api"}[$interval])) by (le)

# Format: Heatmap
# Bucket bound: Upper (тому що le = less-or-equal, тобто верхня межа)

# /etc/prometheus/rules/api.yml
groups:
  - name: api.alerts
    interval: 1m  # як часто перевіряти (default: global evaluation_interval)
    rules:

      # Алерт на high error rate
      - alert: HighErrorRate
        expr: |
          sum(rate(http_requests_total{status=~"5.."}[5m]))
          /
          sum(rate(http_requests_total[5m]))
          * 100 > 5          
        for: 5m
        # ^ "for" — алерт спрацьовує тільки якщо умова TRUE протягом 5 хвилин безперервно.
        # Без "for": будь-який спайк → негайний алерт (багато false positives)
        labels:
          severity: critical
          team: backend
        annotations:
          summary: "High error rate on {{ $labels.job }}"
          description: |
            Error rate is {{ $value | printf "%.2f" }}% 
            for job {{ $labels.job }} on instance {{ $labels.instance }}.
            Current threshold: 5%            

      # Алерт на latency
      - alert: HighLatencyP99
        expr: |
          histogram_quantile(0.99,
            sum by (le, job) (rate(http_request_duration_seconds_bucket[5m]))
          ) > 1.0          
        for: 10m
        labels:
          severity: warning
        annotations:
          summary: "p99 latency > 1s for {{ $labels.job }}"
          description: "p99 = {{ $value | printf \"%.3f\" }}s"

      # Алерт на відсутність метрик (dead exporter)
      - alert: ExporterDown
        expr: up == 0
        for: 2m
        labels:
          severity: critical
        annotations:
          summary: "Exporter down: {{ $labels.instance }}"

# /etc/alertmanager/alertmanager.yml
global:
  smtp_smarthost: 'smtp.gmail.com:587'
  smtp_from: 'alerts@company.com'
  slack_api_url: 'https://hooks.slack.com/services/T.../B.../xxx'

# Шаблони повідомлень
templates:
  - '/etc/alertmanager/templates/*.tmpl'

# Дерево маршрутизації
route:
  receiver: 'default-receiver'  # fallback
  group_by: ['alertname', 'job']
  # ^ групувати алерти з однаковим alertname+job в одне повідомлення
  group_wait: 30s
  # ^ чекати 30s перед відправкою першої нотифікації (щоб зібрати групу)
  group_interval: 5m
  # ^ мінімальний інтервал між повідомленнями для тієї ж групи
  repeat_interval: 4h
  # ^ якщо алерт не resolved — повторювати кожні 4h

  routes:
    # Critical → Slack #alerts-critical + PagerDuty
    - match:
        severity: critical
      receiver: 'critical-receiver'
      continue: false  # не передавати далі по дереву

    # Warning → Slack #alerts-warning тільки в робочий час
    - match:
        severity: warning
      receiver: 'warning-receiver'
      active_time_intervals:
        - business_hours

    # Конкретна команда
    - match_re:
        team: ^(backend|api)$
      receiver: 'backend-team'

time_intervals:
  - name: business_hours
    time_intervals:
      - weekdays: ['monday:friday']
        times:
          - start_time: '09:00'
            end_time: '18:00'
        location: 'Europe/Kyiv'

receivers:
  - name: 'default-receiver'
    slack_configs:
      - channel: '#alerts-general'
        send_resolved: true
        title: '{{ template "slack.title" . }}'
        text: '{{ template "slack.text" . }}'

  - name: 'critical-receiver'
    slack_configs:
      - channel: '#alerts-critical'
        send_resolved: true
    pagerduty_configs:
      - service_key: '<YOUR_PD_KEY>'

  - name: 'backend-team'
    slack_configs:
      - channel: '#backend-alerts'

inhibit_rules:
  # Якщо instance Down — не посилати інші алерти для цього instance
  - source_match:
      alertname: InstanceDown
    target_match_re:
      alertname: .+
    equal: ['instance']

# CLI через amtool:
amtool silence add \
  --alertmanager.url=http://alertmanager:9093 \
  --duration=2h \
  --comment="Planned maintenance window" \
  alertname=HighErrorRate \
  job=my-api

# Переглянути активні silences:
amtool silence query --alertmanager.url=http://alertmanager:9093

# /etc/prometheus/prometheus.yml
global:
  scrape_interval: 15s         # як часто збирати метрики
  evaluation_interval: 15s     # як часто обчислювати alerting rules
  scrape_timeout: 10s          # timeout для одного scrape

# Правила та алерти
rule_files:
  - "/etc/prometheus/rules/*.yml"

# Alertmanager
alerting:
  alertmanagers:
    - static_configs:
        - targets: ['alertmanager:9093']

scrape_configs:
  # --- Prometheus сам себе ---
  - job_name: 'prometheus'
    static_configs:
      - targets: ['localhost:9090']

  # --- Node Exporter ---
  - job_name: 'node'
    static_configs:
      - targets:
          - 'server1.example.com:9100'
          - 'server2.example.com:9100'
    relabel_configs:
      # Замінити instance label на короткий hostname:
      - source_labels: [__address__]
        target_label: __param_target
      - source_labels: [__address__]
        regex: '([^:]+):.*'
        target_label: instance
        replacement: '$1'

  # --- HAProxy exporter ---
  - job_name: 'haproxy'
    static_configs:
      - targets: ['haproxy-host:8405']
    labels:
      datacenter: 'nj'

  # --- File-based service discovery (динамічне оновлення без рестарту) ---
  - job_name: 'dynamic-targets'
    file_sd_configs:
      - files:
          - '/etc/prometheus/targets/*.json'
        refresh_interval: 30s

  # --- Blackbox exporter (зовнішній моніторинг HTTP) ---
  - job_name: 'blackbox-http'
    metrics_path: /probe
    params:
      module: [http_2xx]
    static_configs:
      - targets:
          - 'https://api.example.com/health'
    relabel_configs:
      - source_labels: [__address__]
        target_label: __param_target
      - source_labels: [__param_target]
        target_label: instance
      - target_label: __address__
        replacement: blackbox-exporter:9115

[
  {
    "targets": ["server10.dc1.example.com:9100", "server11.dc1.example.com:9100"],
    "labels": {
      "datacenter": "dc1",
      "role": "proxy"
    }
  }
]

# /etc/prometheus/rules/recording.yml
groups:
  - name: api_recording_rules
    interval: 1m
    rules:
      # Pre-compute error rate по job:
      - record: job:http_request_errors:rate5m
        expr: |
          sum by (job) (rate(http_requests_total{status=~"5.."}[5m]))
          /
          sum by (job) (rate(http_requests_total[5m]))          

      # Pre-compute p99 latency по job:
      - record: job:http_request_duration_p99:rate5m
        expr: |
          histogram_quantile(0.99,
            sum by (job, le) (rate(http_request_duration_seconds_bucket[5m]))
          )          

# Скільки активних time series у Prometheus:
prometheus_tsdb_head_series

# Топ метрик за кардинальністю:
topk(10, count by (__name__) ({__name__=~".+"}))

# Кількість series на метрику:
count by (__name__) ({__name__="http_requests_total"})

# Обмеження кардинальності на рівні scrape:
scrape_configs:
  - job_name: 'my-app'
    sample_limit: 5000  # якщо > 5000 samples — весь scrape відкидається
    label_limit: 30     # максимум labels на серію

# prometheus.yml запуск:
--storage.tsdb.retention.time=30d    # зберігати 30 днів
--storage.tsdb.retention.size=50GB   # або до 50GB (спрацьовує перший)

# Оцінка розміру (приблизна формула):
# needed_disk = retention_seconds * ingested_samples_per_second * bytes_per_sample
# bytes_per_sample ≈ 1-2 байти (після стиснення XOR delta encoding)
# 
# Приклад: 30d × 10,000 samples/s × 2 bytes = ~51GB

# ПОМИЛКА: rate на gauge
rate(node_memory_MemAvailable_bytes[5m])  # ❌ безглуздо — gauge не counter

# ПОМИЛКА: irate в alerting rule
alert: HighRPS
expr: irate(http_requests_total[5m]) > 1000  # ❌ нестабільний результат

# ПОМИЛКА: занадто малий інтервал
rate(http_requests_total[30s])  # ❌ якщо scrape_interval=15s — тільки 2 точки!

# ПРАВИЛЬНО:
rate(http_requests_total[5m])   # ✅ плавно, 20 точок при scrape 15s

# ПОГАНО: алерт без "for" → шквал false positives
- alert: HighCPU
  expr: node_load1 > 2.0
  # ← немає "for"! Будь-який секундний спайк = алерт

# ДОБРЕ: з обґрунтованим "for"
- alert: HighCPU
  expr: node_load1 > 2.0
  for: 10m  # проблема має бути стабільною

# ПОГАНО: алерт на сирий counter
- alert: ErrorsSpike
  expr: http_requests_total{status="500"} > 100  # ❌

# ДОБРЕ: алерт на rate
- alert: ErrorsSpike
  expr: rate(http_requests_total{status="500"}[5m]) > 0.1  # ✅

# RPS по бекенду:
sum by (proxy) (rate(haproxy_frontend_http_requests_total[5m]))

# Error rate 5xx:
sum(rate(haproxy_frontend_http_responses_total{code="5xx"}[5m]))
/
sum(rate(haproxy_frontend_http_requests_total[5m]))
* 100

# Кількість живих серверів у кожному бекенді:
sum by (proxy) (haproxy_server_status == 1)

# Пропускна здатність (Мбіт/с):
sum(rate(haproxy_frontend_bytes_in_total[5m])) * 8 / 1e6

# Активні з'єднання vs максимум:
haproxy_frontend_current_sessions / haproxy_frontend_limit_sessions * 100

groups:
  - name: haproxy
    rules:
      # Сервер виключився з ротації
      - alert: HAProxyServerDown
        expr: haproxy_server_status == 0
        for: 1m
        labels:
          severity: critical
        annotations:
          summary: "HAProxy server {{ $labels.server }} is DOWN in {{ $labels.proxy }}"

      # Більше 50% серверів бекенду недоступні
      - alert: HAProxyBackendHalfDown
        expr: |
          sum by (proxy) (haproxy_server_status == 0)
          /
          sum by (proxy) (haproxy_server_status)
          > 0.5          
        for: 2m
        labels:
          severity: critical
        annotations:
          summary: "More than 50% servers down in backend {{ $labels.proxy }}"

      # Висока кількість 5xx помилок
      - alert: HAProxyHighErrorRate
        expr: |
          sum by (proxy) (rate(haproxy_frontend_http_responses_total{code="5xx"}[5m]))
          /
          sum by (proxy) (rate(haproxy_frontend_http_requests_total[5m]))
          * 100 > 5          
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "HAProxy 5xx error rate > 5% on {{ $labels.proxy }}"
          description: "Current rate: {{ $value | printf \"%.2f\" }}%"

      # Насичення з'єднань
      - alert: HAProxySessionSaturation
        expr: |
          haproxy_frontend_current_sessions
          / haproxy_frontend_limit_sessions
          * 100 > 80          
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "HAProxy session limit at {{ $value | printf \"%.0f\" }}%"

# --- Prometheus UI (порт 9090) ---
# /graph         — PromQL playground
# /targets       — стан всіх таргетів (UP/DOWN)
# /rules         — стан recording/alerting rules
# /alerts        — активні алерти та їх стан
# /tsdb-status   — кардинальність, топ series за розміром
# /config        — поточна конфігурація

# --- Перевірка конфігурації перед застосуванням ---
promtool check config /etc/prometheus/prometheus.yml
promtool check rules /etc/prometheus/rules/*.yml

# --- Валідація alertmanager конфігу ---
amtool check-config /etc/alertmanager/alertmanager.yml

# --- Тест алерту (симуляція firing) ---
amtool alert add \
  --alertmanager.url=http://alertmanager:9093 \
  alertname=TestAlert \
  severity=warning \
  summary="Test alert from CLI"

# --- Розмір TSDB на диску ---
du -sh /var/lib/prometheus/

# --- API для отримання series ---
curl 'http://localhost:9090/api/v1/series?match[]=http_requests_total&start=2024-01-01T00:00:00Z&end=2024-01-01T01:00:00Z'

# --- Скільки samples ingested/s ---
curl -s 'http://localhost:9090/api/v1/query?query=rate(prometheus_tsdb_head_samples_appended_total[1m])' \
  | python3 -m json.tool