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 "Erro de aviso"';
inclui ("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.

Repara: [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: erro de sintaxe, '5' inesperado (L_NAME), esperando ')' em /home/u802426761/domains/username/public_html/wp-config.php na linha 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 Erro fatal: Chamada a função indefinida get_header() em /var/www/username/public/blog/wp-content/themes/theme/index.php na linha 37

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

Erro fatal: Tempo máximo de execução de 30 segundos excedido em /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 = Ligado
relatório_de_erros = E_ALL
log_errors = On
error_log = /caminho/para/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('Esta é uma mensagem de erro personalizada');

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:

Valor PHP 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:

relatório_de_erros = E_ALL & ~E_NOTICE

relatório_de_erros = E_ALL & ~E_NOTICE | E_STRICT

error_reporting = E_COMPILE_ERROR|E_RECOVERABLE_ERROR|E_ER... _ERROR

relatório_de_erros = 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 ; Oculta a apresentação de erros no front end
log_errors = On ; Ativa o registo de erros
error_log = /path/to/php-error.log ; Especifica a localização do ficheiro de registo de erros
error_reporting = E_ALL ; Regista todos os tipos de erros

• 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:

# Para ver as últimas 50 linhas do log de erros do PHP, executa a seguinte linha de código

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("Mensagem de erro personalizada: Algo correu mal!", 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
// Gera um aviso ao nível do utilizador
trigger_error("Este é um aviso personalizado", E_USER_WARNING);

// Gera um erro ao nível do utilizador (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
// Abre uma ligação ao registador do sistema
openlog("php_script", LOG_PID | LOG_PERROR, LOG_LOCAL0);

// Regista uma mensagem informativa no registo do sistema
syslog(LOG_INFO, "Esta é uma mensagem informativa");

// Regista uma mensagem de erro no registo do sistema
syslog(LOG_ERR, "Esta é uma mensagem de erro");

// Fecha a ligação ao registador do sistema
fecha o registo();
?>

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.

o compositor exige monólogo/monólogo

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
utiliza Monolog\Logger;
utiliza Monolog\Handler\StreamHandler;
utiliza Monolog\Formatter\JsonFormatter;

// Cria o registador
$logger = new Logger('custom_logger');

// Cria um StreamHandler para escrever os logs em um arquivo
$handler = new StreamHandler(__DIR__ . '/logs/app.log', Logger::ERROR);

// Define o formatador do manipulador para JSON
$handler->setFormatter(new JsonFormatter());

// Empurra o manipulador para o registador
$logger->pushHandler($handler);

// Regista um erro com uma mensagem e um contexto personalizados
$logger->error('Ocorreu um erro inesperado', [
  'user_id' =>  1234,
  'ação' =>  'update_profile',
  'carimbo de data/hora' =>  data('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.

// Suprime erros não críticos
error_reporting(E_ERROR | E_PARSE); // Regista apenas os erros críticos

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 = /caminho/para/erro.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

função divide($dividendo, $divisor) {
  se ($divisor == 0) {
  lança uma nova Exceção ("Não é possível dividir por zero.");
  }
  devolve $dividendo / $divisor;
}

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

Erro: Não podes dividir por 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
função inverse($x) {
  se (!$x) {
  lança uma nova Exceção('Divisão por zero.');
  }
  devolve 1/$x;
}

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

// Continua a execução
ecoa "Olá Mundo\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
função inverse($x) {
  se (!$x) {
  lança uma nova Exceção('Divisão por zero.');
  }
  devolve 1/$x;
}

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

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

// Continua a execução
ecoa "Olá Mundo\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 ou index.php

// Define a função de registo de erros
function logError($severity, $message, $file, $line) {
  $logMessage = json_encode([
  'severidade' =>  $severidade,
  'mensagem' =>  $mensagem,
  'ficheiro' =>  $file,
  'linha' =>  $linha,
  'carimbo de data/hora' =>  data('Y-m-d H:i:s')
  ]);

  // Regista num ficheiro específico
  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.

// Define um gestor de erros personalizado para converter erros em excepções
set_error_handler(function ($severity, $message, $file, $line) {
  // Regista apenas níveis de erro específicos, se necessário
  se (!(error_reporting() & $severity)) {
  regressa;
  }
  lança uma nova ErrorException($message, 0, $severity, $file, $line);
});

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

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

• Usa register_shutdown_function() para erros fatais.

register_shutdown_function(function () {
  $error = error_get_last();
  se ($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.