Enhanced context format

composer.json

@@ -43,7 +43,7 @@
     "scripts": {
         "cs:diff": "php-cs-fixer fix --dry-run -v --diff --show-progress dots",
         "cs:fix": "php-cs-fixer fix -v",
-        "test": "phpunit",
+        "test": "XDEBUG_MODE=coverage phpunit",
         "psalm": "psalm"
     },
     "autoload": {

src/Internal/ContextProcessor/BuiltInTypeProcessor.php

@@ -0,0 +1,54 @@
+<?php
+
+declare(strict_types=1);
+
+namespace RoadRunner\PsrLogger\Internal\ContextProcessor;
+
+/**
+ * Processor for built-in PHP types (null, scalar, array).
+ *
+ * Handles null and scalar values by passing them through as-is since they are already
+ * suitable for structured logging. Arrays are processed recursively to handle nested structures.
+ *
+ * This consolidates the functionality of the former NullProcessor, ScalarProcessor, and ArrayProcessor
+ * for better performance and simpler architecture.
+ *
+ * @internal This class is internal to the PSR Logger implementation and should not be used directly.
+ *
+ * @implements ContextProcessorInterface<null|scalar|array<array-key, mixed>, null|scalar|array<array-key, mixed>>
+ */
+class BuiltInTypeProcessor implements ContextProcessorInterface
+{
+    public function canProcess(mixed $value): bool
+    {
+        return $value === null || \is_scalar($value) || \is_array($value);
+    }
+
+    /**
+     * @param null|scalar|array<array-key, mixed> $value
+     * @param callable(mixed): mixed $recursiveProcessor
+     * @return null|scalar|array<array-key, mixed>
+     */
+    public function process(mixed $value, callable $recursiveProcessor): mixed
+    {
+        // Handle arrays recursively
+        if (\is_array($value)) {
+            /** @var array<array-key, mixed> $processed */
+            $processed = [];
+
+            /**
+             * @var array-key $key
+             * @var mixed $item
+             */
+            foreach ($value as $key => $item) {
+                /** @psalm-suppress MixedAssignment - Intentionally processing mixed types */
+                $processed[$key] = $recursiveProcessor($item);
+            }
+
+            return $processed;
+        }
+
+        // Null and scalar values are already suitable for logging
+        return $value;
+    }
+}

src/Internal/ContextProcessor/ContextProcessorInterface.php

@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace RoadRunner\PsrLogger\Internal\ContextProcessor;
+
+/**
+ * Interface for context data processors.
+ *
+ * Each processor handles a specific type of data and converts it to a
+ * format suitable for structured logging.
+ *
+ * @internal This interface is internal to the PSR Logger implementation and should not be used directly.
+ *
+ * @template TValue The input value type
+ * @template TProcessed The processed output type
+ */
+interface ContextProcessorInterface
+{
+    /**
+     * Check if this processor can handle the given value.
+     */
+    public function canProcess(mixed $value): bool;
+
+    /**
+     * Process the value and return a serializable representation.
+     *
+     * @param TValue $value The value to process
+     * @param callable(mixed): mixed $recursiveProcessor Function to process nested values recursively
+     * @return TProcessed Processed value suitable for logging
+     */
+    public function process(mixed $value, callable $recursiveProcessor): mixed;
+}

src/Internal/ContextProcessor/ContextProcessorManager.php

@@ -0,0 +1,102 @@
+<?php
+
+declare(strict_types=1);
+
+namespace RoadRunner\PsrLogger\Internal\ContextProcessor;
+
+/**
+ * Manager for context data processors.
+ *
+ * Coordinates multiple processors to handle different data types for structured logging.
+ * Processors are executed in registration order, with the first matching processor handling the value.
+ *
+ * @internal This class is internal to the PSR Logger implementation and should not be used directly.
+ */
+class ContextProcessorManager
+{
+    /** @var array<ContextProcessorInterface> */
+    private array $processors = [];
+
+    public function __construct()
+    {
+        $this->registerDefaultProcessors();
+    }
+
+    /**
+     * Register a processor.
+     * Processors are checked in the order they are added.
+     */
+    public function addProcessor(ContextProcessorInterface $processor): void
+    {
+        $this->processors[] = $processor;
+    }
+
+    /**
+     * Process context data recursively.
+     *
+     * @template TKey of array-key
+     * @template TValue
+     * @param array<TKey, TValue> $context
+     * @return array<string, mixed>
+     */
+    public function processContext(array $context): array
+    {
+        if (empty($context)) {
+            return [];
+        }
+
+        /** @var array<string, mixed> $processed */
+        $processed = [];
+
+        /**
+         * @var TKey $key
+         * @var TValue $value
+         */
+        foreach ($context as $key => $value) {
+            $stringKey = (string) $key;
+            /** @psalm-suppress MixedAssignment - Intentionally processing mixed types */
+            $processed[$stringKey] = $this->processValue($value);
+        }
+
+        return $processed;
+    }
+
+    /**
+     * Process a single value using the appropriate processor.
+     */
+    public function processValue(mixed $value): mixed
+    {
+        foreach ($this->processors as $processor) {
+            if ($processor->canProcess($value)) {
+                return $processor->process($value, [$this, 'processValue']);
+            }
+        }
+
+        // This should never happen due to FallbackProcessor, but just in case
+        return \gettype($value);
+    }
+
+    /**
+     * Register the default set of processors in the correct order.
+     * Order matters: more specific processors should be registered first.
+     */
+    private function registerDefaultProcessors(): void
+    {
+        // Built-in PHP types (null, scalar, array) - most common and efficient
+        $this->addProcessor(new BuiltInTypeProcessor());
+
+        // Specific object types (before generic object processor)
+        $this->addProcessor(new DateTimeProcessor());
+        $this->addProcessor(new ThrowableProcessor());
+        $this->addProcessor(new StringableProcessor());
+
+        // Resources
+        $this->addProcessor(new ResourceProcessor());
+
+        // Generic object processor (before fallback)
+        $this->addProcessor(new ObjectProcessor());
+
+        // Fallback processor (last resort)
+        $this->addProcessor(new FallbackProcessor());
+    }
+}

src/Internal/ContextProcessor/DateTimeProcessor.php

@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace RoadRunner\PsrLogger\Internal\ContextProcessor;
+
+/**
+ * Processor for DateTime objects.
+ *
+ * Converts DateTime and DateTimeImmutable objects to ISO 8601 format
+ * for consistent structured logging.
+ *
+ * @internal This class is internal to the PSR Logger implementation and should not be used directly.
+ *
+ * @implements ContextProcessorInterface<\DateTimeInterface, string>
+ */
+class DateTimeProcessor implements ContextProcessorInterface
+{
+    public function canProcess(mixed $value): bool
+    {
+        return $value instanceof \DateTimeInterface;
+    }
+
+    /**
+     * @param \DateTimeInterface $value
+     * @param callable(mixed): mixed $recursiveProcessor
+     * @return string
+     */
+    public function process(mixed $value, callable $recursiveProcessor): mixed
+    {
+        return $value->format(\DateTimeInterface::ATOM);
+    }
+}

src/Internal/ContextProcessor/FallbackProcessor.php

@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace RoadRunner\PsrLogger\Internal\ContextProcessor;
+
+/**
+ * Fallback processor for unknown types.
+ *
+ * Returns the type name for any value that couldn't be processed
+ * by more specific processors.
+ *
+ * @internal This class is internal to the PSR Logger implementation and should not be used directly.
+ *
+ * @implements ContextProcessorInterface<mixed, string>
+ */
+class FallbackProcessor implements ContextProcessorInterface
+{
+    public function canProcess(mixed $value): bool
+    {
+        // This processor can handle anything as a last resort
+        return true;
+    }
+
+    /**
+     * @param callable(mixed): mixed $recursiveProcessor
+     * @return string
+     */
+    public function process(mixed $value, callable $recursiveProcessor): mixed
+    {
+        return \gettype($value);
+    }
+}

src/Internal/ContextProcessor/ObjectProcessor.php

@@ -0,0 +1,51 @@
+<?php
+
+declare(strict_types=1);
+
+namespace RoadRunner\PsrLogger\Internal\ContextProcessor;
+
+/**
+ * Processor for generic objects.
+ *
+ * Attempts to convert objects to array representation using public properties,
+ * or falls back to class name if no public properties are available.
+ *
+ * @internal This class is internal to the PSR Logger implementation and should not be used directly.
+ *
+ * @implements ContextProcessorInterface<object, array<string, mixed>|string>
+ */
+class ObjectProcessor implements ContextProcessorInterface
+{
+    public function canProcess(mixed $value): bool
+    {
+        return \is_object($value);
+    }
+
+    /**
+     * @param object $value
+     * @param callable(mixed): mixed $recursiveProcessor
+     * @return array<string, mixed>|string
+     */
+    public function process(mixed $value, callable $recursiveProcessor): mixed
+    {
+        // Try to convert to array (for objects with public properties)
+        $objectVars = \get_object_vars($value);
+
+        if (!empty($objectVars)) {
+            /** @var array<string, mixed> $processed */
+            $processed = [];
+            /**
+             * @var string $property
+             * @var mixed $propertyValue
+             */
+            foreach ($objectVars as $property => $propertyValue) {
+                /** @psalm-suppress MixedAssignment - Intentionally processing mixed types */
+                $processed[$property] = $recursiveProcessor($propertyValue);
+            }
+            return $processed;
+        }
+
+        // Fallback to class name if no public properties
+        return \get_class($value);
+    }
+}

src/Internal/ContextProcessor/ResourceProcessor.php

@@ -0,0 +1,32 @@
+<?php
+
+declare(strict_types=1);
+
+namespace RoadRunner\PsrLogger\Internal\ContextProcessor;
+
+/**
+ * Processor for resource types.
+ *
+ * Converts resources to string representation indicating the resource type.
+ *
+ * @internal This class is internal to the PSR Logger implementation and should not be used directly.
+ *
+ * @implements ContextProcessorInterface<resource, string>
+ */
+class ResourceProcessor implements ContextProcessorInterface
+{
+    public function canProcess(mixed $value): bool
+    {
+        return \is_resource($value);
+    }
+
+    /**
+     * @param resource $value
+     * @param callable(mixed): mixed $recursiveProcessor
+     * @return string
+     */
+    public function process(mixed $value, callable $recursiveProcessor): mixed
+    {
+        return \get_resource_type($value) . ' resource';
+    }
+}

src/Internal/ContextProcessor/StringableProcessor.php

@@ -0,0 +1,32 @@
+<?php
+
+declare(strict_types=1);
+
+namespace RoadRunner\PsrLogger\Internal\ContextProcessor;
+
+/**
+ * Processor for objects implementing the Stringable interface.
+ *
+ * Converts Stringable objects to their string representation.
+ *
+ * @internal This class is internal to the PSR Logger implementation and should not be used directly.
+ *
+ * @implements ContextProcessorInterface<\Stringable, string>
+ */
+class StringableProcessor implements ContextProcessorInterface
+{
+    public function canProcess(mixed $value): bool
+    {
+        return $value instanceof \Stringable;
+    }
+
+    /**
+     * @param \Stringable $value
+     * @param callable(mixed): mixed $recursiveProcessor
+     * @return string
+     */
+    public function process(mixed $value, callable $recursiveProcessor): mixed
+    {
+        return (string) $value;
+    }
+}