PHP: Gestión personalizada de errores

J.A.Cobo — Mon, 04 Feb 2008 11:13:49 +0000

Hace tiempo que ya conocía la manera de gestionar el control de errores en php4 -excepciones en php5-, pero, aunque me curré cosas más o menos apañás, nunca me gustó del todo pues los errores graves escapaban del control de set_error_handler().
Como en todo, nunca estamos limitados a lo que el propio lenguaje nos ofrece, quizá hemos caído demasiadas veces en la comodidad del uso de frameworks, o quizá sea lo que viene inmediatamente, y la encapsulación no nos deje ver un poco más allá… precisamente :) .

Frameworks, librerías o métodos nativos

Es decir, que POO pase a ser un modelo de programación en scripts prácticamente único y absoluto, basándonos en frameworks o librerías que muchas vecen reinventan la rueda, sin una mejora real y sustancial de los métodos nativos del lenguaje.

El hecho es que si quieres gestionar tus propios errores en PHP4 con niveles de informe de usuario y administrador no es tan difícil como en un principio me parecía… solo era pensar un poco… más.
Sé que PHP4 está prácticamente muerto pero también sé que muchos servers aún no han migrado :(

Controla la Gestión de Errores:

Desde que decidí convertir el sitio web de La Guardia -era básicamente un blog- en un CMS y me forcé a usar, en la medida de lo posible y gracias a «Zend FW» o «Simfony», la metodología MVC, debo decir que me gusta aún más programar para la web… es esa forma de «hacer las cosas bien», elegantes… Luego te puede quedar mejor o peor, pero lo que importa es la intención y tener los conceptos claros ^^.

El método

Así, el método, básico desde luego, es tener un control de usuarios o al menos del administrador…. obviamente para elegir un nivel de informe de errores. Aunque casi es lo de menos, usaremos por ejemplo las funciones de sesión de usuario en Wordpress y sin tocar WP_error() del que no he estudiado mucho aunque sería muy útil, más aún si hablamos de MVC y POO.

El funcionamiento sería muy sencillo:
Mediante las funciones de usuario de Wordpress o cualquier otro sistema, o el reconocimiento del nivel administrador, bien mediante IP (avanzada para IPs dinámicas en su caso y no muy recomendable en realidad), generaremos dos tipos de nivel de errores básicamente:

Nivel administrativo.
Nivel de usuario.

Nivel de reporte de errores por usuario

Primero procederemos a establecer el reporte de errores en off para luego comprobar el nivel de usuario y establecer los siguientes niveles:

Admin: E_ALL ^ E_NOTICE: Todos los avisos y errores menos los avisos de PHP.
User: E_USER_NOTICE: Solo los avisos de usuario.

A la vez que proporcionamos el nivel de error estableceremos la función que ofrecerá el reporte de errores para cada tipo:
set_error_handler('miGestorErrores');

Y aquí vienen las carencias de PHP4 que nos obligan a escribir un poco más de código:
En PHP5 solo necesitaríamos una única función de gestión de errores porque podríamos pasar a set_error_handler el nivel que queremos que muestre, en este caso para cada tipo de usuario, por ejemplo:

Si es el administrador:
set_error_handler('MiGestorErrores', E_ALL);
Sino:
set_error_handler('MiGestorErrores', E_USER_NOTICE);

Pero para PHP4 no podemos hacerlo, ya que no podemos pasarle parámetros a set_error_handler(), así que simplemente nos costará unas cuantas líneas más para crear una función más. Esto es: una función de gestión de errores de usuario y otra de administrador. Sí, es muy bruto y se puede y debe pulir... pero por ahora lo dejaremos así para ilustrar.


Así, ya tenemos montado el sistema de informes de error y que podemos usar sin miedo alguno a imprimir errores de php al usuario y sabiendo que tendremos información de todos los errores en modo administrador. Digamos que, omitiendo el tema de seguridad al funcionar como admin, tenemos un entorno de desarrollo y producción en uno :D
El código:
Bien, en el caso de Wordpress se puede hacer más o menos así:
Muy importante:

(Línea 5) Usa tus propios métodos de chequeo del admin, estos son a modo de ejemplo.

El código va bastante explicado y ¡ojo!, le faltaría un poco más de depuración para controlar los datos que llegan a la función...

En fin, que si lo usas, es a modo de ejemplo sólo, ¡compruébalo! ;)

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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
error_reporting(0); // Errores Off inicial.
global $userdata;
get_currentuserinfo();
 
// Asegurar el nivel de usuario de administrador, eso como cada uno vea -ver 2ª condición-:
if ( ($userdata->user_level === 'Nivel del admin') && ($userdata->user_login, $userdata->ID, $userdata->user_nicename, etc... lo dicho) ) :
	error_reporting(E_ALL ^ E_NOTICE); // Activamos los errores para el admin
	// Pasar el control al gestor de errores definido.
	set_error_handler('miAdminGestorErrores');
else :
	error_reporting(E_USER_NOTICE);
	// Pasar el control al gestor de errores, en este caso con un nivel mínimo de reporte: E_USER_NOTICE.
	set_error_handler('miUserGestorErrores');
endif;
 
/**
 * función de gestión de errores NIVEL USUARIO.
 */
function miUserGestorErrores($num_err, $cadena_err, $archivo_err, $linea_err) {
	switch ( $num_err ) {
		// USER: Este será el Nivel de errores que daremos a los usuarios.
		// No debemos imprimir nada más que nuestra cadena de error, si así lo queremos, claro.
		case E_USER_NOTICE:
			echo 'Error: ' . $cadena_err . "
\n";
			break;
 
		// Para el resto nada.
		default:
			return false;
			break;
	}
	/* MUY IMPORTANTE: No ejecutar el gestor de errores interno de PHP */
	return true;
}
 
/**
 * función de gestión de errores NIVEL ADMIN.
 */
function miAdminGestorErrores($num_err, $cadena_err, $archivo_err, $linea_err) {
	switch ( $num_err ) {
		// ADMIN: Error Grave:
		case E_USER_ERROR:
			echo 'DEBUG: Error Grave'
			. "[{$num_err}] {$cadena_err}

			Error fatal administrativo en la línea {$linea_err} del archivo {$archivo_err}

			" . PHP . " " . PHP_VERSION . " (" . PHP_OS . ")

			Abortando...
";
			exit(1);
			break;
 
		// ADMIN: Error Alerta:
		case E_USER_WARNING:
			echo 'DEBUG: Advertencia'
			. "[{$num_err}] {$cadena_err}

			Advertencia administrativa en la línea {$linea_err} del archivo {$archivo_err}

			" . PHP . " " . PHP_VERSION . " (" . PHP_OS . ")
";
 
		// USER: Este será el Nivel de errores que daremos a los usuarios.
		// No debemos imprimir nada más que nuestra cadena de error.
		case E_USER_NOTICE:
			echo 'Error: '.$cadena_err."
\n";
			break;
 
		// Para el resto nada.
		default:
			return false;
			break;
	}
	/* MUY IMPORTANTE: No ejecutar el gestor de errores interno de PHP */
	return true;
}

Conclusiones
Hay que hacer notar que en la función de reporte del administrador, sigo usando E_USER_NOTICE aparte de que con el nivel establecido me llegarán todos menos los avisos de php (E_NOTICE) no cejo en el empeño de ¡usar una única función! ...pero será más tarde, ahora no hay tiempo :(
Por lo demás, creo que el código por sí mismo se explica bastante bien.
En mis scripts simplemente genero mis errores con un simple:

trigger_error('Cadena de Error', Nivel de Error);

por ejemplo:

trigger_error('No se encontró un archivo básico para el sistema', E_USER_ERROR);

Y su versión administrativa con detalles digamos más sensibles:

trigger_error('No se encontró el archivo básico para el sistema: ' . $fileRequired, E_USER_ERROR); El nivel de error ya, como es lógico, depende de la severidad del error en tu código.
MVC
¿Porqué mencioné MVC?.. pues porque, aún no siendo MVC real, teniendo en cuenta que puedes establecer un preformato para tus avisos de error no necesitarás incrustar más código HTML para generar errores.
La función inicial sería el Modelo de datos, las funciones de php, este caso trigger_error, serían los Controladores y tu formato de error predefinido sería la Vista, tu plantilla.

De esta forma puedes llamar a los errores siempre desde funciones con búfer, por ejemplo con, aunque casi todo filtro es pesado, sprintf() o guardándolos en búferes de salida, y luego aplicarles el formato de la Vista. Ej:

1
2
3
4
5
6
7
8
9
	// Notices:
	$msgError = 'No se realizó la caché!

	No se pudo %1$s en el archivo: %2$s';
 
	$msgNotice = 'Atención!

	%1$s.';
 
	$msgOk = 'Caché!.

	El archivo %1$s se cacheó correctamente!';

Y luego generar un error formateado simplemente con:

trigger_error(sprintf($msgError,'escribir',$fileCached), E_USER_WARNING);

Sabiendo que tus errores tienen un formato HTML o una Vista del tipo:

1
2
3
4
5
 class="error">>DEBUG: Error Grave>
			>[%NúmeroError%] %TextoError% />
			Error fatal administrativo en la línea %LineaError% del archivo %ArchivoError% />
			%DatosOpcionales% />
			Abortando...>>

 con el que puede trabajar un Diseñador Web :?
O incluso puedes hacer otra función que gestione a trigger_error, o lo suyo, una clase... pero es ya es liar mucho la breva para eta entrada ;)
Fin
Pues eso, como siempre, a mí me basta y me va muy bien :D pero cualquier sugerencia será bien recibida ;) sin olvidar, eso sí, que es un ejercicio práctico a modo de ejemplo y de compatibilidad inversa -por el tema de la nueva gestión de errores de PHP5, las excepciones y tal- ;)

Cultura Digital#Blog » errores

PHP: Gestión personalizada de errores

Frameworks, librerías o métodos nativos

Controla la Gestión de Errores:

El método

Nivel de reporte de errores por usuario

El código:

DEBUG: Error Grave

DEBUG: Advertencia

Conclusiones

MVC

Fin