[8.x] support action_level configuration (#40305)

* chore (logging): support action_level configuration

Enable the usage of the action_level configuration for log channels. When the action_level configuration is used the choosen handler by the developer will be wrapped in a Fingerscrossed handler.

The Fingerscrossed handler will buffer all log records that are at or above the provided level configuration. Only when a log record is provided at or above the action_level all the buffered records will be flushed to the log itself.

This methodology helps developers to gather debug information about a process while only logging that debug information if the code hits for example a critical error.

@see https://github.com/Seldaek/monolog/blob/main/src/Monolog/Handler/FingersCrossedHandler.php
@see https://symfony.com/doc/current/logging.html#handlers-that-modify-log-entries

* fix (test): support older Monolog version

Support checking the wrapped handler in older Monolog versions (pre 1.x). In the older versions the getHandler method was not yet available. The handler was only set as a protected property.

* formatting

Co-authored-by: Wim Ulkeman <[email protected]>
Co-authored-by: Taylor Otwell <[email protected]>

Author: 3 people

src/Illuminate/Log/LogManager.php

@@ -7,6 +7,7 @@
 use InvalidArgumentException;
 use Monolog\Formatter\LineFormatter;
 use Monolog\Handler\ErrorLogHandler;
+use Monolog\Handler\FingersCrossedHandler;
 use Monolog\Handler\FormattableHandlerInterface;
 use Monolog\Handler\HandlerInterface;
 use Monolog\Handler\RotatingFileHandler;
@@ -416,6 +417,10 @@ protected function prepareHandlers(array $handlers)
      */
     protected function prepareHandler(HandlerInterface $handler, array $config = [])
     {
+        if (isset($config['action_level'])) {
+            $handler = new FingersCrossedHandler($handler, $this->actionLevel($config));
+        }
+
         if (Monolog::API !== 1 && (Monolog::API !== 2 || ! $handler instanceof FormattableHandlerInterface)) {
             return $handler;
         }

src/Illuminate/Log/ParsesLogConfiguration.php

@@ -49,6 +49,23 @@ protected function level(array $config)
         throw new InvalidArgumentException('Invalid log level.');
     }
 
+    /**
+     * Parse the action level from the given configuration.
+     *
+     * @param  array  $config
+     * @return int
+     */
+    protected function actionLevel(array $config)
+    {
+        $level = $config['action_level'] ?? 'debug';
+
+        if (isset($this->levels[$level])) {
+            return $this->levels[$level];
+        }
+
+        throw new InvalidArgumentException('Invalid log action level.');
+    }
+
     /**
      * Extract the log channel from the given configuration.
      *

tests/Log/LogManagerTest.php

@@ -7,6 +7,7 @@
 use Monolog\Formatter\HtmlFormatter;
 use Monolog\Formatter\LineFormatter;
 use Monolog\Formatter\NormalizerFormatter;
+use Monolog\Handler\FingersCrossedHandler;
 use Monolog\Handler\LogEntriesHandler;
 use Monolog\Handler\NewRelicHandler;
 use Monolog\Handler\NullHandler;
@@ -432,4 +433,52 @@ public function __invoke()
 
         $this->assertSame(storage_path('logs/custom.log'), $url->getValue($handler));
     }
+
+    public function testWrappingHandlerInFingersCrossedWhenActionLevelIsUsed()
+    {
+        $config = $this->app['config'];
+
+        $config->set('logging.channels.fingerscrossed', [
+            'driver' => 'monolog',
+            'handler' => StreamHandler::class,
+            'level' => 'debug',
+            'action_level' => 'critical',
+            'with' => [
+                'stream' => 'php://stderr',
+                'bubble' => false,
+            ],
+        ]);
+
+        $manager = new LogManager($this->app);
+
+        // create logger with handler specified from configuration
+        $logger = $manager->channel('fingerscrossed');
+        $handlers = $logger->getLogger()->getHandlers();
+
+        $this->assertInstanceOf(Logger::class, $logger);
+        $this->assertCount(1, $handlers);
+
+        $expectedFingersCrossedHandler = $handlers[0];
+        $this->assertInstanceOf(FingersCrossedHandler::class, $expectedFingersCrossedHandler, );
+
+        $activationStrategyProp = new ReflectionProperty(get_class($expectedFingersCrossedHandler), 'activationStrategy');
+        $activationStrategyProp->setAccessible(true);
+        $activationStrategyValue = $activationStrategyProp->getValue($expectedFingersCrossedHandler);
+
+        $actionLevelProp = new ReflectionProperty(get_class($activationStrategyValue), 'actionLevel');
+        $actionLevelProp->setAccessible(true);
+        $actionLevelValue = $actionLevelProp->getValue($activationStrategyValue);
+
+        $this->assertEquals(Monolog::CRITICAL, $actionLevelValue);
+
+        if (method_exists($expectedFingersCrossedHandler, 'getHandler')) {
+            $expectedStreamHandler = $expectedFingersCrossedHandler->getHandler();
+        } else {
+            $handlerProp = new ReflectionProperty(get_class($expectedFingersCrossedHandler), 'handler');
+            $handlerProp->setAccessible(true);
+            $expectedStreamHandler = $handlerProp->getValue($expectedFingersCrossedHandler);
+        }
+        $this->assertInstanceOf(StreamHandler::class, $expectedStreamHandler);
+        $this->assertEquals(Monolog::DEBUG, $expectedStreamHandler->getLevel());
+    }
 }