Kurs JavaScript i TypeScript · Moduł 5: Zaawansowany JavaScript

Projekt końcowy: System diagnostyki Parku Jurajskiego

9 min czytania ·
W tej lekcji4

Dotarłeś do końcowego projektu tego modułu! Przez ostatnie lekcje poznałeś narzędzia, które są fundamentem profesjonalnego programowania: modularyzację kodu, techniki debugowania, profilowanie wydajności oraz zaawansowaną obsługę błędów. Teraz nadszedł czas, aby wszystkie te umiejętności połączyć w jeden kompleksowy system.

Wyobraź sobie, że po serii incydentów w Parku Jurajskim - awariach ogrodzeń, przeciążeniach systemów zasilania i niewyjaśnionych błędach w oprogramowaniu sterującym - zarząd parku postanowił stworzyć zaawansowany system diagnostyczny. System ten ma wykrywać problemy zanim staną się katastrofalne, logować wszystkie zdarzenia, a w przypadku awarii - dostarczać szczegółowe raporty, które pomogą inżynierom szybko zlokalizować i naprawić usterki. Twoje zadanie: zaprojektować i zaimplementować ten system od podstaw.

W tym projekcie zbudujesz modularny system diagnostyczny z własnymi typami błędów, zaawansowaną obsługą wyjątków, systemem logowania i narzędziami do analizy wydajności.

Cel projektu

Stworzysz system diagnostyki Parku Jurajskiego składający się z czterech kluczowych modułów:

  1. Moduł błędów - własna hierarchia typów błędów dla systemów parku
  2. Moduł logowania - zaawansowany logger z poziomami i kontekstem
  3. Moduł diagnostyczny - skanowanie i testowanie podsystemów parku
  4. Moduł raportowania - generowanie szczegółowych raportów diagnostycznych

Wymagania funkcjonalne

1. Hierarchia błędów parku (Własne typy błędów)

Pierwszym krokiem jest stworzenie dedykowanej hierarchii błędów, która pozwoli precyzyjnie identyfikować rodzaj i źródło każdego problemu w parku.

// Bazowy błąd parku
class ParkError extends Error {
  constructor(message, code, sector, severity) {
    super(message);
    this.name = "ParkError";
    this.code = code;
    this.sector = sector;
    this.severity = severity; // "low", "medium", "high", "critical"
    this.timestamp = new Date().toISOString();
    this.resolved = false;
  }

  resolve() {
    this.resolved = true;
    this.resolvedAt = new Date().toISOString();
  }

  toReport() {
    return {
      type: this.name,
      message: this.message,
      code: this.code,
      sector: this.sector,
      severity: this.severity,
      timestamp: this.timestamp,
      resolved: this.resolved
    };
  }
}

// Błąd ogrodzenia - krytyczny dla bezpieczeństwa
class FenceError extends ParkError {
  constructor(sector, fenceId, integrityLevel) {
    const severity = integrityLevel < 50 ? "critical" : "high";
    super(
      `Ogrodzenie ${fenceId} w sektorze ${sector}: integralność ${integrityLevel}%`,
      "FENCE_INTEGRITY",
      sector,
      severity
    );
    this.name = "FenceError";
    this.fenceId = fenceId;
    this.integrityLevel = integrityLevel;
  }
}

// Błąd zasilania
class PowerError extends ParkError {
  constructor(sector, powerLevel, isBackupActive) {
    const severity = !isBackupActive && powerLevel < 20 ? "critical" : "medium";
    super(
      `Zasilanie w sektorze ${sector}: ${powerLevel}% - backup: ${isBackupActive ? "aktywny" : "nieaktywny"}`,
      "POWER_FAILURE",
      sector,
      severity
    );
    this.name = "PowerError";
    this.powerLevel = powerLevel;
    this.isBackupActive = isBackupActive;
  }
}

// Błąd czujników
class SensorError extends ParkError {
  constructor(sector, sensorId, errorType) {
    super(
      `Czujnik ${sensorId} w sektorze ${sector}: ${errorType}`,
      "SENSOR_MALFUNCTION",
      sector,
      "medium"
    );
    this.name = "SensorError";
    this.sensorId = sensorId;
    this.errorType = errorType;
  }
}

// Błąd bezpieczeństwa - zawsze krytyczny
class SecurityBreachError extends ParkError {
  constructor(sector, breachType, speciesInvolved) {
    super(
      `NARUSZENIE BEZPIECZEŃSTWA w ${sector}: ${breachType} - gatunek: ${speciesInvolved}`,
      "SECURITY_BREACH",
      sector,
      "critical"
    );
    this.name = "SecurityBreachError";
    this.breachType = breachType;
    this.speciesInvolved = speciesInvolved;
  }
}

Każdy typ błędu niesie dodatkowe informacje kontekstowe, co ułatwia diagnostykę i naprawę problemu.

2. System logowania (Logger z poziomami)

Drugi moduł to profesjonalny system logowania, który rejestruje wszystkie zdarzenia z odpowiednim poziomem ważności i kontekstem.

// Poziomy logowania
const LogLevel = {
  DEBUG: 0,
  INFO: 1,
  WARN: 2,
  ERROR: 3,
  FATAL: 4
};

const LogLevelNames = ["DEBUG", "INFO", "WARN", "ERROR", "FATAL"];

class ParkLogger {
  constructor(moduleName, minLevel = LogLevel.DEBUG) {
    this.moduleName = moduleName;
    this.minLevel = minLevel;
    this.logs = [];
    this.maxLogs = 1000; // Limit przechowywanych logów
  }

  _log(level, message, context = {}) {
    if (level < this.minLevel) return;

    const entry = {
      timestamp: new Date().toISOString(),
      level: LogLevelNames[level],
      module: this.moduleName,
      message,
      context
    };

    this.logs.push(entry);

    // Rotacja logów - usuwanie najstarszych
    if (this.logs.length > this.maxLogs) {
      this.logs = this.logs.slice(-this.maxLogs);
    }

    // Formatowanie wyjścia
    const prefix = `[${entry.timestamp}] [${entry.level}] [${this.moduleName}]`;
    const contextStr = Object.keys(context).length > 0
      ? ` | ${JSON.stringify(context)}`
      : "";

    switch (level) {
      case LogLevel.DEBUG: console.log(`${prefix} ${message}${contextStr}`); break;
      case LogLevel.INFO:  console.info(`${prefix} ${message}${contextStr}`); break;
      case LogLevel.WARN:  console.warn(`${prefix} ${message}${contextStr}`); break;
      case LogLevel.ERROR: console.error(`${prefix} ${message}${contextStr}`); break;
      case LogLevel.FATAL: console.error(`${prefix} ${message}${contextStr}`); break;
    }

    return entry;
  }

  debug(message, context) { return this._log(LogLevel.DEBUG, message, context); }
  info(message, context)  { return this._log(LogLevel.INFO, message, context); }
  warn(message, context)  { return this._log(LogLevel.WARN, message, context); }
  error(message, context) { return this._log(LogLevel.ERROR, message, context); }
  fatal(message, context) { return this._log(LogLevel.FATAL, message, context); }

  // Filtrowanie logów po poziomie
  getLogsByLevel(level) {
    const levelName = LogLevelNames[level];
    return this.logs.filter(log => log.level === levelName);
  }

  // Statystyki logów
  getStats() {
    const stats = { total: this.logs.length };
    LogLevelNames.forEach(name => {
      stats[name] = this.logs.filter(l => l.level === name).length;
    });
    return stats;
  }
}

Logger pozwala na filtrowanie po poziomie, przechowuje historię zdarzeń i automatycznie rotuje stare logi.

3. Moduł diagnostyczny (Skanowanie i try/catch/finally)

Trzeci moduł to serce systemu - skanuje poszczególne podsystemy parku, przechwytuje i klasyfikuje błędy, a następnie podejmuje odpowiednie działania naprawcze.

class ParkDiagnostics {
  constructor() {
    this.logger = new ParkLogger("Diagnostyka", LogLevel.DEBUG);
    this.errors = [];
    this.scanResults = [];
  }

  // Symulacja skanowania ogrodzenia
  scanFence(sector, fenceId) {
    this.logger.info(`Skanowanie ogrodzenia ${fenceId} w sektorze ${sector}`);

    try {
      const integrity = Math.round(40 + Math.random() * 60);

      if (integrity < 80) {
        throw new FenceError(sector, fenceId, integrity);
      }

      this.logger.debug(`Ogrodzenie ${fenceId} OK: ${integrity}%`, { sector, fenceId });
      return { status: "OK", integrity };

    } catch (error) {
      if (error instanceof FenceError) {
        this.errors.push(error);
        this.logger.error(error.message, error.toReport());

        if (error.severity === "critical") {
          this.logger.fatal(`KRYTYCZNA awaria ogrodzenia! Ewakuacja sektora ${sector}!`);
          this._initiateEmergencyProtocol(sector);
        }
      } else {
        // Nieoczekiwany błąd - loguj i rzuć dalej
        this.logger.fatal(`Nieoczekiwany błąd podczas skanowania: ${error.message}`);
        throw error;
      }

      return { status: "AWARIA", error: error.toReport() };

    } finally {
      this.logger.debug(`Zakończono skanowanie ogrodzenia ${fenceId}`);
    }
  }

  // Skanowanie zasilania z zagnieżdżonym try/catch
  scanPower(sector) {
    this.logger.info(`Skanowanie zasilania w sektorze ${sector}`);

    try {
      const mainPower = Math.round(Math.random() * 100);
      let backupStatus = false;

      try {
        // Próba sprawdzenia zasilania awaryjnego
        backupStatus = Math.random() > 0.3;
        if (!backupStatus && mainPower < 30) {
          throw new PowerError(sector, mainPower, false);
        }
      } catch (innerError) {
        if (innerError instanceof PowerError) {
          this.errors.push(innerError);
          this.logger.error(`Problem z zasilaniem: ${innerError.message}`);
        } else {
          throw innerError; // Przekaż nieznane błędy do zewnętrznego catch
        }
      }

      if (mainPower < 50) {
        throw new PowerError(sector, mainPower, backupStatus);
      }

      return { status: "OK", mainPower, backupActive: backupStatus };

    } catch (error) {
      if (error instanceof PowerError) {
        this.errors.push(error);
        this.logger.warn(error.message, error.toReport());
        return { status: "OSTRZEŻENIE", error: error.toReport() };
      }
      throw error;
    }
  }

  // Pełna diagnostyka sektora
  runFullDiagnostics(sector) {
    this.logger.info(`=== Pełna diagnostyka sektora: ${sector} ===`);
    const startTime = performance.now();

    const result = {
      sector,
      fences: [],
      power: null,
      errors: [],
      duration: 0
    };

    try {
      // Skanowanie ogrodzeń (3 ogrodzenia per sektor)
      for (let i = 1; i <= 3; i++) {
        const fenceResult = this.scanFence(sector, `FENCE-${sector}-${i}`);
        result.fences.push(fenceResult);
      }

      // Skanowanie zasilania
      result.power = this.scanPower(sector);

    } catch (unexpectedError) {
      this.logger.fatal(`Nieoczekiwany błąd diagnostyki: ${unexpectedError.message}`);
      result.criticalFailure = true;
    } finally {
      result.duration = `${(performance.now() - startTime).toFixed(2)}ms`;
      result.errors = this.errors.filter(e => e.sector === sector).map(e => e.toReport());
      this.scanResults.push(result);
      this.logger.info(`Diagnostyka ${sector} zakończona w ${result.duration}`);
    }

    return result;
  }

  _initiateEmergencyProtocol(sector) {
    this.logger.fatal(`PROTOKÓŁ AWARYJNY dla sektora ${sector} - wysyłanie powiadomień`);
  }
}

Zwróć uwagę na zagnieżdżone bloki try/catch i zastosowanie finally do rejestrowania czasu trwania operacji niezależnie od wyniku.

4. Moduł raportowania (Agregacja i analiza danych)

Ostatni moduł zbiera dane ze wszystkich diagnostyk i generuje czytelny raport z rekomendacjami.

class DiagnosticsReporter {
  constructor(diagnostics) {
    this.diagnostics = diagnostics;
    this.logger = new ParkLogger("Raportowanie", LogLevel.INFO);
  }

  generateReport() {
    const allErrors = this.diagnostics.errors;
    const scanResults = this.diagnostics.scanResults;

    // Grupowanie błędów po typie
    const errorsByType = {};
    allErrors.forEach(error => {
      const type = error.name;
      if (!errorsByType[type]) errorsByType[type] = [];
      errorsByType[type].push(error.toReport());
    });

    // Grupowanie błędów po sektorze
    const errorsBySector = {};
    allErrors.forEach(error => {
      if (!errorsBySector[error.sector]) errorsBySector[error.sector] = [];
      errorsBySector[error.sector].push(error.toReport());
    });

    // Zliczanie po severity
    const severityCounts = { low: 0, medium: 0, high: 0, critical: 0 };
    allErrors.forEach(error => {
      severityCounts[error.severity]++;
    });

    const report = {
      generatedAt: new Date().toISOString(),
      summary: {
        totalErrors: allErrors.length,
        criticalErrors: severityCounts.critical,
        sectorsScanned: scanResults.length,
        overallStatus: severityCounts.critical > 0 ? "KRYTYCZNY" :
                       severityCounts.high > 0 ? "OSTRZEŻENIE" : "STABILNY"
      },
      errorsByType,
      errorsBySector,
      severityCounts,
      recommendations: this._generateRecommendations(allErrors, severityCounts)
    };

    this._printReport(report);
    return report;
  }

  _generateRecommendations(errors, severity) {
    const recommendations = [];

    if (severity.critical > 0) {
      recommendations.push("NATYCHMIAST: Ewakuacja sektorów z krytycznymi awariami ogrodzeń");
      recommendations.push("Wysłanie zespołów naprawczych do uszkodzonych ogrodzeń");
    }

    if (severity.high > 0) {
      recommendations.push("PILNE: Przegląd ogrodzeń z obniżoną integralnością");
    }

    const fenceErrors = errors.filter(e => e instanceof FenceError);
    if (fenceErrors.length > 3) {
      recommendations.push("Systemowy przegląd wszystkich ogrodzeń - wykryto liczne awarie");
    }

    const powerErrors = errors.filter(e => e instanceof PowerError);
    if (powerErrors.length > 0) {
      recommendations.push("Sprawdzenie generatorów awaryjnych we wszystkich sektorach");
    }

    if (recommendations.length === 0) {
      recommendations.push("Wszystkie systemy stabilne - kontynuować standardowy monitoring");
    }

    return recommendations;
  }

  _printReport(report) {
    console.log("\n" + "=".repeat(60));
    console.log("   RAPORT DIAGNOSTYCZNY PARKU JURAJSKIEGO");
    console.log("=".repeat(60));
    console.log(`Wygenerowano: ${report.generatedAt}`);
    console.log(`Status: ${report.summary.overallStatus}`);
    console.log(`Sektory przeskanowane: ${report.summary.sectorsScanned}`);
    console.log(`Wykryte błędy: ${report.summary.totalErrors} (krytycznych: ${report.summary.criticalErrors})`);

    console.log("\nBłędy wg typu:");
    Object.entries(report.errorsByType).forEach(([type, errors]) => {
      console.log(`  ${type}: ${errors.length}`);
    });

    console.log("\nRekomendacje:");
    report.recommendations.forEach((rec, i) => {
      console.log(`  ${i + 1}. ${rec}`);
    });

    console.log("=".repeat(60));
  }
}

// Uruchomienie systemu diagnostycznego
const diagnostics = new ParkDiagnostics();

const sectors = ["T-Rex-Paddock", "Raptor-Pen", "Herbivore-Valley"];
sectors.forEach(sector => diagnostics.runFullDiagnostics(sector));

const reporter = new DiagnosticsReporter(diagnostics);
reporter.generateReport();

// Statystyki loggera
console.log("\nStatystyki logów:", diagnostics.logger.getStats());

Wskazówki implementacyjne

Przy budowaniu systemu diagnostycznego pamiętaj o następujących zasadach:

Hierarchia błędów powinna odzwierciedlać domenę:

// Każdy typ błędu = jeden rodzaj problemu w parku
ParkError          // bazowy - ogólny błąd parku
├── FenceError     // ogrodzenia - bezpieczeństwo fizyczne
├── PowerError     // zasilanie - infrastruktura
├── SensorError    // czujniki - monitoring
└── SecurityBreachError  // naruszenia - najwyższy priorytet

Używaj instanceof do rozróżniania typów błędów:

try {
  riskyOperation();
} catch (error) {
  if (error instanceof SecurityBreachError) {
    // Natychmiastowa reakcja
  } else if (error instanceof FenceError) {
    // Protokół naprawczy
  } else if (error instanceof ParkError) {
    // Ogólna obsługa błędów parku
  } else {
    // Nieznany błąd - loguj i eskaluj
    throw error;
  }
}

Zawsze używaj finally do czyszczenia zasobów:

function scanWithCleanup() {
  const connection = openConnection();
  try {
    return performScan(connection);
  } catch (error) {
    logError(error);
    return null;
  } finally {
    // Zawsze zamknij połączenie - nawet przy błędzie
    connection.close();
  }
}

Powodzenia!

Ten projekt to Twoja szansa na udowodnienie, że potrafisz budować odporne, dobrze zorganizowane systemy. W Parku Jurajskim nie ma miejsca na nieobsłużone wyjątki - każdy błąd musi być przechwycony, zalogowany i obsłużony, zanim sytuacja wymknie się spod kontroli. Jak mówił John Hammond: "Nie szczędziliśmy kosztów!" - a Ty nie szczędź wysiłku przy obsłudze błędów.

Stwórz swój system diagnostyczny w edytorze poniżej. Zaimplementuj własne typy błędów, system logowania i mechanizm diagnostyki przynajmniej dwóch podsystemów parku.

Kod do tej lekcji: index.js
// Projekt koncowy: System diagnostyki Parku Jurajskiego
// Polacz: moduly, obsluge bledow, try/catch, wlasne bledy

// === 1. HIERARCHIA BLEDOW ===
// TODO: Stworz klase ParkError rozszerzajaca Error
class ParkError extends Error {
  constructor(message, code, sector, severity) {
    super(message);
    this.name = "ParkError";
    // TODO: Przypisz code, sector, severity, timestamp
  }

  // TODO: Metoda toReport() zwracajaca obiekt raportu
}

// TODO: Stworz klasy pochodne: FenceError, PowerError, SystemError
class FenceError extends ParkError {
  constructor(message, sector, fenceId) {
    // TODO: Wywolaj super z odpowiednimi parametrami
  }
}

// === 2. SYSTEM LOGOWANIA ===
// TODO: Stworz obiekt Logger z poziomami: debug, info, warn, error
const Logger = {
  logs: [],
  // TODO: Metody log(level, message, context)
  // TODO: Metoda getLogsByLevel(level)
  // TODO: Metoda exportLogs()
};

// === 3. MODUL DIAGNOSTYCZNY ===
// TODO: Stworz funkcje diagnostyczne uzywajace try/catch/finally
function scanSubsystem(subsystemName) {
  // TODO: Symuluj skanowanie podsystemu
  // TODO: Uzyj try/catch do przechwycenia bledow
  // TODO: Uzyj finally do logowania zakonczenia skanu
}

// === 4. GENERATOR RAPORTOW ===
// TODO: Stworz funkcje generateDiagnosticReport()
// Zbierz dane ze wszystkich podsystemow
// Obsluz bledy kazdego podsystemu osobno

function generateDiagnosticReport() {
  console.log("=== RAPORT DIAGNOSTYCZNY ===");
  const subsystems = ["Ogrodzenia", "Zasilanie", "Monitoring", "Komunikacja"];
  // TODO: Przeskanuj kazdy podsystem z obsluga bledow
  console.log("=== KONIEC RAPORTU ===");
}

// Uruchom diagnostyke:
generateDiagnosticReport();

Hasła z dokumentacji w tej lekcji

Widzisz błąd w tej lekcji?

  1. Projekt do wysłaniaPrzejście do stacji badawczej
  2. WideoVideo: Podsumowanie modułu

Przydatne artykuły