feat(log): emit MessageLogged when logs are written (#795)

Author: innocenzi

src/Tempest/Log/src/GenericLogger.php

@@ -4,9 +4,11 @@
 
 namespace Tempest\Log;
 
-use Monolog\Level;
+use Monolog\Level as MonologLogLevel;
 use Monolog\Logger as Monolog;
+use Psr\Log\LogLevel as PsrLogLevel;
 use Stringable;
+use Tempest\EventBus\EventBus;
 
 final class GenericLogger implements Logger
 {
@@ -15,64 +17,80 @@ final class GenericLogger implements Logger
 
     public function __construct(
         private readonly LogConfig $logConfig,
+        private readonly EventBus $eventBus,
     ) {
     }
 
     public function emergency(Stringable|string $message, array $context = []): void
     {
-        $this->writeLog(Level::Emergency, $message, $context);
+        $this->log(LogLevel::EMERGENCY, $message, $context);
     }
 
     public function alert(Stringable|string $message, array $context = []): void
     {
-        $this->writeLog(Level::Alert, $message, $context);
+        $this->log(LogLevel::ALERT, $message, $context);
     }
 
     public function critical(Stringable|string $message, array $context = []): void
     {
-        $this->writeLog(Level::Critical, $message, $context);
+        $this->log(LogLevel::CRITICAL, $message, $context);
     }
 
     public function error(Stringable|string $message, array $context = []): void
     {
-        $this->writeLog(Level::Error, $message, $context);
+        $this->log(LogLevel::ERROR, $message, $context);
     }
 
     public function warning(Stringable|string $message, array $context = []): void
     {
-        $this->writeLog(Level::Warning, $message, $context);
+        $this->log(LogLevel::WARNING, $message, $context);
     }
 
     public function notice(Stringable|string $message, array $context = []): void
     {
-        $this->writeLog(Level::Notice, $message, $context);
+        $this->log(LogLevel::NOTICE, $message, $context);
     }
 
     public function info(Stringable|string $message, array $context = []): void
     {
-        $this->writeLog(Level::Info, $message, $context);
+        $this->log(LogLevel::INFO, $message, $context);
     }
 
     public function debug(Stringable|string $message, array $context = []): void
     {
-        $this->writeLog(Level::Debug, $message, $context);
+        $this->log(LogLevel::DEBUG, $message, $context);
     }
 
+    /** @param MonologLogLevel|LogLevel|string $level */
     public function log($level, Stringable|string $message, array $context = []): void
     {
-        $level = Level::tryFrom($level) ?? Level::Info;
+        if (! $level instanceof MonologLogLevel) {
+            $level = match ($level) {
+                LogLevel::EMERGENCY, PsrLogLevel::EMERGENCY => MonologLogLevel::Emergency,
+                LogLevel::ALERT, PsrLogLevel::ALERT => MonologLogLevel::Alert,
+                LogLevel::CRITICAL, PsrLogLevel::CRITICAL => MonologLogLevel::Critical,
+                LogLevel::ERROR, PsrLogLevel::ERROR => MonologLogLevel::Error,
+                LogLevel::WARNING, PsrLogLevel::WARNING => MonologLogLevel::Warning,
+                LogLevel::NOTICE, PsrLogLevel::NOTICE => MonologLogLevel::Notice,
+                LogLevel::INFO, PsrLogLevel::INFO => MonologLogLevel::Info,
+                LogLevel::DEBUG, PsrLogLevel::DEBUG => MonologLogLevel::Debug,
+                default => MonologLogLevel::Info
+            };
+        }
 
         $this->writeLog($level, $message, $context);
+
+        $this->eventBus->dispatch(new MessageLogged(LogLevel::fromMonolog($level), $message, $context));
     }
 
-    private function writeLog(Level $level, string $message, array $context): void
+    private function writeLog(MonologLogLevel $level, string $message, array $context): void
     {
         foreach ($this->logConfig->channels as $channel) {
             $this->resolveDriver($channel, $level)->log($level, $message, $context);
         }
     }
 
-    private function resolveDriver(LogChannel $channel, Level $level): Monolog
+    private function resolveDriver(LogChannel $channel, MonologLogLevel $level): Monolog
     {
         if (! isset($this->drivers[spl_object_id($channel)])) {
             $this->drivers[spl_object_id($channel)] = new Monolog(

src/Tempest/Log/src/LogLevel.php

@@ -0,0 +1,64 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tempest\Log;
+
+use Monolog\Level;
+
+enum LogLevel: string
+{
+    /**
+     * System is unusable.
+     */
+    case EMERGENCY = 'emergency';
+
+    /**
+     * Errors that require action immediately.
+     */
+    case ALERT = 'alert';
+
+    /**
+     * Important, unexpected errors that require attention.
+     */
+    case CRITICAL = 'critical';
+
+    /**
+     * Runtime errors that do not require immediate action but should be monitored.
+     */
+    case ERROR = 'error';
+
+    /**
+     * Exceptional occurrences that are not errors.
+     */
+    case WARNING = 'warning';
+
+    /**
+     * Uncommon events.
+     */
+    case NOTICE = 'notice';
+
+    /**
+     * Miscellaneous events.
+     */
+    case INFO = 'info';
+
+    /**
+     * Detailed debug information.
+     */
+    case DEBUG = 'debug';
+
+    public static function fromMonolog(Level $level): self
+    {
+        return match ($level) {
+            Level::Emergency => self::EMERGENCY,
+            Level::Alert => self::ALERT,
+            Level::Critical => self::CRITICAL,
+            Level::Error => self::ERROR,
+            Level::Warning => self::WARNING,
+            Level::Notice => self::NOTICE,
+            Level::Info => self::INFO,
+            Level::Debug => self::DEBUG,
+        };
+    }
+}

src/Tempest/Log/src/LoggerInitializer.php

@@ -8,6 +8,7 @@
 use Tempest\Container\Container;
 use Tempest\Container\Initializer;
 use Tempest\Container\Singleton;
+use Tempest\EventBus\EventBus;
 
 final readonly class LoggerInitializer implements Initializer
 {
@@ -16,6 +17,7 @@ public function initialize(Container $container): LoggerInterface|Logger
     {
         return new GenericLogger(
             $container->get(LogConfig::class),
+            $container->get(EventBus::class),
         );
     }
 }

src/Tempest/Log/src/MessageLogged.php

@@ -0,0 +1,17 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tempest\Log;
+
+use Stringable;
+
+final class MessageLogged
+{
+    public function __construct(
+        public LogLevel $level,
+        public Stringable|string $message,
+        public array $context = [],
+    ) {
+    }
+}

src/Tempest/Log/tests/GenericLoggerTest.php

@@ -0,0 +1,36 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tempest\Log\Tests;
+
+use Monolog\Level;
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\TestCase;
+use Tempest\Log\LogLevel;
+
+/**
+ * @internal
+ */
+final class LogLevelTest extends TestCase
+{
+    #[DataProvider('levelsProvider')]
+    public function test_from_monolog(Level $level, LogLevel $expected): void
+    {
+        $this->assertSame($expected, LogLevel::fromMonolog($level));
+    }
+
+    public static function levelsProvider(): array
+    {
+        return [
+            [Level::Emergency, LogLevel::EMERGENCY],
+            [Level::Alert, LogLevel::ALERT],
+            [Level::Critical, LogLevel::CRITICAL],
+            [Level::Error, LogLevel::ERROR],
+            [Level::Warning, LogLevel::WARNING],
+            [Level::Notice, LogLevel::NOTICE],
+            [Level::Info, LogLevel::INFO],
+            [Level::Debug, LogLevel::DEBUG],
+        ];
+    }
+}