Logger.php

<?php
/*
    This file is part of Plop, a simple logging library for PHP.

    Copyright © 2010-2014 François Poirotte

    Plop is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    Plop is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with Plop.  If not, see <http://www.gnu.org/licenses/>.
*/

namespace Plop;

class Logger extends \Plop\LoggerAbstract
{
    protected $ns;

    protected $cls;

    protected $method;

    protected $level;

    protected $handlers;

    protected $emittedWarning;

    protected $filters;

    public function __construct(
        $ns = null,
        $cls = null,
        $method = null,
        \Plop\HandlersCollectionAbstract $handlers = null,
        \Plop\FiltersCollectionAbstract $filters = null
    ) {
        if ($handlers === null) {
            $handlers = new \Plop\HandlersCollection();
        }
        if ($filters === null) {
            $filters = new \Plop\FiltersCollection();
        }
        if ($ns !== null) {
            while (substr($ns, -strlen('\\')) == '\\') {
                $ns = (string) substr($ns, 0, -strlen('\\'));
            }
        }

        // Strip potential namespace from class name.
        $cls = (string) substr($cls, strrpos('\\' . $cls, '\\'));
        if ($cls === '') {
            $cls = null;
        }

        // Strip potential namespace from method/function name.
        $method = (string) substr($method, strrpos('\\' . $method, '\\'));
        if ($method === '') {
            $method = null;
        }

        $this->ns               = $ns;
        $this->cls              = $cls;
        $this->method           = $method;
        $this->level            = \Plop\NOTSET;
        $this->handlers         = $handlers;
        $this->emittedWarning   = false;
        $this->filters          = $filters;
        $this->setRecordFactory(new \Plop\RecordFactory());
    }

    public function getNamespace()
    {
        return $this->ns;
    }

    public function getClass()
    {
        return $this->cls;
    }

    public function getMethod()
    {
        return $this->method;
    }

    public function getRecordFactory()
    {
        return $this->recordFactory;
    }

    public function setRecordFactory(\Plop\RecordFactoryInterface $factory)
    {
        $this->recordFactory = $factory;
        return $this;
    }

    public function getFilters()
    {
        return $this->filters;
    }

    public function setFilters(\Plop\FiltersCollectionAbstract $filters)
    {
        $this->filters = $filters;
        return $this;
    }

    public function getHandlers()
    {
        return $this->handlers;
    }

    public function setHandlers(\Plop\HandlersCollectionAbstract $handlers)
    {
        $this->handlers = $handlers;
        return $this;
    }

    public function log(
        $level,
        $msg,
        array $args = array(),
        \Exception $exception = null
    ) {
        if ($this->isEnabledFor($level)) {
            $caller = \Plop\Plop::findCaller();
            $record = $this->recordFactory->createRecord(
                $this->ns,
                $this->cls,
                $this->method,
                $caller['ns'],
                $caller['cls'],
                $caller['func'],
                $level,
                $caller['file'] ? $caller['file'] : '???',
                $caller['line'],
                $msg,
                $args,
                $exception
            );
            $this->handle($record);
        }
        return $this;
    }

    protected function handle(\Plop\RecordInterface $record)
    {
        if ($this->filters->filter($record)) {
            $this->callHandlers($record);
        }
        return $this;
    }

    protected function callHandlers(\Plop\RecordInterface $record)
    {
        if (!count($this->handlers) && !$this->emittedWarning) {
            $stderr = $this->getStderr();
            fprintf(
                $stderr,
                'No handlers could be found for logger ("%s" in "%s")' . "\n",
                $this->cls .
                ($this->cls === null || $this->cls === '' ? '' : '::') .
                $this->method,
                $this->ns
            );
            fclose($stderr);
            $this->emittedWarning = true;
            return $this;
        }

        $this->handlers->handle($record);
        return $this;
    }

    protected function getStderr()
    {
        return fopen('php://stderr', 'at');
    }

    public function getLevel()
    {
        return $this->level;
    }

    public function setLevel($level)
    {
        if (!is_int($level)) {
            $plop = \Plop\Plop::getInstance();
            $level = $plop->getLevelValue($level);
        }
        $this->level = $level;
        return $this;
    }

    public function isEnabledFor($level)
    {
        if (!is_int($level)) {
            $plop = \Plop\Plop::getInstance();
            $level = $plop->getLevelValue($level);
        }
        return ($level >= $this->level);
    }
}