Journalisation de l’exécution des requêtes

Comme dans n’importe quel système complexe, il arrive que PostgreSQL fasse des siennes : les requêtes prennent trop de temps, la charge serveur grimpe, et les utilisateurs commencent à râler. La journalisation, c’est le moyen de mater ce qui se passe sous le capot de ta base de données, pour :

1. Repérer les requêtes lentes — celles qui ralentissent ton appli.
2. Optimiser les performances — en analysant le comportement des requêtes.
3. Diagnostiquer les erreurs — genre violations de contraintes ou mauvaise syntaxe.
4. Assurer l’audit — suivre qui a fait quoi sur le serveur.

Paramètres clés de la journalisation

Les fichiers de config de PostgreSQL (postgresql.conf) contiennent plein de paramètres liés à la journalisation. On va voir les plus importants.

1. log_statement — journalisation des requêtes SQL

Le paramètre log_statement définit quelles requêtes SQL seront enregistrées dans le log. Il peut prendre les valeurs suivantes :

• none — désactiver la journalisation des requêtes.
• ddl — journaliser seulement les commandes de définition de données (genre CREATE, ALTER, DROP).
• mod — journaliser toutes les commandes qui modifient les données (genre INSERT, UPDATE, DELETE).
• all — journaliser toutes les requêtes SQL (y compris les SELECT simples).

Exemple :

Pour activer la journalisation de toutes les requêtes, dans le fichier postgresql.conf mets :

log_statement = 'all'

Si tu veux journaliser seulement les commandes qui modifient les données :

log_statement = 'mod'

Après avoir modifié la config, n’oublie pas de relancer le serveur :

sudo systemctl restart postgresql

2. log_duration — journalisation du temps d’exécution

Le paramètre log_duration permet d’enregistrer dans le log le temps d’exécution de chaque requête. Pratique pour savoir lesquelles sont les plus gourmandes en temps.

Exemple :

Pour activer la journalisation de la durée d’exécution des requêtes, mets :

log_duration = on

Si tu veux journaliser seulement les requêtes lentes, utilise le paramètre log_min_duration_statement (on en parle juste après).

3. log_min_duration_statement — journalisation des requêtes lentes

Ce paramètre permet d’enregistrer dans le log uniquement les requêtes qui prennent plus de temps que la valeur indiquée (en millisecondes). Super utile pour chasser les “ralentisseurs” dans la base.

Exemple :

Pour journaliser les requêtes qui durent plus d’1 seconde :

log_min_duration_statement = 1000

Si tu veux journaliser TOUTES les requêtes peu importe leur durée, mets juste 0 :

log_min_duration_statement = 0

La valeur -1 désactive la journalisation basée sur la durée.

4. log_line_prefix — structure du message dans le log

Le paramètre log_line_prefix permet de personnaliser le format des messages enregistrés. Pratique pour ajouter du contexte à chaque requête loggée (genre nom d’utilisateur, PID, date et heure).

Exemple :

Pour enregistrer le nom d’utilisateur, la base, l’heure et le process, utilise :

log_line_prefix = '%t [%p]: [%d]: [%u]: '

Ici :

• %t — heure de la requête.
• %p — PID du process.
• %d — nom de la base.
• %u — nom d’utilisateur.

Liste de toutes les options dispos : Documentation PostgreSQL.

5. logging_collector — collecteur de logs

Le paramètre logging_collector active le mécanisme d’écriture des logs dans des fichiers. S’il est désactivé, les logs partent juste sur la sortie standard (stdout), ce qui n’est pas super pratique.

Pour activer le collecteur de logs :

logging_collector = on

N’oublie pas d’indiquer le chemin du fichier log avec log_directory et log_filename :

log_directory = '/var/log/postgresql'
log_filename = 'postgresql-%Y-%m-%d.log'

Utilisation pratique des paramètres

Voyons comment utiliser ces paramètres de journalisation dans un cas concret.

Scénario 1 : journalisation de toutes les requêtes

Si tu viens de démarrer avec une nouvelle base et que tu veux tout voir passer, configure :

log_statement = 'all'
log_line_prefix = '%t [%p]: [%d]: [%u]: '

Maintenant chaque requête exécutée dans la base sera enregistrée dans le fichier log — nickel pour le debug !

Scénario 2 : recherche des requêtes lentes

Si tu remarques que le serveur “rame” parfois et que tu veux trouver les requêtes problématiques, configure :

log_min_duration_statement = 500  # Journaliser les requêtes de plus de 500 ms
log_line_prefix = '%t [%p]: [%d]: [%u]: [%r] '

Où %r ajoute l’adresse IP du client. Après ça, tu pourras facilement repérer les requêtes qui surchargent le serveur.

Scénario 3 : mode journalisation minimale

Si ton serveur tourne bien et que tu veux juste un minimum de logs pour l’audit :

log_statement = 'mod'
log_duration = off

Ici, seules les modifs de données sont loggées (genre INSERT, UPDATE).

Analyse des logs

Quand les logs commencent à se remplir, faut savoir les analyser ! Tu peux :

Ouvrir le fichier log dans un éditeur de texte :

cat /var/log/postgresql/postgresql.log

Utiliser des outils pour analyser, genre grep, pour trouver les requêtes lentes :

grep "duration: " /var/log/postgresql/postgresql.log

Utiliser des utilitaires pour une analyse avancée des logs, comme pgBadger.

Astuces utiles

Une journalisation trop détaillée peut charger ton disque à mort. Sur les systèmes en prod, active seulement les paramètres dont t’as vraiment besoin.

Pense à nettoyer ou archiver régulièrement les vieux fichiers logs, histoire de pas saturer le disque.

La journalisation est efficace avec des paramètres qui collectent juste ce qu’il faut. Par exemple, log_min_duration_statement te permet de rester précis et d’économiser des ressources.

Alors, prêt ? Maintenant, configurer la journalisation dans PostgreSQL et l’utiliser pour analyser les requêtes et booster les perfs, c’est fingers in the nose ! Comme l’a dit un (ouais, pas qu’un seul) dev inconnu mais sûrement cool : “Les logs, c’est notre chance de mater le passé des requêtes et d’améliorer le futur de la base.”