Shopify non ti fornisce i file di log. Ecco una guida tecnica completa per ottenerli con Cloudflare (o qualsiasi Edge CDN).

Un grande punto cieco nell’e-commerce e stato finalmente risolto

Dal giorno in cui Shopify e stato lanciato, la piattaforma ha tenuto i log grezzi del server completamente fuori dalla portata dei proprietari dei negozi. Ottieni funnel di conversione e report sulle vendite. Quello che non ottieni e l’unica cosa che ti dice davvero cosa sta colpendo il tuo server: il log delle richieste HTTP.

Per anni, questo e stato un fastidio minore. Chi si preoccupa dei log grezzi quando hai le visualizzazioni di pagina e i tassi di conversione? Google Analytics traccia i tuoi visitatori umani. La tua piattaforma pubblicitaria traccia le tue campagne. Tutto bene.

Poi e arrivata l’AI.

ChatGPT, Claude, Perplexity, Google AI Overviews, Microsoft Copilot - stanno tutti inviando bot al tuo negozio proprio ora. Alcuni stanno scansionando le tue pagine per costruire dati di addestramento. Altri stanno recuperando il contenuto dei tuoi prodotti in tempo reale per rispondere alla domanda di un cliente. E la beffa? Gli strumenti di analisi tradizionali come Google Analytics non riescono a vedere nulla di tutto cio. Si basano su JavaScript lato client che i bot non eseguono mai. La maggior parte dell’interazione AI con il tuo negozio ti e completamente invisibile.

Questo e il nuovo punto cieco dell’e-commerce. I bot AI non eseguono i tuoi script di tracciamento. Non accettano i cookie. Non appaiono nei tuoi report GA4. Ma stanno assolutamente leggendo le pagine dei tuoi prodotti, inserendo le tue descrizioni nelle risposte generate dall’AI e influenzando se i clienti scopriranno mai il tuo marchio.

Stanno emergendo nuovi strumenti focalizzati sull’“agent analytics” per aiutare i proprietari di siti a comprendere l’attivita dei crawler AI e i referral generati dall’AI attraverso il tracciamento lato server, la classificazione dei bot e la verifica degli IP. Il settore riconosce che il vecchio modello di analisi lato client e fondamentalmente inadeguato per l’era della scoperta di contenuti AI-first. E per questo che abbiamo costruito la WISLR AI Visibility Dashboard - per dare ai brand un quadro chiaro di come le piattaforme AI interagiscono con i loro contenuti, dai tassi di scansione alle richieste di recupero fino al traffico referral guidato dall’AI.

Ma se sei su Shopify, hai un problema unico: non controlli il server. Non puoi installare il tracciamento lato server direttamente. Non puoi consultare i tuoi log di accesso. Non puoi fare grep per GPTBot. L’infrastruttura di Shopify e una scatola nera, e non hanno mostrato alcuna urgenza di aprirla.

Basta cosi. Ecco come riprendere il controllo dei tuoi log.

Questa guida ti accompagna nella costruzione della tua pipeline completa di registrazione delle richieste per un negozio Shopify utilizzando Cloudflare. Ogni richiesta HTTP. Dati geografici completi. Metriche di performance. E soprattutto, rilevamento e classificazione completa dei bot, cosi puoi finalmente vedere esattamente quali sistemi AI stanno visitando il tuo negozio, con quale frequenza e quali pagine interessano loro.

Come funziona la registrazione delle richieste Cloudflare per Shopify?

 Visitor requests your Shopify store
         │
         ▼
 Cloudflare CDN (your domain proxied through Cloudflare)
         │
         ▼
 Cloudflare Worker (runs on every request)
    ├──→ Passes request through to Shopify origin (visitor gets normal response)
    └──→ POSTs a JSON log entry to your log receiver (non-blocking, via ctx.waitUntil)
              │
              ▼
         Cloudflare Tunnel
         (CNAME on your domain → tunnel → localhost on your server)
              │
              ▼
         Node.js HTTP Receiver (localhost:9090)
              │
              ▼
         JSON log files written to disk

Nessuna porta e esposta pubblicamente. Il Cloudflare Tunnel gestisce il trasporto sicuro dal bordo di Cloudflare al tuo server tramite una connessione solo in uscita.

Cosa ti serve per configurare la registrazione delle richieste Shopify?

• Un negozio Shopify con un dominio personalizzato instradato attraverso Cloudflare (cloud arancione abilitato)
• Un server per ricevere i log
• Node.js installato sul server
• Un account Cloudflare con Workers abilitati
• Wrangler CLI installato (npm install -g wrangler)
• Cloudflared installato sul server

Passo 1: Crea il Cloudflare Worker

Il Worker intercetta ogni richiesta sul tuo dominio, la inoltra a Shopify e invia in modo asincrono una voce di log al tuo ricevitore.

1a. Codice sorgente del 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. Configurazione 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" }
]

Sostituisci www.yourdomain.com con il dominio personalizzato del tuo negozio Shopify.

1c. Imposta i segreti del Worker

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

1d. Deploy

npx wrangler deploy

Passo 2: Configura il ricevitore di log sul tuo server

Un server HTTP Node.js minimale che accetta batch di log e li scrive su disco.

2a. Script del ricevitore (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}`);
});

Punti chiave:

• Si lega solo a 127.0.0.1 - non esposto a internet
• Autentica le richieste con un header X-API-Key
• Scrive ogni batch di log come file JSON con timestamp
• Limite di 10MB per payload per richiesta

2b. Servizio systemd

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

Abilita e avvia:

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

Passo 3: Configura il Cloudflare Tunnel

Il tunnel crea una connessione sicura dal bordo di Cloudflare al tuo server - nessuna porta aperta, nessuna regola firewall necessaria.

3a. Installa 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. Autenticazione

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

Questo salva un cert.pem in ~/.cloudflared/.

3c. Crea il Tunnel

cloudflared tunnel create shopify-log-collector

Questo restituisce un Tunnel ID (un UUID) e crea un file JSON di credenziali in ~/.cloudflared/.

3d. Configura il Tunnel

Crea ~/.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: Il sottodominio a cui il tuo Worker inviera i log tramite POST
• service: Instrada verso il tuo ricevitore Node.js su localhost:9090
• Regola catch-all: Restituisce 404 per qualsiasi altro hostname (richiesta da cloudflared)

3e. Crea il record DNS

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

Questo crea un record CNAME nel tuo DNS Cloudflare:

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

Il record e instradato attraverso Cloudflare (cloud arancione) - il Tunnel ID nel CNAME non ha significato pubblico.

3f. Installa come servizio di sistema

cloudflared service install
systemctl enable --now cloudflared

Questo copia la tua configurazione in /etc/cloudflared/config.yml e crea un’unita systemd.

Verifica il Tunnel

systemctl status cloudflared
# Should show: active (running)

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

Passo 4: Genera la tua chiave API

Genera una chiave API casuale condivisa tra il Worker e il ricevitore:

openssl rand -hex 32

Imposta questo valore:

1. Come segreto del Worker tramite wrangler secret put INGEST_API_KEY
2. Nella riga Environment di systemd del ricevitore (LOG_API_KEY=…)

Passo 5: Verifica end-to-end

1. Visita il tuo negozio Shopify in un browser
2. Controlla i log del ricevitore:

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

3. Esamina un file di log:

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

Dovresti vedere una voce di log completa con i dettagli della richiesta, dati geografici e metriche di performance.

Esempio di voce di log

{
  "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"
  }]
}

Come funziona la pipeline completa di registrazione Shopify?

Flusso dei dati

1. Visitor hits https://www.yourdomain.com/products/something
2. Cloudflare routes through the Worker
3. Worker fetches origin response from Shopify → returns it to visitor
4. Worker POSTs { logs: [entry] } to https://log-collector.yourdomain.com/collect
   (non-blocking - visitor doesn't wait for this)
5. Cloudflare resolves log-collector.yourdomain.com via tunnel CNAME
6. Tunnel forwards request to localhost:9090 on your server
7. Receiver validates X-API-Key, writes JSON file to disk

Quali dati delle richieste Shopify puoi catturare che Shopify non ti mostra?

L’admin di Shopify ti mostra visualizzazioni di pagina, ordini e fonti di referral. Non ti mostra quali bot AI hanno visitato il sito, quali pagine hanno recuperato, da dove provenivano o quanto velocemente ha risposto il tuo server. Questa configurazione cattura oltre 40 campi per richiesta nelle seguenti categorie:

Client Hints e Fetch Metadata sono particolarmente utili per identificare browser headless e bot non firmati - i browser reali inviano questi header, la maggior parte dei bot no.

Quali bot AI stanno visitando il tuo negozio Shopify?

Shopify non distingue tra visitatori umani e crawler AI. Questo Worker classifica ogni User-Agent in due categorie rilevanti per la visibilita AI:

Le richieste da User-Agent non riconosciuti sono etichettate come other / unknown - puoi analizzarle in seguito per trovare crawler non firmati. Questi sono dati che Shopify, Google Analytics e la maggior parte delle piattaforme di analisi SaaS semplicemente non forniscono.

Come archiviare i dati dei bot Shopify in un database per un’analisi piu approfondita

Per un’analisi dei bot piu approfondita, puoi estendere il Worker per registrare le richieste dei bot su Supabase (o qualsiasi database) oltre che su disco. Aggiungi questi segreti del Worker:

wrangler secret put SUPABASE_URL
wrangler secret put SUPABASE_SERVICE_KEY

Poi aggiungi una funzione logToDatabase() che effettua un POST all’API REST del tuo database, chiamata tramite ctx.waitUntil() per le richieste di bot conosciuti. Questo ti fornisce dati strutturati e interrogabili sui bot insieme ai file di log grezzi.

Come configurare il DNS Cloudflare per un negozio Shopify con registrazione delle richieste

Perche questa configurazione funzioni, il tuo dominio deve essere instradato attraverso Cloudflare (cloud arancione). Una tipica configurazione DNS Shopify + Cloudflare:

Il CNAME www punta a Shopify - Cloudflare fa da proxy e cache. Il CNAME log-collector punta al tuo tunnel - Cloudflare instrada il traffico dei log in modo sicuro verso il tuo server.

Importante: La route del Worker deve corrispondere all’hostname con proxy (ad es. www.yourdomain.com/*). Non si attivera su record non proxied (cloud grigio).

Come monitorare e mantenere la tua pipeline di log 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/

Considera l’aggiunta di un cron job per monitorare l’utilizzo del disco e ricevere un avviso quando lo spazio di archiviazione si avvicina al limite.

Domande frequenti

Perche i proprietari dei negozi Shopify non possono accedere ai log del server?

Shopify e una piattaforma SaaS completamente gestita. I proprietari dei negozi non hanno accesso all’infrastruttura server sottostante, il che significa nessun accesso ai log grezzi delle richieste HTTP, ai log di accesso o ai log degli errori. Shopify fornisce la propria dashboard di analisi con visualizzazioni di pagina, ordini e dati di referral, ma questa non include le singole richieste HTTP, gli user agent dei bot, i tempi di risposta o i dati geografici a livello di richiesta. Non esiste nessun piano Shopify, incluso Shopify Plus, che fornisca l’accesso ai log grezzi del server. L’unico modo per catturare questi dati e intercettare le richieste a livello CDN prima che raggiungano i server di origine di Shopify.

Come si traccia il traffico dei bot AI su un negozio Shopify?

Il traffico dei bot AI non puo essere tracciato tramite Google Analytics, Shopify Analytics o qualsiasi strumento di analisi JavaScript lato client perche i bot AI non eseguono JavaScript. L’unico metodo affidabile e la registrazione delle richieste lato server. Per i negozi Shopify, questo significa intercettare le richieste a livello CDN utilizzando un Cloudflare Worker (o una funzione edge equivalente su un altro CDN). Il Worker registra ogni richiesta in arrivo, incluso l’header User-Agent, che identifica specifici bot AI come ChatGPT-User, GPTBot, ClaudeBot, PerplexityBot e altri. Questo e lo stesso approccio utilizzato dalle piattaforme emergenti di “agent analytics”, ma self-hosted e completamente sotto il tuo controllo.

Quali bot AI stanno scansionando i negozi Shopify in questo momento?

A partire dal 2026, i principali bot AI che colpiscono i negozi Shopify si dividono in due categorie. I bot di recupero in tempo reale (ChatGPT-User, Claude-User, Perplexity-User) recuperano contenuti su richiesta durante le conversazioni live degli utenti. I crawler di addestramento (GPTBot, ClaudeBot, PerplexityBot, Bytespider, Amazonbot, Applebot) raccolgono contenuti secondo una programmazione per l’addestramento dei modelli e la costruzione degli indici. Senza la registrazione lato server, nessuno di questi appare nelle analisi di Shopify o in Google Analytics.

Quanti campi dati registra Cloudflare per richiesta?

Questa configurazione cattura oltre 40 campi per richiesta, inclusi i dati base della richiesta (timestamp, metodo, URL, percorso, user agent, IP, referer), classificazione dei bot (nome e tipo del bot), dati geografici Cloudflare (paese, regione, citta, codice postale, latitudine, longitudine, fuso orario, continente), informazioni di rete (ASN, organizzazione, data center, protocollo HTTP, versione TLS), client hints (header sec-ch-ua che aiutano a rilevare browser headless), fetch metadata (header sec-fetch che identificano richieste programmatiche) e metriche di performance (tempo al primo byte, tempo di andata e ritorno TCP, stato della cache, stato della risposta di origine).

Come si confronta con le analisi integrate di Shopify?

La dashboard di analisi di Shopify mostra visualizzazioni di pagina, sessioni, tassi di conversione e fonti di referral. Non mostra le singole richieste HTTP, gli user agent dei bot, i dati geografici a livello di richiesta, le metriche di performance della risposta o qualsiasi attivita dei bot AI. Google Analytics, con cui Shopify si integra, ha la stessa limitazione perche si basa su JavaScript lato client. Questa configurazione di registrazione basata su Cloudflare cattura ogni richiesta che tocca il tuo dominio, comprese quelle provenienti da bot che non eseguono mai JavaScript, offrendoti un quadro completo che gli strumenti di Shopify non possono fornire.

Si puo usare questa configurazione con un CDN diverso da Cloudflare?

L’architettura si applica a qualsiasi edge CDN che supporti funzioni edge e tunneling sicuro. I Cloudflare Workers hanno equivalenti su altre piattaforme: Vercel Edge Functions, AWS CloudFront Functions, Fastly Compute e Akamai EdgeWorkers possono tutti intercettare le richieste e inviare i dati di log. Il componente tunnel puo essere sostituito con qualsiasi metodo di connessione sicura (tunnel SSH, VPN, endpoint HTTPS diretto con allowlisting degli IP). Il pattern fondamentale e lo stesso: intercetta al bordo, registra in modo asincrono, invia al tuo ricevitore.