Deprecated: Constant E_STRICT is deprecated in /home/pastorz/old-espace-client/vendor/symfony/error-handler/ErrorHandler.php on line 58

Deprecated: Constant E_STRICT is deprecated in /home/pastorz/old-espace-client/vendor/symfony/error-handler/ErrorHandler.php on line 76
Symfony Profiler

vendor/symfony/http-kernel/DataCollector/LoggerDataCollector.php line 225

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <fabien@symfony.com>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Symfony\Component\HttpKernel\DataCollector;
  14. use Symfony\Component\ErrorHandler\Exception\SilencedErrorContext;
  15. use Symfony\Component\HttpFoundation\Request;
  16. use Symfony\Component\HttpFoundation\RequestStack;
  17. use Symfony\Component\HttpFoundation\Response;
  18. use Symfony\Component\HttpKernel\Log\DebugLoggerInterface;
  20. /**
  21.  * @author Fabien Potencier <fabien@symfony.com>
  22.  *
  23.  * @final
  24.  */
  25. class LoggerDataCollector extends DataCollector implements LateDataCollectorInterface
  26. {
  27.     private $logger;
  28.     private $containerPathPrefix;
  29.     private $currentRequest;
  30.     private $requestStack;
  31.     private $processedLogs;
  33.     public function __construct(object $logger = null, string $containerPathPrefix = null, RequestStack $requestStack = null)
  34.     {
  35.         if (null !== $logger && $logger instanceof DebugLoggerInterface) {
  36.             $this->logger = $logger;
  37.         }
  39.         $this->containerPathPrefix = $containerPathPrefix;
  40.         $this->requestStack = $requestStack;
  41.     }
  43.     /**
  44.      * {@inheritdoc}
  45.      */
  46.     public function collect(Request $request, Response $response, \Throwable $exception = null)
  47.     {
  48.         $this->currentRequest = $this->requestStack && $this->requestStack->getMainRequest() !== $request ? $request : null;
  49.     }
  51.     /**
  52.      * {@inheritdoc}
  53.      */
  54.     public function reset()
  55.     {
  56.         if ($this->logger instanceof DebugLoggerInterface) {
  57.             $this->logger->clear();
  58.         }
  59.         $this->data = [];
  60.     }
  62.     /**
  63.      * {@inheritdoc}
  64.      */
  65.     public function lateCollect()
  66.     {
  67.         if (null !== $this->logger) {
  68.             $containerDeprecationLogs = $this->getContainerDeprecationLogs();
  69.             $this->data = $this->computeErrorsCount($containerDeprecationLogs);
  70.             // get compiler logs later (only when they are needed) to improve performance
  71.             $this->data['compiler_logs'] = [];
  72.             $this->data['compiler_logs_filepath'] = $this->containerPathPrefix.'Compiler.log';
  73.             $this->data['logs'] = $this->sanitizeLogs(array_merge($this->logger->getLogs($this->currentRequest), $containerDeprecationLogs));
  74.             $this->data = $this->cloneVar($this->data);
  75.         }
  76.         $this->currentRequest = null;
  77.     }
  79.     public function getLogs()
  80.     {
  81.         return $this->data['logs'] ?? [];
  82.     }
  84.     public function getProcessedLogs()
  85.     {
  86.         if (null !== $this->processedLogs) {
  87.             return $this->processedLogs;
  88.         }
  90.         $rawLogs = $this->getLogs();
  91.         if ([] === $rawLogs) {
  92.             return $this->processedLogs = $rawLogs;
  93.         }
  95.         $logs = [];
  96.         foreach ($this->getLogs()->getValue() as $rawLog) {
  97.             $rawLogData = $rawLog->getValue();
  99.             if ($rawLogData['priority']->getValue() > 300) {
  100.                 $logType = 'error';
  101.             } elseif (isset($rawLogData['scream']) && false === $rawLogData['scream']->getValue()) {
  102.                 $logType = 'deprecation';
  103.             } elseif (isset($rawLogData['scream']) && true === $rawLogData['scream']->getValue()) {
  104.                 $logType = 'silenced';
  105.             } else {
  106.                 $logType = 'regular';
  107.             }
  109.             $logs[] = [
  110.                 'type' => $logType,
  111.                 'errorCount' => $rawLog['errorCount'] ?? 1,
  112.                 'timestamp' => $rawLogData['timestamp_rfc3339']->getValue(),
  113.                 'priority' => $rawLogData['priority']->getValue(),
  114.                 'priorityName' => $rawLogData['priorityName']->getValue(),
  115.                 'channel' => $rawLogData['channel']->getValue(),
  116.                 'message' => $rawLogData['message'],
  117.                 'context' => $rawLogData['context'],
  118.             ];
  119.         }
  121.         // sort logs from oldest to newest
  122.         usort($logs, static function ($logA, $logB) {
  123.             return $logA['timestamp'] <=> $logB['timestamp'];
  124.         });
  126.         return $this->processedLogs = $logs;
  127.     }
  129.     public function getFilters()
  130.     {
  131.         $filters = [
  132.             'channel' => [],
  133.             'priority' => [
  134.                 'Debug' => 100,
  135.                 'Info' => 200,
  136.                 'Notice' => 250,
  137.                 'Warning' => 300,
  138.                 'Error' => 400,
  139.                 'Critical' => 500,
  140.                 'Alert' => 550,
  141.                 'Emergency' => 600,
  142.             ],
  143.         ];
  145.         $allChannels = [];
  146.         foreach ($this->getProcessedLogs() as $log) {
  147.             if ('' === trim($log['channel'] ?? '')) {
  148.                 continue;
  149.             }
  151.             $allChannels[] = $log['channel'];
  152.         }
  153.         $channels = array_unique($allChannels);
  154.         sort($channels);
  155.         $filters['channel'] = $channels;
  157.         return $filters;
  158.     }
  160.     public function getPriorities()
  161.     {
  162.         return $this->data['priorities'] ?? [];
  163.     }
  165.     public function countErrors()
  166.     {
  167.         return $this->data['error_count'] ?? 0;
  168.     }
  170.     public function countDeprecations()
  171.     {
  172.         return $this->data['deprecation_count'] ?? 0;
  173.     }
  175.     public function countWarnings()
  176.     {
  177.         return $this->data['warning_count'] ?? 0;
  178.     }
  180.     public function countScreams()
  181.     {
  182.         return $this->data['scream_count'] ?? 0;
  183.     }
  185.     public function getCompilerLogs()
  186.     {
  187.         return $this->cloneVar($this->getContainerCompilerLogs($this->data['compiler_logs_filepath'] ?? null));
  188.     }
  190.     /**
  191.      * {@inheritdoc}
  192.      */
  193.     public function getName(): string
  194.     {
  195.         return 'logger';
  196.     }
  198.     private function getContainerDeprecationLogs(): array
  199.     {
  200.         if (null === $this->containerPathPrefix || !is_file($file = $this->containerPathPrefix.'Deprecations.log')) {
  201.             return [];
  202.         }
  204.         if ('' === $logContent = trim(file_get_contents($file))) {
  205.             return [];
  206.         }
  208.         $bootTime = filemtime($file);
  209.         $logs = [];
  210.         foreach (unserialize($logContent) as $log) {
  211.             $log['context'] = ['exception' => new SilencedErrorContext($log['type'], $log['file'], $log['line'], $log['trace'], $log['count'])];
  212.             $log['timestamp'] = $bootTime;
  213.             $log['timestamp_rfc3339'] = (new \DateTimeImmutable())->setTimestamp($bootTime)->format(\DateTimeInterface::RFC3339_EXTENDED);
  214.             $log['priority'] = 100;
  215.             $log['priorityName'] = 'DEBUG';
  216.             $log['channel'] = null;
  217.             $log['scream'] = false;
  218.             unset($log['type'], $log['file'], $log['line'], $log['trace'], $log['trace'], $log['count']);
  219.             $logs[] = $log;
  220.         }
  222.         return $logs;
  223.     }
  225.     private function getContainerCompilerLogs(string $compilerLogsFilepath = null): array
  226.     {
  227.         if (!is_file($compilerLogsFilepath)) {
  228.             return [];
  229.         }
  231.         $logs = [];
  232.         foreach (file($compilerLogsFilepath, \FILE_IGNORE_NEW_LINES) as $log) {
  233.             $log = explode(': ', $log, 2);
  234.             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])) {
  235.                 $log = ['Unknown Compiler Pass', implode(': ', $log)];
  236.             }
  238.             $logs[$log[0]][] = ['message' => $log[1]];
  239.         }
  241.         return $logs;
  242.     }
  244.     private function sanitizeLogs(array $logs)
  245.     {
  246.         $sanitizedLogs = [];
  247.         $silencedLogs = [];
  249.         foreach ($logs as $log) {
  250.             if (!$this->isSilencedOrDeprecationErrorLog($log)) {
  251.                 $sanitizedLogs[] = $log;
  253.                 continue;
  254.             }
  256.             $message = '_'.$log['message'];
  257.             $exception = $log['context']['exception'];
  259.             if ($exception instanceof SilencedErrorContext) {
  260.                 if (isset($silencedLogs[$h = spl_object_hash($exception)])) {
  261.                     continue;
  262.                 }
  263.                 $silencedLogs[$h] = true;
  265.                 if (!isset($sanitizedLogs[$message])) {
  266.                     $sanitizedLogs[$message] = $log + [
  267.                         'errorCount' => 0,
  268.                         'scream' => true,
  269.                     ];
  270.                 }
  271.                 $sanitizedLogs[$message]['errorCount'] += $exception->count;
  273.                 continue;
  274.             }
  276.             $errorId = md5("{$exception->getSeverity()}/{$exception->getLine()}/{$exception->getFile()}\0{$message}", true);
  278.             if (isset($sanitizedLogs[$errorId])) {
  279.                 ++$sanitizedLogs[$errorId]['errorCount'];
  280.             } else {
  281.                 $log += [
  282.                     'errorCount' => 1,
  283.                     'scream' => false,
  284.                 ];
  286.                 $sanitizedLogs[$errorId] = $log;
  287.             }
  288.         }
  290.         return array_values($sanitizedLogs);
  291.     }
  293.     private function isSilencedOrDeprecationErrorLog(array $log): bool
  294.     {
  295.         if (!isset($log['context']['exception'])) {
  296.             return false;
  297.         }
  299.         $exception = $log['context']['exception'];
  301.         if ($exception instanceof SilencedErrorContext) {
  302.             return true;
  303.         }
  305.         if ($exception instanceof \ErrorException && \in_array($exception->getSeverity(), [\E_DEPRECATED, \E_USER_DEPRECATED], true)) {
  306.             return true;
  307.         }
  309.         return false;
  310.     }
  312.     private function computeErrorsCount(array $containerDeprecationLogs): array
  313.     {
  314.         $silencedLogs = [];
  315.         $count = [
  316.             'error_count' => $this->logger->countErrors($this->currentRequest),
  317.             'deprecation_count' => 0,
  318.             'warning_count' => 0,
  319.             'scream_count' => 0,
  320.             'priorities' => [],
  321.         ];
  323.         foreach ($this->logger->getLogs($this->currentRequest) as $log) {
  324.             if (isset($count['priorities'][$log['priority']])) {
  325.                 ++$count['priorities'][$log['priority']]['count'];
  326.             } else {
  327.                 $count['priorities'][$log['priority']] = [
  328.                     'count' => 1,
  329.                     'name' => $log['priorityName'],
  330.                 ];
  331.             }
  332.             if ('WARNING' === $log['priorityName']) {
  333.                 ++$count['warning_count'];
  334.             }
  336.             if ($this->isSilencedOrDeprecationErrorLog($log)) {
  337.                 $exception = $log['context']['exception'];
  338.                 if ($exception instanceof SilencedErrorContext) {
  339.                     if (isset($silencedLogs[$h = spl_object_hash($exception)])) {
  340.                         continue;
  341.                     }
  342.                     $silencedLogs[$h] = true;
  343.                     $count['scream_count'] += $exception->count;
  344.                 } else {
  345.                     ++$count['deprecation_count'];
  346.                 }
  347.             }
  348.         }
  350.         foreach ($containerDeprecationLogs as $deprecationLog) {
  351.             $count['deprecation_count'] += $deprecationLog['context']['exception']->count;
  352.         }
  354.         ksort($count['priorities']);
  356.         return $count;
  357.     }
  358. }