Kurs Next.js · Moduł 8: Deployment i produkcja

Monitoring wydajności i analityka błędów

21 min czytania ·
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:

  1. Wczesnego wykrywania problemów - zanim dotkną użytkowników
  2. Śledzenia wydajności - czasy ładowania, Core Web Vitals, przepustowość
  3. Analizy zachowań użytkowników - jak użytkownicy korzystają z aplikacji
  4. Identyfikacji waskóch gardeł - miejsca wymagające optymalizacji
  5. 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/nextjs

Utwó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/analytics

Podstawowa 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-insights

Konfiguracja

// 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?

  1. Performance Score

    • Overall performance rating (0-100)
    • Based on Core Web Vitals i inne metryki
  2. Field Data (RUM)

    • Rzeczywiste dane od użytkowników
    • Segmentowane po device type, connection speed, geographic location
  3. Lab Data

    • Syntetyczne testy wydajności
    • Kontrolowane warunki dla consistency
  4. 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:

  1. Overview

    • Total page views
    • Unique visitors
    • Top pages
    • Top referrers
  2. Audiences

    • Device breakdown (mobile, desktop, tablet)
    • Browser usage
    • Operating systems
    • Geographic distribution
  3. Real-time

    • Live visitor count
    • Current popular pages
    • Recent events
  4. Web Vitals

    • LCP, INP, CLS scores
    • Performance over time
    • Device-specific metrics
  5. 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:

  1. Śledzenie błędów - automatyczne wykrywanie i raportowanie problemów
  2. Monitoring wydajności - Core Web Vitals i inne kluczowe metryki
  3. Alerting - natychmiastowe powiadomienia o krytycznych problemach
  4. Dashboardy - wizualizacja danych dla podejmowania decyzji
  5. 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: &lt;{m.threshold.good}{m.unit} | Poor: &gt;{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. 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:

  1. Zadanie z kodemPraktyka: Utwórz system monitorowania aplikacji:
  2. Ułóż w kolejnościKolejność: Choose tool → Add instrumentation → ...
  3. PytanieMonitoring wydajności aplikacji
  4. Ułóż w kolejnościKolejność: Define metrics → Measure baseline → Set limits

Przydatne artykuły