Merge remote-tracking branch 'hver/master'

src/Monolog/Handler/MinMaxHandler.php

@@ -0,0 +1,95 @@
+<?php
+
+namespace Monolog\Handler;
+
+use Monolog\Logger;
+
+/**
+ * Simple handler wrapper that processes only log entries, which are between the min and max log level.
+ *
+ * @author Hennadiy Verkh
+ */
+class MinMaxHandler extends AbstractHandler
+{
+    /**
+     * Handler or factory callable($record, $this)
+     *
+     * @var callable|\Monolog\Handler\HandlerInterface
+     */
+    protected $handler;
+    /**
+     * Minimum level for logs that are passes to handler
+     *
+     * @var int
+     */
+    protected $minLevel;
+    /**
+     * Maximum level for logs that are passes to handler
+     *
+     * @var int
+     */
+    protected $maxLevel;
+    /**
+     * Whether the messages that are handled can bubble up the stack or not
+     *
+     * @var Boolean
+     */
+    protected $bubble;
+
+    /**
+     * @param callable|HandlerInterface $handler Handler or factory callable($record, $this).
+     * @param int                       $minLevel Minimum level for logs that are passes to handler
+     * @param int                       $maxLevel Maximum level for logs that are passes to handler
+     * @param Boolean                   $bubble Whether the messages that are handled can bubble up the stack or not
+     */
+    public function __construct($handler, $minLevel = Logger::DEBUG, $maxLevel = Logger::EMERGENCY, $bubble = true)
+    {
+
+        $this->handler  = $handler;
+        $this->minLevel = $minLevel;
+        $this->maxLevel = $maxLevel;
+        $this->bubble   = $bubble;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function isHandling(array $record)
+    {
+        return $record['level'] >= $this->minLevel && $record['level'] <= $this->maxLevel;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function handle(array $record)
+    {
+        if (!$this->isHandling($record)) {
+            return false;
+        }
+
+        // The same logic as in FingersCrossedHandler
+        if (!$this->handler instanceof HandlerInterface) {
+            if (!is_callable($this->handler)) {
+                throw new \RuntimeException(
+                    "The given handler (" . json_encode($this->handler)
+                    . ") is not a callable nor a Monolog\\Handler\\HandlerInterface object"
+                );
+            }
+            $this->handler = call_user_func($this->handler, $record, $this);
+            if (!$this->handler instanceof HandlerInterface) {
+                throw new \RuntimeException("The factory callable should return a HandlerInterface");
+            }
+        }
+
+        if ($this->processors) {
+            foreach ($this->processors as $processor) {
+                $record = call_user_func($processor, $record);
+            }
+        }
+
+        $this->handler->handle($record);
+
+        return false === $this->bubble;
+    }
+}

tests/Monolog/Handler/MinMaxHandlerTest.php

@@ -0,0 +1,127 @@
+<?php
+
+namespace Monolog\Handler;
+
+use Monolog\Logger;
+use Monolog\TestCase;
+
+/**
+ * Unit tests for minMaxHandler
+ *
+ * @author Hennadiy Verkh
+ */
+class MinMaxHandlerTest extends TestCase
+{
+
+    /**
+     * @covers Monolog\Handler\MinMaxHandler::isHandling
+     */
+    public function testIsHandling()
+    {
+        $test    = new TestHandler();
+        $handler = new MinMaxHandler($test, Logger::INFO, Logger::NOTICE);
+        $this->assertFalse($handler->isHandling($this->getRecord(Logger::DEBUG)));
+        $this->assertTrue($handler->isHandling($this->getRecord(Logger::INFO)));
+        $this->assertTrue($handler->isHandling($this->getRecord(Logger::NOTICE)));
+        $this->assertFalse($handler->isHandling($this->getRecord(Logger::WARNING)));
+        $this->assertFalse($handler->isHandling($this->getRecord(Logger::ERROR)));
+        $this->assertFalse($handler->isHandling($this->getRecord(Logger::CRITICAL)));
+        $this->assertFalse($handler->isHandling($this->getRecord(Logger::ALERT)));
+        $this->assertFalse($handler->isHandling($this->getRecord(Logger::EMERGENCY)));
+    }
+
+    /**
+     * @covers Monolog\Handler\MinMaxHandler::handle
+     */
+    public function testHandleProcessOnlyNeededLevels()
+    {
+        $test    = new TestHandler();
+        $handler = new MinMaxHandler($test, Logger::INFO, Logger::NOTICE);
+
+        $handler->handle($this->getRecord(Logger::DEBUG));
+        $this->assertFalse($test->hasDebugRecords());
+
+        $handler->handle($this->getRecord(Logger::INFO));
+        $this->assertTrue($test->hasInfoRecords());
+        $handler->handle($this->getRecord(Logger::NOTICE));
+        $this->assertTrue($test->hasNoticeRecords());
+
+        $handler->handle($this->getRecord(Logger::WARNING));
+        $this->assertFalse($test->hasWarningRecords());
+        $handler->handle($this->getRecord(Logger::ERROR));
+        $this->assertFalse($test->hasErrorRecords());
+        $handler->handle($this->getRecord(Logger::CRITICAL));
+        $this->assertFalse($test->hasCriticalRecords());
+        $handler->handle($this->getRecord(Logger::ALERT));
+        $this->assertFalse($test->hasAlertRecords());
+        $handler->handle($this->getRecord(Logger::EMERGENCY));
+        $this->assertFalse($test->hasEmergencyRecords());
+    }
+
+    /**
+     * @covers Monolog\Handler\MinMaxHandler::handle
+     */
+    public function testHandleUsesProcessors()
+    {
+        $test    = new TestHandler();
+        $handler = new MinMaxHandler($test, Logger::DEBUG, Logger::EMERGENCY);
+        $handler->pushProcessor(
+            function ($record) {
+                $record['extra']['foo'] = true;
+
+                return $record;
+            }
+        );
+        $handler->handle($this->getRecord(Logger::WARNING));
+        $this->assertTrue($test->hasWarningRecords());
+        $records = $test->getRecords();
+        $this->assertTrue($records[0]['extra']['foo']);
+    }
+
+    /**
+     * @covers Monolog\Handler\MinMaxHandler::handle
+     */
+    public function testHandleRespectsBubble()
+    {
+        $test = new TestHandler();
+
+        $handler = new MinMaxHandler($test, Logger::INFO, Logger::NOTICE, false);
+        $this->assertTrue($handler->handle($this->getRecord(Logger::INFO)));
+        $this->assertFalse($handler->handle($this->getRecord(Logger::WARNING)));
+
+        $handler = new MinMaxHandler($test, Logger::INFO, Logger::NOTICE, true);
+        $this->assertFalse($handler->handle($this->getRecord(Logger::INFO)));
+        $this->assertFalse($handler->handle($this->getRecord(Logger::WARNING)));
+    }
+
+    /**
+     * @covers Monolog\Handler\MinMaxHandler::handle
+     */
+    public function testHandleWithCallback()
+    {
+        $test    = new TestHandler();
+        $handler = new MinMaxHandler(
+            function ($record, $handler) use ($test) {
+                return $test;
+            }, Logger::INFO, Logger::NOTICE, false
+        );
+        $handler->handle($this->getRecord(Logger::DEBUG));
+        $handler->handle($this->getRecord(Logger::INFO));
+        $this->assertFalse($test->hasDebugRecords());
+        $this->assertTrue($test->hasInfoRecords());
+    }
+
+    /**
+     * @covers Monolog\Handler\MinMaxHandler::handle
+     * @expectedException \RuntimeException
+     */
+    public function testHandleWithBadCallbackThrowsException()
+    {
+        $handler = new MinMaxHandler(
+            function ($record, $handler) {
+                return 'foo';
+            }
+        );
+        $handler->handle($this->getRecord(Logger::WARNING));
+    }
+}