Enhanced context format

composer.json

@@ -37,13 +37,17 @@
         "buggregator/trap": "^1.13",
         "phpunit/phpunit": "^10.5.45",
         "spiral/code-style": "^2.2",
+        "symfony/polyfill-php83": "*",
         "ta-tikoma/phpunit-architecture-test": "^0.8.5",
         "vimeo/psalm": "^6.10"
     },
     "scripts": {
         "cs:diff": "php-cs-fixer fix --dry-run -v --diff --show-progress dots",
         "cs:fix": "php-cs-fixer fix -v",
-        "test": "phpunit",
+        "test": [
+            "@putenv XDEBUG_MODE=coverage",
+            "phpunit"
+        ],
         "psalm": "psalm"
     },
     "autoload": {

src/Context/DefaultProcessor.php

@@ -0,0 +1,79 @@
+<?php
+
+declare(strict_types=1);
+
+namespace RoadRunner\PsrLogger\Context;
+
+use RoadRunner\PsrLogger\Context\ObjectProcessor\DateTimeProcessor;
+use RoadRunner\PsrLogger\Context\ObjectProcessor\FallbackProcessor;
+use RoadRunner\PsrLogger\Context\ObjectProcessor\StringableProcessor;
+use RoadRunner\PsrLogger\Context\ObjectProcessor\ThrowableProcessor;
+
+/**
+ * Default context processor.
+ *
+ * @api
+ */
+final class DefaultProcessor
+{
+    /** @var list<ObjectProcessor> */
+    private array $processors = [];
+
+    private function __construct() {}
+
+    /**
+     * Create empty instance.
+     */
+    public static function create(): self
+    {
+        return new self();
+    }
+
+    /**
+     * Create with default set of {@see ObjectProcessor}.
+     */
+    public static function createDefault(): self
+    {
+        $self = new self();
+        $self->processors = [
+            new DateTimeProcessor(),
+            new StringableProcessor(),
+            new ThrowableProcessor(),
+            new FallbackProcessor(),
+        ];
+        return $self;
+    }
+
+    /**
+     * Copy the current object and add Object Processors before existing ones.
+     */
+    public function withObjectProcessors(ObjectProcessor ...$processors): self
+    {
+        $clone = clone $this;
+        $clone->processors = \array_merge(\array_values($processors), $clone->processors);
+        return $clone;
+    }
+
+    public function __invoke(mixed $value): mixed
+    {
+        if (\is_resource($value)) {
+            return \get_resource_type($value) . ' resource';
+        }
+
+        if (\is_array($value)) {
+            foreach ($value as &$v) {
+                $v = $this($v);
+            }
+        }
+
+        if (\is_object($value)) {
+            foreach ($this->processors as $processor) {
+                if ($processor->canProcess($value)) {
+                    return $processor->process($value, $this);
+                }
+            }
+        }
+
+        return $value;
+    }
+}

src/Context/ObjectProcessor.php

@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace RoadRunner\PsrLogger\Context;
+
+/**
+ * Converts an object into a scalar or an array for serializable logger context.
+ *
+ * @template T
+ * @api
+ */
+interface ObjectProcessor
+{
+    /**
+     * Check if this processor can handle the given value.
+     */
+    public function canProcess(object $value): bool;
+
+    /**
+     * @param T $value
+     * @param callable(mixed): mixed $processor Function to process nested object values
+     */
+    public function process(object $value, callable $processor): mixed;
+}

src/Context/ObjectProcessor/DateTimeProcessor.php

@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace RoadRunner\PsrLogger\Context\ObjectProcessor;
+
+use RoadRunner\PsrLogger\Context\ObjectProcessor;
+
+/**
+ * Processor for DateTime objects.
+ *
+ * Converts DateTime and DateTimeImmutable objects to ISO 8601 format
+ * for consistent structured logging.
+ *
+ * @implements ObjectProcessor<\DateTimeInterface>
+ * @api
+ */
+final class DateTimeProcessor implements ObjectProcessor
+{
+    #[\Override]
+    public function canProcess(object $value): bool
+    {
+        return $value instanceof \DateTimeInterface;
+    }
+
+    #[\Override]
+    public function process(object $value, callable $processor): mixed
+    {
+        return $value->format(\DateTimeInterface::ATOM);
+    }
+}

src/Context/ObjectProcessor/FallbackProcessor.php

@@ -0,0 +1,37 @@
+<?php
+
+declare(strict_types=1);
+
+namespace RoadRunner\PsrLogger\Context\ObjectProcessor;
+
+use RoadRunner\PsrLogger\Context\ObjectProcessor;
+
+/**
+ * Fallback processor for unknown objects.
+ *
+ * @implements ObjectProcessor<object>
+ * @api
+ */
+final class FallbackProcessor implements ObjectProcessor
+{
+    #[\Override]
+    public function canProcess(object $value): bool
+    {
+        return true;
+    }
+
+    #[\Override]
+    public function process(object $value, callable $processor): array
+    {
+        $result = ['@class' => $value::class] + \get_object_vars($value);
+        foreach ($result as $k => &$v) {
+            if ($v === $value) {
+                unset($result[$k]);
+            }
+
+            $v = $processor($v);
+        }
+
+        return $result;
+    }
+}

src/Context/ObjectProcessor/StringableProcessor.php

@@ -0,0 +1,28 @@
+<?php
+
+declare(strict_types=1);
+
+namespace RoadRunner\PsrLogger\Context\ObjectProcessor;
+
+use RoadRunner\PsrLogger\Context\ObjectProcessor;
+
+/**
+ * Converts Stringable objects to their string representation.
+ *
+ * @implements ObjectProcessor<\Stringable>
+ * @api
+ */
+final class StringableProcessor implements ObjectProcessor
+{
+    #[\Override]
+    public function canProcess(object $value): bool
+    {
+        return $value instanceof \Stringable;
+    }
+
+    #[\Override]
+    public function process(object $value, callable $processor): mixed
+    {
+        return (string) $value;
+    }
+}

src/Context/ObjectProcessor/ThrowableProcessor.php

@@ -0,0 +1,36 @@
+<?php
+
+declare(strict_types=1);
+
+namespace RoadRunner\PsrLogger\Context\ObjectProcessor;
+
+use RoadRunner\PsrLogger\Context\ObjectProcessor;
+
+/**
+ * Converts exceptions to structured data containing class, message,
+ * code, file, line, and stack trace information.
+ *
+ * @implements ObjectProcessor<\Throwable>
+ * @api
+ */
+final class ThrowableProcessor implements ObjectProcessor
+{
+    #[\Override]
+    public function canProcess(object $value): bool
+    {
+        return $value instanceof \Throwable;
+    }
+
+    #[\Override]
+    public function process(object $value, callable $processor): array
+    {
+        return [
+            'class' => \get_class($value),
+            'message' => $value->getMessage(),
+            'code' => $value->getCode(),
+            'file' => $value->getFile(),
+            'line' => $value->getLine(),
+            'trace' => $value->getTraceAsString(),
+        ];
+    }
+}

src/RpcLogger.php

@@ -10,16 +10,22 @@
 use Psr\Log\InvalidArgumentException as PsrInvalidArgumentException;
 use RoadRunner\Logger\Logger as AppLogger;
 use RoadRunner\Logger\LogLevel;
+use RoadRunner\PsrLogger\Context\DefaultProcessor;
 
+/**
+ * @api
+ */
 class RpcLogger implements LoggerInterface
 {
     use LoggerTrait;
 
     private readonly AppLogger $logger;
+    private readonly \Closure $objectProcessor;
 
-    public function __construct(AppLogger $logger)
+    public function __construct(AppLogger $logger, ?callable $processor = null)
     {
         $this->logger = $logger;
+        $this->objectProcessor = ($processor ?? DefaultProcessor::createDefault())(...);
     }
 
     /**
@@ -29,26 +35,29 @@ public function __construct(AppLogger $logger)
      *
      * @link https://www.php-fig.org/psr/psr-3/#5-psrlogloglevel
      */
+    #[\Override]
     public function log($level, \Stringable|string $message, array $context = []): void
     {
         $normalizedLevel = \strtolower(match (true) {
-            \is_string($level),
+            \is_string($level) => $level,
             $level instanceof \Stringable => (string) $level,
             $level instanceof \BackedEnum => (string) $level->value,
             $level instanceof LogLevel => $level->name,
             default => throw new PsrInvalidArgumentException('Invalid log level type provided.'),
         });
 
-        /** @var array<string, mixed> $context */
+        // Process context data for structured logging using the processor manager
+        $processedContext = ($this->objectProcessor)($context);
+
         match ($normalizedLevel) {
             PsrLogLevel::EMERGENCY,
             PsrLogLevel::ALERT,
             PsrLogLevel::CRITICAL,
-            PsrLogLevel::ERROR => $this->logger->error($message, $context),
-            PsrLogLevel::WARNING => $this->logger->warning($message, $context),
-            PsrLogLevel::NOTICE, PsrLogLevel::INFO => $this->logger->info((string) $message, $context),
-            'log' => $this->logger->log((string) $message, $context),
-            PsrLogLevel::DEBUG => $this->logger->debug($message, $context),
+            PsrLogLevel::ERROR => $this->logger->error($message, $processedContext),
+            PsrLogLevel::WARNING => $this->logger->warning($message, $processedContext),
+            PsrLogLevel::NOTICE, PsrLogLevel::INFO => $this->logger->info((string) $message, $processedContext),
+            'log' => $this->logger->log((string) $message, $processedContext),
+            PsrLogLevel::DEBUG => $this->logger->debug($message, $processedContext),
             default => throw new PsrInvalidArgumentException("Invalid log level `$normalizedLevel` provided."),
         };
     }