Interception erreurs et mail

Version imprimable

Bonjour.

J'ai défini un même gestionnaire d'erreur et d'exception, gerer_plantage(), qui me permet de logger l'événement dans un fichier et d'envoyer un mail à l'administrateur pour l'informer du plantage. Le mail est envoyé via une fonction envoyer_mail() qui permet de formater les messages pour l'ensemble du site.
Je constate les choses suivantes :

lorsque la fonction standard mail(), utilisée par envoyer_mail(), plante (ex : impossible de contacter le serveur SMTP), une erreur est générée ;
l'erreur est bien récupérée par le gestionnaire, qui écrit dans le fichier de logs ;
la fonction envoyer_mail() ne semble pas appelée par le gestionnaire pour informer l'administrateur.

La troisième constatation est-elle normale ? S'explique-t-elle par le fait que PHP ne rappelle pas une fonction ayant généré une erreur ?
Pour éviter une boucle en cas de plantage de envoyer_mail(), j'ai bien tenté l'interception d'une exception (cf. code ci-après), qui ne fonctionne pas puisqu'il s'agit d'une erreur. A part traiter les exceptions et les erreurs de manière séparée, voyez-vous une autre solution ?
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 function gerer_plantage($Code, $Message, $Fichier, $Ligne, $Contexte=array()) { /* Gestion des plantages (erreurs et exceptions) /* Prend en arguments : /* - $Code, le code du plantage (entier) /* - $Message, le message décrivant le plantage (chaîne) /* - $Fichier, le fichier ayant géneré le plantage (chaîne) /* - $Ligne, la ligne où s'est produit le plantage (entier) /* - $Contexte, le contexte lors du plantage (tableau) /* Renvoie true si tout s'est bien passé, false sinon. */ /* Ecriture du message d'erreur dans les logs */ ecrire_log("Plantage n°$Code \"$Message\" à la ligne $Ligne", "E", basename($Fichier)); /* Envoi d'un mail à l'administrateur */ $Sujet = "Plantage n°$Code"; $Message = "Plantage n°$Code \"$Message\" à la ligne $Ligne dans le fichier $Fichier"; try { if (envoyer_mail($Sujet, $Message, DESTINATAIRE_MAILS_ERR)) { return true; } else { print formater_message("Echec lors de la gestion de l'erreur. Merci de prévenir l'administrateur à l'adresse " . DESTINATAIRE_MAILS_ERR . ".", "E"); return false; } } catch (Exception $Excep) { print formater_message("Echec lors de la gestion de l'erreur. Merci de prévenir l'administrateur à l'adresse " . DESTINATAIRE_MAILS_ERR . ".", "E"); return false; } }

Salut

Citation:

La troisième constatation est-elle normale ? S'explique-t-elle par le fait que PHP ne rappelle pas une fonction ayant généré une erreur ?
Pour éviter une boucle en cas de plantage de envoyer_mail(), j'ai bien tenté l'interception d'une exception (cf. code ci-après), qui ne fonctionne pas puisqu'il s'agit d'une erreur. A part traiter les exceptions et les erreurs de manière séparée, voyez-vous une autre solution ?

Cela dépend du code qu'il y a dans la fonction envoyer_mail().
Admettons que c'est la fonction mail(), c'est bien, elle renvoie FALSE (une erreur) et non une Exception.

Pour attraper une Exception il faut que ce soit une Exception qui soit renvoyée en cas d'erreur.

La gestion des erreurs et des Exceptions est un sujet assez vaste.

Mais si tu souhaites faire cela simplement (ne serait-ce que dans un premiers temps), il y a peut être moyen.
C'est peut être pas très zen mais c'est juste une piste.
Admettons ceci dans la fonction envoyer_mail() :
Code:

1 2 3 4 5 6 7 8 9 10 <?php envoyer_mail { // Du code ... etc ... $verif = @mail(); if (!$verif) { throw new Exception('Erreur fonction mail()'); } return true; } ?>
(le @ n'est peut être pas nécessaire, faut voir).
Théoriquement, le fait ici de lancer une exception celle devrait pouvoir être attrapée dans le catch dans la fonction gerer_plantage();

Avant de lancer l'Exception, on peu récupérer le message d'erreur avec error_get_last() pour éventuellement le mettre dans le message.
De même qu'on peu rajouter le message d'erreur avec $Excep->getMessage() (au niveau du catch).

Du coup, en admettant que cela se passe ainsi, on peu prévoir comme :
Code:

1 2 3 4 5 6 7 8 9 try { envoyer_mail($Sujet, $Message, DESTINATAIRE_MAILS_ERR); } catch (Exception $Excep) { print formater_message("Echec lors de la gestion de l'erreur. Merci de prévenir l'administrateur à l'adresse " . DESTINATAIRE_MAILS_ERR . ".", "E"); return false; } return true;
Sans garantie ;)

Sinon, il faudrait définir à la fonction set_error_handler() une fonction qui s'occuperait de gérer les erreurs, comme dans la doc par exemple :
Code:

1 2 3 4 function exception_error_handler($errno, $errstr, $errfile, $errline ) { throw new ErrorException($errstr, 0, $errno, $errfile, $errline); } set_error_handler("exception_error_handler");
Faut voir. ;)

En fait envoyer_mail() est conçue comme suit :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
function envoyer_mail($Sujet, $Message, $Destinataire, $Expediteur=EXPEDITEUR_MAILS) {
	/* Initialisation des variables */
	$PrefObj = "[PREF]";	/* Préfixe de l'objet */
 
	/* Préparation du mail */
	$Message = wordwrap($Message,70);
	$EnTetes = "From: $Expediteur\r\n";
	$EnTetes .= "X-Mailer: PHP/" . phpversion();
 
	/* Envoi du mail et retour du booléen */
	try {
		return mail($Destinataire, $PrefObj . " " . $Sujet, $Message, $EnTetes);
	} catch (Exception $Excep) {
		gerer_exception($Excep);
		return false;
	}
}

Et pour les interceptions d'erreurs et d'exceptions :

Code:

1
2
3
4
5
6
7
8
9
10
11
/* Gestion des exceptions non interceptées */
set_exception_handler("gerer_exception");
set_error_handler("gerer_erreur");
 
function gerer_exception($Exception) {
	return gerer_plantage($Exception->getCode(), $Exception->getMessage(), $Exception->getFile(), $Exception->getLine(), $Exception->getTrace());
}
 
function gerer_erreur($Code, $Message, $Fichier, $Ligne) {
	return gerer_plantage($Code, $Message, $Fichier, $Ligne);
}

Lorsque mail() se plante faute de pouvoir joindre le serveur SMTP, il n'y a pas d'exception levée. gerer_erreur() est appelée, puis gerer_plantage(), qui s'arrête au début du try (ou avant).

13/04/2012, 11h17
RunCodePhp

Citation:

/* Gestion des exceptions non interceptées */
set_exception_handler("gerer_exception");
set_error_handler("gerer_erreur");

Donc tu as défini 2 fonctions pour ça.
Puis vu que gerer_erreur() appel gerer_plantage(), toutes Erreurs et Exceptions seront alors gérées dans gerer_plantage(), si j'ai bien suivi.

Le truc que je remarques c'est qu'en cas d'erreurs il est prévu d'envoyer un mail.
Tu dois tout de même te rendre compte que cela peu être très lourd, énormément même, peut être même que ça peut très bien être cette gestion d'erreurs et d'Exceptions en être la cause d'un plantage, ce qui peut être un comble.
Disons il faut le savoir.

De plus, vu qu'il y un try/catch dans cette fonction gerer_plantage(), et bien en cas d'erreur dans celle-ci on est pas loin d'une boucle infinie.
Il y a là peut être un point à éclaircir.

Mise à pas ça, théoriquement tu devrais rien avoir à faire, aucun try/catch autour de la fonction mail() du fait qu'en cas d'erreur la fonction gerer_erreur() devrait être déclenchée.

En essayant d'attraper cette erreur (donc un try/catch) c'est pour pouvoir gérer cette erreur autrement que par le gestionnaire que tu as prévus pour ça (gerer_erreur).
Or, ce n'est pas ton but apparemment.

En supprimant tous les try/catch, est-ce que le message d'erreur et enregistré (ecrire_log), et un mail envoyé ? (en cas d'erreur sur mail() bien sûr)
(faut espérer qu'il n'y ait pas d'erreur dans gerer_exception).

Après avoir enlevé tous les blocs try/catch, mes fonctions ressemblent à ça :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 function gerer_plantage($Code, $Message, $Fichier, $Ligne, $Contexte=array()) { /* Ecriture du message d'erreur dans les logs */ ecrire_log("Plantage n°$Code \"$Message\" à la ligne $Ligne", "E", basename($Fichier)); /* Envoi d'un mail à l'administrateur */ $Sujet = "Plantage n°$Code"; $Message = "Plantage n°$Code \"$Message\" à la ligne $Ligne dans le fichier $Fichier"; if (envoyer_mail($Sujet, $Message, DESTINATAIRE_MAILS_ERR)) { return true; } else { print formater_message("Echec lors de la gestion de l'erreur. Merci de prévenir l'administrateur à l'adresse " . DESTINATAIRE_MAILS_ERR . ".", "E"); return false; } } function envoyer_mail($Sujet, $Message, $Destinataire, $Expediteur=EXPEDITEUR_MAILS) { /* Initialisation des variables */ $PrefObj = "[PREF]"; /* Préfixe de l'objet */ /* Préparation du mail */ $Message = wordwrap($Message,70); $EnTetes = "From: $Expediteur\r\n"; $EnTetes .= "X-Mailer: PHP/" . phpversion(); /* Envoi du mail et retour du booléen */ return mail($Destinataire, $PrefObj . " " . $Sujet, $Message, $EnTetes); }
La gestion du plantage de mail() se fait toujours via gerer_erreurs(), le message est bien écrit dans la log par gerer_plantage() mais c'est tout.

Par ailleurs, j'ai les erreurs suivantes dans php-errors.log :

Citation:

[13-Apr-2012 12:20:26 UTC] PHP Warning: mail(): Failed to connect to mailserver at "smtp.neldoreth.fr" port 25, verify your "SMTP" and "smtp_port" setting in php.ini or use ini_set() in mon_fichier.php on line 101

[13-Apr-2012 12:20:26 UTC] PHP Fatal error: Maximum execution time of 30 seconds exceeded in mon_fichier.php on line 101

13/04/2012, 16h42
RunCodePhp
Citation:

La gestion du plantage de mail() se fait toujours via gerer_erreurs(), le message est bien écrit dans la log par gerer_plantage() mais c'est tout.

La fonction gerer_plantage() doit peut être "planter".

A mon sens il faudrait éviter d'utiliser la fonction envoyer_mail() dans la fonction gerer_plantage(), utiliser directement la fonction mail() serait (peut être) mieux.
(j'y vois un éventuel problème de boucle infinie sinon).

Code:

[13-Apr-2012 12:20:26 UTC] PHP Fatal error: Maximum execution time of 30 seconds exceeded in mon_fichier.php on line 101

Les erreur Fatal ne peuvent pas être gérées par un gestionnaire personnalisé, elles sont à juste titre trop grave, donc Php stoppe tout à ce moment.

Ici tu as dépasser la limité d'exécution autorisé (de 30 secondes), c'est normal que tout s'arrête à ce moment.
Tu ferais trop de traitements (trop d’envoi de mail, ou boucle trop longue, etc ...).
Qu'est-ce qui est fait autout de cette ligne 101 de mon_fichier.php ?
Code:

1 2 3 4 else { print formater_message("Echec lors de la gestion de l'erreur. Merci de prévenir l'administrateur à l'adresse " . DESTINATAIRE_MAILS_ERR . ".", "E"); return false; }
Tu devrais éviter de faire cette de code dans cette fonction gerer_plantage(), car si tu envoie des mail dans une partie où il ne faut pas de renvoie de contenu (comme avant un header par exemple) tu vas provoquer une erreur.
Provoquer une erreur dans son propre gestionnaire d'erreur c'est contre productif (c'est pas logique).
Faut faire au plus simple, juste enregistrer l'erreur. ;)

Le message pour les utilisateur fais le plutôt dans la fonction envoyer_mail(), suffit de récupérer la valeur de mail().
Si false -> message à l'utilisateur.

A coté de ça tu pourrais faire comme ceci :
Code:

1 2 3 4 function gerer_error ($errno, $errstr, $errfile, $errline) { throw new ErrorException($errstr, 0, $errno, $errfile, $errline); }
On renvoi directement toute erreurs vers ErrorException(), ce qui fait que gerer_plantage() va récupérer l'Exception.
Toute erreur sera une Exception.

Bonjour.

J'ai allégé ma fonction gerer_plantage() :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 function gerer_plantage($Code, $Message, $Fichier, $Ligne, $Contexte=array()) { /* Ecriture du message d'erreur dans les logs */ ecrire_log("Plantage n°$Code \"$Message\" à la ligne $Ligne", "E", basename($Fichier)); /* Envoi d'un mail à l'administrateur */ $Sujet = "[Cadeaux] Plantage n°$Code"; $Message = "Plantage n°$Code \"$Message\" à la ligne $Ligne dans le fichier $Fichier"; $Message = wordwrap($Message,70); $EnTetes = "From: " . EXPEDITEUR_MAILS ."\r\n"; $EnTetes .= "X-Mailer: PHP/" . phpversion(); if (mail(DESTINATAIRE_MAILS_ERR, $Sujet, $Message, $EnTetes)) { return true; } else { print formater_message("Echec lors de la gestion de l'erreur. Merci de prévenir l'administrateur à l'adresse " . DESTINATAIRE_MAILS_ERR . ".", "E"); return false; } }
Ça n'a pas l'air de résoudre le problème. Mon fichier de logs m'indique bien :

Citation:

Plantage n°2 "mail(): Failed to connect to mailserver at "smtp.neldoreth.fr" port 25, verify your "SMTP" and "smtp_port" setting in php.ini or use ini_set()" à la ligne 98

La ligne 98 [de mon_fichier.php] est celle de la fonction mail() dans envoyer_mail().

Dans le fichier php-errors.log en revanche j'ai :

Citation:

[16-Apr-2012 08:11:24 UTC] PHP Warning: mail(): Failed to connect to mailserver at "smtp.neldoreth.fr" port 25, verify your "SMTP" and "smtp_port" setting in php.ini or use ini_set() in mon_fichier.php on line 71

[16-Apr-2012 08:11:24 UTC] PHP Fatal error: Maximum execution time of 30 seconds exceeded in mon_fichier.php on line 71

La ligne 71 de mon_fichier.php correspond à la ligne mail() dans gerer_plantage().

Pour ce qui est du message aux utilisateurs via formater_message() dans gerer_plantage(), je le vois comme un moyen de gérer cette diffusion d'information de manière centralisée plutôt que la refaire dans tous les scripts PHP. D'autant que je ne maîtrise pas le moment de génération des erreurs.

Pour éviter d'être coincé dans une boucle avec le plantage de mail(), j'ai modifié gerer_plantage() comme suit :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
function gerer_plantage($Code, $Message, $Fichier, $Ligne, $Contexte=array()) {
/* Gestion des plantages (erreurs et exceptions)
/* Prend en arguments :
/*	- $Code, le code du plantage (entier)
/*	- $Message, le message décrivant le plantage (chaîne)
/*	- $Fichier, le fichier ayant géneré le plantage (chaîne)
/*	- $Ligne, la ligne où s'est produit le plantage (entier)
/*	- $Contexte, le contexte lors du plantage (tableau)
/* Renvoie true si tout s'est bien passé, false sinon. */
 
	/* Ecriture du message d'erreur dans les logs */
	ecrire_log("Plantage n°$Code \"$Message\" à la ligne $Ligne", "E", basename($Fichier));
 
	/* Envoi d'un mail à l'administrateur */
	$Sujet = "[Cadeaux] Plantage n°$Code";
	$Message = "Plantage n°$Code \"$Message\" à la ligne $Ligne dans le fichier $Fichier";
 
	/* Si l'erreur/exception n'implique pas la fonction mail(), envoie d'un mail à l'administrateur.
	/* Sinon affichage d'un message pour l'utilisateur. */
	if (stripos($Message, "mail()") === false ) {
		$Message = wordwrap($Message,70);
		$EnTetes = "From: " . EXPEDITEUR_MAILS ."\r\n";
		$EnTetes .= "X-Mailer: PHP/" . phpversion();
		if (mail(DESTINATAIRE_MAILS_ERR, $Sujet, $Message, $EnTetes)) {
			return true;
		} else {
			print formater_message("Echec lors de la gestion de l'erreur. Merci de prévenir l'administrateur à l'adresse " . DESTINATAIRE_MAILS_ERR . ".", "E");
			return false;
		}
	} else {
		print formater_message("Echec lors de la gestion de l'erreur. Merci de prévenir l'administrateur à l'adresse " . DESTINATAIRE_MAILS_ERR . ".", "E");
		return false;
	}
}

Cela fonctionne correctement puisque le message à destination de l'utilisateur s'affiche comme prévu.
Du coup, je n'ai plus la ligne "PHP Fatal error: Maximum execution time of 30 seconds exceeded" dans php-errors.log. En revanche j'ai toujours un délai d'environ 20s avant déclenchement de gerer_plantage(). Je suppose que c'est dû à mail() et que je ne peux pas y faire grand chose.

16/04/2012, 12h53
RunCodePhp

Citation:

Je suppose que c'est dû à mail() et que je ne peux pas y faire grand chose

Est-ce que tu perçois les dégâts que peu provoquer l'envoie de mail qu'il y a dans cette fonction gerer_plantage() ?

Es-tu certain que lors d'une erreur (telle quelle soit : erreur ou exception) en tout genre) que cela ne va jamais provoquer d'erreur du fait d'afficher l'erreur, de faire un "print" ? (dans gerer_plantage toujours).
Pour rappel, si son gestionnaire d'erreur "plante" lui même c'est un comble, c'est donc sous entendu qu'il se doit d'être fiable.
16/04/2012, 13h28
scrouet

Oui, j'en suis conscient. Mais je cherche à prévenir l'administrateur (moi-même en l'occurrence) des plantages plutôt que de faire une recherche régulière dans les logs. Ou alors il faut que j'implémente un script de vérification des fichiers de logs, lancé par cron, qui m'informe de l'évolution de ceux-ci.
Quelle serait la meilleure solution ?
17/04/2012, 10h16
RunCodePhp

Citation:

Oui, j'en suis conscient. Mais je cherche à prévenir l'administrateur (moi-même en l'occurrence) des plantages plutôt que de faire une recherche régulière dans les logs. Ou alors il faut que j'implémente un script de vérification des fichiers de logs, lancé par cron, qui m'informe de l'évolution de ceux-ci.
Quelle serait la meilleure solution ?

Le principe ou cet objectif là peut être intéressante, mais comme je l'avais dit dès le début, ce sujet là est vaste.

Il est vaste dans le sens où chacun à sa politique.
La tienne me parais très particulière car on peu classer cela comme une charte de qualité (qui serait très élevée), proche d'une astreinte (genre 24/24h) dans certains secteur.

La question à se poser c'est est-ce que tu as les moyens de le faire ?
(matériel, connaissances, le temps, etc ...)

Si je me tiens stricto texto du code ici j'ai tendance à dire que ce tu veux faire serait démesuré, irréalisable à l'heure actuelle car les contraintes sont quasi maximale.

Puis mon avis est assez simple sur cette question.
Entre recevoir les erreurs par mail où les lire dans les logs c'est du pareil au même, donc autant consulter les logs, ça élimine d'office cette énorme contrainte d'envoi de mail.

Puis cette fonction gerer_plantage() ne devrait pas s'occuper à afficher l'erreur, normalement ce n'est pas son rôle.
Là encore le faire c'est prendre le risque que cette fonction fasse "planter" l'application elle même, et le risque est théoriquement fort.
Une erreur (même banale) peu très bien avoir lieu avant que les fonctionnalités liées aux entêtes soient faites (session, cookie, header, pour les plus connues).
On peu quand même le faire, mais cela demande de gérer ces cas là qui sont particuliers.

Sans compter que normalement on n'affiche pas de message lié à un bug sur un site en production, ces indications sont d'une part destinées uniquement au développeur, les internautes eux en ont rien affaire, puis ces infos se devant être très précis techniquement pour être pertinent (pour le développeur toujours) ils seront autant d'indications pertinentes pour un pirate/hacker.
Donc dans tous les cas ce gerer_platange() à mon sens devrait se contenter d'enregistrer les messages (log), sans plus.

Aussi, par défaut les erreurs sont déjà enregistrés dans un fichier de log (php_error.log), donc c'est presque inutile de vouloir refaire ce qui existe déjà.
Mais pourquoi pas.

Ici il serait peut être plus simple et plus pratique de redéfinir le chemin où seront enregistrés toutes ces erreurs là où on veut, comme dans son espace disque de son hébergement (genre /home/****/logs/php_error.log).
(dans le php.ini ou .htaccess la directive "error_log")
Ceci le rendre facilement accessible.

Ensuite, pourquoi pas créer son propre système de consultation des ces erreurs, une sorte d'historique (genre dans un espace Admin).
On peu même le faire via une Bdd (import des données en les classant pourquoi pas selon le type d'erreur, etc, etc ...).
Ici on peu imaginer pleins de choses pour gérer ces enregistrements d'erreurs.

En résumé, vouloir refaire ce qui existe déjà n'est peut être si utile que ça, mais à voir.
Ce qui à mon sens est beaucoup plus utile, voir indispensable si on recherche une fiabilité accrue de son code, c'est de rajouter toutes sortes de test partout où on jugera les traitements effectués sensibles pour provoquer soit même d'autres erreurs, ses propres erreurs.
On le faire très simplement avec la fonction trigger_error().
Mais si on connais la POO, on peu créer une succession de classes d'Exceptions (des dérivées de Exception ou autre) et déclencher ses propres erreurs avec des throw new MesException(...).

Ceci dit, rien empêche de conserver son propre gestionnaire d'erreurs ou d'exceptions (que ce soit une fonction ou une classe, peu importe), mais il faut que ce soit fiable à ce niveau.

J'arrête là car comme tu vois il y a beaucoup à dire, sans compter que selon sa manière de faire on peu dire une chose et son contraire ... c'est pas simple.
As tu déjà regardé dans des CMS ou FW par exemple comment les gestionnaires des erreurs sont effectués ?
Personnellement c'est là où je m'inspire. ;)