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

Memory Management - optymalizacja magazynów kastrum

10 min czytania ·
W tej lekcji5

Zarządco magazynów! Konsul Caesar.js zauważył, że nasz fort jest przeciążony: po tygodniu pracy proces zajmuje dwa razy więcej pamięci niż po starcie, a legion ma coraz mniej miejsca na manewry. W końcu kontener dostaje limit pamięci i ginie w środku dnia. Czas nauczyć się zarządzania pamięcią w Node.js.

Czym jest zarządzanie pamięcią w świecie legionariuszy?

Wyobraź sobie aplikację jako system magazynów:

  • heap - główny magazyn, gdzie przechowywane są tributy (obiekty),
  • stack - formacja, w której tymczasowo stoją wywołania funkcji i ich zmienne lokalne,
  • garbage collector - oddział sprzątający przedmioty, do których nikt już nie sięga,
  • memory leaks - tributy, o których zapomniano, ale wciąż ktoś trzyma do nich klucz.

Dobre zarządzanie pamięcią to sprawny, szybki fort.

Monitoring pamięci

process.memoryUsage() zwraca pięć liczb: rss to cała pamięć procesu, heapTotal - zarezerwowana sterta, heapUsed - jej zajęta część, external - pamięć obiektów C++ powiązanych z JavaScriptem, a arrayBuffers - bufory. Serwis monitorujący próbkuje je co 10 sekund:

// memory-monitor.service.ts
import { Injectable } from '@nestjs/common';
import { Cron } from '@nestjs/schedule';
import { getHeapStatistics } from 'node:v8';

@Injectable()
export class MemoryMonitorService {
  private memoryHistory: Array<{
    timestamp: Date;
    usage: NodeJS.MemoryUsage;
  }> = [];

  private readonly MEMORY_THRESHOLD_MB = 512; // Alert przy 512MB
  private readonly HISTORY_SIZE = 100;
  // Prawdziwy limit sterty: domyślny albo z flagi --max-old-space-size
  private readonly HEAP_LIMIT = getHeapStatistics().heap_size_limit;

  @Cron('*/10 * * * * *') // Co 10 sekund
  checkMemoryUsage(): void {
    const usage = process.memoryUsage();

    this.memoryHistory.push({ timestamp: new Date(), usage });

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

    // Sprawdź czy pamięć nie przekracza progu
    const heapUsedMB = usage.heapUsed / 1024 / 1024;
    if (heapUsedMB > this.MEMORY_THRESHOLD_MB) {
      console.warn(`Wysokie użycie pamięci: ${heapUsedMB.toFixed(2)}MB`);
      this.suggestOptimizations(usage);
    }

    // Loguj co minutę
    if (new Date().getSeconds() === 0) {
      this.logMemoryStatus(usage);
    }
  }

@Cron wymaga ScheduleModule.forRoot(). Prawdziwy limit sterty podaje getHeapStatistics() z node:v8: heapTotal to tylko bieżąca rezerwacja, którą V8 sam powiększa, więc pierwsza wersja, porównując z nią, alarmowała przy zupełnie zdrowym procesie.

Co minutę serwis wypisuje stan i liczy trend:

  private logMemoryStatus(usage: NodeJS.MemoryUsage): void {
    const formatMB = (bytes: number) => (bytes / 1024 / 1024).toFixed(2);

    console.log('Status magazynów kastrum:');
    console.log(`Heap używany: ${formatMB(usage.heapUsed)}MB`);
    console.log(`Heap całkowity: ${formatMB(usage.heapTotal)}MB`);
    console.log(`RSS (pamięć fizyczna): ${formatMB(usage.rss)}MB`);
    console.log(`Zewnętrzna: ${formatMB(usage.external)}MB`);

    // Oblicz wzrost pamięci
    const growthInfo = this.calculateMemoryGrowth();
    if (growthInfo.isGrowing) {
      console.log(`Trend: +${growthInfo.growthRate.toFixed(2)}MB/min`);
    }
  }

  private calculateMemoryGrowth(): { isGrowing: boolean; growthRate: number } {
    if (this.memoryHistory.length < 10) return { isGrowing: false, growthRate: 0 };

    const recent = this.memoryHistory.slice(-10);
    const oldest = recent[0];
    const newest = recent[recent.length - 1];

    const timeDiffMin = (newest.timestamp.getTime() - oldest.timestamp.getTime()) / 60000;
    const memoryDiffMB = (newest.usage.heapUsed - oldest.usage.heapUsed) / 1024 / 1024;

    const growthRate = memoryDiffMB / timeDiffMin;

    return {
      isGrowing: growthRate > 1, // Więcej niż 1MB/min
      growthRate,
    };
  }

Trend porównuje najstarszy i najnowszy z dziesięciu ostatnich pomiarów. Wzrost o ponad 1 MB na minutę, który nie spada, to pierwszy objaw wycieku.

Sugestie i alerty sprawdzają te same progi:

  private suggestOptimizations(usage: NodeJS.MemoryUsage): void {
    console.log('Sugestie optymalizacji:');

    if (usage.heapUsed / this.HEAP_LIMIT > 0.9) {
      console.log(' - Sterta blisko limitu: zrób heap snapshot i szukaj wycieku');
    }

    if (usage.external > 50 * 1024 * 1024) {
      console.log(' - Sprawdź bufory i strumienie - może za dużo danych w pamięci');
    }

    console.log(" - Sprawdź potencjalne memory leaks w cache'ach");
    console.log(' - Rozważ zmniejszenie TTL dla danych tymczasowych');
  }

  getMemoryReport() {
    const current = process.memoryUsage();
    const formatMB = (bytes: number) => (bytes / 1024 / 1024).toFixed(2);

    return {
      current: {
        heapUsed: formatMB(current.heapUsed) + 'MB',
        heapTotal: formatMB(current.heapTotal) + 'MB',
        heapLimit: formatMB(this.HEAP_LIMIT) + 'MB',
        rss: formatMB(current.rss) + 'MB',
        external: formatMB(current.external) + 'MB',
      },
      trend: this.calculateMemoryGrowth(),
      history: this.memoryHistory.slice(-20), // Ostatnie 20 pomiarów
      alerts: this.generateAlerts(current),
    };
  }

  private generateAlerts(usage: NodeJS.MemoryUsage): string[] {
    const alerts = [];
    const heapUsedMB = usage.heapUsed / 1024 / 1024;

    if (heapUsedMB > this.MEMORY_THRESHOLD_MB) {
      alerts.push(`Wysokie użycie heap: ${heapUsedMB.toFixed(2)}MB`);
    }

    if (usage.heapUsed / this.HEAP_LIMIT > 0.85) {
      alerts.push('Sterta zajmuje ponad 85% limitu - grozi błąd out of memory');
    }

    const growthInfo = this.calculateMemoryGrowth();
    if (growthInfo.isGrowing && growthInfo.growthRate > 5) {
      alerts.push(`Szybki wzrost pamięci: ${growthInfo.growthRate.toFixed(2)}MB/min`);
    }

    return alerts;
  }

Stara wersja radziła tu „uruchom global.gc()”. To zła rada: V8 sprząta sam, a ręczne GC tylko zatrzymuje aplikację. Pełne sprzątanie ma jedno uczciwe zastosowanie - diagnostykę:

  // Diagnostyka: czy pamięć wraca po pełnym GC? (wymaga flagi --expose-gc)
  forceGarbageCollection(): { before: number; after: number; freed: number } {
    const beforeMB = process.memoryUsage().heapUsed / 1024 / 1024;

    if (global.gc) {
      global.gc();
      const afterMB = process.memoryUsage().heapUsed / 1024 / 1024;
      const freedMB = beforeMB - afterMB;

      console.log(`Garbage collection: zwolniono ${freedMB.toFixed(2)}MB`);

      return {
        before: beforeMB,
        after: afterMB,
        freed: freedMB,
      };
    } else {
      console.warn('Garbage collection niedostępny - uruchom z flagą --expose-gc');
      return { before: beforeMB, after: beforeMB, freed: 0 };
    }
  }
}

Jeśli po wymuszonym GC pamięć nie spada, obiekty wciąż ktoś trzyma, czyli masz wyciek. Flagę --expose-gc włączaj tylko przy takim śledztwie.

Event loop - jedna droga przez obóz

JavaScript w Node.js działa w jednym wątku, który obsługuje zdarzenia w pętli. Dokumentacja Node.js wymienia jej fazy w tej kolejności: timers (setTimeout, setInterval), pending callbacks (odroczone wywołania I/O, dawniej nazywane I/O callbacks), idle i prepare, poll (nowe zdarzenia I/O), check (setImmediate) i close callbacks. Gdy jedna funkcja liczy synchronicznie przez sekundę, event loop jest zablokowany i zatrzymuje obsługę wszystkich innych żądań.

Opóźnienie pętli mierzy monitorEventLoopDelay() z perf_hooks, który zbiera pomiary w histogram:

// event-loop.monitor.ts
import { Injectable, Logger, OnModuleDestroy } from '@nestjs/common';
import { Interval } from '@nestjs/schedule';
import { monitorEventLoopDelay } from 'node:perf_hooks';

@Injectable()
export class EventLoopMonitor implements OnModuleDestroy {
  private readonly logger = new Logger(EventLoopMonitor.name);
  private readonly histogram = monitorEventLoopDelay({ resolution: 20 });

  constructor() {
    this.histogram.enable();
  }

  @Interval(10000) // Co 10 sekund
  check() {
    const p99 = this.histogram.percentile(99) / 1e6; // nanosekundy na milisekundy
    if (p99 > 100) {
      this.logger.warn(`Event loop opóźniony: p99 = ${p99.toFixed(1)} ms`);
    }
    this.histogram.reset();
  }

  onModuleDestroy() {
    this.histogram.disable();
  }
}

Histogram podaje wartości w nanosekundach, stąd dzielenie przez 1e6. W teście 200 ms blokady dało p99 równe 208 ms.

Techniki unikania blokowania, od najprostszej:

  1. async/await zamiast operacji synchronicznych, np. fs.promises zamiast readFileSync,
  2. przeniesienie ciężkich obliczeń do kolejki Bull (dziś BullMQ) obsługiwanej przez osobny proces,
  3. worker threads z node:worker_threads dla zadań obciążających CPU,
  4. clustering z PM2, czyli kilka procesów na kilku rdzeniach.

Wycieki - tributy, o których zapomniano

Najczęstszą przyczyną wycieku są niezwolnione referencje: listener dodany przy każdym żądaniu i nigdy nieusunięty, domknięcie trzymające duży obiekt, rosnąca bez końca mapa albo zapomniany timer. Diagnoza idzie krokami:

  1. monitoruj rosnące zużycie pamięci (process.memoryUsage),
  2. wykonaj heap dump i przeanalizuj retencję obiektów,
  3. zidentyfikuj niezwolnione referencje i listenery,
  4. napraw wyciek i zweryfikuj stabilność pamięci.

Analiza heap dumpa pokazuje, które obiekty zajmują pamięć i kto je trzyma; narzędzia do zrzutów poznasz w lekcji o profilowaniu.

Optymalizacja cache'a i kolekcji

Klasyczny wyciek to cache bez limitu. Nasz ma limit liczby elementów i pamięci:

// memory-optimized-cache.service.ts
import { Injectable } from '@nestjs/common';
import { Cron } from '@nestjs/schedule';

@Injectable()
export class MemoryOptimizedCacheService {
  private cache = new Map<string, {
    data: any;
    timestamp: number;
    accessCount: number;
    lastAccess: number;
    size: number;
    timer: NodeJS.Timeout;
  }>();

  private maxSize = 1000; // Maksymalna liczba elementów
  private maxMemoryMB = 100; // Maksymalna pamięć cache'a
  private currentMemoryBytes = 0;

  set(key: string, value: any, ttl: number = 300000): void {
    const size = this.estimateSize(value);

    // Usuń stary element jeśli istnieje - razem z jego timerem
    this.delete(key);

    // Zwalniaj miejsce, dopóki nowy element się nie zmieści
    while (this.cache.size > 0 && (this.cache.size >= this.maxSize ||
      (this.currentMemoryBytes + size) > this.maxMemoryMB * 1024 * 1024)) {
      this.evictOldest();
    }

    // Ustaw TTL; unref() nie trzyma procesu przy życiu
    const timer = setTimeout(() => this.delete(key), ttl);
    timer.unref();

    this.cache.set(key, {
      data: value,
      timestamp: Date.now(),
      accessCount: 0,
      lastAccess: Date.now(),
      size,
      timer,
    });

    this.currentMemoryBytes += size;
  }

  get(key: string): any {
    const item = this.cache.get(key);
    if (!item) return null;

    // Aktualizuj statystyki dostępu
    item.accessCount++;
    item.lastAccess = Date.now();

    return item.data;
  }

  delete(key: string): boolean {
    const item = this.cache.get(key);
    if (item) {
      clearTimeout(item.timer);
      this.currentMemoryBytes -= item.size;
      return this.cache.delete(key);
    }
    return false;
  }

To wersja poprawiona. Pierwsza tworzyła nowy timer przy każdym set(), nie kasując starego - stary odpalał później i usuwał świeżą wartość. delete() czyści teraz timer, a unref() sprawia, że czekający timer nie blokuje zamknięcia procesu. Pętla while zwalnia tyle miejsca, ile trzeba, a nie jeden element.

Strategię eksmisji dobiera stan pamięci:

  // Eksmisja według różnych strategii
  private evictOldest(): void {
    if (this.cache.size === 0) return;

    const strategy = this.getEvictionStrategy();

    switch (strategy) {
      case 'LRU': // Least Recently Used
        this.evictLRU();
        break;
      case 'LFU': // Least Frequently Used
        this.evictLFU();
        break;
      case 'SIZE': // Największe elementy pierwsze
        this.evictLargest();
        break;
      default:
        this.evictOldestByTime();
    }
  }

  private getEvictionStrategy(): string {
    // Inteligentny wybór strategii na podstawie stanu pamięci
    const memoryPressure = this.currentMemoryBytes / (this.maxMemoryMB * 1024 * 1024);

    if (memoryPressure > 0.9) {
      return 'SIZE'; // Pod wysokim ciśnieniem pamięci - usuń duże elementy
    } else if (this.cache.size > this.maxSize * 0.8) {
      return 'LRU'; // Dużo elementów - usuń najdawniej używane
    } else {
      return 'LFU'; // Normalnie - usuń najmniej popularne
    }
  }

Pod presją pamięci usuwamy największe elementy, przy dużej liczbie - najdawniej używane (LRU), a normalnie - najrzadziej używane (LFU).

Cztery strategie różnią się tylko kryterium:

  private evictLRU(): void {
    let oldestKey = '';
    let oldestTime = Infinity;

    this.cache.forEach((item, key) => {
      if (item.lastAccess < oldestTime) {
        oldestTime = item.lastAccess;
        oldestKey = key;
      }
    });

    if (oldestKey) {
      console.log(`LRU eviction: ${oldestKey}`);
      this.delete(oldestKey);
    }
  }

  private evictLFU(): void {
    let leastUsedKey = '';
    let leastUsedCount = Infinity;

    this.cache.forEach((item, key) => {
      if (item.accessCount < leastUsedCount) {
        leastUsedCount = item.accessCount;
        leastUsedKey = key;
      }
    });

    if (leastUsedKey) {
      console.log(`LFU eviction: ${leastUsedKey}`);
      this.delete(leastUsedKey);
    }
  }

  private evictLargest(): void {
    let largestKey = '';
    let largestSize = 0;

    this.cache.forEach((item, key) => {
      if (item.size > largestSize) {
        largestSize = item.size;
        largestKey = key;
      }
    });

    if (largestKey) {
      console.log(`SIZE eviction: ${largestKey} (${largestSize} bytes)`);
      this.delete(largestKey);
    }
  }

  private evictOldestByTime(): void {
    let oldestKey = '';
    let oldestTime = Infinity;

    this.cache.forEach((item, key) => {
      if (item.timestamp < oldestTime) {
        oldestTime = item.timestamp;
        oldestKey = key;
      }
    });

    if (oldestKey) {
      console.log(`TIME eviction: ${oldestKey}`);
      this.delete(oldestKey);
    }
  }

Poszukiwania startują od Infinity. Pierwsza wersja zaczynała od Date.now(), więc elementy dodane w tej samej milisekundzie nigdy nie były starsze i nic nie znikało: w teście cache z limitem 3 urósł do 10 elementów.

Na koniec szacowanie rozmiaru, statystyki i sprzątanie:

  private estimateSize(obj: any): number {
    // Przybliżone obliczenie rozmiaru obiektu w pamięci
    const jsonString = JSON.stringify(obj);
    return jsonString.length * 2; // UTF-16 = 2 bytes per character
  }

  getStats() {
    const memoryUsageMB = this.currentMemoryBytes / 1024 / 1024;
    const avgItemSize = this.cache.size > 0 ? this.currentMemoryBytes / this.cache.size : 0;

    let totalAccesses = 0;
    this.cache.forEach(item => {
      totalAccesses += item.accessCount;
    });

    return {
      size: this.cache.size,
      maxSize: this.maxSize,
      memoryUsageMB: memoryUsageMB.toFixed(2),
      maxMemoryMB: this.maxMemoryMB,
      avgItemSize: Math.round(avgItemSize),
      totalAccesses,
      fillRatio: (this.cache.size / this.maxSize * 100).toFixed(1) + '%',
      memoryRatio: (memoryUsageMB / this.maxMemoryMB * 100).toFixed(1) + '%',
    };
  }

  // Czyszczenie przeterminowanych elementów
  @Cron('0 */5 * * * *') // Co 5 minut (pierwsze pole to sekundy)
  cleanupExpired(): void {
    const now = Date.now();
    const toDelete = [];

    this.cache.forEach((item, key) => {
      // Usuń elementy starsze niż godzina bez dostępu
      if (now - item.lastAccess > 3600000) {
        toDelete.push(key);
      }
    });

    toDelete.forEach(key => {
      this.delete(key);
    });

    if (toDelete.length > 0) {
      console.log(`Wyczyszczono ${toDelete.length} przestarzałych elementów cache'a`);
    }
  }
}

JSON.stringify daje tylko zgrubny rozmiar, bo obiekt w pamięci zajmuje inaczej niż jego tekst. Wzorzec 0 */5 * * * * znaczy co 5 minut; stary */5 * * * * * odpalał się co 5 sekund, bo pierwsze pole to sekundy.

Polecam Ci gotową bibliotekę lru-cache albo prosty trik z edytora obok: Map pamięta kolejność wstawiania, więc najstarszy wpis usuniesz w stałym czasie. Własny cache pisz tylko po to, żeby zrozumieć mechanizm. W następnej lekcji ograniczymy ruch, zanim zaleje magazyny.

Pamiętaj: w dobrze prowadzonym magazynie każdy tribut ma datę przydatności i miejsce na półce, a nie leży zapomniany w kącie.

Kod do tej lekcji: src/memory-management.ts
// Memory Management - Optymalizacja Magazynow Kohorty
import { Injectable, Logger } from '@nestjs/common';

// 1. Monitoring pamieci
@Injectable()
export class MemoryMonitor {
  private readonly logger = new Logger('MemoryMonitor');

  getMemoryUsage() {
    const usage = process.memoryUsage();
    return {
      rss: Math.round(usage.rss / 1024 / 1024),          // MB
      heapTotal: Math.round(usage.heapTotal / 1024 / 1024),
      heapUsed: Math.round(usage.heapUsed / 1024 / 1024),
      external: Math.round(usage.external / 1024 / 1024),
      heapPercent: Math.round(
        (usage.heapUsed / usage.heapTotal) * 100
      ),
    };
  }

  // Sprawdz czy pamiec jest w normie
  checkHealth(thresholdMB: number = 512): {
    healthy: boolean;
    message: string;
  } {
    const mem = this.getMemoryUsage();
    const healthy = mem.heapUsed < thresholdMB;

    return {
      healthy,
      message: healthy
        ? `Memory OK: ${mem.heapUsed}MB / ${thresholdMB}MB`
        : `WARNING: ${mem.heapUsed}MB exceeds ${thresholdMB}MB!`,
    };
  }
}

// 2. Unikanie wyciekow pamieci

// ZLE - wyciek pamieci (tablica rosnie bez konca):
// class BadService {
//   private cache: any[] = [];
//   addToCache(data: any) {
//     this.cache.push(data); // NIGDY nie czyszczone!
//   }
// }

// DOBRZE - cache z limitem:
class BoundedCache<T> {
  private items: Map<string, { data: T; addedAt: number }> = new Map();
  private maxSize: number;
  private ttlMs: number;

  constructor(maxSize = 1000, ttlMs = 300000) {
    this.maxSize = maxSize;
    this.ttlMs = ttlMs;
  }

  set(key: string, data: T) {
    // Usun najstarsze jesli za duzo
    if (this.items.size >= this.maxSize) {
      const oldest = this.items.keys().next().value;
      this.items.delete(oldest);
    }
    this.items.set(key, { data, addedAt: Date.now() });
  }

  get(key: string): T | null {
    const item = this.items.get(key);
    if (!item) return null;

    // Sprawdz TTL
    if (Date.now() - item.addedAt > this.ttlMs) {
      this.items.delete(key);
      return null;
    }
    return item.data;
  }

  get size() { return this.items.size; }
}

// 3. Garbage Collector
// Node.js automatycznie zarzadza pamiecia (GC)
// Ale mozesz wymuszic: global.gc() (z flaga --expose-gc)

// 4. Streams zamiast ladowania calych plikow do pamieci
// ZLE:  const data = fs.readFileSync('huge-file.csv');
// DOBRZE: const stream = fs.createReadStream('huge-file.csv');

// 5. WeakMap dla tymczasowych danych
// const cache = new WeakMap();
// Obiekty w WeakMap moga byc garbage collected!

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. Event loop blocking w Node.js powoduje:

  2. 2. Worker threads w Node.js najlepiej używać do:

To 2 z 4 pytań do tej lekcji. Pozostałe rozwiążesz w grze.

Zadania praktyczne w grze

  • Edytor kodu

    Napisz serwis monitorujący opóźnienia event loop i logujący ostrzeżenia

  • Układanie w pionie

    Uporządkuj fazy event loop Node.js:

  • Klikanie w kolejności

    Ułóż techniki unikania blokowania event loop od najprostszej:

  • Edytor kodu

    Napisz serwis zbierający metryki pamięci (heapUsed, rss, external)

  • Układanie w pionie

    Uporządkuj kroki diagnostyki memory leak:

  • Układanie w pionie

    Ułóż warstwy cache'owania od najbliższej użytkownikowi:

  1. PytanieEvent loop blocking
  2. PytanieWorker threads w Node.js
  3. Zadanie z kodemPraktyka: Monitoring event loop
  4. Ułóż w kolejnościFazy event loop Node.js
  5. Kliknij w kolejnościTechniki unikania blokowania
  6. PytanieHeap dump analysis
  7. PytanieWykrywanie memory leaks
  8. Zadanie z kodemPraktyka: Memory monitoring
  9. Ułóż w kolejnościProces debugowania memory leak
  10. Ułóż w kolejnościWarstwy cache'owania

Przydatne artykuły