Kurs JavaScript i React · Moduł 16: Obsługa błędów i Suspense
Logowanie i monitoring błędów
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 siecioweSentry 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 ./buildSource 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. Dlaczego console.error jest niewystarczające do monitorowania błędów na produkcji?
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: