Fichiers
meteo-vercors/collecte/statistiques_vercors.py
T

301 lignes
12 KiB
Python

#!/usr/bin/env python3
"""Statistiques de fréquentation de vercors.me, sans cookie ni identifiant (Python standard uniquement).
Lit les journaux d'accès Caddy de vercors.me (JSON, une ligne par requête, déjà anonymisés par le bloc `log`
de deploy/vercors-me-journal.caddy : ni IP, ni cookie, ni en-tête) et publie data/statistiques.json.
Ce qui est compté : les pages vues (GET d'une page HTML répondue en 200 ou 304), hors robots, hors /data/,
/polices/, /tuiles/ et fichiers techniques. Ce qui n'est PAS fait : aucun visiteur unique (rien ne permet de
reconnaître quelqu'un d'une page à l'autre), aucune IP lue ni conservée, aucune valeur individuelle écrite.
Deux fichiers sont écrits :
- l'état privé (--etat) : compteurs agrégés par jour (jamais une ligne de journal), pour garder l'historique
quand Caddy supprime les vieux journaux ;
- la sortie publique (--sortie) : agrégats sur 30 jours, rien sous 5 occurrences (SEUIL).
Relancer le script sur les mêmes journaux ne double rien : chaque jour est recalculé depuis les journaux, et
un jour dont les journaux ont été en partie supprimés n'est jamais diminué.
Usage :
python statistiques_vercors.py --journaux "/var/log/caddy/vercors.me*.log*" \
--etat ~/stats-vercors/etat.json --sortie /srv/vercors.me/data/statistiques.json
options : --maintenant 2026-11-05T10:00:00Z (tests) --jours 30 --historique 90
"""
import argparse
import datetime as dt
import glob
import gzip
import json
import os
import re
import sys
from collections import Counter
from urllib.parse import urlsplit
SEUIL = 5 # rien n'est publié sous 5 occurrences
DOMAINES_PROPRES = {"vercors.me", "www.vercors.me"}
EXTENSIONS_PAGE = {"", ".html"}
PREFIXES_EXCLUS = ("/data/", "/polices/", "/tuiles/")
MAX_CLES_PAR_JOUR = 300 # borne contre les valeurs fabriquées (référents bidons)
JOURS_ETAT = 400
RE_ROBOT = re.compile(r"bot|crawl|spider|slurp|fetch|curl|wget|python|scrapy|headless|monitor|preview|"
r"facebookexternalhit|go-http|java/|okhttp|httpclient|lighthouse|uptime", re.I)
RE_MOBILE = re.compile(r"mobi|android|iphone|ipad|ipod", re.I)
RE_DOMAINE = re.compile(r"^[a-z0-9](?:[a-z0-9.-]{0,98}[a-z0-9])?$")
RE_CHEMIN = re.compile(r"^/[A-Za-z0-9/_.\-]{0,80}$")
RE_LANGUE = re.compile(r"^[a-z]{2,3}$")
# ---------------------------------------------------------------- heure de Paris, sans fuseau installé
def _dernier_dimanche(annee, mois):
d = dt.date(annee, mois, 31)
return d - dt.timedelta(days=(d.weekday() + 1) % 7)
def jour_paris(ts):
"""Date locale (Europe/Paris) d'un horodatage Unix, règle européenne de l'heure d'été."""
u = dt.datetime.fromtimestamp(ts, dt.timezone.utc)
debut = dt.datetime.combine(_dernier_dimanche(u.year, 3), dt.time(1), dt.timezone.utc)
fin = dt.datetime.combine(_dernier_dimanche(u.year, 10), dt.time(1), dt.timezone.utc)
decal = 2 if debut <= u < fin else 1
return (u + dt.timedelta(hours=decal)).date().isoformat()
# ---------------------------------------------------------------- lecture et réduction des lignes
def lignes(chemin):
ouvrir = gzip.open if chemin.endswith(".gz") else open
with ouvrir(chemin, "rt", encoding="utf-8", errors="replace") as f:
for ligne in f:
yield ligne
def page_normalisee(uri):
"""Chemin d'une page ('/', '/a-propos', ...) ou None si ce n'est pas une page."""
chemin = (uri or "").split("?", 1)[0].split("#", 1)[0]
if not chemin.startswith("/") or chemin.startswith(PREFIXES_EXCLUS):
return None
base = chemin.rsplit("/", 1)[-1]
ext = os.path.splitext(base)[1].lower()
if ext not in EXTENSIONS_PAGE:
return None
if chemin.endswith("/index.html"):
chemin = chemin[:-len("index.html")]
elif chemin.endswith(".html"):
chemin = chemin[:-len(".html")]
if len(chemin) > 1:
chemin = chemin.rstrip("/")
return chemin if RE_CHEMIN.match(chemin or "/") else None
def classe_appareil(rec, ua):
"""'robot' | 'mobile' | 'bureau' | None. Le champ ua_classe (posé par Caddy) prime ; sinon le UA brut,
s'il est présent, est classé puis oublié."""
c = rec.get("ua_classe")
if c in ("robot", "mobile", "bureau"):
return c
if ua:
return "robot" if RE_ROBOT.search(ua) else "mobile" if RE_MOBILE.search(ua) else "bureau"
return None
def domaine_referent(valeur):
if not isinstance(valeur, str) or not valeur:
return None
v = valeur.strip().lower()
if "://" in v:
try:
v = urlsplit(v).hostname or ""
except ValueError:
return None
v = v[4:] if v.startswith("www.") else v
return v if RE_DOMAINE.match(v) and "." in v else None
def langue(valeur):
if not isinstance(valeur, str):
return None
m = re.match(r"\s*([A-Za-z]{2,3})", valeur)
l = m.group(1).lower() if m else None
return l if l and RE_LANGUE.match(l) else None
def en_tete(rec, nom):
h = (rec.get("request") or {}).get("headers") or {}
v = h.get(nom)
if isinstance(v, list) and v:
return v[0]
return v if isinstance(v, str) else None
def reduire(rec):
"""Une ligne de journal -> (jour, page, appareil, référent, langue) ou 'robot:jour' ; jamais d'IP.
Retourne None si la ligne ne compte pas."""
req = rec.get("request") or {}
if req.get("method") != "GET" or rec.get("status") not in (200, 304):
return None
hote = (req.get("host") or "vercors.me").lower().split(":")[0]
if hote not in DOMAINES_PROPRES:
return None
page = page_normalisee(req.get("uri"))
ts = rec.get("ts")
if page is None or not isinstance(ts, (int, float)):
return None
appareil = classe_appareil(rec, en_tete(rec, "User-Agent"))
jour = jour_paris(ts)
if appareil == "robot":
return jour, None, "robot", None, None
ref = domaine_referent(rec.get("referent") or en_tete(rec, "Referer"))
if ref in DOMAINES_PROPRES:
ref = "(interne)"
lang = langue(rec.get("langue") or en_tete(rec, "Accept-Language"))
return jour, page, appareil, ref, lang
def jour_vide():
return {"vues": 0, "robots": 0, "pages": {}, "appareils": {}, "referents": {}, "directs": 0, "langues": {}}
def ajouter(d, cle):
if cle in d or len(d) < MAX_CLES_PAR_JOUR:
d[cle] = d.get(cle, 0) + 1
def compter(fichiers):
jours = {}
for chemin in fichiers:
for ligne in lignes(chemin):
try:
rec = json.loads(ligne)
except ValueError:
continue
if not isinstance(rec, dict):
continue
r = reduire(rec)
if r is None:
continue
jour, page, appareil, ref, lang = r
j = jours.setdefault(jour, jour_vide())
if appareil == "robot":
j["robots"] += 1
continue
j["vues"] += 1
ajouter(j["pages"], page)
if appareil:
j["appareils"][appareil] = j["appareils"].get(appareil, 0) + 1
if ref is None:
j["directs"] += 1
elif ref != "(interne)":
ajouter(j["referents"], ref)
if lang:
ajouter(j["langues"], lang)
return jours
# ---------------------------------------------------------------- état privé et sortie publique
def charger_etat(chemin):
try:
with open(chemin, encoding="utf-8") as f:
e = json.load(f)
return e["jours"] if isinstance(e.get("jours"), dict) else {}
except (OSError, ValueError, KeyError, AttributeError):
return {}
def ecrire_atomique(chemin, objet, mode=None):
os.makedirs(os.path.dirname(os.path.abspath(chemin)), exist_ok=True)
tmp = chemin + ".tmp"
with open(tmp, "w", encoding="utf-8") as f:
json.dump(objet, f, ensure_ascii=False, indent=1, sort_keys=True)
f.write("\n")
if mode is not None:
try:
os.chmod(tmp, mode)
except OSError:
pass
os.replace(tmp, chemin)
def fusionner(etat, nouveaux, maintenant_j):
"""Un jour recalculé remplace le jour stocké, sauf s'il en ressort moins (journaux partiellement purgés)."""
for jour, j in nouveaux.items():
ancien = etat.get(jour)
if ancien is None or j["vues"] + j["robots"] >= ancien.get("vues", 0) + ancien.get("robots", 0):
etat[jour] = j
limite = (dt.date.fromisoformat(maintenant_j) - dt.timedelta(days=JOURS_ETAT)).isoformat()
for jour in [k for k in etat if k < limite]:
del etat[jour]
return etat
def somme(jours, champ):
c = Counter()
for j in jours:
c.update(j.get(champ) or {})
return c
def publier(etat, maintenant_dt, nb_jours=30, historique=90):
auj = dt.date.fromisoformat(jour_paris(maintenant_dt.timestamp()))
liste = [(auj - dt.timedelta(days=i)).isoformat() for i in range(historique - 1, -1, -1)]
par_jour = []
for jr in liste:
v = (etat.get(jr) or {}).get("vues", 0)
par_jour.append({"jour": jr, "pages_vues": v if v >= SEUIL else None})
fenetre = [etat[jr] for jr in liste[-nb_jours:] if jr in etat]
total = sum(j["vues"] for j in fenetre)
def classer(compteur, cle, n=10):
return [{cle: k, "vues": v} for k, v in sorted(compteur.items(), key=lambda kv: (-kv[1], kv[0]))
if v >= SEUIL][:n]
app = somme(fenetre, "appareils")
app_tot = sum(app.values())
appareils = {"telephone": None, "ordinateur": None}
if app_tot >= SEUIL:
for cle, nom in (("mobile", "telephone"), ("bureau", "ordinateur")):
if app.get(cle, 0) >= SEUIL:
appareils[nom] = round(100 * app[cle] / app_tot)
langues = somme(fenetre, "langues")
lang_tot = sum(langues.values())
directs = sum(j.get("directs", 0) for j in fenetre)
return {
"genere": maintenant_dt.strftime("%Y-%m-%dT%H:%MZ"),
"periode": {"debut": liste[-nb_jours], "fin": liste[-1], "jours": nb_jours},
"seuil": SEUIL,
"pages_vues_periode": total if total >= SEUIL else None,
"par_jour": par_jour,
"pages_les_plus_vues": classer(somme(fenetre, "pages"), "page"),
"appareils_pct": appareils,
"referents": classer(somme(fenetre, "referents"), "site"),
"acces_directs": directs if directs >= SEUIL else None,
"langues": [{"langue": e["langue"], "pct": round(100 * e["vues"] / lang_tot)}
for e in classer(langues, "langue")] if lang_tot >= SEUIL else [],
}
def main(argv=None):
if hasattr(sys.stdout, "reconfigure"):
sys.stdout.reconfigure(encoding="utf-8")
p = argparse.ArgumentParser(description=__doc__.split("\n")[0])
p.add_argument("--journaux", required=True, help="motif(s) glob des journaux Caddy (.log, .log.gz)", nargs="+")
p.add_argument("--etat", required=True, help="état privé (compteurs agrégés par jour)")
p.add_argument("--sortie", required=True, help="data/statistiques.json")
p.add_argument("--maintenant", help="horodatage ISO UTC forcé (tests)")
p.add_argument("--jours", type=int, default=30)
p.add_argument("--historique", type=int, default=90)
a = p.parse_args(argv)
if a.maintenant:
maintenant_dt = dt.datetime.fromisoformat(a.maintenant.replace("Z", "+00:00"))
else:
maintenant_dt = dt.datetime.now(dt.timezone.utc)
fichiers = sorted({f for motif in a.journaux for f in glob.glob(os.path.expanduser(motif))})
etat = fusionner(charger_etat(a.etat), compter(fichiers), jour_paris(maintenant_dt.timestamp()))
ecrire_atomique(a.etat, {"jours": etat}, 0o600)
ecrire_atomique(a.sortie, publier(etat, maintenant_dt, a.jours, a.historique), 0o644)
print("journaux lus : %d ; jours en état : %d ; sortie : %s" % (len(fichiers), len(etat), a.sortie))
return 0
if __name__ == "__main__":
sys.exit(main())