Shopify nie udostępnia plików logów. Oto kompletny przewodnik techniczny, jak je uzyskać za pomocą Cloudflare (lub dowolnego Edge CDN).

Duży martwy punkt w e-commerce właśnie został rozwiązany

Od momentu uruchomienia Shopify platforma ta całkowicie uniemożliwia właścicielom sklepów dostęp do surowych logów serwera. Dostajesz lejki konwersji i raporty sprzedaży. Nie dostajesz jednak jednej rzeczy, która naprawdę mówi Ci, co trafia na Twój serwer: logu żądań HTTP.

Przez lata było to drobne niedogodność. Kogo obchodzą surowe logi, skoro masz odsłony stron i współczynniki konwersji? Google Analytics śledzi Twoich użytkowników. Platforma reklamowa śledzi Twoje kampanie. Życie jest piękne.

A potem pojawił się AI.

ChatGPT, Claude, Perplexity, Google AI Overviews, Microsoft Copilot - wszystkie wysyłają boty do Twojego sklepu właśnie teraz. Niektóre przeszukują Twoje strony, aby budować dane treningowe. Inne pobierają treści Twoich produktów w czasie rzeczywistym, aby odpowiedzieć na pytanie klienta. A najgorsze? Tradycyjne narzędzia analityczne, takie jak Google Analytics, nie widzą niczego z tego. Opierają się na JavaScript po stronie klienta, którego boty nigdy nie wykonują. Większość interakcji AI z Twoim sklepem jest dla Ciebie niewidoczna.

To nowy martwy punkt w e-commerce. Boty AI nie uruchamiają Twoich skryptów śledzących. Nie akceptują ciasteczek. Nie pojawiają się w raportach GA4. Ale absolutnie czytają Twoje strony produktów, pobierają Twoje opisy do odpowiedzi generowanych przez AI i wpływają na to, czy klienci w ogóle odkryją Twoją markę.

Pojawiają się nowe narzędzia skupione na “analityce agentów”, które pomagają właścicielom stron zrozumieć aktywność crawlerów AI i ruch poleceń generowanych przez AI poprzez śledzenie po stronie serwera, klasyfikację botów i weryfikację IP. Branża uznaje, że stary model analityki po stronie klienta jest fundamentalnie nieadekwatny w erze odkrywania treści opartego na AI. Dlatego stworzyliśmy WISLR AI Visibility Dashboard - aby dać markom jasny obraz tego, jak platformy AI wchodzą w interakcję z ich treściami, od częstotliwości crawlowania po żądania pobierania i ruch poleceń napędzany przez AI.

Ale jeśli korzystasz z Shopify, masz unikalny problem: nie kontrolujesz serwera. Nie możesz zainstalować śledzenia po stronie serwera bezpośrednio. Nie możesz przeglądać logów dostępu. Nie możesz wyszukać GPTBot za pomocą grep. Infrastruktura Shopify to czarna skrzynka i nie wykazują pilności w jej otwarciu.

Koniec z tym. Oto jak odzyskać swoje logi.

Ten przewodnik przeprowadzi Cię przez budowę własnego kompletnego pipeline’u logowania żądań dla sklepu Shopify przy użyciu Cloudflare. Każde żądanie HTTP. Pełne dane geolokalizacyjne. Metryki wydajności. A co najważniejsze, kompletne wykrywanie i klasyfikacja botów, dzięki czemu w końcu zobaczysz dokładnie, które systemy AI odwiedzają Twój sklep, jak często i które strony ich interesują.

Jak działa logowanie żądań Cloudflare dla Shopify?

 Odwiedzający wysyła żądanie do Twojego sklepu Shopify
         │
         ▼
 Cloudflare CDN (Twoja domena przekierowana przez Cloudflare)
         │
         ▼
 Cloudflare Worker (uruchamiany przy każdym żądaniu)
    ├──→ Przekazuje żądanie do serwera źródłowego Shopify (odwiedzający otrzymuje normalną odpowiedź)
    └──→ Wysyła wpis logu JSON POST do Twojego odbiornika logów (nieblokująco, przez ctx.waitUntil)
              │
              ▼
         Cloudflare Tunnel
         (CNAME w Twojej domenie → tunel → localhost na Twoim serwerze)
              │
              ▼
         Odbiornik HTTP Node.js (localhost:9090)
              │
              ▼
         Pliki logów JSON zapisywane na dysku

Żadne porty nie są publicznie otwarte. Cloudflare Tunnel obsługuje bezpieczny transport z krawędzi Cloudflare do Twojego serwera przez połączenie wyłącznie wychodzące.

Czego potrzebujesz do skonfigurowania logowania żądań Shopify?

• Sklep Shopify z własną domeną przekierowaną przez Cloudflare (pomarańczowa chmurka włączona)
• Serwer do odbierania logów
• Node.js zainstalowany na serwerze
• Konto Cloudflare z włączonymi Workers
• Wrangler CLI zainstalowany (npm install -g wrangler)
• Cloudflared zainstalowany na serwerze

Krok 1: Utwórz Cloudflare Worker

Worker przechwytuje każde żądanie na Twojej domenie, przekazuje je do Shopify i asynchronicznie wysyła wpis logu do Twojego odbiornika.

1a. Źródło Worker (cloudflare-worker.js)

/**
 * Shopify Request Logger
 *
 * Cloudflare Worker that:
 * 1. Logs ALL requests to a self-hosted log receiver (via Cloudflare Tunnel)
 * 2. Optionally logs detailed bot request data to a database
 */

// ============================================
// CONFIG - update these for your setup
// ============================================
const INGEST_URL = 'https://log-collector.yourdomain.com/collect';  // Your tunnel hostname
const INGEST_API_KEY = process.env.INGEST_API_KEY || '';          // Set as Worker secret

// ============================================
// BOT DETECTION PATTERNS
// ============================================
const BOT_PATTERNS = {
  // AI realtime fetchers (user-triggered queries)
  'ChatGPT-User':    { pattern: /ChatGPT-User/i,    type: 'realtime' },
  'Perplexity-User': { pattern: /Perplexity-User/i,  type: 'realtime' },
  // Add your own patterns here for other AI bots

  // Search engine crawlers
  'Googlebot':       { pattern: /Googlebot/i,        type: 'crawler' },
  'Bingbot':         { pattern: /bingbot/i,          type: 'crawler' },

  // Social link preview bots
  'FacebookBot':     { pattern: /facebookexternalhit/i, type: 'preview' },
  'LinkedInBot':     { pattern: /LinkedInBot/i,      type: 'preview' },
};

function identifyBot(userAgent) {
  if (!userAgent) return { name: 'unknown', type: 'unknown' };
  for (const [name, config] of Object.entries(BOT_PATTERNS)) {
    if (config.pattern.test(userAgent)) return { name, type: config.type };
  }
  return { name: 'other', type: 'unknown' };
}

function isKnownBot(userAgent) {
  if (!userAgent) return false;
  return Object.values(BOT_PATTERNS).some(config => config.pattern.test(userAgent));
}

async function logToReceiver(request, env, perfData = {}) {
  const url = new URL(request.url);
  const cf = request.cf || {};
  const bot = identifyBot(request.headers.get('user-agent') || '');

  const logEntry = {
    // Request basics
    timestamp:        new Date().toISOString(),
    method:           request.method,
    url:              request.url,
    path:             url.pathname,
    host:             url.hostname,
    userAgent:        request.headers.get('user-agent') || '',
    ip:               request.headers.get('cf-connecting-ip') || '',
    referer:          request.headers.get('referer') || '',
    cfRay:            request.headers.get('cf-ray') || '',

    // Bot classification
    botName:          bot.name,
    botType:          bot.type,

    // Cloudflare geo data
    country:          cf.country || '',
    region:           cf.region || '',
    city:             cf.city || '',
    postalCode:       cf.postalCode || '',
    latitude:         cf.latitude || '',
    longitude:        cf.longitude || '',
    timezone:         cf.timezone || '',
    continent:        cf.continent || '',

    // Network info
    asn:              cf.asn || '',
    asOrganization:   cf.asOrganization || '',
    colo:             cf.colo || '',
    httpProtocol:     cf.httpProtocol || '',
    tlsVersion:       cf.tlsVersion || '',

    // Client hints (helps detect headless browsers)
    secChUa:          request.headers.get('sec-ch-ua') || '',
    secChUaMobile:    request.headers.get('sec-ch-ua-mobile') || '',
    secChUaPlatform:  request.headers.get('sec-ch-ua-platform') || '',

    // Fetch metadata (helps detect programmatic requests)
    secFetchDest:     request.headers.get('sec-fetch-dest') || '',
    secFetchMode:     request.headers.get('sec-fetch-mode') || '',
    secFetchSite:     request.headers.get('sec-fetch-site') || '',

    // Performance metrics
    edgeStartTimestamp:       perfData.startTime || '',
    edgeEndTimestamp:         perfData.endTime || '',
    edgeTimeToFirstByteMs:   perfData.ttfbMs ?? '',
    clientTcpRttMs:          cf.clientTcpRtt ?? '',
    cacheCacheStatus:        perfData.cacheStatus || '',
    originResponseStatus:    perfData.responseStatus ?? '',
  };

  try {
    await fetch(INGEST_URL, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'X-API-Key': env.INGEST_API_KEY,
      },
      body: JSON.stringify({ logs: [logEntry] }),
    });
  } catch (e) {
    console.error(`Log ingest failed: ${e.message}`);
  }
}

export default {
  async fetch(request, env, ctx) {
    const startTime = Date.now();
    const url = new URL(request.url);

    // Avoid infinite loop - skip logging for your ingest hostname
    if (url.hostname === 'log-collector.yourdomain.com') {
      return fetch(request);
    }

    // Fetch the origin response (Shopify)
    const response = await fetch(request);
    const endTime = Date.now();

    // Ship log entry asynchronously (does not delay the response)
    ctx.waitUntil(logToReceiver(request, env, {
      startTime,
      endTime,
      ttfbMs: endTime - startTime,
      cacheStatus: response.headers.get('cf-cache-status') || '',
      responseStatus: response.status,
    }));

    return response;
  }
};

1b. Konfiguracja Wrangler (wrangler.toml)

name = "shopify-request-logger"
main = "cloudflare-worker.js"
compatibility_date = "2024-01-01"

routes = [
  { pattern = "www.yourdomain.com/*", zone_name = "yourdomain.com" }
]

Zastąp www.yourdomain.com własną domeną Twojego sklepu Shopify.

1c. Ustaw sekrety Worker

wrangler secret put INGEST_API_KEY
# Paste your generated API key when prompted

1d. Wdrożenie

npx wrangler deploy

Krok 2: Skonfiguruj odbiornik logów na swoim serwerze

Minimalny serwer HTTP Node.js, który przyjmuje paczki logów i zapisuje je na dysku.

2a. Skrypt odbiornika (receive-logs.js)

const http = require('http');
const fs = require('fs');
const path = require('path');

const PORT = 9090;
const API_KEY = process.env.LOG_API_KEY;
const LOG_DIR = '/var/log/cdn-requests';  // Choose your log directory

if (!API_KEY) {
  console.error('LOG_API_KEY environment variable is required');
  process.exit(1);
}

// Ensure log directory exists
fs.mkdirSync(LOG_DIR, { recursive: true });

const server = http.createServer((req, res) => {
  // Health check
  if (req.method === 'GET' && req.url === '/status') {
    res.writeHead(200, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify({ status: 'ok' }));
    return;
  }

  // Log ingest endpoint
  if (req.method === 'POST' && req.url === '/collect') {
    const apiKey = req.headers['x-api-key'];
    if (apiKey !== API_KEY) {
      res.writeHead(401, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify({ error: 'unauthorized' }));
      return;
    }

    let body = '';
    let size = 0;
    const MAX_BODY = 10 * 1024 * 1024; // 10MB limit

    req.on('data', chunk => {
      size += chunk.length;
      if (size > MAX_BODY) {
        res.writeHead(413, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify({ error: 'payload too large' }));
        req.destroy();
        return;
      }
      body += chunk;
    });

    req.on('end', () => {
      try {
        JSON.parse(body); // Validate JSON
      } catch (e) {
        res.writeHead(400, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify({ error: 'invalid JSON' }));
        return;
      }

      const filename = `logs-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.json`;
      const filepath = path.join(LOG_DIR, filename);

      fs.writeFile(filepath, body, err => {
        if (err) {
          console.error(`Write failed: ${err.message}`);
          res.writeHead(500, { 'Content-Type': 'application/json' });
          res.end(JSON.stringify({ error: 'write failed' }));
          return;
        }
        console.log(`Wrote ${filename} (${size} bytes)`);
        res.writeHead(200, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify({ ok: true }));
      });
    });
  } else {
    res.writeHead(404, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify({ error: 'not found' }));
  }
});

server.listen(PORT, '127.0.0.1', () => {
  console.log(`Log receiver listening on 127.0.0.1:${PORT}`);
});

Kluczowe informacje:

• Nasłuchuje wyłącznie na 127.0.0.1 - nie jest wystawiony na internet
• Uwierzytelnia żądania za pomocą nagłówka X-API-Key
• Zapisuje każdą paczkę logów jako plik JSON ze znacznikiem czasu
• Limit ładunku 10MB na żądanie

2b. Usługa systemd

Utwórz /etc/systemd/system/log-receiver.service:

[Unit]
Description=Shopify request log receiver
After=network.target

[Service]
Type=simple
Environment=LOG_API_KEY=<your-generated-api-key>
ExecStart=/usr/bin/node /opt/log-receiver/receive-logs.js
Restart=always
RestartSec=5
StandardOutput=journal
StandardError=journal

[Install]
WantedBy=multi-user.target

Włącz i uruchom:

systemctl daemon-reload
systemctl enable --now log-receiver

Krok 3: Skonfiguruj Cloudflare Tunnel

Tunel tworzy bezpieczne połączenie z krawędzi Cloudflare do Twojego serwera - bez otwartych portów, bez konieczności konfiguracji firewalla.

3a. Zainstaluj cloudflared

# Debian/Ubuntu
curl -L https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-amd64.deb \
  -o /tmp/cloudflared.deb
dpkg -i /tmp/cloudflared.deb

3b. Uwierzytelnianie

cloudflared tunnel login
# Opens a browser (or gives you a URL) to authorize with your Cloudflare account

To zapisuje plik cert.pem w katalogu ~/.cloudflared/.

3c. Utwórz tunel

cloudflared tunnel create shopify-log-collector

To generuje Tunnel ID (UUID) i tworzy plik JSON z poświadczeniami w ~/.cloudflared/.

3d. Skonfiguruj tunel

Utwórz ~/.cloudflared/config.yml:

tunnel: <YOUR-TUNNEL-ID>
credentials-file: /root/.cloudflared/<YOUR-TUNNEL-ID>.json

ingress:
  - hostname: log-collector.yourdomain.com
    service: http://localhost:9090
  - service: http_status:404

• hostname: Subdomena, na którą Worker będzie wysyłał logi metodą POST
• service: Kieruje ruch do Twojego odbiornika Node.js na localhost:9090
• Reguła domyślna: Zwraca 404 dla każdej innej nazwy hosta (wymagane przez cloudflared)

3e. Utwórz rekord DNS

cloudflared tunnel route dns shopify-log-collector log-collector.yourdomain.com

To tworzy rekord CNAME w DNS Cloudflare:

log-collector.yourdomain.com  →  <TUNNEL-ID>.cfargotunnel.com

Rekord jest przekierowany przez Cloudflare (pomarańczowa chmurka) - identyfikator tunelu w CNAME nie ma publicznego znaczenia.

3f. Zainstaluj jako usługę systemową

cloudflared service install
systemctl enable --now cloudflared

To kopiuje Twoją konfigurację do /etc/cloudflared/config.yml i tworzy jednostkę systemd.

Zweryfikuj tunel

systemctl status cloudflared
# Should show: active (running)

curl https://log-collector.yourdomain.com/status
# Should return: {"status":"ok"}

Krok 4: Wygeneruj klucz API

Wygeneruj losowy klucz API współdzielony między Worker a odbiornikiem:

openssl rand -hex 32

Ustaw tę wartość:

1. Jako sekret Worker za pomocą wrangler secret put INGEST_API_KEY
2. W linii Environment usługi systemd odbiornika (LOG_API_KEY=…)

Krok 5: Zweryfikuj działanie end-to-end

1. Odwiedź swój sklep Shopify w przeglądarce
2. Sprawdź logi odbiornika:

journalctl -u log-receiver -f
# Should show: Wrote logs-1234567890-abc123.json (1234 bytes)

3. Sprawdź plik logu:

cat /var/log/cdn-requests/logs-*.json | head -1 | python3 -m json.tool

Powinieneś zobaczyć pełny wpis logu ze szczegółami żądania, danymi geolokalizacyjnymi i metrykami wydajności.

Przykładowy wpis logu

{
  "logs": [{
    "timestamp": "2026-03-04T15:19:55.584Z",
    "method": "GET",
    "url": "https://www.yourdomain.com/products/example",
    "path": "/products/example",
    "host": "www.yourdomain.com",
    "userAgent": "Mozilla/5.0 ...",
    "ip": "198.51.100.23",
    "country": "US",
    "city": "Seattle",
    "asn": 16509,
    "asOrganization": "Amazon.com",
    "colo": "SEA",
    "edgeTimeToFirstByteMs": 109,
    "originResponseStatus": 200,
    "cacheCacheStatus": "HIT",
    "botName": "other",
    "botType": "unknown"
  }]
}

Jak działa pełny pipeline logowania Shopify?

Przepływ danych

1. Odwiedzający otwiera https://www.yourdomain.com/products/something
2. Cloudflare kieruje ruch przez Worker
3. Worker pobiera odpowiedź ze źródła Shopify → zwraca ją odwiedzającemu
4. Worker wysyła POST { logs: [entry] } do https://log-collector.yourdomain.com/collect
   (nieblokująco - odwiedzający na to nie czeka)
5. Cloudflare rozwiązuje log-collector.yourdomain.com przez CNAME tunelu
6. Tunel przekazuje żądanie na localhost:9090 na Twoim serwerze
7. Odbiornik weryfikuje X-API-Key, zapisuje plik JSON na dysku

Jakie dane żądań Shopify możesz rejestrować, których Shopify Ci nie pokaże?

Panel administracyjny Shopify pokazuje odsłony stron, zamówienia i źródła poleceń. Nie pokazuje, które boty AI odwiedziły sklep, jakie strony pobrały, skąd pochodziły ani jak szybko serwer odpowiedział. Ta konfiguracja rejestruje ponad 40 pól na żądanie w następujących kategoriach:

Client Hints i Fetch Metadata są szczególnie przydatne do identyfikowania przeglądarek bezgłowych i nieoznakowanych botów - prawdziwe przeglądarki wysyłają te nagłówki, większość botów nie.

Które boty AI odwiedzają Twój sklep Shopify?

Shopify nie rozróżnia między ludzkimi odwiedzającymi a crawlerami AI. Ten Worker klasyfikuje każdy User-Agent w dwie kategorie istotne dla widoczności AI:

Żądania z nierozpoznanych User-Agentów są oznaczane jako other / unknown - możesz je analizować później, aby znaleźć nieoznakowane crawlery. To dane, których Shopify, Google Analytics i większość platform analitycznych SaaS po prostu nie dostarcza.

Jak przechowywać dane botów Shopify w bazie danych do głębszej analizy

Aby uzyskać głębszą analitykę botów, możesz rozszerzyć Worker o logowanie żądań botów do Supabase (lub dowolnej bazy danych) oprócz zapisu na dysku. Dodaj następujące sekrety Worker:

wrangler secret put SUPABASE_URL
wrangler secret put SUPABASE_SERVICE_KEY

Następnie dodaj funkcję logToDatabase(), która wysyła POST do REST API Twojej bazy danych, wywoływaną przez ctx.waitUntil() dla rozpoznanych żądań botów. To daje Ci ustrukturyzowane, możliwe do odpytywania dane o botach obok surowych plików logów.

Jak skonfigurować DNS Cloudflare dla sklepu Shopify z logowaniem żądań

Aby ta konfiguracja działała, Twoja domena musi być przekierowana przez Cloudflare (pomarańczowa chmurka). Typowa konfiguracja DNS Shopify + Cloudflare:

CNAME www wskazuje na Shopify - Cloudflare pośredniczy i buforuje. CNAME log-collector wskazuje na Twój tunel - Cloudflare bezpiecznie kieruje ruch logów do Twojego serwera.

Ważne: Trasa Worker musi odpowiadać proxowanej nazwie hosta (np. www.yourdomain.com/*). Nie uruchomi się na rekordach bez proxy (szara chmurka).

Jak monitorować i utrzymywać pipeline logów Shopify

# Check receiver status
systemctl status log-receiver

# Check tunnel status
systemctl status cloudflared

# Tail live logs
journalctl -u log-receiver -f

# Count stored log files
ls /var/log/cdn-requests/*.json | wc -l

# Check disk usage
du -sh /var/log/cdn-requests/

Rozważ dodanie zadania cron do monitorowania użycia dysku i alertowania, gdy przestrzeń dyskowa zbliża się do limitu.

Najczęściej zadawane pytania

Dlaczego właściciele sklepów Shopify nie mają dostępu do logów serwera?

Shopify to w pełni zarządzana platforma SaaS. Właściciele sklepów nie mają dostępu do podstawowej infrastruktury serwera, co oznacza brak dostępu do surowych logów żądań HTTP, logów dostępu ani logów błędów. Shopify udostępnia własny panel analityczny z odsłonami stron, zamówieniami i danymi o poleceniach, ale nie obejmuje to poszczególnych żądań HTTP, user agentów botów, czasów odpowiedzi ani danych geolokalizacyjnych na poziomie żądania. Żaden plan Shopify, w tym Shopify Plus, nie zapewnia dostępu do surowych logów serwera. Jedynym sposobem na uzyskanie tych danych jest przechwycenie żądań na warstwie CDN, zanim dotrą one do serwerów źródłowych Shopify.

Jak śledzić ruch botów AI w sklepie Shopify?

Ruchu botów AI nie da się śledzić za pomocą Google Analytics, Shopify Analytics ani żadnego narzędzia analitycznego JavaScript po stronie klienta, ponieważ boty AI nie wykonują JavaScript. Jedyną niezawodną metodą jest logowanie żądań po stronie serwera. W przypadku sklepów Shopify oznacza to przechwytywanie żądań na warstwie CDN za pomocą Cloudflare Worker (lub równoważnej funkcji edge na innym CDN). Worker loguje każde przychodzące żądanie, w tym nagłówek User-Agent, który identyfikuje konkretne boty AI, takie jak ChatGPT-User, GPTBot, ClaudeBot, PerplexityBot i inne. Jest to takie samo podejście, jakie stosują powstające platformy “analityki agentów”, ale hostowane samodzielnie i w pełni pod Twoją kontrolą.

Jakie boty AI przeszukują sklepy Shopify w tej chwili?

Według stanu na 2026 rok, główne boty AI odwiedzające sklepy Shopify dzielą się na dwie kategorie. Boty pobierające w czasie rzeczywistym (ChatGPT-User, Claude-User, Perplexity-User) pobierają treści na żądanie podczas rozmów z użytkownikami na żywo. Crawlery treningowe (GPTBot, ClaudeBot, PerplexityBot, Bytespider, Amazonbot, Applebot) zbierają treści według harmonogramu do trenowania modeli i budowania indeksów. Bez logowania po stronie serwera żadne z nich nie pojawiają się w analityce Shopify ani Google Analytics.

Ile pól danych Cloudflare rejestruje na żądanie?

Ta konfiguracja rejestruje ponad 40 pól na żądanie, w tym podstawowe dane żądania (timestamp, method, URL, path, user agent, IP, referer), klasyfikację botów (nazwa i typ bota), dane geolokalizacyjne Cloudflare (country, region, city, postal code, latitude, longitude, timezone, continent), informacje o sieci (ASN, organization, data center, HTTP protocol, TLS version), Client Hints (nagłówki sec-ch-ua pomagające wykrywać przeglądarki bezgłowe), metadane Fetch (nagłówki sec-fetch identyfikujące żądania programistyczne) oraz metryki wydajności (time to first byte, TCP round trip time, cache status, origin response status).

Jak to się ma do wbudowanej analityki Shopify?

Panel analityczny Shopify pokazuje odsłony stron, sesje, współczynniki konwersji i źródła poleceń. Nie pokazuje poszczególnych żądań HTTP, user agentów botów, danych geograficznych na poziomie żądania, metryk wydajności odpowiedzi ani żadnej aktywności botów AI. Google Analytics, z którym Shopify się integruje, ma to samo ograniczenie, ponieważ opiera się na JavaScript po stronie klienta. Ta konfiguracja logowania oparta na Cloudflare rejestruje każde żądanie trafiające na Twoją domenę, w tym te od botów, które nigdy nie wykonują JavaScript, dając Ci pełny obraz, którego narzędzia Shopify nie są w stanie zapewnić.

Czy można użyć tej konfiguracji z innym CDN niż Cloudflare?

Architektura ma zastosowanie do dowolnego edge CDN, który obsługuje funkcje edge i bezpieczne tunelowanie. Cloudflare Workers mają odpowiedniki na innych platformach: Vercel Edge Functions, AWS CloudFront Functions, Fastly Compute i Akamai EdgeWorkers - wszystkie mogą przechwytywać żądania i wysyłać dane logów. Komponent tunelu można zastąpić dowolną metodą bezpiecznego połączenia (tunel SSH, VPN, bezpośredni endpoint HTTPS z listą dozwolonych adresów IP). Podstawowy wzorzec jest taki sam: przechwytuj na krawędzi, loguj asynchronicznie, wysyłaj do własnego odbiornika.