Compare commits

...
2 Commits
Author SHA1 Message Date
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
14 changed files with 1949 additions and 250 deletions

No files matched your search

+88 -25
View File
@@ -9,8 +9,8 @@
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.
@@ -19,7 +19,8 @@ Logs Reader est une application web **locale et mono-utilisateur** qui permet à
| 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. |
| **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,7 +64,7 @@ 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.
@@ -76,7 +80,9 @@ 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`, `log_dirs` (un par ligne), `vhost` (vides = défaut / aucun) | `()` |
| `update_project` | `project_id`, `path`, `name`, `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` | `()` |
@@ -95,13 +101,19 @@ 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
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)
@@ -146,15 +158,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.
3. Il est valide si c'est un répertoire (aucun fichier particulier n'est exigé).
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.
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 vide → dernier segment du chemin ; 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 +185,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).
@@ -196,13 +221,26 @@ 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 (optionnel), 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.
- **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.
- **Réglages** : intervalle en secondes (champ numérique, 1–3600).
### 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
@@ -211,9 +249,11 @@ Convention : `Given / When / Then`. « Écrire une entrée » signifie ajouter a
### 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.
@@ -273,7 +313,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).
@@ -304,6 +344,25 @@ Convention : `Given / When / Then`. « Écrire une entrée » signifie ajouter a
- **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 +380,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. » |
@@ -343,6 +403,9 @@ Convention : `Given / When / Then`. « Écrire une entrée » signifie ajouter a
| 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. » |
| 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,10 +417,10 @@ 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 ou est un log d'accès Apache ; `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]`.
@@ -384,7 +447,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">`.
---
+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
+8 -3
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).
@@ -32,8 +36,9 @@ 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/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';
+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()
);
}
}
+103 -26
View File
@@ -17,9 +17,20 @@ pub async fn unread_summary() -> Result<Summary, ServerFnError> {
.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. Sans nom, le projet prend celui du dernier
/// dossier du chemin ; 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,
log_dirs: &str,
vhost: &str,
) -> Result<crate::scanner::ProjectConfig, ServerFnError> {
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
@@ -28,26 +39,81 @@ pub async fn add_project(path: String, name: String) -> Result<(), ServerFnError
.unwrap_or_else(|| root_str.clone()),
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,
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,
log_dirs: String,
vhost: String,
) -> Result<(), ServerFnError> {
let project = project_fields(&path, &name, &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, 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,
log_dirs: String,
vhost: String,
) -> Result<(), ServerFnError> {
let project = project_fields(&path, &name, &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 +140,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 +151,11 @@ 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
/// (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 +165,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 +233,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,
+390 -70
View File
@@ -1,12 +1,13 @@
use crate::{
api::{
AddProject, MarkAllRead, MarkRead, RemoveProject, SetFileSort, SetPaused,
SetRefreshInterval, get_settings, read_entries, unread_summary,
SetRefreshInterval, UpdateProject, get_settings, read_entries, suggest_log_dirs,
unread_summary,
},
model::{
DEFAULT_INTERVAL, EntriesPage, Entry, FaviconState, FileSort, LEVELS, PAGE_SIZE,
ProjectSummary, Settings, Summary, UNKNOWN_LEVEL, favicon_data_url, human_size, page_title,
relative_age, sort_files,
DEFAULT_INTERVAL, EntriesPage, Entry, FaviconState, FileSort, FileSummary, LEVELS, LogKind,
PAGE_SIZE, ProjectSummary, Settings, Summary, UNKNOWN_LEVEL, favicon_data_url, human_size,
page_title, relative_age, sort_files,
},
};
use leptos::{html, prelude::*};
@@ -236,10 +237,12 @@ fn Sidebar() -> impl IntoView {
let add = ServerAction::<AddProject>::new();
let remove = ServerAction::<RemoveProject>::new();
let mark_all = ServerAction::<MarkAllRead>::new();
let form = NodeRef::<html::Form>::new();
// Projets repliés par l'utilisateur. La liste est reconstruite à chaque rafraîchissement :
// sans cet état, chaque projet se redéplierait.
let collapsed = RwSignal::new(HashSet::<i64>::new());
let update = ServerAction::<UpdateProject>::new();
// Projet ajouté ou modifié dans la fenêtre modale, `None` quand elle est fermée.
let editing = RwSignal::new(None::<ProjectForm>);
// Ordre des fichiers : le choix fait ici s'applique tout de suite, sans attendre que
// les réglages soient relus ; sinon, celui enregistré en base.
@@ -282,19 +285,12 @@ fn Sidebar() -> impl IntoView {
add.version().get(),
remove.version().get(),
mark_all.version().get(),
update.version().get(),
)
},
move |_, _, _| live.bump(),
false,
);
// Vide le formulaire quand l'ajout a réussi (`ActionForm` ne le fait pas).
Effect::new(move |_| {
if matches!(add.value().get(), Some(Ok(())))
&& let Some(form) = form.get()
{
form.reset();
}
});
let pause = expect_context::<Pause>();
let total = move || live.current().map(|s| s.total).unwrap_or(0);
@@ -316,38 +312,14 @@ fn Sidebar() -> impl IntoView {
</A>
</header>
<ActionForm action=add node_ref=form attr:class="flex flex-col gap-2">
<input
name="path"
required
placeholder="/chemin/vers/projet-laravel"
aria-label="Chemin du projet"
class=INPUT
/>
<input
name="name"
placeholder="Nom (optionnel)"
aria-label="Nom du projet"
class=INPUT
/>
<button type="submit" class=BUTTON disabled=move || add.pending().get()>
"Ajouter le projet"
<button
type="button"
class=BUTTON
on:click=move |_| editing.set(Some(ProjectForm::default()))
>
"+ Ajouter un projet"
</button>
{move || {
add.value()
.get()
.and_then(Result::err)
.map(|e| view! { <p class="text-sm text-red-400">{error_message(&e)}</p> })
}}
</ActionForm>
{move || {
remove
.value()
.get()
.and_then(Result::err)
.map(|e| view! { <p class="text-sm text-red-400">{error_message(&e)}</p> })
}}
<ProjectDialog editing add update remove />
<Transition fallback=|| view! { <p class="text-sm text-zinc-400">"Chargement…"</p> }>
<Show when=move || live.offline()>
@@ -394,7 +366,16 @@ fn Sidebar() -> impl IntoView {
.projects
.into_iter()
.map(|project| {
view! { <ProjectItem project remove mark_all collapsed sort now /> }
view! {
<ProjectItem
project
mark_all
collapsed
editing
sort
now
/>
}
})
.collect_view()
.into_any()
@@ -406,6 +387,287 @@ fn Sidebar() -> impl IntoView {
}
}
/// Contenu de la fenêtre de projet : vide pour un ajout, pré-rempli pour une modification.
#[derive(Clone, Debug, Default, PartialEq)]
struct ProjectForm {
/// `None` pour un nouveau projet.
id: Option<i64>,
name: String,
path: String,
/// Un dossier par ligne.
log_dirs: String,
vhost: String,
}
impl ProjectForm {
fn edit(project: &ProjectSummary) -> Self {
ProjectForm {
id: Some(project.id),
name: project.name.clone(),
path: project.root_path.clone(),
log_dirs: project.log_dirs.join("\n"),
vhost: project.vhost_path.clone().unwrap_or_default(),
}
}
}
/// Fenêtre modale d'ajout ou de modification d'un projet (`<dialog>` natif : fond, touche
/// Échap et focus gérés par le navigateur). Ouverte tant que `editing` vaut `Some`, elle se
/// ferme quand l'enregistrement a réussi.
///
/// Elle est hors de la liste des projets, reconstruite à chaque rafraîchissement : la saisie
/// en cours y serait perdue.
#[component]
fn ProjectDialog(
editing: RwSignal<Option<ProjectForm>>,
add: ServerAction<AddProject>,
update: ServerAction<UpdateProject>,
remove: ServerAction<RemoveProject>,
) -> impl IntoView {
let dialog = NodeRef::<html::Dialog>::new();
let path_input = NodeRef::<html::Input>::new();
// Versions des actions à l'ouverture : une erreur d'une ouverture précédente ne doit pas
// s'afficher.
let opened_at = RwSignal::new((0usize, 0usize, 0usize));
Effect::new(move |_| {
let Some(dialog) = dialog.get() else { return };
match editing.get() {
Some(_) if !dialog.open() => {
opened_at.set((
add.version().get_untracked(),
update.version().get_untracked(),
remove.version().get_untracked(),
));
let _ = dialog.show_modal();
// Le formulaire est rendu en même temps : on attend qu'il soit en place.
request_animation_frame(move || {
if let Some(input) = path_input.get_untracked() {
let _ = input.focus();
}
});
}
None if dialog.open() => dialog.close(),
_ => {}
}
});
Effect::new(move |_| {
if matches!(add.value().get(), Some(Ok(()))) {
editing.set(None);
}
});
Effect::new(move |_| {
if matches!(update.value().get(), Some(Ok(()))) {
editing.set(None);
}
});
Effect::new(move |_| {
if matches!(remove.value().get(), Some(Ok(()))) {
editing.set(None);
}
});
let add_error = Signal::derive(move || {
(add.version().get() > opened_at.get().0)
.then(|| add.value().get().and_then(Result::err))
.flatten()
.map(|e| error_message(&e))
});
let update_error = Signal::derive(move || {
let (_, update_at, remove_at) = opened_at.get();
let update_error = (update.version().get() > update_at)
.then(|| update.value().get().and_then(Result::err))
.flatten();
let remove_error = (remove.version().get() > remove_at)
.then(|| remove.value().get().and_then(Result::err))
.flatten();
update_error.or(remove_error).map(|e| error_message(&e))
});
view! {
<dialog
node_ref=dialog
aria-labelledby="project-dialog-title"
class="m-auto w-full max-w-lg rounded-lg bg-zinc-900 text-zinc-100 shadow-xl backdrop:bg-black/60"
// Fermée par Échap : l'état suit.
on:close=move |_| editing.set(None)
// Un clic sur le fond (hors du contenu) ferme la fenêtre.
on:click=move |ev| {
if dialog.get().is_some_and(|d| ev.target() == Some(d.into())) {
editing.set(None);
}
}
>
{move || {
editing
.get()
.map(|form| match form.id {
None => {
let pending = add.pending().into();
view! {
<ActionForm action=add attr:class="flex flex-col gap-3 p-5">
<ProjectFields
form
error=add_error
pending
path_input
editing
remove
/>
</ActionForm>
}
.into_any()
}
Some(id) => {
let pending = Signal::derive(move || {
update.pending().get() || remove.pending().get()
});
view! {
<ActionForm action=update attr:class="flex flex-col gap-3 p-5">
<input type="hidden" name="project_id" value=id.to_string() />
<ProjectFields
form
error=update_error
pending
path_input
editing
remove
/>
</ActionForm>
}
.into_any()
}
})
}}
</dialog>
}
}
/// Champs et boutons de la fenêtre de projet, communs à l'ajout et à la modification.
#[component]
fn ProjectFields(
form: ProjectForm,
error: Signal<Option<String>>,
pending: Signal<bool>,
path_input: NodeRef<html::Input>,
editing: RwSignal<Option<ProjectForm>>,
remove: ServerAction<RemoveProject>,
) -> impl IntoView {
let is_new = form.id.is_none();
// Retrait d'un projet existant, après confirmation (sous le nom enregistré).
let remove_button = form.id.map(|project_id| {
let name = form.name.clone();
let confirm_remove = move |_| {
let message =
format!("Retirer le projet « {name} » ? Les fichiers de log ne sont pas modifiés.");
if window().confirm_with_message(&message).unwrap_or(false) {
remove.dispatch(RemoveProject { project_id });
}
};
view! {
<button
type="button"
class="rounded-md px-3 py-1.5 text-sm text-red-400 hover:bg-red-950 hover:text-red-300 disabled:opacity-50"
disabled=move || pending.get()
on:click=confirm_remove
>
"Retirer ce projet"
</button>
}
});
let title = if is_new {
"Ajouter un projet".to_string()
} else {
format!("Modifier « {} »", form.name)
};
// Dossiers de logs : proposés d'après le chemin saisi, tant que l'utilisateur ne les a pas
// modifiés lui-même (ceux d'un projet existant sont conservés).
let log_dirs = RwSignal::new(form.log_dirs);
let dirs_touched = RwSignal::new(!is_new);
let suggest = move |ev: leptos::ev::Event| {
if dirs_touched.get_untracked() {
return;
}
let path = event_target_value(&ev);
leptos::task::spawn_local(async move {
if let Ok(dirs) = suggest_log_dirs(path).await
&& !dirs_touched.get_untracked()
{
log_dirs.set(dirs.join("\n"));
}
});
};
view! {
<h2 id="project-dialog-title" class="text-lg font-semibold">
{title}
</h2>
<label class="flex flex-col gap-1 text-sm">
"Chemin du projet"
<input
name="path"
required
node_ref=path_input
value=form.path
placeholder="/chemin/vers/projet"
class=INPUT
on:change=suggest
/>
{(!is_new)
.then(|| {
view! {
<span class="text-xs text-zinc-400">
"Un autre chemin remplace les logs suivis, sans compter leur historique en non-lu."
</span>
}
})}
</label>
<label class="flex flex-col gap-1 text-sm">
"Nom (optionnel)"
<input name="name" value=form.name placeholder="Dernier dossier du chemin" class=INPUT />
</label>
<label class="flex flex-col gap-1 text-sm">
"Dossiers de logs"
<textarea
name="log_dirs"
rows="2"
placeholder="storage/logs"
class=INPUT
prop:value=move || log_dirs.get()
on:input=move |ev| {
dirs_touched.set(true);
log_dirs.set(event_target_value(&ev));
}
></textarea>
<span class="text-xs text-zinc-400">
"Un par ligne, relatifs au projet. Les fichiers *.log y sont suivis, sous-dossiers compris ; leur format est détecté."
</span>
</label>
<label class="flex flex-col gap-1 text-sm">
"Vhost Apache (optionnel)"
<input
name="vhost"
value=form.vhost
placeholder="/etc/apache2/sites-available/site.conf"
class=INPUT
/>
<span class="text-xs text-zinc-400">
"Ses fichiers ErrorLog et CustomLog sont suivis ; seules les erreurs comptent dans les nouveaux logs."
{(!is_new).then_some(" Vider le champ retire le vhost.")}
</span>
</label>
{move || error.get().map(|e| view! { <p class="text-sm text-red-400">{e}</p> })}
<div class="flex items-center gap-2">
{remove_button}
<button type="button" class=format!("ml-auto {SMALL_BUTTON}") on:click=move |_| editing.set(None)>
"Annuler"
</button>
<button type="submit" class=BUTTON disabled=move || pending.get()>
{if is_new { "Ajouter" } else { "Enregistrer" }}
</button>
</div>
}
}
/// Bouton marche/arrêt de la lecture automatique des logs : un engrenage qui tourne
/// lentement quand elle est active, un bouton rouge quand elle est arrêtée.
#[component]
@@ -480,9 +742,9 @@ fn UnreadBadge(count: u64) -> impl IntoView {
#[component]
fn ProjectItem(
project: ProjectSummary,
remove: ServerAction<RemoveProject>,
mark_all: ServerAction<MarkAllRead>,
collapsed: RwSignal<HashSet<i64>>,
editing: RwSignal<Option<ProjectForm>>,
sort: FileSort,
/// Heure du serveur, pour l'ancienneté des fichiers.
now: i64,
@@ -500,17 +762,19 @@ fn ProjectItem(
}
});
};
let name = project.name.clone();
let confirm_remove = move |_| {
let message =
format!("Retirer le projet « {name} » ? Les fichiers de log ne sont pas modifiés.");
if window().confirm_with_message(&message).unwrap_or(false) {
remove.dispatch(RemoveProject { project_id: id });
}
};
let mut files = project.files;
let edit_form = ProjectForm::edit(&project);
let (mut apache, mut files): (Vec<_>, Vec<_>) = project
.files
.into_iter()
.partition(|f| f.kind != LogKind::Project);
sort_files(&mut files, sort);
sort_files(&mut apache, sort);
let empty = files.is_empty();
// Avec un seul dossier de logs, les fichiers sont désignés par leur chemin dans ce dossier.
let prefix = match project.log_dirs.as_slice() {
[dir] => Some(format!("{dir}/")),
_ => None,
};
view! {
<details open=open on:toggle=on_toggle class="group">
@@ -533,13 +797,13 @@ fn ProjectItem(
</Show>
<button
class=SMALL_BUTTON
title="Retirer le projet"
title="Modifier le projet"
on:click=move |ev| {
ev.prevent_default();
confirm_remove(ev);
editing.set(Some(edit_form.clone()));
}
>
"✕"
"✎"
</button>
</summary>
{project.error.map(|e| view! { <p class="px-1 text-xs text-red-400">{e}</p> })}
@@ -547,12 +811,45 @@ fn ProjectItem(
<ul class="mt-1 flex flex-col">
{files
.into_iter()
.map(|file| {
.map(|file| view! { <FileRow file sort now prefix=prefix.clone() /> })
.collect_view()}
</ul>
{(project.vhost_path.is_some())
.then(|| {
view! {
<p class="mt-1 px-3 text-xs font-semibold uppercase tracking-wide text-zinc-500">
"Apache"
</p>
}
})}
{project.vhost_error.map(|e| view! { <p class="px-3 text-xs text-red-400">{e}</p> })}
<ul class="flex flex-col">
{apache
.into_iter()
.map(|file| view! { <FileRow file sort now prefix=None /> })
.collect_view()}
</ul>
</details>
}
}
/// Un fichier dans la liste d'un projet. Un log Apache est désigné par son nom de fichier,
/// suivi de son rôle (erreurs ou accès).
#[component]
fn FileRow(
file: FileSummary,
sort: FileSort,
now: i64,
/// Début de chemin commun retiré de l'affichage (dossier de logs unique).
prefix: Option<String>,
) -> impl IntoView {
let age = file.modified.map(|m| relative_age(now - m));
let tooltip = match &age {
Some(age) => {
format!("{} — {} — modifié {age}", file.relative_path, human_size(file.size))
}
Some(age) => format!(
"{} — {} — modifié {age}",
file.relative_path,
human_size(file.size)
),
None => format!("{} — {}", file.relative_path, human_size(file.size)),
};
// Trié par date, l'ancienneté est plus utile que la taille.
@@ -565,6 +862,28 @@ fn ProjectItem(
} else {
"flex-1 truncate"
};
let (label, role) = match file.kind {
LogKind::Project => (
prefix
.as_deref()
.and_then(|prefix| file.relative_path.strip_prefix(prefix))
.unwrap_or(&file.relative_path)
.to_string(),
None,
),
kind => (
file.relative_path
.rsplit('/')
.next()
.unwrap_or(&file.relative_path)
.to_string(),
Some(if kind == LogKind::ApacheError {
"erreurs"
} else {
"accès"
}),
),
};
view! {
<li>
<A
@@ -572,8 +891,9 @@ fn ProjectItem(
attr:class="flex items-center gap-2 rounded py-1 pl-4 pr-1 text-sm text-zinc-300 hover:bg-zinc-800 aria-[current=page]:bg-zinc-800 aria-[current=page]:text-white"
>
<span class=label_class title=tooltip>
{file.relative_path.clone()}
{label}
</span>
{role.map(|role| view! { <span class="shrink-0 text-xs text-zinc-500">{role}</span> })}
{file.missing.then(|| view! { <span class="text-xs text-zinc-500">"manquant"</span> })}
{file
.error
@@ -584,11 +904,6 @@ fn ProjectItem(
</A>
</li>
}
})
.collect_view()}
</ul>
</details>
}
}
#[component]
@@ -599,8 +914,13 @@ fn HomePage() -> impl IntoView {
"Logs Reader"
</h1>
<p class="mb-2">
"Ajoutez un projet Laravel avec son chemin dans la barre latérale : tous les fichiers de "
<code>"storage/logs"</code> " sont suivis."
"Ajoutez un projet avec son chemin et ses dossiers de logs (" <code>"storage/logs"</code>
", " <code>"var/log"</code>
"… proposés d'après le projet) : tous leurs fichiers " <code>"*.log"</code>
" sont suivis, quel que soit leur format."
</p>
<p class="mb-2">
"Un projet peut aussi suivre les logs Apache (ErrorLog et CustomLog) de son vhost : indiquez son fichier de configuration à l'ajout ou en modifiant le projet (✎)."
</p>
<p>
"Les nouveaux logs sont signalés par l'icône de l'onglet, même quand il est en arrière-plan. Choisissez un fichier pour les lire."
+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")
+135
View File
@@ -38,14 +38,118 @@ pub struct ProjectSummary {
pub id: i64,
pub name: String,
pub root_path: String,
/// 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).
@@ -273,6 +377,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 +411,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");
+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");
+536 -89
View File
@@ -1,6 +1,8 @@
//! 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},
};
@@ -9,7 +11,7 @@ use std::{
collections::HashMap,
fs::{self, File, Metadata},
io::{BufReader, ErrorKind, Read, Seek, SeekFrom},
path::{Path, PathBuf},
path::{Component, Path, PathBuf},
time::{Duration, Instant},
};
use tokio::sync::Mutex;
@@ -19,23 +21,32 @@ 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);
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 +56,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 +172,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 +190,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 +227,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 +265,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 +273,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 +305,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 +337,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 +345,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 +358,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 +453,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 +468,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 +525,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,23 +543,55 @@ 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(())
}
@@ -412,26 +608,95 @@ impl Scanner {
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")
let projects: Vec<i64> = sqlx::query_scalar("SELECT id FROM projects")
.fetch_all(pool)
.await?;
for (id, root) in projects {
scan_project(pool, id, &root, false).await?;
for id in projects {
scan_project(pool, id, MarkRead::None).await?;
}
*last = Some(Instant::now());
Ok(())
}
/// Premier scan d'un projet qui vient d'être ajouté.
pub async fn scan_new_project(
/// 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 _guard = self.last_full_scan.lock().await;
let id: i64 = sqlx::query_scalar(
"INSERT INTO projects (name, root_path, log_dirs, vhost_path, created_at)
VALUES (?, ?, ?, ?, ?) RETURNING id",
)
.bind(&project.name)
.bind(&project.root)
.bind(project.log_dirs.join("\n"))
.bind(&project.vhost)
.bind(now())
.fetch_one(pool)
.await?;
scan_project(pool, id, MarkRead::All).await
}
/// 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<()> {
project: &ProjectConfig,
) -> sqlx::Result<bool> {
let _guard = self.last_full_scan.lock().await;
scan_project(pool, project_id, root, true).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 = ?, log_dirs = ?, vhost_path = ?, vhost_error = NULL
WHERE id = ?",
)
.bind(&project.name)
.bind(&project.root)
.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?;
Ok(true)
}
}
/// Configuration d'un projet, validée.
#[derive(Clone, Debug)]
pub struct ProjectConfig {
pub name: String,
/// Chemin canonique.
pub root: String,
/// Relatifs à la racine.
pub log_dirs: Vec<String>,
/// Chemin canonique du vhost Apache.
pub vhost: Option<String>,
}
#[cfg(test)]
@@ -439,6 +704,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 +730,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 +828,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 +849,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 +890,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 +919,134 @@ 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(),
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());
}
#[test]
fn missing_file() {
let project = laravel_project();
+37 -13
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::{
DEFAULT_INTERVAL, FileSort, FileSummary, LogFormat, LogKind, ProjectSummary, Settings,
Summary, parse_log_dirs,
},
scanner::Scanner,
};
use leptos::prelude::*;
@@ -103,11 +106,13 @@ pub async fn load_settings(pool: &SqlitePool) -> sqlx::Result<Settings> {
})
}
/// (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 +122,26 @@ 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`]).
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,
String,
Option<String>,
Option<String>,
Option<String>,
);
let projects: Vec<ProjectRow> = sqlx::query_as(
"SELECT id, name, root_path, 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
@@ -142,24 +158,29 @@ pub async fn load_summary(pool: &SqlitePool) -> sqlx::Result<Summary> {
now: time::OffsetDateTime::now_utc().unix_timestamp(),
projects: Vec::with_capacity(projects.len()),
};
for (id, name, root_path, error) in projects {
for (id, name, root_path, log_dirs, error, vhost_path, vhost_error) in projects {
let project_ok = error.is_none();
let files: Vec<FileSummary> = files
.iter()
.filter(|f| f.1 == id)
.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 +190,10 @@ pub async fn load_summary(pool: &SqlitePool) -> sqlx::Result<Summary> {
id,
name,
root_path,
log_dirs: parse_log_dirs(&log_dirs),
error,
vhost_path,
vhost_error,
unread,
files,
});