Shopify Nao Fornece Arquivos de Log. Aqui Esta um Guia Tecnico Completo para Obte-los com Cloudflare (ou qualquer Edge CDN).

Um Grande Ponto Cego no E-Commerce Acaba de Ser Resolvido

Desde o dia em que Shopify foi lançado, a plataforma manteve os logs brutos do servidor completamente fora do alcance dos proprietários de lojas. Você recebe funis de conversão e relatórios de vendas. O que você não recebe é a única coisa que realmente mostra o que está acessando seu servidor: o log de requisições HTTP.

Durante anos, isso foi um pequeno incômodo. Quem se importa com logs brutos quando você tem visualizações de página e taxas de conversão? Google Analytics rastreia seus humanos. Sua plataforma de anúncios rastreia suas campanhas. A vida é boa.

Então a IA aconteceu.

ChatGPT, Claude, Perplexity, Google AI Overviews, Microsoft Copilot - todos estão enviando bots para sua loja agora mesmo. Alguns estão rastreando suas páginas para construir dados de treinamento. Outros estão buscando o conteúdo dos seus produtos em tempo real para responder à pergunta de um cliente. E o pior? Ferramentas tradicionais de análise como Google Analytics não conseguem ver nada disso. Elas dependem de JavaScript do lado do cliente que bots nunca executam. A maioria da interação de IA com sua loja é invisível para você.

Este é o novo ponto cego do e-commerce. Bots de IA não executam seus scripts de rastreamento. Não aceitam cookies. Não aparecem nos seus relatórios do GA4. Mas eles estão absolutamente lendo suas páginas de produtos, puxando suas descrições para respostas geradas por IA e moldando se os clientes algum dia descobrirão sua marca.

Novas ferramentas focadas em “análise de agentes” estão surgindo para ajudar proprietários de sites a entender a atividade de crawlers de IA e referências geradas por IA através de rastreamento do lado do servidor, classificação de bots e verificação de IP. A indústria reconhece que o antigo modelo de análise do lado do cliente está fundamentalmente quebrado para a era da descoberta de conteúdo orientada por IA. É por isso que construímos o WISLR AI Visibility Dashboard - para dar às marcas uma visão clara de como as plataformas de IA estão interagindo com seu conteúdo, desde taxas de rastreamento até requisições de busca e tráfego de referência impulsionado por IA.

Mas se você está no Shopify, tem um problema único: você não controla o servidor. Você não pode instalar rastreamento do lado do servidor diretamente. Não pode acessar seus logs de acesso. Não pode fazer grep por GPTBot. A infraestrutura do Shopify é uma caixa preta, e eles não demonstraram nenhuma urgência em abri-la.

Chega. Veja como recuperar seus logs.

Este guia orienta você na construção do seu próprio pipeline completo de registro de requisições para uma loja Shopify usando Cloudflare. Cada requisição HTTP. Dados geográficos completos. Métricas de desempenho. E o mais importante, detecção e classificação completa de bots, para que você possa finalmente ver exatamente quais sistemas de IA estão visitando sua loja, com que frequência e quais páginas lhes interessam.

Como Funciona o Registro de Requisições do Cloudflare para Shopify?

 Visitante faz requisição à sua loja Shopify
         │
         ▼
 Cloudflare CDN (seu domínio proxeado pelo Cloudflare)
         │
         ▼
 Cloudflare Worker (executa em cada requisição)
    ├──→ Passa a requisição para a origem Shopify (visitante recebe resposta normal)
    └──→ Envia via POST uma entrada de log JSON para seu receptor de logs (não bloqueante, via ctx.waitUntil)
              │
              ▼
         Cloudflare Tunnel
         (CNAME no seu domínio → túnel → localhost no seu servidor)
              │
              ▼
         Receptor HTTP Node.js (localhost:9090)
              │
              ▼
         Arquivos de log JSON gravados em disco

Nenhuma porta é exposta publicamente. O Cloudflare Tunnel lida com o transporte seguro da borda do Cloudflare até seu servidor através de uma conexão somente de saída.

O Que Você Precisa para Configurar o Registro de Requisições do Shopify?

• Uma loja Shopify com um domínio personalizado proxeado pelo Cloudflare (nuvem laranja ativada)
• Um servidor para receber logs
• Node.js instalado no servidor
• Uma conta Cloudflare com Workers habilitados
• Wrangler CLI instalado (npm install -g wrangler)
• Cloudflared instalado no servidor

Passo 1: Criar o Cloudflare Worker

O Worker intercepta cada requisição no seu domínio, faz proxy para o Shopify e envia assincronamente uma entrada de log para seu receptor.

1a. Código-fonte do 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. Configuração do 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" }
]

Substitua www.yourdomain.com pelo domínio personalizado da sua loja Shopify.

1c. Definir Secrets do Worker

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

1d. Fazer Deploy

npx wrangler deploy

Passo 2: Configurar o Receptor de Logs no Seu Servidor

Um servidor HTTP mínimo em Node.js que aceita lotes de logs e os grava em disco.

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

Pontos principais:

• Vincula apenas a 127.0.0.1 - não exposto à internet
• Autentica requisições com um cabeçalho X-API-Key
• Grava cada lote de logs como um arquivo JSON com timestamp
• Limite de 10MB de payload por requisição

2b. Serviço systemd

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

Habilitar e iniciar:

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

Passo 3: Configurar o Cloudflare Tunnel

O túnel cria uma conexão segura da borda do Cloudflare até seu servidor - sem portas abertas, sem regras de firewall necessárias.

3a. Instalar o 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. Autenticar

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

Isso salva um cert.pem em ~/.cloudflared/.

3c. Criar o Túnel

cloudflared tunnel create shopify-log-collector

Isso gera um Tunnel ID (um UUID) e cria um arquivo JSON de credenciais em ~/.cloudflared/.

3d. Configurar o Túnel

Crie ~/.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: O subdomínio para o qual seu Worker enviará logs via POST
• service: Roteia para seu receptor Node.js em localhost:9090
• Regra catch-all: Retorna 404 para qualquer outro hostname (exigido pelo cloudflared)

3e. Criar o Registro DNS

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

Isso cria um registro CNAME no seu DNS do Cloudflare:

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

O registro é proxeado pelo Cloudflare (nuvem laranja) - o ID do túnel no CNAME não tem significado público.

3f. Instalar como Serviço do Sistema

cloudflared service install
systemctl enable --now cloudflared

Isso copia sua configuração para /etc/cloudflared/config.yml e cria uma unidade systemd.

Verificar o Túnel

systemctl status cloudflared
# Should show: active (running)

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

Passo 4: Gerar Sua Chave de API

Gere uma chave de API aleatória compartilhada entre o Worker e o receptor:

openssl rand -hex 32

Defina este valor:

1. Como um secret do Worker via wrangler secret put INGEST_API_KEY
2. Na linha Environment do systemd do receptor (LOG_API_KEY=…)

Passo 5: Verificar o Fluxo de Ponta a Ponta

1. Visite sua loja Shopify em um navegador
2. Verifique os logs do receptor:

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

3. Inspecione um arquivo de log:

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

Você deve ver uma entrada de log completa com detalhes da requisição, dados geográficos e métricas de desempenho.

Exemplo de Entrada de 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"
  }]
}

Como Funciona o Pipeline Completo de Logging do Shopify?

Fluxo de Dados

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

Quais Dados de Requisição do Shopify Você Pode Capturar que o Shopify Nao Mostra?

O admin do Shopify mostra visualizações de página, pedidos e fontes de referência. Ele não mostra quais bots de IA visitaram, quais páginas eles buscaram, de onde vieram ou quão rápido seu servidor respondeu. Esta configuração captura mais de 40 campos por requisição nas seguintes categorias:

Client Hints e Fetch Metadata são especialmente úteis para identificar navegadores headless e bots não assinados - navegadores reais enviam esses cabeçalhos, a maioria dos bots não.

Quais Bots de IA Estão Visitando Sua Loja Shopify?

Shopify não distingue entre visitantes humanos e crawlers de IA. Este Worker classifica cada User-Agent em duas categorias que importam para a visibilidade de IA:

Requisições de User-Agents não reconhecidos são marcadas como other / unknown - você pode analisá-las depois para encontrar crawlers não assinados. Estes são dados que Shopify, Google Analytics e a maioria das plataformas de análise SaaS simplesmente não fornecem.

Como Armazenar Dados de Bots do Shopify em um Banco de Dados para Análise Mais Profunda

Para análises de bots mais aprofundadas, você pode estender o Worker para registrar requisições de bots no Supabase (ou qualquer banco de dados) além do disco. Adicione estes secrets ao Worker:

wrangler secret put SUPABASE_URL
wrangler secret put SUPABASE_SERVICE_KEY

Em seguida, adicione uma função logToDatabase() que faz POST para a API REST do seu banco de dados, chamada via ctx.waitUntil() para requisições de bots conhecidos. Isso fornece dados estruturados e consultáveis de bots junto com os arquivos de log brutos.

Como Configurar o DNS do Cloudflare para uma Loja Shopify com Registro de Requisições

Para que esta configuração funcione, seu domínio deve ser proxeado pelo Cloudflare (nuvem laranja). Uma configuração típica de DNS Shopify + Cloudflare:

O CNAME www aponta para o Shopify - Cloudflare faz proxy e cache. O CNAME log-collector aponta para seu túnel - Cloudflare roteia o tráfego de logs com segurança até seu servidor.

Importante: A rota do Worker deve corresponder ao hostname proxeado (ex.: www.yourdomain.com/*). Ele não será acionado em registros não proxeados (nuvem cinza).

Como Monitorar e Manter Seu Pipeline de Logs do 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/

Considere adicionar um cron job para monitorar o uso de disco e alertar quando o armazenamento se aproximar do seu limite.

Perguntas Frequentes

Por que os proprietários de lojas Shopify não podem acessar logs do servidor?

Shopify é uma plataforma SaaS totalmente gerenciada. Os proprietários de lojas não têm acesso à infraestrutura de servidor subjacente, o que significa nenhum acesso a logs brutos de requisições HTTP, logs de acesso ou logs de erro. Shopify fornece seu próprio painel de análise com visualizações de página, pedidos e dados de referência, mas isso não inclui requisições HTTP individuais, user agents de bots, tempos de resposta ou dados geográficos no nível da requisição. Não existe nenhum plano do Shopify, incluindo o Shopify Plus, que forneça acesso a logs brutos do servidor. A única maneira de capturar esses dados é interceptar as requisições na camada CDN antes que elas cheguem aos servidores de origem do Shopify.

Como rastrear tráfego de bots de IA em uma loja Shopify?

O tráfego de bots de IA não pode ser rastreado através do Google Analytics, Shopify Analytics ou qualquer ferramenta de análise baseada em JavaScript do lado do cliente, porque bots de IA não executam JavaScript. O único método confiável é o registro de requisições do lado do servidor. Para lojas Shopify, isso significa interceptar requisições na camada CDN usando um Cloudflare Worker (ou função de borda equivalente em outro CDN). O Worker registra cada requisição recebida, incluindo o cabeçalho User-Agent, que identifica bots de IA específicos como ChatGPT-User, GPTBot, ClaudeBot, PerplexityBot e outros. Esta é a mesma abordagem usada por plataformas emergentes de “análise de agentes”, mas auto-hospedada e totalmente sob seu controle.

Quais bots de IA estão rastreando lojas Shopify agora?

Em 2026, os principais bots de IA acessando lojas Shopify se dividem em duas categorias. Bots de busca em tempo real (ChatGPT-User, Claude-User, Perplexity-User) recuperam conteúdo sob demanda durante conversas ao vivo com usuários. Crawlers de treinamento (GPTBot, ClaudeBot, PerplexityBot, Bytespider, Amazonbot, Applebot) coletam conteúdo em um cronograma para treinamento de modelos e construção de índices. Sem registro do lado do servidor, nenhum desses aparece nas análises do Shopify ou no Google Analytics.

Quantos campos de dados o Cloudflare registra por requisição?

Esta configuração captura mais de 40 campos por requisição, incluindo dados básicos da requisição (timestamp, método, URL, caminho, user agent, IP, referer), classificação de bots (nome e tipo do bot), dados geográficos do Cloudflare (país, região, cidade, código postal, latitude, longitude, fuso horário, continente), informações de rede (ASN, organização, data center, protocolo HTTP, versão TLS), client hints (cabeçalhos sec-ch-ua que ajudam a detectar navegadores headless), fetch metadata (cabeçalhos sec-fetch que identificam requisições programáticas) e métricas de desempenho (tempo até o primeiro byte, tempo de ida e volta TCP, status do cache, status de resposta da origem).

Como isso se compara às análises nativas do Shopify?

O painel de análises do Shopify mostra visualizações de página, sessões, taxas de conversão e fontes de referência. Ele não mostra requisições HTTP individuais, user agents de bots, dados geográficos no nível da requisição, métricas de desempenho de resposta ou qualquer atividade de bots de IA. Google Analytics, que o Shopify integra, tem a mesma limitação porque depende de JavaScript do lado do cliente. Esta configuração de logging baseada em Cloudflare captura cada requisição que toca seu domínio, incluindo aquelas de bots que nunca executam JavaScript, dando a você uma visão completa que as ferramentas do Shopify não conseguem fornecer.

Você pode usar esta configuração com um CDN diferente do Cloudflare?

A arquitetura se aplica a qualquer edge CDN que suporte funções de borda e tunelamento seguro. Cloudflare Workers têm equivalentes em outras plataformas: Vercel Edge Functions, AWS CloudFront Functions, Fastly Compute e Akamai EdgeWorkers podem todos interceptar requisições e enviar dados de log. O componente de túnel pode ser substituído por qualquer método de conexão segura (túnel SSH, VPN, endpoint HTTPS direto com lista de IPs permitidos). O padrão central é o mesmo: interceptar na borda, registrar assincronamente, enviar para seu próprio receptor.