Subreality\Dilmun\Nabu\LoggerHandler\File

Complexity

Total Complexity

22

Size/Duplication

Total Lines	228
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Importance

Changes	1
Bugs	0	Features	0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	9	2
A	__destruct()	0	4	1
A	getFileName()	0	4	1
A	getFilePath()	0	4	1
A	setFileName()	0	4	1
A	setFilePath()	0	5	1
A	suppressInitFailureMessage()	0	4	1
A	displayInitFailureMessage()	0	4	1
A	sendInitFailureEmailAddress()	0	4	1
A	clearFile()	0	10	2
A	close()	0	4	1
B	initialize()	0	36	6
A	write()	0	18	3

<?php

namespace Subreality\Dilmun\Nabu\LoggerHandler;

/**
 * Log file object implementing a standard HandlerInterface for log entry handlers.
 *
 * @author derek
 *
 * @todo Create methods that set Class properties from actual file properties.
 * @todo Implement log rotation mechanism based on the size of an existing log file specified for writing.
 */
class File implements HandlerInterface
{
    private $file_name;
    private $file_path;

    private $display_init_failure = true;

    private $init_failure_email_address = false;

    /**
     * @var \SplFileObject
     */
    private $file_pointer;

    /**
     * Sets up the file name and path if optional parameters provided.
     *
     * @param string $file_name [optional] The name of the file used for logging; file_path is not required if file_name
     *                          is fully-qualified.
     * @param string $file_path [optional] The path of the file used for logging without the trailing directory
     *                          separator
     */
    public function __construct($file_name = null, $file_path = null)
    {
        $this->file_name = $file_name;

        //Trim any trailing directory separators from the path.
        if (isset($file_path)) {
            $this->file_path = rtrim($file_path, '\/');
        }
    }

    /**
     * Clean-up
     */
    public function __destruct()
    {
        $this->close();
    }

    /**
     * @return null|string  The file_name set for the File instance
     */
    public function getFileName()
    {
        return $this->file_name;
    }

    /**
     * @return null|string  The file_path set for the File instance
     */
    public function getFilePath()
    {
        return $this->file_path;
    }

    /**
     * Sets the name of the file to be used for logging; setting file_path is not required if the specified file name
     * is fully-qualified.
     *
     * @param string $file_name The name of the file to be used for logging
     *
     * @todo Perform some sort of validation against the file name string
     */
    public function setFileName($file_name)
    {
        $this->file_name = $file_name;
    }

    /**
     * Sets the path of the file to be used for logging; file path should not be set if the File's file name is
     * fully-qualified.
     *
     * @see File::setFileName()
     *
     * @param string $file_path The path of the file to be used for logging
     *
     * @todo Perform some sort of validation against the file path string, maybe considering file_name contents
     */
    public function setFilePath($file_path)
    {
        //Trip any trailing directory separators from the path.
        $this->file_path = rtrim($file_path, '\/');
    }

    /**
     * Prevents the initialization function from outputting an exception/failure message when initialization fails;
     * reversed by displayInitFailureMessage. If message is suppressed, a message is instead written to the PHP error
     * log via error_log.
     *
     * @see error_log()
     * @see File::displayInitFailureMessage()
     * @see File::initialize()
     */
    public function suppressInitFailureMessage()
    {
        $this->display_init_failure = false;
    }

    /**
     * Enables the initialization function to output an exception/failure message when initialization fails; reversed
     * by suppressInitFailureMessage.
     *
     * @see File::initialize()
     * @see File::suppressInitFailureMessage()
     */
    public function displayInitFailureMessage()
    {
        $this->display_init_failure = true;
    }

    /**
     * Sets the email address to send a failure notification if File initialization fails. Note that setting the email
     * address enables sending an email notification via PHP's error_log.
     *
     * @see File::initialize()
     * @see error_log()
     *
     * @param string $email_address
     */
    public function sendInitFailureEmailAddress($email_address)
    {
        $this->init_failure_email_address = $email_address;

The property $init_failure_email_address was declared of type boolean, but $email_address is of type string. Maybe add a type cast?

    }

    /**
     * Truncates the File to zero bytes, effectively clearing the file's contents. Does not delete the file.
     *
     * @return bool Returns true if truncate succeeded; returns false on failure.
     */
    public function clearFile()
    {
        if (isset($this->file_pointer)) {
            $this->file_pointer->ftruncate(0);

            return true;
        } else {
            return false;
        }
    }

    /**
     * Sets the File's file_pointer to null to clean up resource.
     */
    public function close()
    {
        $this->file_pointer = null;
    }

    /**
     * Initializes the File for writing via append. Initialization attempts to create an SplFileObject pointer using
     * the File's name and path properties. On failure, initialization may output the full file path with an Exception
     * message depending on File properties. By default, File::initialize() writes output to the standard output
     * buffer and does not send email.
     *
     * @see \SplFileObject
     *
     * @return bool Returns true on successful file pointer creation; returns false on failure.
     *
     * @todo Detect whether file_path has trailing directory separator; add both cases to FileTest.
     */
    public function initialize()
    {
        $full_file = "";

        if (isset($this->file_path)) {
            $full_file = $this->file_path . DIRECTORY_SEPARATOR;
        }

        $full_file .= $this->file_name;

        try {
            $this->file_pointer = new \SplFileObject($full_file, "a");

            return true;
        } catch (\Exception $e) {
            $file_error_message = "Cannot open specified log file for writing: {$full_file}: {$e->getMessage()}\n";

            if ($this->init_failure_email_address) {
                $email_success = error_log($file_error_message, 1, $this->init_failure_email_address);

                //Write to PHP log if sending email fails
                if (!$email_success) {
                    error_log("Sending email to {$this->init_failure_email_address}
                               failed! Message: {$file_error_message}");
                }
            }

            if ($this->display_init_failure) {
                echo $file_error_message;
            } else {
                error_log($file_error_message);
            }

            return false;
        }
    }

    /**
     * Writes the specified message to the File pointer. Requires initialization via File::initialize().
     *
     * @see File::initialize()
     *
     * @param string $message   Message to be written to the file.
     *
     * @return bool Returns true on successful write; returns false on failure.
     *
     * @todo Refactor to return what was written to the file rather than true on success.
     */
    public function write($message)
    {
        if (isset($this->file_pointer)) {
            $locked = $this->file_pointer->flock(LOCK_EX);
        } else {
            $locked = false;
        }

        if ($locked) {
            $now = date('Y-m-d H:i:s');
            $this->file_pointer->fwrite("$now : $message" . "\r\n");
            $this->file_pointer->flock(LOCK_UN);

            return true;
        } else {
            return false;
        }
    }
}