feat: Logger

composer.json

@@ -6,7 +6,9 @@
         "giggsey/libphonenumber-for-php": "^8.13",
         "egulias/email-validator": "^4.0",
         "tempest/highlight": "^2.0",
-        "symfony/var-exporter": "^7.0"
+        "symfony/var-exporter": "^7.0",
+        "psr/log": "^3.0",
+        "monolog/monolog": "^3.6"
     },
     "require-dev": {
         "phpunit/phpunit": "^10.2",

src/Config/logs.php

@@ -0,0 +1,9 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tempest\Config;
+
+use Tempest\Log\LogConfig;
+
+return new LogConfig();

src/Discovery/LogHandlerDiscovery.php

@@ -0,0 +1,54 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tempest\Discovery;
+
+use ReflectionClass;
+use Tempest\Container\Container;
+use Tempest\Log\Channels\LogChannel;
+use Tempest\Log\LogConfig;
+
+final readonly class LogHandlerDiscovery implements Discovery
+{
+    private const string CACHE_PATH = __DIR__ . '/log-handler-discovery.cache.php';
+
+    public function __construct(
+        private LogConfig $logConfig,
+    ) {
+    }
+
+    public function discover(ReflectionClass $class): void
+    {
+        if (
+            ! $class->isInstantiable()
+            || ! $class->implementsInterface(LogChannel::class)
+        ) {
+            return;
+        }
+
+        $this->logConfig->channels[$class->getName()] = $class->getName();
+    }
+
+    public function hasCache(): bool
+    {
+        return file_exists(self::CACHE_PATH);
+    }
+
+    public function storeCache(): void
+    {
+        file_put_contents(self::CACHE_PATH, serialize($this->logConfig->channels));
+    }
+
+    public function restoreCache(Container $container): void
+    {
+        $channels = unserialize(file_get_contents(self::CACHE_PATH));
+
+        $this->logConfig->channels = $channels;
+    }
+
+    public function destroyCache(): void
+    {
+        @unlink(self::CACHE_PATH);
+    }
+}

src/Log/Channels/AppendLogChannel.php

@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tempest\Log\Channels;
+
+use Monolog\Handler\HandlerInterface;
+use Monolog\Handler\StreamHandler;
+use Monolog\Level;
+use Monolog\Processor\PsrLogMessageProcessor;
+
+final class AppendLogChannel implements LogChannel
+{
+    public function handler(Level $level, array $config): HandlerInterface
+    {
+        return new StreamHandler(
+            stream: $config['path'] ?? 'logs/tempest.log',
+            level: $level,
+            bubble: $config['bubble'] ?? true,
+            filePermission: $config['file_permission'] ?? null,
+            useLocking: $config['use_locking'] ?? false
+        );
+    }
+
+    public function processor(array $config): array
+    {
+        return [
+            new PsrLogMessageProcessor(),
+        ];
+    }
+}

src/Log/Channels/DailyLogChannel.php

@@ -0,0 +1,32 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tempest\Log\Channels;
+
+use Monolog\Handler\HandlerInterface;
+use Monolog\Handler\RotatingFileHandler;
+use Monolog\Level;
+use Monolog\Processor\PsrLogMessageProcessor;
+
+final class DailyLogChannel implements LogChannel
+{
+    public function handler(Level $level, array $config): HandlerInterface
+    {
+        return new RotatingFileHandler(
+            filename: $config['path'] ?? 'logs/tempest.log',
+            maxFiles: $config['rotation'] ?? 30,
+            level: $level,
+            bubble: $config['bubble'] ?? true,
+            filePermission: $config['file_permission'] ?? null,
+            useLocking: $config['use_locking'] ?? false
+        );
+    }
+
+    public function processor(array $config): array
+    {
+        return [
+            new PsrLogMessageProcessor(),
+        ];
+    }
+}

src/Log/Channels/LogChannel.php

@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tempest\Log\Channels;
+
+use Monolog\Handler\HandlerInterface;
+use Monolog\Level;
+use Monolog\Processor\ProcessorInterface;
+
+interface LogChannel
+{
+    /**
+     * @param Level $level
+     * @param array $config
+     *
+     * @return array<int, HandlerInterface>|HandlerInterface
+     */
+    public function handler(Level $level, array $config): array|HandlerInterface;
+
+    /**
+     * @return ProcessorInterface|array<int, ProcessorInterface>
+     */
+    public function processor(array $config): array|ProcessorInterface;
+}

src/Log/GenericLogger.php

@@ -0,0 +1,95 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tempest\Log;
+
+use Monolog\Level;
+use Monolog\Logger as Monolog;
+use Psr\Log\LoggerInterface;
+use Stringable;
+use Tempest\Container\Container;
+use Tempest\Log\Channels\LogChannel;
+use Tempest\Support\ArrayHelper;
+
+final class GenericLogger implements LoggerInterface
+{
+    public function __construct(
+        private LogConfig $logConfig,
+        private Container $container,
+        /** @var array<class-string, Monolog> $drivers */
+        private array $drivers = [],
+    ) {
+
+    }
+
+    public function emergency(Stringable|string $message, array $context = []): void
+    {
+        $this->writeLog(Level::Emergency, $message, $context);
+    }
+
+    public function alert(Stringable|string $message, array $context = []): void
+    {
+        $this->writeLog(Level::Alert, $message, $context);
+    }
+
+    public function critical(Stringable|string $message, array $context = []): void
+    {
+        $this->writeLog(Level::Critical, $message, $context);
+    }
+
+    public function error(Stringable|string $message, array $context = []): void
+    {
+        $this->writeLog(Level::Error, $message, $context);
+    }
+
+    public function warning(Stringable|string $message, array $context = []): void
+    {
+        $this->writeLog(Level::Warning, $message, $context);
+    }
+
+    public function notice(Stringable|string $message, array $context = []): void
+    {
+        $this->writeLog(Level::Notice, $message, $context);
+    }
+
+    public function info(Stringable|string $message, array $context = []): void
+    {
+        $this->writeLog(Level::Info, $message, $context);
+    }
+
+    public function debug(Stringable|string $message, array $context = []): void
+    {
+        $this->writeLog(Level::Debug, $message, $context);
+    }
+
+    public function log($level, Stringable|string $message, array $context = []): void
+    {
+        $level = Level::tryFrom($level) ?? Level::Info;
+
+        $this->writeLog($level, $message, $context);
+    }
+
+    private function writeLog(Level $level, string $message, array $context): void
+    {
+        $this->resolveDriver($this->logConfig->channel, $level)->log($level, $message, $context);
+    }
+
+    private function resolveDriver(string $channelName, Level $level): Monolog
+    {
+        if (isset($this->drivers[$channelName])) {
+            return $this->drivers[$channelName];
+        }
+
+        /** @var LogChannel $channel */
+        $channel = $this->container->get($channelName);
+
+        $config = $this->logConfig->channelsConfig[$channelName] ?? [];
+
+        return $this->drivers[$channelName] = new Monolog(
+            name: $this->logConfig->prefix,
+            handlers: ArrayHelper::wrap($channel->handler($level, $config)),
+            processors: ArrayHelper::wrap($channel->processor($config)),
+        );
+    }
+}

src/Log/LogConfig.php

@@ -0,0 +1,22 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tempest\Log;
+
+use Tempest\Log\Channels\AppendLogChannel;
+use Tempest\Log\Channels\LogChannel;
+
+final class LogConfig
+{
+    public function __construct(
+        /** @var LogChannel[] */
+        public array $channels = [],
+        /** @var array<class-string<LogChannel>, array|string> */
+        public array $channelsConfig = [],
+        /** @var class-string<LogChannel> */
+        public string $channel = AppendLogChannel::class,
+        public string $prefix = 'tempest',
+    ) {
+    }
+}

src/Log/Logger.php

@@ -0,0 +1,11 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tempest\Log;
+
+use Psr\Log\LoggerInterface;
+
+interface Logger extends LoggerInterface
+{
+}

src/Log/LoggerInitializer.php

@@ -0,0 +1,22 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tempest\Log;
+
+use Psr\Log\LoggerInterface;
+use Tempest\Container\Container;
+use Tempest\Container\Initializer;
+use Tempest\Container\Singleton;
+
+#[Singleton]
+final readonly class LoggerInitializer implements Initializer
+{
+    public function initialize(Container $container): LoggerInterface
+    {
+        return new GenericLogger(
+            $container->get(LogConfig::class),
+            $container,
+        );
+    }
+}

tests/Unit/KernelTest.php

@@ -12,6 +12,7 @@
 use Tempest\Discovery\DiscoveryLocation;
 use Tempest\Discovery\EventBusDiscovery;
 use Tempest\Discovery\InitializerDiscovery;
+use Tempest\Discovery\LogHandlerDiscovery;
 use Tempest\Discovery\MapperDiscovery;
 use Tempest\Kernel;
 
@@ -38,11 +39,12 @@ public function test_discovery_boot(): void
 
         $appConfig = $container->get(AppConfig::class);
 
-        $this->assertCount(4, $appConfig->discoveryClasses);
+        $this->assertCount(5, $appConfig->discoveryClasses);
         $this->assertSame(DiscoveryDiscovery::class, $appConfig->discoveryClasses[0]);
         $this->assertSame(EventBusDiscovery::class, $appConfig->discoveryClasses[1]);
         $this->assertSame(MapperDiscovery::class, $appConfig->discoveryClasses[2]);
-        $this->assertSame(InitializerDiscovery::class, $appConfig->discoveryClasses[3]);
+        $this->assertSame(LogHandlerDiscovery::class, $appConfig->discoveryClasses[3]);
+        $this->assertSame(InitializerDiscovery::class, $appConfig->discoveryClasses[4]);
 
         $this->assertCount(2, $appConfig->discoveryLocations);
         $this->assertSame('Tempest\\', $appConfig->discoveryLocations[0]->namespace);

tests/Unit/Log/.gitignore

@@ -0,0 +1 @@
+logs/