Cómo activar el registro de errores y la automatización de PHP

¿Eres desarrollador y quieres automatizar el registro de errores de PHP?

El registro de errores PHP es un sistema que captura los problemas en tiempo de ejecución dentro del código PHP, registrando detalles sobre errores y advertencias. Esta herramienta tiene un valor incalculable para los desarrolladores, ya que proporciona información sobre por qué y dónde puede estar fallando un programa, lo cual es crucial para la resolución de problemas, la optimización del rendimiento y la mejora de la experiencia del usuario.

Esta guía se centra en los diferentes tipos de errores PHP, cómo activar el registro de errores PHP, cómo ver los registros, cómo automatizar el registro de errores y mucho más.

Empecemos…

Comprender los distintos tipos de errores PHP

Los errores PHP se producen cuando algo está fuera de base dentro del código. Pueden ser tan complejos como llamar a una variable incorrecta o tan simples como saltarse un punto y coma. Debes comprender el tipo de errores a los que te enfrentas para resolverlos eficazmente. Así que vamos a averiguar más sobre los errores PHP más comunes.

Error de advertencia

Los errores de advertencia de PHP alertan sobre un problema que puede causar un error más crítico a largo plazo. Los errores de advertencia no interrumpen la ejecución del código y suelen producirse cuando se utiliza una ruta de archivo que no existe.

Por ejemplo, si aparece el siguiente error, debes comprobar el nombre del archivo en el código o directorio, ya que es posible que el script no lo encuentre debido al error de sintaxis.

<?php
echo "Warning error"';
include ("external_file.php");
?
>

No hay ningún archivo llamado «archivo_externo», por lo que la salida mostrará un cuadro de mensaje de error, y la ejecución no se interrumpirá.

Error de aviso

Los errores de aviso son menores y, al igual que los errores de advertencia, no detienen la ejecución del código. Sin embargo, pueden dificultar que el sistema determine si hay un problema real o sólo un comportamiento estándar del código. Los errores de aviso suelen producirse cuando el script intenta acceder a una variable no definida.

Notice: [8] Undefined variable: undefinedVariable in /path/to/your/script.php on line 12

Error de sintaxis

Los símbolos parseados, mal utilizados o ausentes suelen provocar errores de sintaxis. Cuando el compilador detecta un error, termina el script.

Los errores de análisis sintáctico/sintaxis se deben a:

• Paréntesis o comillas sin cerrar
• Falta o sobra punto y coma o paréntesis
• Errores ortográficos

Aquí tienes un ejemplo de mensaje de error de análisis:

PHP Parse error: syntax error, unexpected ‘5’ (L_NAME), expecting ‘)’ in /home/u802426761/domains/username/public_html/wp-config.php on line 32

Error fatal

Un error fatal se produce cuando el código llama a la función, pero la función en sí no se caracteriza. A diferencia de otros errores PHP, un error fatal interrumpe la ejecución y a veces también bloquea la aplicación.

Hay tres tipos de errores fatales:

1. Un error fatal de inicio ocurre cuando el framework no puede ejecutar el código debido a un error durante la instalación.
2. Se produce un error fatal en tiempo de compilación cuando el programador utiliza una función o clase no definida, o una variable o dato inexistente.
3. Un error fatal en tiempo de ejecución es similar a un error fatal en tiempo de compilación, pero ocurre durante la ejecución del programa.

Aquí tienes un ejemplo de error fatal PHP:

PHP Fatal error: Call to undefined function get_header() in /var/www/username/public/blog/wp-content/themes/theme/index.php on line 37

Otro motivo de error fatal es superar el tiempo de ejecución:

Fatal error: Maximum execution time of 30 seconds exceeded in /home/username/domains/domain.com/public_html/wp-includes/class-phpmailer.php on line 737

Configuración básica del registro de errores de PHP

Los ajustes de configuración del registro de errores de PHP permiten a los desarrolladores gestionar cómo se registran y muestran los errores. Directivas clave como log_errors y error_log activan o desactivan el registro de errores y especifican rutas de archivo personalizadas para almacenar los archivos de registro.

Empecemos revisando algunas directivas de configuración y ubicaciones de archivos por defecto para comprender el flujo de la gestión de errores en PHP, incluyendo dónde se almacenan los registros y cómo se controla la visibilidad de los errores en entornos de desarrollo o producción.

Directivas de configuración

Las directivas de configuración en PHP son ajustes en el archivo php.ini que controlan el comportamiento del tiempo de ejecución de PHP.

Estas directivas permiten a los desarrolladores configurar varios aspectos, como los informes de errores, el uso de memoria y los límites de carga de archivos, para optimizar la funcionalidad de PHP para sus aplicaciones.

Directiva	Valor por defecto	Descripción
limite_memoria	128M	Establece la cantidad máxima de memoria que puede consumir un script. Evita que los scripts agoten la memoria del servidor.
tiempo_de_ejecución_máx	30	Establece el tiempo máximo (en segundos) que se permite ejecutar un script antes de ser finalizado.
mostrar_errores	Fuera de	Controla si los errores se muestran como parte de la salida. Se utiliza durante el desarrollo, no se recomienda en producción.
notificación_de_errores	E_TODOS	Define el nivel de notificación de errores (por ejemplo, advertencias, avisos).
tamaño_máx_post	8M	Establece el tamaño máximo de los datos POST permitidos. Debe ser mayor que upload_max_filesize.
subir_tamaño_max_archivos	2M	Especifica el tamaño máximo de los archivos subidos. Útil para controlar los límites de subida.
log_errores	En	Activa o desactiva el registro de errores. Ayuda a capturar los errores en los registros en lugar de mostrarlos a los usuarios.
fecha.zona horaria	No fijado	Especifica la zona horaria por defecto utilizada por todas las funciones fecha/hora. Debe establecerse para evitar advertencias.
session.gc_maxlifetime	1440	Define el tiempo máximo en segundos durante el que se conservan los datos de la sesión.
tamaño_cache_camino_real	4M	Establece el tamaño de la caché de la ruta real. Mejora el rendimiento cuando se realizan muchas operaciones con archivos.

 

Para obtener información detallada sobre estas directivas y otras, consulta la documentación de PHP sobre directivas de configuración y la descripción de los ajustes básicos de php.ini.

Localización de archivos

Los registros de errores de PHP se configuran en el archivo php.ini, donde puedes definir una ruta personalizada para error_log. Si no se configura esta ubicación de archivo, PHP envía por defecto los registros de errores al registro del sistema o a stderr() en contextos CLI.

Estas son las ubicaciones de configuración por defecto para los registros de errores PHP, que varían según el sistema operativo y el entorno PHP:

Sistema operativo	Ruta por defecto para el registro de errores	Notas adicionales
Linux	/var/log/syslog /var/log/messages	Ubicación por defecto si error_log no está establecido en php.ini. Los registros también pueden dirigirse a los registros del servidor web (por ejemplo, /var/log/apache2/error.log para Apache).
Windows	Visor de sucesos de Windows (Registros de aplicaciones)	Los errores aparecen en el Visor de Sucesos, en «Registros de la aplicación». Se pueden establecer rutas personalizadas mediante php.ini.
macOS	/var/log/sistema.log	Los registros se dirigen aquí por defecto si no se especifica lo contrario en php.ini.
Personalizado	Ruta definida por el usuario en php.ini	Se especifica mediante la directiva error_log. Por ejemplo, error_log = /ruta/a/php_errores.log.

Cómo activar el registro de errores de PHP [7 métodos]

Habilitar el registro de errores PHP puede hacerse mediante varios métodos. A continuación se presentan siete técnicas eficaces para activar el registro de errores de PHP.

Método 1: Monitorizar el Registro de Errores Usando la Plataforma Cloudways [Método Más Fácil]

Dado que habilitar el registro de errores PHP requiere modificar el archivo php.ini, puedes activar el registro de errores desde la propia plataforma Cloudways con unos simples clics. Puedes personalizar fácilmente la configuración de error_reporting y logging desde tu Plataforma Cloudways.

• Accede a tu panel de control de Cloudways y haz clic en la pestaña «Servidores».

• Una vez activado, los registros de errores PHP se grabarán en la carpeta «Registros» de tus aplicaciones. También puedes comprobar los errores en la pestaña de monitorización de cada aplicación.
• Puedes filtrar fácilmente los errores y advertencias de php desde el filtro de registros.

Método 2: Activar el registro de errores mediante cPanel

Si tu proveedor de alojamiento utiliza cPanel, puedes activar el registro de errores de PHP a través de la interfaz de cPanel:

• Accede a tu panel de control de cPanel y navega hasta la sección «Software».
• Haz clic en la opción «Seleccionar versión de PHP».
• Desplázate hasta la sección «Editor PHP INI» y haz clic en «Abrir en una ventana nueva».
• Localiza la directiva «error_log» y establece su valor en la ruta deseada del archivo de registro.

Método 3: Activar el registro de errores mediante el archivo .htaccess

También puedes activar el registro de errores PHP modificando el archivo .htaccess del directorio raíz de tu sitio web. Añade las siguientes líneas:

php_flag display_startup_errors on
php_flag display_errors on
php_flag html_errors on
php_value error_reporting 32767

Método 4: Activar el registro de errores mediante el archivo php.ini

Si tienes acceso al archivo php.ini, puedes activar el registro de errores de PHP modificando las siguientes directivas:

display_errors = On
error_reporting = E_ALL
log_errors = On
error_log = /path/to/error_log

Método 5: Activar el registro de errores PHP en un archivo mediante la función error_log()

Puedes utilizar la función error_log() en tu código PHP para registrar mensajes personalizados en el registro de errores:

error_log('This is a custom error message');

Método 6: Activar la recopilación automática de errores PHP con Retrace APM

Para activar la recopilación automática de errores PHP con Retrace APM, primero regístrate para obtener una cuenta de Retrace e instala el agente de Retrace en tu servidor, asegurándote de que la monitorización APM está activada durante la instalación.

Una vez configurado, Retrace recopilará automáticamente errores, advertencias y avisos de tu aplicación PHP sin requerir cambios adicionales en el código.

Puedes ver los errores recopilados en la sección «Errores» de tu cuenta de Retrace, que proporciona información detallada, incluidos los mensajes de error, las trazas de pila y los archivos afectados.

Además, Retrace se integra con herramientas populares de seguimiento de problemas y recopila métricas de rendimiento, agilizando tu proceso de supervisión de errores y resolución de problemas para mejorar la salud y la eficiencia de la aplicación.

Método 7: Habilitar el registro de errores PHP a través de la configuración del servidor web

Dependiendo de la configuración de tu servidor web, puedes activar el registro de errores PHP a través de la configuración del servidor. Por ejemplo, puedes añadir estas directivas al archivo httpd.conf de Apache:

PHP_value error_log /path/to/error_log

Localización de archivos

La ubicación del archivo de registro de errores de PHP se define mediante la directiva error_log en php.ini. Sin embargo, puedes elegir la ruta que mejor se adapte a tu entorno.

Aquí tienes algunas rutas de archivos comunes:

• /var/log/php_errors.log: Se utiliza a menudo en sistemas basados en Unix.
• /tmp/php-error.log: Una ubicación temporal adecuada para realizar pruebas.
• /ruta/al/proyecto/php-error.log: Una ubicación personalizada dentro del directorio de tu proyecto, que puede ayudar con el acceso al archivo.

Para establecer una ruta personalizada, utiliza la siguiente directiva en php.ini o en el script:

Cómo ver los registros de errores de PHP

Ahora que ya sabes cómo activar los registros de errores de PHP, vamos a examinar distintas formas de verlos.

Método 1: Utilizar el archivo .htaccess

El archivo .htaccess, típicamente utilizado en servidores Apache, puede configurarse para activar el registro de errores PHP para directorios específicos.

Navega hasta el directorio raíz de tu proyecto Laravel, En la carpeta de tu proyecto, busca el directorio público my-laravel-app/public/. El archivo .htaccess debe encontrarse directamente dentro de la carpeta pública

Añade las siguientes líneas a tu archivo .htaccess:

php_flag log_errors On
php_value error_log /path/to/php-error.log

Sustituye /ruta/para/error.log por la ruta real donde quieras almacenar el archivo de registro de errores. Después de añadir este código, los errores PHP de ese directorio se registrarán en el archivo especificado.

Método 2: Utilizar el archivo php.ini

Configurar el registro de errores de PHP implica unos cuantos ajustes principales en el archivo php.ini, donde puedes controlar la visibilidad y el registro de errores.

• Primero, localiza tu archivo php.ini;
• Abre tu editor de código para crear un archivo .php. En este caso, añade este fragmento de código al nuevo archivo:

<?php phpinfo(); ?>

• Abre el Disco local. Localiza la carpeta Wamp y abre la carpeta www. Copia este archivo info.php en la carpeta wamp/www.

• Abre el navegador. Escribe localhost/info.php en la barra de direcciones. Verás una tabla con los ajustes disponibles.
• Intenta buscar con php.ini como palabra clave. En el campo Archivo de configuración cargado, verás la ruta al archivo php.ini. En este caso, es C:\wamp\bin\apache\apache2.4.9\bin\php.ini. Sólo tienes que seguir la ruta para encontrar el archivo:

• Aquí tienes el archivo php.ini que tienes que editar. Sólo tienes que abrir y editar el archivo, y luego guardarlo:

Para registrar errores en PHP,

• Abre el archivo php.ini.
• Busca y actualiza los siguientes ajustes:

error_reporting = E_ALL & ~E_NOTICE

error_reporting = E_ALL & ~E_NOTICE | E_STRICT

error_reporting = E_COMPILE_ERROR|E_RECOVERABLE_ERROR|E_ER… _ERROR

error_reporting = E_ALL & ~E_NOTICE

• Si quieres activar el registro de errores PHP en archivos individuales, añade este código en la parte superior del archivo PHP.

ini_set('display_errors', 1);
ini_set('display_startup_errors', 1);
error_reporting(E_ALL);

• Debes activar sólo una sentencia para analizar los errores del registro en el archivo php.ini:

display_errors = on.

• Ahora, puedes ver fácilmente los errores registrados en tu navegador.
• Algunos de los comandos adicionales que puedes escribir para el registro de errores de PHP son:

display_errors = Off          ; Hides errors from being displayed on the front end
log_errors = On               ; Enables error logging
error_log = /path/to/php-error.log ; Specifies the error log file location
error_reporting = E_ALL       ; Logs all types of errors

• Guarda el archivo y reinicia tu servidor web para que los cambios surtan efecto.

Método 3: Ver registros en el servidor

Si tienes acceso al servidor, puedes ver directamente el archivo de registro de errores PHP. La ubicación de este archivo depende de la configuración de tu servidor. Las rutas de archivo más comunes son:

• /var/log/php_errors.log en sistemas basados en Unix
• /usr/local/apache/logs/error_log en algunas configuraciones

Utiliza SSH para acceder a tu servidor y ver los registros. Puedes utilizar comandos como cat, tail o less para leer los registros:

# To see last 50 lines of the PHP error log run the following line of code

tail -n 50 /var/log/php_errors.log

Método 4: Utilizar funciones de registro

PHP también ofrece funciones integradas para registrar errores manualmente, permitiéndote crear mensajes de error personalizados en el archivo de registro de errores.

1. función error_log()

La función error_log( ) puede utilizarse en tus scripts PHP para registrar eventos o errores específicos.

He aquí un ejemplo:

error_log("Custom error message: Something went wrong!", 3, "/path/to/php-error.log");

• Mensaje de error personalizado: Algo ha ido mal! es el mensaje de error.
• 3 especifica que el mensaje se añada al archivo de registro de errores.
• «/ruta/a/errorphp.log» es la ruta al archivo de registro

Utilizar error_log() es útil para registrar errores condicionalmente, especialmente en scripts en los que se necesitan mensajes de error personalizados para solucionar problemas.

2. Función trigger_error()

trigger_error() genera un error, advertencia o aviso a nivel de usuario.

Esta función es útil en los casos en que quieras detener la ejecución o mostrar advertencias basadas en condiciones específicas.

<?php
// Generates a user-level warning
trigger_error("This is a custom warning", E_USER_WARNING);

// Generates a user-level error (fatal)
trigger_error("Fatal error encountered", E_USER_ERROR);
?>

3. Función syslog()

Otro tipo de función de registro es syslog(). Su finalidad básica es registrar mensajes en el registrador del sistema, gestionado por el SO.

Syslog () registra los mensajes directamente en el sistema de registro del sistema operativo. Esta función es útil en entornos en los que se prefiere el registro a nivel de sistema y la gestión de registros está centralizada.

<?php
// Open a connection to the system logger
openlog("php_script", LOG_PID | LOG_PERROR, LOG_LOCAL0);

// Logs an informational message to the system log
syslog(LOG_INFO, "This is an informational message");

// Logs an error message to the system log
syslog(LOG_ERR, "This is an error message");

// Close the connection to the system logger
closelog();
?>

Personalización avanzada del registro de errores PHP

La personalización avanzada del registro de errores PHP implica adaptar cómo se registran y gestionan los errores en tu aplicación, sobre todo en entornos de producción.

Esto puede mejorar la depuración, proporcionar una visión más clara y optimizar el rendimiento de la aplicación estructurando los registros y suprimiendo los errores no críticos.

Para mostrar cómo llevar a cabo una personalización avanzada del registro de errores en PHP, configuraré un sistema estructurado de registro de errores en PHP utilizando la biblioteca Monolog, configurándolo para que registre los errores en formato JSON en un archivo para facilitar su análisis y análisis.

También utilizaremos configuraciones PHP para suprimir los errores no críticos en producción, dirigiendo sólo los errores esenciales a un archivo de registro y ocultándolos a los usuarios finales para mejorar la seguridad y la experiencia de usuario.

Formatos de registro personalizados: Uso de JSON u otros formatos estructurados

Utilizar formatos estructurados para el registro, como JSON, hace que los registros sean legibles por las máquinas. El registro JSON es especialmente beneficioso en aplicaciones complejas.

Esto permite que los registros sean fácilmente analizados, buscados y analizados por varias herramientas y sistemas de registro, permitiendo una mejor comprensión de los entornos de producción.

Configurar el formato de registro JSON en PHP

• Primero, instala Monolog con Composer.

composer require monolog/monolog

Los registros de errores de PHP están en formato de texto plano, puedes personalizar el formato del registro a JSON utilizando una herramienta de biblioteca de registro de terceros como Monolog,

• A continuación, crea un registrador sencillo que dé salida a los errores en formato JSON.

<?php
use Monolog\Logger;
use Monolog\Handler\StreamHandler;
use Monolog\Formatter\JsonFormatter;

// Create the logger
$logger = new Logger('custom_logger');

// Create a StreamHandler to write logs to a file
$handler = new StreamHandler(__DIR__ . '/logs/app.log', Logger::ERROR);

// Set the handler's formatter to JSON
$handler->setFormatter(new JsonFormatter());

// Push the handler to the logger
$logger->pushHandler($handler);

// Log an error with a custom message and context
$logger->error('An unexpected error occurred', [
    'user_id' => 1234,
    'action' => 'update_profile',
    'timestamp' => date('Y-m-d H:i:s')
]);

Suprimir Errores: Técnicas para Ocultar Errores No Críticos en Producción

En entornos de producción, suele ser una buena práctica ocultar los errores no críticos o sensibles a los usuarios finales y, en su lugar, registrarlos para que los revisen después los desarrolladores.

Suprimir estos errores mejora la experiencia del usuario, reduce los posibles riesgos de seguridad y mantiene la aplicación funcionando sin problemas incluso cuando surgen problemas menores.

PHP proporciona opciones de configuración para controlar de qué errores se informa y si deben mostrarse a los usuarios.

1. Desactivar la Visualización de Errores: Esto evita que los errores se muestren en la pantalla. En php.ini, establece:

display_errors = Off

2. Configura los Niveles de Notificación de Errores: Configura los informes de errores para capturar sólo los errores críticos y suprimir las advertencias o avisos.

// Suppress non-critical errors
error_reporting(E_ERROR | E_PARSE); // Only log critical errors

3. Salida directa de errores a un archivo de registro: Esta opción registra los errores en un archivo en lugar de mostrarlos, lo que permite a los desarrolladores revisarlos más tarde.

log_errors = On
error_log = /path/to/error.log

Tratamiento de errores en PHP 8.x

PHP 8 ha introducido nuevas funciones de gestión de errores y excepciones, incluidos mensajes de error más detallados y un conjunto refinado de tipos de excepción.

• TypeError y ValueError: Estas excepciones son más estrictas en PHP 8.x, especialmente con la introducción de un nuevo manejo de tipos y reglas de tipado más estrictas. Por ejemplo, se lanzará TypeError si pasas un argumento con un tipo incorrecto.
• Nuevos tipos de error: PHP 8 introdujo ValueError, que se lanza cuando una función recibe un argumento que es correcto en tipo pero inválido en valor.
• Manejo mejorado de ErrorException: PHP 8 ofrece una mejor integración con ErrorException, permitiendo a los desarrolladores capturar y convertir errores en excepciones de forma más eficiente.

<?php

function divide($dividend, $divisor) {
    if ($divisor == 0) {
        throw new Exception("Cannot divide by zero.");
    }
    return $dividend / $divisor;
}

try {
    echo divide(10, 0);
} catch (Exception $e) {
    echo "Error: " . $e->getMessage();
}

Error: Cannot divide by zero.

Utilizar excepciones personalizadas

PHP 8.x te permite definir excepciones personalizadas extendiendo la clase Excepción , lo que permite un manejo más específico de los errores.

<?php
function inverse($x) {
    if (!$x) {
        throw new Exception('Division by zero.');
    }
    return 1/$x;
}

try {
    echo inverse(5) . "\n";
    echo inverse(0) . "\n";
} catch (Exception $e) {
    echo 'Caught exception: ',  $e->getMessage(), "\n";
}

// Continue execution
echo "Hello World\n";
?>

Salida

Tratamiento de excepciones con un bloque Finally

El bloque finally se utiliza para acciones de limpieza, como cerrar archivos o liberar recursos, asegurando que se produzcan aunque ocurra un error durante la ejecución.

<?php
function inverse($x) {
    if (!$x) {
        throw new Exception('Division by zero.');
    }
    return 1/$x;
}

try {
    echo inverse(5) . "\n";
} catch (Exception $e) {
    echo 'Caught exception: ',  $e->getMessage(), "\n";
} finally {
    echo "First finally.\n";
}

try {
    echo inverse(0) . "\n";
} catch (Exception $e) {
    echo 'Caught exception: ',  $e->getMessage(), "\n";
} finally {
    echo "Second finally.\n";
}

// Continue execution
echo "Hello World\n";
?>

 

Salida

Automatizar el proceso de registro de errores de PHP

Automatizar el proceso de registro de errores en PHP es una forma eficaz de gestionar los errores de forma coherente y reducir el riesgo de errores no gestionados.

• Crea una función de gestión de errores personalizada que capture y registre los errores.
• Este gestor puede formatear y dirigir los registros a un archivo o a un servicio de registro.

<?php
// config.php or index.php

// Define the error logging function
function logError($severity, $message, $file, $line) {
    $logMessage = json_encode([
        'severity' => $severity,
        'message' => $message,
        'file' => $file,
        'line' => $line,
        'timestamp' => date('Y-m-d H:i:s')
    ]);

    // Log to a specific file
    error_log($logMessage . PHP_EOL, 3, __DIR__ . '/logs/errors.log');
}

• A continuación, utiliza set_error_handler() para convertir los errores tradicionales de PHP en excepciones, facilitando el manejo de todos los errores en un solo lugar.

// Set a custom error handler to convert errors to exceptions
set_error_handler(function ($severity, $message, $file, $line) {
    // Only log specific error levels if needed
    if (!(error_reporting() & $severity)) {
        return;
    }
    throw new ErrorException($message, 0, $severity, $file, $line);
});

• Ahora tienes que establecer un manejador de excepciones personalizado.

set_exception_handler(function ($exception) {
    logError(
        $exception->getCode(),
        $exception->getMessage(),
        $exception->getFile(),
        $exception->getLine()
    );
});

• Utiliza register_shutdown_function() para los Errores Fatales.

register_shutdown_function(function () {
    $error = error_get_last();
    if ($error && in_array($error['type'], [E_ERROR, E_PARSE, E_CORE_ERROR, E_COMPILE_ERROR])) {
        logError($error['type'], $error['message'], $error['file'], $error['line']);
    }
});

Error de salida

Después de ejecutar esta configuración, logs/errors.log puede contener entradas como

En la siguiente salida,

1. Registro 1: Esta entrada del registro indica una advertencia PHP no fatal debida a una variable indefinida en la línea 35 de index.php.

La primera entrada del registro es de gravedad 2 e informa de una«Variable indefinida: undefinedVariable«. El error se produjo en el archivo /ruta/a/index.php.

2. Registro 2: Esta entrada sirve como registro informativo de baja gravedad, probablemente utilizado para probar la funcionalidad de registro de excepciones.

La segunda entrada del registro es de gravedad 1 y registra un mensaje«Registro de excepción de prueba«. Este error se registró en el mismo archivo, /ruta/a/index.php, en la línea 37.