Реализация Soak Testing (длительное тестирование под нагрузкой)

Soak Testing: тестирование под длительной нагрузкой

Soak test (endurance test) — запуск системы под нормальной или умеренной нагрузкой в течение 4–24 часов. Выявляет проблемы, которые не проявляются за минуты: утечки памяти, накопление файловых дескрипторов, деградация пула соединений БД, рост медленных запросов из-за накопления данных в таблицах.

Что обнаруживает soak тест

Утечки памяти: приложение растёт по памяти на 100–200MB/час и через 12 часов падает с OOM.

Connection pool exhaustion: соединения с БД не возвращаются в пул, через 6 часов pool исчерпан — новые запросы ждут до таймаута.

Накопление в heap: JVM/Node.js GC справляется первые 2 часа, затем Full GC паузы начинают влиять на latency.

Рост таблиц без autovacuum: PostgreSQL bloat — после миллиона операций UPDATE/DELETE производительность деградирует без vacuum.

File descriptor leak: каждый запрос открывает лог-файл или сокет и не закрывает — через 8 часов ulimit исчерпан.

k6 сценарий soak теста

// tests/soak/endurance.js
import http from 'k6/http'
import { check, sleep } from 'k6'
import { Rate, Trend, Gauge } from 'k6/metrics'

const errorRate = new Rate('errors')
const p95Latency = new Trend('p95_latency_trend', true)
const activeUsers = new Gauge('active_users')

export const options = {
  stages: [
    { duration: '5m',  target: 50 },   // разогрев
    { duration: '8h',  target: 50 },   // 8 часов нормальной нагрузки
    { duration: '5m',  target: 0 },    // остывание
  ],

  thresholds: {
    // Latency не должна деградировать в течение теста
    http_req_duration: ['p(95)<600'],

    // Ошибок не должно быть вообще (утечки проявляются через ошибки)
    errors: ['rate<0.001'],

    // Время подключения к БД не должно расти
    http_req_connecting: ['p(95)<50'],
  }
}

const BASE_URL = __ENV.BASE_URL || 'https://staging.example.com'

export function setup() {
  const res = http.post(`${BASE_URL}/api/auth/login`, JSON.stringify({
    email: '[email protected]',
    password: __ENV.TEST_PASSWORD
  }), { headers: { 'Content-Type': 'application/json' } })

  return { token: res.json('token') }
}

export default function(data) {
  const headers = {
    'Authorization': `Bearer ${data.token}`,
    'Content-Type': 'application/json'
  }

  activeUsers.add(1)

  // Микс операций, типичных для реального трафика
  const scenario = Math.random()

  if (scenario < 0.6) {
    // 60%: чтение данных
    const r = http.get(`${BASE_URL}/api/products?page=${Math.ceil(Math.random() * 50)}`,
      { headers })
    check(r, { 'read: 200': (r) => r.status === 200 })
    errorRate.add(r.status !== 200)

  } else if (scenario < 0.8) {
    // 20%: запись данных (создаём реальные записи)
    const r = http.post(`${BASE_URL}/api/cart/items`, JSON.stringify({
      productId: Math.ceil(Math.random() * 1000),
      quantity: 1
    }), { headers })
    check(r, { 'write: 2xx': (r) => r.status < 300 })
    errorRate.add(r.status >= 400)

  } else if (scenario < 0.9) {
    // 10%: поиск
    const r = http.get(`${BASE_URL}/api/search?q=test&limit=20`, { headers })
    check(r, { 'search: 200': (r) => r.status === 200 })
    errorRate.add(r.status !== 200)

  } else {
    // 10%: профиль пользователя
    const r = http.get(`${BASE_URL}/api/me`, { headers })
    check(r, { 'profile: 200': (r) => r.status === 200 })
    errorRate.add(r.status !== 200)
  }

  // Добавить p95 для временного ряда
  p95Latency.add(http.get(`${BASE_URL}/api/health`).timings.duration)

  sleep(Math.random() * 2 + 0.5)  // 0.5–2.5 секунды между запросами
}

Мониторинг утечек памяти

#!/bin/bash
# scripts/memory-soak-monitor.sh
# Запускать параллельно с k6 soak тестом

APP_PID=$(pgrep -f "node server.js")
LOG_FILE="soak-memory-$(date +%Y%m%d-%H%M).csv"

echo "timestamp,rss_mb,heap_used_mb,heap_total_mb,external_mb,fd_count" > $LOG_FILE

while true; do
  TS=$(date -u +%Y-%m-%dT%H:%M:%SZ)

  # Node.js memory через endpoint /metrics (если expose)
  METRICS=$(curl -s http://localhost:3000/metrics/memory)
  RSS=$(echo $METRICS | jq -r '.rss')
  HEAP_USED=$(echo $METRICS | jq -r '.heapUsed')
  HEAP_TOTAL=$(echo $METRICS | jq -r '.heapTotal')
  EXTERNAL=$(echo $METRICS | jq -r '.external')

  # File descriptors
  FD_COUNT=$(ls /proc/$APP_PID/fd 2>/dev/null | wc -l)

  echo "$TS,$RSS,$HEAP_USED,$HEAP_TOTAL,$EXTERNAL,$FD_COUNT" >> $LOG_FILE
  echo "[$TS] RSS: ${RSS}MB | Heap: ${HEAP_USED}/${HEAP_TOTAL}MB | FDs: $FD_COUNT"

  sleep 60  # каждую минуту
done

// Express/Fastify endpoint для экспонирования памяти
app.get('/metrics/memory', (req, res) => {
  const mem = process.memoryUsage()
  res.json({
    rss: Math.round(mem.rss / 1024 / 1024),
    heapUsed: Math.round(mem.heapUsed / 1024 / 1024),
    heapTotal: Math.round(mem.heapTotal / 1024 / 1024),
    external: Math.round(mem.external / 1024 / 1024),
  })
})

PostgreSQL мониторинг во время soak

-- Запускать каждые 15 минут и сохранять результаты

-- Рост таблиц (bloat)
SELECT relname, n_live_tup, n_dead_tup,
       round(n_dead_tup::numeric / nullif(n_live_tup + n_dead_tup, 0) * 100, 1) AS dead_pct,
       last_vacuum, last_autovacuum
FROM pg_stat_user_tables
ORDER BY n_dead_tup DESC LIMIT 10;

-- Накопление idle транзакций (connection leak)
SELECT count(*), state, wait_event_type
FROM pg_stat_activity
WHERE pid != pg_backend_pid()
GROUP BY state, wait_event_type
ORDER BY count DESC;

-- Рост размеров временных файлов
SELECT temp_files, temp_bytes
FROM pg_stat_database
WHERE datname = current_database();

Анализ тренда деградации

# analyze_soak.py
import pandas as pd
import numpy as np
from scipy import stats
import matplotlib.pyplot as plt

def analyze_memory_trend(csv_file: str):
    df = pd.read_csv(csv_file, parse_dates=['timestamp'])
    df['minutes'] = (df['timestamp'] - df['timestamp'].iloc[0]).dt.total_seconds() / 60

    # Линейная регрессия для RSS
    slope, intercept, r_value, p_value, std_err = stats.linregress(
        df['minutes'], df['rss_mb']
    )

    hours_to_oom = None
    if slope > 0:
        # При каком потреблении памяти начнётся OOM (assume 4GB limit)
        oom_threshold = 4096
        current_rss = df['rss_mb'].iloc[-1]
        hours_to_oom = (oom_threshold - current_rss) / (slope * 60)

    print(f"Memory growth rate: {slope:.2f} MB/min ({slope*60:.1f} MB/hour)")
    print(f"R²: {r_value**2:.3f} (1.0 = perfect linear growth = definite leak)")

    if hours_to_oom:
        print(f"Estimated OOM in: {hours_to_oom:.1f} hours")

    # Тест на статистическую значимость роста
    if p_value < 0.01 and slope > 0.1:
        print("⚠️  MEMORY LEAK DETECTED (statistically significant growth)")
    else:
        print("✓  No significant memory leak detected")

    return {
        'slope_mb_per_min': slope,
        'r_squared': r_value ** 2,
        'hours_to_oom': hours_to_oom,
        'leak_detected': p_value < 0.01 and slope > 0.1
    }

# Запуск
result = analyze_memory_trend('soak-memory-20240315-100000.csv')

Типичные находки и решения

Утечка EventEmitter (Node.js): MaxListenersExceededWarning в логах. Добавить emitter.removeListener() или использовать once().

Незакрытые DB connections: использовать pool.release() в finally блоке или ORM-level connection pooling.

Accumulating cron jobs: если cron работает while previous still running — добавить mutex lock.

Redis pub/sub leak: отписываться от каналов при завершении соединения.

Срок выполнения

Настройка и запуск soak теста на 8–24 часа с анализом трендов памяти и производительности — 2–3 рабочих дня.