feat(logging): introduce SilentLogger for null-safe logging

Previously, components requiring a logger had to handle cases where one might not be provided, often leading to nullable properties (`?Logger`) and conditional checks. This increased complexity and the risk of fatal errors if a null logger was used.

This commit introduces the `SilentLogger`, a new class that implements the Null Object Pattern for the Logger interface.

- The `SilentLogger` can be used as a default or fallback logger.
- It silently discards all log messages it receives, ensuring that calls to methods like `info()` or `error()` are always safe, even when no actual logging is configured.
- This eliminates the need for `null` checks in client code (e.g., services, command executors), resulting in a cleaner and more robust design.

A corresponding PHPUnit test (`SilentLoggerTest.php`) is included to ensure the class adheres to the Logger contract and functions correctly.

Author: walmir-silva

src/SilentLogger.php

@@ -0,0 +1,46 @@
+<?php
+
+declare(strict_types=1);
+
+namespace KaririCode\Logging;
+
+use KaririCode\Contract\Logging\Logger;
+use KaririCode\Contract\Logging\LogLevel;
+use KaririCode\Logging\Trait\LoggerTrait;
+
+/**
+ * Implements the Null Object Pattern for the Logger interface using a semantic name.
+ *
+ * This logger silently discards all log records it receives. It can be used
+ * as a default or fallback logger to disable logging for a specific channel
+ * or to prevent errors when a logger instance is not available, completely
+ * eliminating the need for conditional checks (`if ($logger)`).
+ */
+final class SilentLogger implements Logger
+{
+    use LoggerTrait;
+
+    public function __construct(private readonly string $name = 'silent')
+    {
+    }
+
+    /**
+     * Silently discards any log message sent to it.
+     *
+     * This method is the core of the Null Object Pattern for this class.
+     * It accepts all the parameters required by the Logger interface but
+     * intentionally has no implementation.
+     */
+    public function log(LogLevel $level, \Stringable|string $message, array $context = []): void
+    {
+        // This logger does nothing, by design.
+    }
+
+    /**
+     * Returns the name of this logger instance.
+     */
+    public function getName(): string
+    {
+        return $this->name;
+    }
+}

tests/Logger/SilentLoggerTest.php

@@ -0,0 +1,70 @@
+<?php
+
+declare(strict_types=1);
+
+namespace KaririCode\Logging\Tests\Logger;
+
+use KaririCode\Contract\Logging\Logger;
+use KaririCode\Logging\LogLevel;
+use KaririCode\Logging\SilentLogger;
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\TestCase;
+
+#[CoversClass(SilentLogger::class)]
+final class SilentLoggerTest extends TestCase
+{
+    /**
+     * Tests that the logger can be instantiated with its default name.
+     */
+    public function testShouldBeInstantiableWithDefaultName(): void
+    {
+        // Arrange
+        $logger = new SilentLogger();
+
+        // Assert
+        $this->assertInstanceOf(Logger::class, $logger, 'SilentLogger must implement the Logger interface.');
+        $this->assertEquals('silent', $logger->getName(), 'The default name for the logger should be "silent".');
+    }
+
+    /**
+     * Tests that the logger can be instantiated with a custom name.
+     */
+    public function testShouldBeInstantiableWithCustomName(): void
+    {
+        // Arrange
+        $logger = new SilentLogger('custom_channel');
+
+        // Assert
+        $this->assertEquals('custom_channel', $logger->getName(), 'The logger should accept and return a custom name.');
+    }
+
+    /**
+     * Tests that calling the main log() method does not produce any errors or output.
+     * This is the core behavior of the Null Object Pattern.
+     */
+    public function testLogMethodShouldDoNothingAndNotThrowErrors(): void
+    {
+        // Arrange
+        $logger = new SilentLogger();
+        $this->expectNotToPerformAssertions(); // The assertion is that no error/exception occurs.
+
+        // Act
+        $logger->log(LogLevel::INFO, 'This message should be discarded silently.');
+    }
+
+    /**
+     * Tests that convenience methods like info(), error(), etc., can be called safely.
+     * These methods are provided by the LoggerTrait and rely on the empty log() method.
+     */
+    public function testConvenienceMethodsShouldDoNothingAndNotThrowErrors(): void
+    {
+        // Arrange
+        $logger = new SilentLogger();
+        $this->expectNotToPerformAssertions();
+
+        // Act
+        $logger->info('Info message to be discarded.');
+        $logger->error('Error message to be discarded.', ['exception' => 'details']);
+        $logger->warning('Warning message to be discarded.');
+    }
+}