PHP 7+ Logging class Magic Constants

Question

I just wrote a little "logging" class and want to ask a question about the usage of this class, how i could make it easier to use.

For example:

$log = new Log();
$log->Error("You have an error!", __FILE__, __CLASS__, __FUNCTION__, __LINE__);

This is how i write errors to a log file at the moment, but it seems to complex?! Is there a way to get the "MAGIC CONSTANTS" inside the logging class from the "calling" php ?

Here is the class code (any other tips are welcome too):

    <?php
    class Log
    {   
        private $path;

        public function __construct()
        {
            $config = new Config();         // init. from autoloader
            $path = $config->app_log_dir;

            if (!is_dir($path) && !is_writable($path))
            {
                error_log('[ERROR] [Log::__Construct()] -> ' . $path . ' does not exist or is not writeable!',0);
                header("HTTP/1.0 500 Internal Server Error");
                exit();
            }

            $this->path = $path;
        }

        public function Error($message, $file, $class = '', $function = '', $line)
        {
            $array_data = array($message, $file, $class, $function, $line);
            $this->write('ERROR', $array_data);
        }

        public function TestError($message, $file = __FILE__, $class = __CLASS__, $function = __FUNCTION__, $line = __LINE__)
        {
            $array_data = array($message, $file, $class, $function, $line);
            $this->write('TESTERROR', $array_data);
        }

        private function write($error_type, $array_data)
        {
            $date = date("Y-m-d H:i:s");
            $dateFile = date("Y-m-d");      

            $message = "[{$date}] [{$error_type}] [{$array_data[1]}->{$array_data[2]}::{$array_data[3]}:{$array_data[4]}] $array_data[0]".PHP_EOL;

            try 
            {
                file_put_contents($this->path.'/'.$dateFile.'.log', $message, FILE_APPEND);
            }
            catch (Exception $e)
            {
                error_log('[ERROR] [Log::write()] -> ' . $e, 0);
                header("HTTP/1.0 500 Internal Server Error");
                exit();
            }
        }
    }

score 1 · Answer 1 · answered Mar 01 '19 at 19:35

1

Pass those constants as function parameters instead:

public function Error(
    $message,
    $file = __FILE__,
    $class = __CLASS__,
    $function = __FUNCTION__,
    $line = __LINE__,
) {
    // ...
}

and call as always:

$log->Error('xxx');

If I may, your code smells, why not use PSR-3 compatible logger like Monolog? Or even handle errors like a pro with Whoops.

answered Mar 01 '19 at 19:35

Mike Doe

16,349
11
65
88

1

It may be useful to explain to the OP what you mean by "code smells", and/or link to the PSR-3 standard. – Martin Mar 01 '19 at 19:57
And OP would end up with the details of the `->Error()` method, not where the error really occurred. – Mike Doe Mar 01 '19 at 20:02
Thanks for the answers. I added a TestError function to above code. I tried it before and because of that i asked here :) If i use the TestError function from "index.php" my error log shows -> [2019-03-01 20:52:32] [TESTERROR] [/var/www/example.home/inc/log.class.php->Log::TestError:27] This Error was called from index.php for Stackoverflow It doesn't show the "index.php" as __FILE__.... – Thomas Mar 01 '19 at 20:23

Martin · Accepted Answer · 2019-03-01T20:30:21.610

Check out debug_backtrace().

So you can do :

public function Error($message, $debug)
{
    $array_data = array($message, $debug);
    $this->write('ERROR', $array_data);
}

$log->Error("Oh noo!!", print_r(debug_backtrace(),true) );

A backtrace contains a potentially huge amount of data so I'm not going to example a full one here, but it can contain:

function ; The current function name. See also __FUNCTION__.

line ; The current line number. See also __LINE__.

file ; The current file name. See also __FILE__.

class ; The current class name. See also __CLASS__.

object ; The current object.

type ; The current call type. If a method call, "->" is returned. If a static method call, "::" is returned. If a function call, nothing is returned.

args ; If inside a function, this lists the functions arguments. If inside an included file, this lists the included file name(s).

debug_backtrace() is a goldmine of information to debug PHP. This covers everything you ask for in your question.

Thanks, debug_backtrace will do it for now. It's just a little project and for learning. — Thomas, Mar 01 '19 at 20:58

PHP 7+ Logging class Magic Constants

2 Answers2