Kurs Next.js · Moduł 8: Deployment i produkcja
Monitoring wydajności i analityka błędów
W tej lekcji12
W produkcyjnych aplikacjach Next.js, monitoring wydajności i śledzenie błędów są kluczowe dla utrzymania wysokiej jakości dostarczanych usług. W tym module poznamy narzędzia i techniki, które pozwolą skutecznie monitorować aplikację, wykrywać problemy przed użytkownikami i optymalizować wydajność na bieżąco.
Znaczenie monitoringu w aplikacjach produkcyjnych
Monitoring to proces ciągłego obserwowania aplikacji w celu:
- Wczesnego wykrywania problemów - zanim dotkną użytkowników
- Śledzenia wydajności - czasy ładowania, Core Web Vitals, przepustowość
- Analizy zachowań użytkowników - jak użytkownicy korzystają z aplikacji
- Identyfikacji waskóch gardeł - miejsca wymagające optymalizacji
- Zapewnienia SLA - spełniania uzgodnionych poziomów usług
Typy monitoringu
1. Monitoring wydajności (Performance Monitoring)
- Core Web Vitals (LCP, INP, CLS)
- Czasy ładowania stron
- Czasy odpowiedzi API
- Zużycie zasobów (CPU, pamięć)
2. Monitoring błędów (Error Monitoring)
- JavaScript errors
- API errors
- Network errors
- Stack traces
3. Monitoring infrastruktury
- Dostępność serwerów
- Zużycie zasobów
- Metryki sieciowe
4. User Experience Monitoring (UX)
- Real User Monitoring (RUM)
- Session recordings
- Heat maps
- User flows
Integracja z Sentry dla monitoring błędów
Sentry to jedno z najpopularniejszych narzędzi do monitoringu błędów w aplikacjach JavaScript i Next.js.
1. Instalacja i konfiguracja Sentry
npm install @sentry/nextjs
# lub
yarn add @sentry/nextjsUtwórz pliki konfiguracyjne:
// sentry.client.config.js
import * as Sentry from '@sentry/nextjs';
Sentry.init({
dsn: process.env.NEXT_PUBLIC_SENTRY_DSN,
// Ustawienia środowiska
environment: process.env.NODE_ENV,
// Sample rate dla transakcji wydajnościowych
tracesSampleRate: 1.0,
// Włącz Replay dla sesji użytkowników
replaysSessionSampleRate: 0.1, // 10% sesji
replaysOnErrorSampleRate: 1.0, // 100% sesji z błędami
// Integracje
integrations: [
new Sentry.Replay({
maskAllText: false,
blockAllMedia: false,
}),
],
// Filtrowanie błędów
beforeSend(event) {
// Ignoruj pewne typy błędów
if (event.exception) {
const error = event.exception.values[0];
if (error.type === 'ChunkLoadError') {
return null; // Ignoruj błędy ładowania chunków
}
}
return event;
},
});// sentry.server.config.js
import * as Sentry from '@sentry/nextjs';
Sentry.init({
dsn: process.env.NEXT_PUBLIC_SENTRY_DSN,
environment: process.env.NODE_ENV,
tracesSampleRate: 1.0,
// Dodatkowe opcje dla serwera
debug: false,
// Integracje specyficzne dla Node.js
integrations: [
new Sentry.Integrations.Http({ tracing: true }),
],
});// sentry.edge.config.js
import * as Sentry from '@sentry/nextjs';
Sentry.init({
dsn: process.env.NEXT_PUBLIC_SENTRY_DSN,
environment: process.env.NODE_ENV,
tracesSampleRate: 1.0,
debug: false,
});2. Konfiguracja Next.js dla Sentry
// next.config.js
const { withSentryConfig } = require('@sentry/nextjs');
const nextConfig = {
// Twoja standardowa konfiguracja Next.js
};
const sentryWebpackPluginOptions = {
// Dodatkowe opcje konfiguracyjne dla Sentry webpack plugin
silent: true, // Wycisz logi Sentry podczas budowania
org: process.env.SENTRY_ORG,
project: process.env.SENTRY_PROJECT,
};
module.exports = withSentryConfig(nextConfig, sentryWebpackPluginOptions);3. Dodawanie kontekstu do błędów
// lib/sentry.ts
import * as Sentry from '@sentry/nextjs';
// Funkcja do dodawania kontekstu użytkownika
export function setUserContext(user: { id: string; email: string; name?: string }) {
Sentry.setUser({
id: user.id,
email: user.email,
username: user.name,
});
}
// Funkcja do dodawania tagów
export function addTags(tags: Record<string, string>) {
Sentry.setTags(tags);
}
// Funkcja do manualnego raportowania błędów
export function captureException(error: Error, context?: Record<string, any>) {
Sentry.withScope((scope) => {
if (context) {
scope.setContext('additional_info', context);
}
Sentry.captureException(error);
});
}
// Funkcja do śledzenia wydajności
export function startTransaction(name: string, op: string) {
return Sentry.startTransaction({ name, op });
}4. Wykorzystanie Sentry w komponentach
// components/ErrorBoundary.tsx
'use client';
import React from 'react';
import * as Sentry from '@sentry/nextjs';
interface ErrorBoundaryState {
hasError: boolean;
eventId?: string;
}
class ErrorBoundary extends React.Component<
React.PropsWithChildren<{}>,
ErrorBoundaryState
> {
constructor(props: React.PropsWithChildren<{}>) {
super(props);
this.state = { hasError: false };
}
static getDerivedStateFromError(_: Error): ErrorBoundaryState {
return { hasError: true };
}
componentDidCatch(error: Error, errorInfo: React.ErrorInfo) {
const eventId = Sentry.captureException(error, {
contexts: {
react: {
componentStack: errorInfo.componentStack,
},
},
});
this.setState({ eventId });
}
render() {
if (this.state.hasError) {
return (
<div className="error-fallback">
<h2>Ups! Coś poszło nie tak</h2>
<p>Wystąpił nieoczekiwany błąd. Nasz zespół został powiadomiony.</p>
<details style={{ whiteSpace: 'pre-wrap' }}>
ID błędu: {this.state.eventId}
</details>
<button onClick={() => window.location.reload()}>
Odśwież stronę
</button>
</div>
);
}
return this.props.children;
}
}
export default ErrorBoundary;Monitoring Core Web Vitals
Core Web Vitals to kluczowe metryki wydajności, które Google używa do oceny doświadczenia użytkownika:
- LCP (Largest Contentful Paint) - czas ładowania największego elementu
- INP (Interaction to Next Paint) - czas reakcji strony na interakcje użytkownika (od 2024 zastępuje FID)
- CLS (Cumulative Layout Shift) - niestabilność layoutu
1. Implementacja Web Vitals w Next.js
// lib/web-vitals.ts
import { onCLS, onINP, onFCP, onLCP, onTTFB } from 'web-vitals';
import * as Sentry from '@sentry/nextjs';
interface WebVitalMetric {
name: string;
value: number;
id: string;
delta: number;
}
// Funkcja do raportowania metryk
function sendToAnalytics(metric: WebVitalMetric) {
// Wyślij do Google Analytics
if (typeof window !== 'undefined' && window.gtag) {
window.gtag('event', metric.name, {
event_category: 'Web Vitals',
event_label: metric.id,
value: Math.round(metric.name === 'CLS' ? metric.value * 1000 : metric.value),
non_interaction: true,
});
}
// Wyślij do Sentry
Sentry.addBreadcrumb({
category: 'web-vital',
message: `${metric.name}: ${metric.value}`,
level: 'info',
data: {
name: metric.name,
value: metric.value,
id: metric.id,
delta: metric.delta,
},
});
// W przypadku słabych wyników, wyślij jako event do Sentry
const thresholds = {
LCP: 2500,
INP: 200,
CLS: 0.1,
};
if (metric.value > thresholds[metric.name as keyof typeof thresholds]) {
Sentry.captureMessage(`Poor ${metric.name}: ${metric.value}`, 'warning');
}
}
// Zainicjuj pomiary Web Vitals
export function initWebVitals() {
onCLS(sendToAnalytics);
onINP(sendToAnalytics);
onFCP(sendToAnalytics);
onLCP(sendToAnalytics);
onTTFB(sendToAnalytics);
}2. Komponent do monitoringu Web Vitals
// components/WebVitalsReporter.tsx
'use client';
import { useEffect } from 'react';
import { useReportWebVitals } from 'next/web-vitals';
export default function WebVitalsReporter() {
useReportWebVitals((metric) => {
// Wyślij do różnych systemów analitycznych
switch (metric.name) {
case 'FCP':
case 'LCP':
case 'CLS':
case 'INP':
case 'TTFB':
// Wyślij do własnego API
fetch('/api/analytics/web-vitals', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(metric),
}).catch(console.error);
break;
default:
break;
}
});
return null;
}3. API endpoint do zbierania metryk
// app/api/analytics/web-vitals/route.ts
import { NextRequest, NextResponse } from 'next/server';
import { prisma } from '@/lib/prisma'; // Załóżmy, że używasz Prisma
export async function POST(request: NextRequest) {
try {
const metric = await request.json();
// Walidacja podstawowa
if (!metric.name || !metric.value) {
return NextResponse.json({ error: 'Invalid metric data' }, { status: 400 });
}
// Zapisz do bazy danych
await prisma.webVitalMetric.create({
data: {
name: metric.name,
value: metric.value,
id: metric.id,
delta: metric.delta,
url: request.headers.get('referer') || '',
userAgent: request.headers.get('user-agent') || '',
timestamp: new Date(),
},
});
return NextResponse.json({ success: true });
} catch (error) {
console.error('Error saving web vital metric:', error);
return NextResponse.json({ error: 'Internal server error' }, { status: 500 });
}
}Monitoring wydajności z New Relic
New Relic oferuje kompleksowe rozwiązanie do monitoringu wydajności aplikacji Next.js.
1. Konfiguracja New Relic
npm install newrelic// newrelic.js (w root projektu)
'use strict';
exports.config = {
app_name: ['Next.js App'],
license_key: process.env.NEW_RELIC_LICENSE_KEY,
// Konfiguracja logowania
logging: {
level: 'info',
},
// Włącz distributed tracing
distributed_tracing: {
enabled: true,
},
// Monitoring browserów
browser_monitoring: {
enable: true,
},
// Konfiguracja specyficzna dla Next.js
allow_all_headers: true,
attributes: {
exclude: [
'request.headers.cookie',
'request.headers.authorization',
'request.headers.x-*',
],
},
};// next.config.js
if (process.env.NODE_ENV === 'production') {
require('./newrelic');
}
const nextConfig = {
// Twoja konfiguracja Next.js
};
module.exports = nextConfig;2. Custom instrumentation w New Relic
// lib/monitoring.ts
import newrelic from 'newrelic';
// Funkcja do śledzenia niestandardowych metryk
export function recordCustomMetric(name: string, value: number) {
if (process.env.NODE_ENV === 'production') {
newrelic.recordMetric(name, value);
}
}
// Funkcja do śledzenia eventów biznesowych
export function recordCustomEvent(eventType: string, attributes: Record<string, any>) {
if (process.env.NODE_ENV === 'production') {
newrelic.recordCustomEvent(eventType, attributes);
}
}
// Wrapper dla API calls z automatycznym śledzeniem
export async function instrumentedApiCall<T>(
name: string,
apiCall: () => Promise<T>
): Promise<T> {
const startTime = Date.now();
try {
const result = await apiCall();
// Zapisz metryki sukcesu
recordCustomMetric(`Custom/API/${name}/Duration`, Date.now() - startTime);
recordCustomEvent('APICall', {
name,
status: 'success',
duration: Date.now() - startTime,
});
return result;
} catch (error) {
// Zapisz metryki błędu
recordCustomMetric(`Custom/API/${name}/Error`, 1);
recordCustomEvent('APICall', {
name,
status: 'error',
duration: Date.now() - startTime,
error: error.message,
});
throw error;
}
}Vercel Analytics - Monitoring nowej generacji w Metropolii Quantum
W Metropolii Quantum 2150, każda interakcja użytkownika jest monitorowana przez zaawansowane systemy analityczne. Vercel Analytics to natywne rozwiązanie monitoringu dla aplikacji Next.js, zaprojektowane z myślą o prywatności użytkowników i zgodności z GDPR. W przeciwieństwie do Google Analytics, Vercel Analytics działa bezpośrednio w Vercel Edge Network, co zapewnia minimalne opóźnienia i dokładne pomiary.
Vercel Analytics vs Google Analytics
Zanim zdecydujesz się na wybór narzędzia analitycznego, warto zrozumieć kluczowe różnice:
Vercel Analytics:
- Zintegrowany z Vercel Edge Network
- Automatyczne śledzenie Core Web Vitals
- Privacy-first (bez cookies, zgodny z GDPR)
- Zerowa konfiguracja dla podstawowych metryk
- Real-time data w dashboard Vercel
- Płatny plan dla większej liczby page views
- Podstawowe funkcje segmentacji
Google Analytics 4:
- Zaawansowana segmentacja użytkowników
- Funnel analysis i conversion tracking
- Integracja z Google Ads i innymi narzędziami Google
- Darmowy plan dla większości przypadków użycia
- Wymaga zgody na cookies (GDPR compliance)
- Większy wpływ na wydajność strony
- Bardziej skomplikowana konfiguracja
Real User Monitoring (RUM) z Vercel Analytics
Real User Monitoring to technika zbierania danych o rzeczywistych doświadczeniach użytkowników, a nie syntetycznych testów. Vercel Analytics automatycznie śledzi wszystkie kluczowe metryki wydajności.
Instalacja Vercel Analytics
npm install @vercel/analytics
# lub
yarn add @vercel/analytics
# lub
pnpm add @vercel/analyticsPodstawowa konfiguracja
// app/layout.tsx
import { Analytics } from '@vercel/analytics/react';
export default function RootLayout({
children
}: {
children: React.ReactNode
}) {
return (
<html lang="pl">
<body>
{children}
<Analytics />
</body>
</html>
);
}To wszystko! Vercel Analytics automatycznie rozpocznie śledzenie:
- Page views
- Unique visitors
- Top pages
- Top referrers
- Devices i browsers
- Geographic data
Core Web Vitals Tracking
Core Web Vitals to kluczowe metryki wydajności web, które Google używa jako sygnały rankingowe. Vercel Analytics automatycznie śledzi wszystkie trzy metryki:
1. Largest Contentful Paint (LCP)
- Mierzy czas ładowania największego elementu content
- Target: < 2.5s
- Wpływa na: First impression, perceived performance
2. Interaction to Next Paint (INP)
- Mierzy responsywność na interakcje użytkownika
- INP target: < 200ms (INP zastąpiło FID w 2024)
- Wpływa na: Interaktywność, user experience
3. Cumulative Layout Shift (CLS)
- Mierzy stabilność wizualną (niespodziewane przesunięcia layoutu)
- Target: < 0.1
- Wpływa na: Visual stability, user frustration
Dostęp do Core Web Vitals w kodzie
Możesz programatically dostać się do metryk Web Vitals:
// app/web-vitals.tsx
'use client';
import { useReportWebVitals } from 'next/web-vitals';
export function WebVitals() {
useReportWebVitals((metric) => {
console.log(metric);
// Możesz wysłać metryki do własnego endpointu
if (metric.label === 'web-vital') {
fetch('/api/analytics/web-vitals', {
method: 'POST',
body: JSON.stringify(metric),
headers: {
'Content-Type': 'application/json'
}
});
}
});
return null;
}// app/layout.tsx
import { Analytics } from '@vercel/analytics/react';
import { WebVitals } from './web-vitals';
export default function RootLayout({ children }: { children: React.ReactNode }) {
return (
<html lang="pl">
<body>
{children}
<Analytics />
<WebVitals />
</body>
</html>
);
}Custom Events - śledzenie niestandardowych interakcji
Vercel Analytics pozwala śledzić custom events dla specyficznych akcji użytkowników:
'use client';
import { track } from '@vercel/analytics';
export default function NewsletterForm() {
const handleSubscribe = async (email: string) => {
try {
await subscribeToNewsletter(email);
// Śledź udaną subskrypcję
track('Newsletter Subscribe', {
email_domain: email.split('@')[1],
source: 'homepage'
});
} catch (error) {
// Śledź błąd
track('Newsletter Subscribe Error', {
error: error.message
});
}
};
return (
<form onSubmit={(e) => {
e.preventDefault();
const email = e.target.email.value;
handleSubscribe(email);
}}>
<input type="email" name="email" required />
<button type="submit">Subskrybuj</button>
</form>
);
}Zaawansowane custom events
'use client';
import { track } from '@vercel/analytics';
export default function ProductPage({ product }: { product: Product }) {
// Śledź wyświetlenie produktu
useEffect(() => {
track('Product View', {
product_id: product.id,
product_name: product.name,
product_category: product.category,
product_price: product.price
});
}, [product]);
// Śledź dodanie do koszyka
const handleAddToCart = () => {
track('Add to Cart', {
product_id: product.id,
quantity: 1,
value: product.price
});
addToCart(product);
};
// Śledź rozpoczęcie checkout
const handleCheckout = () => {
track('Begin Checkout', {
value: cartTotal,
items: cartItems.length
});
router.push('/checkout');
};
return (
<div>
<h1>{product.name}</h1>
<p>{product.price} PLN</p>
<button onClick={handleAddToCart}>Dodaj do koszyka</button>
<button onClick={handleCheckout}>Kup teraz</button>
</div>
);
}Vercel Speed Insights - monitoring wydajności w czasie rzeczywistym
Speed Insights to rozszerzenie Analytics, które dostarcza szczegółowe informacje o wydajności aplikacji dla prawdziwych użytkowników.
Instalacja
npm install @vercel/speed-insightsKonfiguracja
// app/layout.tsx
import { Analytics } from '@vercel/analytics/react';
import { SpeedInsights } from '@vercel/speed-insights/next';
export default function RootLayout({ children }: { children: React.ReactNode }) {
return (
<html lang="pl">
<body>
{children}
<Analytics />
<SpeedInsights />
</body>
</html>
);
}Co śledzi Speed Insights?
Performance Score
- Overall performance rating (0-100)
- Based on Core Web Vitals i inne metryki
Field Data (RUM)
- Rzeczywiste dane od użytkowników
- Segmentowane po device type, connection speed, geographic location
Lab Data
- Syntetyczne testy wydajności
- Kontrolowane warunki dla consistency
Opportunities
- Konkretne sugestie optymalizacji
- Estimated time savings
Kombinacja z innymi narzędziami analitycznymi
Możesz łączyć Vercel Analytics z innymi narzędziami dla pełniejszego obrazu:
// app/layout.tsx
import { Analytics } from '@vercel/analytics/react';
import { SpeedInsights } from '@vercel/speed-insights/next';
import { GoogleAnalytics } from '@next/third-parties/google';
export default function RootLayout({ children }: { children: React.ReactNode }) {
return (
<html lang="pl">
<body>
{children}
{/* Vercel Analytics - dla Core Web Vitals i podstawowych metryk */}
<Analytics />
<SpeedInsights />
{/* Google Analytics - dla zaawansowanej segmentacji */}
<GoogleAnalytics gaId={process.env.NEXT_PUBLIC_GA_ID} />
</body>
</html>
);
}Best practices dla Vercel Analytics
1. Używaj environment-specific tracking
// app/layout.tsx
import { Analytics } from '@vercel/analytics/react';
export default function RootLayout({ children }: { children: React.ReactNode }) {
return (
<html lang="pl">
<body>
{children}
{/* Tylko w produkcji */}
{process.env.NODE_ENV === 'production' && <Analytics />}
</body>
</html>
);
}2. Grupuj custom events logicznie
// lib/analytics.ts
import { track } from '@vercel/analytics';
export const analytics = {
// User events
user: {
signup: (method: string) => track('User Signup', { method }),
login: (method: string) => track('User Login', { method }),
logout: () => track('User Logout')
},
// E-commerce events
ecommerce: {
viewProduct: (productId: string) =>
track('Product View', { product_id: productId }),
addToCart: (productId: string, value: number) =>
track('Add to Cart', { product_id: productId, value }),
purchase: (orderId: string, value: number) =>
track('Purchase', { order_id: orderId, value })
},
// Engagement events
engagement: {
shareContent: (contentType: string, method: string) =>
track('Share', { content_type: contentType, method }),
search: (query: string) =>
track('Search', { search_term: query }),
playVideo: (videoId: string) =>
track('Video Play', { video_id: videoId })
}
};3. Monitoruj conversion funnel
'use client';
import { track } from '@vercel/analytics';
export default function CheckoutFlow() {
// Step 1: View cart
useEffect(() => {
track('Checkout Step 1 - Cart', {
items: cart.length,
value: cartTotal
});
}, []);
// Step 2: Shipping info
const handleShippingSubmit = () => {
track('Checkout Step 2 - Shipping', {
value: cartTotal
});
};
// Step 3: Payment
const handlePaymentSubmit = () => {
track('Checkout Step 3 - Payment', {
value: cartTotal,
payment_method: selectedPaymentMethod
});
};
// Step 4: Confirmation
const handleOrderComplete = (orderId: string) => {
track('Purchase Complete', {
order_id: orderId,
value: cartTotal,
items: cart.length
});
};
return <CheckoutSteps />;
}Dashboard i raporty
Vercel Analytics Dashboard oferuje:
Overview
- Total page views
- Unique visitors
- Top pages
- Top referrers
Audiences
- Device breakdown (mobile, desktop, tablet)
- Browser usage
- Operating systems
- Geographic distribution
Real-time
- Live visitor count
- Current popular pages
- Recent events
Web Vitals
- LCP, INP, CLS scores
- Performance over time
- Device-specific metrics
Custom Events
- Event counts
- Event properties
- Conversion tracking
Limitacje i pricing
Free tier:
- 2,500 events/month
- Podstawowe analytics
- 1 member
Pro tier ($10/member/month):
- 100,000 events/month
- Advanced filtering
- Unlimited members
- Data export
Enterprise:
- Custom event limits
- Dedicated support
- SLA guarantees
Integracja z Vercel Edge Config
Możesz dynamicznie kontrolować feature flags bazując na analytics:
// lib/feature-flags.ts
import { get } from '@vercel/edge-config';
import { track } from '@vercel/analytics';
export async function checkFeatureFlag(flagName: string): Promise<boolean> {
const isEnabled = await get(flagName);
// Śledź użycie feature flag
if (isEnabled) {
track('Feature Flag Enabled', { flag: flagName });
}
return isEnabled || false;
}Podsumowanie Vercel Analytics
W Metropolii Quantum 2150, gdzie każda milisekunda ma znaczenie, Vercel Analytics dostarcza kwantowej precyzji w monitoringu aplikacji Next.js:
Kluczowe zalety:
- Zero-config setup dla podstawowych metryk
- Automatyczne śledzenie Core Web Vitals
- Privacy-first approach (GDPR compliant)
- Real-time data w Vercel Dashboard
- Integracja z Vercel Edge Network
- Custom events dla business metrics
Kiedy używać Vercel Analytics:
- Aplikacje hostowane na Vercel
- Potrzebujesz privacy-first analytics
- Chcesz zero-config Web Vitals monitoring
- Podstawowa analityka wystarczy dla Twojego case'u
- Budżet pozwala na płatny plan dla większego traffic
Kiedy rozważyć alternatywy:
- Potrzebujesz zaawansowanej segmentacji użytkowników
- Wymagasz funnel analysis i attribution modeling
- Masz bardzo duży traffic (> 1M page views/month)
- Potrzebujesz integracji z ad platforms
- Preferujesz self-hosted solution
Vercel Analytics to idealne rozwiązanie dla większości aplikacji Next.js, oferujące doskonałą równowagę między prostotą, wydajnością i funkcjonalnością. W połączeniu z Speed Insights tworzy kompletny system monitoringu wydajności aplikacji w czasie rzeczywistym!
Monitoring niestandardowy z Prometheus i Grafana
Dla bardziej zaawansowanego monitoringu możesz skonfigurować własny stack z Prometheus i Grafana.
1. Konfiguracja metryk Prometheus
// lib/metrics.ts
import client from 'prom-client';
// Rejestr metryk
const register = new client.Registry();
// Metryki HTTP
const httpRequestDuration = new client.Histogram({
name: 'http_request_duration_seconds',
help: 'Duration of HTTP requests in seconds',
labelNames: ['method', 'route', 'status_code'],
buckets: [0.1, 0.3, 0.5, 0.7, 1, 3, 5, 7, 10],
});
const httpRequestTotal = new client.Counter({
name: 'http_requests_total',
help: 'Total number of HTTP requests',
labelNames: ['method', 'route', 'status_code'],
});
// Metryki biznesowe
const userRegistrations = new client.Counter({
name: 'user_registrations_total',
help: 'Total number of user registrations',
});
const ordersTotal = new client.Counter({
name: 'orders_total',
help: 'Total number of orders',
labelNames: ['status'],
});
// Zarejestruj metryki
register.registerMetric(httpRequestDuration);
register.registerMetric(httpRequestTotal);
register.registerMetric(userRegistrations);
register.registerMetric(ordersTotal);
// Dodaj domyślne metryki Node.js
client.collectDefaultMetrics({ register });
export {
register,
httpRequestDuration,
httpRequestTotal,
userRegistrations,
orderTotal
};2. Middleware do śledzenia HTTP
// middleware.ts
import { NextRequest, NextResponse } from 'next/server';
import { httpRequestDuration, httpRequestTotal } from '@/lib/metrics';
export function middleware(request: NextRequest) {
const start = Date.now();
// Kontynuuj przetwarzanie żądania
const response = NextResponse.next();
// Zapisz metryki po przetworzeniu żądania
response.headers.set('x-response-time', (Date.now() - start).toString());
// Async zapisanie metryk (nie blokuje odpowiedzi)
setImmediate(() => {
const duration = (Date.now() - start) / 1000;
const labels = {
method: request.method,
route: request.nextUrl.pathname,
status_code: response.status.toString(),
};
httpRequestDuration.observe(labels, duration);
httpRequestTotal.inc(labels);
});
return response;
}
export const config = {
matcher: [
'/((?!api|_next/static|_next/image|favicon.ico).*)',
],
};3. Endpoint dla metryk Prometheus
// app/api/metrics/route.ts
import { NextRequest, NextResponse } from 'next/server';
import { register } from '@/lib/metrics';
export async function GET(request: NextRequest) {
const metrics = await register.metrics();
return new NextResponse(metrics, {
headers: {
'Content-Type': register.contentType,
},
});
}Alerting i powiadomienia
Ważnym aspektem monitoringu jest automatyczne powiadamianie o problemach.
1. Integracja ze Slack
// lib/alerts.ts
import { IncomingWebhook } from '@slack/webhook';
const webhook = new IncomingWebhook(process.env.SLACK_WEBHOOK_URL);
export async function sendSlackAlert(message: string, severity: 'info' | 'warning' | 'error') {
const colors = {
info: '#36a64f',
warning: '#ffcc00',
error: '#ff0000',
};
try {
await webhook.send({
attachments: [
{
color: colors[severity],
fields: [
{
title: 'Alert',
value: message,
short: false,
},
{
title: 'Time',
value: new Date().toISOString(),
short: true,
},
{
title: 'Environment',
value: process.env.NODE_ENV,
short: true,
},
],
},
],
});
} catch (error) {
console.error('Failed to send Slack alert:', error);
}
}
// Funkcja do sprawdzania thresholdów i wysyłania alertów
export function checkPerformanceThresholds(metrics: {
lcp: number;
inp: number;
cls: number;
}) {
if (metrics.lcp > 2500) {
sendSlackAlert(`High LCP detected: ${metrics.lcp}ms`, 'warning');
}
if (metrics.inp > 200) {
sendSlackAlert(`High INP detected: ${metrics.inp}ms`, 'warning');
}
if (metrics.cls > 0.1) {
sendSlackAlert(`High CLS detected: ${metrics.cls}`, 'warning');
}
}2. Monitoring uptime
// lib/uptime-monitor.ts
import { sendSlackAlert } from './alerts';
interface HealthCheckResult {
service: string;
status: 'healthy' | 'unhealthy';
responseTime: number;
timestamp: Date;
}
export async function checkServiceHealth(url: string, service: string): Promise<HealthCheckResult> {
const start = Date.now();
try {
const response = await fetch(url, {
method: 'GET',
timeout: 10000, // 10 second timeout
});
const responseTime = Date.now() - start;
if (response.ok) {
return {
service,
status: 'healthy',
responseTime,
timestamp: new Date(),
};
} else {
await sendSlackAlert(`Service ${service} returned ${response.status}`, 'error');
return {
service,
status: 'unhealthy',
responseTime,
timestamp: new Date(),
};
}
} catch (error) {
await sendSlackAlert(`Service ${service} is unreachable: ${error.message}`, 'error');
return {
service,
status: 'unhealthy',
responseTime: Date.now() - start,
timestamp: new Date(),
};
}
}
// Funkcja do uruchamiania health checków
export async function runHealthChecks() {
const services = [
{ name: 'Main App', url: 'https://your-app.com/api/health' },
{ name: 'Database', url: 'https://your-app.com/api/health/db' },
{ name: 'External API', url: 'https://api.external-service.com/health' },
];
const results = await Promise.allSettled(
services.map(service => checkServiceHealth(service.url, service.name))
);
results.forEach((result, index) => {
if (result.status === 'fulfilled') {
console.log(`Health check for ${services[index].name}:`, result.value);
} else {
console.error(`Health check failed for ${services[index].name}:`, result.reason);
}
});
}Dashboard i wizualizacja danych
1. Prosty dashboard w Next.js
// app/admin/monitoring/page.tsx
import { getWebVitalMetrics, getErrorMetrics } from '@/lib/analytics';
import { LineChart, BarChart } from '@/components/Charts';
export default async function MonitoringDashboard() {
const webVitals = await getWebVitalMetrics();
const errors = await getErrorMetrics();
return (
<div className="p-6">
<h1 className="text-3xl font-bold mb-8">Monitoring Dashboard</h1>
<div className="grid grid-cols-1 lg:grid-cols-2 gap-6 mb-8">
{/* Core Web Vitals */}
<div className="bg-white p-6 rounded-lg shadow">
<h2 className="text-xl font-semibold mb-4">Core Web Vitals</h2>
<LineChart
data={webVitals}
categories={['lcp', 'inp', 'cls']}
xKey="timestamp"
/>
</div>
{/* Error Rate */}
<div className="bg-white p-6 rounded-lg shadow">
<h2 className="text-xl font-semibold mb-4">Error Rate</h2>
<BarChart
data={errors}
category="count"
xKey="hour"
/>
</div>
</div>
{/* Real-time metrics */}
<div className="grid grid-cols-1 md:grid-cols-4 gap-4">
<MetricCard title="Active Users" value="1,234" change="+5.2%" />
<MetricCard title="Response Time" value="156ms" change="-2.1%" />
<MetricCard title="Error Rate" value="0.01%" change="-50%" />
<MetricCard title="Uptime" value="99.9%" change="+0.1%" />
</div>
</div>
);
}
function MetricCard({ title, value, change }: {
title: string;
value: string;
change: string;
}) {
const isPositive = change.startsWith('+');
const isNegative = change.startsWith('-');
return (
<div className="bg-white p-4 rounded-lg shadow">
<h3 className="text-sm font-medium text-gray-500">{title}</h3>
<div className="mt-2 flex items-baseline">
<p className="text-2xl font-semibold text-gray-900">{value}</p>
<p className={`ml-2 text-sm font-medium ${
isPositive ? 'text-green-600' : isNegative ? 'text-red-600' : 'text-gray-500'
}`}>
{change}
</p>
</div>
</div>
);
}Najlepsze praktyki monitoringu
1. Strategie sampling
// lib/sampling.ts
// Funkcja do określania, czy zdarzenie powinno być śledzone
export function shouldSample(sampleRate: number): boolean {
return Math.random() < sampleRate;
}
// Adaptive sampling - więcej próbek dla błędów
export function adaptiveSample(isError: boolean): boolean {
return isError ? shouldSample(1.0) : shouldSample(0.1);
}
// Sampling based on user tier
export function userTierSample(userTier: 'free' | 'premium' | 'enterprise'): boolean {
const rates = {
free: 0.05, // 5% dla darmowych użytkowników
premium: 0.25, // 25% dla premium
enterprise: 1.0, // 100% dla enterprise
};
return shouldSample(rates[userTier]);
}2. Optymalizacja wydajności monitoringu
// lib/performance-monitoring.ts
// Buffer dla metryk - zbieraj i wysyłaj partiami
class MetricsBuffer {
private buffer: any[] = [];
private maxSize = 100;
private flushInterval = 30000; // 30 sekund
constructor() {
// Automatyczne opróżnianie bufora
setInterval(() => this.flush(), this.flushInterval);
}
add(metric: any) {
this.buffer.push(metric);
if (this.buffer.length >= this.maxSize) {
this.flush();
}
}
private async flush() {
if (this.buffer.length === 0) return;
const metricsToSend = [...this.buffer];
this.buffer = [];
try {
await fetch('/api/metrics/batch', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ metrics: metricsToSend }),
});
} catch (error) {
console.error('Failed to send metrics batch:', error);
// Wróć metryki do bufora w przypadku błędu
this.buffer.unshift(...metricsToSend);
}
}
}
export const metricsBuffer = new MetricsBuffer();Podsumowanie
Monitoring wydajności i analityka błędów to kluczowe elementy każdej produkcyjnej aplikacji Next.js. Kompleksowe podejście do monitoringu obejmuje:
- Śledzenie błędów - automatyczne wykrywanie i raportowanie problemów
- Monitoring wydajności - Core Web Vitals i inne kluczowe metryki
- Alerting - natychmiastowe powiadomienia o krytycznych problemach
- Dashboardy - wizualizacja danych dla podejmowania decyzji
- Analityka użytkowników - zrozumienie, jak użytkownicy korzystają z aplikacji
Wybierając narzędzia monitoringu, rozważ:
- Sentry - dla kompleksowego śledzenia błędów
- Vercel Analytics - dla prostego monitoringu na Vercel
- New Relic/DataDog - dla zaawansowanego monitoringu wydajności
- Własne rozwiązania - dla specjalistycznych potrzeb
Pamiętaj o balansie między głębokością monitoringu a wpływem na wydajność aplikacji. Używaj sampling, bufferingu i optymalizuj zapytania, aby monitoring nie wpływał negatywnie na doświadczenie użytkownika.
Kod do tej lekcji: App.tsx
import React, { useState, useEffect } from 'react';
// Demo: Monitoring wydajnosci i analityka bledow
interface ErrorEntry {
id: string;
type: 'error' | 'warning' | 'info';
message: string;
stack: string;
count: number;
lastSeen: string;
status: 'new' | 'acknowledged' | 'resolved';
}
interface PerformanceMetric {
name: string;
value: number;
unit: string;
status: 'good' | 'needs-improvement' | 'poor';
threshold: { good: number; poor: number };
}
function MonitoringDemo() {
const [errors, setErrors] = useState<ErrorEntry[]>([
{ id: '1', type: 'error', message: 'TypeError: Cannot read property of undefined', stack: 'at UserProfile (/app/components/UserProfile.tsx:42)', count: 23, lastSeen: '2 min ago', status: 'new' },
{ id: '2', type: 'error', message: 'NetworkError: Failed to fetch /api/data', stack: 'at fetchData (/app/lib/api.ts:15)', count: 8, lastSeen: '15 min ago', status: 'acknowledged' },
{ id: '3', type: 'warning', message: 'Large bundle size: chunk-vendors.js (450KB)', stack: 'Build warning', count: 1, lastSeen: '1 hour ago', status: 'new' },
{ id: '4', type: 'error', message: 'Hydration mismatch in <Header />', stack: 'at Header (/app/components/Header.tsx:18)', count: 156, lastSeen: '30 sec ago', status: 'new' },
]);
const [metrics, setMetrics] = useState<PerformanceMetric[]>([
{ name: 'FCP', value: 1.2, unit: 's', status: 'good', threshold: { good: 1.8, poor: 3.0 } },
{ name: 'LCP', value: 2.4, unit: 's', status: 'needs-improvement', threshold: { good: 2.5, poor: 4.0 } },
{ name: 'CLS', value: 0.05, unit: '', status: 'good', threshold: { good: 0.1, poor: 0.25 } },
{ name: 'FID', value: 45, unit: 'ms', status: 'good', threshold: { good: 100, poor: 300 } },
{ name: 'TTFB', value: 320, unit: 'ms', status: 'needs-improvement', threshold: { good: 200, poor: 600 } },
{ name: 'INP', value: 180, unit: 'ms', status: 'needs-improvement', threshold: { good: 200, poor: 500 } },
]);
const [activeTab, setActiveTab] = useState<'errors' | 'performance' | 'setup'>('errors');
const [selectedTool, setSelectedTool] = useState<'sentry' | 'vercel' | 'custom'>('sentry');
const statusColors: Record<string, string> = { good: '#10b981', 'needs-improvement': '#f59e0b', poor: '#ef4444' };
const errorTypeColors: Record<string, string> = { error: '#ef4444', warning: '#f59e0b', info: '#3b82f6' };
const errorStatusColors: Record<string, string> = { new: '#ef4444', acknowledged: '#f59e0b', resolved: '#10b981' };
const updateErrorStatus = (id: string, status: ErrorEntry['status']) => {
setErrors(prev => prev.map(e => e.id === id ? { ...e, status } : e));
};
const triggerError = () => {
const newError: ErrorEntry = {
id: String(Date.now()),
type: 'error',
message: ['RangeError: Maximum call stack', 'SyntaxError: Unexpected token', 'ReferenceError: x is not defined'][Math.floor(Math.random() * 3)],
stack: 'at Component (/app/page.tsx:' + Math.floor(Math.random() * 100) + ')',
count: 1, lastSeen: 'just now', status: 'new',
};
setErrors(prev => [newError, ...prev]);
};
const setupCode: Record<string, string> = {
sentry: "// sentry.client.config.ts\nimport * as Sentry from '@sentry/nextjs';\n\nSentry.init({\n dsn: process.env.SENTRY_DSN,\n tracesSampleRate: 0.1,\n replaysSessionSampleRate: 0.1,\n integrations: [\n Sentry.replayIntegration(),\n Sentry.browserTracingIntegration(),\n ],\n});",
vercel: "// next.config.js\nmodule.exports = {\n experimental: {\n instrumentationHook: true,\n },\n};\n\n// instrumentation.ts\nexport async function register() {\n if (process.env.NEXT_RUNTIME === 'nodejs') {\n // Server-side monitoring\n }\n}",
custom: "// lib/monitoring.ts\nexport function reportError(error: Error, context?: object) {\n fetch('/api/errors', {\n method: 'POST',\n body: JSON.stringify({\n message: error.message,\n stack: error.stack,\n context,\n timestamp: Date.now(),\n }),\n });\n}",
};
return (
<div style={{ background: '#0f0f23', minHeight: '100vh', padding: '20px', color: '#e0e0e0', fontFamily: 'system-ui' }}>
<h1 style={{ color: '#64ffda', marginBottom: '8px' }}>Monitoring & Error Tracking</h1>
<p style={{ color: '#8892b0', marginBottom: '24px' }}>Monitoring wydajnosci i sledzenie bledow w Next.js</p>
<div style={{ display: 'flex', gap: '8px', marginBottom: '24px' }}>
{[
{ id: 'errors' as const, label: 'Bledy (' + errors.filter(e => e.status === 'new').length + ')' },
{ id: 'performance' as const, label: 'Wydajnosc' },
{ id: 'setup' as const, label: 'Konfiguracja' },
].map(tab => (
<button key={tab.id} onClick={() => setActiveTab(tab.id)} style={{
padding: '10px 20px', borderRadius: '8px', border: 'none', cursor: 'pointer',
background: activeTab === tab.id ? '#64ffda' : '#1a1a2e', color: activeTab === tab.id ? '#0f0f23' : '#8892b0', fontWeight: 'bold',
}}>{tab.label}</button>
))}
</div>
{activeTab === 'errors' && (
<div>
<button onClick={triggerError} style={{ padding: '8px 16px', borderRadius: '6px', background: '#ef4444', color: '#fff', border: 'none', cursor: 'pointer', marginBottom: '16px' }}>
Symuluj blad
</button>
<div style={{ display: 'grid', gap: '8px' }}>
{errors.map(err => (
<div key={err.id} style={{ padding: '14px', borderRadius: '8px', background: '#1a1a2e', border: '1px solid #333' }}>
<div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: '8px' }}>
<div style={{ display: 'flex', alignItems: 'center', gap: '8px' }}>
<span style={{ fontSize: '11px', padding: '2px 8px', borderRadius: '12px', background: errorTypeColors[err.type] + '30', color: errorTypeColors[err.type] }}>{err.type}</span>
<span style={{ fontSize: '11px', padding: '2px 8px', borderRadius: '12px', background: errorStatusColors[err.status] + '30', color: errorStatusColors[err.status] }}>{err.status}</span>
<span style={{ fontSize: '12px', color: '#8892b0' }}>x{err.count} | {err.lastSeen}</span>
</div>
<select value={err.status} onChange={e => updateErrorStatus(err.id, e.target.value as any)} style={{ padding: '4px 8px', borderRadius: '4px', background: '#0f0f23', color: '#fff', border: '1px solid #333', fontSize: '11px' }}>
<option value="new">New</option>
<option value="acknowledged">Acknowledged</option>
<option value="resolved">Resolved</option>
</select>
</div>
<div style={{ color: errorTypeColors[err.type], fontWeight: 'bold', fontSize: '14px' }}>{err.message}</div>
<div style={{ fontSize: '12px', color: '#555', marginTop: '4px' }}>{err.stack}</div>
</div>
))}
</div>
</div>
)}
{activeTab === 'performance' && (
<div style={{ display: 'grid', gridTemplateColumns: 'repeat(3, 1fr)', gap: '16px' }}>
{metrics.map(m => (
<div key={m.name} style={{ background: '#1a1a2e', padding: '20px', borderRadius: '12px', border: '1px solid #333', textAlign: 'center' }}>
<div style={{ fontSize: '32px', fontWeight: 'bold', color: statusColors[m.status] }}>{m.value}{m.unit}</div>
<div style={{ fontSize: '16px', color: '#64ffda', marginTop: '4px' }}>{m.name}</div>
<div style={{ fontSize: '12px', color: statusColors[m.status], marginTop: '4px' }}>{m.status.replace('-', ' ')}</div>
<div style={{ marginTop: '8px', height: '4px', background: '#333', borderRadius: '2px', overflow: 'hidden' }}>
<div style={{ width: Math.min(100, (m.value / m.threshold.poor) * 100) + '%', height: '100%', background: statusColors[m.status] }} />
</div>
<div style={{ fontSize: '10px', color: '#555', marginTop: '4px' }}>Good: <{m.threshold.good}{m.unit} | Poor: >{m.threshold.poor}{m.unit}</div>
</div>
))}
</div>
)}
{activeTab === 'setup' && (
<div>
<div style={{ display: 'flex', gap: '8px', marginBottom: '16px' }}>
{[
{ id: 'sentry' as const, label: 'Sentry' },
{ id: 'vercel' as const, label: 'Vercel Analytics' },
{ id: 'custom' as const, label: 'Custom' },
].map(tool => (
<button key={tool.id} onClick={() => setSelectedTool(tool.id)} style={{
padding: '8px 16px', borderRadius: '8px', border: 'none', cursor: 'pointer',
background: selectedTool === tool.id ? '#7c3aed' : '#1a1a2e', color: '#fff',
}}>{tool.label}</button>
))}
</div>
<pre style={{ background: '#1a1a2e', padding: '16px', borderRadius: '8px', fontSize: '12px', overflow: 'auto', border: '1px solid #333', color: '#e0e0e0', whiteSpace: 'pre-wrap' }}>
{setupCode[selectedTool]}
</pre>
</div>
)}
</div>
);
}
export default MonitoringDemo;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. Które metryki Core Web Vitals mierzy Google do oceny wydajności strony?
Zadania praktyczne w grze
- Edytor kodu
Utwórz system monitorowania aplikacji: performance metrics, error tracking, uptime monitoring używając Web Vitals
- Układanie w pionie
Ułóż elementy w prawidłowej kolejności: Choose tool → Add instrumentation → Set
- Układanie w pionie
Ułóż etapy konfiguracji performance budgets w prawidłowej kolejności: