Steps to Enable PHP Error Logging & Automation

If you are a skilled developer, you may constantly be aware of potential mistakes that could arise when creating a web application. It is possible that you have set up methods to facilitate accurate error logging. PHP offers some of the most reliable methods for managing error logs, which can be automatically generated after being manually logged. Additionally, there are a few third-party solutions for managing PHP error logging that have been created by the open source community.
What you should consider is the appropriate time and method for logging errors. You can log PHP errors as you see fit when working in the dev mode. You have two options: save them as notifications on various channels or generate a PHP error log file. Errors can always be easily logged according with your needs.

For now, when you are working in a production mode, you should create a smooth workflow to log errors in the backend, so that the users don’t face any glitch during runtime execution.
In this article, you will get some handy PHP error logging tips which can be helpful for potential developers.

Getting Started with PHP Error Logging
PHP is the most popular and widely used programming language for developing web applications. As per the builtwith insights, today almost 37,805,937 websites use PHP as their backend language, which makes it around 75% of all the websites in the world. These stats clearly display that PHP still has a highest market share in the programming world.
While developing an application in PHP, you use few commands like print_r(),var_dump() to debug errors and log on browser. But while working in the production mode, that is not the safest way. In dev mode, you can do it, but you need to disable it when initiating the migration. Therefore, it is easy to log errors in PHP with error_log() function in dev mode, which sends an error message to the defined error handling routines.
Let’s imagine that you are connecting MySQL database with PHP and if it fails to connect with it, you can log errors in PHP as below:

<?php
// Send error message to the server log if error connecting to the database
if (!mysqli_connect(“localhost”,”bad_user”,”bad_password”,”my_db”)) {
error_log(“Failed to connect to database!”, 0);
}
// Send email to administrator if we run out of FOO
if (!($foo = allocate_new_foo())) {
error_log(“Oh no! We are out of FOOs!”, 1, “admin@example.com”);
}
?>

Enabling Error Logging in php.ini

In order to log errors in PHP, open the php.ini file and uncomment/add the below lines of code:
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

For enabling the error logging in individual files, add this code at the top of the PHP file.
ini_set(‘display_errors’, 1);
ini_set(‘display_startup_errors’, 1);
error_reporting(E_ALL);

Now, you should enable only one statement to parse the log errors in php.ini file:
display_errors = on.

With this you can easily see logged errors in your browser. Some of the additional commands you can write for PHP error logging include:
// Turn off all error reporting
error_reporting(0);
// Report simple running errors
error_reporting(E_ERROR | E_WARNING | E_PARSE);
// Reporting E_NOTICE can be good too (to report uninitialized variables or catch variable name misspellings …)
error_reporting(E_ERROR | E_WARNING | E_PARSE | E_NOTICE);

// Report all errors except E_NOTICE
error_reporting(E_ALL & ~E_NOTICE);

// Report all PHP errors (see changelog)
error_reporting(E_ALL);

// Report all PHP errors
error_reporting(-1);

// Same as error_reporting(E_ALL);
ini_set(‘error_reporting’, E_ALL);

Copying PHP Error Logs to File
The above mentioned practices work well when you work in the dev environment. But, while taking your website live and starting your work in the production mode, it is essential to hide the errors from on screen display and log them within a backend file. These can be saved at a specific PHP error logs location whose URL is already described in the php.ini file.

Pick A Laravel Hosting Plans With Our Highly Optimized Servers.!
PHP stores error logs in /var/log/apache2, if it uses an apache2 module. Shared hosts have a tendency to store PHP error log files in your root directory /log subfolder. But, if you have access to the php.ini file you can do this as below:

error_log = /var/log/php-scripts.log
In case you are using cPanel, the master log file, the thing you’re looking for is stored (by default) at:/usr/local/apache/logs/error_log
If everything fails, you can check the PHP error logs location with the below code:

Error Logging in PHP Frameworks

The above steps are for core PHP development. PHP has several Model View Architecture (MVC) and micro-frameworks which have their own methods on top of the core functions. Some of the best PHP MVC frameworks to build advanced web applications with comprise of: Laravel, CodeIgniter and Symfony.

Error Logging In Laravel

Error logging and exception handling are pre-configured in a newly created Laravel project. All of these problems are handled by a different class in Laravel called App\Exceptions\Handler. It makes use of the Monolog library, which offers an array of log handlers, to log Laravel issues. Laravel configures a number of these handlers for you, giving you the option to rotate log files, write error information to the system log, or use a single PHP error log file.

You can configure the PHP debug option in config/app.php file to log the errors on the display of user. This option’s value can be set in .env file under property APP_DEBUG which is an environment variable, thus setting up in app.php file. When the development is done locally, the value can be set to true, and after migrating to production, it should be set as false. Otherwise, the security concern always remains there, as it shows error on browser screen.

Being the developer, you can save Laravel log information on a single file, daily file, syslog and the errorlog. For configuring these options for Laravel error logging, open app.php file and edit the log option. For example, if you want to setup daily logging for errors, follow the below code:

‘log’ => ‘daily’

Monolog is enable to log errors with different security warnings. It adds all the errors in storage by default, but you can identify them as error, alert, emergency, critical and warning. For this, add ‘log_level’ property in options as below:
‘log_level’ => env(‘APP_LOG_LEVEL’, ‘error’),
You will get the log file in storage/logs. Log facades can also be used to log errors.

<?php
namespace App\Http\Controllers;
use App\User;
use Illuminate\Support\Facades\Log;
use App\Http\Controllers\Controller;
class UserController extends Controller
{

/**
* Show the profile for the given user.
*
* @param int $id
* @return Response
*/
public function showProfile($id)
{
Log::info(‘Showing user profile for user: ‘.$id);
return view(‘user.profile’, [‘user’ => User::findOrFail($id)]);
}
}
The logger provides eight different logging levels, including:
Log::emergency($message);
Log::alert($message);
Log::critical($message);
Log::error($message);
Log::warning($message);
Log::notice($message);
Log::info($message);
Log::debug($message);
Error Logging In Symfony

Symfony comprises of a default logger that can be injected into controller showing different warning levels. Log entries are written in the var/log/dev.log file by default when you’re in the dev environment. Logs are written in the var/log/prod.log in the production environment.

use Psr\Log\LoggerInterface;
public function index(LoggerInterface $logger)
{

$logger->info(‘I just got the logger’);
$logger->error(‘An error occurred’);
$logger->critical(‘I left the oven on!’, [
// include extra “context” info in your logs
’cause’ => ‘in_hurry’,
]);
// …
}

Symfony being the parent framework for Laravel, the warning levels of the framework will be the same.

monolog:
handlers:
main:
type: fingers_crossed
action_level: error
handler: nested
nested:
type: stream
path: “%kernel.logs_dir%/%kernel.environment%.log”
level: debug
console:
type: console
slack:
type: slack
token: xxxx-xxxxxxxxxxx-xxxxxxxxx-xxxxxxxxxx-xxxxxx
channel: “#name-of-channel”
bot_name: ChooseName
icon_emoji: :ghost:
level: critical

Monolog is used by Symfony for error logging and Symfony pre-configures some basic handlers in the default monolog.yaml. Check the below example that uses syslogs to write logs on the file:

// config/packages/prod/monolog.php
$container->loadFromExtension(‘monolog’, [
‘handlers’ => [
‘file_log’ => [
‘type’ => ‘stream’,
‘path’ => ‘%kernel.logs_dir%/%kernel.environment%.log’,
‘level’ => ‘debug’,
],
‘syslog_handler’ => [
‘type’ => ‘syslog’,
‘level’ => ‘error’,
],
],
]);

Automating PHP Error Logging Process:-

The complete work of error logging can be done manually, but while working in multiple teams and larger projects, you must setup an automated workflow which can log errors in third party services like Slack, Sentry, Blackfire etc.

With these tools you can get a better understanding of errors and their solutions. It is possible to setup Slack channels to send quick notifications to the teams about any runtime incidents.

Suppose that you have already setup Slack channel and webhooks as below:

monolog:
handlers:
main:
type: fingers_crossed
action_level: error
handler: nested
nested:
type: stream
path: “%kernel.logs_dir%/%kernel.environment%.log”
level: debug
console:
type: console
slack:
type: slack
token: xxxx-xxxxxxxxxxx-xxxxxxxxx-xxxxxxxxxx-xxxxxx
channel: “#name-of-channel”
bot_name: ChooseName
icon_emoji: :ghost:
level: critical

In the above example, you will also find the emojis setup? This indicates the ways you can send Slack notifications to any particular channel as per your needs.\

Bottom Line
This article explains how to configure the php.ini file to log problems in PHP. Understanding how to properly log problems in both development and production environments is a major task for website developers, as error management is one of their most important responsibilities. Without upsetting the developers, this post explains how to enable and automate PHP error logging.

Read more: How To Debug Node.js Applications?