301 lignes
12 KiB
Python
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())
|