New default implementation of logger shared by default between master…

… and child processes

src/Internal/ErrorHandler.php

@@ -6,6 +6,7 @@
 
 use Psr\Log\LoggerInterface;
 use Psr\Log\LogLevel;
+use Psr\Log\NullLogger;
 
 /**
  * @internal
@@ -30,32 +31,35 @@ final class ErrorHandler
         \E_CORE_ERROR => ['Core Error', LogLevel::CRITICAL],
     ];
 
-    private static LoggerInterface|null $logger = null;
+    private static bool $registered = false;
+    private static LoggerInterface $logger;
 
     private function __construct()
     {
     }
 
     public static function register(LoggerInterface $logger): void
     {
-        if (self::$logger !== null) {
+        if (self::$registered === true) {
             throw new \LogicException(\sprintf('%s(): Already registered', __METHOD__));
         }
 
+        self::$registered = true;
         self::$logger = $logger;
         \set_error_handler(self::handleError(...));
         \set_exception_handler(self::handleException(...));
     }
 
     public static function unregister(): void
     {
-        if (self::$logger === null) {
+        if (self::$registered === false) {
             return;
         }
 
         \restore_error_handler();
         \restore_exception_handler();
-        self::$logger = null;
+        self::$registered = false;
+        self::$logger = new NullLogger();
     }
 
     /**
@@ -78,7 +82,7 @@ private static function handleError(int $type, string $message, string $file, in
 
     public static function handleException(\Throwable $exception): void
     {
-        if (self::$logger === null) {
+        if (self::$registered === false) {
             throw new \LogicException(\sprintf('%s(): ErrorHandler is unregistered', __METHOD__), 0, $exception);
         }
 

src/Internal/Logger/ConsoleLogger.php

@@ -4,11 +4,9 @@
 
 namespace Luzrain\PHPStreamServer\Internal\Logger;
 
-use Amp\ByteStream\ResourceStream;
-use Amp\ByteStream\WritableStream;
 use Luzrain\PHPStreamServer\Internal\Console\Colorizer;
-use Psr\Log\LoggerInterface;
 use Psr\Log\LoggerTrait;
+use function Amp\ByteStream\getStderr;
 
 /**
  * @internal
@@ -17,35 +15,57 @@ final class ConsoleLogger implements LoggerInterface
 {
     use LoggerTrait;
 
-    private readonly WritableStream $stream;
-    private readonly FormatterInterface $formatter;
-    private bool $colorSupport = false;
+    public const DEFAULT_JSON_FLAGS = JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE | JSON_PRESERVE_ZERO_FRACTION | JSON_INVALID_UTF8_SUBSTITUTE | JSON_PARTIAL_OUTPUT_ON_ERROR | JSON_FORCE_OBJECT;
 
-    public function __construct(WritableStream $stream)
+    private const LEVELS_COLOR_MAP = [
+        'debug' => 'fg=15',
+        'info' => 'fg=116',
+        'notice' => 'fg=38',
+        'warning' => 'fg=yellow',
+        'error' => 'fg=red',
+        'critical' => 'fg=red',
+        'alert' => 'fg=red',
+        'emergency' => 'bg=red',
+    ];
+
+    private ContextNormalizer $contextNormalizer;
+    private bool $colorSupport;
+    private string $channel = 'server';
+
+    public function __construct()
+    {
+        $this->contextNormalizer = new ContextNormalizer();
+        $this->colorSupport = Colorizer::hasColorSupport(getStderr()->getResource());
+    }
+
+    public function withChannel(string $channel): self
     {
-        $this->stream = $stream;
-        $this->formatter = new ConsoleFormatter();
+        $that = clone $this;
+        $that->channel = $channel;
 
-        if ($stream instanceof ResourceStream) {
-            $this->colorSupport = Colorizer::hasColorSupport($stream->getResource());
-        }
+        return $that;
     }
 
     public function log(mixed $level, string|\Stringable $message, array $context = []): void
     {
-        $this->doLog(new LogEntry(
-            time: new \DateTimeImmutable(),
-            level: $level,
-            channel: 'app',
-            message: (string) $message,
-            context: $context,
+        $time = (new \DateTimeImmutable('now'))->format(\DateTimeInterface::RFC3339);
+        $level = (string) $level;
+        $message = (string) $message;
+        $context = $this->contextNormalizer->normalize($context);
+        $context = $context === [] ? '' : \json_encode($this->contextNormalizer->normalize($context), self::DEFAULT_JSON_FLAGS);
+
+        $message = \rtrim(\sprintf(
+            "[%s] <color;fg=green>%s</>.<color;%s>%s</> %s %s",
+            $time,
+            $this->channel,
+            self::LEVELS_COLOR_MAP[\strtolower($level)] ?? 'fg=gray',
+            \strtoupper($level),
+            $message,
+            $context,
         ));
-    }
 
-    private function doLog(LogEntry $logEntry): void
-    {
-        $message = $this->formatter->format($logEntry);
         $message = $this->colorSupport ? Colorizer::colorize($message) : Colorizer::stripTags($message);
-        $this->stream->write($message . PHP_EOL);
+
+        getStderr()->write($message . PHP_EOL);
     }
 }

src/Internal/Logger/ContextNormalizer.php

@@ -9,58 +9,74 @@
  */
 final class ContextNormalizer
 {
-    private function __construct()
+    public function __construct()
     {
     }
 
-    /**
-     * @param array<string, mixed> $context
-     * @return array<string, string>
-     */
-    public static function normalize(array $context): array
+    public function normalize(mixed $data): mixed
     {
-        foreach ($context as $key => $val) {
-            $context[$key] = match(true) {
-                \is_array($val) => self::normalize($val),
-                $val instanceof \Throwable => self::formatException($val),
-                $val instanceof \DateTimeInterface => $val->format(\DateTimeInterface::RFC3339),
-                $val instanceof \JsonSerializable => \json_decode($val->jsonSerialize()),
-                $val instanceof \Stringable => (string) $val,
-                \is_scalar($val) || \is_null($val) => $val,
-                \is_object($val) => '[object ' . $val::class . ']',
-                default => '[' . \get_debug_type($val) . ']',
-            };
+        if (\is_array($data)) {
+            foreach ($data as $key => $value) {
+                $data[$key] = $this->normalize($value);
+            }
+
+            return $data;
+        }
+
+        if (\is_null($data) || \is_scalar($data)) {
+            return $data;
+        }
+
+        if ($data instanceof \Throwable) {
+            return $this->normalizeException($data);
+        }
+
+        if ($data instanceof \JsonSerializable) {
+            return $data->jsonSerialize();
+        }
+
+        if ($data instanceof \Stringable) {
+            return $data->__toString();
+        }
+
+        if ($data instanceof \DateTimeInterface) {
+            return $data->format(\DateTimeInterface::RFC3339);
+        }
+
+        if (\is_object($data)) {
+            return \sprintf('[object(%s)]', $data::class);
         }
 
-        return $context;
+        if (\is_resource($data)) {
+            return \sprintf('[resource(%s)]', \get_resource_type($data));
+        }
+
+        return \sprintf('[unknown(%s)]', \get_debug_type($data));
     }
 
-    /**
-     * @param array<string, string> $context
-     */
-    public static function contextreplacement(string $message, array $context): string
+    private function normalizeException(\Throwable $e): string
     {
-        if (\str_contains($message, '{')) {
-            $replacements = [];
-            foreach ($context as $key => $val) {
-                $replacements["{{$key}}"] = \is_array($val) ? '[array]' : (string) $val;
-            }
-            $message = \strtr($message, $replacements);
+        $str = $this->formatException($e, 'object');
+
+        if (null !== $previous = $e->getPrevious()) {
+            do {
+                $str .= "\n" . $this->formatException($previous, 'previous');
+            } while (null !== $previous = $previous->getPrevious());
         }
 
-        return $message;
+        return $str;
     }
 
-    private static function formatException(\Throwable $e): string
+    private function formatException(\Throwable $e, string $objectTitle): string
     {
         return \sprintf(
-            "[object] (%s(code:%d): %s at %s:%d)\n[stacktrace]\n%s",
+            "[%s(%s) code:%d]: %s at %s:%d",
+            $objectTitle,
             $e::class,
             $e->getCode(),
             $e->getMessage(),
             $e->getFile(),
             $e->getLine(),
-            $e->getTraceAsString(),
         );
     }
 }

src/Internal/Logger/LoggerInterface.php

@@ -0,0 +1,10 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Luzrain\PHPStreamServer\Internal\Logger;
+
+interface LoggerInterface extends \Psr\Log\LoggerInterface
+{
+    public function withChannel(string $channel): self;
+}

src/Internal/Logger/NullLogger.php

@@ -4,7 +4,6 @@
 
 namespace Luzrain\PHPStreamServer\Internal\Logger;
 
-use Psr\Log\LoggerInterface;
 use Psr\Log\LoggerTrait;
 
 /**
@@ -18,7 +17,13 @@ public function __construct()
     {
     }
 
+    public function withChannel(string $channel): self
+    {
+        return $this;
+    }
+
     public function log(mixed $level, string|\Stringable $message, array $context = []): void
     {
+        // do nothing
     }
 }