Como ativar o registo de erros e a automatização do PHP

És um programador que pretende automatizar o registo de erros do PHP?
O registo de erros do PHP é um sistema que captura problemas de tempo de execução no código PHP, registando detalhes sobre erros e avisos. Esta ferramenta é inestimável para os programadores, uma vez que fornece informações sobre a razão e o local onde um programa pode estar a falhar, o que é crucial para a resolução de problemas, otimização do desempenho e melhoria da experiência do utilizador.
Este guia concentra-se nos diferentes tipos de erros do PHP, como ativar o registro de erros do PHP, como visualizar os registros, como automatizar o registro de erros e muito mais.
Vamos começar…

Entendendo os diferentes tipos de erros do PHP

Os erros de PHP ocorrem quando algo está errado no código. Podem ser tão complexos como chamar uma variável incorrecta ou tão simples como faltar um ponto e vírgula. Tens de compreender o tipo de erros que enfrentas para os resolveres eficazmente. Portanto, vamos descobrir mais sobre os erros comuns do PHP.

Erro de aviso

Os erros de aviso do PHP alertam sobre um problema que pode causar um erro mais crítico a longo prazo. Os erros de aviso não interrompem a execução do código e geralmente ocorrem quando se usa um caminho de arquivo que não existe.
Por exemplo, se aparecer o erro abaixo, tens de verificar o nome do ficheiro no código ou na diretoria, pois o script pode não o encontrar devido a um erro de sintaxe.

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

Não existe nenhum ficheiro com o nome “external_file”, pelo que a saída apresentará uma caixa de mensagem de erro e a execução não será interrompida.

Aviso de erro

Os erros de aviso são menores e, como os erros de aviso, não interrompem a execução do código. No entanto, eles podem tornar mais difícil para o sistema determinar se há um problema real ou apenas um comportamento de código padrão. Os erros de aviso geralmente ocorrem quando o script tenta acessar uma variável indefinida.

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

Erro de sintaxe

Os símbolos analisados, mal utilizados ou em falta causam frequentemente erros de sintaxe. Quando o compilador detecta um erro, termina o script.
Os erros de análise/sintaxe são causados por:

• Parêntesis ou aspas não fechadas
• Falta ou excesso de ponto e vírgula ou parênteses
• Erros ortográficos

Aqui tens um exemplo de uma mensagem de erro de análise:

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

Erro fatal

Um erro fatal acontece quando o código chama a função, mas a função em si não é caracterizada. Ao contrário de outros erros do PHP, um erro fatal interrompe a execução e, por vezes, também bloqueia a aplicação.
Existem três tipos de erros fatais:

1. Um erro fatal de arranque ocorre quando a estrutura não consegue executar o código devido a um erro durante a instalação.
2. Um erro fatal em tempo de compilação ocorre quando o programador utiliza uma função ou classe indefinida ou uma variável ou dados inexistentes.
3. Um erro fatal em tempo de execução é semelhante a um erro fatal em tempo de compilação, mas ocorre durante a execução do programa.

Aqui tens um exemplo de um erro fatal do 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

Outra razão para um erro fatal é o facto de excederes o tempo de execução:

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

Noções básicas de configuração para o registro de erros do PHP

As definições de configuração do registo de erros do PHP permitem aos programadores gerir a forma como os erros são registados e apresentados. Diretivas-chave como log_errors e error_log activam ou desactivam o registo de erros e especificam caminhos de ficheiros personalizados para armazenar ficheiros de registo.
Vamos começar por rever algumas diretivas de configuração e localizações de ficheiros predefinidos para compreender o fluxo do tratamento de erros no PHP, incluindo onde os registos são armazenados e como a visibilidade dos erros é controlada para ambientes de desenvolvimento ou produção.

Diretivas de configuração

As diretivas de configuração no PHP são configurações no arquivo php.ini que controlam o comportamento do tempo de execução do PHP.
Estas diretivas permitem aos programadores configurar vários aspectos, como o relatório de erros, a utilização de memória e os limites de carregamento de ficheiros, para otimizar a funcionalidade do PHP para as suas aplicações.

Diretiva	Valor por defeito	Descrição
memory_limit	128M	Define a quantidade máxima de memória que um script pode consumir. Evita que os scripts esgotem a memória do servidor.
tempo_de_execução_máx	30	Define o tempo máximo (em segundos) que um script pode ser executado antes de ser encerrado.
exibir_erros	Desliga	Controla se os erros são exibidos como parte da saída. Usado durante o desenvolvimento, não recomendado na produção.
relatório_de_erros	E_ALL	Define o nível de comunicação de erros (por exemplo, avisos, notificações).
post_max_size	8M	Define o tamanho máximo dos dados POST permitidos. Deve ser maior do que upload_max_filesize.
upload_max_filesize	2M	Especifica o tamanho máximo dos ficheiros carregados. Útil para controlar os limites de carregamento.
log_errors	Ligado	Ativa ou desactiva o registo de erros. Ajuda a capturar erros em logs em vez de exibi-los aos usuários.
date.timezone	Não definido	Especifica o fuso horário padrão usado por todas as funções de data/hora. Tem de ser definido para evitar avisos.
session.gc_maxlifetime	1440	Define o tempo máximo em segundos durante o qual os dados da sessão são mantidos.
tamanho_da_cache_do_caminho_real	4M	Define o tamanho do cache realpath. Melhora o desempenho quando muitas operações de arquivo são executadas.

Para obter informações detalhadas sobre estas diretivas e outras, consulta a documentação do PHP sobre as diretivas de configuração e a descrição das definições principais do php.ini.

Localizações de ficheiros

Os logs de erro do PHP são configurados no arquivo php.ini, onde você pode definir um caminho personalizado para error_log. Se este local de arquivo não for configurado, o PHP envia por padrão os logs de erro para o log do sistema ou stderr() em contextos CLI.
Aqui estão os locais de configuração padrão para os logs de erro do PHP, que variam de acordo com o sistema operacional e o ambiente do PHP:

Sistema operativo	Caminho predefinido para o registo de erros	Notas adicionais
Linux	/var/log/syslog /var/log/messages	Localização padrão se error_log não estiver definido no php.ini. Os logs também podem ser direcionados para os logs do servidor web (e.g., /var/log/apache2/error.log para Apache).
Windows	Visualizador de Eventos do Windows (Registos de Aplicações)	Os erros aparecem no Visualizador de eventos em “Logs de aplicativos”. Os caminhos personalizados podem ser definidos através do php.ini.
macOS	/var/log/system.log	Os logs são direcionados aqui por padrão se não for especificado de outra forma no php.ini.
Personalizar	Caminho definido pelo utilizador em php.ini	Especificado usando a diretiva error_log. Por exemplo, error_log = /path/to/php_errors.log.

Como ativar o registo de erros do PHP [7 métodos]

A ativação do registo de erros do PHP pode ser feita através de vários métodos. Abaixo estão sete técnicas eficazes para ativar o registo de erros do PHP.

Método 1: Monitorizar o registo de erros utilizando a plataforma Cloudways [Método mais fácil]

Uma vez que a ativação do registro de erros PHP requer modificação no arquivo php.ini, você pode simplesmente ativar o registro de erros a partir da própria plataforma Cloudways com simples cliques. Você pode facilmente personalizar as configurações de error_reporting e logging da sua plataforma Cloudways.

• Faz login no painel de controle do Cloudways e clica na guia “Servidores”.

• Uma vez ativado, os teus registos de erros PHP serão gravados na pasta “Logs” das tuas aplicações. Também podes verificar os erros no separador de monitorização de cada aplicação.
• Podes filtrar facilmente os erros e avisos do php a partir do filtro de registos.

Método 2: Ativar o registo de erros utilizando o cPanel

Se o teu fornecedor de alojamento utiliza o cPanel, podes ativar o registo de erros do PHP através da interface do cPanel:

• Acede ao teu painel de controlo cPanel e navega até à secção “Software”.
• Clica na opção “Select PHP Version”.
• Desce até à secção “PHP INI Editor” e clica em “Open in New Window”.
• Localiza a diretiva “error_log” e define o seu valor para o caminho do ficheiro de registo pretendido.

Método 3: Ativar o registo de erros utilizando o ficheiro .htaccess

Também podes ativar o registo de erros do PHP modificando o ficheiro .htaccess no diretório raiz do teu site. Adiciona as seguintes linhas:

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

Método 4: Ativar o registo de erros utilizando o ficheiro php.ini

Se tiveres acesso ao ficheiro php.ini, podes ativar o registo de erros do PHP modificando as seguintes diretivas:

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

Método 5: Habilita o registro de erros do PHP em um arquivo usando a função error_log()

Podes utilizar a função error_log() no teu código PHP para registar mensagens personalizadas no registo de erros:

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

Método 6: ativar a coleta automática de erros de PHP com o Retrace APM

Para habilitar a coleta automática de erros de PHP com o Retrace APM, primeiro inscreve-se em uma conta do Retrace e instala o agente do Retrace no servidor, garantindo que o monitoramento do APM esteja habilitado durante a instalação.
Uma vez configurado, o Retrace recolherá automaticamente erros, avisos e notificações da tua aplicação PHP sem exigir alterações adicionais ao código.
Podes ver os erros recolhidos na secção “Erros” da tua conta Retrace, que fornece informações detalhadas, incluindo mensagens de erro, traços de pilha e ficheiros afectados.
Além disso, o Retrace integra-se com ferramentas populares de rastreio de problemas e recolhe métricas de desempenho, simplificando a monitorização de erros e o processo de resolução de problemas para melhorar a saúde e a eficiência das aplicações.

Método 7: Ativar o registo de erros do PHP através da configuração do servidor Web

Dependendo da configuração do servidor Web, podes ativar o registo de erros do PHP através das definições do servidor. Por exemplo, podes adicionar estas diretivas ao ficheiro httpd.conf no Apache:

PHP_value error_log /path/to/error_log

Localizações de ficheiros

A localização do arquivo de log de erros do PHP é definida pela diretiva error_log no php.ini. No entanto, podes escolher um caminho que melhor se adapte ao teu ambiente.
Aqui estão alguns caminhos de ficheiros comuns:

• /var/log/php_errors.log: Usado frequentemente em sistemas baseados em Unix.
• /tmp/php-error.log: Uma localização temporária adequada para testes.
• /path/to/project/php-error.log: Uma localização personalizada dentro do diretório do teu projeto, que pode ajudar no acesso ao arquivo.

Para definir um caminho personalizado, utiliza a seguinte diretiva em php.ini ou no script:

Como ver os registos de erros do PHP

Agora que sabes como ativar os registos de erros do PHP, vamos examinar diferentes formas de os ver.

Método 1: Utilizar o ficheiro .htaccess

O ficheiro .htaccess, normalmente utilizado em servidores Apache, pode ser configurado para permitir o registo de erros do PHP em diretórios específicos.
Navega para o diretório raiz do teu projeto Laravel. Na pasta do teu projeto, encontra o diretório público my-laravel-app/public/. O arquivo .htaccess deve estar localizado diretamente dentro da pasta pública

Adiciona as seguintes linhas ao teu ficheiro .htaccess:

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

Substitui /path/to/php-error.log pelo caminho real onde queres armazenar o ficheiro de registo de erros. Depois de adicionares este código, os erros do PHP para esse diretório serão registados no ficheiro especificado.

Método 2: Utilizar o ficheiro php.ini

A configuração do registo de erros do PHP envolve algumas definições primárias no ficheiro php.ini, onde podes controlar a visibilidade e o registo de erros.

• Primeiro, localiza o teu ficheiro php.ini;
• Abre o teu editor de código para criar um ficheiro .php. Neste caso, adiciona este pedaço de código ao novo ficheiro:

<?php phpinfo(); ?>

• Abre o disco local. Localiza a pasta Wamp e, em seguida, abre a pasta www. Copia este ficheiro info.php para a pasta wamp/www.

• Abre o browser. Escreve localhost/info.php na barra de endereços. Verás uma tabela com as definições disponíveis.
• Tenta pesquisar com php.ini como palavra-chave. No campo Loaded Configuration File (Ficheiro de Configuração Carregado), verás o caminho para o ficheiro php.ini. Neste caso, é C:\wamp\bin\apache\apache2.4.9\bin\php.ini. Basta seguires o caminho para encontrares o ficheiro:

• Aqui está o ficheiro php.ini que tens de editar. Abre e edita o ficheiro e depois guarda-o:

Para registar erros no PHP,

• Abre o ficheiro php.ini.
• Procura e actualiza as seguintes definições:

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

• Se quiseres ativar o registo de erros do PHP em ficheiros individuais, adiciona este código no topo do ficheiro PHP.

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

• Deves ativar apenas uma declaração para analisar os erros de registo no ficheiro php.ini:

display_errors = on.

• Agora, podes ver facilmente os erros registados no teu browser.
• Alguns dos comandos adicionais que podes escrever para o registo de erros do PHP incluem:

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 o ficheiro e reinicia o servidor Web para que as alterações tenham efeito.

Método 3: Ver os registos no servidor

Se tiveres acesso ao servidor, podes ver diretamente o ficheiro de registo de erros do PHP. A localização deste ficheiro depende da configuração do teu servidor. Os caminhos de arquivo comuns incluem:

• /var/log/php_errors.log em sistemas baseados em Unix
• /usr/local/apache/logs/error_log em algumas configurações

Usa o SSH para aceder ao teu servidor e ver os registos. Podes usar comandos como cat, tail ou less para ler os registos:

# 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 funções de registo

O PHP também oferece funções incorporadas para registar erros manualmente, permitindo-te criar mensagens de erro personalizadas no ficheiro de registo de erros.

1. função error_log()

A função error_log() pode ser utilizada nos teus scripts PHP para registar eventos ou erros específicos.
Eis um exemplo:

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

• Mensagem de erro personalizada: Algo correu mal! é a mensagem de erro.
• 3 especifica que a mensagem deve ser anexada ao ficheiro de registo de erros.
• “/path/to/php-error.log” é o caminho para o ficheiro de registo

Usar error_log() é útil para registar erros condicionalmente, especialmente em scripts onde são necessárias mensagens de erro personalizadas para a resolução de problemas.

2. Função trigger_error()

trigger_error() gera um erro, aviso ou notificação ao nível do utilizador.
Esta função é útil nos casos em que pretendes parar a execução ou apresentar avisos com base em condições 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. Função syslog()

Outro tipo de função de registo é syslog(). O seu objetivo básico é registar mensagens no registador do sistema, que é gerido pelo SO.
O Syslog () registra mensagens diretamente no sistema de registro do sistema operacional. Essa função é útil em ambientes onde o registro em nível de sistema é preferido e o gerenciamento de registro é centralizado.

<?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();
?>

Personalização avançada do registo de erros do PHP

A personalização avançada do registo de erros do PHP envolve a adaptação da forma como os erros são registados e geridos na sua aplicação, particularmente em ambientes de produção.
Isto pode melhorar a depuração, fornecer informações mais claras e otimizar o desempenho da aplicação através da estruturação de registos e da supressão de erros não críticos.
Para mostrar como executar a personalização avançada do registro de erros do PHP, configurarei um sistema de registro de erros estruturado no PHP usando a biblioteca Monolog, configurando-o para registrar erros no formato JSON em um arquivo para facilitar a análise e a análise.
Também utilizaremos as configurações do PHP para suprimir erros não críticos na produção, direcionando apenas os erros essenciais para um ficheiro de registo e ocultando-os dos utilizadores finais para melhorar a segurança e a experiência do utilizador.

Formatos de registo personalizados: Usando JSON ou outros formatos estruturados

A utilização de formatos estruturados para o registo, como o JSON, torna os registos legíveis por máquinas. O registo JSON é especialmente benéfico em aplicações complexas.
Isto permite que os registos sejam facilmente analisados, pesquisados e analisados por várias ferramentas e sistemas de registo, permitindo melhores conhecimentos em ambientes de produção.

Configurar o formato de registo JSON em PHP

• Primeiro, instala o Monolog utilizando o Composer.

composer require monolog/monolog

Os registos de erros do PHP estão em formato de texto simples, mas podes personalizar o formato do registo para JSON utilizando uma ferramenta de biblioteca de registo de terceiros, como o Monolog,

• Em seguida, cria um registador simples que produza erros no 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')
]);

Supressão de erros: Técnicas para ocultar erros não críticos na produção

Em ambientes de produção, é geralmente uma prática recomendada ocultar erros não críticos ou sensíveis dos utilizadores finais e, em vez disso, registá-los para que os programadores os revejam mais tarde.
A supressão destes erros melhora a experiência do utilizador, reduz potenciais riscos de segurança e mantém a aplicação a funcionar sem problemas, mesmo quando surgem pequenos problemas.
O PHP fornece opções de configuração para controlar quais erros são relatados e se eles devem ser exibidos aos usuários.

1. Desativar a apresentação de erros: Isto impede que os erros sejam mostrados no ecrã. Em php.ini, define:

display_errors = Off

2. Configura os níveis de relatório de erros: Configura o relatório de erros para capturar apenas erros críticos e suprimir avisos ou notificações.

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

3. Saída direta de erros para um arquivo de log: Esta opção registra os erros em um arquivo em vez de mostrá-los, permitindo que os desenvolvedores os revisem mais tarde.

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

Tratamento de erros no PHP 8.x

O PHP 8 introduziu novos recursos de tratamento de erros e exceções, incluindo mensagens de erro mais detalhadas e um conjunto refinado de tipos de exceção.

• TypeError e ValueError: Essas exceções são mais rígidas no PHP 8.x, especialmente com a introdução de um novo tratamento de tipos e regras de tipagem mais rígidas. Por exemplo, TypeError será lançado se tu passares um argumento com o tipo errado.
• Novos tipos de erro: O PHP 8 introduziu o ValueError, que é lançado quando uma função recebe um argumento que é correto no tipo, mas inválido no valor.
• Melhoria no tratamento de ErrorException: O PHP 8 oferece uma melhor integração com ErrorException, permitindo que os desenvolvedores capturem e convertam erros em exceções de forma mais 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 excepções personalizadas

O PHP 8.x permite-te definir excepções personalizadas ao estender a classe Exception , permitindo um tratamento de erros mais específico.

<?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";
?>

Saída

Tratamento de exceções com um bloco Finally

O bloco finally é utilizado para acções de limpeza, como o encerramento de ficheiros ou a libertação de recursos, garantindo que ocorrem mesmo que ocorra um erro durante a execução.

<?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";
?>

 

Saída

Automatizando o processo de registro de erros do PHP

Automatizar o processo de registo de erros em PHP é uma forma eficaz de tratar os erros de forma consistente e reduzir o risco de erros não tratados.

• Cria uma função de tratamento de erros personalizada que capta e regista os erros.
• Este manipulador pode formatar e direcionar os registos para um ficheiro ou serviço de registo.

<?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 seguir, usa set_error_handler() para converter os erros tradicionais do PHP em excepções, facilitando o tratamento de todos os erros num único local.

// 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);
});

• Agora precisas de definir um manipulador de excepções personalizado.

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

• Usa register_shutdown_function() para erros fatais.

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']);
    }
});

Erro de saída

Depois de executares esta configuração, o logs/errors.log pode conter entradas como:

No seguinte resultado,
1. Registo 1: Esta entrada de registo indica um aviso PHP não fatal devido a uma variável indefinida na linha 35 de index.php.
A primeira entrada de registo é de Gravidade 2 e relata uma“Variável indefinida: undefinedVariable“. O erro ocorreu no ficheiro /path/to/index.php.
2. Registo 2: Esta entrada serve como um registo informativo de baixa gravidade, provavelmente utilizado para testar a funcionalidade de registo de excepções.
A segunda entrada de registo é de Severidade 1 e regista uma mensagem“Testar registo de excepções“. Este erro foi registado no mesmo ficheiro, /path/to/index.php, na linha 37.