Kurs NestJS · Moduł 8: Cache i wydajność

Performance Optimization - zwiększanie prędkości kohorty

8 min czytania ·
W tej lekcji6

Wieczorem, gdy kohorty zdają raporty, fort zwalnia: odpowiedź, która rano trwa 80 ms, po zmroku ciągnie się sekundami. Konsul Caesar.js chce przyspieszenia, ale nikt nie wie, co spowalnia - baza, procesor czy pamięć. Pierwsza zasada inżyniera legionowego brzmi więc: najpierw zmierz, potem optymalizuj.

Czym jest optymalizacja wydajności?

Wyobraź sobie aplikację jako obóz legionu:

  • siła legionistów (CPU) - musi wystarczyć na wszystkie zadania,
  • magazyny (pamięć) - muszą być dobrze zarządzane,
  • tabularium (baza danych) - musi być uporządkowane,
  • kohorty (procesy) - muszą sprawnie współpracować,
  • drogi i posłańcy (operacje I/O) - muszą być przejezdne.

Optymalizacja to sztuka harmonijnego dostrojenia wszystkich tych elementów.

Cztery sygnały

Zanim cokolwiek zmienisz, ustal, co mierzysz. Książka Google o SRE wymienia cztery złote sygnały, w tej kolejności:

  • latencja - czas odpowiedzi, podawany jako percentyle p95 i p99,
  • ruch - przepustowość, na przykład żądania na sekundę,
  • błędy - odsetek nieudanych żądań,
  • nasycenie - zużycie zasobów, czyli CPU i pamięci.

p95 równe 200 ms znaczy, że 95% żądań kończy się szybciej niż w 200 ms. Średnia ukrywa pechowców z ogona: użytkownik czekający 10 sekund ginie w niej wśród tysiąca szybkich odpowiedzi.

Cztery próby obciążenia

Sygnały odczytujesz podczas testów obciążeniowych, od najlżejszego do najcięższego:

  • smoke test - minimalne obciążenie, sprawdza, czy system w ogóle działa,
  • load test - oczekiwany, typowy ruch,
  • stress test - obciążenie powyżej oczekiwanego, szukające punktu krytycznego,
  • spike test - nagły, krótki i ogromny skok ruchu.

Tak dzieli je dokumentacja narzędzia k6; samo strzelanie żądaniami poznasz w lekcji o profilowaniu.

Profiling - diagnoza problemów

Wewnątrz aplikacji czas mierzy moduł perf_hooks z Node.js: performance.mark() stawia znacznik na osi czasu, performance.measure() liczy odstęp między dwoma znacznikami, a PerformanceObserver dostaje każdy nowy pomiar. Na tym zbudujemy serwis profilujący:

// performance-profiler.service.ts
import { Injectable } from '@nestjs/common';
import { performance, PerformanceObserver } from 'node:perf_hooks';

@Injectable()
export class PerformanceProfilerService {
  private measurements = new Map<string, number[]>();
  private observer: PerformanceObserver;

  constructor() {
    this.setupPerformanceObserver();
  }

  private setupPerformanceObserver(): void {
    this.observer = new PerformanceObserver((list) => {
      list.getEntries().forEach((entry) => {
        if (entry.entryType === 'measure') {
          this.recordMeasurement(entry.name, entry.duration);
        }
      });
    });

    this.observer.observe({ entryTypes: ['measure'] });
  }

  private recordMeasurement(name: string, duration: number): void {
    if (!this.measurements.has(name)) {
      this.measurements.set(name, []);
    }

    const measurements = this.measurements.get(name)!;
    measurements.push(duration);

    // Zachowaj tylko ostatnie 100 pomiarów
    if (measurements.length > 100) {
      measurements.shift();
    }

    // Loguj wolne operacje
    if (duration > 1000) {
      console.warn(`Wolna operacja: ${name} - ${duration.toFixed(2)}ms`);
    }
  }

Obserwator przekazuje pomiary do recordMeasurement(), który trzyma ostatnie 100 wyników każdej operacji i ostrzega o dłuższych niż sekunda.

Najwygodniej mierzy się dekoratorem - statyczną metodą, która owija oryginalną metodę pomiarem:

  // Dekorator do mierzenia czasu wykonania
  static Measure(operationName?: string) {
    return function (target: any, propertyName: string, descriptor: PropertyDescriptor) {
      const originalMethod = descriptor.value;
      const measureName = operationName || `${target.constructor.name}.${propertyName}`;
      let callId = 0;

      descriptor.value = async function (...args: any[]) {
        const id = ++callId; // osobne znaczniki dla równoległych wywołań
        const startMark = `${measureName}-start-${id}`;
        const endMark = `${measureName}-end-${id}`;

        performance.mark(startMark);

        try {
          const result = await originalMethod.apply(this, args);
          performance.mark(endMark);
          performance.measure(measureName, startMark, endMark);
          return result;
        } catch (error) {
          performance.mark(endMark);
          performance.measure(`${measureName}-error`, startMark, endMark);
          throw error;
        } finally {
          // Znaczniki zostają w globalnej osi czasu, dopóki ich nie usuniemy
          performance.clearMarks(startMark);
          performance.clearMarks(endMark);
          performance.clearMeasures(measureName);
          performance.clearMeasures(`${measureName}-error`);
        }
      };
    };
  }

Pierwsza wersja budowała nazwy znaczników z Date.now(), więc dwa wywołania w tej samej milisekundzie nadpisywały sobie znaczniki; licznik callId to naprawia. Blok finally sprząta, bo znaczniki bez clearMarks() rosłyby w serwerze działającym tygodniami jak wyciek pamięci. Obserwator dostał już pomiar, więc nic nie tracimy.

Pomiar ręczny przydaje się, gdy mierzysz tylko fragment metody:

  startMeasurement(name: string): void {
    performance.mark(`${name}-start`);
  }

  endMeasurement(name: string): number {
    const endMark = `${name}-end`;
    performance.mark(endMark);
    // measure() zwraca świeży pomiar - nie szukamy go w historii
    const measurement = performance.measure(name, `${name}-start`, endMark);

    performance.clearMarks(`${name}-start`);
    performance.clearMarks(endMark);
    performance.clearMeasures(name);
    return measurement.duration;
  }

Wcześniej serwis szukał pomiaru przez getEntriesByName(name)[0], a to zwraca najstarszy pomiar o tej nazwie - od drugiego wywołania wynik był w kółko ten sam.

Z zebranych liczb robimy statystyki:

  getStatistics(operationName: string) {
    const measurements = this.measurements.get(operationName) || [];
    if (measurements.length === 0) return null;

    const sorted = [...measurements].sort((a, b) => a - b);
    const avg = measurements.reduce((a, b) => a + b, 0) / measurements.length;

    return {
      count: measurements.length,
      average: avg.toFixed(2),
      median: sorted[Math.floor(sorted.length / 2)].toFixed(2),
      min: sorted[0].toFixed(2),
      max: sorted[sorted.length - 1].toFixed(2),
      p95: sorted[Math.ceil(sorted.length * 0.95) - 1].toFixed(2),
    };
  }

  getAllStatistics() {
    const stats = {};
    this.measurements.forEach((_, name) => {
      stats[name] = this.getStatistics(name);
    });
    return stats;
  }
}

p95 liczymy metodą najbliższej rangi: przy 100 pomiarach to 95. wynik po posortowaniu.

W serwisie dekorator stoi nad metodą, a pomiar ręczny otacza wybrany fragment:

// Użycie w serwisie
@Injectable()
export class TributeService {
  constructor(private profiler: PerformanceProfilerService) {}

  @PerformanceProfilerService.Measure('tribute-search')
  async findTributes(criteria: any) {
    // Złożone wyszukiwanie tributów
    await this.complexDatabaseQuery(criteria);
    return [];
  }

  async manualMeasurement() {
    this.profiler.startMeasurement('manual-operation');

    // Jakaś operacja
    await this.doSomething();

    const duration = this.profiler.endMeasurement('manual-operation');
    console.log(`Operacja zajęła: ${duration}ms`);
  }

  private async complexDatabaseQuery(criteria: any) {
    await new Promise((r) => setTimeout(r, 20)); // zaślepka zapytania
  }

  private async doSomething() {
    await new Promise((r) => setTimeout(r, 30)); // zaślepka pracy
  }
}

Dekorator nie zmienia treści findTributes - metoda dalej tylko wyszukuje, a pomiar dzieje się obok.

Database Query Optimization

Najczęstszym winowajcą jest baza. Klasyczny problem N+1 wygląda niewinnie:

// query-optimizer.service.ts
@Injectable()
export class QueryOptimizerService {
  constructor(
    @InjectRepository(Tribute) private tributeRepo: Repository<Tribute>,
  ) {}

  // Zamiast N+1 queries
  async getBadTributesWithOwners(): Promise<any[]> {
    const tributes = await this.tributeRepo.find();

    // To generuje N zapytań dodatkowych!
    const tributesWithOwners = [];
    for (const tribute of tributes) {
      const owner = await this.getOwner(tribute.ownerId);
      tributesWithOwners.push({ ...tribute, owner });
    }

    return tributesWithOwners;
  }

Jedno zapytanie po listę i po jednym na każdego właściciela: w teście na PostgreSQL 120 tributów kosztowało 121 zapytań.

Rozwiązaniem jest JOIN, który TypeORM zbuduje z opcji relations:

  // Optymalna wersja z JOIN
  async getOptimizedTributesWithOwners(): Promise<any[]> {
    // Jedno zapytanie z JOIN
    return await this.tributeRepo.find({
      relations: { owner: true },
      select: {
        id: true,
        name: true,
        value: true,
        owner: {
          id: true,
          name: true,
          rank: true,
        },
      },
    });
  }

Ten sam wynik przyszedł jednym zapytaniem, a select pobrał tylko potrzebne kolumny. TypeORM 1.x usunął tablicową składnię relations: ['owner'] - obowiązuje obiekt.

Duże zbiory przetwarzamy partiami, zamiast ładować wszystko do pamięci:

  // Batch processing dla dużych zbiorów
  async processTributesInBatches(batchSize: number = 100): Promise<void> {
    let offset = 0;
    let batch;

    do {
      batch = await this.tributeRepo.find({
        skip: offset,
        take: batchSize,
        order: { id: 'ASC' },
      });

      if (batch.length > 0) {
        await this.processTributeBatch(batch);
        offset += batchSize;

        // Oddaj na chwilę event loop innym żądaniom
        await this.delay(10);
      }
    } while (batch.length === batchSize);
  }

Pauza oddaje event loop innym żądaniom; pierwsza wersja twierdziła, że „daje czas garbage collectorowi”, ale GC działa, kiedy sam uzna za stosowne. Z każdą partią rośnie skip, a baza i tak przechodzi pominięte wiersze, więc przy milionach rekordów lepszy jest kursor:

  // Paginacja z cursor dla bardzo dużych zbiorów
  async getTributesWithCursor(cursor?: number, limit: number = 50) {
    const qb = this.tributeRepo.createQueryBuilder('tribute');

    if (cursor) {
      qb.where('tribute.id > :cursor', { cursor });
    }

    const tributes = await qb
      .orderBy('tribute.id', 'ASC')
      .limit(limit + 1) // +1 żeby sprawdzić czy są kolejne
      .getMany();

    const hasNext = tributes.length > limit;
    const items = hasNext ? tributes.slice(0, -1) : tributes;
    const nextCursor = hasNext ? tributes[tributes.length - 2].id : null;

    return {
      items,
      nextCursor,
      hasNext,
    };
  }

Kursor to id ostatniego zwróconego wiersza, a WHERE id > :cursor korzysta z indeksu klucza głównego, więc setna strona jest tak szybka jak pierwsza. Jeden dodatkowy wiersz mówi, czy istnieje następna strona, bez osobnego COUNT.

Filtry też decydują o szybkości:

  // Optymalizacja z indeksami
  async searchTributesOptimized(filters: any) {
    const qb = this.tributeRepo.createQueryBuilder('tribute');

    // Używaj indeksowanych kolumn w WHERE
    if (filters.type) {
      qb.andWhere('tribute.type = :type', { type: filters.type });
    }

    if (filters.minValue) {
      qb.andWhere('tribute.value >= :minValue', { minValue: filters.minValue });
    }

    // Użyj indeksu na created_at
    if (filters.dateRange) {
      qb.andWhere('tribute.createdAt BETWEEN :start AND :end', {
        start: filters.dateRange.start,
        end: filters.dateRange.end,
      });
    }

    return await qb
      .orderBy('tribute.value', 'DESC') // Indeks na value
      .limit(filters.limit || 100)
      .getMany();
  }

  private async delay(ms: number): Promise<void> {
    return new Promise(resolve => setTimeout(resolve, ms));
  }

  private async processTributeBatch(tributes: Tribute[]): Promise<void> {
    // Przetwarzanie batch'a
    console.log(`Przetwarzam ${tributes.length} tributów...`);
  }
}

Warunki na indeksowanych kolumnach pozwalają bazie od razu przeskoczyć do właściwych wierszy. limit() jest tu bezpieczny, bo zapytanie nie ma JOIN-ów; przy nich używaj take().

Warstwy szybkości

Najszybsze żądanie to takie, które w ogóle nie dotrze do fortu. Od warstwy najbliższej użytkownikowi:

  • cache przeglądarki - sterowany nagłówkami Cache-Control,
  • CDN, czyli edge cache - kopie treści na serwerach blisko użytkowników, co skraca drogę i latencję,
  • cache aplikacji - Redis z poprzednich lekcji,
  • cache zapytań po stronie bazy danych.

Polecam Ci jedną kolejność pracy: zmierz, popraw największy problem, zmierz ponownie - bez drugiego pomiaru nie wiesz, czy pomogłeś. W kolejnych lekcjach zajmiemy się indeksami, rozkładaniem ruchu i pamięcią.

Pamiętaj: szybka kohorta nie biega szybciej, tylko nie dźwiga zbędnego ciężaru - najpierw go zważ, potem zrzuć.

Kod do tej lekcji: src/performance-optimization.ts
// Performance Optimization - Zwiekszanie Predkosci Kohorty
import { Injectable, NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common';
import { Observable } from 'rxjs';
import { tap } from 'rxjs/operators';

// 1. Interceptor mierzacy czas odpowiedzi
@Injectable()
export class PerformanceInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    const start = Date.now();
    const req = context.switchToHttp().getRequest();

    return next.handle().pipe(
      tap(() => {
        const duration = Date.now() - start;
        const method = req.method;
        const url = req.url;
        console.log(`[${method}] ${url} - ${duration}ms`);

        if (duration > 1000) {
          console.warn(`SLOW REQUEST: ${url} took ${duration}ms`);
        }
      }),
    );
  }
}

// 2. Lazy loading modulow
// @Module({
//   imports: [
//     LazyModuleLoader, // NestJS lazy loading
//   ],
// })
// class AppModule {}
//
// // W serwisie:
// const { ProvinceModule } = await import('./province.module');
// const moduleRef = await this.lazyModuleLoader.load(
//   () => ProvinceModule
// );
// const service = moduleRef.get(ProvinceService);

// 3. Pagination - nie laduj wszystkiego naraz
@Injectable()
class PaginationService {
  async findPaginated<T>(
    query: any,
    page: number = 1,
    limit: number = 20
  ): Promise<{
    data: T[];
    total: number;
    page: number;
    lastPage: number;
  }> {
    const skip = (page - 1) * limit;
    // const [data, total] = await repo.findAndCount({
    //   skip, take: limit,
    //   order: { createdAt: 'DESC' },
    // });

    const total = 100; // symulacja
    const data = [] as T[];

    return {
      data,
      total,
      page,
      lastPage: Math.ceil(total / limit),
    };
  }
}

// 4. Connection pooling
const databaseConfig = {
  type: 'postgres',
  host: 'localhost',
  port: 5432,
  // Pool configuration
  extra: {
    max: 20,        // Max polaczen w puli
    min: 5,         // Min polaczen
    idle: 10000,    // Timeout bezczynnosci (ms)
    acquire: 30000, // Timeout uzyskania polaczenia
  },
};

// 5. Kompresja odpowiedzi
// import * as compression from 'compression';
// app.use(compression());
// Zmniejsza rozmiar odpowiedzi o 60-80%!

Hasła z dokumentacji w tej lekcji

Widzisz błąd w tej lekcji?

Sprawdź się

Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.

  1. 1. Stress testing w kontekście wydajności oznacza:

  2. 2. Edge caching w CDN oznacza:

Zadania praktyczne w grze

  • Układanie w pionie

    Uporządkuj etapy testowania obciążeniowego od najlżejszego:

  • Klikanie w kolejności

    Ułóż kluczowe metryki wydajności w kolejności czterech złotych sygnałów Google SRE:

  1. PytanieRodzaje load testów
  2. PytanieCDN i edge caching
  3. Ułóż w kolejnościEtapy load testing
  4. Kliknij w kolejnościMetryki wydajności

Przydatne artykuły