Kurs Next.js · Moduł 8: Deployment i produkcja
Integracja z Web Analytics
W tej lekcji13
W świecie aplikacji webowych, zrozumienie zachowań użytkowników i mierzenie efektywności jest kluczowe dla podejmowania trafnych decyzji biznesowych i technicznych. Integracja narzędzi analitycznych z aplikacją Next.js pozwala na śledzenie ruchu, zachowania użytkowników, konwersji i innych istotnych wskaźników wydajności.
Popularne narzędzia analityczne
Do najczęściej używanych narzędzi analitycznych w aplikacjach Next.js należą:
- Google Analytics - kompleksowe narzędzie z szerokim zakresem funkcji analitycznych
- Vercel Analytics - natywna analityka dla aplikacji hostowanych na Vercel
- Plausible - przyjazna dla prywatności alternatywa open-source
- Fathom - prosty i skoncentrowany na prywatności system analityczny
- PostHog - platforma all-in-one łącząca analitykę, sesje użytkowników i funkcje eksperymentalne
- Mixpanel - zaawansowana analityka z naciskiem na śledzenie zdarzeń i lejki konwersji
- Amplitude - skupiona na analizie zachowań użytkowników i analizie produktowej
Integracja Google Analytics 4 (GA4)
Google Analytics to najpopularniejsze narzędzie analityczne. Oto jak zintegrować GA4 z aplikacją Next.js:
1. Konfiguracja Google Analytics
Zacznij od utworzenia konta Google Analytics i konfiguracji strumienia danych:
- Przejdź do Google Analytics
- Utwórz nowe konto i ustaw wskaźnik witryny
- Skonfiguruj strumień danych internetowych i zanotuj ID pomiaru (G-XXXXXXXX)
2. Implementacja w Next.js za pomocą App Router
Utwórz komponent Google Analytics:
// components/GoogleAnalytics.tsx
'use client';
import Script from 'next/script';
export default function GoogleAnalytics({ GA_MEASUREMENT_ID }: { GA_MEASUREMENT_ID: string }) {
return (
<>
<Script
strategy="afterInteractive"
src={`https://www.googletagmanager.com/gtag/js?id=${GA_MEASUREMENT_ID}`}
/>
<Script
id="google-analytics"
strategy="afterInteractive"
dangerouslySetInnerHTML={{
__html: `
window.dataLayer = window.dataLayer || [];
function gtag(){dataLayer.push(arguments);}
gtag('js', new Date());
gtag('config', '${GA_MEASUREMENT_ID}', {
page_path: window.location.pathname,
cookie_flags: 'SameSite=None;Secure'
});
`,
}}
/>
</>
);
}Następnie dodaj komponent do głównego layoutu aplikacji:
// app/layout.tsx
import GoogleAnalytics from '@/components/GoogleAnalytics';
export default function RootLayout({
children,
}: {
children: React.ReactNode;
}) {
return (
<html lang="pl">
<body>
{process.env.NEXT_PUBLIC_GA_MEASUREMENT_ID && (
<GoogleAnalytics GA_MEASUREMENT_ID={process.env.NEXT_PUBLIC_GA_MEASUREMENT_ID} />
)}
{children}
</body>
</html>
);
}Upewnij się, że dodasz zmienną środowiskową do pliku .env.local:
NEXT_PUBLIC_GA_MEASUREMENT_ID=G-XXXXXXXXXX3. Śledzenie nawigacji między stronami
W App Router, powinieneś zaimplementować śledzenie zmian URL, ponieważ nawigacja klientska nie powoduje pełnego odświeżenia strony:
// hooks/usePageTracking.ts
'use client';
import { usePathname, useSearchParams } from 'next/navigation';
import { useEffect } from 'react';
export function usePageTracking() {
const pathname = usePathname();
const searchParams = useSearchParams();
useEffect(() => {
if (pathname && window.gtag) {
let url = window.origin + pathname;
if (searchParams.toString()) {
url = url + '?' + searchParams.toString();
}
window.gtag('config', process.env.NEXT_PUBLIC_GA_MEASUREMENT_ID!, {
page_path: pathname,
page_location: url,
});
}
}, [pathname, searchParams]);
}Następnie wykorzystaj ten hook w komponencie klienckim:
// components/PageTracker.tsx
'use client';
import { usePageTracking } from '@/hooks/usePageTracking';
export default function PageTracker() {
usePageTracking();
return null;
}
// app/layout.tsx
import PageTracker from '@/components/PageTracker';
export default function RootLayout({ children }: { children: React.ReactNode }) {
return (
<html lang="pl">
<body>
{process.env.NEXT_PUBLIC_GA_MEASUREMENT_ID && (
<>
<GoogleAnalytics GA_MEASUREMENT_ID={process.env.NEXT_PUBLIC_GA_MEASUREMENT_ID} />
<PageTracker />
</>
)}
{children}
</body>
</html>
);
}4. Śledzenie niestandardowych zdarzeń
Utwórz narzędzie do śledzenia niestandardowych zdarzeń:
// lib/analytics.ts
'use client';
export type EventOptions = {
category: string;
label?: string;
value?: number;
nonInteraction?: boolean;
[key: string]: any;
};
export const trackEvent = (action: string, options: EventOptions) => {
const { category, label, value, nonInteraction = false, ...restOptions } = options;
if (typeof window !== 'undefined' && window.gtag) {
window.gtag('event', action, {
event_category: category,
event_label: label,
value: value,
non_interaction: nonInteraction,
...restOptions,
});
}
};Użycie w komponencie:
// components/SubscribeButton.tsx
'use client';
import { trackEvent } from '@/lib/analytics';
export default function SubscribeButton() {
const handleSubscribe = () => {
// Logika subskrypcji...
// Śledzenie zdarzenia
trackEvent('subscribe', {
category: 'Engagement',
label: 'Newsletter',
value: 1,
});
};
return (
<button
onClick={handleSubscribe}
className="bg-blue-500 hover:bg-blue-600 text-white py-2 px-4 rounded"
>
Zapisz się do newslettera
</button>
);
}Integracja z Vercel Analytics
Jeśli hostujesz swoją aplikację Next.js na Vercel, możesz skorzystać z wbudowanej analityki Vercel, która oferuje proste wdrożenie i solidne metryki wydajności.
1. Instalacja pakietu @vercel/analytics
npm install @vercel/analytics
# lub
yarn add @vercel/analytics
# lub
pnpm add @vercel/analytics2. Dodanie providera analityki
// 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 automatycznie zbiera dane dotyczące odwiedzin stron i kluczowych metryk Web Vitals.
3. Śledzenie niestandardowych zdarzeń w Vercel Analytics
// components/ContactForm.tsx
'use client';
import { track } from '@vercel/analytics';
import { useState } from 'react';
export default function ContactForm() {
const [email, setEmail] = useState('');
const handleSubmit = (e: React.FormEvent) => {
e.preventDefault();
// Logika formularza kontaktowego...
// Śledzenie zdarzenia
track('contact_form_submitted', { email_domain: email.split('@')[1] });
};
return (
<form onSubmit={handleSubmit} className="space-y-4">
<div>
<label htmlFor="email" className="block mb-1">Email</label>
<input
id="email"
type="email"
value={email}
onChange={(e) => setEmail(e.target.value)}
required
className="w-full px-3 py-2 border rounded"
/>
</div>
<button
type="submit"
className="bg-blue-500 hover:bg-blue-600 text-white py-2 px-4 rounded"
>
Wyślij
</button>
</form>
);
}Integracja przyjaznych dla prywatności narzędzi analitycznych
Z rosnącą świadomością prywatności i regulacjami jak RODO/GDPR, wiele firm wybiera narzędzia analityczne, które są przyjazne dla prywatności. Poniżej znajdziesz przykład integracji z Plausible Analytics.
Integracja z Plausible Analytics
// components/PlausibleAnalytics.tsx
'use client';
import Script from 'next/script';
export default function PlausibleAnalytics({ domain }: { domain: string }) {
return (
<Script
strategy="afterInteractive"
data-domain={domain}
src="https://plausible.io/js/script.js"
/>
);
}
// app/layout.tsx
import PlausibleAnalytics from '@/components/PlausibleAnalytics';
export default function RootLayout({
children,
}: {
children: React.ReactNode;
}) {
return (
<html lang="pl">
<body>
{process.env.NEXT_PUBLIC_ANALYTICS_DOMAIN && (
<PlausibleAnalytics domain={process.env.NEXT_PUBLIC_ANALYTICS_DOMAIN} />
)}
{children}
</body>
</html>
);
}Integracja z PostHog
PostHog to kompleksowa platforma analityczna open-source, która łączy w sobie analitykę, nagrywanie sesji, funkcje AB testów i inne.
// app/providers.tsx
'use client';
import posthog from 'posthog-js';
import { PostHogProvider } from 'posthog-js/react';
import { usePathname, useSearchParams } from 'next/navigation';
import { useEffect } from 'react';
if (typeof window !== 'undefined' && process.env.NEXT_PUBLIC_POSTHOG_KEY) {
posthog.init(process.env.NEXT_PUBLIC_POSTHOG_KEY, {
api_host: process.env.NEXT_PUBLIC_POSTHOG_HOST || 'https://app.posthog.com',
// Inne opcje...
capture_pageview: false // Wyłącz automatyczne śledzenie widoku strony
});
}
export function PostHogPageview(): JSX.Element {
const pathname = usePathname();
const searchParams = useSearchParams();
useEffect(() => {
if (pathname) {
let url = window.origin + pathname;
if (searchParams && searchParams.toString()) {
url = url + `?${searchParams.toString()}`;
}
posthog.capture('$pageview', {
$current_url: url,
});
}
}, [pathname, searchParams]);
return <></>;
}
export function PHProvider({ children }: { children: React.ReactNode }) {
return (
<PostHogProvider client={posthog}>
<PostHogPageview />
{children}
</PostHogProvider>
);
}
// app/layout.tsx
import { PHProvider } from './providers';
export default function RootLayout({
children,
}: {
children: React.ReactNode;
}) {
return (
<html lang="pl">
<body>
<PHProvider>{children}</PHProvider>
</body>
</html>
);
}Obsługa RODO/GDPR i zgody użytkownika
Zgodnie z przepisami o ochronie danych osobowych, należy uzyskać zgodę użytkownika przed rozpoczęciem śledzenia. Implementacja prostego banner z informacją o cookies:
// components/CookieConsent.tsx
'use client';
import { useState, useEffect } from 'react';
export default function CookieConsent() {
const [consent, setConsent] = useState<boolean | null>(null);
useEffect(() => {
// Sprawdzenie, czy użytkownik już wyraził zgodę
const storedConsent = localStorage.getItem('cookieConsent');
if (storedConsent !== null) {
setConsent(storedConsent === 'true');
} else {
setConsent(false); // Domyślnie brak zgody
}
}, []);
const handleAccept = () => {
localStorage.setItem('cookieConsent', 'true');
setConsent(true);
// Włącz analitykę
if (window.gtag) {
window.gtag('consent', 'update', {
'analytics_storage': 'granted'
});
}
};
const handleReject = () => {
localStorage.setItem('cookieConsent', 'false');
setConsent(false);
// Wyłącz analitykę
if (window.gtag) {
window.gtag('consent', 'update', {
'analytics_storage': 'denied'
});
}
};
if (consent === null || consent === true) {
return null; // Nie pokazuj bannera, jeśli zgoda została wyrażona lub jeszcze nie załadowano
}
return (
<div className="fixed bottom-0 left-0 right-0 bg-gray-100 p-4 shadow-md z-50">
<div className="max-w-6xl mx-auto flex flex-col md:flex-row items-center justify-between">
<div className="mb-4 md:mb-0">
<p className="text-sm">
Ta strona używa plików cookie do analizy ruchu. Możesz zdecydować, czy chcesz zaakceptować pliki cookie.
</p>
</div>
<div className="flex space-x-4">
<button
onClick={handleReject}
className="px-4 py-2 text-sm border border-gray-300 rounded hover:bg-gray-200"
>
Odrzuć
</button>
<button
onClick={handleAccept}
className="px-4 py-2 text-sm bg-blue-500 text-white rounded hover:bg-blue-600"
>
Akceptuj
</button>
</div>
</div>
</div>
);
}
// app/layout.tsx
import CookieConsent from '@/components/CookieConsent';
export default function RootLayout({
children,
}: {
children: React.ReactNode;
}) {
return (
<html lang="pl">
<body>
{children}
<CookieConsent />
</body>
</html>
);
}Dostosowanie Google Analytics do wymogów RODO
Zmodyfikuj inicjalizację Google Analytics, aby uwzględnić zgodę użytkownika:
// components/GoogleAnalytics.tsx
'use client';
import Script from 'next/script';
import { useEffect } from 'react';
export default function GoogleAnalytics({ GA_MEASUREMENT_ID }: { GA_MEASUREMENT_ID: string }) {
useEffect(() => {
// Sprawdzenie zgody użytkownika
const consent = localStorage.getItem('cookieConsent') === 'true';
// Aktualizacja stanu zgody w Google Analytics
if (window.gtag) {
window.gtag('consent', 'update', {
'analytics_storage': consent ? 'granted' : 'denied'
});
}
}, []);
return (
<>
<Script
strategy="afterInteractive"
src={`https://www.googletagmanager.com/gtag/js?id=${GA_MEASUREMENT_ID}`}
/>
<Script
id="google-analytics"
strategy="afterInteractive"
dangerouslySetInnerHTML={{
__html: `
window.dataLayer = window.dataLayer || [];
function gtag(){dataLayer.push(arguments);}
gtag('js', new Date());
// Ustaw domyślną zgodę jako 'denied'
gtag('consent', 'default', {
'analytics_storage': 'denied'
});
// Skonfiguruj Google Analytics
gtag('config', '${GA_MEASUREMENT_ID}', {
page_path: window.location.pathname,
});
`,
}}
/>
</>
);
}Integracja kros-platform: Web, iOS, Android
Dla aplikacji, które działają na wielu platformach, warto zaimplementować spójne śledzenie analityczne. Możesz skorzystać z bibliotek takich jak Segment, Amplitude lub Firebase Analytics, które oferują SDK dla różnych platform.
Przykład z Firebase Analytics
// lib/analytics.ts
import { initializeApp } from 'firebase/app';
import { getAnalytics, logEvent, isSupported } from 'firebase/analytics';
const firebaseConfig = {
apiKey: process.env.NEXT_PUBLIC_FIREBASE_API_KEY,
authDomain: process.env.NEXT_PUBLIC_FIREBASE_AUTH_DOMAIN,
projectId: process.env.NEXT_PUBLIC_FIREBASE_PROJECT_ID,
// Inne konfiguracje...
};
let analytics: any = null;
export async function initAnalytics() {
if (typeof window !== 'undefined' && await isSupported()) {
const app = initializeApp(firebaseConfig);
analytics = getAnalytics(app);
return true;
}
return false;
}
export function trackEvent(eventName: string, eventParams?: any) {
if (analytics) {
logEvent(analytics, eventName, eventParams);
}
}
// components/AnalyticsProvider.tsx
'use client';
import { useEffect } from 'react';
import { usePathname, useSearchParams } from 'next/navigation';
import { initAnalytics, trackEvent } from '@/lib/analytics';
export default function AnalyticsProvider({ children }: { children: React.ReactNode }) {
const pathname = usePathname();
const searchParams = useSearchParams();
useEffect(() => {
initAnalytics();
}, []);
useEffect(() => {
if (pathname) {
trackEvent('page_view', {
page_path: pathname,
page_search: searchParams?.toString(),
});
}
}, [pathname, searchParams]);
return <>{children}</>;
}Pomiar Web Vitals
Metryki Web Vitals są kluczowe dla zrozumienia wydajności twojej aplikacji. Next.js oferuje wbudowane narzędzie do raportowania Web Vitals do systemów analitycznych:
// app/layout.tsx
import { useReportWebVitals } from 'next/web-vitals';
export function WebVitals() {
useReportWebVitals((metric) => {
const { id, name, label, value } = metric;
// Raportowanie do Google Analytics
if (window.gtag) {
window.gtag('event', name, {
event_category: 'Web Vitals',
event_label: label,
value: Math.round(name === 'CLS' ? value * 1000 : value),
non_interaction: true,
metric_id: id,
});
}
// Raportowanie do konsoli w środowisku deweloperskim
if (process.env.NODE_ENV === 'development') {
console.log(`Web Vital: ${name}`, metric);
}
});
return null;
}
export default function RootLayout({ children }: { children: React.ReactNode }) {
return (
<html lang="pl">
<body>
<WebVitals />
{children}
</body>
</html>
);
}Własne panele analityczne
Czasami potrzebujesz wizualizować dane analityczne bezpośrednio w swojej aplikacji. Możesz zaimplementować własny dashboard analityczny, pobierając dane z API Google Analytics lub innego narzędzia:
// app/admin/analytics/page.tsx
import { google } from 'googleapis';
import { BarChart, LineChart } from '@/components/Charts';
async function getAnalyticsData() {
try {
// Inicjalizacja klienta Google Analytics
const auth = new google.auth.GoogleAuth({
keyFile: process.env.GOOGLE_APPLICATION_CREDENTIALS,
scopes: ['https://www.googleapis.com/auth/analytics.readonly'],
});
const analyticsreporting = google.analyticsreporting({
version: 'v4',
auth,
});
// Pobranie danych analitycznych
const response = await analyticsreporting.reports.batchGet({
requestBody: {
reportRequests: [
{
viewId: process.env.GA_VIEW_ID,
dateRanges: [{ startDate: '30daysAgo', endDate: 'today' }],
metrics: [{ expression: 'ga:sessions' }, { expression: 'ga:pageviews' }],
dimensions: [{ name: 'ga:date' }],
},
],
},
});
// Przetworzenie danych
const report = response.data.reports[0];
const rows = report.data.rows;
return rows.map((row) => ({
date: row.dimensions[0],
sessions: parseInt(row.metrics[0].values[0], 10),
pageviews: parseInt(row.metrics[0].values[1], 10),
}));
} catch (error) {
console.error('Błąd podczas pobierania danych analitycznych:', error);
return [];
}
}
export default async function AnalyticsDashboard() {
const analyticsData = await getAnalyticsData();
return (
<div className="p-6">
<h1 className="text-2xl font-bold mb-6">Panel analityczny</h1>
<div className="grid grid-cols-1 md:grid-cols-2 gap-6">
<div className="bg-white p-4 rounded shadow">
<h2 className="text-lg font-semibold mb-4">Sesje vs. odsłony strony</h2>
<LineChart
data={analyticsData}
categories={['sessions', 'pageviews']}
xKey="date"
/>
</div>
<div className="bg-white p-4 rounded shadow">
<h2 className="text-lg font-semibold mb-4">Odsłony według dnia</h2>
<BarChart
data={analyticsData}
category="pageviews"
xKey="date"
/>
</div>
</div>
</div>
);
}Testowanie i debugowanie analityki
Przed wdrożeniem na produkcję, warto przetestować integrację analityczną w środowisku deweloperskim:
// lib/analytics.ts
export function trackEvent(eventName: string, eventParams: any = {}) {
// W środowisku deweloperskim wypisuj zdarzenia do konsoli
if (process.env.NODE_ENV === 'development') {
console.log(`Analytics Event: ${eventName}`, eventParams);
return;
}
// W środowisku produkcyjnym wysyłaj do serwisu analitycznego
if (window.gtag) {
window.gtag('event', eventName, eventParams);
}
}Do testowania możesz także użyć dodatków przeglądarkowych, takich jak Google Analytics Debugger, Tag Assistant lub Facebook Pixel Helper.
Najlepsze praktyki
- Szanuj prywatność użytkowników - zawsze informuj o użyciu narzędzi analitycznych i zbieraj zgodę
- Minimalizuj wpływ na wydajność - używaj strategii
afterInteractivelublazyOnloaddla skryptów analitycznych - Segmentuj dane - kategoryzuj zdarzenia, aby łatwiej analizować dane
- Korzystaj z wielu źródeł danych - łącz dane z różnych narzędzi dla pełniejszego obrazu
- Regularnie weryfikuj dane - sprawdzaj poprawność danych analitycznych
- Analizuj trendy - szukaj wzorców i anomalii w danych
- Anonimizuj dane - zbieraj dane w sposób zgodny z RODO
Frameworki analityczne dla Next.js
Dla bardziej zaawansowanych potrzeb, warto rozważyć użycie specjalizowanych frameworków analitycznych dla Next.js:
- Next-GA - uproszczona integracja z Google Analytics
- Use-Analytics - uniwersalny hook do integracji z różnymi dostawcami analitycznymi
- React-GA - popularna biblioteka do integracji React z Google Analytics
- Next-Plausible - integracja z przyjaznym dla prywatności narzędziem Plausible
Podsumowanie
Analityka webowa jest kluczowym narzędziem do zrozumienia użytkowników i optymalizacji aplikacji. Next.js oferuje wiele sposobów integracji z różnymi narzędziami analitycznymi, od Google Analytics przez Vercel Analytics po alternatywy bardziej przyjazne dla prywatności, takie jak Plausible czy Fathom.
Pamiętaj, że najważniejsze jest, aby zbierać tylko te dane, które są naprawdę potrzebne i robić to z poszanowaniem prywatności użytkowników. Dobre praktyki obejmują uzyskiwanie zgody, anonimizację danych i informowanie użytkowników o tym, jakie dane są zbierane i w jakim celu.
Kod do tej lekcji: App.tsx
import React, { useState, useEffect } from 'react';
// Demo: Web Analytics Integration
interface AnalyticsEvent {
id: string;
type: 'pageview' | 'click' | 'scroll' | 'conversion' | 'error';
page: string;
timestamp: string;
data?: string;
}
interface AnalyticsMetrics {
pageViews: number;
uniqueVisitors: number;
bounceRate: number;
avgSessionDuration: number;
topPages: { page: string; views: number }[];
}
function AnalyticsDemo() {
const [events, setEvents] = useState<AnalyticsEvent[]>([]);
const [metrics, setMetrics] = useState<AnalyticsMetrics>({
pageViews: 1247,
uniqueVisitors: 892,
bounceRate: 34.2,
avgSessionDuration: 245,
topPages: [
{ page: '/', views: 456 },
{ page: '/blog', views: 312 },
{ page: '/products', views: 278 },
{ page: '/about', views: 201 },
],
});
const [activeProvider, setActiveProvider] = useState<'ga4' | 'plausible' | 'custom'>('ga4');
const [isTracking, setIsTracking] = useState(true);
const providers = [
{ id: 'ga4' as const, name: 'Google Analytics 4', color: '#f59e0b' },
{ id: 'plausible' as const, name: 'Plausible', color: '#10b981' },
{ id: 'custom' as const, name: 'Custom Analytics', color: '#8b5cf6' },
];
const trackEvent = (type: AnalyticsEvent['type'], page: string, data?: string) => {
if (!isTracking) return;
const event: AnalyticsEvent = {
id: Math.random().toString(36).substr(2, 6),
type, page, data,
timestamp: new Date().toLocaleTimeString(),
};
setEvents(prev => [event, ...prev.slice(0, 19)]);
if (type === 'pageview') {
setMetrics(prev => ({ ...prev, pageViews: prev.pageViews + 1 }));
}
};
const eventColors: Record<string, string> = {
pageview: '#3b82f6', click: '#10b981', scroll: '#f59e0b', conversion: '#8b5cf6', error: '#ef4444',
};
const codeSnippets: Record<string, string> = {
ga4: "// app/layout.tsx\nimport { GoogleAnalytics } from '@next/third-parties/google';\n\nexport default function RootLayout({ children }) {\n return (\n <html>\n <body>{children}</body>\n <GoogleAnalytics gaId=\"G-XXXXXXX\" />\n </html>\n );\n}",
plausible: "// app/layout.tsx\nimport Script from 'next/script';\n\nexport default function RootLayout({ children }) {\n return (\n <html>\n <body>\n {children}\n <Script\n defer\n data-domain=\"yourdomain.com\"\n src=\"https://plausible.io/js/script.js\"\n />\n </body>\n </html>\n );\n}",
custom: "// lib/analytics.ts\nexport function trackPageView(url: string) {\n fetch('/api/analytics', {\n method: 'POST',\n body: JSON.stringify({ type: 'pageview', url, timestamp: Date.now() }),\n });\n}\n\n// app/layout.tsx - use in useEffect\nuseEffect(() => {\n trackPageView(pathname);\n}, [pathname]);",
};
return (
<div style={{ background: '#0f0f23', minHeight: '100vh', padding: '20px', color: '#e0e0e0', fontFamily: 'system-ui' }}>
<h1 style={{ color: '#64ffda', marginBottom: '8px' }}>Web Analytics Dashboard</h1>
<p style={{ color: '#8892b0', marginBottom: '24px' }}>Integracja analityki w Next.js</p>
<div style={{ display: 'grid', gridTemplateColumns: 'repeat(4, 1fr)', gap: '16px', marginBottom: '24px' }}>
{[
{ label: 'Page Views', value: metrics.pageViews.toLocaleString(), color: '#3b82f6' },
{ label: 'Unique Visitors', value: metrics.uniqueVisitors.toLocaleString(), color: '#10b981' },
{ label: 'Bounce Rate', value: metrics.bounceRate + '%', color: '#f59e0b' },
{ label: 'Avg Session', value: Math.floor(metrics.avgSessionDuration / 60) + 'm ' + (metrics.avgSessionDuration % 60) + 's', color: '#8b5cf6' },
].map(m => (
<div key={m.label} style={{ background: '#1a1a2e', padding: '16px', borderRadius: '12px', border: '1px solid #333', textAlign: 'center' }}>
<div style={{ fontSize: '28px', fontWeight: 'bold', color: m.color }}>{m.value}</div>
<div style={{ fontSize: '13px', color: '#8892b0', marginTop: '4px' }}>{m.label}</div>
</div>
))}
</div>
<div style={{ display: 'flex', gap: '8px', marginBottom: '20px' }}>
{providers.map(p => (
<button key={p.id} onClick={() => setActiveProvider(p.id)} style={{
padding: '8px 16px', borderRadius: '8px', border: 'none', cursor: 'pointer',
background: activeProvider === p.id ? p.color : '#1a1a2e', color: activeProvider === p.id ? '#fff' : '#8892b0', fontWeight: 'bold',
}}>{p.name}</button>
))}
<button onClick={() => setIsTracking(!isTracking)} style={{ padding: '8px 16px', borderRadius: '8px', border: 'none', cursor: 'pointer', background: isTracking ? '#10b981' : '#ef4444', color: '#fff', marginLeft: 'auto' }}>
{isTracking ? 'Tracking ON' : 'Tracking OFF'}
</button>
</div>
<div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr', gap: '20px', marginBottom: '24px' }}>
<div>
<h3 style={{ color: '#64ffda', fontSize: '16px' }}>Symuluj zdarzenia</h3>
<div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr', gap: '8px' }}>
{[
{ type: 'pageview' as const, label: 'Page View', page: '/home' },
{ type: 'click' as const, label: 'Button Click', page: '/cta' },
{ type: 'scroll' as const, label: 'Scroll 50%', page: '/blog' },
{ type: 'conversion' as const, label: 'Conversion', page: '/checkout' },
{ type: 'error' as const, label: 'JS Error', page: '/app' },
].map(e => (
<button key={e.type} onClick={() => trackEvent(e.type, e.page, e.label)} style={{
padding: '10px', borderRadius: '8px', border: '1px solid ' + eventColors[e.type], background: eventColors[e.type] + '20', color: eventColors[e.type], cursor: 'pointer',
}}>{e.label}</button>
))}
</div>
</div>
<div>
<h3 style={{ color: '#64ffda', fontSize: '16px' }}>Event Log</h3>
<div style={{ maxHeight: '200px', overflow: 'auto', background: '#1a1a2e', borderRadius: '8px', padding: '12px', border: '1px solid #333' }}>
{events.map(e => (
<div key={e.id} style={{ fontSize: '12px', padding: '4px 0', borderBottom: '1px solid #222', display: 'flex', gap: '8px' }}>
<span style={{ color: eventColors[e.type], minWidth: '80px' }}>{e.type}</span>
<span style={{ color: '#64ffda' }}>{e.page}</span>
<span style={{ color: '#555', marginLeft: 'auto' }}>{e.timestamp}</span>
</div>
))}
{events.length === 0 && <p style={{ color: '#555', margin: 0 }}>Brak zdarzen</p>}
</div>
</div>
</div>
<div style={{ background: '#1a1a2e', padding: '16px', borderRadius: '8px', border: '1px solid #333' }}>
<h3 style={{ color: '#f59e0b', fontSize: '14px', marginTop: 0 }}>Kod integracji ({providers.find(p => p.id === activeProvider)?.name}):</h3>
<pre style={{ fontSize: '12px', color: '#e0e0e0', margin: 0, overflow: 'auto', whiteSpace: 'pre-wrap' }}>{codeSnippets[activeProvider]}</pre>
</div>
</div>
);
}
export default AnalyticsDemo;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. Core Web Vitals obejmują:
Zadania praktyczne w grze
- Edytor kodu
Stwórz panel kontrolny z monitorowaniem Web Vitals
- Klikanie w kolejności
Ułóż składnię funkcji reportWebVitals w Next.js
- Edytor kodu
Zaimplementuj dashboard zoptymalizowany pod kątem wydajności