Kurs JavaScript i React · Moduł 16: Obsługa błędów i Suspense

Logowanie i monitoring błędów

5 min czytania ·
W tej lekcji5

Na statku kosmicznym każda awaria jest rejestrowana w czarnej skrzynce. Bez niej załoga nie mogłaby analizować przyczyn problemów po fakcie. W aplikacjach React mamy dokładnie ten sam problem -- jeśli błąd wystąpi u użytkownika na produkcji, a my go nie zalogujemy, nigdy się o nim nie dowiemy. Logowanie i monitoring błędów to Twoja czarna skrzynka produkcyjna.

Strategie logowania błędów

W środowisku produkcyjnym potrzebujemy kilku warstw logowania:

1. console.error -- tylko do developmentu

console.error jest przydatny podczas pracy lokalnej, ale na produkcji użytkownik go nie widzi, a Ty nie masz do niego dostępu.

// Dobre do developmentu, bezużyteczne na produkcji
componentDidCatch(error, errorInfo) {
  console.error('Error caught:', error);
  console.error('Component stack:', errorInfo.componentStack);
}

2. Logowanie do zewnętrznego serwisu

Na produkcji błędy muszą być wysyłane do serwisu monitorującego:

class ErrorBoundary extends React.Component {
  componentDidCatch(error, errorInfo) {
    // Wysłanie do serwisu monitorującego
    logErrorToService({
      message: error.message,
      stack: error.stack,
      componentStack: errorInfo.componentStack,
      timestamp: new Date().toISOString(),
      url: window.location.href,
      userAgent: navigator.userAgent,
    });
  }

  // ...render z fallback
}

async function logErrorToService(errorData) {
  try {
    await fetch('/api/errors', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(errorData),
    });
  } catch (e) {
    // Fallback -- nie blokuj aplikacji jeśli logowanie się nie powiedzie
    console.error('Failed to log error:', e);
  }
}

Sentry i serwisy error tracking

Sentry to najpopularniejszy serwis do monitorowania błędów w aplikacjach JavaScript i React. Inne popularne narzędzia to LogRocket, Bugsnag, Datadog i New Relic.

Podstawowa integracja z Sentry

import * as Sentry from '@sentry/react';

// Inicjalizacja w main/index.js
Sentry.init({
  dsn: 'https://klucz@sentry.io/projekt',
  environment: 'production',
  // Procent sesji do rejestrowania (performance)
  tracesSampleRate: 0.2,
});

// Sentry automatycznie przechwytuje:
// - Nieobsłużone wyjątki (uncaught exceptions)
// - Nieobsłużone rejection Promise
// - Błędy sieciowe

Sentry z Error Boundary

import * as Sentry from '@sentry/react';

// Sentry dostarcza gotowy Error Boundary
function App() {
  return (
    <Sentry.ErrorBoundary
      fallback={({ error }) => (
        <div className="error-page">
          <h2>Coś poszło nie tak</h2>
          <p>Błąd został automatycznie zgłoszony</p>
          <button onClick={() => window.location.reload()}>
            Odśwież stronę
          </button>
        </div>
      )}
    >
      <SpaceStation />
    </Sentry.ErrorBoundary>
  );
}

Kontekst i breadcrumbs w Sentry

Sentry pozwala dodawać kontekst do błędów -- informacje o użytkowniku, ostatnich akcjach (breadcrumbs) i dodatkowe dane:

// Ustawienie kontekstu użytkownika
Sentry.setUser({
  id: user.id,
  email: user.email,
  username: user.callsign,
});

// Ręczne dodawanie breadcrumbs (ślad akcji użytkownika)
Sentry.addBreadcrumb({
  category: 'navigation',
  message: 'Użytkownik przeszedł do panelu misji',
  level: 'info',
});

// Ręczne raportowanie błędu z dodatkowym kontekstem
Sentry.captureException(error, {
  extra: {
    missionId: currentMission.id,
    moduleState: moduleStatus,
  },
});

Customowy hook do logowania błędów

Możesz stworzyć własny hook, który centralizuje logikę logowania:

function useErrorLogger() {
  const logError = useCallback((error, context = {}) => {
    const errorReport = {
      message: error.message,
      stack: error.stack,
      timestamp: new Date().toISOString(),
      url: window.location.href,
      ...context,
    };

    // W produkcji wyślij do serwisu
    if (process.env.NODE_ENV === 'production') {
      sendToErrorService(errorReport);
    }

    // W development loguj do konsoli
    console.error('[ErrorLogger]', errorReport);
  }, []);

  return { logError };
}

// Użycie w komponencie
function MissionControl() {
  const { logError } = useErrorLogger();

  const handleDataFetch = async () => {
    try {
      const data = await fetchMissionData();
      setMissions(data);
    } catch (error) {
      logError(error, {
        component: 'MissionControl',
        action: 'fetchMissionData',
      });
      setError('Nie udało się pobrać danych misji');
    }
  };
}

Raportowanie błędów na produkcji

Global error handlers

Oprócz Error Boundaries i try-catch, warto dodać globalne handlery, które przechwycą błędy wymykające się innym mechanizmom:

// Globalne przechwytywanie nieprzechwyconych błędów
window.addEventListener('error', (event) => {
  logErrorToService({
    type: 'uncaught_error',
    message: event.message,
    filename: event.filename,
    lineno: event.lineno,
    colno: event.colno,
  });
});

// Globalne przechwytywanie nieobsłużonych Promise rejections
window.addEventListener('unhandledrejection', (event) => {
  logErrorToService({
    type: 'unhandled_rejection',
    message: event.reason?.message || 'Unknown rejection',
    stack: event.reason?.stack,
  });
});

Poziomy ważności błędów

Nie wszystkie błędy są równie ważne. Serwisy error tracking pozwalają na klasyfikację:

// Krytyczny błąd - aplikacja nie działa
Sentry.captureException(error, { level: 'fatal' });

// Błąd - funkcjonalność nie działa, ale aplikacja tak
Sentry.captureException(error, { level: 'error' });

// Ostrzeżenie - coś może być nie tak
Sentry.captureMessage('API odpowiada wolno', 'warning');

// Informacja - przydatna do debugowania
Sentry.captureMessage('Użytkownik zmienił język', 'info');

Source maps dla debugowania produkcji

Kod produkcyjny jest zminifikowany -- stack trace jest nieczytelny bez source maps. Source maps to jak mapa dekodująca -- pozwalają przetłumaczyć pozycje w zminifikowanym kodzie na oryginalne pliki źródłowe.

// Bez source maps stack trace wygląda tak:
// Error at e.render (main.a1b2c3.js:1:45678)

// Z source maps:
// Error at MissionControl.render (MissionControl.jsx:42:15)

Konfiguracja source maps

// webpack.config.js
module.exports = {
  devtool: 'source-map', // Generuj source maps
  // ...
};

// Ważne: source maps NIE powinny być publiczne!
// Uploaduj je do Sentry, ale nie serwuj użytkownikom:
// sentry-cli sourcemaps upload ./build

Source maps pozwalają Ci zobaczyć dokładnie w której linii oryginalnego kodu wystąpił błąd, nawet jeśli produkcyjny bundle jest zminifikowany do jednej linii. To jak posiadanie schematu technicznego statku kosmicznego -- zamiast patrzeć na niezrozumiały zminifikowany panel, widzisz dokładnie który moduł zawiódł i dlaczego. Pamiętaj jednak, żeby nigdy nie udostępniać source maps publicznie -- to byłby jak udostępnienie planów statku potencjalnym najeźdźcom.

Kod do tej lekcji: App.jsx
import React, { useState, useCallback, useEffect } from 'react';
import './styles.css';

// Customowy hook do logowania bledow
function useErrorLogger() {
  const [errorLog, setErrorLog] = useState([]);

  const logError = useCallback((error, context = {}) => {
    const report = {
      id: Date.now(),
      message: error.message || String(error),
      stack: error.stack ? error.stack.split('\n').slice(0, 3).join('\n') : 'brak',
      timestamp: new Date().toLocaleTimeString(),
      url: window.location.href,
      ...context,
    };

    setErrorLog(prev => [report, ...prev].slice(0, 10));

    // W produkcji wyslalibysmy do serwisu:
    // sendToSentry(report);
    console.error('[ErrorLogger]', report);
  }, []);

  return { logError, errorLog };
}

// Error Boundary z logowaniem
class LoggingErrorBoundary extends React.Component {
  constructor(props) {
    super(props);
    this.state = { hasError: false, error: null };
  }

  static getDerivedStateFromError(error) {
    return { hasError: true, error };
  }

  componentDidCatch(error, errorInfo) {
    // Logowanie do "serwisu"
    if (this.props.onError) {
      this.props.onError(error, {
        component: this.props.label || 'Unknown',
        type: 'render_error',
        componentStack: errorInfo.componentStack,
      });
    }
  }

  render() {
    if (this.state.hasError) {
      return (
        <div className="error-card">
          <strong>{this.props.label}: Awaria</strong>
          <p>{this.state.error?.message}</p>
          <button onClick={() => this.setState({ hasError: false })}>
            Retry
          </button>
        </div>
      );
    }
    return this.props.children;
  }
}

// Modul ktory moze rzucic blad
function UnstableModule({ name, failRate = 0.3 }) {
  if (Math.random() < failRate) {
    throw new Error(name + ': krytyczna awaria systemu!');
  }
  return (
    <div className="module-ok">
      <span className="dot green" /> {name}: Online
    </div>
  );
}

// Komponent z async bledem
function DataPanel({ logError }) {
  const [data, setData] = useState(null);
  const [loading, setLoading] = useState(false);

  const fetchData = async () => {
    setLoading(true);
    try {
      await new Promise(r => setTimeout(r, 800));
      if (Math.random() > 0.5) {
        throw new Error('Timeout polaczenia z baza danych');
      }
      setData({ missions: 42, crew: 7, fuel: '87%' });
    } catch (error) {
      logError(error, {
        component: 'DataPanel',
        action: 'fetchData',
        type: 'async_error',
      });
      setData(null);
    } finally {
      setLoading(false);
    }
  };

  return (
    <div className="data-panel">
      <h3>Dane stacji</h3>
      <button onClick={fetchData} className="fetch-btn">
        {loading ? 'Ladowanie...' : 'Pobierz dane'}
      </button>
      {data && (
        <ul>
          <li>Misje: {data.missions}</li>
          <li>Zaloga: {data.crew}</li>
          <li>Paliwo: {data.fuel}</li>
        </ul>
      )}
    </div>
  );
}

export default function App() {
  const { logError, errorLog } = useErrorLogger();
  const [key, setKey] = useState(0);

  // Globalny handler (symulacja)
  useEffect(() => {
    const handler = (event) => {
      logError(new Error(event.reason?.message || 'Unhandled rejection'), {
        type: 'unhandled_rejection',
      });
    };
    window.addEventListener('unhandledrejection', handler);
    return () => window.removeEventListener('unhandledrejection', handler);
  }, [logError]);

  return (
    <div className="app">
      <h1>Error Logging & Monitoring</h1>
      <p className="subtitle">
        Kazdy blad jest rejestrowany w logu (czarnej skrzynce)
      </p>
      <button onClick={() => setKey(k => k + 1)} className="reset-btn">
        Reset modulow
      </button>

      <div className="modules" key={key}>
        <LoggingErrorBoundary label="Nawigacja" onError={logError}>
          <UnstableModule name="Nawigacja" />
        </LoggingErrorBoundary>

        <LoggingErrorBoundary label="Komunikacja" onError={logError}>
          <UnstableModule name="Komunikacja" />
        </LoggingErrorBoundary>

        <DataPanel logError={logError} />
      </div>

      <div className="log-panel">
        <h3>Log bledow ({errorLog.length})</h3>
        {errorLog.length === 0 ? (
          <p className="empty-log">Brak zarejestrowanych bledow</p>
        ) : (
          errorLog.map(entry => (
            <div key={entry.id} className="log-entry">
              <span className="log-time">{entry.timestamp}</span>
              <span className="log-type">[{entry.type || 'error'}]</span>
              <span className="log-msg">{entry.message}</span>
              {entry.component && (
                <span className="log-comp">({entry.component})</span>
              )}
            </div>
          ))
        )}
      </div>
    </div>
  );
}

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. Dlaczego console.error jest niewystarczające do monitorowania błędów na produkcji?

  2. 2. W jaki sposób Sentry integruje się z Error Boundaries w React?

Zadania praktyczne w grze

  • Układanie w pionie

    Uporządkuj poziomy ważności błędów od najwyższego do najniższego:

  • Edytor kodu

    Zaimplementuj hook useErrorLogger

  • Klikanie w kolejności

    Kliknij elementy w kolejności budowania logowania w componentDidCatch:

  • Układanie w poziomie

    Ułóż poprawną składnię globalnego handlera Promise rejection:

  1. Pytanieconsole.error na produkcji
  2. Ułóż w kolejnościPoziomy ważności błędów
  3. Zadanie z kodemPraktyka: Customowy hook useErrorLogger
  4. PytanieSentry i Error Boundary
  5. Kliknij w kolejnościLogowanie błędu w componentDidCatch
  6. Ułóż w kolejnościGlobalny handler unhandledrejection

Przydatne artykuły