CakePHP frameworks provide different types of functionality to the developer and are open-source tools. For example, logging is very important from the development perspective; using a log can easily find the problem in terms of errors, exceptions, different user activities, user actions during the operation, and any background activities. Normally implementation of logging is a very easy and time-saving activity. In CakePHP, we have a log() function to log the different activities, errors, and exceptions. For Log implementation, we need to configure the different parameters per our requirements.

Start Your Free Software Development Course

Web development, programming languages, Software testing & others

How to Create CakePHP log?

Now let’s see how we can create log-in CakePHP as follows.

Logging information in CakePHP is simple – the log() work is given by the LogTrait, which is the normal predecessor for some CakePHP classes. On the off chance that the setting is a CakePHP class (Controller, Component, and View), you can log your information. You can likewise utilize Log::write() straightforwardly. See Writing to Logs.

Log stream overseers can be essential for your application or part of modules. On the off chance that, for instance, you had an information base lumberjack called DatabaseLog as a component of your application; it would be set in

application/Lib/Log/Engine/DatabaseLog.php.

Assuming you had an information base lumberjack as a module component, it would be put in application/Plugin/LoggingPack/Lib/Log/Engine/DatabaseLog.php. When arranged, CakeLog will endeavor to stack Configuring log streams, which is finished by calling CakeLog::config(). Arranging our DatabaseLog would resemble:

App::uses('BaseLog', 'Log/Engine');
class DatabaseLog extends BaseLog {
public function __construct($options = array()) {
parent::__construct($options);
// ...
}
public function write($specified type, $required message) {
// write to the database.
}
}

While CakePHP has no prerequisites for Log streams other than that they should execute a compose technique, broadening the BaseLog class has a couple of advantages:

It consequently handles the degree and type contention projecting. Finally, it executes the config() technique expected to make perused logging work.

Every logger’s compose technique should accept two boundaries: $type and $message (in a specific order). $type is the string sort of the logged message; basic beliefs are blunder, cautioning, information, and troubleshooting. Moreover, you can characterize your kinds by utilizing them when you call CakeLog::write.

How to Configure Log in CakePHP?

Now let’s see how we can configure log-in CakePHP as follows.

First, we need to configure the app.php file; we can configure the log section with different options.

'Log' => [
'debug'=>[
'className'=> 'Cake\Log\Engine\FileLog',
'path' => LOGS,
'file'=> 'debug',
'levels' => ['specified notice', 'required info', 'debug'],
'url' => env('Specified URL', null),
],
'error' => [
'className'=> 'Cake\Log\Engine\FileLog',
'path' => LOGS,
'file'=> 'error',
'levels' => ['specified warning', 'error', 'critical', 'alert'],
'url' => env('Specified URL', null),
],
},

Explanation

In the above code, we can see by default; we have two log levels: an error and debug that we already configured, and it handles the different levels of the message. So basically, CakePHP supports the different levels of logging as follows.

• Emergency: It is used to show the system is unusable.
• Alert: It shows what action we need to take immediately.
• Critical: It is used for critical conditions.
• Error: It is used to show error conditions.
• Warning: It is used to show warning conditions.
• Notice: It is used to show the significant condition of execution.
• Info: It is used to show informational messages as per requirement.
• Debug: It is used to show debug level of all messages.

CakePHP Log file

Now let’s see what the log file in CakePHP is as follows.

We can write in a Log record in two different ways.

The first is to utilize the static write() technique. Next is the linguistic structure of the static write() technique.

Syntax:

write(integer|string $level, blended $message, string|array $context [])

Parameters:

The seriousness level of the message being composed. The worth should be a whole number or string matching a known level.

Message content to log.

Extra information to be utilized for logging the message. The unique extension key can be passed to be utilized for additional separating of the log motors. If a string or a mathematical record exhibit is passed, it will be treated as the degree key. See CakeLogLog::config() for more data on logging degrees.

It Returns:?boolean

Description:?Composes the given message and type to all of the designed log connectors. Arranged connectors are passed both the $level and $message factors. $level is one of the accompanying strings/values. The second is to utilize the log() easy route work accessible on any utilizing the LogTrait Calling log() will inside call Log::write().

CakePHP Log Example

Now let’s see an example of a log file as follows.

First, we need to make the changes in the routes.php file as follows.

<?php
use Cake\Http\Middleware\CsrfProtectionMiddleware;
use Cake\Routing\Route\DashedRoute;
use Cake\Routing\RouteBuilder;
$routes->setRouteClass(DashedRoute::class);
$routes->scope('/', function (RouteBuilder $builder) {
$builder->registerMiddleware('csrf', new CsrfProtectionMiddleware([
'httpOnly' => true,
]));
$builder->applyMiddleware('csrf');
//$builder->connect('/pages',
['controller'=>'Pages','action'=>'display message', 'home page']);
$builder->connect('logex',['controller'=>'Logexs','action'=>'index']);
$builder->fallbacks();
});

Now we need to create controller.php and write the following code as follows.

<?php
namespace App\Controller;
use App\Controller\AppController;
use Cake\Log\Log;
class LogexsController extends AppController{
public function index(){
/*First way to write log file.*/
Log::write('debug', "Something went wrong during execution.");
/* Second way to write log file.*/
$this->log("Something went wrong during execution.", 'debug');
}
}
?>

Create an index.php file under the view directory and write the following code.

Something went wrong during execution. Need to check log file\debug.log

Now we need to execute this file in localhost, and after execution, we will do some output that we illustrated by using the following screenshot.

After execution debug log was added to the debug.log file, as shown in the following screenshot.

Conclusion

We hope from this article you learn more about the CakePHP log. From the above article, we have taken in the essential idea of the CakePHP log and see the representation and example of the CakePHP log. Furthermore, this article taught us how and when to use the CakePHP log.

The above is the detailed content of CakePHP Log. For more information, please follow other related articles on the PHP Chinese website!