Initial

system/Log/Exceptions/LogException.php

@@ -0,0 +1,27 @@
+<?php
+
+/**
+ * This file is part of CodeIgniter 4 framework.
+ *
+ * (c) CodeIgniter Foundation <admin@codeigniter.com>
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+namespace CodeIgniter\Log\Exceptions;
+
+use CodeIgniter\Exceptions\FrameworkException;
+
+class LogException extends FrameworkException
+{
+    public static function forInvalidLogLevel(string $level)
+    {
+        return new static(lang('Log.invalidLogLevel', [$level]));
+    }
+
+    public static function forInvalidMessageType(string $messageType)
+    {
+        return new static(lang('Log.invalidMessageType', [$messageType]));
+    }
+}

system/Log/Handlers/BaseHandler.php

@@ -0,0 +1,70 @@
+<?php
+
+/**
+ * This file is part of CodeIgniter 4 framework.
+ *
+ * (c) CodeIgniter Foundation <admin@codeigniter.com>
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+namespace CodeIgniter\Log\Handlers;
+
+/**
+ * Base class for logging
+ */
+abstract class BaseHandler implements HandlerInterface
+{
+    /**
+     * Handles
+     *
+     * @var array
+     */
+    protected $handles;
+
+    /**
+     * Date format for logging
+     *
+     * @var string
+     */
+    protected $dateFormat = 'Y-m-d H:i:s';
+
+    /**
+     * Constructor
+     */
+    public function __construct(array $config)
+    {
+        $this->handles = $config['handles'] ?? [];
+    }
+
+    /**
+     * Checks whether the Handler will handle logging items of this
+     * log Level.
+     */
+    public function canHandle(string $level): bool
+    {
+        return in_array($level, $this->handles, true);
+    }
+
+    /**
+     * Handles logging the message.
+     * If the handler returns false, then execution of handlers
+     * will stop. Any handlers that have not run, yet, will not
+     * be run.
+     *
+     * @param string $level
+     * @param string $message
+     */
+    abstract public function handle($level, $message): bool;
+
+    /**
+     * Stores the date format to use while logging messages.
+     */
+    public function setDateFormat(string $format): HandlerInterface
+    {
+        $this->dateFormat = $format;
+
+        return $this;
+    }
+}

system/Log/Handlers/ChromeLoggerHandler.php

@@ -0,0 +1,164 @@
+<?php
+
+/**
+ * This file is part of CodeIgniter 4 framework.
+ *
+ * (c) CodeIgniter Foundation <admin@codeigniter.com>
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+namespace CodeIgniter\Log\Handlers;
+
+use CodeIgniter\HTTP\ResponseInterface;
+use Config\Services;
+
+/**
+ * Class ChromeLoggerHandler
+ *
+ * Allows for logging items to the Chrome console for debugging.
+ * Requires the ChromeLogger extension installed in your browser.
+ *
+ * @see https://craig.is/writing/chrome-logger
+ */
+class ChromeLoggerHandler extends BaseHandler
+{
+    /**
+     * Version of this library - for ChromeLogger use.
+     */
+    public const VERSION = 1.0;
+
+    /**
+     * The number of track frames returned from the backtrace.
+     *
+     * @var int
+     */
+    protected $backtraceLevel = 0;
+
+    /**
+     * The final data that is sent to the browser.
+     *
+     * @var array
+     */
+    protected $json = [
+        'version' => self::VERSION,
+        'columns' => [
+            'log',
+            'backtrace',
+            'type',
+        ],
+        'rows' => [],
+    ];
+
+    /**
+     * The header used to pass the data.
+     *
+     * @var string
+     */
+    protected $header = 'X-ChromeLogger-Data';
+
+    /**
+     * Maps the log levels to the ChromeLogger types.
+     *
+     * @var array
+     */
+    protected $levels = [
+        'emergency' => 'error',
+        'alert'     => 'error',
+        'critical'  => 'error',
+        'error'     => 'error',
+        'warning'   => 'warn',
+        'notice'    => 'warn',
+        'info'      => 'info',
+        'debug'     => 'info',
+    ];
+
+    /**
+     * Constructor
+     */
+    public function __construct(array $config = [])
+    {
+        parent::__construct($config);
+
+        $this->json['request_uri'] = current_url();
+    }
+
+    /**
+     * Handles logging the message.
+     * If the handler returns false, then execution of handlers
+     * will stop. Any handlers that have not run, yet, will not
+     * be run.
+     *
+     * @param string $level
+     * @param string $message
+     */
+    public function handle($level, $message): bool
+    {
+        // Format our message
+        $message = $this->format($message);
+
+        // Generate Backtrace info
+        $backtrace = debug_backtrace(0, $this->backtraceLevel);
+        $backtrace = end($backtrace);
+
+        $backtraceMessage = 'unknown';
+        if (isset($backtrace['file'], $backtrace['line'])) {
+            $backtraceMessage = $backtrace['file'] . ':' . $backtrace['line'];
+        }
+
+        // Default to 'log' type.
+        $type = '';
+
+        if (array_key_exists($level, $this->levels)) {
+            $type = $this->levels[$level];
+        }
+
+        $this->json['rows'][] = [
+            [$message],
+            $backtraceMessage,
+            $type,
+        ];
+
+        $this->sendLogs();
+
+        return true;
+    }
+
+    /**
+     * Converts the object to display nicely in the Chrome Logger UI.
+     *
+     * @param mixed $object
+     *
+     * @return array
+     */
+    protected function format($object)
+    {
+        if (! is_object($object)) {
+            return $object;
+        }
+
+        // @todo Modify formatting of objects once we can view them in browser.
+        $objectArray = (array) $object;
+
+        $objectArray['___class_name'] = get_class($object);
+
+        return $objectArray;
+    }
+
+    /**
+     * Attaches the header and the content to the passed in request object.
+     *
+     * @param ResponseInterface $response
+     */
+    public function sendLogs(?ResponseInterface &$response = null)
+    {
+        if ($response === null) {
+            $response = Services::response(null, true);
+        }
+
+        $data = base64_encode(utf8_encode(json_encode($this->json)));
+
+        $response->setHeader($this->header, $data);
+    }
+}

system/Log/Handlers/ErrorlogHandler.php

@@ -0,0 +1,84 @@
+<?php
+
+/**
+ * This file is part of CodeIgniter 4 framework.
+ *
+ * (c) CodeIgniter Foundation <admin@codeigniter.com>
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+namespace CodeIgniter\Log\Handlers;
+
+use CodeIgniter\Log\Exceptions\LogException;
+
+/**
+ * Log handler that writes to PHP's `error_log()`
+ */
+class ErrorlogHandler extends BaseHandler
+{
+    /**
+     * Message is sent to PHP's system logger, using the Operating System's
+     * system logging mechanism or a file, depending on what the error_log
+     * configuration directive is set to.
+     */
+    public const TYPE_OS = 0;
+
+    /**
+     * Message is sent directly to the SAPI logging handler.
+     */
+    public const TYPE_SAPI = 4;
+
+    /**
+     * Says where the error should go. Currently supported are
+     * 0 (`TYPE_OS`) and 4 (`TYPE_SAPI`).
+     *
+     * @var int
+     */
+    protected $messageType = 0;
+
+    /**
+     * Constructor.
+     *
+     * @param mixed[] $config
+     */
+    public function __construct(array $config = [])
+    {
+        parent::__construct($config);
+
+        $messageType = $config['messageType'] ?? self::TYPE_OS;
+
+        if (! is_int($messageType) || ! in_array($messageType, [self::TYPE_OS, self::TYPE_SAPI], true)) {
+            throw LogException::forInvalidMessageType(print_r($messageType, true));
+        }
+
+        $this->messageType = $messageType;
+    }
+
+    /**
+     * Handles logging the message.
+     * If the handler returns false, then execution of handlers
+     * will stop. Any handlers that have not run, yet, will not
+     * be run.
+     *
+     * @param string $level
+     * @param string $message
+     */
+    public function handle($level, $message): bool
+    {
+        $message = strtoupper($level) . ' --> ' . $message . "\n";
+
+        return $this->errorLog($message, $this->messageType);
+    }
+
+    /**
+     * Extracted call to `error_log()` in order to be tested.
+     *
+     * @codeCoverageIgnore
+     */
+    protected function errorLog(string $message, int $messageType): bool
+    {
+        return error_log($message, $messageType);
+    }
+}

system/Log/Handlers/FileHandler.php

@@ -0,0 +1,122 @@
+<?php
+
+/**
+ * This file is part of CodeIgniter 4 framework.
+ *
+ * (c) CodeIgniter Foundation <admin@codeigniter.com>
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+namespace CodeIgniter\Log\Handlers;
+
+use DateTime;
+use Exception;
+
+/**
+ * Log error messages to file system
+ */
+class FileHandler extends BaseHandler
+{
+    /**
+     * Folder to hold logs
+     *
+     * @var string
+     */
+    protected $path;
+
+    /**
+     * Extension to use for log files
+     *
+     * @var string
+     */
+    protected $fileExtension;
+
+    /**
+     * Permissions for new log files
+     *
+     * @var int
+     */
+    protected $filePermissions;
+
+    /**
+     * Constructor
+     */
+    public function __construct(array $config = [])
+    {
+        parent::__construct($config);
+
+        $this->path = empty($config['path']) ? WRITEPATH . 'logs/' : $config['path'];
+
+        $this->fileExtension = empty($config['fileExtension']) ? 'log' : $config['fileExtension'];
+        $this->fileExtension = ltrim($this->fileExtension, '.');
+
+        $this->filePermissions = $config['filePermissions'] ?? 0644;
+    }
+
+    /**
+     * Handles logging the message.
+     * If the handler returns false, then execution of handlers
+     * will stop. Any handlers that have not run, yet, will not
+     * be run.
+     *
+     * @param string $level
+     * @param string $message
+     *
+     * @throws Exception
+     */
+    public function handle($level, $message): bool
+    {
+        $filepath = $this->path . 'log-' . date('Y-m-d') . '.' . $this->fileExtension;
+
+        $msg = '';
+
+        if (! is_file($filepath)) {
+            $newfile = true;
+
+            // Only add protection to php files
+            if ($this->fileExtension === 'php') {
+                $msg .= "<?php defined('SYSTEMPATH') || exit('No direct script access allowed'); ?>\n\n";
+            }
+        }
+
+        if (! $fp = @fopen($filepath, 'ab')) {
+            return false;
+        }
+
+        // Instantiating DateTime with microseconds appended to initial date is needed for proper support of this format
+        if (strpos($this->dateFormat, 'u') !== false) {
+            $microtimeFull  = microtime(true);
+            $microtimeShort = sprintf('%06d', ($microtimeFull - floor($microtimeFull)) * 1000000);
+            $date           = new DateTime(date('Y-m-d H:i:s.' . $microtimeShort, (int) $microtimeFull));
+            $date           = $date->format($this->dateFormat);
+        } else {
+            $date = date($this->dateFormat);
+        }
+
+        $msg .= strtoupper($level) . ' - ' . $date . ' --> ' . $message . "\n";
+
+        flock($fp, LOCK_EX);
+
+        $result = null;
+
+        for ($written = 0, $length = strlen($msg); $written < $length; $written += $result) {
+            if (($result = fwrite($fp, substr($msg, $written))) === false) {
+                // if we get this far, we'll never see this during travis-ci
+                // @codeCoverageIgnoreStart
+                break;
+                // @codeCoverageIgnoreEnd
+            }
+        }
+
+        flock($fp, LOCK_UN);
+        fclose($fp);
+
+        if (isset($newfile) && $newfile === true) {
+            chmod($filepath, $this->filePermissions);
+        }
+
+        return is_int($result);
+    }
+}

system/Log/Handlers/HandlerInterface.php

@@ -0,0 +1,42 @@
+<?php
+
+/**
+ * This file is part of CodeIgniter 4 framework.
+ *
+ * (c) CodeIgniter Foundation <admin@codeigniter.com>
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+namespace CodeIgniter\Log\Handlers;
+
+/**
+ * Expected behavior for a Log handler
+ */
+interface HandlerInterface
+{
+    /**
+     * Handles logging the message.
+     * If the handler returns false, then execution of handlers
+     * will stop. Any handlers that have not run, yet, will not
+     * be run.
+     *
+     * @param string $level
+     * @param string $message
+     */
+    public function handle($level, $message): bool;
+
+    /**
+     * Checks whether the Handler will handle logging items of this
+     * log Level.
+     */
+    public function canHandle(string $level): bool;
+
+    /**
+     * Sets the preferred date format to use when logging.
+     *
+     * @return HandlerInterface
+     */
+    public function setDateFormat(string $format);
+}

system/Log/Logger.php

@@ -0,0 +1,432 @@
+<?php
+
+/**
+ * This file is part of CodeIgniter 4 framework.
+ *
+ * (c) CodeIgniter Foundation <admin@codeigniter.com>
+ *
+ * For the full copyright and license information, please view
+ * the LICENSE file that was distributed with this source code.
+ */
+
+namespace CodeIgniter\Log;
+
+use CodeIgniter\Log\Exceptions\LogException;
+use CodeIgniter\Log\Handlers\HandlerInterface;
+use Psr\Log\LoggerInterface;
+use RuntimeException;
+use Throwable;
+
+/**
+ * The CodeIgntier Logger
+ *
+ * The message MUST be a string or object implementing __toString().
+ *
+ * The message MAY contain placeholders in the form: {foo} where foo
+ * will be replaced by the context data in key "foo".
+ *
+ * The context array can contain arbitrary data, the only assumption that
+ * can be made by implementors is that if an Exception instance is given
+ * to produce a stack trace, it MUST be in a key named "exception".
+ */
+class Logger implements LoggerInterface
+{
+    /**
+     * Used by the logThreshold Config setting to define
+     * which errors to show.
+     *
+     * @var array<string, integer>
+     */
+    protected $logLevels = [
+        'emergency' => 1,
+        'alert'     => 2,
+        'critical'  => 3,
+        'error'     => 4,
+        'warning'   => 5,
+        'notice'    => 6,
+        'info'      => 7,
+        'debug'     => 8,
+    ];
+
+    /**
+     * Array of levels to be logged.
+     * The rest will be ignored.
+     * Set in Config/logger.php
+     *
+     * @var array
+     */
+    protected $loggableLevels = [];
+
+    /**
+     * File permissions
+     *
+     * @var int
+     */
+    protected $filePermissions = 0644;
+
+    /**
+     * Format of the timestamp for log files.
+     *
+     * @var string
+     */
+    protected $dateFormat = 'Y-m-d H:i:s';
+
+    /**
+     * Filename Extension
+     *
+     * @var string
+     */
+    protected $fileExt;
+
+    /**
+     * Caches instances of the handlers.
+     *
+     * @var array
+     */
+    protected $handlers = [];
+
+    /**
+     * Holds the configuration for each handler.
+     * The key is the handler's class name. The
+     * value is an associative array of configuration
+     * items.
+     *
+     * @var array
+     */
+    protected $handlerConfig = [];
+
+    /**
+     * Caches logging calls for debugbar.
+     *
+     * @var array
+     */
+    public $logCache;
+
+    /**
+     * Should we cache our logged items?
+     *
+     * @var bool
+     */
+    protected $cacheLogs = false;
+
+    /**
+     * Constructor.
+     *
+     * @param \Config\Logger $config
+     *
+     * @throws RuntimeException
+     */
+    public function __construct($config, bool $debug = CI_DEBUG)
+    {
+        $this->loggableLevels = is_array($config->threshold) ? $config->threshold : range(1, (int) $config->threshold);
+
+        // Now convert loggable levels to strings.
+        // We only use numbers to make the threshold setting convenient for users.
+        if ($this->loggableLevels) {
+            $temp = [];
+
+            foreach ($this->loggableLevels as $level) {
+                $temp[] = array_search((int) $level, $this->logLevels, true);
+            }
+
+            $this->loggableLevels = $temp;
+            unset($temp);
+        }
+
+        $this->dateFormat = $config->dateFormat ?? $this->dateFormat;
+
+        if (! is_array($config->handlers) || empty($config->handlers)) {
+            throw LogException::forNoHandlers('LoggerConfig');
+        }
+
+        // Save the handler configuration for later.
+        // Instances will be created on demand.
+        $this->handlerConfig = $config->handlers;
+
+        $this->cacheLogs = $debug;
+        if ($this->cacheLogs) {
+            $this->logCache = [];
+        }
+    }
+
+    /**
+     * System is unusable.
+     *
+     * @param string $message
+     */
+    public function emergency($message, array $context = []): bool
+    {
+        return $this->log('emergency', $message, $context);
+    }
+
+    /**
+     * Action must be taken immediately.
+     *
+     * Example: Entire website down, database unavailable, etc. This should
+     * trigger the SMS alerts and wake you up.
+     *
+     * @param string $message
+     */
+    public function alert($message, array $context = []): bool
+    {
+        return $this->log('alert', $message, $context);
+    }
+
+    /**
+     * Critical conditions.
+     *
+     * Example: Application component unavailable, unexpected exception.
+     *
+     * @param string $message
+     */
+    public function critical($message, array $context = []): bool
+    {
+        return $this->log('critical', $message, $context);
+    }
+
+    /**
+     * Runtime errors that do not require immediate action but should typically
+     * be logged and monitored.
+     *
+     * @param string $message
+     */
+    public function error($message, array $context = []): bool
+    {
+        return $this->log('error', $message, $context);
+    }
+
+    /**
+     * Exceptional occurrences that are not errors.
+     *
+     * Example: Use of deprecated APIs, poor use of an API, undesirable things
+     * that are not necessarily wrong.
+     *
+     * @param string $message
+     */
+    public function warning($message, array $context = []): bool
+    {
+        return $this->log('warning', $message, $context);
+    }
+
+    /**
+     * Normal but significant events.
+     *
+     * @param string $message
+     */
+    public function notice($message, array $context = []): bool
+    {
+        return $this->log('notice', $message, $context);
+    }
+
+    /**
+     * Interesting events.
+     *
+     * Example: User logs in, SQL logs.
+     *
+     * @param string $message
+     */
+    public function info($message, array $context = []): bool
+    {
+        return $this->log('info', $message, $context);
+    }
+
+    /**
+     * Detailed debug information.
+     *
+     * @param string $message
+     */
+    public function debug($message, array $context = []): bool
+    {
+        return $this->log('debug', $message, $context);
+    }
+
+    /**
+     * Logs with an arbitrary level.
+     *
+     * @param mixed  $level
+     * @param string $message
+     */
+    public function log($level, $message, array $context = []): bool
+    {
+        if (is_numeric($level)) {
+            $level = array_search((int) $level, $this->logLevels, true);
+        }
+
+        // Is the level a valid level?
+        if (! array_key_exists($level, $this->logLevels)) {
+            throw LogException::forInvalidLogLevel($level);
+        }
+
+        // Does the app want to log this right now?
+        if (! in_array($level, $this->loggableLevels, true)) {
+            return false;
+        }
+
+        // Parse our placeholders
+        $message = $this->interpolate($message, $context);
+
+        if (! is_string($message)) {
+            $message = print_r($message, true);
+        }
+
+        if ($this->cacheLogs) {
+            $this->logCache[] = [
+                'level' => $level,
+                'msg'   => $message,
+            ];
+        }
+
+        foreach ($this->handlerConfig as $className => $config) {
+            if (! array_key_exists($className, $this->handlers)) {
+                $this->handlers[$className] = new $className($config);
+            }
+
+            /**
+             * @var HandlerInterface $handler
+             */
+            $handler = $this->handlers[$className];
+
+            if (! $handler->canHandle($level)) {
+                continue;
+            }
+
+            // If the handler returns false, then we
+            // don't execute any other handlers.
+            if (! $handler->setDateFormat($this->dateFormat)->handle($level, $message)) {
+                break;
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * Replaces any placeholders in the message with variables
+     * from the context, as well as a few special items like:
+     *
+     * {session_vars}
+     * {post_vars}
+     * {get_vars}
+     * {env}
+     * {env:foo}
+     * {file}
+     * {line}
+     *
+     * @param mixed $message
+     *
+     * @return mixed
+     */
+    protected function interpolate($message, array $context = [])
+    {
+        if (! is_string($message)) {
+            return $message;
+        }
+
+        // build a replacement array with braces around the context keys
+        $replace = [];
+
+        foreach ($context as $key => $val) {
+            // Verify that the 'exception' key is actually an exception
+            // or error, both of which implement the 'Throwable' interface.
+            if ($key === 'exception' && $val instanceof Throwable) {
+                $val = $val->getMessage() . ' ' . $this->cleanFileNames($val->getFile()) . ':' . $val->getLine();
+            }
+
+            // todo - sanitize input before writing to file?
+            $replace['{' . $key . '}'] = $val;
+        }
+
+        // Add special placeholders
+        $replace['{post_vars}'] = '$_POST: ' . print_r($_POST, true);
+        $replace['{get_vars}']  = '$_GET: ' . print_r($_GET, true);
+        $replace['{env}']       = ENVIRONMENT;
+
+        // Allow us to log the file/line that we are logging from
+        if (strpos($message, '{file}') !== false) {
+            [$file, $line] = $this->determineFile();
+
+            $replace['{file}'] = $file;
+            $replace['{line}'] = $line;
+        }
+
+        // Match up environment variables in {env:foo} tags.
+        if (strpos($message, 'env:') !== false) {
+            preg_match('/env:[^}]+/', $message, $matches);
+
+            if ($matches) {
+                foreach ($matches as $str) {
+                    $key                 = str_replace('env:', '', $str);
+                    $replace["{{$str}}"] = $_ENV[$key] ?? 'n/a';
+                }
+            }
+        }
+
+        if (isset($_SESSION)) {
+            $replace['{session_vars}'] = '$_SESSION: ' . print_r($_SESSION, true);
+        }
+
+        // interpolate replacement values into the message and return
+        return strtr($message, $replace);
+    }
+
+    /**
+     * Determines the file and line that the logging call
+     * was made from by analyzing the backtrace.
+     * Find the earliest stack frame that is part of our logging system.
+     */
+    public function determineFile(): array
+    {
+        $logFunctions = [
+            'log_message',
+            'log',
+            'error',
+            'debug',
+            'info',
+            'warning',
+            'critical',
+            'emergency',
+            'alert',
+            'notice',
+        ];
+
+        // Generate Backtrace info
+        $trace = \debug_backtrace(0);
+
+        // So we search from the bottom (earliest) of the stack frames
+        $stackFrames = \array_reverse($trace);
+
+        // Find the first reference to a Logger class method
+        foreach ($stackFrames as $frame) {
+            if (\in_array($frame['function'], $logFunctions, true)) {
+                $file = isset($frame['file']) ? $this->cleanFileNames($frame['file']) : 'unknown';
+                $line = $frame['line'] ?? 'unknown';
+
+                return [
+                    $file,
+                    $line,
+                ];
+            }
+        }
+
+        return [
+            'unknown',
+            'unknown',
+        ];
+    }
+
+    /**
+     * Cleans the paths of filenames by replacing APPPATH, SYSTEMPATH, FCPATH
+     * with the actual var. i.e.
+     *
+     *  /var/www/site/app/Controllers/Home.php
+     *      becomes:
+     *  APPPATH/Controllers/Home.php
+     */
+    protected function cleanFileNames(string $file): string
+    {
+        $file = str_replace(APPPATH, 'APPPATH/', $file);
+        $file = str_replace(SYSTEMPATH, 'SYSTEMPATH/', $file);
+
+        return str_replace(FCPATH, 'FCPATH/', $file);
+    }
+}