Add console mode to log handler

spiral · Nov 23, 2022 · b3135b8 · b3135b8
1 parent 88002ac
commit b3135b8
Show file tree

Hide file tree

Showing 3 changed files with 45 additions and 95 deletions.
diff --git a/src/Bootloader/LoggerBootloader.php b/src/Bootloader/LoggerBootloader.php
@@ -4,10 +4,12 @@
 
 namespace Spiral\RoadRunnerBridge\Bootloader;
 
+use Monolog\Handler\ErrorLogHandler;
 use Spiral\Boot\Bootloader\Bootloader;
 use Spiral\Boot\EnvironmentInterface;
 use RoadRunner\Logger\Logger;
 use Spiral\RoadRunnerBridge\Logger\Handler;
+use Spiral\RoadRunnerBridge\RoadRunnerMode;
 
 final class LoggerBootloader extends Bootloader
 {
@@ -19,8 +21,10 @@ final class LoggerBootloader extends Bootloader
         Handler::class => [self::class, 'initHandler'],
     ];
 
-    private function initHandler(Logger $logger, EnvironmentInterface $env): Handler
+    private function initHandler(Logger $logger, RoadRunnerMode $mode, EnvironmentInterface $env): Handler
     {
-        return new Handler($logger, $env->get('LOGGER_FORMAT', Handler::FORMAT));
+        $fallbackHandler = $mode === RoadRunnerMode::Unknown ? new ErrorLogHandler() : null;
+
+        return new Handler($logger, $fallbackHandler, $env->get('LOGGER_FORMAT', Handler::FORMAT));
     }
 }
diff --git a/src/Logger/Handler.php b/src/Logger/Handler.php
@@ -7,16 +7,18 @@
 use Monolog\Formatter\FormatterInterface;
 use Monolog\Formatter\LineFormatter;
 use Monolog\Handler\AbstractProcessingHandler;
+use Monolog\Handler\HandlerInterface;
 use Monolog\Logger;
 use RoadRunner\Logger\Logger as RoadRunnerLogger;
 
-class Handler extends AbstractProcessingHandler
+final class Handler extends AbstractProcessingHandler
 {
     public const FORMAT = "%message% %context% %extra%\n";
 
     public function __construct(
         private readonly RoadRunnerLogger $logger,
-        string|FormatterInterface $formatter = self::FORMAT
+        private readonly ?HandlerInterface $fallbackHandler = null,
+        string|FormatterInterface $formatter = self::FORMAT,
     ) {
         parent::__construct();
 
@@ -27,6 +29,15 @@ public function __construct(
         $this->setFormatter($formatter);
     }
 
+    public function handle(array $record): bool
+    {
+        if ($this->fallbackHandler !== null) {
+            return $this->fallbackHandler->handle($record);
+        }
+
+        return parent::handle($record);
+    }
+
     protected function write(array $record): void
     {
         $message = $record['formatted'];

diff --git a/tests/src/Logger/HandlerTest.php b/tests/src/Logger/HandlerTest.php
@@ -6,123 +6,58 @@
 
 use RoadRunner\Logger\Logger;
 use Spiral\Goridge\RPC\RPCInterface;
+use Monolog\Handler\HandlerInterface;
 use Spiral\RoadRunnerBridge\Logger\Handler;
 use Spiral\Tests\TestCase;
 use Mockery as m;
 use Monolog\Logger as Monolog;
 
 final class HandlerTest extends TestCase
 {
-    /**
-     * @dataProvider provideLogData
-     */
-    public function testSendLog($expectedResult, $input): void
+    public function testLoggerShouldSendDataToRRIfFallbackNull(): void
     {
         $rpc = m::mock(RPCInterface::class);
 
         $rpc->shouldReceive('withServicePrefix')->once()->with('app')->andReturnSelf();
 
         $monolog = new Monolog('default');
+
         $monolog->setHandlers([
             new Handler(
                 new Logger($rpc),
+                null,
                 '%message% foo'
             ),
         ]);
 
         $rpc->shouldReceive('call')
             ->once()
-            ->with($expectedResult['level'], $expectedResult['message'])
+            ->with('Error', 'Error message foo')
             ->andReturnSelf();
 
-        $method = $input['method'];
-
-        $monolog->$method($input['message']);
+        $monolog->error('Error message');
     }
 
-    public function provideLogData(): array
+    public function testLoggerShouldSendDataToFallback(): void
     {
-        return [
-            [
-                [
-                    'level' => 'Error',
-                    'message' => 'Error message foo',
-                ],
-                [
-                    'method' => 'error',
-                    'message' => 'Error message',
-                ],
-            ],
-            [
-                [
-                    'level' => 'Warning',
-                    'message' => 'Warning message foo',
-                ],
-                [
-                    'method' => 'warning',
-                    'message' => 'Warning message',
-                ],
-            ],
-            [
-                [
-                    'level' => 'Info',
-                    'message' => 'Info message foo',
-                ],
-                [
-                    'method' => 'info',
-                    'message' => 'Info message',
-                ],
-            ],
-            [
-                [
-                    'level' => 'Debug',
-                    'message' => 'Debug message foo',
-                ],
-                [
-                    'method' => 'debug',
-                    'message' => 'Debug message',
-                ],
-            ],
-            [
-                [
-                    'level' => 'Warning',
-                    'message' => 'Emergency message foo',
-                ],
-                [
-                    'method' => 'emergency',
-                    'message' => 'Emergency message',
-                ],
-            ],
-            [
-                [
-                    'level' => 'Warning',
-                    'message' => 'Alert message foo',
-                ],
-                [
-                    'method' => 'alert',
-                    'message' => 'Alert message',
-                ],
-            ],
-            [
-                [
-                    'level' => 'Error',
-                    'message' => 'Critical message foo',
-                ],
-                [
-                    'method' => 'critical',
-                    'message' => 'Critical message',
-                ],
-            ],
-            [
-                [
-                    'level' => 'Info',
-                    'message' => 'Notice message foo',
-                ],
-                [
-                    'method' => 'notice',
-                    'message' => 'Notice message',
-                ],
-            ],
-        ];
+        $rpc = m::mock(RPCInterface::class);
+
+        $rpc->shouldReceive('withServicePrefix')->once()->with('app')->andReturnSelf();
+
+        $monolog = new Monolog('default');
+
+        $monolog->setHandlers([
+            new Handler(
+                new Logger($rpc),
+                $fallback = m::mock(HandlerInterface::class),
+                '%message% foo'
+            ),
+        ]);
+
+        $fallback->shouldReceive('handle')->withArgs(function (array $record) {
+            return $record['message'] === 'Error message';
+        })->andReturn(true);
+
+        $monolog->error('Error message');
     }
 }