Collecte côté serveur
Le traceur ne voit que les navigateurs qui exécutent le JavaScript. Votre serveur voit tout : robots, scripts, scanners et attaques, avec le code, la taille et la durée de chaque réponse. Trois voies pour l’envoyer à Kreomnis, de la plus simple à la plus complète.
Sur cette page
Ce que la collecte serveur apporte#
- Le journal du trafic complet (Trafic) : les robots qui n’exécutent pas le JavaScript (Googlebot, GPTBot, ClaudeBot, outils SEO…), les scripts et clients HTTP, les scanners et les attaques, les erreurs et les temps de réponse.
- Les rapports Robots et Comportement : les pages, flux et fichiers lus par les robots y entrent aussi.
- L’audience ne change pas : elle reste mesurée par le traceur, et les requêtes envoyées ici n’entrent jamais dans les statistiques d’audience. Gardez donc le traceur.
La collecte côté serveur et les clés d’API dépendent de l’offre de l’espace (voir Offres et abonnement).
Trois voies#
| Voie | Pour qui | Ce qu’elle voit |
|---|---|---|
| Plugin WordPress | Un site WordPress : rien d’autre à installer. | Les requêtes qui passent par WordPress, avec leur code et leur durée : pages, robots, scripts, attaques (wp-login.php, xmlrpc.php, pages absentes). Pas les pages servies par un cache sans passer par WordPress. |
| Journaux d’accès | Vous administrez le serveur web (Caddy, nginx, Apache) : rien à changer dans le code du site. | Tout ce que voit le serveur web : codes, tailles, durées, fichiers statiques et pages en cache compris. |
| Extrait dans l’application | Next.js, Node, PHP, ou tout langage par l’API, quand vous n’avez pas la main sur le serveur web (Vercel, hébergement mutualisé). | Les requêtes qui passent par votre application. |
Deux voies en même temps enverraient les mêmes requêtes deux fois : le journal compterait chaque requête en double.
Le pas-à-pas, avec la commande et les extraits déjà remplis pour votre site, est dans Installation › Collecte côté serveur : tout le trafic.
Ce qui est transmis, ce qui est gardé#
Pour chaque requête : la méthode, le chemin et la requête de l’adresse, l’hôte, le code, la taille et la durée de la réponse, l’adresse IP et le User-Agent du visiteur, le référent (sans sa requête ni son fragment), le protocole, le type de réponse, la première langue demandée et l’en-tête de préchargement (Sec-Purpose).
| Ce qui est mesuré | Node, Next.js (instrumentation) | Next.js (proxy) | PHP, WordPress |
|---|---|---|---|
| Code et durée de la réponse | Oui | Non : le proxy passe avant la réponse | Oui |
| Taille de la réponse | Oui | Non | Si l’application annonce sa taille (Content-Length) |
| Protocole et type de réponse | Oui | Non | Oui |
| Pays fourni par le serveur | Non | Non | WordPress derrière Cloudflare (réglage « proxy ») |
- Paramètres sensibles : leur valeur ne quitte jamais votre serveur, seul leur nom part. Ce sont les paramètres dont le nom contient
pass,pwd,token,secret,nonce,sess,signature,credential, ou vaut exactementkey,code,login,email,mail,user,sid,auth. Les autres valeurs partent : elles servent à repérer les attaques. - Gardé par Kreomnis : ni l’adresse IP (seulement le pays, le réseau et, pour le trafic non humain, le préfixe du réseau), ni la valeur d’aucun paramètre (seulement leurs noms), ni cookie. Les journaux d’accès partent bruts : Kreomnis en tire les mêmes champs et ne garde jamais la ligne. Le détail : Ce qui est gardé et Vie privée et RGPD.
Créer une clé d’API#
- Ouvrez les clés d’API
Installation › Collecte côté serveur : tout le trafic › Clés d’API (propriétaires et administrateurs du site).
- Nommez la clé et créez-la
Par exemple « Serveur de production ». Elle commence par
ki_live_. - Copiez-la tout de suite
Elle ne s’affiche qu’une fois : seule son empreinte est conservée.
- Rangez-la dans une variable d’environnement
KREOMNIS_API_KEY, sur le serveur uniquement.
Jamais dans le code envoyé au navigateur, jamais dans une variable préfixée NEXT_PUBLIC_, jamais dans un fichier servi par le web ni dans un dépôt de code. Une clé exposée se révoque dans la même page : elle cesse de fonctionner en 10 secondes au plus. Vingt clés actives au plus par site.
Le plugin WordPress crée sa propre clé (« Plugin WordPress ») à chaque téléchargement et révoque la précédente. La création d’une clé dépend de l’offre de l’espace ; une clé déjà créée reste valable si l’offre change.
Plugin WordPress#
Le plugin (version 2.2.0) envoie le trafic vu par WordPress selon le réglage Réglages › Kreomnis Indexation › Trafic envoyé à Kreomnis : tout le trafic (par défaut, recommandé), les robots et clients HTTP seulement (sites à très fort trafic), ou rien (le traceur mesure toujours l’audience).
- Après la réponse : la requête part une fois la page envoyée au visiteur (PHP-FPM, LiteSpeed), en 2 secondes au plus. Sous Apache mod_php, qui ne sait pas terminer la réponse avant, seuls les robots partent, sans attendre Kreomnis : vos visiteurs n’attendent jamais.
- Envoyés : pages,
wp-login.php,xmlrpc.php, API REST, appels AJAX des visiteurs, pages absentes, flux, sitemaps. - Jamais envoyés : WP-Cron, WP-CLI, le battement de cœur de l’administration, les pages d’administration consultées par un compte connecté, et les administrateurs connectés (sauf réglage « Compter aussi les visites des administrateurs connectés »).
- Une requête vers Kreomnis par page : au-delà d’environ 10 pages par seconde, la limite de 600 appels par minute et par clé est atteinte. Choisissez alors « robots seulement », ou les journaux d’accès.
- Kreomnis ne répond pas : l’envoi du trafic s’arrête une minute ; votre site fonctionne normalement.
Installation, e-commerce et autres réglages : WordPress et WooCommerce.
Journaux d’accès (Caddy, nginx, Apache)#
Un petit programme, kreomnis-logs.mjs (Node 18 ou plus, aucune dépendance), suit le journal d’accès du serveur web et l’envoie par lots à Kreomnis. Rien à changer dans le code du site.
- Il suit un ou plusieurs fichiers à partir de leur fin (
--depuis-le-debutenvoie aussi ce qu’ils contiennent déjà), et gère la rotation et la troncature des journaux. - Sans fichier, il lit l’entrée standard :
docker logs -f mon-site | node kreomnis-logs.mjs --format caddy. - Il envoie un lot toutes les 2 secondes, ou dès 1 000 lignes (900 Ko au plus).
- Kreomnis indisponible : nouvel essai plus tard, avec un recul jusqu’à 5 minutes (
Retry-Afterrespecté). La file est bornée (--max-lignes, 100 000 lignes par défaut) : pour un fichier, la lecture attend et les lignes restent sur le disque ; pour l’entrée standard, les plus anciennes sont abandonnées et comptées. - Arrêt propre sur
SIGTERMouSIGINT: la file part d’abord.KREOMNIS_APIdoit être en https. Ni la clé ni les lignes du journal ne s’affichent.
1. Le format du journal
Formats lus : le JSON de Caddy, et le format « combined » de nginx et d’Apache, avec ou sans l’hôte en tête et la durée en queue. Une durée avec décimales se lit en secondes ($request_time de nginx), une durée entière en microsecondes (%D d’Apache).
# Caddyfile : un journal JSON pour le site (Caddy 2.8 ou plus pour « mode »)
exemple.fr {
log {
output file /var/log/caddy/exemple.fr.log {
mode 0640
}
format json
}
# … le reste de votre configuration
}
# puis : sudo systemctl reload caddy# /etc/nginx/conf.d/kreomnis.conf : hôte en tête, durée en queue (secondes)
log_format kreomnis '$host $remote_addr - $remote_user [$time_local] "$request" '
'$status $body_bytes_sent "$http_referer" "$http_user_agent" $request_time';
# dans le bloc server { } du site, à côté de l'access_log existant :
access_log /var/log/nginx/kreomnis.log kreomnis;
# puis : sudo nginx -t && sudo systemctl reload nginx
# Le journal par défaut (« combined », /var/log/nginx/access.log) convient aussi, sans durée ni hôte.# /etc/apache2/conf-available/kreomnis.conf (puis : sudo a2enconf kreomnis) : hôte en tête, durée en queue (microsecondes)
LogFormat "%v %h %l %u %t \"%r\" %>s %b \"%{Referer}i\" \"%{User-Agent}i\" %D" kreomnis
# dans le <VirtualHost> du site, à côté du CustomLog existant :
CustomLog ${APACHE_LOG_DIR}/kreomnis.log kreomnis
# puis : sudo apachectl configtest && sudo systemctl reload apache2
# Le journal par défaut (« combined », /var/log/apache2/access.log) convient aussi, sans durée ni hôte.2. Installation et essai
Ici pour nginx ; pour Caddy ou Apache, changez --format et le chemin du journal.
# 1. L'expéditeur : un seul fichier, Node 18 ou plus, aucune dépendance sudo mkdir -p /opt/kreomnis sudo curl -fsSL -o /opt/kreomnis/kreomnis-logs.mjs https://kreomnisindexation.com/kreomnis-logs.mjs # 2. La clé (créée ci-dessus, affichée une seule fois), lisible par root seulement sudo install -m 600 /dev/null /etc/kreomnis-logs.env sudoedit /etc/kreomnis-logs.env # une ligne : KREOMNIS_API_KEY=ki_live_… # 3. Essai au premier plan (Ctrl+C pour arrêter) : chaque lot envoyé s'affiche sudo sh -c 'set -a; . /etc/kreomnis-logs.env; KREOMNIS_API=https://kreomnisindexation.com exec node /opt/kreomnis/kreomnis-logs.mjs --format nginx /var/log/nginx/kreomnis.log'
3. Service permanent (systemd)
# /etc/systemd/system/kreomnis-logs.service [Unit] Description=Kreomnis Indexation : envoi des journaux d'accès After=network-online.target Wants=network-online.target [Service] # Chemin de node : command -v node ExecStart=/usr/bin/node /opt/kreomnis/kreomnis-logs.mjs --format nginx /var/log/nginx/kreomnis.log Environment=KREOMNIS_API=https://kreomnisindexation.com EnvironmentFile=/etc/kreomnis-logs.env DynamicUser=yes # Groupe qui peut lire le journal SupplementaryGroups=adm NoNewPrivileges=yes ProtectSystem=strict ProtectHome=yes PrivateTmp=yes Restart=always RestartSec=10 [Install] WantedBy=multi-user.target # puis : sudo systemctl daemon-reload && sudo systemctl enable --now kreomnis-logs # suivi : journalctl -u kreomnis-logs -f
La clé reste dans /etc/kreomnis-logs.env, lisible par root seulement ; le service tourne sous un compte sans droits, membre du groupe qui lit le journal.
Next.js#
Sur votre propre serveur
next start, sortie standalone, Docker : deux fichiers à la racine du projet (ou dans src/). Node signale lui-même chaque requête et chaque fin de réponse : code, taille et durée sont mesurés sans toucher à vos pages.
// instrumentation.ts, à la racine du projet (ou dans src/), à côté de kreomnis-node.ts.
// Next.js 15 ou 16 sur votre propre serveur (next start, sortie standalone, Docker) : tout le trafic,
// avec le code, la taille et la durée de chaque réponse. Sans effet sur Vercel et en edge (proxy.ts).
// Vous avez déjà un instrumentation.ts ? Ajoutez seulement la ligne « if (…) await import(…) » à votre register.
export async function register() {
if (process.env.NEXT_RUNTIME === 'nodejs') await import('./kreomnis-node');
}
// kreomnis-node.ts, à côté d'instrumentation.ts, qui le charge sur le serveur Node seulement.
// Node signale lui-même chaque requête et chaque fin de réponse (diagnostics_channel) : rien à changer
// dans vos pages ni dans votre proxy. Envoi par lots toutes les 2 s, en arrière-plan ; file bornée,
// vidée à l'arrêt du serveur ; Kreomnis indisponible ne change rien pour vos visiteurs.
// Clé : KREOMNIS_API_KEY dans les variables d'environnement du serveur (jamais préfixée NEXT_PUBLIC_).
import { subscribe } from 'node:diagnostics_channel';
import type { IncomingMessage, ServerResponse } from 'node:http';
import type { Socket } from 'node:net';
const KREOMNIS_API = 'https://kreomnisindexation.com/api/v1/hits';
const KREOMNIS_ROBOTS_ONLY = false; // true : seulement les robots et clients HTTP (sites à très fort trafic)
const KREOMNIS_DURABLE = true; // processus durable : envoi groupé toutes les 2 s ou par 50 requêtes
const KREOMNIS_BOT = /bot|crawl|spider|slurp|preview|fetch|scan|monitor|checker|archiver|headless|gpt|claude|anthropic|perplexity|bytespider|cohere|mistralai|meta-external|google-|-google|googleother|yandex|qwant|yeti\/|ahrefs|semrush|lighthouse|pagespeed|screaming frog|seokicks|barkrowler|seobility|seolyt|w3c|gtmetrix|facebookexternalhit|facebookcatalog|whatsapp|pinterest\/|slack-|embedly|mastodon|bluesky|cardyb|vkshare|uptime|pingdom|statuscake|better stack|site24x7|datadog|newrelic|vercel|checkly|phantomjs|playwright|puppeteer|selenium|webdriver|curl|wget|python|aiohttp|httpx|scrapy|go-http|java\/|okhttp|axios|undici|libwww|guzzle|postman|insomnia|wordpress\/|feedly|feedbin|newsblur|inoreader|rss|sqlmap|nikto|nuclei|zgrab|nmap|dirbuster|gobuster|ffuf|wfuzz|acunetix|nessus|openvas|qualys|zmap|censys|shodan|expanse|netcraft|leakix/i;
const KREOMNIS_SECRET = /pass|pwd|token|secret|nonce|sess|signature|credential|^(?:key|code|login|email|mail|user|sid|auth)$/i;
function kreomnisRegister() {
try {
const g = globalThis as unknown as { kreomnisOn?: boolean };
if (g.kreomnisOn || process.env.NODE_ENV === 'development' || !process.env.KREOMNIS_API_KEY) return;
g.kreomnisOn = true;
const started = new WeakMap<object, number[]>();
subscribe('http.server.request.start', (m) => {
const { request, socket } = m as { request: IncomingMessage; socket: Socket };
started.set(request, [Date.now(), performance.now(), socket.bytesWritten]);
});
subscribe('http.server.response.finish', (m) => {
try {
const { request, response, socket } = m as { request: IncomingMessage; response: ServerResponse; socket: Socket };
const t = started.get(request);
const path = request.url || '/';
// Fichiers internes de Next.js servis sans erreur : ni pages ni robots, rien à apprendre.
if (!t || (response.statusCode < 400 && /^\/(?:_next\/(?:static|image|webpack-hmr)|__nextjs)/.test(path))) return;
const h = request.headers;
const ua = kreomnisStr(h['user-agent']).slice(0, 300);
if (KREOMNIS_ROBOTS_ONLY && !kreomnisRobot(ua)) return;
const len = Number(response.getHeader('content-length'));
kreomnisPush({
ts: new Date(t[0]).toISOString(),
method: request.method || 'GET',
url: kreomnisUrl(path),
host: kreomnisFirst(h['x-forwarded-host'] || h.host, 255),
status: response.statusCode,
bytes: len >= 0 ? len : Math.max(0, socket.bytesWritten - t[2]),
ms: Math.round((performance.now() - t[1]) * 10) / 10,
ip: kreomnisIp(socket.remoteAddress, h['x-real-ip'], h['x-forwarded-for']),
user_agent: ua,
referrer: kreomnisRef(h.referer),
protocol: 'HTTP/' + request.httpVersion,
content_type: kreomnisType(response.getHeader('content-type')),
language: kreomnisLang(h['accept-language']),
purpose: h['next-router-prefetch'] ? 'prefetch' : kreomnisFirst(h['sec-purpose'] || h.purpose || h['x-purpose'], 30),
});
} catch {
// jamais d'erreur visible pour le site
}
});
for (const s of ['SIGTERM', 'SIGINT'] as const) process.prependListener(s, kreomnisStop);
} catch {
// idem
}
}
// Adresse du visiteur : celle de la connexion, sauf si elle est locale ou privée (proxy inverse :
// nginx, Caddy), auquel cas celle que le proxy transmet.
function kreomnisIp(peer: string | undefined, real: unknown, forwarded: unknown) {
const p = (peer || '').replace(/^::ffff:/, '');
if (p && !/^(?:127\.|10\.|192\.168\.|172\.(?:1[6-9]|2\d|3[01])\.|169\.254\.|::1$|f[cd]|fe80:)/i.test(p)) return p;
return kreomnisFirst(real, 64) || kreomnisFirst(forwarded, 64) || p || null;
}
// ---- file d'attente et envoi (rien à modifier ci-dessous) ----
const kq = {
items: [] as string[], // requêtes sérialisées, des plus anciennes aux plus récentes
chars: 0,
next: 0, // pas d'envoi avant cet instant (recul après un échec)
backoff: 0,
at: 0, // échéance de la minuterie en cours
sending: null as Promise<void> | null,
timer: null as ReturnType<typeof setTimeout> | null,
};
function kreomnisPush(hit: Record<string, string | number | null>) {
const s = JSON.stringify(hit);
kq.items.push(s);
kq.chars += s.length;
kreomnisTrim();
if (KREOMNIS_DURABLE) kreomnisSchedule();
}
// File bornée : au-delà de 2000 requêtes (ou 2000000 caractères), les plus anciennes sont abandonnées.
function kreomnisTrim() {
while (kq.items.length > 2000 || kq.chars > 2000000) kq.chars -= (kq.items.shift() || '').length;
}
// Envoi 2 s après la première requête en file, ou dès 50 requêtes ; jamais pendant un recul.
function kreomnisSchedule() {
if (kq.sending || !kq.items.length) return;
const at = Date.now() + Math.max(kq.next - Date.now(), kq.items.length >= 50 ? 0 : 2000);
if (kq.timer) {
if (kq.at <= at) return;
clearTimeout(kq.timer);
}
kq.at = at;
kq.timer = setTimeout(() => {
kq.timer = null;
kreomnisFlush();
}, at - Date.now());
if (typeof kq.timer === 'object' && kq.timer && kq.timer.unref) kq.timer.unref(); // n'empêche jamais l'arrêt
}
// Un envoi à la fois ; ce qui arrive pendant l'envoi part au lot suivant. Ne rejette jamais.
function kreomnisFlush(): Promise<void> {
if (!kq.sending) {
const p: Promise<void> = kreomnisDrain().catch(() => {}).then(() => {
if (kq.sending === p) kq.sending = null;
if (KREOMNIS_DURABLE) {
kq.next = Math.max(kq.next, Date.now() + 1000);
kreomnisSchedule();
}
});
kq.sending = p;
}
return kq.sending;
}
// Sans processus durable : jusqu'à vider la file. Durable : un lot, puis d'autres seulement tant qu'il en
// reste de pleins (retard à rattraper) ; le reste attend la minuterie (un envoi par seconde au plus).
async function kreomnisDrain() {
do {
if (!kq.items.length || Date.now() < kq.next || !(await kreomnisPost())) return;
} while (!KREOMNIS_DURABLE || kq.items.length >= 500 || kq.chars >= 300000);
}
// Un lot : 500 requêtes et 300000 caractères au plus (moins de 1 Mo une fois encodé).
async function kreomnisPost(): Promise<boolean> {
let n = 0;
let size = 0;
while (n < kq.items.length && n < 500 && size + kq.items[n].length < 300000) size += kq.items[n++].length + 1;
const batch = kq.items.splice(0, n);
kq.chars -= size - n;
let status = 0;
try {
const res = await fetch(KREOMNIS_API, {
method: 'POST',
// Jamais de redirection suivie : la clé ne part que vers l'adresse configurée (une 3xx est une erreur de
// réglage, pas une reprise ; un POST redirigé deviendrait un GET et perdrait le lot sans bruit).
redirect: 'manual',
headers: { Authorization: 'Bearer ' + process.env.KREOMNIS_API_KEY, 'Content-Type': 'application/json' },
body: '{"hits":[' + batch.join(',') + ']}',
signal: typeof AbortSignal.timeout === 'function' ? AbortSignal.timeout(5000) : undefined,
});
status = res.status;
await res.arrayBuffer();
} catch {
// Kreomnis injoignable ou trop lent : rien ne change pour le site.
}
// 2xx : reçu. 4xx (sauf 408 et 429) : refusé pour de bon, inutile d'insister. Sinon : on recule.
const retry = status === 0 || status === 408 || status === 429 || status >= 500;
if (retry && KREOMNIS_DURABLE) {
kq.items.unshift(...batch);
kq.chars += size - n;
kreomnisTrim();
}
kq.backoff = retry ? Math.min(300000, kq.backoff * 2 || 2000) : status === 401 || status === 403 ? 600000 : 0;
kq.next = Date.now() + kq.backoff;
return kq.backoff === 0;
}
// ---- lecture de la requête ----
// Valeurs des paramètres sensibles jamais transmises : seul le nom part.
function kreomnisUrl(raw: string) {
const s = raw.slice(0, 2000);
const i = s.indexOf('?');
if (i < 0) return s;
return s.slice(0, i + 1) + s.slice(i + 1).split('&').map((p) => {
const j = p.indexOf('=');
return j > 0 && KREOMNIS_SECRET.test(p.slice(0, j)) ? p.slice(0, j + 1) : p;
}).join('&');
}
const kreomnisStr = (v: unknown) => (Array.isArray(v) ? String(v[0] ?? '') : v == null ? '' : String(v));
const kreomnisFirst = (v: unknown, n: number) => kreomnisStr(v).split(',')[0].trim().slice(0, n) || null;
// Référent : ni la requête ni le fragment.
function kreomnisRef(v: unknown) {
const s = kreomnisStr(v);
const i = s.search(/[?#]/);
return (i < 0 ? s : s.slice(0, i)).slice(0, 500) || null;
}
function kreomnisLang(v: unknown) {
const l = kreomnisStr(v).split(',')[0].split(';')[0].trim();
return /^[A-Za-z0-9-]{1,35}$/.test(l) ? l : null;
}
const kreomnisType = (v: unknown) => kreomnisStr(v).split(';')[0].trim().toLowerCase().slice(0, 100) || null;
const kreomnisRobot = (ua: string) => !ua || !/mozilla\/|opera\//i.test(ua) || KREOMNIS_BOT.test(ua);
function kreomnisStop(signal: NodeJS.Signals) {
const alone = process.listenerCount(signal) === 1;
let done = false;
const end = () => {
if (done) return;
done = true;
if (alone) {
process.removeListener(signal, kreomnisStop);
process.kill(process.pid, signal);
}
};
const deadline = setTimeout(end, 1500);
if (deadline.unref) deadline.unref();
(async () => {
for (let i = 0; i < 10 && kq.items.length && !kq.backoff; i++) {
kq.next = 0;
await kreomnisFlush();
}
})().then(end, end);
}
kreomnisRegister();
Vous avez déjà un instrumentation.ts ? Ajoutez seulement la ligne if (process.env.NEXT_RUNTIME === 'nodejs') await import('./kreomnis-node'); à votre fonction register.
Sur Vercel ou un hébergement sans serveur
proxy.ts pour Next.js 16, middleware.ts pour Next.js 13 à 15. Chaque requête de page et d’API part en arrière-plan (event.waitUntil), sans retarder la réponse ; les fichiers statiques sont exclus par le matcher (robots.txt, sitemaps et PDF restent inclus). Le proxy passe avant la réponse : il ne voit ni le code, ni la taille, ni la durée.
// proxy.ts (Next.js 16) ou middleware.ts (Next.js 13 à 15), à la racine du projet (ou dans src/).
// Pour Vercel et tout hébergement sans serveur : chaque requête de page et d'API (robots, scripts,
// attaques…) part en arrière-plan (event.waitUntil), sans retarder la réponse. Le proxy passe avant le
// rendu : il ne voit ni le code, ni la taille, ni la durée des réponses. Sur votre propre serveur
// (next start, Docker), préférez instrumentation.ts, qui les voit.
// Clé : KREOMNIS_API_KEY dans les variables d'environnement du serveur (jamais préfixée NEXT_PUBLIC_).
// Vous avez déjà un proxy ? Copiez tout jusqu'à « export default » et appelez kreomnis(req, event) au début du vôtre.
import { NextResponse, type NextFetchEvent, type NextRequest } from 'next/server';
const KREOMNIS_API = 'https://kreomnisindexation.com/api/v1/hits';
const KREOMNIS_ROBOTS_ONLY = false; // true : seulement les robots et clients HTTP (sites à très fort trafic)
// Processus durable (next start, Docker) : envoi groupé toutes les 2 s. Sans serveur : au fil des requêtes.
const KREOMNIS_DURABLE = process.env.NEXT_RUNTIME === 'nodejs' && !process.env.VERCEL && !process.env.NETLIFY && !process.env.AWS_LAMBDA_FUNCTION_NAME;
const KREOMNIS_BOT = /bot|crawl|spider|slurp|preview|fetch|scan|monitor|checker|archiver|headless|gpt|claude|anthropic|perplexity|bytespider|cohere|mistralai|meta-external|google-|-google|googleother|yandex|qwant|yeti\/|ahrefs|semrush|lighthouse|pagespeed|screaming frog|seokicks|barkrowler|seobility|seolyt|w3c|gtmetrix|facebookexternalhit|facebookcatalog|whatsapp|pinterest\/|slack-|embedly|mastodon|bluesky|cardyb|vkshare|uptime|pingdom|statuscake|better stack|site24x7|datadog|newrelic|vercel|checkly|phantomjs|playwright|puppeteer|selenium|webdriver|curl|wget|python|aiohttp|httpx|scrapy|go-http|java\/|okhttp|axios|undici|libwww|guzzle|postman|insomnia|wordpress\/|feedly|feedbin|newsblur|inoreader|rss|sqlmap|nikto|nuclei|zgrab|nmap|dirbuster|gobuster|ffuf|wfuzz|acunetix|nessus|openvas|qualys|zmap|censys|shodan|expanse|netcraft|leakix/i;
const KREOMNIS_SECRET = /pass|pwd|token|secret|nonce|sess|signature|credential|^(?:key|code|login|email|mail|user|sid|auth)$/i;
function kreomnis(req: NextRequest, event: NextFetchEvent) {
try {
const h = req.headers;
const ua = (h.get('user-agent') || '').slice(0, 300);
if (!process.env.KREOMNIS_API_KEY || process.env.NODE_ENV === 'development' || (KREOMNIS_ROBOTS_ONLY && !kreomnisRobot(ua))) return;
kreomnisPush({
ts: new Date().toISOString(),
method: req.method,
url: kreomnisUrl(req.nextUrl.pathname + req.nextUrl.search),
host: kreomnisFirst(h.get('x-forwarded-host') || h.get('host') || req.nextUrl.host, 255),
ip: kreomnisFirst(h.get('x-real-ip') || h.get('x-forwarded-for'), 64),
user_agent: ua,
referrer: kreomnisRef(h.get('referer')),
language: kreomnisLang(h.get('accept-language')),
purpose: kreomnisFirst(h.get('sec-purpose') || h.get('purpose') || h.get('x-purpose'), 30),
});
if (!KREOMNIS_DURABLE) event.waitUntil(kreomnisFlush());
} catch {
// jamais d'erreur visible pour le site
}
}
// ---- file d'attente et envoi (rien à modifier ci-dessous) ----
const kq = {
items: [] as string[], // requêtes sérialisées, des plus anciennes aux plus récentes
chars: 0,
next: 0, // pas d'envoi avant cet instant (recul après un échec)
backoff: 0,
at: 0, // échéance de la minuterie en cours
sending: null as Promise<void> | null,
timer: null as ReturnType<typeof setTimeout> | null,
};
function kreomnisPush(hit: Record<string, string | number | null>) {
const s = JSON.stringify(hit);
kq.items.push(s);
kq.chars += s.length;
kreomnisTrim();
if (KREOMNIS_DURABLE) kreomnisSchedule();
}
// File bornée : au-delà de 2000 requêtes (ou 2000000 caractères), les plus anciennes sont abandonnées.
function kreomnisTrim() {
while (kq.items.length > 2000 || kq.chars > 2000000) kq.chars -= (kq.items.shift() || '').length;
}
// Envoi 2 s après la première requête en file, ou dès 50 requêtes ; jamais pendant un recul.
function kreomnisSchedule() {
if (kq.sending || !kq.items.length) return;
const at = Date.now() + Math.max(kq.next - Date.now(), kq.items.length >= 50 ? 0 : 2000);
if (kq.timer) {
if (kq.at <= at) return;
clearTimeout(kq.timer);
}
kq.at = at;
kq.timer = setTimeout(() => {
kq.timer = null;
kreomnisFlush();
}, at - Date.now());
if (typeof kq.timer === 'object' && kq.timer && kq.timer.unref) kq.timer.unref(); // n'empêche jamais l'arrêt
}
// Un envoi à la fois ; ce qui arrive pendant l'envoi part au lot suivant. Ne rejette jamais.
function kreomnisFlush(): Promise<void> {
if (!kq.sending) {
const p: Promise<void> = kreomnisDrain().catch(() => {}).then(() => {
if (kq.sending === p) kq.sending = null;
if (KREOMNIS_DURABLE) {
kq.next = Math.max(kq.next, Date.now() + 1000);
kreomnisSchedule();
}
});
kq.sending = p;
}
return kq.sending;
}
// Sans processus durable : jusqu'à vider la file. Durable : un lot, puis d'autres seulement tant qu'il en
// reste de pleins (retard à rattraper) ; le reste attend la minuterie (un envoi par seconde au plus).
async function kreomnisDrain() {
do {
if (!kq.items.length || Date.now() < kq.next || !(await kreomnisPost())) return;
} while (!KREOMNIS_DURABLE || kq.items.length >= 500 || kq.chars >= 300000);
}
// Un lot : 500 requêtes et 300000 caractères au plus (moins de 1 Mo une fois encodé).
async function kreomnisPost(): Promise<boolean> {
let n = 0;
let size = 0;
while (n < kq.items.length && n < 500 && size + kq.items[n].length < 300000) size += kq.items[n++].length + 1;
const batch = kq.items.splice(0, n);
kq.chars -= size - n;
let status = 0;
try {
const res = await fetch(KREOMNIS_API, {
method: 'POST',
// Jamais de redirection suivie : la clé ne part que vers l'adresse configurée (une 3xx est une erreur de
// réglage, pas une reprise ; un POST redirigé deviendrait un GET et perdrait le lot sans bruit).
redirect: 'manual',
headers: { Authorization: 'Bearer ' + process.env.KREOMNIS_API_KEY, 'Content-Type': 'application/json' },
body: '{"hits":[' + batch.join(',') + ']}',
signal: typeof AbortSignal.timeout === 'function' ? AbortSignal.timeout(5000) : undefined,
});
status = res.status;
await res.arrayBuffer();
} catch {
// Kreomnis injoignable ou trop lent : rien ne change pour le site.
}
// 2xx : reçu. 4xx (sauf 408 et 429) : refusé pour de bon, inutile d'insister. Sinon : on recule.
const retry = status === 0 || status === 408 || status === 429 || status >= 500;
if (retry && KREOMNIS_DURABLE) {
kq.items.unshift(...batch);
kq.chars += size - n;
kreomnisTrim();
}
kq.backoff = retry ? Math.min(300000, kq.backoff * 2 || 2000) : status === 401 || status === 403 ? 600000 : 0;
kq.next = Date.now() + kq.backoff;
return kq.backoff === 0;
}
// ---- lecture de la requête ----
// Valeurs des paramètres sensibles jamais transmises : seul le nom part.
function kreomnisUrl(raw: string) {
const s = raw.slice(0, 2000);
const i = s.indexOf('?');
if (i < 0) return s;
return s.slice(0, i + 1) + s.slice(i + 1).split('&').map((p) => {
const j = p.indexOf('=');
return j > 0 && KREOMNIS_SECRET.test(p.slice(0, j)) ? p.slice(0, j + 1) : p;
}).join('&');
}
const kreomnisStr = (v: unknown) => (Array.isArray(v) ? String(v[0] ?? '') : v == null ? '' : String(v));
const kreomnisFirst = (v: unknown, n: number) => kreomnisStr(v).split(',')[0].trim().slice(0, n) || null;
// Référent : ni la requête ni le fragment.
function kreomnisRef(v: unknown) {
const s = kreomnisStr(v);
const i = s.search(/[?#]/);
return (i < 0 ? s : s.slice(0, i)).slice(0, 500) || null;
}
function kreomnisLang(v: unknown) {
const l = kreomnisStr(v).split(',')[0].split(';')[0].trim();
return /^[A-Za-z0-9-]{1,35}$/.test(l) ? l : null;
}
const kreomnisRobot = (ua: string) => !ua || !/mozilla\/|opera\//i.test(ua) || KREOMNIS_BOT.test(ua);
export default function proxy(req: NextRequest, event: NextFetchEvent) {
kreomnis(req, event);
return NextResponse.next();
}
// Fichiers statiques (images, styles, scripts, polices, médias) exclus ; pages, API, robots.txt, sitemaps et PDF inclus.
export const config = {
matcher: ['/((?!_next/static|_next/image|favicon.ico|.*\\.(?:png|jpe?g|gif|webp|avif|svg|ico|css|js|mjs|map|woff2?|ttf|otf|eot|mp4|webm|mp3|wav|ogg)$).*)'],
};
Vous avez déjà un proxy ? Copiez tout jusqu’à export default et appelez kreomnis(req, event) au début du vôtre. En développement, rien n’est envoyé.
Node.js et Express#
Node 18 ou plus : Express 4 ou 5, Connect, ou tout serveur à middlewares. Collez le bloc après la création de app, avant vos autres app.use. Derrière un proxy (nginx, Caddy, CDN), réglez app.set('trust proxy', 'loopback, linklocal, uniquelocal') pour que req.ip soit l’adresse du visiteur : avec true, ce serait la première adresse de X-Forwarded-For, que le client choisit.
// Node.js 18 ou plus : Express 4 ou 5, Connect, ou tout serveur à middlewares (req, res, next).
// Tout le trafic (pages, API, robots, scripts, attaques) avec le code, la taille et la durée de chaque
// réponse, envoyé par lots en arrière-plan : la réponse n'attend jamais Kreomnis, et Kreomnis
// indisponible ne change rien pour vos visiteurs. File bornée, vidée à l'arrêt du serveur.
// Clé : KREOMNIS_API_KEY dans les variables d'environnement du serveur, jamais dans le code navigateur.
// Collez ce bloc après la création de app, avant vos autres app.use (la durée se mesure à partir d'ici).
// Derrière un proxy (nginx, Caddy, CDN) : app.set('trust proxy', 'loopback, linklocal, uniquelocal')
// pour que req.ip soit l'adresse du visiteur.
const KREOMNIS_API = 'https://kreomnisindexation.com/api/v1/hits';
const KREOMNIS_ROBOTS_ONLY = false; // true : seulement les robots et clients HTTP (sites à très fort trafic)
const KREOMNIS_DURABLE = true; // processus durable : envoi groupé toutes les 2 s ou par 50 requêtes
const KREOMNIS_BOT = /bot|crawl|spider|slurp|preview|fetch|scan|monitor|checker|archiver|headless|gpt|claude|anthropic|perplexity|bytespider|cohere|mistralai|meta-external|google-|-google|googleother|yandex|qwant|yeti\/|ahrefs|semrush|lighthouse|pagespeed|screaming frog|seokicks|barkrowler|seobility|seolyt|w3c|gtmetrix|facebookexternalhit|facebookcatalog|whatsapp|pinterest\/|slack-|embedly|mastodon|bluesky|cardyb|vkshare|uptime|pingdom|statuscake|better stack|site24x7|datadog|newrelic|vercel|checkly|phantomjs|playwright|puppeteer|selenium|webdriver|curl|wget|python|aiohttp|httpx|scrapy|go-http|java\/|okhttp|axios|undici|libwww|guzzle|postman|insomnia|wordpress\/|feedly|feedbin|newsblur|inoreader|rss|sqlmap|nikto|nuclei|zgrab|nmap|dirbuster|gobuster|ffuf|wfuzz|acunetix|nessus|openvas|qualys|zmap|censys|shodan|expanse|netcraft|leakix/i;
const KREOMNIS_SECRET = /pass|pwd|token|secret|nonce|sess|signature|credential|^(?:key|code|login|email|mail|user|sid|auth)$/i;
function kreomnisTraffic(req, res, next) {
try {
const ua = kreomnisStr(req.headers['user-agent']).slice(0, 300);
if (process.env.KREOMNIS_API_KEY && (!KREOMNIS_ROBOTS_ONLY || kreomnisRobot(ua))) {
const t0 = Date.now();
const p0 = performance.now();
const b0 = req.socket ? req.socket.bytesWritten : 0;
res.on('finish', () => {
try {
const h = req.headers;
const len = Number(res.getHeader('content-length'));
kreomnisPush({
ts: new Date(t0).toISOString(),
method: req.method,
url: kreomnisUrl(String(req.originalUrl || req.url || '/')),
host: kreomnisFirst(h['x-forwarded-host'] || h.host, 255),
status: res.statusCode,
bytes: len >= 0 ? len : req.socket ? Math.max(0, req.socket.bytesWritten - b0) : null,
ms: Math.round((performance.now() - p0) * 10) / 10,
ip: kreomnisFirst(req.ip || (req.socket && req.socket.remoteAddress), 64),
user_agent: ua,
referrer: kreomnisRef(h.referer),
protocol: 'HTTP/' + req.httpVersion,
content_type: kreomnisType(res.getHeader('content-type')),
language: kreomnisLang(h['accept-language']),
purpose: kreomnisFirst(h['sec-purpose'] || h.purpose || h['x-purpose'], 30),
});
} catch {
// jamais d'erreur visible pour le site
}
});
}
} catch {
// idem
}
next();
}
// ---- file d'attente et envoi (rien à modifier ci-dessous) ----
const kq = {
items: [], // requêtes sérialisées, des plus anciennes aux plus récentes
chars: 0,
next: 0, // pas d'envoi avant cet instant (recul après un échec)
backoff: 0,
at: 0, // échéance de la minuterie en cours
sending: null,
timer: null,
};
function kreomnisPush(hit) {
const s = JSON.stringify(hit);
kq.items.push(s);
kq.chars += s.length;
kreomnisTrim();
if (KREOMNIS_DURABLE) kreomnisSchedule();
}
// File bornée : au-delà de 2000 requêtes (ou 2000000 caractères), les plus anciennes sont abandonnées.
function kreomnisTrim() {
while (kq.items.length > 2000 || kq.chars > 2000000) kq.chars -= (kq.items.shift() || '').length;
}
// Envoi 2 s après la première requête en file, ou dès 50 requêtes ; jamais pendant un recul.
function kreomnisSchedule() {
if (kq.sending || !kq.items.length) return;
const at = Date.now() + Math.max(kq.next - Date.now(), kq.items.length >= 50 ? 0 : 2000);
if (kq.timer) {
if (kq.at <= at) return;
clearTimeout(kq.timer);
}
kq.at = at;
kq.timer = setTimeout(() => {
kq.timer = null;
kreomnisFlush();
}, at - Date.now());
if (typeof kq.timer === 'object' && kq.timer && kq.timer.unref) kq.timer.unref(); // n'empêche jamais l'arrêt
}
// Un envoi à la fois ; ce qui arrive pendant l'envoi part au lot suivant. Ne rejette jamais.
function kreomnisFlush() {
if (!kq.sending) {
const p = kreomnisDrain().catch(() => {}).then(() => {
if (kq.sending === p) kq.sending = null;
if (KREOMNIS_DURABLE) {
kq.next = Math.max(kq.next, Date.now() + 1000);
kreomnisSchedule();
}
});
kq.sending = p;
}
return kq.sending;
}
// Sans processus durable : jusqu'à vider la file. Durable : un lot, puis d'autres seulement tant qu'il en
// reste de pleins (retard à rattraper) ; le reste attend la minuterie (un envoi par seconde au plus).
async function kreomnisDrain() {
do {
if (!kq.items.length || Date.now() < kq.next || !(await kreomnisPost())) return;
} while (!KREOMNIS_DURABLE || kq.items.length >= 500 || kq.chars >= 300000);
}
// Un lot : 500 requêtes et 300000 caractères au plus (moins de 1 Mo une fois encodé).
async function kreomnisPost() {
let n = 0;
let size = 0;
while (n < kq.items.length && n < 500 && size + kq.items[n].length < 300000) size += kq.items[n++].length + 1;
const batch = kq.items.splice(0, n);
kq.chars -= size - n;
let status = 0;
try {
const res = await fetch(KREOMNIS_API, {
method: 'POST',
// Jamais de redirection suivie : la clé ne part que vers l'adresse configurée (une 3xx est une erreur de
// réglage, pas une reprise ; un POST redirigé deviendrait un GET et perdrait le lot sans bruit).
redirect: 'manual',
headers: { Authorization: 'Bearer ' + process.env.KREOMNIS_API_KEY, 'Content-Type': 'application/json' },
body: '{"hits":[' + batch.join(',') + ']}',
signal: typeof AbortSignal.timeout === 'function' ? AbortSignal.timeout(5000) : undefined,
});
status = res.status;
await res.arrayBuffer();
} catch {
// Kreomnis injoignable ou trop lent : rien ne change pour le site.
}
// 2xx : reçu. 4xx (sauf 408 et 429) : refusé pour de bon, inutile d'insister. Sinon : on recule.
const retry = status === 0 || status === 408 || status === 429 || status >= 500;
if (retry && KREOMNIS_DURABLE) {
kq.items.unshift(...batch);
kq.chars += size - n;
kreomnisTrim();
}
kq.backoff = retry ? Math.min(300000, kq.backoff * 2 || 2000) : status === 401 || status === 403 ? 600000 : 0;
kq.next = Date.now() + kq.backoff;
return kq.backoff === 0;
}
// ---- lecture de la requête ----
// Valeurs des paramètres sensibles jamais transmises : seul le nom part.
function kreomnisUrl(raw) {
const s = raw.slice(0, 2000);
const i = s.indexOf('?');
if (i < 0) return s;
return s.slice(0, i + 1) + s.slice(i + 1).split('&').map((p) => {
const j = p.indexOf('=');
return j > 0 && KREOMNIS_SECRET.test(p.slice(0, j)) ? p.slice(0, j + 1) : p;
}).join('&');
}
const kreomnisStr = (v) => (Array.isArray(v) ? String(v[0] ?? '') : v == null ? '' : String(v));
const kreomnisFirst = (v, n) => kreomnisStr(v).split(',')[0].trim().slice(0, n) || null;
// Référent : ni la requête ni le fragment.
function kreomnisRef(v) {
const s = kreomnisStr(v);
const i = s.search(/[?#]/);
return (i < 0 ? s : s.slice(0, i)).slice(0, 500) || null;
}
function kreomnisLang(v) {
const l = kreomnisStr(v).split(',')[0].split(';')[0].trim();
return /^[A-Za-z0-9-]{1,35}$/.test(l) ? l : null;
}
const kreomnisType = (v) => kreomnisStr(v).split(';')[0].trim().toLowerCase().slice(0, 100) || null;
const kreomnisRobot = (ua) => !ua || !/mozilla\/|opera\//i.test(ua) || KREOMNIS_BOT.test(ua);
function kreomnisStop(signal) {
const alone = process.listenerCount(signal) === 1;
let done = false;
const end = () => {
if (done) return;
done = true;
if (alone) {
process.removeListener(signal, kreomnisStop);
process.kill(process.pid, signal);
}
};
const deadline = setTimeout(end, 1500);
if (deadline.unref) deadline.unref();
(async () => {
for (let i = 0; i < 10 && kq.items.length && !kq.backoff; i++) {
kq.next = 0;
await kreomnisFlush();
}
})().then(end, end);
}
if (process.env.KREOMNIS_API_KEY) for (const s of ['SIGTERM', 'SIGINT']) process.prependListener(s, kreomnisStop);
app.use(kreomnisTraffic);
PHP#
Pour un site PHP sans WordPress (PHP 7.4 et plus, extension curl), en tête de index.php ou pour tous vos fichiers (auto_prepend_file). Une requête vers Kreomnis par page, une fois la page partie (fastcgi_finish_request sous PHP-FPM, litespeed_finish_request), avec 300 ms pour se connecter et 800 ms en tout. Sans fin de réponse anticipée (Apache mod_php, CGI), seuls les robots partent. Après un échec, une minute de pause. Même limite que WordPress : au-delà d’environ 10 pages par seconde, préférez « robots seulement » ou les journaux d’accès.
<?php
// Kreomnis Indexation : tout le trafic d'un site PHP sans WordPress (pages, API, robots, scripts,
// attaques), avec le code et la durée de chaque réponse. Une requête par page, envoyée une fois la page
// partie (fastcgi_finish_request), avec un délai court ; toute erreur est absorbée.
// En tête de index.php, ou pour tous vos fichiers PHP : auto_prepend_file dans php.ini ou .user.ini.
// Clé : variable d'environnement KREOMNIS_API_KEY (PHP-FPM : env[KREOMNIS_API_KEY] dans le pool ;
// nginx : fastcgi_param ; Apache : SetEnv), jamais dans un fichier servi par le web.
if (!function_exists('kreomnis_hit')) {
define('KREOMNIS_ROBOTS_ONLY', false); // true : seulement les robots et clients HTTP (sites à très fort trafic)
function kreomnis_hit()
{
try {
$key = (string) (getenv('KREOMNIS_API_KEY') ?: ($_SERVER['KREOMNIS_API_KEY'] ?? ''));
if (PHP_SAPI === 'cli' || !function_exists('curl_init') || !preg_match('/^[A-Za-z0-9_.-]{8,200}$/', $key)) {
return;
}
// Après une erreur fatale de mémoire ou de temps, ne rien tenter.
$err = error_get_last();
if ($err && preg_match('/Allowed memory size|Maximum execution time/', (string) $err['message'])) {
return;
}
// Kreomnis a échoué il y a moins d'une minute : on n'insiste pas.
$pause = sys_get_temp_dir() . '/kreomnis-pause-' . md5(__FILE__);
if (@is_file($pause) && time() - (int) @filemtime($pause) < 60) {
return;
}
$start = (float) ($_SERVER['REQUEST_TIME_FLOAT'] ?? microtime(true));
$ms = round((microtime(true) - $start) * 1000, 1);
$ua = substr((string) ($_SERVER['HTTP_USER_AGENT'] ?? ''), 0, 300);
$robot = $ua === '' || !preg_match('~mozilla/|opera/~i', $ua) || preg_match('~bot|crawl|spider|slurp|preview|fetch|scan|monitor|checker|archiver|headless|gpt|claude|anthropic|perplexity|bytespider|cohere|mistralai|meta-external|google-|-google|googleother|yandex|qwant|yeti/|ahrefs|semrush|lighthouse|pagespeed|screaming frog|seokicks|barkrowler|seobility|seolyt|w3c|gtmetrix|facebookexternalhit|facebookcatalog|whatsapp|pinterest/|slack-|embedly|mastodon|bluesky|cardyb|vkshare|uptime|pingdom|statuscake|better stack|site24x7|datadog|newrelic|vercel|checkly|phantomjs|playwright|puppeteer|selenium|webdriver|curl|wget|python|aiohttp|httpx|scrapy|go-http|java/|okhttp|axios|undici|libwww|guzzle|postman|insomnia|wordpress/|feedly|feedbin|newsblur|inoreader|rss|sqlmap|nikto|nuclei|zgrab|nmap|dirbuster|gobuster|ffuf|wfuzz|acunetix|nessus|openvas|qualys|zmap|censys|shodan|expanse|netcraft|leakix~i', $ua);
if (KREOMNIS_ROBOTS_ONLY && !$robot) {
return;
}
$status = (int) http_response_code();
$type = null;
$bytes = null;
foreach (headers_list() as $header) {
$colon = (int) strpos($header, ':');
$name = strtolower(trim(substr($header, 0, $colon)));
$value = trim((string) substr($header, $colon + 1));
if ($name === 'content-type') {
$type = strtolower(trim(explode(';', $value)[0]));
} elseif ($name === 'content-length' && ctype_digit($value)) {
$bytes = (int) $value;
}
}
if ($type === null) {
$type = strtolower((string) ini_get('default_mimetype'));
}
// La page part d'abord ; l'envoi à Kreomnis se fait ensuite, hors du temps de réponse.
$finished = false;
if (function_exists('fastcgi_finish_request')) {
$finished = fastcgi_finish_request();
} elseif (function_exists('litespeed_finish_request')) {
$finished = litespeed_finish_request();
}
// Sans fin de réponse anticipée (Apache mod_php, CGI) : les robots seulement, pour que vos
// visiteurs n'attendent jamais.
if (!$finished) {
if (!$robot) {
return;
}
while (ob_get_level() > 0) {
@ob_end_flush();
}
flush();
}
// Requête : sert à repérer les attaques ; Kreomnis n'en garde que les noms de paramètres.
// Valeurs des paramètres sensibles (mots de passe, jetons, e-mails…) jamais transmises.
$uri = substr((string) ($_SERVER['REQUEST_URI'] ?? '/'), 0, 2000);
$qpos = strpos($uri, '?');
if ($qpos !== false) {
$pairs = explode('&', (string) substr($uri, $qpos + 1));
foreach ($pairs as $i => $pair) {
$eq = strpos($pair, '=');
if ($eq && preg_match('~pass|pwd|token|secret|nonce|sess|signature|credential|^(?:key|code|login|email|mail|user|sid|auth)$~i', substr($pair, 0, $eq))) {
$pairs[$i] = substr($pair, 0, $eq + 1);
}
}
$uri = substr($uri, 0, $qpos + 1) . implode('&', $pairs);
}
$ref = (string) ($_SERVER['HTTP_REFERER'] ?? '');
$ref = (string) substr($ref, 0, min(strcspn($ref, '?#'), 500));
$lang = trim(explode(';', explode(',', (string) ($_SERVER['HTTP_ACCEPT_LANGUAGE'] ?? ''))[0])[0]);
$purpose = (string) ($_SERVER['HTTP_SEC_PURPOSE'] ?? ($_SERVER['HTTP_PURPOSE'] ?? ($_SERVER['HTTP_X_PURPOSE'] ?? '')));
$body = json_encode(['hits' => [[
'ts' => gmdate('Y-m-d\TH:i:s', (int) $start) . sprintf('.%03dZ', (int) (($start - floor($start)) * 1000)),
'method' => substr((string) preg_replace('/[^A-Z]/', '', strtoupper((string) ($_SERVER['REQUEST_METHOD'] ?? 'GET'))), 0, 10),
'url' => $uri,
'host' => substr((string) ($_SERVER['HTTP_HOST'] ?? ($_SERVER['SERVER_NAME'] ?? '')), 0, 255),
'status' => $status >= 100 && $status <= 599 ? $status : 200,
'bytes' => $bytes,
'ms' => $ms,
'ip' => isset($_SERVER['REMOTE_ADDR']) ? (string) $_SERVER['REMOTE_ADDR'] : null,
'user_agent' => $ua,
'referrer' => $ref !== '' ? $ref : null,
'protocol' => isset($_SERVER['SERVER_PROTOCOL']) ? substr((string) $_SERVER['SERVER_PROTOCOL'], 0, 16) : null,
'content_type' => $type !== '' ? substr($type, 0, 100) : null,
'language' => preg_match('/^[A-Za-z0-9-]{1,35}$/', $lang) ? $lang : null,
'purpose' => $purpose !== '' ? substr($purpose, 0, 30) : null,
]]], JSON_UNESCAPED_SLASHES | JSON_INVALID_UTF8_SUBSTITUTE);
if (!is_string($body)) {
return;
}
$ch = curl_init('https://kreomnisindexation.com/api/v1/hits');
curl_setopt_array($ch, [
CURLOPT_POST => true,
CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $key, 'Content-Type: application/json'],
CURLOPT_POSTFIELDS => $body,
CURLOPT_RETURNTRANSFER => true,
CURLOPT_NOSIGNAL => true,
CURLOPT_CONNECTTIMEOUT_MS => 300,
CURLOPT_TIMEOUT_MS => 800,
]);
$ok = curl_exec($ch);
$code = (int) curl_getinfo($ch, CURLINFO_RESPONSE_CODE);
if ($ok === false || $code === 429 || $code >= 500) {
@touch($pause);
}
if (PHP_VERSION_ID < 80000) {
curl_close($ch);
}
} catch (\Throwable $e) {
// jamais d'erreur visible pour le site
}
}
// Enregistrée pendant l'arrêt, elle passe après les autres fonctions d'arrêt (pages d'erreur des
// frameworks comprises) : la réponse est complète quand elle la termine.
register_shutdown_function(function () {
register_shutdown_function('kreomnis_hit');
});
}
Autres langages : l’API#
Tout langage capable d’envoyer une requête HTTP peut envoyer des requêtes (/api/v1/hits) ou des lignes de journal (/api/v1/logs) :
# Requêtes vues par votre serveur : POST /api/v1/hits (500 requêtes et 1 Mo au plus par appel).
# Groupez-les : 600 appels par minute et par clé au plus. Seuls url et host sont obligatoires.
curl -X POST https://kreomnisindexation.com/api/v1/hits \
-H "Authorization: Bearer $KREOMNIS_API_KEY" \
-H "Content-Type: application/json" \
--max-time 5 \
-d '{
"hits": [{
"ts": "2026-11-19T10:15:00.120Z",
"method": "GET",
"url": "/produits/pain?tri=prix",
"host": "exemple.fr",
"status": 200,
"bytes": 18432,
"ms": 42.5,
"ip": "IP_DU_VISITEUR",
"user_agent": "USER_AGENT_DU_VISITEUR",
"referrer": "https://www.google.fr/",
"protocol": "HTTP/2.0",
"content_type": "text/html",
"language": "fr-FR"
}]
}'
# Réponse 202 : { "received": 1, "accepted": 1, "rejected": [] }
# Lignes brutes d'un journal d'accès : POST /api/v1/logs (5000 lignes et 1 Mo au plus par appel).
# format : auto, caddy (JSON), nginx ou apache (« combined », hôte en tête et durée en queue facultatifs).
tail -n 1000 /var/log/nginx/access.log | curl -X POST "https://kreomnisindexation.com/api/v1/logs?format=nginx" \
-H "Authorization: Bearer $KREOMNIS_API_KEY" \
-H "Content-Type: text/plain" \
--max-time 10 \
--data-binary @-
# Réponse 202 : { "lines": 1000, "accepted": 990, "skipped": 10 }
# La requête de l'URL sert à repérer les attaques : Kreomnis n'en garde que les noms de paramètres, et aucune adresse IP.Champs, limites, réponses et erreurs : la référence de l’API.
Événements serveur#
Paiement confirmé par webhook, abonnement, commande saisie en administration : envoyez l’événement à /api/v1/events avec l’adresse IP et le User-Agent du visiteur, il rejoint sa visite et sa provenance.
# Clé dans une variable d'environnement (jamais en clair dans un script versionné ni côté navigateur)
curl -X POST https://kreomnisindexation.com/api/v1/events \
-H "Authorization: Bearer $KREOMNIS_API_KEY" \
-H "Content-Type: application/json" \
--max-time 3 \
-d '{
"name": "purchase",
"url": "https://VOTRE-SITE/merci",
"ip": "IP_DU_VISITEUR",
"user_agent": "USER_AGENT_DU_VISITEUR",
"order_id": "A-1001",
"revenue": { "amount": 42.5, "currency": "EUR" },
"items": [{ "id": "SKU-42", "name": "Pain au levain", "price": 4.5, "quantity": 2 }]
}'
# Lot : { "events": [ … ] } (100 au plus, 512 ko au plus). Robots et tout le trafic : /api/v1/hits (collecte côté serveur).
# N'envoyez que l'origine et le chemin de l'URL : la partie ?… peut contenir des données personnelles.Champs et réponses : API d’événements.
Garanties#
- Rien pendant la réponse : l’envoi se fait après (Node, PHP, WordPress) ou en arrière-plan (Next.js). Toute erreur est absorbée : Kreomnis indisponible ne change rien pour vos visiteurs.
- Par lots (extraits JavaScript) : 500 requêtes au plus par envoi, toutes les 2 secondes ou dès 50 requêtes, un envoi à la fois, 5 secondes de délai.
- File bornée : 2 000 requêtes au plus ; au-delà, les plus anciennes sont abandonnées.
- Recul : après un échec passager (réseau, délai, 408, 429, 5xx), le lot revient en file et l’envoi attend 2 secondes, puis le double, jusqu’à 5 minutes ; une clé refusée (401, 403) suspend l’envoi 10 minutes.
- Jamais de redirection suivie : extraits, plugin WordPress et expéditeur des journaux n’envoient la clé qu’à l’adresse de Kreomnis configurée, jamais vers l’adresse d’une redirection.
- Robots seulement :
KREOMNIS_ROBOTS_ONLY = truedans l’extrait (ou le réglage du plugin) n’envoie que les robots et les clients HTTP, pour les sites à très fort trafic. - Débit : 600 appels par minute et par clé, partagés entre
/api/v1/hitset/api/v1/logs.
Une question sans réponse ici ? Consultez les questions fréquentes.