Shopify ne vous donne pas de fichiers de logs. Voici un guide technique complet pour les obtenir avec Cloudflare (ou tout autre CDN Edge).

Un angle mort majeur du e-commerce vient d’etre resolu

Depuis le jour de son lancement, Shopify a toujours tenu les logs bruts du serveur completement hors de portee des proprietaires de boutiques. Vous obtenez des tunnels de conversion et des rapports de ventes. Ce que vous n’obtenez pas, c’est la seule chose qui vous indique reellement ce qui frappe votre serveur : le log des requetes HTTP.

Pendant des annees, c’etait un desagrement mineur. Qui se soucie des logs bruts quand on a les pages vues et les taux de conversion ? Google Analytics suit vos visiteurs humains. Votre plateforme publicitaire suit vos campagnes. Tout va bien.

Puis l’IA est arrivee.

ChatGPT, Claude, Perplexity, Google AI Overviews, Microsoft Copilot - ils envoient tous des bots sur votre boutique en ce moment meme. Certains explorent vos pages pour constituer des donnees d’entrainement. D’autres recuperent le contenu de vos produits en temps reel pour repondre a la question d’un client. Et le plus frappant ? Les outils d’analyse traditionnels comme Google Analytics ne peuvent rien voir de tout cela. Ils reposent sur du JavaScript cote client que les bots n’executent jamais. La majorite des interactions de l’IA avec votre boutique vous est invisible.

C’est le nouvel angle mort du e-commerce. Les bots IA n’executent pas vos scripts de suivi. Ils n’acceptent pas les cookies. Ils n’apparaissent pas dans vos rapports GA4. Mais ils lisent absolument vos pages produits, integrent vos descriptions dans des reponses generees par l’IA, et influencent la facon dont les clients decouvrent votre marque.

De nouveaux outils axes sur l’« analyse des agents » emergent pour aider les proprietaires de sites a comprendre l’activite des robots d’exploration IA et les referrals generes par l’IA grace au suivi cote serveur, a la classification des bots et a la verification des IP. L’industrie reconnait que l’ancien modele d’analyse cote client est fondamentalement inadapte a l’ere de la decouverte de contenu pilotee par l’IA. C’est pourquoi nous avons cree le tableau de bord WISLR AI Visibility - pour donner aux marques une image claire de la facon dont les plateformes d’IA interagissent avec leur contenu, des taux d’exploration aux requetes de recuperation en passant par le trafic de referral genere par l’IA.

Mais si vous etes sur Shopify, vous avez un probleme unique : vous ne controlez pas le serveur. Vous ne pouvez pas installer de suivi cote serveur directement. Vous ne pouvez pas consulter vos logs d’acces. Vous ne pouvez pas chercher GPTBot dans vos fichiers. L’infrastructure de Shopify est une boite noire, et ils n’ont montre aucune urgence a l’ouvrir.

C’est termine. Voici comment reprendre le controle de vos logs.

Ce guide vous accompagne dans la construction de votre propre pipeline complet de journalisation des requetes pour une boutique Shopify en utilisant Cloudflare. Chaque requete HTTP. Toutes les donnees geographiques. Les metriques de performance. Et surtout, une detection et une classification completes des bots, pour que vous puissiez enfin voir exactement quels systemes d’IA visitent votre boutique, a quelle frequence, et quelles pages les interessent.

Comment fonctionne la journalisation des requetes Cloudflare pour 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

Aucun port n’est expose publiquement. Le Cloudflare Tunnel gere le transport securise depuis le reseau edge de Cloudflare vers votre serveur via une connexion sortante uniquement.

De quoi avez-vous besoin pour configurer la journalisation des requetes Shopify ?

• Une boutique Shopify avec un domaine personnalise proxifie via Cloudflare (icone orange activee)
• Un serveur pour recevoir les logs
• Node.js installe sur le serveur
• Un compte Cloudflare avec Workers active
• Wrangler CLI installe (npm install -g wrangler)
• Cloudflared installe sur le serveur

Etape 1 : Creer le Cloudflare Worker

Le Worker intercepte chaque requete sur votre domaine, la proxifie vers Shopify, et envoie de maniere asynchrone une entree de log a votre recepteur.

1a. Code source du 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. Configuration 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" }
]

Remplacez www.yourdomain.com par le domaine personnalise de votre boutique Shopify.

1c. Configurer les secrets du Worker

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

1d. Deployer

npx wrangler deploy

Etape 2 : Configurer le recepteur de logs sur votre serveur

Un serveur HTTP Node.js minimal qui accepte les lots de logs et les ecrit sur le disque.

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

Points cles :

• Se lie a 127.0.0.1 uniquement - non expose a Internet
• Authentifie les requetes avec un en-tete X-API-Key
• Ecrit chaque lot de logs sous forme de fichier JSON horodate
• Limite de 10 Mo par requete

2b. Service systemd

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

Activez et demarrez le service :

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

Etape 3 : Configurer le Cloudflare Tunnel

Le tunnel cree une connexion securisee entre le reseau edge de Cloudflare et votre serveur - aucun port ouvert, aucune regle de pare-feu necessaire.

3a. Installer 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. S’authentifier

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

Cela enregistre un fichier cert.pem dans ~/.cloudflared/.

3c. Creer le tunnel

cloudflared tunnel create shopify-log-collector

Cela genere un Tunnel ID (un UUID) et cree un fichier JSON d’identifiants dans ~/.cloudflared/.

3d. Configurer le tunnel

Creez ~/.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 : Le sous-domaine vers lequel votre Worker enverra les logs en POST
• service : Redirige vers votre recepteur Node.js sur localhost:9090
• Regle de secours : Renvoie une erreur 404 pour tout autre nom d’hote (requis par cloudflared)

3e. Creer l’enregistrement DNS

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

Cela cree un enregistrement CNAME dans votre DNS Cloudflare :

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

L’enregistrement est proxifie via Cloudflare (icone orange) - l’identifiant du tunnel dans le CNAME n’a pas de signification publique.

3f. Installer en tant que service systeme

cloudflared service install
systemctl enable --now cloudflared

Cela copie votre configuration dans /etc/cloudflared/config.yml et cree une unite systemd.

Verifier le tunnel

systemctl status cloudflared
# Should show: active (running)

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

Etape 4 : Generer votre cle API

Generez une cle API aleatoire partagee entre le Worker et le recepteur :

openssl rand -hex 32

Definissez cette valeur :

1. En tant que secret du Worker via wrangler secret put INGEST_API_KEY
2. Dans la ligne Environment de systemd du recepteur (LOG_API_KEY=…)

Etape 5 : Verification de bout en bout

1. Visitez votre boutique Shopify dans un navigateur
2. Verifiez les logs du recepteur :

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

3. Inspectez un fichier de log :

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

Vous devriez voir une entree de log complete avec les details de la requete, les donnees geographiques et les metriques de performance.

Exemple d’entree 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"
  }]
}

Comment fonctionne le pipeline complet de journalisation Shopify ?

Flux de donnees

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

Quelles donnees de requetes Shopify pouvez-vous capturer que Shopify ne vous montrera pas ?

L’interface d’administration de Shopify vous montre les pages vues, les commandes et les sources de referral. Elle ne vous montre pas quels bots IA ont visite, quelles pages ils ont recuperees, d’ou ils venaient, ni la vitesse de reponse de votre serveur. Cette configuration capture plus de 40 champs par requete dans les categories suivantes :

Les Client Hints et les Fetch Metadata sont particulierement utiles pour identifier les navigateurs headless et les bots non signes - les vrais navigateurs envoient ces en-tetes, la plupart des bots ne le font pas.

Quels bots IA visitent votre boutique Shopify ?

Shopify ne fait pas la distinction entre les visiteurs humains et les robots d’exploration IA. Ce Worker classe chaque User-Agent en deux categories pertinentes pour la visibilite IA :

Les requetes provenant de User-Agents non reconnus sont etiquetees other / unknown - vous pouvez les analyser ulterieurement pour trouver des robots d’exploration non signes. Ce sont des donnees que Shopify, Google Analytics et la plupart des plateformes d’analyse SaaS ne fournissent tout simplement pas.

Comment stocker les donnees de bots Shopify dans une base de donnees pour une analyse approfondie

Pour une analyse plus poussee des bots, vous pouvez etendre le Worker pour enregistrer les requetes de bots dans Supabase (ou toute autre base de donnees) en plus du disque. Ajoutez ces secrets au Worker :

wrangler secret put SUPABASE_URL
wrangler secret put SUPABASE_SERVICE_KEY

Ajoutez ensuite une fonction logToDatabase() qui envoie des requetes POST a l’API REST de votre base de donnees, appelee via ctx.waitUntil() pour les requetes de bots connus. Cela vous donne des donnees de bots structurees et interrogeables en complement des fichiers de logs bruts.

Comment configurer le DNS Cloudflare pour une boutique Shopify avec journalisation des requetes

Pour que cette configuration fonctionne, votre domaine doit etre proxifie via Cloudflare (icone orange). Voici une configuration DNS typique Shopify + Cloudflare :

Le CNAME www pointe vers Shopify - Cloudflare proxifie et met en cache. Le CNAME log-collector pointe vers votre tunnel - Cloudflare achemine le trafic de logs de maniere securisee vers votre serveur.

Important : La route du Worker doit correspondre au nom d’hote proxifie (par exemple, www.yourdomain.com/*). Elle ne se declenchera pas sur les enregistrements non proxifies (icone grise).

Comment surveiller et maintenir votre pipeline de logs 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/

Envisagez d’ajouter une tache cron pour surveiller l’utilisation du disque et vous alerter lorsque le stockage approche de votre limite.

Questions frequemment posees

Pourquoi les proprietaires de boutiques Shopify ne peuvent-ils pas acceder aux logs du serveur ?

Shopify est une plateforme SaaS entierement geree. Les proprietaires de boutiques n’ont pas acces a l’infrastructure serveur sous-jacente, ce qui signifie aucun acces aux logs bruts des requetes HTTP, aux logs d’acces ou aux logs d’erreurs. Shopify fournit son propre tableau de bord d’analyse avec les pages vues, les commandes et les donnees de referral, mais cela n’inclut pas les requetes HTTP individuelles, les user agents des bots, les temps de reponse ou les donnees geographiques au niveau de la requete. Aucun plan Shopify, y compris Shopify Plus, ne fournit d’acces aux logs bruts du serveur. La seule facon de capturer ces donnees est d’intercepter les requetes au niveau de la couche CDN avant qu’elles n’atteignent les serveurs d’origine de Shopify.

Comment suivre le trafic des bots IA sur une boutique Shopify ?

Le trafic des bots IA ne peut pas etre suivi via Google Analytics, Shopify Analytics ou tout autre outil d’analyse JavaScript cote client car les bots IA n’executent pas le JavaScript. La seule methode fiable est la journalisation des requetes cote serveur. Pour les boutiques Shopify, cela signifie intercepter les requetes au niveau de la couche CDN en utilisant un Cloudflare Worker (ou une fonction edge equivalente sur un autre CDN). Le Worker enregistre chaque requete entrante, y compris l’en-tete User-Agent, qui identifie les bots IA specifiques comme ChatGPT-User, GPTBot, ClaudeBot, PerplexityBot et d’autres. C’est la meme approche utilisee par les plateformes emergentes d’« analyse des agents », mais auto-hebergee et entierement sous votre controle.

Quels bots IA explorent les boutiques Shopify actuellement ?

En 2026, les principaux bots IA qui visitent les boutiques Shopify se repartissent en deux categories. Les bots de recuperation en temps reel (ChatGPT-User, Claude-User, Perplexity-User) recuperent le contenu a la demande lors de conversations en direct avec les utilisateurs. Les robots d’exploration pour l’entrainement (GPTBot, ClaudeBot, PerplexityBot, Bytespider, Amazonbot, Applebot) collectent le contenu selon un calendrier pour l’entrainement des modeles et la construction d’index. Sans journalisation cote serveur, aucun de ces bots n’apparait dans les analyses de Shopify ni dans Google Analytics.

Combien de champs de donnees Cloudflare enregistre-t-il par requete ?

Cette configuration capture plus de 40 champs par requete, incluant les informations de base de la requete (horodatage, methode, URL, chemin, user agent, IP, referer), la classification des bots (nom et type du bot), les donnees geographiques Cloudflare (pays, region, ville, code postal, latitude, longitude, fuseau horaire, continent), les informations reseau (ASN, organisation, centre de donnees, protocole HTTP, version TLS), les client hints (en-tetes sec-ch-ua qui aident a detecter les navigateurs headless), les fetch metadata (en-tetes sec-fetch qui identifient les requetes programmatiques) et les metriques de performance (temps jusqu’au premier octet, temps d’aller-retour TCP, statut du cache, statut de la reponse d’origine).

Comment cela se compare-t-il aux analyses integrees de Shopify ?

Le tableau de bord d’analyse de Shopify affiche les pages vues, les sessions, les taux de conversion et les sources de referral. Il ne montre pas les requetes HTTP individuelles, les user agents des bots, les donnees geographiques au niveau de la requete, les metriques de performance des reponses, ni aucune activite de bot IA. Google Analytics, que Shopify integre, a la meme limitation car il repose sur du JavaScript cote client. Cette configuration de journalisation basee sur Cloudflare capture chaque requete qui touche votre domaine, y compris celles provenant de bots qui n’executent jamais le JavaScript, vous donnant une image complete que les outils de Shopify ne peuvent pas fournir.

Peut-on utiliser cette configuration avec un CDN autre que Cloudflare ?

L’architecture s’applique a tout CDN edge qui prend en charge les fonctions edge et le tunneling securise. Les Cloudflare Workers ont des equivalents sur d’autres plateformes : Vercel Edge Functions, AWS CloudFront Functions, Fastly Compute et Akamai EdgeWorkers peuvent tous intercepter les requetes et envoyer les donnees de log. Le composant tunnel peut etre remplace par toute methode de connexion securisee (tunnel SSH, VPN, endpoint HTTPS direct avec liste blanche d’IP). Le schema de base est le meme : intercepter au niveau edge, journaliser de maniere asynchrone, envoyer vers votre propre recepteur.