Compare commits

...
4 Commits
Author SHA1 Message Date
Romulus21andClaude Opus 5.5 981b28c058 Compteurs par niveau, barre de filtres collante et fenêtre de détail des entrées
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 10:03:35 +02:00
Romulus21andClaude Opus 5.5 e44e0fd162 Rafraîchissement par projet, nom obligatoire et fichiers anciens masqués
- Chaque projet choisit sa fréquence de relecture (jamais, 5 s … 1 h) ; le
  serveur ne relit que les projets dus, le fichier affiché est toujours à
  jour. Le réglage global et sa page disparaissent (migration de l'ancien
  intervalle vers chaque projet).
- Le nom du projet est obligatoire, proposé d'après le chemin.
- Les fichiers non modifiés depuis N jours peuvent être masqués ; ils ne
  comptent plus dans les non-lus et réapparaissent dès qu'ils changent.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-21 13:24:11 +02:00
Romulus21andClaude Opus 5.5 86c8f1bb49 Projets génériques, logs Apache du vhost et fenêtre de projet
- Un projet est un dossier quelconque avec ses dossiers de logs (proposés
  d'après le projet : storage/logs, var/log, logs…) ; le format de chaque
  fichier est détecté (Monolog, erreurs Apache, accès, une ligne par entrée).
- Le vhost Apache d'un projet ajoute ses ErrorLog et CustomLog ; les logs
  d'accès ne comptent jamais dans les non-lus.
- Ajout, modification et retrait d'un projet dans une fenêtre modale.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-21 12:53:01 +02:00
Romulus21andClaude Opus 5.5 6af0bbe0c0 Makefile de déploiement local
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-21 11:33:21 +02:00
18 changed files with 2803 additions and 447 deletions

No files matched your search

+124 -47
View File
@@ -9,17 +9,18 @@
Logs Reader est une application web **locale et mono-utilisateur** qui permet à un développeur de :
1. enregistrer un ou plusieurs projets Laravel par leur chemin sur le disque ;
2. voir tous les fichiers de log de chaque projet et en lire les entrées ;
1. enregistrer un ou plusieurs projets (Laravel, Symfony, Node… : n'importe quel dossier) par leur chemin sur le disque et leurs dossiers de logs ;
2. voir tous les fichiers de log de chaque projet et en lire les entrées, y compris les logs Apache du vhost du projet ;
3. être prévenu, via le **favicon** et le titre de l'onglet, de toute nouvelle entrée apparue depuis sa dernière consultation ;
4. choisir l'intervalle de rafraîchissement.
4. choisir, pour chaque projet, la fréquence de relecture de ses logs.
### 1.1 Périmètre
| Dans le périmètre | Hors périmètre (v1) |
|---|---|
| Fichiers de log sur le disque local | Logs distants (SSH, S3, Papertrail…) |
| Format Monolog par défaut de Laravel (`single`, `daily`, channels custom en fichier) | Formats JSON, syslog, stderr |
| Formats Monolog (Laravel, Symfony), erreurs Apache, accès Apache/nginx, et tout format texte (une ligne par entrée), détectés par fichier | Découpage des entrées JSON multi-lignes, syslog, stderr |
| Logs Apache (`ErrorLog`, `CustomLog`) déclarés par le vhost d'un projet | Fichiers rotés (`.1`, `.gz`), logs envoyés à un programme (`\|…`) ou à syslog |
| Lecture seule des logs | Édition, suppression ou vidage des logs |
| Un seul utilisateur, sans authentification | Comptes, rôles, partage |
| Notification par favicon et titre d'onglet | E-mail, Slack, notifications natives de l'OS |
@@ -30,17 +31,20 @@ Logs Reader est une application web **locale et mono-utilisateur** qui permet à
| Terme | Définition |
|---|---|
| **Projet** | Un projet Laravel enregistré, identifié par son chemin racine **canonique** (absolu, symlinks résolus, sans `/` final). |
| **Répertoire de logs** | `<racine>/storage/logs`. |
| **Fichier de log** | Tout fichier `*.log` situé (récursivement) dans le répertoire de logs. |
| **Entrée** | Une écriture de log. Elle commence par une ligne d'en-tête Monolog et contient toutes les lignes suivantes jusqu'à la prochaine ligne d'en-tête (stack trace comprise). |
| **Ligne d'en-tête** | Ligne qui correspond à `^\[(\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:[+-]\d{2}:?\d{2})?)\] (\w+)\.(\w+): ` → horodatage, environnement, niveau. |
| **Projet** | Un dossier enregistré, identifié par son chemin racine **canonique** (absolu, symlinks résolus, sans `/` final). |
| **Dossier de logs** | Sous-dossier du projet déclaré par l'utilisateur (`storage/logs`, `var/log`, `logs`…), relatif à la racine. |
| **Format** | Manière de découper un fichier en entrées : `monolog`, `apache_error`, `access` ou `lines`, détectée sur ses premières lignes (cf. 5.3). |
| **Fichier de log** | Tout fichier `*.log` situé (récursivement) dans un dossier de logs, ou déclaré par le vhost (cf. 5.8). |
| **Entrée** | Une écriture de log. Elle commence par une ligne d'en-tête (selon le format) et contient toutes les lignes suivantes jusqu'à la prochaine ligne d'en-tête (stack trace comprise). |
| **Ligne d'en-tête Monolog** | Ligne qui correspond à `^\[(\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:[+-]\d{2}:?\d{2})?)\] (\w+)\.(\w+): ` → horodatage, environnement, niveau. |
| **Niveau** | L'un des niveaux PSR-3 : `DEBUG`, `INFO`, `NOTICE`, `WARNING`, `ERROR`, `CRITICAL`, `ALERT`, `EMERGENCY`. |
| **Entrée complète** | Une entrée suivie d'une autre ligne d'en-tête, ou, pour la dernière du fichier, terminée par `\n` dans un fichier non modifié depuis 1 s. |
| **Offset de scan** | Position (en octets) jusqu'à laquelle le fichier a été lu et découpé en entrées complètes. |
| **Curseur de lecture** | Position (en octets) de fin de la dernière entrée **consultée** par l'utilisateur, une par fichier. |
| **Non-lu** | Une entrée complète qui commence à un offset ≥ curseur de lecture. |
| **Intervalle** | Délai en secondes entre deux rafraîchissements côté client. |
| **Intervalle** | Délai entre deux relectures automatiques des logs d'un projet, choisi par projet : jamais, 5 s, 15 s, 30 s, 1 min, 5 min, 15 min, 30 min ou 1 h. |
| **Vhost** | Fichier de configuration Apache rattaché à un projet (au plus un), identifié par son chemin canonique. |
| **Log Apache** | Fichier déclaré par une directive `ErrorLog` (log d'erreurs) ou `CustomLog`/`TransferLog` (log d'accès) du vhost. |
---
@@ -60,12 +64,12 @@ Logs Reader est une application web **locale et mono-utilisateur** qui permet à
│ - Repository SQLite (sqlx, migrations) │
└──────┬───────────────────────────┬─────────┘
│ lecture seule │
<projet>/storage/logs/*.log data.sqlite
<projet>/<dossiers>/*.log data.sqlite
```
- **Build** : `cargo-leptos` (features `ssr` / `hydrate`), Tailwind CSS intégré via la config `tailwind-input-file` de cargo-leptos.
- **Persistance** : SQLite via `sqlx`, migrations embarquées (`sqlx::migrate!`) appliquées au démarrage, `PRAGMA foreign_keys = ON`, mode WAL.
- **Scan** : déclenché par chaque appel `unread_summary` (donc au rythme du polling). Les scans concurrents d'un même projet sont sérialisés (mutex par projet) ; un appel qui arrive pendant un scan attend son résultat au lieu d'en relancer un.
- **Scan** : déclenché par chaque appel `unread_summary` (donc au rythme du polling) pour les projets dont l'intervalle est écoulé (cf. 5.5), et par `read_entries` pour le projet du fichier affiché. Les scans concurrents d'un même projet sont sérialisés (mutex par projet) ; un appel qui arrive pendant un scan attend son résultat au lieu d'en relancer un.
- **Configuration** (variables d'environnement) :
- `LOGS_READER_DATABASE_URL` — défaut `sqlite://./logs_reader.sqlite?mode=rwc`
- `LOGS_READER_ADDR` — défaut `127.0.0.1:3000`
@@ -76,13 +80,15 @@ Chaque fonction est exposée en `POST /api/<nom>`.
| Fonction | Entrée | Sortie |
|---|---|---|
| `add_project` | `path: String`, `name: Option<String>` | `Project` |
| `add_project` | `path`, `name`, `refresh_seconds`, `hide_after_days` (vide = aucun), `log_dirs` (un par ligne), `vhost` (vides = défaut / aucun) | `()` |
| `update_project` | `project_id`, `path`, `name`, `refresh_seconds`, `hide_after_days`, `log_dirs`, `vhost` (vhost vide = retirer) | `()` |
| `suggest_log_dirs` | `path` | `Vec<String>` (cf. 5.1) |
| `remove_project` | `project_id` | `()` |
| `read_entries` | `file_id`, `limit` (≤ 2000), `levels: Vec<String>`, `query: String` | `EntriesPage { entries, has_more, scan_offset, read_offset, levels }` |
| `mark_read` | `file_id`, `up_to` | `()` |
| `mark_all_read` | `project_id: Option<_>` | `()` |
| `unread_summary` | — | `Summary { total, projects[{…, unread, files[{…, unread}]}] }` |
| `get_settings` / `set_refresh_interval` | `seconds: String` | `Settings { refresh_interval_seconds, file_sort }` |
| `get_settings` | — | `Settings { file_sort, paused }` |
| `set_paused` | `paused: bool` | `()` |
| `set_file_sort` | `sort: "name" \| "modified"` | `()` |
@@ -95,13 +101,21 @@ CREATE TABLE projects (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
root_path TEXT NOT NULL UNIQUE, -- chemin canonique
last_error TEXT, -- projet introuvable sur le disque
vhost_path TEXT, -- vhost Apache, chemin canonique
vhost_error TEXT, -- vhost illisible
log_dirs TEXT NOT NULL DEFAULT 'storage/logs', -- dossiers de logs, un par ligne
refresh_seconds INTEGER NOT NULL DEFAULT 5, -- 0 (jamais), 5, 15, 30, 60, 300, 900, 1800, 3600
hide_after_days INTEGER, -- masque les fichiers plus anciens ; NULL = aucun
created_at TEXT NOT NULL
);
CREATE TABLE log_files (
id INTEGER PRIMARY KEY,
project_id INTEGER NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
relative_path TEXT NOT NULL, -- relatif à storage/logs
relative_path TEXT NOT NULL, -- relatif à la racine ; absolu pour un log Apache
kind TEXT NOT NULL, -- origine : 'project' | 'apache_error' | 'apache_access'
format TEXT, -- 'monolog' | 'apache_error' | 'access' | 'lines' ; NULL = pas encore détecté
file_identity TEXT, -- inode+device (Unix) / file index (Windows)
size INTEGER NOT NULL DEFAULT 0,
modified_at INTEGER, -- mtime, secondes Unix (tri)
@@ -132,7 +146,7 @@ CREATE TABLE settings (
key TEXT PRIMARY KEY,
value TEXT NOT NULL
);
-- valeurs initiales : ('refresh_interval_seconds', '5'), ('file_sort', 'name')
-- valeurs : ('file_sort', 'name' | 'modified'), ('paused', '0' | '1')
```
- Le **contenu** des entrées n'est pas stocké : il est relu dans le fichier à partir de `start_offset`/`end_offset`. L'index permet compteurs, filtres par niveau et pagination sans tout relire.
@@ -146,15 +160,26 @@ CREATE TABLE settings (
1. Le chemin saisi est nettoyé (trim) ; `~` en tête est remplacé par `$HOME`.
2. Il est canonicalisé (`std::fs::canonicalize`).
3. Il est valide si : c'est un répertoire, il contient un fichier `artisan` **et** un répertoire `storage/logs` lisible.
4. Le nom par défaut est le nom du dernier segment du chemin.
5. Les fichiers de log existants sont découverts et indexés. **Leur curseur de lecture est placé à la fin** (`read_offset = scan_offset`) : l'historique n'est pas compté comme non-lu.
3. Il est valide si c'est un répertoire (aucun fichier particulier n'est exigé).
4. Le nom est obligatoire (« Veuillez saisir un nom. ») ; la fenêtre propose le dernier segment du chemin tant que l'utilisateur ne l'a pas saisi lui-même.
5. **Dossiers de logs** : un par ligne (ou séparés par des virgules), relatifs à la racine ; espaces, `./` en tête et `/` final retirés, doublons ignorés. Chacun doit être un sous-dossier (ni `.`, ni `..`, ni chemin absolu) existant et lisible.
6. **Proposition** : quand le chemin est saisi (et tant que l'utilisateur n'a pas modifié le champ), la fenêtre propose les dossiers existants parmi : `storage/logs` si `artisan` existe (Laravel), `var/log` si `bin/console` existe (Symfony), puis `storage/logs`, `var/log`, `var/logs`, `logs`, `log`.
7. Un vhost Apache peut être indiqué (optionnel, cf. 5.8). Il faut au moins un dossier de logs ou un vhost. Si un champ est invalide, rien n'est enregistré.
8. Les fichiers de log existants sont découverts et indexés. **Leur curseur de lecture est placé à la fin** (`read_offset = scan_offset`) : l'historique n'est pas compté comme non-lu.
### 5.1 bis Modification d'un projet
- Le nom, le chemin, les dossiers de logs et le vhost se modifient avec les mêmes règles qu'à l'ajout (nom obligatoire ; vhost vide → aucun vhost).
- Un nouveau chemin déjà enregistré par un autre projet est refusé (« Ce projet est déjà enregistré. »).
- Changer de chemin supprime les fichiers suivis de l'ancien chemin ; ceux du nouveau sont indexés avec leur curseur en fin de fichier. Retirer un dossier de logs supprime ses fichiers. Les fichiers qui deviennent suivis (nouveau chemin, nouveau dossier, nouveau vhost) ne comptent pas leur historique en non-lu ; les autres gardent leurs curseurs.
- La modification et le scan qui suit se font sous le verrou du scanner.
### 5.2 Découverte des fichiers
- Parcours récursif de `storage/logs`, à chaque scan.
- Parcours récursif de chaque dossier de logs, à chaque scan ; rien d'autre du projet n'est parcouru (`vendor/`, `node_modules/`… sont ignorés sauf s'ils sont déclarés). Deux dossiers imbriqués ne suivent un fichier qu'une fois.
- Retenus : fichiers réguliers dont le nom se termine par `.log`. Ignorés : fichiers cachés (`.gitignore`…), répertoires, autres extensions (`.gz`…).
- Liens symboliques : suivis uniquement si la cible canonique reste sous `storage/logs`.
- Liens symboliques : suivis uniquement si la cible canonique reste sous le même dossier de logs.
- Si la racine ou un dossier de logs disparaît, le projet est marqué en erreur et ses fichiers restent en l'état jusqu'au retour du dossier (E09).
- Un fichier **apparu après l'ajout du projet** (ex. nouveau `laravel-2026-10-22.log` en mode daily) est créé avec `read_offset = 0` : tout son contenu est non-lu.
- Un fichier disparu reçoit `missing_since` ; ses entrées ne comptent plus dans les non-lus ; il réapparaît normalement s'il revient (traité comme une rotation, cf. 5.4).
@@ -162,7 +187,9 @@ CREATE TABLE settings (
- Le fichier est ouvert en **lecture seule**, lu à partir de `scan_offset` par blocs (ex. 64 Kio), sans jamais le charger en entier.
- Les octets sont décodés en UTF-8 avec remplacement (`from_utf8_lossy`) ; les offsets restent des offsets d'octets.
- **Détection du format** : à la première lecture d'un fichier du projet (et après une rotation), sur ses 50 premières lignes complètes (64 Kio au plus) : `monolog` si l'une est une ligne d'en-tête Monolog, sinon `apache_error` si l'une est un en-tête d'erreur Apache, sinon `access` si l'une est une ligne de log d'accès (`common`/`combined`), sinon `lines`. Un fichier sans ligne complète non vide n'est pas indexé ; la détection est retentée au scan suivant. Les fichiers du vhost ont le format de leur directive.
- Une ligne d'en-tête ouvre une nouvelle entrée. Toute autre ligne est rattachée à l'entrée courante.
- **Format `lines`** : toute ligne non indentée ouvre une entrée ; une ligne qui commence par un espace ou une tabulation (stack trace Python, Java, Node…) est rattachée à la précédente. Date : la première `YYYY-MM-DD[ T]HH:MM:SS` dans les 40 premiers caractères, sinon la date de modification. Niveau : le premier mot `EMERGENCY`, `ALERT`, `CRITICAL`/`CRIT`/`FATAL`, `ERROR`/`ERR`, `WARNING`/`WARN`, `NOTICE`, `INFO`, `DEBUG`/`TRACE` en majuscules, ou `level=…` / `"level":"…"`, sinon `UNKNOWN`.
- Des lignes avant la première ligne d'en-tête du fichier forment une entrée de niveau `UNKNOWN`, horodatée à la date de modification du fichier.
- La dernière entrée du fichier n'est indexée que si elle est **complète** : elle se termine par `\n` **et** le fichier n'a pas été modifié depuis au moins 1 s (sinon une stack trace à moitié écrite serait coupée en deux). Sinon `scan_offset` reste à son début et elle sera relue au scan suivant.
- Taille maximale d'une entrée affichée : 1 Mio ; au-delà le contenu est tronqué à l'affichage avec la mention « entrée tronquée » (l'index garde les vrais offsets).
@@ -177,8 +204,10 @@ Au scan, si `taille actuelle < scan_offset` **ou** `file_identity` a changé :
### 5.5 Rafraîchissement et notification
- Le client appelle `unread_summary` au chargement de la page puis toutes les `refresh_interval_seconds` secondes.
- Le nouvel intervalle s'applique dès l'enregistrement, sans recharger la page (le timer est recréé).
- Le client appelle `unread_summary` au chargement de la page puis toutes les 5 s (le plus court des intervalles).
- Le serveur ne relit que les projets dont l'intervalle est écoulé (marge de 1 s, pour qu'un poll un peu en avance ne fasse pas attendre un cycle de plus) ; les autres gardent leurs compteurs. Un projet réglé sur « jamais » n'est jamais relu ainsi. L'heure de la dernière relecture de chaque projet est tenue en mémoire : au démarrage du serveur, tous les projets (sauf « jamais ») sont relus au premier poll.
- **Fichier affiché** : `read_entries` relit d'abord le projet du fichier, quel que soit son intervalle. Le fichier ouvert est donc à jour à chaque poll, y compris pour un projet « jamais ».
- Un nouvel intervalle s'applique dès l'enregistrement du projet, sans recharger la page.
- Le favicon est un SVG 32×32 généré côté client (URL `data:`) :
- `total = 0` → icône normale ;
- `total ≥ 1` → icône + pastille rouge avec le nombre (`99+` au-delà de 99) ;
@@ -196,28 +225,44 @@ Au scan, si `taille actuelle < scan_offset` **ou** `file_identity` a changé :
### 5.7 Interface
- **Barre latérale** : liste des projets, chacun dépliable en liste de fichiers (chemin relatif, taille, badge de non-lus). Fichiers manquants grisés. Un projet replié le reste aux rafraîchissements.
- **Barre latérale** : liste des projets, chacun dépliable en liste de fichiers (chemin relatif à la racine, ou au dossier de logs s'il n'y en a qu'un ; taille ; badge de non-lus). Fichiers manquants grisés. Un projet replié le reste aux rafraîchissements.
- **Tri des fichiers** : par nom (alphabétique, défaut) ou par date de dernière modification (le plus récent en premier, sans date en dernier, nom en départage). Trié par date, l'ancienneté (« il y a 3 h ») remplace la taille. Le choix s'applique à tous les projets et est enregistré dans `settings` (`file_sort`).
- **Formulaire d'ajout** : champ chemin + nom optionnel, message d'erreur sous le champ.
- **Fenêtre de projet** (modale, `<dialog>` natif) : ouverte par « + Ajouter un projet » ou par le bouton ✎ d'un projet (pré-remplie). Champs : chemin du projet, nom (obligatoire, proposé d'après le chemin), dossiers de logs (zone de texte, un par ligne, proposés d'après le chemin, cf. 5.1), vhost Apache (optionnel). En modification, un bouton « Retirer ce projet » en bas à gauche le supprime après confirmation (c'est le seul moyen de retirer un projet). Message d'erreur dans la fenêtre ; elle se ferme quand l'enregistrement ou le retrait réussit, par « Annuler », Échap ou un clic sur le fond.
- **Vue fichier** : entrées triées du plus récent au plus ancien, 50 par page, bouton « Charger plus ». Chaque entrée : date, niveau (badge coloré), environnement, première ligne ; le reste (stack trace) est repliable. Filtres par niveau (cases à cocher ; les niveaux absents du fichier sont grisés et désactivés, et se réactivent dès qu'une entrée de ce niveau apparaît) et recherche texte (insensible à la casse, sur le contenu complet de l'entrée).
- **Bouton marche/arrêt de la lecture** : à gauche du titre. Lecture active : un engrenage qui tourne lentement (6 s par tour, immobile si l'utilisateur a demandé moins d'animations). Lecture arrêtée : un bouton rouge avec l'icône « power ». L'arrêt supprime le polling et le rafraîchissement au retour sur l'onglet ; « · lecture arrêtée » s'affiche en rouge à côté du compteur. L'état est enregistré dans `settings` (`paused`). À la reprise, un rafraîchissement part immédiatement. Les actions de l'utilisateur (ouvrir un fichier, marquer comme lu, charger la page) rafraîchissent toujours.
- **Réglages** : intervalle en secondes (champ numérique, 1–3600).
- **Logs Apache** : les logs Apache sont listés sous le titre « Apache », après les logs du projet, par nom de fichier suivi de leur rôle (« erreurs » ou « accès »), le chemin complet en info-bulle.
- **Fichiers anciens** : champ numérique « Masquer les fichiers non modifiés depuis (jours) » dans la fenêtre de projet, vide par défaut (aucun fichier masqué), sinon un entier ≥ 1 (« Le nombre de jours doit être un entier positif. »). Un fichier est masqué si sa dernière modification remonte à plus de N × 24 h ; un fichier sans date reste affiché. Les fichiers masqués ne sont ni listés ni comptés dans les non-lus, mais restent scannés : une nouvelle entrée change leur date et les fait réapparaître. Sous le projet, « N fichiers anciens masqués » les signale ; le message « Aucun fichier de log pour l'instant. » n'apparaît pas si des fichiers sont masqués.
- **Rafraîchissement** : liste déroulante dans la fenêtre de projet (« Jamais », « 5 s » … « 1 h », 5 s par défaut). Un projet réglé sur « jamais » porte un ⏸ dans la liste ; l'info-bulle de son nom rappelle l'intervalle. Il n'y a plus de page de réglages.
### 5.8 Logs Apache du vhost
- Le chemin saisi est nettoyé, `~` remplacé par `$HOME`, puis canonicalisé. Il est valide si c'est un fichier lisible qui déclare au moins un log.
- Le vhost est relu à chaque scan : un log ajouté au vhost est suivi, un log retiré du vhost n'est plus suivi (ses lignes sont supprimées). Si le vhost devient illisible, `vhost_error` est renseigné et ses fichiers connus restent en l'état.
- Directives lues (insensibles à la casse, lignes commentées ignorées) : `ErrorLog` → log d'erreurs ; `CustomLog`, `TransferLog` → log d'accès. Seul le premier argument compte (entre guillemets ou non). Ignorés : `|programme`, `syslog…`. Un même fichier déclaré deux fois (vhosts `:80` et `:443`) n'est suivi qu'une fois.
- Les variables `${NOM}` sont remplacées par les `export NOM=…` de `/etc/apache2/envvars` (une variable inconnue vaut la chaîne vide) ; un chemin relatif part de `/etc/apache2`.
- À la configuration du vhost, le curseur des fichiers nouvellement suivis est placé à la fin : l'historique n'est pas non-lu. La mise à jour du vhost et ce premier scan se font sous le verrou du scanner.
- **Log d'erreurs** : une ligne d'en-tête correspond à `[Wed Oct 21 11:29:09.705795 2026] [module:niveau] [pid …] message` (module facultatif). Les lignes suivantes sans en-tête sont rattachées à l'entrée. Niveaux : `emerg` → `EMERGENCY`, `alert` → `ALERT`, `crit` → `CRITICAL`, `error` → `ERROR`, `warn` → `WARNING`, `notice` → `NOTICE`, `info` → `INFO`, `debug` et `trace1`…`trace8` → `DEBUG`. Le module s'affiche à la place de l'environnement.
- **Log d'accès** : chaque ligne est une entrée, complète dès son `\n` (sans attendre 1 s). Formats `common`, `combined`, `vhost_combined`. Niveau selon le code HTTP : 5xx → `ERROR`, 4xx → `WARNING`, 1xx–3xx → `INFO`, autre ou ligne non reconnue → `UNKNOWN`. Affichage : client, puis « code requête », la ligne complète en détail repliable.
- **Non-lus** : les entrées du log d'erreurs comptent comme celles des logs du projet. Celles d'un log d'accès (du vhost ou d'un dossier du projet, format `access`) **ne comptent jamais** (une ligne par requête) ; à l'ouverture du fichier, les lignes arrivées depuis la dernière consultation sont tout de même surlignées.
- Les dates Apache sont converties au format `YYYY-MM-DD HH:MM:SS` (heure locale du log, sans fuseau).
---
## 6. User stories et critères d'acceptation
Convention : `Given / When / Then`. « Écrire une entrée » signifie ajouter au fichier une ligne `[2026-10-21 10:00:00] local.ERROR: message\n`. Tous les délais s'entendent avec un intervalle de 1 s sauf mention contraire.
Convention : `Given / When / Then`. « Écrire une entrée » signifie ajouter au fichier une ligne `[2026-10-21 10:00:00] local.ERROR: message\n`. Tous les délais s'entendent avec un projet rafraîchi toutes les 5 s sauf mention contraire.
### US-01 — Ajouter un projet
> En tant que développeur, je veux ajouter un projet Laravel en saisissant son chemin, afin de surveiller ses logs.
> En tant que développeur, je veux ajouter un projet en saisissant son chemin et ses dossiers de logs, afin de surveiller ses logs.
- **AC-01.1** Given un répertoire `/tmp/app` avec `artisan` et `storage/logs/laravel.log`, When j'ajoute `/tmp/app`, Then le projet `app` apparaît dans la liste avec le fichier `laravel.log`.
- **AC-01.1** Given un répertoire `/tmp/app` avec `artisan` et `storage/logs/laravel.log`, When je saisis `/tmp/app`, Then le champ des dossiers propose `storage/logs` ; When j'ajoute le projet, Then `app` apparaît dans la liste avec le fichier `laravel.log`.
- **AC-01.7** Given un projet Node `/tmp/api` avec `logs/app.log` et `node_modules/x/debug.log`, When je l'ajoute avec le dossier `logs`, Then seul `app.log` est listé ; ses lignes `… ERROR …` sont des entrées `ERROR` et ses lignes indentées sont rattachées à l'entrée précédente.
- **AC-01.8** When j'ajoute un projet sans dossier de logs ni vhost, Then l'ajout est refusé avec « Indiquez au moins un dossier de logs ou un vhost. » ; When je saisis le dossier `../x`, Then il est refusé avec « « ../x » doit être un sous-dossier du projet. ».
- **AC-01.2** Given le même répertoire, When j'ajoute `/tmp/app/` puis `/tmp/../tmp/app`, Then la 2ᵉ et la 3ᵉ tentative sont refusées avec « Ce projet est déjà enregistré ».
- **AC-01.3** Given un lien `/tmp/link → /tmp/app` et `/tmp/app` déjà enregistré, When j'ajoute `/tmp/link`, Then l'ajout est refusé (même chemin canonique).
- **AC-01.4** Given `laravel.log` contient 10 entrées, When j'ajoute le projet, Then le compteur de non-lus du projet vaut 0.
- **AC-01.5** Given un nom saisi « Mon API », When j'ajoute le projet, Then il s'affiche sous le nom « Mon API ».
- **AC-01.5** Given le chemin `/tmp/app` saisi, Then le nom proposé est « app » ; When je le remplace par « Mon API » et j'ajoute le projet, Then il s'affiche sous le nom « Mon API ». When le nom est vide, Then l'ajout est refusé avec « Veuillez saisir un nom. ».
- **AC-01.6** Given `~/code/app` valide, When je saisis `~/code/app`, Then le projet est enregistré avec le chemin absolu.
### US-02 — Lister tous les fichiers de log d'un projet
@@ -239,20 +284,29 @@ Convention : `Given / When / Then`. « Écrire une entrée » signifie ajouter a
- **AC-03.4** Given un fichier contenant des octets non UTF-8, When il est affiché, Then les entrées s'affichent avec le caractère `�` à la place des octets invalides, sans erreur.
- **AC-03.5** Given un fichier de 1 Gio, When je l'ouvre, Then la première page s'affiche en < 2 s après l'indexation initiale et la mémoire du serveur reste < 200 Mio.
### US-04 — Configurer l'intervalle de rafraîchissement
### US-14 — Masquer les fichiers anciens
> En tant que développeur, je veux choisir la fréquence de lecture des logs, pour arbitrer entre réactivité et charge.
> En tant que développeur, je veux ne pas voir les vieux logs journaliers d'un projet, pour trouver vite ceux qui vivent encore.
- **AC-04.1** Given une première installation, When j'ouvre les réglages, Then l'intervalle vaut 5 s.
- **AC-04.2** Given l'intervalle à 5 s, When je saisis 30 et j'enregistre, Then le client n'appelle plus `unread_summary` qu'une fois toutes les 30 s (± 1 s), sans rechargement de page.
- **AC-04.3** When je saisis `0`, `3601`, `-5`, `abc` ou une valeur vide, Then l'enregistrement est refusé avec « L'intervalle doit être un entier entre 1 et 3600 secondes » et la valeur précédente est conservée.
- **AC-04.4** Given l'intervalle à 30 s, When je redémarre le serveur, Then l'intervalle vaut toujours 30 s.
- **AC-14.1** Given `laravel-2026-09-01.log` modifié il y a 50 j et `laravel.log` modifié il y a 1 h, When je règle « 30 » jours, Then seul `laravel.log` est listé, suivi de « 1 fichier ancien masqué ».
- **AC-14.2** Given le réglage à 30 j et 2 non-lus dans un fichier masqué, Then le total ne les compte pas ; When une entrée y est écrite, Then le fichier réapparaît avec 3 non-lus.
- **AC-14.3** When je vide le champ, Then tous les fichiers sont à nouveau listés. When je saisis `0`, Then l'enregistrement est refusé avec « Le nombre de jours doit être un entier positif. ».
### US-04 — Choisir le rafraîchissement d'un projet
> En tant que développeur, je veux régler la fréquence de relecture de chaque projet, pour suivre de près le projet sur lequel je travaille sans relire en permanence les autres.
- **AC-04.1** Given un nouveau projet, When j'ouvre la fenêtre d'ajout, Then le rafraîchissement vaut « 5 s » et la liste propose Jamais, 5 s, 15 s, 30 s, 1 min, 5 min, 15 min, 30 min, 1 h.
- **AC-04.2** Given un projet A à 5 s et un projet B à 1 min, When une entrée est écrite dans chacun, Then A la signale en ≤ 6 s et B en ≤ 61 s.
- **AC-04.3** Given un projet réglé sur « Jamais », When des entrées sont écrites, Then ses compteurs ne changent pas et un ⏸ est affiché à côté de son nom ; When j'ouvre un de ses fichiers, Then les nouvelles entrées s'affichent.
- **AC-04.4** When une valeur hors de la liste est envoyée à `add_project` ou `update_project`, Then l'enregistrement est refusé avec « Intervalle de rafraîchissement invalide. ».
- **AC-04.5** Given un projet à 15 min, When je redémarre le serveur, Then il est toujours à 15 min. Les projets existants avant cette version prennent l'ancien intervalle global, arrondi au choix supérieur.
### US-05 — Être notifié des nouvelles entrées par le favicon
> En tant que développeur, je veux voir dans l'onglet du navigateur s'il y a de nouveaux logs, sans avoir à regarder l'application.
- **AC-05.1** Given 0 non-lu, When 3 entrées sont écrites dans un fichier suivi, Then en ≤ intervalle + 1 s le favicon porte une pastille « 3 » et le titre est `(3) Logs Reader`.
- **AC-05.1** Given 0 non-lu, When 3 entrées sont écrites dans un fichier suivi, Then en ≤ 6 s le favicon porte une pastille « 3 » et le titre est `(3) Logs Reader`.
- **AC-05.2** Given 2 non-lus dans `a.log` et 1 dans `b.log` (même projet ou non), Then la pastille affiche « 3 ».
- **AC-05.3** Given 150 non-lus, Then la pastille affiche « 99+ » et le titre `(150) Logs Reader`.
- **AC-05.4** Given des non-lus, When tout est marqué comme lu, Then le favicon redevient normal et le titre `Logs Reader` sans attendre le prochain poll.
@@ -273,7 +327,7 @@ Convention : `Given / When / Then`. « Écrire une entrée » signifie ajouter a
> En tant que développeur, je veux retirer un projet que je ne surveille plus.
- **AC-07.1** Given un projet avec 5 non-lus, When je le supprime et confirme, Then il disparaît de la liste, le total diminue de 5, et aucune ligne liée ne reste dans `log_files`, `log_entries_index`, `read_cursors`.
- **AC-07.1** Given un projet avec 5 non-lus, When j'ouvre sa fenêtre (✎), clique « Retirer ce projet » et confirme, Then il disparaît de la liste, le total diminue de 5, et aucune ligne liée ne reste dans `log_files`, `log_entries_index`, `read_cursors`.
- **AC-07.2** Given un projet supprimé, When je l'ajoute à nouveau, Then l'ajout réussit et les entrées existantes ne sont pas comptées comme non-lues (cf. AC-01.4).
- **AC-07.3** When je supprime un projet, Then aucun fichier du projet sur le disque n'est modifié (mtime et contenu identiques).
@@ -300,10 +354,29 @@ Convention : `Given / When / Then`. « Écrire une entrée » signifie ajouter a
> En tant que développeur, je veux arrêter temporairement la lecture des logs, par exemple pendant une session de debug bruyante.
- **AC-11.1** Given la lecture active (engrenage qui tourne), When je clique dessus, Then le bouton devient rouge, le favicon affiche la pastille rouge « pause », « · lecture arrêtée » est affiché, et aucun appel `unread_summary` n'est fait pendant 3 intervalles, même si des entrées sont écrites.
- **AC-11.1** Given la lecture active (engrenage qui tourne), When je clique dessus, Then le bouton devient rouge, le favicon affiche la pastille rouge « pause », « · lecture arrêtée » est affiché, et aucun appel `unread_summary` n'est fait pendant 15 s, même si des entrées sont écrites.
- **AC-11.2** Given la lecture arrêtée, When je recharge la page, Then le bouton est toujours rouge, le favicon toujours en pause, et aucun polling ne reprend.
- **AC-11.3** Given la lecture arrêtée et 1 entrée écrite entre-temps, When je clique sur le bouton rouge, Then l'engrenage réapparaît et le compteur et le favicon sont mis à jour en moins de 1 s.
### US-12 — Consulter les logs Apache du vhost
> En tant que développeur, je veux voir les logs Apache du vhost de mon projet à côté de ses autres logs, pour diagnostiquer une erreur 500 sans ouvrir un terminal.
- **AC-12.1** Given un vhost déclarant `ErrorLog ${APACHE_LOG_DIR}/error.app.log` et `CustomLog ${APACHE_LOG_DIR}/access.app.log combined`, When je l'enregistre sur le projet, Then les deux fichiers apparaissent sous « Apache » avec les rôles « erreurs » et « accès », et le total de non-lus ne change pas.
- **AC-12.2** Given le vhost enregistré, When une ligne `[php:error]` est écrite dans le log d'erreurs, Then le total augmente de 1 ; When 10 requêtes sont faites, Then le total ne change pas.
- **AC-12.3** Given le log d'accès ouvert, Then chaque requête est une entrée, une 404 en `WARNING` et une 500 en `ERROR`, et le filtre par niveau s'applique.
- **AC-12.4** When je saisis `/etc/hosts`, Then l'enregistrement est refusé avec « Aucune directive ErrorLog ni CustomLog dans « /etc/hosts ». ».
- **AC-12.5** Given le vhost enregistré, When je vide le champ vhost du projet et j'enregistre, Then les fichiers Apache disparaissent de la liste et leurs non-lus ne comptent plus.
### US-13 — Modifier un projet
> En tant que développeur, je veux corriger le nom, le chemin ou le vhost d'un projet sans le supprimer, pour garder ses compteurs.
- **AC-13.1** Given un projet « app », When je clique ✎, Then la fenêtre s'ouvre avec son chemin, son nom et son vhost.
- **AC-13.2** Given 3 non-lus dans `laravel.log`, When je renomme le projet en « API », Then il s'affiche « API » et garde ses 3 non-lus.
- **AC-13.3** Given deux projets A et B, When je donne à B le chemin de A, Then l'enregistrement est refusé avec « Ce projet est déjà enregistré. » et la fenêtre reste ouverte.
- **AC-13.4** Given un projet, When je change son chemin vers un autre projet dont le dossier de logs contient 10 entrées, Then ses fichiers sont ceux du nouveau chemin et son compteur de non-lus vaut 0.
### US-09 — Conserver l'état entre deux redémarrages
> En tant que développeur, je veux retrouver mes projets et mes compteurs après un redémarrage.
@@ -321,8 +394,9 @@ Convention : `Given / When / Then`. « Écrire une entrée » signifie ajouter a
| E01 | Chemin vide | Validation client et serveur | Refus | « Veuillez saisir un chemin. » |
| E02 | Chemin inexistant | `canonicalize` → `NotFound` | Refus, rien en base | « Le chemin `<p>` n'existe pas. » |
| E03 | Chemin vers un fichier | `!is_dir()` | Refus | « `<p>` n'est pas un répertoire. » |
| E04 | Pas un projet Laravel | `artisan` absent | Refus | « `<p>` ne semble pas être un projet Laravel (fichier `artisan` introuvable). » |
| E05 | `storage/logs` absent | Absence du répertoire | Refus | « Répertoire `storage/logs` introuvable. » |
| E04 | Dossier de logs hors du projet | `.`, `..` ou chemin absolu | Refus | « « `<d>` » doit être un sous-dossier du projet. » |
| E05 | Dossier de logs absent ou illisible | Absence du répertoire, `PermissionDenied` | Refus | « Dossier « `<d>` » introuvable dans le projet. », « Accès refusé à « `<d>` ». » |
| E05 bis | Ni dossier de logs ni vhost | Champs vides | Refus | « Indiquez au moins un dossier de logs ou un vhost. » |
| E06 | Permission refusée à l'ajout | `PermissionDenied` | Refus | « Accès refusé à `<p>`. » |
| E07 | Projet déjà enregistré | Contrainte `UNIQUE(root_path)` après canonicalisation | Refus, projet existant mis en évidence | « Ce projet est déjà enregistré. » |
| E08 | Aucun fichier `.log` | Découverte vide | Ajout accepté, liste vide | « Aucun fichier de log pour l'instant. » |
@@ -335,14 +409,17 @@ Convention : `Given / When / Then`. « Écrire une entrée » signifie ajouter a
| E15 | Texte sans ligne d'en-tête valide | Regex | Entrée `UNKNOWN` (cf. 5.3) | — |
| E16 | Fichier très volumineux | — | Lecture par blocs ; jamais de chargement complet | — |
| E17 | Entrée gigantesque (> 1 Mio) | Taille `end - start` | Affichage tronqué | « Entrée tronquée (X Mio). » |
| E18 | Intervalle invalide | Validation client et serveur | Refus, ancienne valeur conservée | cf. AC-04.3 |
| E18 | Intervalle invalide | Validation serveur (choix de la liste) | Refus, ancienne valeur conservée | cf. AC-04.4 |
| E19 | `log_file_id` / `project_id` inconnu | Requête vide | Erreur 404 de la server function | « Élément introuvable, la liste a été rafraîchie. » |
| E20 | Base SQLite inaccessible au démarrage | Échec de connexion/migration | Arrêt du processus, code de sortie ≠ 0 | Log console explicite avec le chemin |
| E21 | Base verrouillée en cours d'exécution | `SQLITE_BUSY` | `busy_timeout` de 5 s, puis erreur renvoyée au client ; aucun état partiel (transaction) | « Base de données occupée, nouvel essai au prochain rafraîchissement. » |
| E22 | Base corrompue | `PRAGMA quick_check` au démarrage | Arrêt du processus | Log console explicite |
| E23 | Port déjà utilisé | `bind` échoue | Arrêt, code de sortie ≠ 0 | « L'adresse `<addr>` est déjà utilisée. » |
| E24 | Serveur injoignable côté client | Échec réseau du poll | Favicon gris « ! », bandeau discret ; on continue de poller au même intervalle | « Serveur injoignable. » |
| E24 | Serveur injoignable côté client | Échec réseau du poll | Favicon gris « ! », bandeau discret ; on continue de poller toutes les 5 s | « Serveur injoignable. » |
| E25 | Scans simultanés (plusieurs onglets) | Mutex par projet | Un seul scan à la fois, résultats partagés ; pas de double indexation | — |
| E26 | Vhost inexistant, illisible ou sans directive de log | Validation serveur | Refus, vhost précédent conservé | « Le fichier « p » n'existe pas. », « Accès refusé à « p ». », « Aucune directive ErrorLog ni CustomLog dans « p ». » |
| E27 | Vhost supprimé ou illisible après configuration | Lecture au scan | `vhost_error` renseigné, fichiers Apache connus conservés en l'état | Message sous le titre « Apache » |
| E28 | Log Apache illisible (droits `root:adm 640`) | `PermissionDenied` | Comme E10 ; l'utilisateur qui lance le serveur doit être dans le groupe `adm` | Icône d'alerte sur le fichier |
---
@@ -354,13 +431,13 @@ Ces propriétés doivent être vraies après toute opération et peuvent être v
- **INV-02 Ordre des offsets** — Pour tout fichier présent : `0 ≤ read_offset ≤ scan_offset ≤ size`.
- **INV-03 Index cohérent** — Les entrées indexées d'un fichier sont disjointes, contiguës et triées : pour deux entrées consécutives `e1, e2`, `e1.end_offset = e2.start_offset` ; la dernière se termine à `scan_offset` ; `entries_count` = nombre de lignes d'index.
- **INV-04 Aucune entrée partielle ni doublon** — Chaque entrée complète du fichier est indexée exactement une fois ; aucune entrée incomplète n'est indexée.
- **INV-05 Calcul des non-lus** — `unread(f)` = nombre d'entrées indexées de `f` avec `start_offset ≥ read_offset` ; `unread(f) ≥ 0` ; `unread(f) = 0` si `f` est manquant ; `total = Σ unread(f)` sur les fichiers présents des projets accessibles.
- **INV-05 Calcul des non-lus** — `unread(f)` = nombre d'entrées indexées de `f` avec `start_offset ≥ read_offset` ; `unread(f) ≥ 0` ; `unread(f) = 0` si `f` est manquant, masqué (trop ancien) ou est un log d'accès ; `total = Σ unread(f)` sur les fichiers présents des projets accessibles.
- **INV-06 Le curseur n'avance que par l'utilisateur** — Un scan ne fait jamais avancer `read_offset` ; seuls `mark_read`, `mark_all_read` et l'ajout initial d'un projet (5.1) le font avancer. Seule une rotation (5.4) le fait reculer (à 0).
- **INV-07 Monotonie hors rotation** — En l'absence de rotation, `scan_offset` et `read_offset` sont croissants dans le temps.
- **INV-08 Confinement** — Tout fichier suivi a un chemin canonique sous `<root_path>/storage/logs`.
- **INV-08 Confinement** — Tout fichier du projet suivi a un chemin canonique sous l'un de ses dossiers de logs ; tout log Apache suivi est déclaré par le vhost du projet.
- **INV-09 Unicité** — Un chemin canonique correspond à au plus un projet ; un couple (projet, chemin relatif) à au plus un fichier.
- **INV-10 Cascade** — Après suppression d'un projet, aucune ligne de `log_files`, `log_entries_index` ou `read_cursors` ne le référence.
- **INV-11 Bornes de l'intervalle** — `refresh_interval_seconds` stocké est toujours un entier dans `[1, 3600]`.
- **INV-11 Intervalle valide** — `refresh_seconds` d'un projet est toujours l'un de 0, 5, 15, 30, 60, 300, 900, 1800, 3600.
- **INV-12 Persistance** — Sans changement des fichiers sur le disque, un redémarrage ne change aucun compteur de non-lus.
- **INV-13 Idempotence du scan** — Deux scans successifs sans modification des fichiers produisent le même état en base.
- **INV-14 Atomicité** — Le scan d'un fichier (mise à jour de l'index + `scan_offset`) est fait dans une seule transaction : un crash au milieu laisse l'état précédent.
@@ -384,7 +461,7 @@ Ces propriétés doivent être vraies après toute opération et peuvent être v
- **Unitaires** : parser (en-têtes valides/invalides, multi-lignes, entrée partielle, UTF-8 invalide, fuseaux horaires, microsecondes), détection de rotation, validation de chemin et d'intervalle, calcul de `mark_read` (non-régression du curseur).
- **Propriétés** (`proptest`) : écrire des séquences aléatoires d'entrées en morceaux arbitraires, scanner entre chaque morceau, vérifier INV-02 à INV-05 et INV-13.
- **Intégration** : serveur axum sur port aléatoire + SQLite temporaire + projet Laravel factice dans un `tempdir` ; dérouler les AC des US-01 à US-09 via les server functions.
- **Intégration** : serveur axum sur port aléatoire + SQLite temporaire + projet factice dans un `tempdir` ; dérouler les AC des US-01 à US-09 via les server functions.
- **E2E** (Playwright) : AC-04.2, AC-05.1, AC-05.3, AC-05.4, AC-05.5, AC-06.2, AC-06.3 — lecture de `document.title` et de l'attribut `href` du `<link rel="icon">`.
---
Generated
+10 -1
View File
@@ -590,6 +590,12 @@ version = "0.1.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"
[[package]]
name = "foldhash"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb"
[[package]]
name = "form_urlencoded"
version = "1.2.2"
@@ -792,7 +798,7 @@ checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1"
dependencies = [
"allocator-api2",
"equivalent",
"foldhash",
"foldhash 0.1.5",
]
[[package]]
@@ -1428,6 +1434,7 @@ dependencies = [
"leptos_router",
"regex",
"serde",
"serde_json",
"sqlx",
"tempfile",
"time",
@@ -2133,6 +2140,8 @@ version = "1.0.154"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6"
dependencies = [
"foldhash 0.2.0",
"indexmap",
"itoa",
"memchr",
"serde",
+3 -1
View File
@@ -11,11 +11,13 @@ leptos = "0.8"
leptos_meta = "0.8"
leptos_router = "0.8"
serde = { version = "1", features = ["derive"] }
# Contexte JSON des entrées, affiché dans l'ordre des clés du log.
serde_json = { version = "1", features = ["preserve_order"] }
# Client (WASM)
console_error_panic_hook = { version = "0.1", optional = true }
wasm-bindgen = { version = "0.2.106", optional = true }
web-sys = { version = "0.3", features = ["Document", "VisibilityState"], optional = true }
web-sys = { version = "0.3", features = ["Document", "Selection", "VisibilityState"], optional = true }
# Serveur uniquement
axum = { version = "0.8", optional = true }
+24
View File
@@ -0,0 +1,24 @@
DEPLOY_DIR ?= /var/www/logs_reader
SERVICE ?= logs_reader
.PHONY: build deploy status logs
## Compile le binaire et les fichiers statiques en release.
build:
cargo leptos build --release
## Installe la nouvelle version dans $(DEPLOY_DIR) et redémarre le service.
deploy: build
install -m 755 target/release/logs_reader $(DEPLOY_DIR)/logs_reader
rsync -a --delete target/site/ $(DEPLOY_DIR)/site/
systemctl --user restart $(SERVICE)
@for i in $$(seq 1 50); do \
curl -sf -o /dev/null http://127.0.0.1:3100/ && echo "Déployé : http://logs-reader.loc" && exit 0; \
sleep 0.1; \
done; echo "Le service ne répond pas : make logs" >&2; exit 1
status:
systemctl --user status $(SERVICE) --no-pager
logs:
journalctl --user -u $(SERVICE) -f
+9 -4
View File
@@ -1,6 +1,10 @@
# Logs Reader
Lecteur local de logs Laravel. Il signale les nouvelles entrées par l'icône et le titre de l'onglet.
Lecteur local de logs de projets (Laravel, Symfony, Node…). Il suit les fichiers `*.log` des
dossiers de logs déclarés pour chaque projet, détecte leur format (Monolog, Apache, une ligne par
entrée) et signale les nouvelles entrées par l'icône et le titre de l'onglet.
Un projet peut aussi suivre les logs Apache (ErrorLog, CustomLog) de son vhost : l'utilisateur qui
lance le serveur doit pouvoir les lire (groupe `adm` sous Debian/Ubuntu).
Spécification : [`.spec/specification.md`](.spec/specification.md).
Stack : axum, Leptos 0.8 (SSR + hydratation), Tailwind CSS v4, SQLite (sqlx).
@@ -31,9 +35,10 @@ cargo test --features ssr
| Fichier | Rôle |
|---|---|
| `src/model.rs` | Types partagés client/serveur, validation de l'intervalle, favicon SVG |
| `src/parser.rs` | Découpage d'un log Monolog en entrées (lecture en flux) |
| `src/scanner.rs` | Découverte des fichiers, indexation incrémentale, détection de rotation |
| `src/model.rs` | Types partagés client/serveur, choix de rafraîchissement, favicon SVG |
| `src/parser.rs` | Détection du format et découpage d'un log en entrées (lecture en flux) |
| `src/apache.rs` | Lecture du vhost Apache, format des logs d'erreurs et d'accès |
| `src/scanner.rs` | Découverte des fichiers (dossiers de logs et vhost), indexation incrémentale, détection de rotation |
| `src/server.rs` | Connexion SQLite, calcul des non-lus |
| `src/api.rs` | Server functions (`POST /api/<nom>`) |
| `src/app.rs` | Interface Leptos, polling, favicon et titre |
+7
View File
@@ -0,0 +1,7 @@
-- Vhost Apache rattaché à un projet : ses ErrorLog et CustomLog sont suivis avec les logs Laravel.
ALTER TABLE projects ADD COLUMN vhost_path TEXT; -- chemin canonique du fichier de configuration
ALTER TABLE projects ADD COLUMN vhost_error TEXT; -- renseigné si le vhost est illisible
-- 'laravel' (relative_path relatif à storage/logs), 'apache_error' ou 'apache_access'
-- (relative_path absolu, lu dans le vhost).
ALTER TABLE log_files ADD COLUMN kind TEXT NOT NULL DEFAULT 'laravel';
+14
View File
@@ -0,0 +1,14 @@
-- Projets non spécifiques à Laravel : dossiers de logs configurables et format détecté par fichier.
-- Dossiers de logs relatifs à la racine, un par ligne.
ALTER TABLE projects ADD COLUMN log_dirs TEXT NOT NULL DEFAULT 'storage/logs';
-- 'monolog', 'apache_error', 'access' ou 'lines' ; NULL tant qu'il n'est pas détecté.
ALTER TABLE log_files ADD COLUMN format TEXT;
-- Les fichiers Laravel deviennent des fichiers du projet, relatifs à sa racine.
UPDATE log_files
SET relative_path = 'storage/logs/' || relative_path, kind = 'project', format = 'monolog'
WHERE kind = 'laravel';
UPDATE log_files SET format = 'apache_error' WHERE kind = 'apache_error';
UPDATE log_files SET format = 'access' WHERE kind = 'apache_access';
+20
View File
@@ -0,0 +1,20 @@
-- Rafraîchissement propre à chaque projet (secondes, 0 = jamais), qui remplace le réglage global.
ALTER TABLE projects ADD COLUMN refresh_seconds INTEGER NOT NULL DEFAULT 5;
-- Les projets existants prennent l'ancien intervalle global, arrondi au choix supérieur.
UPDATE projects
SET refresh_seconds = (
SELECT CASE
WHEN CAST(value AS INTEGER) <= 5 THEN 5
WHEN CAST(value AS INTEGER) <= 15 THEN 15
WHEN CAST(value AS INTEGER) <= 30 THEN 30
WHEN CAST(value AS INTEGER) <= 60 THEN 60
WHEN CAST(value AS INTEGER) <= 300 THEN 300
WHEN CAST(value AS INTEGER) <= 900 THEN 900
WHEN CAST(value AS INTEGER) <= 1800 THEN 1800
ELSE 3600
END
FROM settings WHERE key = 'refresh_interval_seconds')
WHERE EXISTS (SELECT 1 FROM settings WHERE key = 'refresh_interval_seconds');
DELETE FROM settings WHERE key = 'refresh_interval_seconds';
+3
View File
@@ -0,0 +1,3 @@
-- Fichiers masqués d'un projet : ceux dont la dernière modification remonte à plus de ce
-- nombre de jours (NULL = aucun fichier masqué).
ALTER TABLE projects ADD COLUMN hide_after_days INTEGER;
+369
View File
@@ -0,0 +1,369 @@
//! Logs Apache d'un vhost : lecture de la configuration et format des lignes.
use crate::model::{LogKind, UNKNOWN_LEVEL};
use regex::Regex;
use std::{
collections::HashMap,
fs,
io::ErrorKind,
path::{Path, PathBuf},
sync::LazyLock,
};
/// Répertoire de configuration d'Apache (Debian/Ubuntu), base des chemins relatifs.
const SERVER_ROOT: &str = "/etc/apache2";
/// Variables d'environnement d'Apache, dont `APACHE_LOG_DIR`.
const ENVVARS: &str = "/etc/apache2/envvars";
/// `[Wed Oct 21 11:29:09.705795 2026] [module:level] [pid 1:tid 1] message`
/// (le module est absent dans les formats anciens).
static ERROR_HEADER: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(
r"^\[\w{3} (\w{3}) +(\d{1,2}) (\d{2}:\d{2}:\d{2})(?:\.\d+)? (\d{4})\] \[(?:([^:\]]*):)?(\w+)\](?: \[pid [^\]]*\])? ?",
)
.unwrap()
});
/// Formats `common`, `combined` et `vhost_combined` (préfixé par `vhost:port`).
static ACCESS_LINE: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(
r#"^(?:\S+ )?(\S+) \S+ \S+ \[(\d{2})/(\w{3})/(\d{4}):(\d{2}:\d{2}:\d{2}) [+-]\d{4}\] "((?:[^"\\]|\\.)*)" (\d{3}|-)"#,
)
.unwrap()
});
static VARIABLE: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"\$\{(\w+)\}|\$(\w+)").unwrap());
fn month_number(month: &str) -> Option<u8> {
let months = [
"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
];
months.iter().position(|m| *m == month).map(|i| i as u8 + 1)
}
/// Date au format des logs Laravel (`YYYY-MM-DD HH:MM:SS`).
fn timestamp(year: &str, month: &str, day: &str, time: &str) -> String {
let month = month_number(month).unwrap_or(0);
let day: u8 = day.parse().unwrap_or(0);
format!("{year}-{month:02}-{day:02} {time}")
}
/// Niveau PSR-3 correspondant à un niveau Apache (`warn`, `crit`, `trace3`…).
fn level(apache: &str) -> String {
let level = match apache.to_ascii_lowercase().as_str() {
"emerg" => "EMERGENCY",
"alert" => "ALERT",
"crit" => "CRITICAL",
"error" => "ERROR",
"warn" => "WARNING",
"notice" => "NOTICE",
"info" => "INFO",
l if l == "debug" || l.starts_with("trace") => "DEBUG",
_ => UNKNOWN_LEVEL,
};
level.to_string()
}
/// Niveau d'une requête selon son code HTTP : 5xx en erreur, 4xx en avertissement.
fn status_level(status: &str) -> String {
match status.as_bytes().first() {
Some(b'5') => "ERROR",
Some(b'4') => "WARNING",
Some(b'1'..=b'3') => "INFO",
_ => UNKNOWN_LEVEL,
}
.to_string()
}
/// Reconnaît une ligne d'en-tête du log d'erreurs : (date, niveau).
pub fn error_header(line: &str) -> Option<(String, String)> {
let caps = ERROR_HEADER.captures(line)?;
Some((
timestamp(&caps[4], &caps[1], &caps[2], &caps[3]),
level(&caps[6]),
))
}
/// Date et niveau d'une ligne du log d'accès. Toute ligne est une entrée : une ligne dans
/// un format inconnu est de niveau `UNKNOWN`, sans date.
pub fn access_header(line: &str) -> (String, String) {
match ACCESS_LINE.captures(line) {
Some(caps) => (
timestamp(&caps[4], &caps[3], &caps[2], &caps[5]),
status_level(&caps[7]),
),
None => (String::new(), UNKNOWN_LEVEL.to_string()),
}
}
/// Vrai si la ligne est au format d'un log d'accès (`common`, `combined`, `vhost_combined`).
pub fn is_access_line(line: &str) -> bool {
ACCESS_LINE.is_match(line)
}
/// Découpe une entrée du log d'erreurs en (module, message, détails).
pub fn split_error(content: &str) -> (String, String, String) {
let content = content.trim_end_matches(['\n', '\r']);
let (first, rest) = content.split_once('\n').unwrap_or((content, ""));
let first = first.trim_end_matches('\r');
match ERROR_HEADER.captures(first) {
Some(caps) => (
caps.get(5).map_or("", |m| m.as_str()).to_string(),
first[caps.get(0).unwrap().end()..].to_string(),
rest.to_string(),
),
None => (String::new(), first.to_string(), rest.to_string()),
}
}
/// Découpe une ligne du log d'accès en (client, « code requête », ligne complète).
pub fn split_access(content: &str) -> (String, String, String) {
let line = content.trim_end_matches(['\n', '\r']);
match ACCESS_LINE.captures(line) {
Some(caps) => (
caps[1].to_string(),
format!("{} {}", &caps[7], &caps[6]),
line.to_string(),
),
None => (String::new(), line.to_string(), String::new()),
}
}
/// Variables `export NOM=valeur` du fichier `envvars`, les références `$NOM` résolues.
/// Une variable inconnue (comme `SUFFIX`, définie dans un `if`) vaut la chaîne vide.
pub fn parse_envvars(text: &str) -> HashMap<String, String> {
let mut vars = HashMap::new();
for line in text.lines() {
let Some(assignment) = line.trim().strip_prefix("export ") else {
continue;
};
let Some((name, value)) = assignment.split_once('=') else {
continue;
};
let value = substitute(value.trim().trim_matches(['"', '\'']), &vars);
vars.insert(name.trim().to_string(), value);
}
vars
}
fn substitute(text: &str, vars: &HashMap<String, String>) -> String {
VARIABLE
.replace_all(text, |caps: &regex::Captures| {
let name = caps.get(1).or(caps.get(2)).unwrap().as_str();
vars.get(name).cloned().unwrap_or_default()
})
.to_string()
}
/// Premier argument d'une directive, entre guillemets ou non.
fn first_argument(args: &str) -> Option<&str> {
let args = args.trim_start();
if let Some(quoted) = args.strip_prefix('"') {
quoted.split('"').next()
} else {
args.split_whitespace().next()
}
}
/// Fichiers de log déclarés par un vhost (`ErrorLog`, `CustomLog`, `TransferLog`), dans
/// l'ordre et sans doublon. Les logs envoyés à un programme (`|…`) ou à syslog sont ignorés,
/// les variables `${…}` sont remplacées et les chemins relatifs résolus depuis `server_root`.
pub fn parse_vhost(
conf: &str,
vars: &HashMap<String, String>,
server_root: &Path,
) -> Vec<(LogKind, PathBuf)> {
let mut logs: Vec<(LogKind, PathBuf)> = Vec::new();
for line in conf.lines() {
let line = line.trim();
let Some((directive, args)) = line.split_once(char::is_whitespace) else {
continue;
};
let kind = match directive.to_ascii_lowercase().as_str() {
"errorlog" => LogKind::ApacheError,
"customlog" | "transferlog" => LogKind::ApacheAccess,
_ => continue,
};
let Some(target) = first_argument(args) else {
continue;
};
if target.starts_with('|') || target.starts_with("syslog") || target.is_empty() {
continue;
}
let path = server_root.join(substitute(target, vars));
if !logs.iter().any(|(_, p)| *p == path) {
logs.push((kind, path));
}
}
logs
}
/// Lit un vhost et renvoie ses fichiers de log.
pub fn vhost_logs(path: &Path) -> Result<Vec<(LogKind, PathBuf)>, String> {
let conf = fs::read_to_string(path).map_err(|e| match e.kind() {
ErrorKind::NotFound => "Vhost introuvable sur le disque.".to_string(),
ErrorKind::PermissionDenied => format!("Accès refusé à « {} ».", path.display()),
_ => format!("Vhost illisible : {e}."),
})?;
let vars = fs::read_to_string(ENVVARS)
.map(|text| parse_envvars(&text))
.unwrap_or_default();
Ok(parse_vhost(&conf, &vars, Path::new(SERVER_ROOT)))
}
/// Valide le chemin saisi pour le vhost d'un projet et renvoie sa forme canonique.
pub fn validate_vhost_path(input: &str) -> Result<PathBuf, String> {
let input = input.trim();
let path = Path::new(&crate::scanner::expand_home(input))
.canonicalize()
.map_err(|e| match e.kind() {
ErrorKind::NotFound => format!("Le fichier « {input} » n'existe pas."),
ErrorKind::PermissionDenied => format!("Accès refusé à « {input} »."),
_ => format!("Le fichier « {input} » est inaccessible : {e}."),
})?;
if !path.is_file() {
return Err(format!("« {input} » n'est pas un fichier."));
}
if vhost_logs(&path)?.is_empty() {
return Err(format!(
"Aucune directive ErrorLog ni CustomLog dans « {input} »."
));
}
Ok(path)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn error_lines() {
let line = "[Wed Oct 21 11:29:09.705795 2026] [mpm_prefork:notice] [pid 2464:tid 2464] AH00170: caught SIGWINCH\n";
assert_eq!(
error_header(line),
Some(("2026-10-21 11:29:09".into(), "NOTICE".into()))
);
let (module, message, details) = split_error(line);
assert_eq!(module, "mpm_prefork");
assert_eq!(message, "AH00170: caught SIGWINCH");
assert_eq!(details, "");
let php = "[Thu Oct 01 09:00:00.1 2026] [php:error] [pid 12] [client 127.0.0.1:5000] PHP Fatal error: x";
assert_eq!(error_header(php).unwrap().1, "ERROR");
assert_eq!(split_error(php).2, "");
assert!(
split_error(php)
.1
.starts_with("[client 127.0.0.1:5000] PHP Fatal")
);
let old = "[Mon Mar 2 10:00:00 2026] [warn] message";
assert_eq!(
error_header(old),
Some(("2026-03-02 10:00:00".into(), "WARNING".into()))
);
assert_eq!(split_error(old).0, "");
assert_eq!(error_header("[Wed Oct 21 2026] [core:info] x"), None);
assert_eq!(error_header("PHP Stack trace:"), None);
assert_eq!(
error_header("[Wed Oct 21 11:29:09 2026] [core:trace5] x")
.unwrap()
.1,
"DEBUG"
);
}
#[test]
fn access_lines() {
let combined = r#"127.0.0.1 - - [21/Oct/2026:11:30:02 +0200] "GET /api/x?a=\"b\" HTTP/1.1" 500 1234 "-" "curl/8""#;
assert_eq!(
access_header(combined),
("2026-10-21 11:30:02".into(), "ERROR".into())
);
let (client, message, details) = split_access(&format!("{combined}\n"));
assert_eq!(client, "127.0.0.1");
assert_eq!(message, r#"500 GET /api/x?a=\"b\" HTTP/1.1"#);
assert_eq!(details, combined);
let vhost =
r#"gpao.loc:80 ::1 - bob [01/Jan/2026:00:00:00 +0000] "POST / HTTP/1.1" 404 0 "-" "-""#;
assert_eq!(access_header(vhost).1, "WARNING");
assert_eq!(split_access(vhost).0, "::1");
let common = r#"10.0.0.1 - - [01/Jan/2026:00:00:00 +0000] "GET / HTTP/1.1" 200 5"#;
assert_eq!(access_header(common).1, "INFO");
assert_eq!(access_header("https://referer -> /x").1, UNKNOWN_LEVEL);
}
#[test]
fn envvars() {
let text = "if [ x ] ; then\n\tSUFFIX=\"-x\"\nfi\nexport APACHE_RUN_USER=www-data\n\
export APACHE_LOG_DIR=/var/log/apache2$SUFFIX\nexport A=\"${APACHE_RUN_USER}/x\"\n";
let vars = parse_envvars(text);
assert_eq!(vars["APACHE_LOG_DIR"], "/var/log/apache2");
assert_eq!(vars["A"], "www-data/x");
}
#[test]
fn vhost_directives() {
let conf = r#"
<VirtualHost *:80>
ServerName gpao.loc
ErrorLog ${APACHE_LOG_DIR}/gpao.loc.log
CustomLog "${APACHE_LOG_DIR}/gpao access.log" combined
# ErrorLog /var/log/apache2/commented.log
customlog logs/relative.log common
CustomLog "|/usr/bin/rotatelogs /x 86400" common
ErrorLog syslog:local1
</VirtualHost>
<VirtualHost *:443>
ErrorLog ${APACHE_LOG_DIR}/gpao.loc.log
</VirtualHost>
"#;
let vars = HashMap::from([("APACHE_LOG_DIR".to_string(), "/var/log/apache2".to_string())]);
assert_eq!(
parse_vhost(conf, &vars, Path::new("/etc/apache2")),
[
(
LogKind::ApacheError,
PathBuf::from("/var/log/apache2/gpao.loc.log")
),
(
LogKind::ApacheAccess,
PathBuf::from("/var/log/apache2/gpao access.log")
),
(
LogKind::ApacheAccess,
PathBuf::from("/etc/apache2/logs/relative.log")
),
]
);
}
#[test]
fn vhost_validation() {
let dir = tempfile::tempdir().unwrap();
let empty = dir.path().join("empty.conf");
fs::write(&empty, "<VirtualHost *:80>\n</VirtualHost>\n").unwrap();
assert!(
validate_vhost_path(empty.to_str().unwrap())
.unwrap_err()
.contains("Aucune directive")
);
assert!(
validate_vhost_path("/nope.conf")
.unwrap_err()
.contains("n'existe pas")
);
assert!(
validate_vhost_path(dir.path().to_str().unwrap())
.unwrap_err()
.contains("n'est pas un fichier")
);
let good = dir.path().join("good.conf");
fs::write(&good, "ErrorLog /tmp/x.log\n").unwrap();
assert_eq!(
validate_vhost_path(good.to_str().unwrap()).unwrap(),
good.canonicalize().unwrap()
);
}
}
+154 -48
View File
@@ -6,48 +6,136 @@ use leptos::{prelude::*, server_fn::codec::Json};
#[cfg(feature = "ssr")]
use crate::server::{internal_error, not_found, now, pool, scanner};
/// Rafraîchit l'index de tous les projets puis renvoie les compteurs de non-lus.
/// Appelée à chaque cycle de polling.
/// Rafraîchit l'index des projets dont l'intervalle est écoulé, puis renvoie les compteurs
/// de non-lus. Appelée à chaque cycle de polling.
#[server(endpoint = "unread_summary")]
pub async fn unread_summary() -> Result<Summary, ServerFnError> {
let pool = pool()?;
scanner()?.scan_all(&pool).await.map_err(internal_error)?;
scanner()?.scan_due(&pool).await.map_err(internal_error)?;
crate::server::load_summary(&pool)
.await
.map_err(internal_error)
}
#[server(endpoint = "add_project")]
pub async fn add_project(path: String, name: String) -> Result<(), ServerFnError> {
let root = crate::scanner::validate_project_path(&path).map_err(ServerFnError::new)?;
/// Valide les champs du formulaire d'un projet. Le nom est obligatoire ; un vhost vide n'en
/// est pas un. Il faut au moins un dossier de logs ou un vhost.
#[cfg(feature = "ssr")]
fn project_fields(
path: &str,
name: &str,
refresh_seconds: u32,
hide_after_days: &str,
log_dirs: &str,
vhost: &str,
) -> Result<crate::scanner::ProjectConfig, ServerFnError> {
let refresh_seconds =
crate::model::validate_refresh(refresh_seconds).map_err(ServerFnError::new)?;
let hide_after_days =
crate::model::parse_hide_days(hide_after_days).map_err(ServerFnError::new)?;
use crate::scanner::{validate_log_dirs, validate_project_path};
let root = validate_project_path(path).map_err(ServerFnError::new)?;
let log_dirs = crate::model::parse_log_dirs(log_dirs);
validate_log_dirs(&root, &log_dirs).map_err(ServerFnError::new)?;
let root_str = root.to_string_lossy().to_string();
let name = match name.trim() {
"" => root
.file_name()
.map(|n| n.to_string_lossy().to_string())
.unwrap_or_else(|| root_str.clone()),
"" => return Err(ServerFnError::new("Veuillez saisir un nom.")),
name => name.to_string(),
};
let pool = pool()?;
let inserted: Result<i64, sqlx::Error> = sqlx::query_scalar(
"INSERT INTO projects (name, root_path, created_at) VALUES (?, ?, ?) RETURNING id",
)
.bind(&name)
.bind(&root_str)
.bind(now())
.fetch_one(&pool)
.await;
let id = match inserted {
Ok(id) => id,
Err(sqlx::Error::Database(e)) if e.is_unique_violation() => {
return Err(ServerFnError::new("Ce projet est déjà enregistré."));
}
Err(e) => return Err(internal_error(e)),
let vhost = match vhost.trim() {
"" => None,
vhost => Some(
crate::apache::validate_vhost_path(vhost)
.map_err(ServerFnError::new)?
.to_string_lossy()
.to_string(),
),
};
if log_dirs.is_empty() && vhost.is_none() {
return Err(ServerFnError::new(
"Indiquez au moins un dossier de logs ou un vhost.",
));
}
Ok(crate::scanner::ProjectConfig {
name,
root: root_str,
refresh_seconds,
hide_after_days,
log_dirs,
vhost,
})
}
/// Dossiers de logs probables du projet à `path` ; aucun si le chemin n'est pas valide.
#[server(endpoint = "suggest_log_dirs")]
pub async fn suggest_log_dirs(path: String) -> Result<Vec<String>, ServerFnError> {
Ok(crate::scanner::validate_project_path(&path)
.map(|root| crate::scanner::suggest_log_dirs(&root))
.unwrap_or_default())
}
#[cfg(feature = "ssr")]
fn save_error(error: sqlx::Error) -> ServerFnError {
match error {
sqlx::Error::Database(e) if e.is_unique_violation() => {
ServerFnError::new("Ce projet est déjà enregistré.")
}
e => internal_error(e),
}
}
/// Enregistre un projet : ses dossiers de logs (un par ligne) et, en option, le vhost Apache
/// dont les logs sont aussi suivis.
#[server(endpoint = "add_project")]
pub async fn add_project(
path: String,
name: String,
refresh_seconds: u32,
hide_after_days: String,
log_dirs: String,
vhost: String,
) -> Result<(), ServerFnError> {
let project = project_fields(
&path,
&name,
refresh_seconds,
&hide_after_days,
&log_dirs,
&vhost,
)?;
scanner()?
.scan_new_project(&pool, id, &root_str)
.add_project(&pool()?, &project)
.await
.map_err(internal_error)
.map_err(save_error)
}
/// Modifie le nom, le chemin, le rafraîchissement, les dossiers de logs ou le vhost d'un projet. Un vhost vide
/// le retire.
#[server(endpoint = "update_project")]
pub async fn update_project(
project_id: i64,
path: String,
name: String,
refresh_seconds: u32,
hide_after_days: String,
log_dirs: String,
vhost: String,
) -> Result<(), ServerFnError> {
let project = project_fields(
&path,
&name,
refresh_seconds,
&hide_after_days,
&log_dirs,
&vhost,
)?;
let found = scanner()?
.update_project(&pool()?, project_id, &project)
.await
.map_err(save_error)?;
if !found {
return Err(not_found());
}
Ok(())
}
#[server(endpoint = "remove_project")]
@@ -74,8 +162,9 @@ pub async fn read_entries(
) -> Result<EntriesPage, ServerFnError> {
use crate::{
model::{Entry, MAX_ENTRIES_LIMIT, MAX_ENTRY_BYTES},
model::{LogFormat, LogKind},
parser::split_entry,
scanner::logs_dir,
scanner::file_path,
};
use std::{
fs::File,
@@ -84,8 +173,26 @@ pub async fn read_entries(
};
let pool = pool()?;
let row: Option<(String, String, String, i64, i64)> = sqlx::query_as(
"SELECT p.root_path, p.name, f.relative_path, f.scan_offset, c.read_offset
// Le fichier affiché est toujours à jour, quel que soit l'intervalle de son projet.
let project_id: Option<i64> =
sqlx::query_scalar("SELECT project_id FROM log_files WHERE id = ?")
.bind(file_id)
.fetch_optional(&pool)
.await
.map_err(internal_error)?;
let Some(project_id) = project_id else {
return Err(not_found());
};
scanner()?
.scan_now(&pool, project_id)
.await
.map_err(internal_error)?;
/// (racine, nom du projet, chemin, origine, format, offset de scan, curseur de lecture)
type FileRow = (String, String, String, String, Option<String>, i64, i64);
let row: Option<FileRow> = sqlx::query_as(
"SELECT p.root_path, p.name, f.relative_path, f.kind, f.format, f.scan_offset,
c.read_offset
FROM log_files f
JOIN projects p ON p.id = f.project_id
JOIN read_cursors c ON c.log_file_id = f.id
@@ -95,10 +202,17 @@ pub async fn read_entries(
.fetch_optional(&pool)
.await
.map_err(internal_error)?;
let Some((root, project_name, relative_path, scan_offset, read_offset)) = row else {
let Some((root, project_name, relative_path, kind, format, scan_offset, read_offset)) = row
else {
return Err(not_found());
};
let path: PathBuf = logs_dir(root.as_ref()).join(&relative_path);
let kind = LogKind::parse(&kind).unwrap_or_default();
// Sans format détecté, le fichier n'a aucune entrée indexée.
let format = format
.as_deref()
.and_then(LogFormat::parse)
.unwrap_or(LogFormat::Lines);
let path: PathBuf = file_path(root.as_ref(), kind, &relative_path);
let limit = limit.clamp(1, MAX_ENTRIES_LIMIT) as usize;
let query = query.trim().to_lowercase();
@@ -156,7 +270,7 @@ pub async fn read_entries(
if !query.is_empty() && !content.to_lowercase().contains(&query) {
continue;
}
let (env, message, details) = split_entry(&content);
let (env, message, details) = split_entry(format, &content);
entries.push(Entry {
start: start as u64,
logged_at,
@@ -178,8 +292,9 @@ pub async fn read_entries(
let has_more = entries.len() > limit;
entries.truncate(limit);
let present: Vec<String> =
sqlx::query_scalar("SELECT DISTINCT level FROM log_entries_index WHERE log_file_id = ?")
let present: Vec<(String, i64)> = sqlx::query_as(
"SELECT level, COUNT(*) FROM log_entries_index WHERE log_file_id = ? GROUP BY level",
)
.bind(file_id)
.fetch_all(&pool)
.await
@@ -193,7 +308,10 @@ pub async fn read_entries(
has_more,
scan_offset: scan_offset as u64,
read_offset: read_offset as u64,
levels: present,
levels: present
.into_iter()
.map(|(level, count)| (level, count as u64))
.collect(),
})
}
@@ -243,18 +361,6 @@ pub async fn get_settings() -> Result<Settings, ServerFnError> {
.map_err(internal_error)
}
#[server(endpoint = "set_refresh_interval")]
pub async fn set_refresh_interval(seconds: String) -> Result<Settings, ServerFnError> {
let seconds = crate::model::parse_interval(&seconds).map_err(ServerFnError::new)?;
let pool = pool()?;
crate::server::set_setting(&pool, "refresh_interval_seconds", &seconds.to_string())
.await
.map_err(internal_error)?;
crate::server::load_settings(&pool)
.await
.map_err(internal_error)
}
/// Arrête ou reprend la lecture automatique des logs, conservé entre deux sessions.
#[server(endpoint = "set_paused")]
pub async fn set_paused(paused: bool) -> Result<(), ServerFnError> {
+754 -175
View File
File diff suppressed because it is too large. Load diff
+2
View File
@@ -1,3 +1,5 @@
#[cfg(feature = "ssr")]
pub mod apache;
pub mod api;
pub mod app;
pub mod model;
+2 -2
View File
@@ -2,13 +2,13 @@
#[tokio::main]
async fn main() {
use axum::Router;
use leptos::{logging::log, prelude::*};
use leptos_axum::{LeptosRoutes, generate_route_list};
use logs_reader::{
app::{App, shell},
scanner::Scanner,
server,
};
use leptos::{logging::log, prelude::*};
use leptos_axum::{LeptosRoutes, generate_route_list};
use std::{net::SocketAddr, process::exit, sync::Arc};
let database_url = std::env::var("LOGS_READER_DATABASE_URL")
+368 -21
View File
@@ -2,9 +2,22 @@
use serde::{Deserialize, Serialize};
pub const MIN_INTERVAL: u32 = 1;
pub const MAX_INTERVAL: u32 = 3600;
pub const DEFAULT_INTERVAL: u32 = 5;
/// Choix de rafraîchissement d'un projet (secondes, libellé) ; 0 = jamais.
pub const REFRESH_CHOICES: [(u32, &str); 9] = [
(0, "Jamais"),
(5, "5 s"),
(15, "15 s"),
(30, "30 s"),
(60, "1 min"),
(300, "5 min"),
(900, "15 min"),
(1800, "30 min"),
(3600, "1 h"),
];
pub const DEFAULT_REFRESH: u32 = 5;
/// Période du polling côté client : le plus petit choix non nul. Le serveur ne relit que les
/// projets dont l'intervalle est écoulé.
pub const POLL_SECONDS: u32 = 5;
/// Nombre d'entrées chargées par page dans la vue d'un fichier.
pub const PAGE_SIZE: u32 = 50;
/// Nombre maximal d'entrées renvoyées par un appel à `read_entries`.
@@ -38,14 +51,124 @@ pub struct ProjectSummary {
pub id: i64,
pub name: String,
pub root_path: String,
/// Intervalle de rafraîchissement (secondes), 0 = jamais.
pub refresh_seconds: u32,
/// Les fichiers non modifiés depuis plus de ce nombre de jours sont masqués.
pub hide_after_days: Option<u32>,
/// Nombre de fichiers masqués (absents de `files`).
pub hidden_files: u32,
/// Dossiers de logs, relatifs à la racine.
pub log_dirs: Vec<String>,
pub error: Option<String>,
/// Fichier de configuration du vhost Apache, s'il y en a un.
pub vhost_path: Option<String>,
pub vhost_error: Option<String>,
pub unread: u64,
pub files: Vec<FileSummary>,
}
/// Origine d'un fichier de log.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum LogKind {
/// Fichier `*.log` d'un dossier de logs du projet.
#[default]
Project,
/// `ErrorLog` du vhost Apache.
ApacheError,
/// `CustomLog` du vhost Apache.
ApacheAccess,
}
impl LogKind {
pub fn as_str(self) -> &'static str {
match self {
LogKind::Project => "project",
LogKind::ApacheError => "apache_error",
LogKind::ApacheAccess => "apache_access",
}
}
pub fn parse(value: &str) -> Option<Self> {
match value {
"project" => Some(LogKind::Project),
"apache_error" => Some(LogKind::ApacheError),
"apache_access" => Some(LogKind::ApacheAccess),
_ => None,
}
}
/// Format imposé par l'origine ; `None` pour un fichier du projet, dont le format est
/// détecté d'après ses premières lignes.
pub fn fixed_format(self) -> Option<LogFormat> {
match self {
LogKind::Project => None,
LogKind::ApacheError => Some(LogFormat::ApacheError),
LogKind::ApacheAccess => Some(LogFormat::Access),
}
}
}
/// Format d'un fichier de log, qui détermine son découpage en entrées.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum LogFormat {
/// `[date] env.LEVEL: message` (Laravel, Symfony…), lignes suivantes rattachées.
Monolog,
/// Log d'erreurs Apache : `[date] [module:niveau] message`.
ApacheError,
/// Log d'accès Apache ou nginx (`common`, `combined`) : une ligne par requête.
Access,
/// Format inconnu : une ligne par entrée, les lignes indentées rattachées à la précédente.
Lines,
}
impl LogFormat {
pub fn as_str(self) -> &'static str {
match self {
LogFormat::Monolog => "monolog",
LogFormat::ApacheError => "apache_error",
LogFormat::Access => "access",
LogFormat::Lines => "lines",
}
}
pub fn parse(value: &str) -> Option<Self> {
match value {
"monolog" => Some(LogFormat::Monolog),
"apache_error" => Some(LogFormat::ApacheError),
"access" => Some(LogFormat::Access),
"lines" => Some(LogFormat::Lines),
_ => None,
}
}
/// Les nouvelles entrées comptent dans les non-lus. Pas celles d'un log d'accès :
/// chaque requête en ajoute une.
pub fn notifies(self) -> bool {
self != LogFormat::Access
}
}
/// Dossiers de logs saisis (un par ligne ou séparés par des virgules) : sans espaces ni `/`
/// final, sans doublon ni dossier vide.
pub fn parse_log_dirs(input: &str) -> Vec<String> {
let mut dirs: Vec<String> = Vec::new();
for dir in input.split(['\n', ',']) {
let dir = dir.trim().trim_end_matches('/');
let dir = dir.strip_prefix("./").unwrap_or(dir);
if !dir.is_empty() && !dirs.iter().any(|d| d == dir) {
dirs.push(dir.to_string());
}
}
dirs
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct FileSummary {
pub id: i64,
pub kind: LogKind,
/// Relatif à la racine du projet, ou absolu pour un log Apache.
pub relative_path: String,
pub size: u64,
/// Date de dernière modification (secondes Unix).
@@ -66,8 +189,8 @@ pub struct EntriesPage {
pub scan_offset: u64,
/// Curseur de lecture au moment de l'appel.
pub read_offset: u64,
/// Niveaux présents dans le fichier, indépendamment des filtres.
pub levels: Vec<String>,
/// Nombre d'entrées de chaque niveau présent dans le fichier, indépendamment des filtres.
pub levels: Vec<(String, u64)>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
@@ -87,7 +210,6 @@ pub struct Entry {
#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
pub struct Settings {
pub refresh_interval_seconds: u32,
pub file_sort: FileSort,
/// Lecture automatique des logs arrêtée par l'utilisateur.
pub paused: bool,
@@ -144,18 +266,44 @@ pub fn relative_age(seconds: i64) -> String {
}
}
/// Valide l'intervalle saisi par l'utilisateur.
pub fn parse_interval(input: &str) -> Result<u32, String> {
input
.trim()
/// Vérifie que l'intervalle de rafraîchissement est l'un des choix proposés.
pub fn validate_refresh(seconds: u32) -> Result<u32, String> {
REFRESH_CHOICES
.iter()
.any(|(s, _)| *s == seconds)
.then_some(seconds)
.ok_or_else(|| "Intervalle de rafraîchissement invalide.".to_string())
}
/// Nombre de jours saisi pour masquer les fichiers anciens : vide pour n'en masquer aucun.
pub fn parse_hide_days(input: &str) -> Result<Option<u32>, String> {
match input.trim() {
"" => Ok(None),
days => days
.parse::<u32>()
.ok()
.filter(|s| (MIN_INTERVAL..=MAX_INTERVAL).contains(s))
.ok_or_else(|| {
format!(
"L'intervalle doit être un entier entre {MIN_INTERVAL} et {MAX_INTERVAL} secondes."
)
})
.filter(|d| *d > 0)
.map(Some)
.ok_or_else(|| "Le nombre de jours doit être un entier positif.".to_string()),
}
}
/// Vrai si un fichier modifié à `modified` (secondes Unix) est masqué à l'heure `now` :
/// sa dernière modification remonte à plus de `days` jours. Sans date, il reste affiché.
pub fn is_hidden(modified: Option<i64>, now: i64, days: Option<u32>) -> bool {
match (modified, days) {
(Some(modified), Some(days)) => now - modified > i64::from(days) * 86_400,
_ => false,
}
}
/// Libellé d'un intervalle de rafraîchissement (« 5 min », « Jamais »).
pub fn refresh_label(seconds: u32) -> String {
REFRESH_CHOICES
.iter()
.find(|(s, _)| *s == seconds)
.map(|(_, label)| label.to_string())
.unwrap_or_else(|| format!("{seconds} s"))
}
/// État affiché par le favicon.
@@ -244,17 +392,147 @@ pub fn human_size(bytes: u64) -> String {
}
}
/// Morceau d'une entrée affichée en détail : du texte, ou une valeur JSON (contexte et extra
/// de Monolog, écrits à la suite du message).
#[derive(Clone, Debug, PartialEq)]
pub enum EntryPart {
Text(String),
Json(serde_json::Value),
}
/// Découpe le texte complet d'une entrée en texte et valeurs JSON. Une valeur commence en
/// début de texte ou après un blanc ; un tableau n'est retenu que s'il n'est suivi d'aucun
/// texte, ailleurs c'est presque toujours du texte (`SQLSTATE[HY000] [1045]`). Les valeurs
/// vides (`[]`, `{}`) sont omises.
pub fn entry_parts(text: &str) -> Vec<EntryPart> {
// (début, fin, valeur) des valeurs JSON trouvées, dans l'ordre.
let mut found: Vec<(usize, usize, serde_json::Value)> = Vec::new();
let bytes = text.as_bytes();
let mut i = 0;
while i < bytes.len() {
let boundary = i == 0 || bytes[i - 1].is_ascii_whitespace();
if boundary
&& matches!(bytes[i], b'{' | b'[')
&& let Some((len, value)) = parse_json_at(&text[i..])
{
found.push((i, i + len, value));
i += len;
} else {
i += 1;
}
}
// Un tableau suivi de texte redevient du texte.
let mut kept: Vec<(usize, usize, serde_json::Value)> = Vec::new();
let mut text_after = false;
for (start, end, value) in found.into_iter().rev() {
let next = kept.last().map_or(text.len(), |(start, _, _)| *start);
text_after = text_after || !text[end..next].trim().is_empty();
if value.is_array() && text_after {
continue;
}
kept.push((start, end, value));
}
kept.reverse();
let mut parts = Vec::new();
let push_text = |parts: &mut Vec<EntryPart>, s: &str| {
let s = s.trim_matches(|c: char| c.is_whitespace());
if !s.is_empty() {
parts.push(EntryPart::Text(s.to_string()));
}
};
let mut from = 0;
for (start, end, value) in kept {
push_text(&mut parts, &text[from..start]);
let empty = match &value {
serde_json::Value::Array(a) => a.is_empty(),
serde_json::Value::Object(o) => o.is_empty(),
_ => false,
};
if !empty {
parts.push(EntryPart::Json(value));
}
from = end;
}
push_text(&mut parts, &text[from..]);
parts
}
/// Valeur JSON au début de `s` (un objet ou un tableau) et sa longueur en octets. Les sauts
/// de ligne bruts dans les chaînes sont acceptés : Monolog y écrit tels quels ceux des traces
/// d'exception.
fn parse_json_at(s: &str) -> Option<(usize, serde_json::Value)> {
let mut depth = 0usize;
let mut in_string = false;
let mut escaped = false;
let mut clean = String::new();
for (i, c) in s.char_indices() {
if in_string {
match c {
_ if escaped => escaped = false,
'\\' => escaped = true,
'"' => in_string = false,
'\n' => {
clean.push_str("\\n");
continue;
}
'\r' => continue,
'\t' => {
clean.push_str("\\t");
continue;
}
_ => {}
}
} else {
match c {
'"' => in_string = true,
'{' | '[' => depth += 1,
'}' | ']' => {
depth -= 1;
if depth == 0 {
clean.push(c);
return serde_json::from_str(&clean)
.ok()
.map(|value| (i + 1, value));
}
}
_ => {}
}
}
clean.push(c);
}
None
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn interval_bounds() {
assert_eq!(parse_interval("5"), Ok(5));
assert_eq!(parse_interval(" 3600 "), Ok(3600));
for bad in ["0", "3601", "-5", "abc", "", "1.5"] {
assert!(parse_interval(bad).is_err(), "{bad:?} devrait être refusé");
fn hide_old_files() {
assert_eq!(parse_hide_days(" "), Ok(None));
assert_eq!(parse_hide_days(" 30 "), Ok(Some(30)));
for bad in ["0", "-1", "1.5", "abc"] {
assert!(parse_hide_days(bad).is_err(), "{bad:?} devrait être refusé");
}
let day = 86_400;
assert!(!is_hidden(Some(0), 2 * day, None));
assert!(!is_hidden(None, 100 * day, Some(1)));
assert!(!is_hidden(Some(0), 2 * day, Some(2)));
assert!(is_hidden(Some(0), 2 * day + 1, Some(2)));
}
#[test]
fn refresh_choices() {
for ok in [0, 5, 15, 30, 60, 300, 900, 1800, 3600] {
assert_eq!(validate_refresh(ok), Ok(ok));
}
for bad in [1, 10, 3601] {
assert!(validate_refresh(bad).is_err(), "{bad} devrait être refusé");
}
assert_eq!(refresh_label(0), "Jamais");
assert_eq!(refresh_label(900), "15 min");
assert_eq!(POLL_SECONDS, REFRESH_CHOICES[1].0);
}
#[test]
@@ -273,6 +551,7 @@ mod tests {
fn file(name: &str, modified: Option<i64>) -> FileSummary {
FileSummary {
id: 0,
kind: LogKind::Project,
relative_path: name.to_string(),
size: 0,
modified,
@@ -306,6 +585,36 @@ mod tests {
assert_eq!(FileSort::parse("size"), None);
}
#[test]
fn kind_and_format_round_trip() {
for kind in [
LogKind::Project,
LogKind::ApacheError,
LogKind::ApacheAccess,
] {
assert_eq!(LogKind::parse(kind.as_str()), Some(kind));
}
for format in [
LogFormat::Monolog,
LogFormat::ApacheError,
LogFormat::Access,
LogFormat::Lines,
] {
assert_eq!(LogFormat::parse(format.as_str()), Some(format));
}
assert!(!LogFormat::Access.notifies());
assert!(LogFormat::Lines.notifies());
}
#[test]
fn log_dirs_input() {
assert_eq!(
parse_log_dirs(" storage/logs/ \n./var/log, logs\n\nstorage/logs"),
["storage/logs", "var/log", "logs"]
);
assert!(parse_log_dirs(" \n ,").is_empty());
}
#[test]
fn ages() {
assert_eq!(relative_age(-3), "à l'instant");
@@ -320,4 +629,42 @@ mod tests {
assert_eq!(page_title(0), "Logs Reader");
assert_eq!(page_title(150), "(150) Logs Reader");
}
#[test]
fn entry_parts_monolog_context() {
use serde_json::json;
let parts = entry_parts(r#"user simulate {"email":"a@b.c","of":"R1"} []"#);
assert_eq!(
parts,
vec![
EntryPart::Text("user simulate".into()),
EntryPart::Json(json!({"email": "a@b.c", "of": "R1"})),
]
);
// Crochets dans le message : du texte.
let text = "SQLSTATE[HY000] [1045] Access denied (Connection: mysql) {\"exception\":\"[object] (PDOException(code: 1045) at /a.php:70)\n[stacktrace]\n#0 {main}\n\"} ";
let parts = entry_parts(text);
assert_eq!(parts.len(), 2);
assert_eq!(
parts[0],
EntryPart::Text("SQLSTATE[HY000] [1045] Access denied (Connection: mysql)".into())
);
let EntryPart::Json(value) = &parts[1] else {
panic!("contexte attendu")
};
assert!(
value["exception"]
.as_str()
.unwrap()
.ends_with("#0 {main}\n")
);
assert_eq!(
entry_parts("liste [1, 2] puis texte"),
vec![EntryPart::Text("liste [1, 2] puis texte".into())]
);
assert_eq!(
entry_parts("{main} et {pas json"),
vec![EntryPart::Text("{main} et {pas json".into())]
);
}
}
+234 -22
View File
@@ -1,6 +1,10 @@
//! Découpage d'un fichier de log Laravel (format Monolog par défaut) en entrées.
//! Découpage d'un fichier de log en entrées, selon son format : Monolog (Laravel, Symfony…),
//! Apache (erreurs, accès) ou une ligne par entrée.
use crate::model::UNKNOWN_LEVEL;
use crate::{
apache,
model::{LogFormat, UNKNOWN_LEVEL},
};
use regex::Regex;
use std::{io::BufRead, sync::LazyLock};
@@ -31,6 +35,92 @@ pub fn parse_header(line: &str) -> Option<Header<'_>> {
})
}
/// Date en début de ligne (dans les 40 premiers caractères), au format `YYYY-MM-DD HH:MM:SS`.
static LINE_DATE: LazyLock<Regex> =
LazyLock::new(|| Regex::new(r"^.{0,40}?(\d{4}-\d{2}-\d{2})[ T](\d{2}:\d{2}:\d{2})").unwrap());
/// Niveau écrit en majuscules (`ERROR`, `[WARN]`…) ou en clé-valeur (`level=error`,
/// `"level":"warning"`).
static LINE_LEVEL: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(
r#"\b(EMERGENCY|ALERT|CRITICAL|CRIT|FATAL|ERROR|ERR|WARNING|WARN|NOTICE|INFO|DEBUG|TRACE)\b|(?i:\blevel"?\s*[=:]\s*"?([a-z]+))"#,
)
.unwrap()
});
/// Niveau PSR-3 correspondant à un nom de niveau courant.
fn normalize_level(name: &str) -> &'static str {
match name.to_ascii_uppercase().as_str() {
"EMERGENCY" | "EMERG" => "EMERGENCY",
"ALERT" => "ALERT",
"CRITICAL" | "CRIT" | "FATAL" => "CRITICAL",
"ERROR" | "ERR" => "ERROR",
"WARNING" | "WARN" => "WARNING",
"NOTICE" => "NOTICE",
"INFO" => "INFO",
"DEBUG" | "TRACE" => "DEBUG",
_ => UNKNOWN_LEVEL,
}
}
/// Date (vide si absente) et niveau d'une ligne d'un log au format inconnu.
fn line_header(line: &str) -> (String, String) {
let logged_at = LINE_DATE
.captures(line)
.map(|c| format!("{} {}", &c[1], &c[2]))
.unwrap_or_default();
let level = LINE_LEVEL
.captures(line)
.and_then(|c| c.get(1).or(c.get(2)))
.map_or(UNKNOWN_LEVEL, |m| normalize_level(m.as_str()));
(logged_at, level.to_string())
}
/// (date, niveau) si `line` ouvre une nouvelle entrée dans un fichier de ce format.
/// La date est vide quand la ligne n'en porte pas.
fn entry_header(format: LogFormat, line: &str) -> Option<(String, String)> {
match format {
LogFormat::Monolog => parse_header(line).map(|h| (h.logged_at.to_string(), h.level)),
LogFormat::ApacheError => apache::error_header(line),
LogFormat::Access => Some(apache::access_header(line)),
LogFormat::Lines => starts_entry(format, line.as_bytes()).then(|| line_header(line)),
}
}
/// Vrai si une ligne qui commence par ces octets ouvre vraisemblablement une nouvelle entrée.
/// Sert pour une ligne partielle en fin de fichier, dont l'en-tête n'est peut-être pas fini.
fn starts_entry(format: LogFormat, line: &[u8]) -> bool {
match format {
LogFormat::Monolog | LogFormat::ApacheError => line.first() == Some(&b'['),
LogFormat::Access => true,
// Les lignes indentées (stack trace Python, Java…) prolongent l'entrée précédente.
LogFormat::Lines => line.first().is_some_and(|b| !b.is_ascii_whitespace()),
}
}
/// Format d'un fichier d'après ses premières lignes complètes : le premier format reconnu
/// sur l'une d'elles, sinon une ligne par entrée. `None` sans ligne non vide (fichier vide).
pub fn detect_format(lines: &[&str]) -> Option<LogFormat> {
let lines: Vec<&str> = lines
.iter()
.copied()
.filter(|l| !l.trim().is_empty())
.collect();
if lines.is_empty() {
return None;
}
let format = if lines.iter().any(|l| parse_header(l).is_some()) {
LogFormat::Monolog
} else if lines.iter().any(|l| apache::error_header(l).is_some()) {
LogFormat::ApacheError
} else if lines.iter().any(|l| apache::is_access_line(l)) {
LogFormat::Access
} else {
LogFormat::Lines
};
Some(format)
}
/// Une entrée repérée dans le fichier, sans son contenu.
#[derive(Clone, Debug, PartialEq)]
pub struct IndexedEntry {
@@ -56,12 +146,16 @@ pub struct Indexed {
/// sinon on pourrait lire une stack trace à moitié écrite. Une entrée incomplète n'est pas
/// indexée : `offset` s'arrête à son début pour qu'elle soit relue au scan suivant.
/// `fallback_ts` horodate le texte qui ne commence pas par une ligne d'en-tête.
///
/// Dans un log d'accès, chaque ligne est une entrée : elle est complète dès son `\n`.
pub fn index_entries(
mut reader: impl BufRead,
start: u64,
fallback_ts: &str,
settled: bool,
format: LogFormat,
) -> std::io::Result<Indexed> {
let line_per_entry = format == LogFormat::Access;
let mut entries = Vec::new();
let mut current: Option<IndexedEntry> = None;
let mut pos = start;
@@ -73,10 +167,10 @@ pub fn index_entries(
break;
}
if buf.last() != Some(&b'\n') {
// Ligne partielle en fin de fichier. Si elle commence par `[`, c'est
// vraisemblablement une nouvelle entrée : la précédente est donc complète.
// Sinon, c'est la suite de l'entrée courante, qui n'est pas encore finie.
if buf.first() != Some(&b'[')
// Ligne partielle en fin de fichier. Si elle ouvre vraisemblablement une nouvelle
// entrée, la précédente est complète. Sinon, c'est la suite de l'entrée courante,
// qui n'est pas encore finie.
if !starts_entry(format, &buf)
&& let Some(cur) = current.take()
{
pos = cur.start;
@@ -84,7 +178,7 @@ pub fn index_entries(
break;
}
let line = String::from_utf8_lossy(&buf);
if let Some(header) = parse_header(&line) {
if let Some((logged_at, level)) = entry_header(format, &line) {
if let Some(mut cur) = current.take() {
cur.end = pos;
entries.push(cur);
@@ -92,8 +186,12 @@ pub fn index_entries(
current = Some(IndexedEntry {
start: pos,
end: 0,
logged_at: header.logged_at.to_string(),
level: header.level,
logged_at: if logged_at.is_empty() {
fallback_ts.to_string()
} else {
logged_at
},
level,
});
} else if current.is_none() {
current = Some(IndexedEntry {
@@ -106,7 +204,7 @@ pub fn index_entries(
pos += n;
}
if let Some(mut cur) = current {
if settled {
if settled || line_per_entry {
cur.end = pos;
entries.push(cur);
} else {
@@ -119,8 +217,18 @@ pub fn index_entries(
})
}
/// Découpe le texte d'une entrée en (env, message, détails).
pub fn split_entry(content: &str) -> (String, String, String) {
/// Découpe le texte d'une entrée en (env, message, détails). Pour Apache, « env » est le
/// module (log d'erreurs) ou le client (log d'accès).
pub fn split_entry(format: LogFormat, content: &str) -> (String, String, String) {
match format {
LogFormat::Monolog | LogFormat::Lines => split_monolog(content),
LogFormat::ApacheError => apache::split_error(content),
LogFormat::Access => apache::split_access(content),
}
}
/// En-tête Monolog retiré de la première ligne s'il y en a un ; sinon la ligne entière.
fn split_monolog(content: &str) -> (String, String, String) {
let content = content.trim_end_matches(['\n', '\r']);
let (first, rest) = content.split_once('\n').unwrap_or((content, ""));
let first = first.trim_end_matches('\r');
@@ -135,7 +243,14 @@ mod tests {
use super::*;
fn index(s: &str) -> Indexed {
index_entries(s.as_bytes(), 0, "2026-01-01 00:00:00", true).unwrap()
index_entries(
s.as_bytes(),
0,
"2026-01-01 00:00:00",
true,
LogFormat::Monolog,
)
.unwrap()
}
#[test]
@@ -185,7 +300,7 @@ mod tests {
fn last_entry_waits_until_settled() {
let first = "[2026-10-21 10:00:00] local.INFO: a\n";
let log = format!("{first}[2026-10-21 10:00:01] local.ERROR: b\n#0 trace\n");
let r = index_entries(log.as_bytes(), 0, "x", false).unwrap();
let r = index_entries(log.as_bytes(), 0, "x", false, LogFormat::Monolog).unwrap();
assert_eq!(r.entries.len(), 1);
assert_eq!(r.offset, first.len() as u64);
}
@@ -202,7 +317,7 @@ mod tests {
fn invalid_utf8_is_tolerated() {
let mut bytes = b"[2026-10-21 10:00:00] local.INFO: caf".to_vec();
bytes.extend_from_slice(&[0xff, 0xfe, b'\n']);
let r = index_entries(&bytes[..], 0, "x", true).unwrap();
let r = index_entries(&bytes[..], 0, "x", true, LogFormat::Monolog).unwrap();
assert_eq!(r.entries.len(), 1);
assert_eq!(r.offset, bytes.len() as u64);
}
@@ -211,7 +326,7 @@ mod tests {
fn incremental_from_offset() {
let a = "[2026-10-21 10:00:00] local.INFO: a\n";
let b = "[2026-10-21 10:00:01] local.INFO: b\n";
let r = index_entries(b.as_bytes(), a.len() as u64, "x", true).unwrap();
let r = index_entries(b.as_bytes(), a.len() as u64, "x", true, LogFormat::Monolog).unwrap();
assert_eq!(r.entries[0].start, a.len() as u64);
assert_eq!(r.offset, (a.len() + b.len()) as u64);
}
@@ -220,10 +335,28 @@ mod tests {
/// résultat que l'indexation d'un seul coup (pas de doublon ni d'entrée coupée).
#[test]
fn chunked_writes_match_full_index() {
let log = "[2026-10-21 10:00:00] local.ERROR: boom\n#0 a\n#1 b\n\
let laravel = "[2026-10-21 10:00:00] local.ERROR: boom\n#0 a\n#1 b\n\
[2026-10-21 10:00:01] local.INFO: ok\n\
[2026-10-21 10:00:02] local.WARNING: w\nmore\n";
let full = index(log);
let error = "[Wed Oct 21 11:29:09.7 2026] [php:error] [pid 1] boom\nPHP Stack trace:\n\
[Wed Oct 21 11:29:10.1 2026] [core:notice] [pid 1] ok\n";
let access = "1.2.3.4 - - [21/Oct/2026:11:30:02 +0200] \"GET / HTTP/1.1\" 200 5\n\
[strange line]\n\
1.2.3.4 - - [21/Oct/2026:11:30:03 +0200] \"GET /x HTTP/1.1\" 500 5\n";
let lines = "2026-10-21T10:00:00Z ERROR boom\nTraceback:\n File x\n\
plain line\n";
for (format, log) in [
(LogFormat::Monolog, laravel),
(LogFormat::ApacheError, error),
(LogFormat::Access, access),
(LogFormat::Lines, lines),
] {
chunked_matches_full(format, log);
}
}
fn chunked_matches_full(format: LogFormat, log: &str) {
let full = index_entries(log.as_bytes(), 0, "x", true, format).unwrap();
for step in 1..log.len() {
let mut offset = 0u64;
let mut entries = Vec::new();
@@ -232,18 +365,97 @@ mod tests {
written = (written + step).min(log.len());
let visible = &log.as_bytes()[offset as usize..written];
let settled = written == log.len();
let r = index_entries(visible, offset, "x", settled).unwrap();
let r = index_entries(visible, offset, "x", settled, format).unwrap();
entries.extend(r.entries);
offset = r.offset;
}
assert_eq!(entries, full.entries, "découpage par {step} octets");
assert_eq!(
entries, full.entries,
"{format:?}, découpage par {step} octets"
);
}
}
#[test]
fn apache_entries() {
let error = "[Wed Oct 21 11:29:09.7 2026] [php:error] [pid 1] boom\nPHP Stack trace:\n\
[Wed Oct 21 11:29:10.1 2026] [core:notice] [pid 1] ok\n";
let r = index_entries(error.as_bytes(), 0, "x", true, LogFormat::ApacheError).unwrap();
assert_eq!(r.entries.len(), 2);
assert_eq!(r.entries[0].level, "ERROR");
assert_eq!(r.entries[0].logged_at, "2026-10-21 11:29:09");
// Log d'accès : chaque ligne terminée est une entrée, même si le fichier vient d'être
// modifié ; une ligne inconnue reste une entrée à part, datée de la modification.
let access =
"1.2.3.4 - - [21/Oct/2026:11:30:02 +0200] \"GET / HTTP/1.1\" 404 5\nweird\npartial";
let r = index_entries(access.as_bytes(), 0, "mtime", false, LogFormat::Access).unwrap();
assert_eq!(r.entries.len(), 2);
assert_eq!(r.entries[0].level, "WARNING");
assert_eq!(r.entries[1].level, UNKNOWN_LEVEL);
assert_eq!(r.entries[1].logged_at, "mtime");
assert_eq!(r.offset, (access.len() - "partial".len()) as u64);
}
#[test]
fn format_detection() {
assert_eq!(detect_format(&[]), None);
assert_eq!(detect_format(&["", " "]), None);
assert_eq!(
detect_format(&["garbage", "[2026-10-21 10:00:00] prod.INFO: x"]),
Some(LogFormat::Monolog)
);
assert_eq!(
detect_format(&["[Wed Oct 21 11:29:09.7 2026] [core:notice] [pid 1] x"]),
Some(LogFormat::ApacheError)
);
assert_eq!(
detect_format(&[
r#"::1 - - [21/Oct/2026:11:30:02 +0200] "GET / HTTP/1.1" 200 5 "-" "-""#
]),
Some(LogFormat::Access)
);
assert_eq!(
detect_format(&["2026-10-21 10:00:00,123 - app - ERROR - boom"]),
Some(LogFormat::Lines)
);
}
#[test]
fn lines_format() {
let log = "2026-10-21T10:00:00.5Z [app] ERROR: boom\n at a.js:1\n\
Traceback (most recent call last):\n File \"a.py\"\n\
{\"level\":\"warn\",\"msg\":\"x\"}\nno level here\n";
let r = index_entries(log.as_bytes(), 0, "mtime", true, LogFormat::Lines).unwrap();
let summary: Vec<_> = r
.entries
.iter()
.map(|e| (e.logged_at.as_str(), e.level.as_str()))
.collect();
assert_eq!(
summary,
[
("2026-10-21 10:00:00", "ERROR"),
("mtime", UNKNOWN_LEVEL),
("mtime", "WARNING"),
("mtime", UNKNOWN_LEVEL),
]
);
// Les lignes indentées appartiennent à l'entrée qui les précède.
let (_, message, details) = split_entry(
LogFormat::Lines,
"Traceback (most recent call last):\n File \"a.py\"\n",
);
assert_eq!(message, "Traceback (most recent call last):");
assert_eq!(details, " File \"a.py\"");
}
#[test]
fn split() {
let (env, msg, details) =
split_entry("[2026-10-21 10:00:00] local.ERROR: boom\n#0 a\n#1 b\n");
let (env, msg, details) = split_entry(
LogFormat::Monolog,
"[2026-10-21 10:00:00] local.ERROR: boom\n#0 a\n#1 b\n",
);
assert_eq!(env, "local");
assert_eq!(msg, "boom");
assert_eq!(details, "#0 a\n#1 b");
+643 -102
View File
@@ -1,41 +1,53 @@
//! Découverte des fichiers de log d'un projet et indexation incrémentale de leurs entrées.
use crate::{
apache,
model::{LogFormat, LogKind, parse_log_dirs},
parser::{self, Indexed},
server::{format_ts, now},
};
use sqlx::{QueryBuilder, SqlitePool};
use std::{
collections::HashMap,
collections::{HashMap, HashSet},
fs::{self, File, Metadata},
io::{BufReader, ErrorKind, Read, Seek, SeekFrom},
path::{Path, PathBuf},
path::{Component, Path, PathBuf},
time::{Duration, Instant},
};
use tokio::sync::Mutex;
/// Délai sans modification au-delà duquel la dernière entrée d'un fichier est jugée complète.
pub const SETTLE_DELAY: Duration = Duration::from_secs(1);
/// Deux scans complets rapprochés de moins de ce délai n'en font qu'un (plusieurs onglets).
const MIN_SCAN_GAP: Duration = Duration::from_millis(500);
/// Marge sur l'intervalle d'un projet : un polling un peu en avance (timers du navigateur,
/// plusieurs onglets) ne le fait pas attendre un cycle de plus.
const DUE_MARGIN: Duration = Duration::from_secs(1);
pub fn logs_dir(root: &Path) -> PathBuf {
root.join("storage").join("logs")
/// Chemin sur le disque d'un fichier suivi : relatif à la racine pour un fichier du projet,
/// tel qu'enregistré (absolu) pour un log Apache.
pub fn file_path(root: &Path, kind: LogKind, relative_path: &str) -> PathBuf {
match kind {
LogKind::Project => root.join(relative_path),
LogKind::ApacheError | LogKind::ApacheAccess => PathBuf::from(relative_path),
}
}
/// Valide le chemin saisi pour un nouveau projet et renvoie sa forme canonique.
/// Remplace un `~` en tête de chemin par le répertoire personnel.
pub fn expand_home(input: &str) -> String {
match input.strip_prefix('~') {
Some(rest) if rest.is_empty() || rest.starts_with('/') => {
format!("{}{rest}", std::env::var("HOME").unwrap_or_default())
}
_ => input.to_string(),
}
}
/// Valide le chemin saisi pour un projet et renvoie sa forme canonique.
pub fn validate_project_path(input: &str) -> Result<PathBuf, String> {
let input = input.trim();
if input.is_empty() {
return Err("Veuillez saisir un chemin.".into());
}
let expanded = match input.strip_prefix('~') {
Some(rest) if rest.is_empty() || rest.starts_with('/') => {
format!("{}{rest}", std::env::var("HOME").unwrap_or_default())
}
_ => input.to_string(),
};
let path = Path::new(&expanded)
let path = Path::new(&expand_home(input))
.canonicalize()
.map_err(|e| match e.kind() {
ErrorKind::NotFound => format!("Le chemin « {input} » n'existe pas."),
@@ -45,24 +57,51 @@ pub fn validate_project_path(input: &str) -> Result<PathBuf, String> {
if !path.is_dir() {
return Err(format!("« {input} » n'est pas un répertoire."));
}
if !path.join("artisan").is_file() {
return Err(format!(
"« {input} » ne semble pas être un projet Laravel (fichier artisan introuvable)."
));
Ok(path)
}
/// Vérifie que chaque dossier de logs est un sous-dossier lisible du projet.
pub fn validate_log_dirs(root: &Path, dirs: &[String]) -> Result<(), String> {
for dir in dirs {
let relative = Path::new(dir);
if !relative
.components()
.all(|c| matches!(c, Component::Normal(_)))
{
return Err(format!("« {dir} » doit être un sous-dossier du projet."));
}
let logs = logs_dir(&path);
if !logs.is_dir() {
return Err(format!(
"Répertoire storage/logs introuvable dans « {input} »."
));
let path = root.join(relative);
if !path.is_dir() {
return Err(format!("Dossier « {dir} » introuvable dans le projet."));
}
if let Err(e) = fs::read_dir(&logs) {
if let Err(e) = fs::read_dir(&path) {
return Err(match e.kind() {
ErrorKind::PermissionDenied => format!("Accès refusé à « {} ».", logs.display()),
_ => format!("« {} » est illisible : {e}.", logs.display()),
ErrorKind::PermissionDenied => format!("Accès refusé à « {dir} »."),
_ => format!("« {dir} » est illisible : {e}."),
});
}
Ok(path)
}
Ok(())
}
/// Dossiers de logs probables d'un projet : ceux de Laravel (`artisan`) et de Symfony
/// (`bin/console`), puis les noms courants, s'ils existent.
pub fn suggest_log_dirs(root: &Path) -> Vec<String> {
let mut candidates = Vec::new();
if root.join("artisan").is_file() {
candidates.push("storage/logs");
}
if root.join("bin/console").is_file() {
candidates.push("var/log");
}
candidates.extend(["storage/logs", "var/log", "var/logs", "logs", "log"]);
let mut dirs: Vec<String> = Vec::new();
for dir in candidates {
if root.join(dir).is_dir() && !dirs.iter().any(|d| d == dir) {
dirs.push(dir.to_string());
}
}
dirs
}
/// Fichiers `*.log` sous `dir` (récursivement), avec leur chemin relatif (séparateur `/`).
@@ -134,6 +173,9 @@ fn identity(meta: &Metadata) -> Option<String> {
#[derive(Clone, Debug)]
struct Known {
id: i64,
kind: LogKind,
/// `None` tant que le format n'a pas pu être détecté (fichier vide).
format: Option<LogFormat>,
identity: Option<String>,
scan_offset: u64,
missing: bool,
@@ -149,10 +191,26 @@ enum Outcome {
identity: Option<String>,
/// Le fichier a été tronqué, remplacé ou recréé : on repart de zéro.
reset: bool,
format: Option<LogFormat>,
indexed: Indexed,
},
}
/// Lignes lues au début d'un fichier pour détecter son format.
const SNIFF_LINES: usize = 50;
/// Format d'un fichier d'après ses premières lignes complètes (E/S bloquantes).
fn sniff_format(path: &Path) -> std::io::Result<Option<LogFormat>> {
let mut head = Vec::new();
File::open(path)?.take(64 * 1024).read_to_end(&mut head)?;
let text = String::from_utf8_lossy(&head);
// Le dernier morceau n'est pas une ligne complète (ou est vide).
let mut lines: Vec<&str> = text.split('\n').collect();
lines.pop();
lines.truncate(SNIFF_LINES);
Ok(parser::detect_format(&lines))
}
/// Lit la partie nouvelle d'un fichier (E/S bloquantes).
fn scan_file(path: &Path, known: &Known) -> Outcome {
let meta = match fs::metadata(path) {
@@ -170,18 +228,35 @@ fn scan_file(path: &Path, known: &Known) -> Outcome {
|| size < known.scan_offset
|| (known.identity.is_some() && ident != known.identity);
let from = if reset { 0 } else { known.scan_offset };
if from == size {
return Outcome::Scanned {
// Un fichier remplacé peut avoir changé de format : il est redétecté.
let format = match reset {
true => known.kind.fixed_format(),
false => known.format.or(known.kind.fixed_format()),
};
let nothing_new = |format| Outcome::Scanned {
size,
modified: modified_unix,
identity: ident,
identity: ident.clone(),
reset,
format,
indexed: Indexed {
entries: Vec::new(),
offset: from,
},
};
if from == size {
return nothing_new(format);
}
let format = match format {
Some(format) => format,
None => match sniff_format(path) {
Ok(Some(format)) => format,
// Pas encore de ligne complète : on attend le prochain scan.
Ok(None) => return nothing_new(None),
Err(e) if e.kind() == ErrorKind::NotFound => return Outcome::Missing,
Err(e) => return Outcome::Error(e.to_string()),
},
};
let settled = modified
.and_then(|m| m.elapsed().ok())
.is_none_or(|elapsed| elapsed >= SETTLE_DELAY);
@@ -191,7 +266,7 @@ fn scan_file(path: &Path, known: &Known) -> Outcome {
file.seek(SeekFrom::Start(from))?;
// Borné à la taille observée : ce qui est écrit pendant la lecture attendra le prochain scan.
let reader = BufReader::with_capacity(64 * 1024, file.take(size - from));
parser::index_entries(reader, from, &fallback_ts, settled)
parser::index_entries(reader, from, &fallback_ts, settled, format)
};
match read() {
Ok(indexed) => Outcome::Scanned {
@@ -199,6 +274,7 @@ fn scan_file(path: &Path, known: &Known) -> Outcome {
modified: modified_unix,
identity: ident,
reset,
format: Some(format),
indexed,
},
Err(e) if e.kind() == ErrorKind::NotFound => Outcome::Missing,
@@ -230,6 +306,7 @@ async fn apply(pool: &SqlitePool, file_id: i64, outcome: Outcome) -> sqlx::Resul
modified,
identity,
reset,
format,
indexed,
} => {
let mut tx = pool.begin().await?;
@@ -261,7 +338,7 @@ async fn apply(pool: &SqlitePool, file_id: i64, outcome: Outcome) -> sqlx::Resul
}
sqlx::query(
"UPDATE log_files
SET size = ?, modified_at = ?, file_identity = ?, scan_offset = ?,
SET size = ?, modified_at = ?, file_identity = ?, format = ?, scan_offset = ?,
entries_count = CASE WHEN ? THEN 0 ELSE entries_count END + ?,
missing_since = NULL, last_error = NULL
WHERE id = ?",
@@ -269,6 +346,7 @@ async fn apply(pool: &SqlitePool, file_id: i64, outcome: Outcome) -> sqlx::Resul
.bind(size as i64)
.bind(modified)
.bind(identity)
.bind(format.map(LogFormat::as_str))
.bind(indexed.offset as i64)
.bind(reset)
.bind(indexed.entries.len() as i64)
@@ -281,47 +359,94 @@ async fn apply(pool: &SqlitePool, file_id: i64, outcome: Outcome) -> sqlx::Resul
Ok(())
}
/// Découvre et indexe les fichiers d'un projet.
///
/// Avec `mark_existing_read`, les curseurs sont placés en fin de fichier : utilisé à l'ajout
/// du projet, pour que l'historique ne soit pas compté comme non-lu.
async fn scan_project(
pool: &SqlitePool,
project_id: i64,
root: &str,
mark_existing_read: bool,
) -> sqlx::Result<()> {
/// Curseurs de lecture à placer en fin de fichier après le scan, pour que l'historique ne
/// soit pas compté comme non-lu.
#[derive(Clone, Copy, PartialEq)]
enum MarkRead {
None,
/// Tous les fichiers du projet : à l'ajout du projet.
All,
/// Les fichiers apparus pendant ce scan : à la modification du projet.
New,
}
/// Fichiers `*.log` des dossiers de logs, avec leur chemin relatif à la racine, ou l'erreur à
/// afficher sur le projet.
async fn project_files(root: &str, dirs: Vec<String>) -> Result<Vec<(String, PathBuf)>, String> {
let root = PathBuf::from(root);
let logs = logs_dir(&root);
let discovered = tokio::task::spawn_blocking(move || {
if !root.is_dir() || !logs.is_dir() {
tokio::task::spawn_blocking(move || {
if !root.is_dir() {
return Err("Projet introuvable sur le disque.".to_string());
}
discover(&logs).map_err(|e| format!("storage/logs illisible : {e}."))
let mut files: Vec<(String, PathBuf)> = Vec::new();
for dir in dirs {
let path = root.join(&dir);
if !path.is_dir() {
return Err(format!("Dossier de logs « {dir} » introuvable."));
}
let found = discover(&path).map_err(|e| format!("« {dir} » illisible : {e}."))?;
for (relative, path) in found {
let relative = format!("{dir}/{relative}");
// Deux dossiers imbriqués trouvent les mêmes fichiers.
if !files.iter().any(|(r, _)| *r == relative) {
files.push((relative, path));
}
}
}
Ok(files)
})
.await
.unwrap_or_else(|e| Err(e.to_string()));
.unwrap_or_else(|e| Err(e.to_string()))
}
let discovered = match discovered {
Ok(files) => {
sqlx::query("UPDATE projects SET last_error = NULL WHERE id = ?")
/// Fichiers de log déclarés par le vhost, ou l'erreur à afficher sur le vhost.
async fn apache_files(vhost: &str) -> Result<Vec<(LogKind, PathBuf)>, String> {
let vhost = PathBuf::from(vhost);
tokio::task::spawn_blocking(move || apache::vhost_logs(&vhost))
.await
.unwrap_or_else(|e| Err(e.to_string()))
}
/// Découvre et indexe les fichiers d'un projet : ceux de ses dossiers de logs et ceux de son
/// vhost, d'après sa configuration en base.
async fn scan_project(pool: &SqlitePool, project_id: i64, mark_read: MarkRead) -> sqlx::Result<()> {
let config: Option<(String, String, Option<String>)> =
sqlx::query_as("SELECT root_path, log_dirs, vhost_path FROM projects WHERE id = ?")
.bind(project_id)
.execute(pool)
.await?;
files
}
Err(message) => {
sqlx::query("UPDATE projects SET last_error = ? WHERE id = ?")
.bind(message)
.bind(project_id)
.execute(pool)
.fetch_optional(pool)
.await?;
let Some((root, log_dirs, vhost)) = config else {
return Ok(());
}
};
let dirs = parse_log_dirs(&log_dirs);
let local = project_files(&root, dirs.clone()).await;
sqlx::query("UPDATE projects SET last_error = ? WHERE id = ?")
.bind(local.as_ref().err())
.bind(project_id)
.execute(pool)
.await?;
let apache = match &vhost {
Some(vhost) => Some(apache_files(vhost).await),
None => None,
};
sqlx::query("UPDATE projects SET vhost_error = ? WHERE id = ?")
.bind(apache.as_ref().and_then(|r| r.as_ref().err()))
.bind(project_id)
.execute(pool)
.await?;
let rows: Vec<(i64, String, Option<String>, i64, bool)> = sqlx::query_as(
"SELECT id, relative_path, file_identity, scan_offset, missing_since IS NOT NULL
type Row = (
i64,
String,
String,
Option<String>,
Option<String>,
i64,
bool,
);
let rows: Vec<Row> = sqlx::query_as(
"SELECT id, relative_path, kind, format, file_identity, scan_offset,
missing_since IS NOT NULL
FROM log_files WHERE project_id = ?",
)
.bind(project_id)
@@ -329,11 +454,13 @@ async fn scan_project(
.await?;
let mut known: HashMap<String, Known> = rows
.into_iter()
.map(|(id, rel, identity, offset, missing)| {
.map(|(id, rel, kind, format, identity, offset, missing)| {
(
rel,
Known {
id,
kind: LogKind::parse(&kind).unwrap_or_default(),
format: format.as_deref().and_then(LogFormat::parse),
identity,
scan_offset: offset as u64,
missing,
@@ -342,18 +469,53 @@ async fn scan_project(
})
.collect();
for (relative, path) in discovered {
// Fichiers à scanner. Si les dossiers de logs ou le vhost sont illisibles, leurs fichiers
// connus sont laissés tels quels jusqu'au retour à la normale.
let mut wanted: Vec<(String, LogKind, PathBuf)> = Vec::new();
if let Ok(files) = &local {
wanted.extend(
files
.iter()
.map(|(rel, path)| (rel.clone(), LogKind::Project, path.clone())),
);
}
if let Some(Ok(files)) = &apache {
wanted.extend(
files
.iter()
.map(|(kind, path)| (path.to_string_lossy().to_string(), *kind, path.clone())),
);
}
let mut new_ids = Vec::new();
for (relative, kind, path) in wanted {
let state = match known.remove(&relative) {
Some(state) => state,
Some(state) if state.kind == kind => state,
Some(state) => {
// Le fichier a changé d'origine (ErrorLog ↔ CustomLog, dossier du projet
// déclaré dans le vhost) : réindexé dans son nouveau format.
sqlx::query("UPDATE log_files SET kind = ? WHERE id = ?")
.bind(kind.as_str())
.bind(state.id)
.execute(pool)
.await?;
Known {
kind,
format: None,
missing: true,
..state
}
}
None => {
// Nouveau fichier : tout son contenu est non-lu (curseur à 0).
let ts = now();
let id: i64 = sqlx::query_scalar(
"INSERT INTO log_files (project_id, relative_path, discovered_at)
VALUES (?, ?, ?) RETURNING id",
"INSERT INTO log_files (project_id, relative_path, kind, discovered_at)
VALUES (?, ?, ?, ?) RETURNING id",
)
.bind(project_id)
.bind(&relative)
.bind(kind.as_str())
.bind(&ts)
.fetch_one(pool)
.await?;
@@ -364,8 +526,11 @@ async fn scan_project(
.bind(&ts)
.execute(pool)
.await?;
new_ids.push(id);
Known {
id,
kind,
format: None,
identity: None,
scan_offset: 0,
missing: false,
@@ -379,59 +544,191 @@ async fn scan_project(
apply(pool, file_id, outcome).await?;
}
// Fichiers connus qui n'ont pas été retrouvés.
for state in known.into_values() {
// Fichiers connus qui n'ont pas été retrouvés : un fichier disparu d'un dossier de logs
// est marqué manquant ; un fichier hors des dossiers de logs, ou que le vhost ne déclare
// plus, n'est plus suivi.
let apache_listed = !matches!(apache, Some(Err(_)));
for (relative, state) in known {
let in_dirs = dirs
.iter()
.any(|dir| relative.starts_with(&format!("{dir}/")));
let forget = match state.kind {
LogKind::Project if local.is_err() => false,
LogKind::Project if in_dirs => {
apply(pool, state.id, Outcome::Missing).await?;
false
}
if mark_existing_read {
sqlx::query(
"UPDATE read_cursors
SET read_offset = (SELECT scan_offset FROM log_files WHERE id = log_file_id),
updated_at = ?
WHERE log_file_id IN (SELECT id FROM log_files WHERE project_id = ?)",
)
.bind(now())
.bind(project_id)
LogKind::Project => true,
LogKind::ApacheError | LogKind::ApacheAccess => apache_listed,
};
if forget {
sqlx::query("DELETE FROM log_files WHERE id = ?")
.bind(state.id)
.execute(pool)
.await?;
}
}
let mut mark = QueryBuilder::new(
"UPDATE read_cursors
SET read_offset = (SELECT scan_offset FROM log_files WHERE id = log_file_id),
updated_at = ",
);
mark.push_bind(now());
match mark_read {
MarkRead::None => return Ok(()),
MarkRead::All => {
mark.push(" WHERE log_file_id IN (SELECT id FROM log_files WHERE project_id = ")
.push_bind(project_id)
.push(")");
}
MarkRead::New if new_ids.is_empty() => return Ok(()),
MarkRead::New => {
mark.push(" WHERE log_file_id IN (");
let mut ids = mark.separated(", ");
for id in &new_ids {
ids.push_bind(id);
}
mark.push(")");
}
}
mark.build().execute(pool).await?;
Ok(())
}
/// Sérialise les scans : un seul à la fois, quel que soit le nombre d'onglets ouverts.
/// Sérialise les scans (un seul à la fois, quel que soit le nombre d'onglets ouverts) et
/// retient quand chaque projet a été relu.
#[derive(Default)]
pub struct Scanner {
last_full_scan: Mutex<Option<Instant>>,
last_scans: Mutex<HashMap<i64, Instant>>,
}
impl Scanner {
/// Scanne tous les projets, sauf si un scan complet vient de se terminer.
pub async fn scan_all(&self, pool: &SqlitePool) -> sqlx::Result<()> {
let mut last = self.last_full_scan.lock().await;
if last.is_some_and(|t| t.elapsed() < MIN_SCAN_GAP) {
return Ok(());
}
let projects: Vec<(i64, String)> = sqlx::query_as("SELECT id, root_path FROM projects")
/// Relit les projets dont l'intervalle de rafraîchissement est écoulé. Un projet réglé sur
/// « jamais » n'est pas relu ici.
pub async fn scan_due(&self, pool: &SqlitePool) -> sqlx::Result<()> {
let mut last = self.last_scans.lock().await;
let projects: Vec<(i64, i64)> =
sqlx::query_as("SELECT id, refresh_seconds FROM projects WHERE refresh_seconds > 0")
.fetch_all(pool)
.await?;
for (id, root) in projects {
scan_project(pool, id, &root, false).await?;
let ids: HashSet<i64> = projects.iter().map(|(id, _)| *id).collect();
last.retain(|id, _| ids.contains(id));
for (id, refresh) in projects {
let interval = Duration::from_secs(refresh as u64);
if last
.get(&id)
.is_some_and(|t| t.elapsed() + DUE_MARGIN < interval)
{
continue;
}
scan_project(pool, id, MarkRead::None).await?;
last.insert(id, Instant::now());
}
*last = Some(Instant::now());
Ok(())
}
/// Premier scan d'un projet qui vient d'être ajouté.
pub async fn scan_new_project(
/// Relit un projet tout de suite, quel que soit son intervalle : quand un de ses fichiers
/// est affiché.
pub async fn scan_now(&self, pool: &SqlitePool, project_id: i64) -> sqlx::Result<()> {
let mut last = self.last_scans.lock().await;
scan_project(pool, project_id, MarkRead::None).await?;
last.insert(project_id, Instant::now());
Ok(())
}
/// Enregistre un nouveau projet et fait son premier scan : l'historique de ses fichiers
/// n'est pas compté comme non-lu.
///
/// Le verrou couvre l'enregistrement et le scan : un scan périodique ne peut pas découvrir
/// les fichiers entre les deux et compter tout leur contenu en non-lu.
pub async fn add_project(
&self,
pool: &SqlitePool,
project: &ProjectConfig,
) -> sqlx::Result<()> {
let mut last = self.last_scans.lock().await;
let id: i64 = sqlx::query_scalar(
"INSERT INTO projects
(name, root_path, refresh_seconds, hide_after_days, log_dirs, vhost_path, created_at)
VALUES (?, ?, ?, ?, ?, ?, ?) RETURNING id",
)
.bind(&project.name)
.bind(&project.root)
.bind(project.refresh_seconds)
.bind(project.hide_after_days)
.bind(project.log_dirs.join("\n"))
.bind(&project.vhost)
.bind(now())
.fetch_one(pool)
.await?;
scan_project(pool, id, MarkRead::All).await?;
last.insert(id, Instant::now());
Ok(())
}
/// Modifie un projet puis le scanne. Les fichiers qui deviennent suivis ne sont pas
/// comptés comme non-lus ; ceux qui ne le sont plus sont oubliés, et un changement de
/// chemin oublie tous les fichiers de l'ancien. Renvoie `false` si le projet n'existe pas.
pub async fn update_project(
&self,
pool: &SqlitePool,
project_id: i64,
root: &str,
) -> sqlx::Result<()> {
let _guard = self.last_full_scan.lock().await;
scan_project(pool, project_id, root, true).await
project: &ProjectConfig,
) -> sqlx::Result<bool> {
let mut last = self.last_scans.lock().await;
let mut tx = pool.begin().await?;
let old_root: Option<String> =
sqlx::query_scalar("SELECT root_path FROM projects WHERE id = ?")
.bind(project_id)
.fetch_optional(&mut *tx)
.await?;
let Some(old_root) = old_root else {
return Ok(false);
};
sqlx::query(
"UPDATE projects
SET name = ?, root_path = ?, refresh_seconds = ?, hide_after_days = ?,
log_dirs = ?, vhost_path = ?, vhost_error = NULL
WHERE id = ?",
)
.bind(&project.name)
.bind(&project.root)
.bind(project.refresh_seconds)
.bind(project.hide_after_days)
.bind(project.log_dirs.join("\n"))
.bind(&project.vhost)
.bind(project_id)
.execute(&mut *tx)
.await?;
if old_root != project.root {
sqlx::query("DELETE FROM log_files WHERE project_id = ? AND kind = ?")
.bind(project_id)
.bind(LogKind::Project.as_str())
.execute(&mut *tx)
.await?;
}
tx.commit().await?;
scan_project(pool, project_id, MarkRead::New).await?;
last.insert(project_id, Instant::now());
Ok(true)
}
}
/// Configuration d'un projet, validée.
#[derive(Clone, Debug)]
pub struct ProjectConfig {
pub name: String,
/// Chemin canonique.
pub root: String,
/// Secondes, 0 = jamais.
pub refresh_seconds: u32,
/// Fichiers non modifiés depuis plus de ce nombre de jours masqués.
pub hide_after_days: Option<u32>,
/// Relatifs à la racine.
pub log_dirs: Vec<String>,
/// Chemin canonique du vhost Apache.
pub vhost: Option<String>,
}
#[cfg(test)]
@@ -439,6 +736,10 @@ mod tests {
use super::*;
use std::io::Write;
fn logs_dir(root: &Path) -> PathBuf {
root.join("storage/logs")
}
fn laravel_project() -> tempfile::TempDir {
let dir = tempfile::tempdir().unwrap();
fs::write(dir.path().join("artisan"), "").unwrap();
@@ -461,20 +762,45 @@ mod tests {
.unwrap_err()
.contains("n'est pas un répertoire")
);
// N'importe quel dossier est un projet.
let plain = tempfile::tempdir().unwrap();
assert!(validate_project_path(plain.path().to_str().unwrap()).is_ok());
}
#[test]
fn log_dirs_validation() {
let project = laravel_project();
let root = project.path();
assert!(validate_log_dirs(root, &["storage/logs".into()]).is_ok());
assert!(validate_log_dirs(root, &[]).is_ok());
for outside in ["../x", "/var/log", ".", "storage/../storage"] {
assert!(
validate_project_path(plain.path().to_str().unwrap())
validate_log_dirs(root, &[outside.into()])
.unwrap_err()
.contains("artisan")
.contains("sous-dossier"),
"{outside}"
);
fs::write(plain.path().join("artisan"), "").unwrap();
}
assert!(
validate_project_path(plain.path().to_str().unwrap())
validate_log_dirs(root, &["var/log".into()])
.unwrap_err()
.contains("storage/logs")
.contains("introuvable")
);
}
#[test]
fn log_dirs_suggestions() {
let project = laravel_project();
assert_eq!(suggest_log_dirs(project.path()), ["storage/logs"]);
let symfony = tempfile::tempdir().unwrap();
fs::create_dir_all(symfony.path().join("bin")).unwrap();
fs::write(symfony.path().join("bin/console"), "").unwrap();
fs::create_dir_all(symfony.path().join("var/log")).unwrap();
fs::create_dir(symfony.path().join("logs")).unwrap();
assert_eq!(suggest_log_dirs(symfony.path()), ["var/log", "logs"]);
assert!(suggest_log_dirs(tempfile::tempdir().unwrap().path()).is_empty());
}
#[test]
fn validation_canonicalizes() {
let project = laravel_project();
@@ -534,6 +860,8 @@ mod tests {
fn known(offset: u64, identity: Option<String>) -> Known {
Known {
id: 1,
kind: LogKind::Project,
format: None,
identity,
scan_offset: offset,
missing: false,
@@ -553,6 +881,13 @@ mod tests {
}
}
fn scanned_format(outcome: Outcome) -> Option<LogFormat> {
match outcome {
Outcome::Scanned { format, .. } => format,
other => panic!("scan inattendu : {other:?}"),
}
}
#[test]
fn truncation_and_rotation_reset() {
let project = laravel_project();
@@ -587,6 +922,22 @@ mod tests {
}
}
#[test]
fn format_is_detected_once_a_line_is_complete() {
let project = laravel_project();
let path = logs_dir(project.path()).join("worker.log");
fs::write(&path, "").unwrap();
assert_eq!(scanned_format(scan_file(&path, &known(0, None))), None);
fs::write(&path, "2026-10-21 10:00:00 WARN slow").unwrap();
assert_eq!(scanned_format(scan_file(&path, &known(0, None))), None);
fs::write(&path, "2026-10-21 10:00:00 WARN slow\n").unwrap();
settle(&path);
let outcome = scan_file(&path, &known(0, None));
assert_eq!(scanned_format(outcome), Some(LogFormat::Lines));
let (_, _, _, indexed) = scanned(scan_file(&path, &known(0, None)));
assert_eq!(indexed.entries[0].level, "WARNING");
}
#[test]
fn last_entry_waits_for_settle() {
let project = laravel_project();
@@ -600,6 +951,196 @@ mod tests {
assert_eq!(indexed.entries.len(), 1);
}
fn config(root: &Path, dirs: &[&str], vhost: Option<&Path>) -> ProjectConfig {
ProjectConfig {
name: "p".into(),
root: root.to_string_lossy().to_string(),
refresh_seconds: 5,
hide_after_days: None,
log_dirs: dirs.iter().map(|d| d.to_string()).collect(),
vhost: vhost.map(|v| v.to_string_lossy().to_string()),
}
}
fn append(path: &Path, line: &str) {
File::options()
.append(true)
.open(path)
.unwrap()
.write_all(line.as_bytes())
.unwrap();
}
/// Dossiers de logs et vhost : l'historique des fichiers qui deviennent suivis n'est pas
/// non-lu, une nouvelle erreur l'est, une nouvelle requête non ; un dossier ou un vhost
/// retiré cesse de suivre ses fichiers.
#[tokio::test]
async fn project_sources() {
let project = laravel_project();
let root = project.path();
fs::create_dir(root.join("logs")).unwrap();
let worker = root.join("logs/worker.log");
fs::write(&worker, "2026-10-21 10:00:00 ERROR old\n").unwrap();
settle(&worker);
let apache_dir = tempfile::tempdir().unwrap();
let error_log = apache_dir.path().join("error.log");
let access_log = apache_dir.path().join("access.log");
let error_line = "[Wed Oct 21 11:29:09.7 2026] [php:error] [pid 1] boom\n";
let access_line = "::1 - - [21/Oct/2026:11:30:02 +0200] \"GET / HTTP/1.1\" 500 5\n";
fs::write(&error_log, error_line).unwrap();
fs::write(&access_log, access_line).unwrap();
settle(&error_log);
let vhost = apache_dir.path().join("site.conf");
fs::write(
&vhost,
format!(
"ErrorLog {}\nCustomLog {} combined\n",
error_log.display(),
access_log.display()
),
)
.unwrap();
let db = apache_dir.path().join("test.sqlite");
let pool = crate::server::connect_db(&format!("sqlite://{}", db.display()))
.await
.unwrap();
let scanner = Scanner::default();
scanner
.add_project(&pool, &config(root, &["storage/logs"], None))
.await
.unwrap();
let id: i64 = sqlx::query_scalar("SELECT id FROM projects")
.fetch_one(&pool)
.await
.unwrap();
let summary = || async { crate::server::load_summary(&pool).await.unwrap() };
let names = |s: &crate::model::Summary| -> Vec<String> {
s.projects[0]
.files
.iter()
.map(|f| f.relative_path.clone())
.collect()
};
// Nouveau dossier et vhost : leurs fichiers sont suivis, sans non-lu.
let both = config(root, &["storage/logs", "logs"], Some(&vhost));
assert!(scanner.update_project(&pool, id, &both).await.unwrap());
let s = summary().await;
assert_eq!(s.projects[0].files.len(), 3);
assert!(names(&s).contains(&"logs/worker.log".to_string()));
assert_eq!(s.total, 0);
append(&error_log, error_line);
append(&access_log, access_line);
append(&worker, "2026-10-21 10:00:01 ERROR new\n");
settle(&error_log);
settle(&worker);
scan_project(&pool, id, MarkRead::None).await.unwrap();
let s = summary().await;
assert_eq!(s.total, 2);
let access = s.projects[0]
.files
.iter()
.find(|f| f.kind == LogKind::ApacheAccess)
.unwrap();
assert_eq!(access.unread, 0);
let indexed: i64 = sqlx::query_scalar("SELECT entries_count FROM log_files WHERE id = ?")
.bind(access.id)
.fetch_one(&pool)
.await
.unwrap();
assert_eq!(indexed, 2);
// Dossier et vhost retirés : leurs fichiers ne sont plus suivis.
let laravel_only = config(root, &["storage/logs"], None);
assert!(
scanner
.update_project(&pool, id, &laravel_only)
.await
.unwrap()
);
let s = summary().await;
assert!(s.projects[0].files.is_empty());
assert_eq!(s.total, 0);
// Autre chemin : les fichiers de l'ancien sont oubliés, l'historique du nouveau
// n'est pas non-lu.
fs::write(logs_dir(root).join("first.log"), "").unwrap();
scan_project(&pool, id, MarkRead::None).await.unwrap();
let other = laravel_project();
let other_log = logs_dir(other.path()).join("laravel.log");
fs::write(&other_log, "[2026-10-21 10:00:00] local.ERROR: old\n").unwrap();
settle(&other_log);
let moved = config(other.path(), &["storage/logs"], None);
assert!(scanner.update_project(&pool, id, &moved).await.unwrap());
let s = summary().await;
assert_eq!(names(&s), ["storage/logs/laravel.log"]);
assert_eq!(s.total, 0);
assert!(!scanner.update_project(&pool, id + 1, &moved).await.unwrap());
}
/// Seuls les projets dont l'intervalle est écoulé sont relus ; « jamais » ne l'est que
/// sur demande (fichier affiché).
#[tokio::test]
async fn refresh_per_project() {
let fast = laravel_project();
let never = laravel_project();
let dir = tempfile::tempdir().unwrap();
let pool = crate::server::connect_db(&format!(
"sqlite://{}",
dir.path().join("t.sqlite").display()
))
.await
.unwrap();
let scanner = Scanner::default();
let mut never_config = config(never.path(), &["storage/logs"], None);
never_config.refresh_seconds = 0;
scanner
.add_project(&pool, &config(fast.path(), &["storage/logs"], None))
.await
.unwrap();
scanner.add_project(&pool, &never_config).await.unwrap();
let line = "[2026-10-21 10:00:00] local.ERROR: x\n";
for project in [&fast, &never] {
let path = logs_dir(project.path()).join("laravel.log");
fs::write(&path, line).unwrap();
settle(&path);
}
let unread = || async {
let s = crate::server::load_summary(&pool).await.unwrap();
let mut counts: Vec<_> = s
.projects
.iter()
.map(|p| (p.refresh_seconds, p.unread))
.collect();
counts.sort();
counts
};
// Les deux viennent d'être scannés à l'ajout : rien n'est dû.
scanner.scan_due(&pool).await.unwrap();
assert_eq!(unread().await, [(0, 0), (5, 0)]);
// Intervalle écoulé pour le projet à 5 s ; « jamais » attend.
scanner
.last_scans
.lock()
.await
.values_mut()
.for_each(|t| *t -= Duration::from_secs(5));
scanner.scan_due(&pool).await.unwrap();
assert_eq!(unread().await, [(0, 0), (5, 1)]);
let never_id: i64 = sqlx::query_scalar("SELECT id FROM projects WHERE refresh_seconds = 0")
.fetch_one(&pool)
.await
.unwrap();
scanner.scan_now(&pool, never_id).await.unwrap();
assert_eq!(unread().await, [(0, 1), (5, 1)]);
}
#[test]
fn missing_file() {
let project = laravel_project();
+63 -24
View File
@@ -1,7 +1,10 @@
//! Code exécuté uniquement côté serveur : base de données et accès au contexte.
use crate::{
model::{DEFAULT_INTERVAL, FileSort, FileSummary, ProjectSummary, Settings, Summary},
model::{
FileSort, FileSummary, LogFormat, LogKind, ProjectSummary, Settings, Summary, is_hidden,
parse_log_dirs,
},
scanner::Scanner,
};
use leptos::prelude::*;
@@ -87,27 +90,21 @@ pub async fn set_setting(pool: &SqlitePool, key: &str, value: &str) -> sqlx::Res
}
pub async fn load_settings(pool: &SqlitePool) -> sqlx::Result<Settings> {
let refresh_interval_seconds = setting(pool, "refresh_interval_seconds")
.await?
.and_then(|v| v.parse().ok())
.unwrap_or(DEFAULT_INTERVAL);
let file_sort = setting(pool, "file_sort")
.await?
.and_then(|v| FileSort::parse(&v))
.unwrap_or_default();
let paused = setting(pool, "paused").await?.as_deref() == Some("1");
Ok(Settings {
refresh_interval_seconds,
file_sort,
paused,
})
Ok(Settings { file_sort, paused })
}
/// (id, project_id, relative_path, size, modifié le, manquant, erreur, non-lus)
/// (id, project_id, relative_path, kind, format, size, modifié le, manquant, erreur, non-lus)
type FileRow = (
i64,
i64,
String,
String,
Option<String>,
i64,
Option<i64>,
bool,
@@ -117,15 +114,30 @@ type FileRow = (
/// Projets, fichiers et compteurs de non-lus.
///
/// Un fichier manquant ou un projet introuvable sur le disque ne compte aucun non-lu.
/// Un fichier manquant ou un projet introuvable sur le disque ne compte aucun non-lu, ni un
/// log d'accès (cf. [`LogFormat::notifies`]). Les fichiers masqués (trop anciens, cf.
/// [`is_hidden`]) ne sont ni listés ni comptés.
pub async fn load_summary(pool: &SqlitePool) -> sqlx::Result<Summary> {
let projects: Vec<(i64, String, String, Option<String>)> = sqlx::query_as(
"SELECT id, name, root_path, last_error FROM projects ORDER BY name COLLATE NOCASE, id",
type ProjectRow = (
i64,
String,
String,
i64,
Option<i64>,
String,
Option<String>,
Option<String>,
Option<String>,
);
let projects: Vec<ProjectRow> = sqlx::query_as(
"SELECT id, name, root_path, refresh_seconds, hide_after_days, log_dirs, last_error,
vhost_path, vhost_error
FROM projects ORDER BY name COLLATE NOCASE, id",
)
.fetch_all(pool)
.await?;
let files: Vec<FileRow> = sqlx::query_as(
"SELECT f.id, f.project_id, f.relative_path, f.size, f.modified_at,
"SELECT f.id, f.project_id, f.relative_path, f.kind, f.format, f.size, f.modified_at,
f.missing_since IS NOT NULL,
f.last_error,
(SELECT COUNT(*) FROM log_entries_index e
@@ -137,29 +149,50 @@ pub async fn load_summary(pool: &SqlitePool) -> sqlx::Result<Summary> {
.fetch_all(pool)
.await?;
let now = time::OffsetDateTime::now_utc().unix_timestamp();
let mut summary = Summary {
total: 0,
now: time::OffsetDateTime::now_utc().unix_timestamp(),
now,
projects: Vec::with_capacity(projects.len()),
};
for (id, name, root_path, error) in projects {
for (
id,
name,
root_path,
refresh_seconds,
hide_after_days,
log_dirs,
error,
vhost_path,
vhost_error,
) in projects
{
let project_ok = error.is_none();
let files: Vec<FileSummary> = files
let hide_after_days = hide_after_days.map(|d| d as u32);
let (hidden, visible): (Vec<&FileRow>, Vec<&FileRow>) = files
.iter()
.filter(|f| f.1 == id)
.partition(|f| is_hidden(f.6, now, hide_after_days));
let files: Vec<FileSummary> = visible
.into_iter()
.map(
|(fid, _, rel, size, modified, missing, ferr, unread)| FileSummary {
|(fid, _, rel, kind, format, size, modified, missing, ferr, unread)| {
let kind = LogKind::parse(kind).unwrap_or_default();
let notifies = format
.as_deref()
.and_then(LogFormat::parse)
.is_none_or(LogFormat::notifies);
let counted = !*missing && notifies && (project_ok || kind != LogKind::Project);
FileSummary {
id: *fid,
kind,
relative_path: rel.clone(),
size: *size as u64,
modified: *modified,
missing: *missing,
error: ferr.clone(),
unread: if project_ok && !*missing {
*unread as u64
} else {
0
},
unread: if counted { *unread as u64 } else { 0 },
}
},
)
.collect();
@@ -169,7 +202,13 @@ pub async fn load_summary(pool: &SqlitePool) -> sqlx::Result<Summary> {
id,
name,
root_path,
refresh_seconds: refresh_seconds as u32,
hide_after_days,
hidden_files: hidden.len() as u32,
log_dirs: parse_log_dirs(&log_dirs),
error,
vhost_path,
vhost_error,
unread,
files,
});