migration symfony 5 4 (#300)

* symfony 5.4 (diff dev)

* symfony 5.4 (working)

* symfony 5.4 (update autoload)

* symfony 5.4 (remove swiftmailer mailer implementation)

* symfony 5.4 (php doc and split Global accessor class)


### Impacted packages:

composer require php:">=7.2.5 <8.0.0" symfony/console:5.4.* symfony/dotenv:5.4.* symfony/framework-bundle:5.4.* symfony/twig-bundle:5.4.* symfony/yaml:5.4.* --update-with-dependencies

composer require symfony/stopwatch:5.4.* symfony/web-profiler-bundle:5.4.* --dev --update-with-dependencies

lib/symfony/http-kernel/DataCollector/LoggerDataCollector.php

@@ -11,40 +11,41 @@
 
 namespace Symfony\Component\HttpKernel\DataCollector;
 
-use Symfony\Component\Debug\Exception\SilencedErrorContext;
+use Symfony\Component\ErrorHandler\Exception\SilencedErrorContext;
 use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpFoundation\RequestStack;
 use Symfony\Component\HttpFoundation\Response;
 use Symfony\Component\HttpKernel\Log\DebugLoggerInterface;
 
 /**
- * LogDataCollector.
- *
  * @author Fabien Potencier <fabien@symfony.com>
+ *
+ * @final
  */
 class LoggerDataCollector extends DataCollector implements LateDataCollectorInterface
 {
     private $logger;
     private $containerPathPrefix;
+    private $currentRequest;
+    private $requestStack;
+    private $processedLogs;
 
-    public function __construct($logger = null, $containerPathPrefix = null)
+    public function __construct(object $logger = null, string $containerPathPrefix = null, RequestStack $requestStack = null)
     {
         if (null !== $logger && $logger instanceof DebugLoggerInterface) {
-            if (!method_exists($logger, 'clear')) {
-                @trigger_error(sprintf('Implementing "%s" without the "clear()" method is deprecated since Symfony 3.4 and will be unsupported in 4.0 for class "%s".', DebugLoggerInterface::class, \get_class($logger)), \E_USER_DEPRECATED);
-            }
-
             $this->logger = $logger;
         }
 
         $this->containerPathPrefix = $containerPathPrefix;
+        $this->requestStack = $requestStack;
     }
 
     /**
      * {@inheritdoc}
      */
-    public function collect(Request $request, Response $response, \Exception $exception = null)
+    public function collect(Request $request, Response $response, \Throwable $exception = null)
     {
-        // everything is done as late as possible
+        $this->currentRequest = $this->requestStack && $this->requestStack->getMainRequest() !== $request ? $request : null;
     }
 
     /**
@@ -52,7 +53,7 @@ class LoggerDataCollector extends DataCollector implements LateDataCollectorInte
      */
     public function reset()
     {
-        if ($this->logger && method_exists($this->logger, 'clear')) {
+        if ($this->logger instanceof DebugLoggerInterface) {
             $this->logger->clear();
         }
         $this->data = [];
@@ -66,58 +67,137 @@ class LoggerDataCollector extends DataCollector implements LateDataCollectorInte
         if (null !== $this->logger) {
             $containerDeprecationLogs = $this->getContainerDeprecationLogs();
             $this->data = $this->computeErrorsCount($containerDeprecationLogs);
-            $this->data['compiler_logs'] = $this->getContainerCompilerLogs();
-            $this->data['logs'] = $this->sanitizeLogs(array_merge($this->logger->getLogs(), $containerDeprecationLogs));
+            // get compiler logs later (only when they are needed) to improve performance
+            $this->data['compiler_logs'] = [];
+            $this->data['compiler_logs_filepath'] = $this->containerPathPrefix.'Compiler.log';
+            $this->data['logs'] = $this->sanitizeLogs(array_merge($this->logger->getLogs($this->currentRequest), $containerDeprecationLogs));
             $this->data = $this->cloneVar($this->data);
         }
+        $this->currentRequest = null;
     }
 
     public function getLogs()
     {
-        return isset($this->data['logs']) ? $this->data['logs'] : [];
+        return $this->data['logs'] ?? [];
+    }
+
+    public function getProcessedLogs()
+    {
+        if (null !== $this->processedLogs) {
+            return $this->processedLogs;
+        }
+
+        $rawLogs = $this->getLogs();
+        if ([] === $rawLogs) {
+            return $this->processedLogs = $rawLogs;
+        }
+
+        $logs = [];
+        foreach ($this->getLogs()->getValue() as $rawLog) {
+            $rawLogData = $rawLog->getValue();
+
+            if ($rawLogData['priority']->getValue() > 300) {
+                $logType = 'error';
+            } elseif (isset($rawLogData['scream']) && false === $rawLogData['scream']->getValue()) {
+                $logType = 'deprecation';
+            } elseif (isset($rawLogData['scream']) && true === $rawLogData['scream']->getValue()) {
+                $logType = 'silenced';
+            } else {
+                $logType = 'regular';
+            }
+
+            $logs[] = [
+                'type' => $logType,
+                'errorCount' => $rawLog['errorCount'] ?? 1,
+                'timestamp' => $rawLogData['timestamp_rfc3339']->getValue(),
+                'priority' => $rawLogData['priority']->getValue(),
+                'priorityName' => $rawLogData['priorityName']->getValue(),
+                'channel' => $rawLogData['channel']->getValue(),
+                'message' => $rawLogData['message'],
+                'context' => $rawLogData['context'],
+            ];
+        }
+
+        // sort logs from oldest to newest
+        usort($logs, static function ($logA, $logB) {
+            return $logA['timestamp'] <=> $logB['timestamp'];
+        });
+
+        return $this->processedLogs = $logs;
+    }
+
+    public function getFilters()
+    {
+        $filters = [
+            'channel' => [],
+            'priority' => [
+                'Debug' => 100,
+                'Info' => 200,
+                'Notice' => 250,
+                'Warning' => 300,
+                'Error' => 400,
+                'Critical' => 500,
+                'Alert' => 550,
+                'Emergency' => 600,
+            ],
+        ];
+
+        $allChannels = [];
+        foreach ($this->getProcessedLogs() as $log) {
+            if ('' === trim($log['channel'])) {
+                continue;
+            }
+
+            $allChannels[] = $log['channel'];
+        }
+        $channels = array_unique($allChannels);
+        sort($channels);
+        $filters['channel'] = $channels;
+
+        return $filters;
     }
 
     public function getPriorities()
     {
-        return isset($this->data['priorities']) ? $this->data['priorities'] : [];
+        return $this->data['priorities'] ?? [];
     }
 
     public function countErrors()
     {
-        return isset($this->data['error_count']) ? $this->data['error_count'] : 0;
+        return $this->data['error_count'] ?? 0;
     }
 
     public function countDeprecations()
     {
-        return isset($this->data['deprecation_count']) ? $this->data['deprecation_count'] : 0;
+        return $this->data['deprecation_count'] ?? 0;
     }
 
     public function countWarnings()
     {
-        return isset($this->data['warning_count']) ? $this->data['warning_count'] : 0;
+        return $this->data['warning_count'] ?? 0;
     }
 
     public function countScreams()
     {
-        return isset($this->data['scream_count']) ? $this->data['scream_count'] : 0;
+        return $this->data['scream_count'] ?? 0;
     }
 
     public function getCompilerLogs()
     {
-        return isset($this->data['compiler_logs']) ? $this->data['compiler_logs'] : [];
+        return $this->cloneVar($this->getContainerCompilerLogs($this->data['compiler_logs_filepath'] ?? null));
     }
 
     /**
      * {@inheritdoc}
      */
-    public function getName()
+    public function getName(): string
     {
         return 'logger';
     }
 
-    private function getContainerDeprecationLogs()
+    private function getContainerDeprecationLogs(): array
     {
-        if (null === $this->containerPathPrefix || !file_exists($file = $this->containerPathPrefix.'Deprecations.log')) {
+        if (null === $this->containerPathPrefix || !is_file($file = $this->containerPathPrefix.'Deprecations.log')) {
             return [];
         }
 
@@ -130,9 +210,10 @@ class LoggerDataCollector extends DataCollector implements LateDataCollectorInte
         foreach (unserialize($logContent) as $log) {
             $log['context'] = ['exception' => new SilencedErrorContext($log['type'], $log['file'], $log['line'], $log['trace'], $log['count'])];
             $log['timestamp'] = $bootTime;
+            $log['timestamp_rfc3339'] = (new \DateTimeImmutable())->setTimestamp($bootTime)->format(\DateTimeInterface::RFC3339_EXTENDED);
             $log['priority'] = 100;
             $log['priorityName'] = 'DEBUG';
-            $log['channel'] = '-';
+            $log['channel'] = null;
             $log['scream'] = false;
             unset($log['type'], $log['file'], $log['line'], $log['trace'], $log['trace'], $log['count']);
             $logs[] = $log;
@@ -141,14 +222,14 @@ class LoggerDataCollector extends DataCollector implements LateDataCollectorInte
         return $logs;
     }
 
-    private function getContainerCompilerLogs()
+    private function getContainerCompilerLogs(string $compilerLogsFilepath = null): array
     {
-        if (null === $this->containerPathPrefix || !file_exists($file = $this->containerPathPrefix.'Compiler.log')) {
+        if (!is_file($compilerLogsFilepath)) {
             return [];
         }
 
         $logs = [];
-        foreach (file($file, \FILE_IGNORE_NEW_LINES) as $log) {
+        foreach (file($compilerLogsFilepath, \FILE_IGNORE_NEW_LINES) as $log) {
             $log = explode(': ', $log, 2);
             if (!isset($log[1]) || !preg_match('/^[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*+(?:\\\\[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*+)++$/', $log[0])) {
                 $log = ['Unknown Compiler Pass', implode(': ', $log)];
@@ -160,7 +241,7 @@ class LoggerDataCollector extends DataCollector implements LateDataCollectorInte
         return $logs;
     }
 
-    private function sanitizeLogs($logs)
+    private function sanitizeLogs(array $logs)
     {
         $sanitizedLogs = [];
         $silencedLogs = [];
@@ -209,7 +290,7 @@ class LoggerDataCollector extends DataCollector implements LateDataCollectorInte
         return array_values($sanitizedLogs);
     }
 
-    private function isSilencedOrDeprecationErrorLog(array $log)
+    private function isSilencedOrDeprecationErrorLog(array $log): bool
     {
         if (!isset($log['context']['exception'])) {
             return false;
@@ -228,18 +309,18 @@ class LoggerDataCollector extends DataCollector implements LateDataCollectorInte
         return false;
     }
 
-    private function computeErrorsCount(array $containerDeprecationLogs)
+    private function computeErrorsCount(array $containerDeprecationLogs): array
     {
         $silencedLogs = [];
         $count = [
-            'error_count' => $this->logger->countErrors(),
+            'error_count' => $this->logger->countErrors($this->currentRequest),
             'deprecation_count' => 0,
             'warning_count' => 0,
             'scream_count' => 0,
             'priorities' => [],
         ];
 
-        foreach ($this->logger->getLogs() as $log) {
+        foreach ($this->logger->getLogs($this->currentRequest) as $log) {
             if (isset($count['priorities'][$log['priority']])) {
                 ++$count['priorities'][$log['priority']]['count'];
             } else {