API p99 Latency: как достичь <100ms для 99% запросов

Ваш API работает быстро в среднем, но некоторые запросы тормозят секундами? В этом руководстве мы разберем, как оптимизировать p99 latency до <100ms — чтобы 99% запросов обрабатывались молниеносно. Вы узнаете про профилирование узких мест, оптимизацию БД, кэширование Redis и async I/O с примерами для Node.js, Python и Go.

🎯 Что такое p99 latency?

p99 latency (99-й перцентиль) — это время, за которое обрабатывается 99% запросов. Это означает что только 1% запросов медленнее этого значения.

Перцентили latency: что они означают

❓ Почему p99 важнее среднего времени ответа

Целевые значения p99 latency

📊 Как измерить p99 latency

1. Prometheus + Grafana (рекомендуется)

// metrics.js
const promClient = require('prom-client');

// HTTP Request Duration Histogram
const httpRequestDuration = new promClient.Histogram({
  name: 'http_request_duration_ms',
  help: 'Duration of HTTP requests in ms',
  labelNames: ['method', 'route', 'status_code'],
  // Buckets для latency (в миллисекундах)
  buckets: [5, 10, 25, 50, 100, 250, 500, 1000, 2500, 5000, 10000]
});

// Middleware для Express
function metricsMiddleware(req, res, next) {
  const start = Date.now();

  res.on('finish', () => {
    const duration = Date.now() - start;
    httpRequestDuration
      .labels(req.method, req.route?.path || req.path, res.statusCode)
      .observe(duration);
  });

  next();
}

// Endpoint для Prometheus scraping
app.get('/metrics', async (req, res) => {
  res.set('Content-Type', promClient.register.contentType);
  res.end(await promClient.register.metrics());
});

module.exports = { metricsMiddleware };

# p99 latency за последние 5 минут
histogram_quantile(0.99,
  sum(rate(http_request_duration_ms_bucket[5m])) by (le, route)
)

# p50, p95, p99 вместе
histogram_quantile(0.50, sum(rate(http_request_duration_ms_bucket[5m])) by (le))
histogram_quantile(0.95, sum(rate(http_request_duration_ms_bucket[5m])) by (le))
histogram_quantile(0.99, sum(rate(http_request_duration_ms_bucket[5m])) by (le))

2. Python с Prometheus

# metrics.py
from prometheus_client import Histogram, generate_latest, REGISTRY
from flask import Response
import time

# HTTP Request Duration Histogram
http_request_duration = Histogram(
    'http_request_duration_seconds',
    'Duration of HTTP requests in seconds',
    ['method', 'endpoint', 'status_code'],
    buckets=[0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1.0, 2.5, 5.0, 10.0]
)

# Декоратор для Flask routes
def track_time(f):
    def wrapper(*args, **kwargs):
        start = time.time()
        result = f(*args, **kwargs)
        duration = time.time() - start

        http_request_duration.labels(
            method=request.method,
            endpoint=request.endpoint,
            status_code=response.status_code
        ).observe(duration)

        return result
    return wrapper

# Endpoint для Prometheus
@app.route('/metrics')
def metrics():
    return Response(generate_latest(REGISTRY), mimetype='text/plain')

# Использование
@app.route('/api/users')
@track_time
def get_users():
    # Your logic here
    return jsonify(users)

3. Go с Prometheus

// metrics.go
package main

import (
    "github.com/prometheus/client_golang/prometheus"
    "github.com/prometheus/client_golang/prometheus/promhttp"
    "net/http"
    "time"
)

var (
    httpDuration = prometheus.NewHistogramVec(
        prometheus.HistogramOpts{
            Name:    "http_request_duration_seconds",
            Help:    "Duration of HTTP requests in seconds",
            Buckets: []float64{.005, .01, .025, .05, .1, .25, .5, 1, 2.5, 5, 10},
        },
        []string{"method", "endpoint", "status"},
    )
)

func init() {
    prometheus.MustRegister(httpDuration)
}

// Middleware для измерения времени
func prometheusMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()

        // Wrap ResponseWriter для capture status code
        wrapped := wrapResponseWriter(w)
        next.ServeHTTP(wrapped, r)

        duration := time.Since(start).Seconds()
        httpDuration.WithLabelValues(
            r.Method,
            r.URL.Path,
            http.StatusText(wrapped.status),
        ).Observe(duration)
    })
}

func main() {
    // Prometheus metrics endpoint
    http.Handle("/metrics", promhttp.Handler())

    // Your API routes with middleware
    http.Handle("/api/", prometheusMiddleware(http.HandlerFunc(apiHandler)))

    http.ListenAndServe(":8080", nil)
}

🗄️ Оптимизация БД запросов

1. Добавление индексов

-- Запрос
SELECT * FROM users WHERE email = 'user@example.com';

-- EXPLAIN показывает full table scan
-- Время: 2500ms для таблицы с 10M записей

-- Создаем индекс
CREATE INDEX idx_users_email ON users(email);

-- Тот же запрос
SELECT * FROM users WHERE email = 'user@example.com';

-- EXPLAIN показывает index scan
-- Время: 5ms (в 500 раз быстрее!)

2. Решение N+1 проблемы

// Node.js + Sequelize
// 1 запрос для users + N запросов для posts каждого user
const users = await User.findAll(); // 1 query

for (const user of users) {
  user.posts = await Post.findAll({ where: { userId: user.id } }); // N queries
}

// Итого: 1 + N запросов (если 100 users, то 101 запрос!)
// p99 latency: 1500ms

// Node.js + Sequelize
// Только 1 запрос с JOIN
const users = await User.findAll({
  include: [{
    model: Post,
    as: 'posts'
  }]
});

// SQL: SELECT users.*, posts.* FROM users LEFT JOIN posts ON posts.user_id = users.id
// Итого: 1 запрос
// p99 latency: 35ms (в 43 раза быстрее!)

3. SELECT только нужные поля

-- Загружаем все поля включая BLOB
SELECT * FROM products WHERE category = 'electronics';

-- Возвращает: id, name, description, price, image (BLOB 5MB), metadata (JSON 100KB)
-- Network transfer: 500MB для 100 товаров
-- p99 latency: 2000ms

-- Только ID, название и цена
SELECT id, name, price FROM products WHERE category = 'electronics';

-- Network transfer: 5MB для 100 товаров (в 100 раз меньше!)
-- p99 latency: 45ms

🏊 Connection Pooling

Connection pooling переиспользует соединения с БД вместо создания нового для каждого запроса.

Node.js + PostgreSQL (pg pool)

// db.js
const { Pool } = require('pg');

// Connection pool configuration
const pool = new Pool({
  host: 'localhost',
  database: 'mydb',
  user: 'user',
  password: 'password',
  port: 5432,
  // Pool settings
  max: 20,                // Максимум 20 соединений
  min: 5,                 // Минимум 5 соединений всегда активны
  idleTimeoutMillis: 30000,  // Закрыть idle соединения через 30s
  connectionTimeoutMillis: 2000,  // Timeout для получения соединения
});

// Использование
async function getUsers() {
  const client = await pool.connect();  // Получаем соединение из пула
  try {
    const result = await client.query('SELECT * FROM users WHERE active = true');
    return result.rows;
  } finally {
    client.release();  // Возвращаем соединение в пул
  }
}

// Или проще с pool.query (автоматически release)
async function getUserById(id) {
  const result = await pool.query('SELECT * FROM users WHERE id = $1', [id]);
  return result.rows[0];
}

module.exports = { pool };

Python + PostgreSQL (psycopg2)

# db.py
from psycopg2 import pool
import os

# Connection pool
connection_pool = pool.SimpleConnectionPool(
    minconn=5,      # Минимум 5 соединений
    maxconn=20,     # Максимум 20 соединений
    host=os.getenv('DB_HOST'),
    database=os.getenv('DB_NAME'),
    user=os.getenv('DB_USER'),
    password=os.getenv('DB_PASSWORD')
)

def get_users():
    conn = connection_pool.getconn()  # Получаем соединение
    try:
        cursor = conn.cursor()
        cursor.execute("SELECT * FROM users WHERE active = true")
        users = cursor.fetchall()
        return users
    finally:
        connection_pool.putconn(conn)  # Возвращаем в пул

# С context manager (автоматический release)
from contextlib import contextmanager

@contextmanager
def get_db_connection():
    conn = connection_pool.getconn()
    try:
        yield conn
    finally:
        connection_pool.putconn(conn)

# Использование
def get_user_by_id(user_id):
    with get_db_connection() as conn:
        cursor = conn.cursor()
        cursor.execute("SELECT * FROM users WHERE id = %s", (user_id,))
        return cursor.fetchone()

Go + PostgreSQL (pgx pool)

// db.go
package main

import (
    "context"
    "github.com/jackc/pgx/v5/pgxpool"
    "time"
)

var dbPool *pgxpool.Pool

func InitDB() error {
    config, err := pgxpool.ParseConfig("postgres://user:password@localhost:5432/mydb")
    if err != nil {
        return err
    }

    // Pool configuration
    config.MaxConns = 20                           // Максимум соединений
    config.MinConns = 5                            // Минимум соединений
    config.MaxConnLifetime = time.Hour             // Пересоздавать соединения каждый час
    config.MaxConnIdleTime = 30 * time.Second      // Закрыть idle через 30s
    config.HealthCheckPeriod = time.Minute         // Health check каждую минуту

    dbPool, err = pgxpool.NewWithConfig(context.Background(), config)
    return err
}

func GetUsers(ctx context.Context) ([]User, error) {
    rows, err := dbPool.Query(ctx, "SELECT id, name, email FROM users WHERE active = true")
    if err != nil {
        return nil, err
    }
    defer rows.Close()

    var users []User
    for rows.Next() {
        var user User
        if err := rows.Scan(&user.ID, &user.Name, &user.Email); err != nil {
            return nil, err
        }
        users = append(users, user)
    }

    return users, rows.Err()
}

💾 Кэширование с Redis

Redis кэширование может снизить p99 latency в 10-50 раз для read-heavy API.

Cache-Aside Pattern (Lazy Loading)

// cache.js
const redis = require('redis');
const client = redis.createClient({ url: 'redis://localhost:6379' });

await client.connect();

// Cache-Aside pattern
async function getUserById(id) {
  const cacheKey = `user:${id}`;

  // 1. Попытка получить из cache
  const cached = await client.get(cacheKey);
  if (cached) {
    console.log('Cache HIT');
    return JSON.parse(cached);
  }

  // 2. Cache MISS — запрос в БД
  console.log('Cache MISS');
  const user = await db.query('SELECT * FROM users WHERE id = $1', [id]);

  // 3. Сохраняем в cache с TTL 5 минут
  await client.setEx(cacheKey, 300, JSON.stringify(user));

  return user;
}

// Cache Invalidation при UPDATE
async function updateUser(id, data) {
  // 1. Обновляем в БД
  await db.query('UPDATE users SET name = $1 WHERE id = $2', [data.name, id]);

  // 2. Инвалидируем cache
  await client.del(`user:${id}`);
}

Cache-Through Pattern (Read-Through)

# cache.py
import redis
import json
from functools import wraps

redis_client = redis.Redis(host='localhost', port=6379, decode_responses=True)

def cache_through(key_prefix, ttl=300):
    """Декоратор для автоматического кэширования"""
    def decorator(func):
        @wraps(func)
        async def wrapper(*args, **kwargs):
            # Генерируем cache key
            cache_key = f"{key_prefix}:{':'.join(map(str, args))}"

            # Попытка получить из cache
            cached = redis_client.get(cache_key)
            if cached:
                return json.loads(cached)

            # Cache MISS — вызываем функцию
            result = await func(*args, **kwargs)

            # Сохраняем в cache
            redis_client.setex(cache_key, ttl, json.dumps(result))

            return result
        return wrapper
    return decorator

# Использование
@cache_through(key_prefix='user', ttl=300)
async def get_user_by_id(user_id):
    # Запрос в БД
    cursor.execute("SELECT * FROM users WHERE id = %s", (user_id,))
    return cursor.fetchone()

# Теперь get_user_by_id автоматически кэшируется!

Best Practices для кэширования

⚡ Async/Non-blocking I/O

Синхронный I/O блокирует поток, пока ждет ответ от БД/API. Async I/O позволяет обрабатывать другие запросы во время ожидания.

Node.js Async (по умолчанию async)

// async.js
const express = require('express');
const app = express();

// ✅ Хорошо: async/await
app.get('/api/users', async (req, res) => {
  try {
    // Параллельные запросы
    const [users, stats] = await Promise.all([
      db.query('SELECT * FROM users'),
      db.query('SELECT COUNT(*) FROM users')
    ]);

    res.json({ users, total: stats.count });
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

// ❌ Плохо: синхронные операции блокируют event loop
app.get('/api/slow', (req, res) => {
  // Blocking operation - BAD!
  const result = someHeavySync Calculation();
  res.json(result);
});

// ✅ Хорошо: offload в Worker Thread
const { Worker } = require('worker_threads');

app.get('/api/fast', async (req, res) => {
  const worker = new Worker('./heavy-calculation.js');
  worker.on('message', (result) => {
    res.json(result);
  });
});

Python Async (asyncio + FastAPI)

# async_api.py
from fastapi import FastAPI
import asyncio
import httpx
import asyncpg

app = FastAPI()

# Database pool (async)
db_pool = None

@app.on_event("startup")
async def startup():
    global db_pool
    db_pool = await asyncpg.create_pool(
        "postgresql://user:password@localhost/mydb",
        min_size=5,
        max_size=20
    )

# ✅ Async endpoint
@app.get("/api/users")
async def get_users():
    async with db_pool.acquire() as conn:
        users = await conn.fetch("SELECT * FROM users")
        return users

# ✅ Параллельные async запросы
@app.get("/api/dashboard")
async def get_dashboard():
    # Все запросы параллельно!
    users, posts, stats = await asyncio.gather(
        db_pool.fetch("SELECT * FROM users"),
        db_pool.fetch("SELECT * FROM posts"),
        db_pool.fetchrow("SELECT COUNT(*) as total FROM users")
    )

    return {
        "users": users,
        "posts": posts,
        "total_users": stats['total']
    }

# ✅ Async внешний API call
@app.get("/api/external")
async def call_external_api():
    async with httpx.AsyncClient() as client:
        # Параллельные вызовы внешних API
        responses = await asyncio.gather(
            client.get("https://api1.example.com/data"),
            client.get("https://api2.example.com/data"),
            client.get("https://api3.example.com/data")
        )
        return [r.json() for r in responses]

🗜️ Compression и Network Optimization

Compression снижает размер ответа в 5-10 раз, что ускоряет transfer time особенно для медленных сетей.

Node.js: gzip/brotli compression

// compression.js
const express = require('express');
const compression = require('compression');

const app = express();

// Включаем compression (gzip/deflate)
app.use(compression({
  level: 6,  // Уровень сжатия (1-9, 6 = баланс скорость/размер)
  threshold: 1024,  // Сжимать ответы > 1KB
  filter: (req, res) => {
    // Не сжимать уже сжатые форматы
    if (req.headers['x-no-compression']) {
      return false;
    }
    return compression.filter(req, res);
  }
}));

// Benchmark:
// Без compression: 500KB JSON → 500KB transfer → p99 = 180ms (slow network)
// С compression: 500KB JSON → 50KB transfer → p99 = 45ms (в 4 раза быстрее!)

Python Flask: gzip compression

# compression.py
from flask import Flask
from flask_compress import Compress

app = Flask(__name__)

# Включаем compression
app.config['COMPRESS_MIMETYPES'] = [
    'text/html',
    'text/css',
    'application/json',
    'application/javascript'
]
app.config['COMPRESS_LEVEL'] = 6  # Уровень сжатия
app.config['COMPRESS_MIN_SIZE'] = 1024  # Сжимать > 1KB

Compress(app)

@app.route('/api/data')
def get_data():
    # Автоматически сжимается если Accept-Encoding: gzip
    return jsonify(large_data)

🔍 Профилирование и поиск bottlenecks

OpenTelemetry Distributed Tracing

// tracing.js
const { NodeTracerProvider } = require('@opentelemetry/sdk-trace-node');
const { registerInstrumentations } = require('@opentelemetry/instrumentation');
const { HttpInstrumentation } = require('@opentelemetry/instrumentation-http');
const { ExpressInstrumentation } = require('@opentelemetry/instrumentation-express');

// Setup tracing
const provider = new NodeTracerProvider();
provider.register();

registerInstrumentations({
  instrumentations: [
    new HttpInstrumentation(),
    new ExpressInstrumentation(),
  ],
});

// Теперь каждый request автоматически трейсится!
// Вы увидите breakdown времени:
// - Database queries: 45ms
// - External API calls: 120ms
// - Redis cache: 2ms
// - Application code: 8ms
// Total: 175ms

✅ Best Practices для p99 latency

🔍 FAQ: Часто задаваемые вопросы

📝 Выводы

В этой статье мы рассмотрели как оптимизировать p99 latency до <100ms:

1. Измерение: Prometheus + Grafana для мониторинга p99
2. Оптимизация БД: индексы, eager loading, SELECT нужных полей
3. Connection Pooling: переиспользование соединений с БД
4. Кэширование: Redis для read-heavy данных (снижает p99 в 10-50 раз)
5. Async I/O: non-blocking операции, параллельные запросы
6. Compression: gzip/brotli для уменьшения network transfer
7. Профилирование: distributed tracing для поиска bottlenecks

Related Articles

• API Load Testing: Apache JMeter, Gatling, K6
• API Performance: как оптимизировать производительность
• API Caching: стратегии кэширования для производительности
• API Monitoring и Logging: как отслеживать здоровье API