Les erreurs 500 sont des erreurs internes du serveur, ce sont des problèmes critiques qui peuvent avoir un impact significatif sur la performance de votre site. Ces erreurs peuvent non seulement frustrer vos utilisateurs, empêcher une transaction de s’effectuer mais aussi nuire à votre SEO ! Rien que ça…
Pourquoi surveiller les erreurs 500 ?
Les erreurs 500 peuvent survenir de différentes façons, cela peut-être une mauvaise config côté serveur, un module qui ne s’execute pas correctement etc… souvent on s’en aperçoit en essayant de charger son site, mais cela devient plus problématique lorsque l’on reçoit un message d’un client qui n’arrive pas à finaliser sa commande.
Il est donc essentiel de détecter et de corriger rapidement ces erreurs pour éviter toute interruption de service prolongée. Toutefois, vérifier manuellement les logs du serveur à la recherche de ces erreurs peut devenir fastidieux, surtout si votre site génère beaucoup de trafic : ces fichiers contiennent des dizaines de milliers de lignes, bon courage alors pour l’interpréter.
C’est pourquoi l’automatisation de la surveillance des erreurs 500 est une bonne chose à mettre en place sur son site. Dans cet article, je vais vous partager mon approche en vous montrant comment mettre en place un script PHP qui analysera les fichiers logs de votre serveur, détectera les erreurs 500, et vous enverra automatiquement une notification par email lorsque ces erreurs se produisent.
Vous pourrez ainsi surveiller votre site en continu et réagir rapidement en cas de problème 😅
Comprendre les erreurs 500 et leur impact sur votre site
Qu’est-ce qu’une erreur 500 ?
Une erreur 500, communément appelée erreur interne du serveur, est un code de statut HTTP qui indique qu’un problème s’est produit sur le serveur hébergeant votre site web, empêchant la page de s’afficher correctement. Contrairement à des erreurs plus spécifiques comme les erreurs 404 (page non trouvée) ou 403 (accès refusé), l’erreur 500 ne fournit pas de détail clair sur la cause exacte du problème. En d’autres termes, c’est un signal d’alarme qui vous informe qu’une anomalie interne est survenue sans en révéler la nature !
Les causes des erreurs 500 peuvent être variées, notamment :
- Une mauvaise configuration des fichiers
.htaccess; - Des permissions incorrectes sur les fichiers ou dossiers du site ;
- Une surcharge de mémoire PHP ou des scripts trop longs à s’exécuter ;
- Des conflits entre extensions ou plugins sur un site utilisant un CMS comme WordPress ;
- Des erreurs de script dans les fichiers PHP.
Impact des erreurs 500 sur l’expérience utilisateur
Lorsqu’une erreur interne survient, l’utilisateur est confronté à une page blanche ou un message d’erreur générique indiquant que le serveur ne peut pas traiter sa requête. Cela entraîne plusieurs conséquences :
- Frustration de l’utilisateur : Un visiteur qui rencontre une erreur 500 est souvent déconcerté et peut quitter votre site pour un concurrent, ce qui augmente votre taux de rebond.
- Perte de conversions : Si l’erreur survient lors d’un processus critique, comme la validation d’une commande ou l’inscription à un service, cela peut entraîner la perte de clients potentiels.
- Détérioration de la confiance : Des erreurs fréquentes donnent une image de site peu fiable ou mal maintenu, ce qui peut dissuader les utilisateurs de revenir.
Pourquoi automatiser la surveillance des erreurs 500 ?
La détection manuelle des erreurs 500 via les logs du serveur est une tâche laborieuse et très chronophage, même si votre site ne fait que quelques centaines de visiteurs/jour.
Les principaux avantages de l’automatisation :
- Vous êtes immédiatement averti lorsqu’une erreur critique survient, ce qui vous permet d’intervenir rapidement avant que l’erreur ne devienne un problème majeur.
- En automatisant la surveillance des erreurs 500, vous n’avez plus besoin de consulter manuellement les fichiers logs du serveur.
- En réagissant vite aux erreurs, vous minimisez leur impact sur les utilisateurs et préservez les performances de votre site.
- Les erreurs internes fréquentes peuvent impacter négativement votre référencement naturel. Google, par exemple, diminue le classement des sites rencontrant régulièrement des erreurs serveur, car cela nuit à l’expérience utilisateur.
Configuration de la surveillance des erreurs 500 avec PHP
Dans cette section, je vais détailler pas à pas la logique que j’ai utilisée pour mettre en place un script PHP capable de lire les fichiers logs du serveur, détecter les erreurs 500, et m’envoyer une notification par email lorsque celles-ci surviennent.
Étape 1 : Accéder aux logs du serveur
Les fichiers logs de votre serveur web contiennent des informations sur toutes les requêtes envoyées au serveur, ainsi que les réponses correspondantes (codes de statut HTTP). Pour surveiller les erreurs 500, il faut déjà savoir où se trouvent ces logs et comment les récupérer.
- Sur un serveur Apache : Les fichiers logs se trouvent généralement dans le répertoire
/var/log/apache2/ou/var/log/httpd/. Le fichieraccess.logenregistre toutes les requêtes, tandis queerror.logconsigne les erreurs spécifiques. - Sur un serveur Nginx : Les logs sont souvent stockés dans
/var/log/nginx/. - Sur un hébergement mutualisé (ex. OVH) : Les logs peuvent être accessibles via le panneau de gestion ou à une URL spécifique fournie par votre hébergeur.
Pour ma part, j’utilise pour mon site un serveur mutualisé OVH, voici une URL typique pour accéder aux logs sur un serveur OVH :
https://logs.clusterXXX.hosting.ovh.net/nomdusite.fr/access.logÉtape 2 : Préparer le script PHP pour lire les logs
Une fois que vous avez localisé vos fichiers logs, nous allons créer un script PHP capable de lire ces fichiers à distance et d’analyser chaque ligne pour détecter les erreurs 500.
Voici un extrait de code qui télécharge le fichier log et le parcourt à la recherche d’erreurs 500 :
// URL du fichier log avec la date dynamique
$url = 'https://login:password@logs.cluster023.hosting.ovh.net/votresite.fr/osl/votresite.fr-' . date('d-m-Y') . '.log';
$filePath = 'votresite.fr.log';
// Télécharge le fichier log
file_put_contents($filePath, fopen($url, 'r'));
// Ouvre le fichier log pour lecture
$file = fopen($filePath, 'r');
if (!$file) {
die("Impossible d'ouvrir le fichier log");
}
// Tableau pour stocker les erreurs 500
$errors = [];
while (($line = fgets($file)) !== false) {
// Vérifie si la ligne contient une erreur 500
if (strpos($line, ' 500 ') !== false) {
// Stocke la ligne contenant l'erreur 500
$errors[] = $line;
}
}
// Ferme le fichier log
fclose($file);
Dans ce code, nous téléchargeons le fichier log du jour en utilisant la fonction file_put_contents() et fopen(). Nous parcourons ensuite le fichier ligne par ligne avec fgets() pour rechercher les lignes contenant l’erreur 500. Si une telle ligne est trouvée, elle est stockée dans un tableau $errors.
Étape 3 : Filtrer les erreurs récentes (< 2 heures)
L’objectif ici est de se concentrer sur les erreurs les plus récentes, nous voulons donc être notifiés des erreurs qui se sont produites dans les deux dernières heures.
Nous allons donc ajouter une vérification temporelle dans notre script pour s’assurer que l’heure d’erreur indiquée dans les logs est récente. Voici comment vous pouvez procéder :
// Date et heure actuelles
$currentTime = time();
$twoHoursAgo = $currentTime - (2 * 60 * 60); // 2 heures en secondes
foreach ($errors as $error) {
// Extraire la date et l'heure de l'erreur
if (preg_match('/\[(.*?)\]/', $error, $matches)) {
$errorTime = strtotime($matches[1]);
// Vérifie si l'erreur est survenue il y a moins de 2 heures
if ($errorTime >= $twoHoursAgo) {
// Conservez l'erreur récente pour envoi par email
$recentErrors[] = $error;
}
}
}
Nous utilisons ici preg_match() pour extraire la date et l’heure de l’erreur logguée. La fonction strtotime() convertit cette date en un timestamp que nous comparons avec le timestamp actuel. Si l’erreur est plus récente que deux heures, elle est stockée dans le tableau $recentErrors.
Étape 4 : Envoyer une notification par email via PHP
Dernière étape, celle qui nous intéresse le plus : être notifié ! Pour recevoir des notifications par email en cas d’erreurs 500, nous allons utiliser la bibliothèque PHPMailer. Cette bibliothèque simplifie l’envoi d’emails avec une configuration SMTP (comme Gmail).
Voici un extrait de code pour configurer et envoyer un email avec PHPMailer lorsque des erreurs 500 sont détectées :
use PHPMailer\PHPMailer\PHPMailer;
use PHPMailer\PHPMailer\Exception;
require 'PHPMailer/src/Exception.php';
require 'PHPMailer/src/PHPMailer.php';
require 'PHPMailer/src/SMTP.php';
$mail = new PHPMailer(true);
try {
// Configuration du serveur SMTP
$mail->isSMTP();
$mail->Host = 'smtp.gmail.com'; // Serveur SMTP de Gmail
$mail->SMTPAuth = true;
$mail->Username = 'votreadresse@gmail.com'; // Votre adresse Gmail
$mail->Password = 'votremotdepasse'; // Votre mot de passe Gmail ou mot de passe d'application
$mail->SMTPSecure = PHPMailer::ENCRYPTION_STARTTLS;
$mail->Port = 587;
// Destinataires
$mail->setFrom('votreadresse@gmail.com', 'Surveillance Erreurs');
$mail->addAddress('destinataire@exemple.com'); // Adresse de notification
// Contenu de l'email
$mail->isHTML(true);
$mail->Subject = 'Erreur 500 détectée';
$mail->Body = 'Des erreurs 500 ont été détectées sur votre site :<br><br>' . implode("<br>", $recentErrors);
$mail->send();
echo 'Email envoyé avec succès.';
} catch (Exception $e) {
echo "L'envoi de l'email a échoué. Erreur: {$mail->ErrorInfo}";
}
Dans cet extrait, nous utilisons PHPMailer pour envoyer un email contenant les erreurs 500 récentes. Le message est envoyé uniquement si des erreurs sont détectées dans la période de 2 heures précédant l’exécution du script.
Optimiser l’envoi d’emails et la gestion des erreurs
Maintenant que nous avons mis en place un système de surveillance des erreurs 500 et d’envoi d’emails, nous allons essayer d’optimiser ce processus.
Regrouper les erreurs pour éviter le spam d’emails
Lorsque plusieurs erreurs 500 surviennent en peu de temps, il peut être tentant d’envoyer un email pour chaque erreur détectée. Cependant, cela pourrait entraîner une surcharge de notifications inutiles. Pour éviter cela, on peut regrouper les erreurs dans un seul email, envoyé périodiquement (par exemple, toutes les heures).
Voici comment vous pouvez adapter le script pour regrouper les erreurs détectées :
// Si des erreurs ont été détectées dans les dernières 2 heures
if (!empty($recentErrors)) {
$message = "Des erreurs 500 ont été détectées sur votre site dans les 2 dernières heures :<br><br>";
$message .= implode("<br>", $recentErrors);
// Envoi de l'email une fois par heure seulement s'il y a plusieurs erreurs
if (count($recentErrors) > 1) {
$message .= "<br><br>Nombre total d'erreurs : " . count($recentErrors);
}
// Configuration de l'envoi d'email avec PHPMailer (comme expliqué dans la Partie 2)
$mail->Body = $message;
$mail->send();
echo 'Email envoyé avec les erreurs regroupées.';
}
En regroupant les erreurs dans un seul email, on réduit le nombre de notifications envoyées tout en restant informé des problèmes critiques qui surviennent sur votre serveur.
Ajouter un système de notifications conditionnelles
Il est important de ne pas envoyer d’emails si la situation ne nécessite pas une intervention immédiate. Par exemple, si une erreur 500 se produit une seule fois sans récurrence, cela pourrait être dû à une surcharge momentanée du serveur ou à un bug mineur. Un envoi d’email serait alors excessif.
Vous pouvez définir un seuil minimal avant de déclencher l’envoi d’une notification, par exemple lorsqu’au moins trois erreurs 500 surviennent dans un intervalle de deux heures. Voici comment vous pourriez implémenter cette règle dans votre script :
// Si plus de 3 erreurs ont été détectées dans les 2 dernières heures
if (count($recentErrors) >= 3) {
$message = "Attention : Plusieurs erreurs 500 ont été détectées sur votre site :<br><br>";
$message .= implode("<br>", $recentErrors);
// Configuration de l'envoi d'email avec PHPMailer
$mail->Body = $message;
$mail->send();
echo 'Email envoyé : plus de 3 erreurs 500 détectées.';
} else {
echo 'Pas d\'envoi d\'email : moins de 3 erreurs détectées.';
}
Améliorer le format des emails pour une meilleure lisibilité
Les emails de notification doivent être clairs, concis et faciles à lire. Cela permet de comprendre rapidement l’origine du problème sans avoir à analyser le fichier log en détail.
Quelques conseils pour structurer vos emails :
- Mettez en évidence les informations clés : L’adresse IP, l’URL de la page concernée et l’heure de l’erreur doivent être facilement identifiables.
- Utilisez des listes pour structurer les erreurs si elles sont nombreuses.
- Ajoutez un lien direct vers le fichier log ou une section spécifique de votre site d’administration si vous en avez un.
Voici un exemple de formatage HTML optimisé pour l’email :
$message = "<h2>Attention : Erreurs 500 détectées</h2>";
$message .= "<p>Voici les détails des erreurs 500 détectées sur votre site dans les dernières 2 heures :</p>";
$message .= "<ul>";
foreach ($recentErrors as $error) {
// Créez une liste des erreurs pour une meilleure lisibilité
$message .= "<li>" . htmlspecialchars($error) . "</li>";
}
$message .= "</ul>";
$message .= "<p><strong>Veuillez vérifier les logs pour plus d'informations.</strong></p>";
Automatiser la surveillance avec une tâche cron
Il est temps maintenant d’automatiser ce processus en utilisant une tâche cron. Cette étape est cruciale pour que la surveillance fonctionne de manière autonome, sans intervention manuelle, et pour garantir une surveillance continue.
Qu’est-ce qu’une tâche cron ?
Une tâche cron est une commande planifiée qui s’exécute automatiquement à des intervalles de temps prédéfinis. Cela permet d’automatiser des tâches récurrentes, telles que la surveillance des logs de votre site web, l’envoi d’emails, ou la sauvegarde de données.
Dans notre cas, nous allons configurer une tâche cron qui exécutera le script PHP de surveillance des erreurs 500 toutes les heures, par exemple. À vous de définir le bon intervalle de temps.
Configurer une tâche cron pour exécuter le script PHP
Pour configurer une tâche cron, il suffit simplement d’accéder aux paramètres de votre serveur. Sur OVH par exemple, les tâches cron se configurent de manière très simple dans le manager :
Planifier des exécutions à intervalles réguliers
La fréquence à laquelle vous choisissez d’exécuter votre script de surveillance dépend de vos besoins. Grâce à cette configuration, votre script PHP s’exécutera automatiquement à intervalles réguliers, garantissant ainsi que vous soyez informé des problèmes en temps réel, sans avoir à vérifier manuellement les fichiers logs. Vous recevrez un mail vous alertant dès qu’il y a une erreur serveur !
Pour aller plus loin
On pourrait améliorer ce process encore :
- en ciblant des erreurs sur des pages spécifiques (page de paiement par exemple)
- en mettant en place une automatisation avec Make : s’il détecte un mail avec un objet prédéfini dans votre boîte mail, cela envoie une notification sur votre téléphone
On peut donc mettre en place un véritable process de monitoring complet ! L’intégration de ce processus avec une tâche cron permet de le rendre totalement autonome, vous assurant une surveillance continue et sans intervention manuelle.
Cette approche proactive renforcera la stabilité de votre site, vous resterez informé des erreurs critiques avant qu’elles n’affectent votre activité, et c’est bien ça le principal 😉