I would like to implement logging mechanism to file in PHP:
- log file path will be in config file config.php
- in several classes I would like to log some events into the log file
For example:
Class A {
public function f_A {
log_to_file($message);
}
}
Class B {
public function f_B {
log_to_file($message);
}
}
I will be very grateful for any tips. I would like to implement some easy and elegant solution.
I was thinking about it (thank you for your answers) and I think I will do it this way (maybe, there are some errors, I was writing it from scratch):
interface Logger {
public function log_message($message);
}
class LoggerFile implements Logger {
private $log_file;
public function __construct($log_file) {
$this->log_file = $log_file;
}
public function log_message($message) {
if (is_string($message)) {
file_put_contents($this->log_file, date("Y-m-d H:i:s")." ".$message."n", FILE_APPEND);
}
}
}
//maybe in the future logging into database
class LoggerDb implements Logger {
private $db;
public function __construct($db) {
//some code
}
public function log_message($message) {
//some code
}
}
Class A {
private $logger;
public function __construct(Logger $l) {
$this->logger = $l;
}
public function f_A {
$this->logger->log_message($message);
}
}
Class B {
private $logger;
public function __construct(Logger $l) {
$this->logger = $l;
}
public function f_B {
$this->logger->log_message($message);
}
}
//usage:
//in config.php:
define("CONFIG_LOG_FILE", "log/app_log.log");
//in the index.php or some other files
$logger = new LoggerFile(CONFIG_LOG_FILE);
$instance_a = new A($logger);
$instance_b = new B($logger);
Where are loggers used?
In general there are two major use-cases for use of loggers within your code:
invasive logging:
For the most part people use this approach because it is the easiest to understand.
In reality you should only use invasive logging if logging is part of the domain logic itself. For example - in classes that deal with payments or management of sensitive information.
Non-invasive logging:
With this method instead of altering the class that you wish to log, you wrap an existing instance in a container that lets you track every exchange between instance and rest of application.
You also gain the ability to enable such logging temporarily, while debugging some specific problem outside of the development environment or when you are conducting some research of user behaviour. Since the class of the logged instance is never altered, the risk of disrupting the project's behaviour is a lot lower when compared to invasive logging.
Implementing an invasive logger
To do this you have two main approaches available. You can either inject an instance that implements the
Loggerinterface, or provide the class with a factory that in turn will initialize the logging system only when necessary.Now .. the implementation with factory and lazy loading.
You start by defining the API that you will use (in perfect world you start with unit-tests).
This factory will have two additional benefits:
Next step would be implementation of the factory:
When you call
$factory->provide('thing');, the factory looks up if the instance has already been created. If the search fails it creates a new instance.And the last step is actually wiring it all up with providers:
Of course to fully understand this approach you will have to know how closures work in PHP, but you will have to learn them anyway.
Implementing non-invasive logging
The core idea of this approach is that instead of injecting the logger, you put an existing instance in a container which acts as membrane between said instance and application. This membrane can then perform different tasks, one of those is logging.
This class can also be used together with the above described lazy factory.
To use this structure, you simply do the following:
At this point the container which wraps the instance becomes a fully functional replacement of the original. The rest of your application can handle it as if it is a simple object (pass around, call methods upon). And the wrapped instance itself is not aware that it is being logged.
And if at some point you decide to remove the logging then it can be done without rewriting the rest of your application.