TimedRotatingFile.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\Handler;

class TimedRotatingFile extends \Plop\Handler\RotatingAbstract
{
    protected $when;

    protected $backupCount;

    protected $utc;

    protected $interval;

    protected $suffix;

    protected $extMatch;

    protected $dayOfWeek;

    protected $rolloverAt;

    protected static $dayNames = array(
        'Monday',
        'Tuesday',
        'Wednesday',
        'Thursday',
        'Friday',
        'Saturday',
        'Sunday'
    );

    public function __construct(
        $filename,
        $when = 'h',
        $interval = 1,
        $backupCount = 0,
        $delay = false,
        $utc = false
    ) {
        parent::__construct($filename, 'a', $delay);
        $this->when         = strtoupper($when);
        $this->backupCount  = $backupCount;
        $this->utc          = $utc;
        $this->rolloverAt   = null;
        $this->dayOfWeek    = null;

        if ($this->when == 'S') {
            $this->interval     = 1;
            $this->suffix       = '%Y-%m-%d_%H-%M-%S';
            $this->extMatch     = '^\\d{4}-\\d{2}-\\d{2}_\\d{2}-\\d{2}-\\d{2}$';
        } elseif ($this->when == 'M') {
            $this->interval     = 60;
            $this->suffix       = '%Y-%m-%d_%H-%M';
            $this->extMatch     = '^\\d{4}-\\d{2}-\\d{2}_\\d{2}-\\d{2}$';
        } elseif ($this->when == 'H') {
            $this->interval     = 60 * 60;
            $this->suffix       = '%Y-%m-%d_%H';
            $this->extMatch     = '^\\d{4}-\\d{2}-\\d{2}_\\d{2}$';
        } elseif ($this->when == 'D' || $this->when == 'MIDNIGHT') {
            $this->interval     = 60 * 60 * 24;
            $this->suffix       = '%Y-%m-%d';
            $this->extMatch     = '^\\d{4}-\\d{2}-\\d{2}$';
        } elseif (substr($this->when, 0, 1) == 'W') {
            $this->interval = 60 * 60 * 24 * 7;
            if (strlen($this->when) != 2) {
                throw new \Plop\Exception(
                    sprintf(
                        'You must specify a day for weekly rollover '.
                        'from 0 to 6 (0 is Monday), not %s',
                        $this->when
                    )
                );
            }

            $day = ord($this->when[1]) - ord('0');
            if ($day < 0 || $day > 6) {
                throw new \Plop\Exception(
                    sprintf(
                        'Invalid day specified for weekly rollover: %s',
                        $this->when[1]
                    )
                );
            }

            $this->dayOfWeek    = $day;
            $this->suffix       = '%Y-%m-%d';
            $this->extMatch     = '^\\d{4}-\\d{2}-\\d{2}$';
        } else {
            throw new \Plop\Exception(
                sprintf(
                    'Invalid rollover interval specified: %s',
                    $this->when
                )
            );
        }

        if (!is_int($interval) || $interval < 1) {
            throw new \Plop\Exception(
                'The interval should be an integer ' .
                'greater than or equal to 1'
            );
        }

        $this->interval     = $this->interval * $interval;
        $this->rolloverAt   = $this->computeRollover($this->getTime());
    }

    protected function computeRollover($currentTime)
    {
        if ($this->when == 'MIDNIGHT') {
            return strtotime("midnight + 1 day", $currentTime);
        }

        if (substr($this->when, 0, 1) == 'W') {
            return strtotime(
                "next " . self::$dayNames[$this->dayOfWeek],
                $currentTime
            );
        }

        return $currentTime + $this->interval;
    }

    protected function getTime()
    {
        return time();
    }

    protected function shouldRollover(\Plop\RecordInterface $record)
    {
        return ($this->getTime() >= $this->rolloverAt);
    }

    protected function getFilesToDelete()
    {
        $dirName    = dirname($this->baseFilename);
        $baseName   = basename($this->baseFilename);
        $fileNames  = scandir($dirName);
        $result     = array();
        $prefix     = $baseName . '.';
        $plen       = strlen($prefix);

        foreach ($fileNames as $fileName) {
            if ($fileName == '.' || $fileName == '..') {
                continue;
            }

            if (!strncmp($fileName, $prefix, $plen)) {
                $suffix = substr($fileName, $plen);
                if (preg_match($this->extMatch, $suffix)) {
                    $result[] = $dirName . DIRECTORY_SEPARATOR . $fileName;
                }
            }
        }

        sort($result);
        $rlen = count($result);
        if ($rlen < $this->backupCount) {
            $result = array();
        } else {
            $result = array_slice($result, 0, $rlen - $this->backupCount);
        }
        return $result;
    }

    protected function doRollover()
    {
        if (is_resource($this->stream)) {
            fclose($this->stream);
        }

        $t = $this->rolloverAt - $this->interval;

        if ($this->utc) {
            $formatFunc = 'gmstrftime';
        } else {
            $formatFunc = 'strftime';
        }

        $dfn = $this->baseFilename . '.' . $formatFunc($this->suffix, $t);
        if (file_exists($dfn)) {
            @unlink($dfn);
        }

        rename($this->baseFilename, $dfn);
        if ($this->backupCount > 0) {
            foreach ($this->getFilesToDelete() as $s) {
                @unlink($s);
            }
        }

        $this->mode     = 'w';
        $this->stream   = $this->open();
        $currentTime    = time();
        $newRolloverAt  = $this->computeRollover($currentTime);
        while ($newRolloverAt <= $currentTime) {
            $newRolloverAt += $this->interval;
        }
        $this->rolloverAt = $newRolloverAt;
    }
}