vendor/symfony/serializer/DataCollector/SerializerDataCollector.php line 36

  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\Serializer\DataCollector;
  14. use Symfony\Component\HttpFoundation\Request;
  15. use Symfony\Component\HttpFoundation\Response;
  16. use Symfony\Component\HttpKernel\DataCollector\DataCollector;
  17. use Symfony\Component\HttpKernel\DataCollector\LateDataCollectorInterface;
  18. use Symfony\Component\Serializer\Debug\TraceableSerializer;
  19. use Symfony\Component\VarDumper\Cloner\Data;
  21. /**
  22.  * @author Mathias Arlaud <mathias.arlaud@gmail.com>
  23.  *
  24.  * @internal
  25.  */
  26. class SerializerDataCollector extends DataCollector implements LateDataCollectorInterface
  27. {
  28.     private array $collected = [];
  30.     public function reset(): void
  31.     {
  32.         $this->data = [];
  33.         $this->collected = [];
  34.     }
  36.     public function collect(Request $request, Response $response, \Throwable $exception = null): void
  37.     {
  38.         // Everything is collected during the request, and formatted on kernel terminate.
  39.     }
  41.     public function getName(): string
  42.     {
  43.         return 'serializer';
  44.     }
  46.     public function getData(): Data|array
  47.     {
  48.         return $this->data;
  49.     }
  51.     public function getHandledCount(): int
  52.     {
  53.         return array_sum(array_map('count', $this->data));
  54.     }
  56.     public function getTotalTime(): float
  57.     {
  58.         $totalTime = 0;
  60.         foreach ($this->data as $handled) {
  61.             $totalTime += array_sum(array_map(fn (array $el): float => $el['time'], $handled));
  62.         }
  64.         return $totalTime;
  65.     }
  67.     public function collectSerialize(string $traceId, mixed $data, string $format, array $context, float $time, array $caller): void
  68.     {
  69.         unset($context[TraceableSerializer::DEBUG_TRACE_ID]);
  71.         $this->collected[$traceId] = array_merge(
  72.             $this->collected[$traceId] ?? [],
  73.             compact('data', 'format', 'context', 'time', 'caller'),
  74.             ['method' => 'serialize'],
  75.         );
  76.     }
  78.     public function collectDeserialize(string $traceId, mixed $data, string $type, string $format, array $context, float $time, array $caller): void
  79.     {
  80.         unset($context[TraceableSerializer::DEBUG_TRACE_ID]);
  82.         $this->collected[$traceId] = array_merge(
  83.             $this->collected[$traceId] ?? [],
  84.             compact('data', 'format', 'type', 'context', 'time', 'caller'),
  85.             ['method' => 'deserialize'],
  86.         );
  87.     }
  89.     public function collectNormalize(string $traceId, mixed $data, ?string $format, array $context, float $time, array $caller): void
  90.     {
  91.         unset($context[TraceableSerializer::DEBUG_TRACE_ID]);
  93.         $this->collected[$traceId] = array_merge(
  94.             $this->collected[$traceId] ?? [],
  95.             compact('data', 'format', 'context', 'time', 'caller'),
  96.             ['method' => 'normalize'],
  97.         );
  98.     }
  100.     public function collectDenormalize(string $traceId, mixed $data, string $type, ?string $format, array $context, float $time, array $caller): void
  101.     {
  102.         unset($context[TraceableSerializer::DEBUG_TRACE_ID]);
  104.         $this->collected[$traceId] = array_merge(
  105.             $this->collected[$traceId] ?? [],
  106.             compact('data', 'format', 'type', 'context', 'time', 'caller'),
  107.             ['method' => 'denormalize'],
  108.         );
  109.     }
  111.     public function collectEncode(string $traceId, mixed $data, ?string $format, array $context, float $time, array $caller): void
  112.     {
  113.         unset($context[TraceableSerializer::DEBUG_TRACE_ID]);
  115.         $this->collected[$traceId] = array_merge(
  116.             $this->collected[$traceId] ?? [],
  117.             compact('data', 'format', 'context', 'time', 'caller'),
  118.             ['method' => 'encode'],
  119.         );
  120.     }
  122.     public function collectDecode(string $traceId, mixed $data, ?string $format, array $context, float $time, array $caller): void
  123.     {
  124.         unset($context[TraceableSerializer::DEBUG_TRACE_ID]);
  126.         $this->collected[$traceId] = array_merge(
  127.             $this->collected[$traceId] ?? [],
  128.             compact('data', 'format', 'context', 'time', 'caller'),
  129.             ['method' => 'decode'],
  130.         );
  131.     }
  133.     public function collectNormalization(string $traceId, string $normalizer, float $time): void
  134.     {
  135.         $method = 'normalize';
  137.         $this->collected[$traceId]['normalization'][] = compact('normalizer', 'method', 'time');
  138.     }
  140.     public function collectDenormalization(string $traceId, string $normalizer, float $time): void
  141.     {
  142.         $method = 'denormalize';
  144.         $this->collected[$traceId]['normalization'][] = compact('normalizer', 'method', 'time');
  145.     }
  147.     public function collectEncoding(string $traceId, string $encoder, float $time): void
  148.     {
  149.         $method = 'encode';
  151.         $this->collected[$traceId]['encoding'][] = compact('encoder', 'method', 'time');
  152.     }
  154.     public function collectDecoding(string $traceId, string $encoder, float $time): void
  155.     {
  156.         $method = 'decode';
  158.         $this->collected[$traceId]['encoding'][] = compact('encoder', 'method', 'time');
  159.     }
  161.     public function lateCollect(): void
  162.     {
  163.         $this->data = [
  164.             'serialize' => [],
  165.             'deserialize' => [],
  166.             'normalize' => [],
  167.             'denormalize' => [],
  168.             'encode' => [],
  169.             'decode' => [],
  170.         ];
  172.         foreach ($this->collected as $collected) {
  173.             if (!isset($collected['data'])) {
  174.                 continue;
  175.             }
  177.             $data = [
  178.                 'data' => $this->cloneVar($collected['data']),
  179.                 'dataType' => get_debug_type($collected['data']),
  180.                 'type' => $collected['type'] ?? null,
  181.                 'format' => $collected['format'],
  182.                 'time' => $collected['time'],
  183.                 'context' => $this->cloneVar($collected['context']),
  184.                 'normalization' => [],
  185.                 'encoding' => [],
  186.                 'caller' => $collected['caller'] ?? null,
  187.             ];
  189.             if (isset($collected['normalization'])) {
  190.                 $mainNormalization = array_pop($collected['normalization']);
  192.                 $data['normalizer'] = ['time' => $mainNormalization['time']] + $this->getMethodLocation($mainNormalization['normalizer'], $mainNormalization['method']);
  194.                 foreach ($collected['normalization'] as $normalization) {
  195.                     if (!isset($data['normalization'][$normalization['normalizer']])) {
  196.                         $data['normalization'][$normalization['normalizer']] = ['time' => 0, 'calls' => 0] + $this->getMethodLocation($normalization['normalizer'], $normalization['method']);
  197.                     }
  199.                     ++$data['normalization'][$normalization['normalizer']]['calls'];
  200.                     $data['normalization'][$normalization['normalizer']]['time'] += $normalization['time'];
  201.                 }
  202.             }
  204.             if (isset($collected['encoding'])) {
  205.                 $mainEncoding = array_pop($collected['encoding']);
  207.                 $data['encoder'] = ['time' => $mainEncoding['time']] + $this->getMethodLocation($mainEncoding['encoder'], $mainEncoding['method']);
  209.                 foreach ($collected['encoding'] as $encoding) {
  210.                     if (!isset($data['encoding'][$encoding['encoder']])) {
  211.                         $data['encoding'][$encoding['encoder']] = ['time' => 0, 'calls' => 0] + $this->getMethodLocation($encoding['encoder'], $encoding['method']);
  212.                     }
  214.                     ++$data['encoding'][$encoding['encoder']]['calls'];
  215.                     $data['encoding'][$encoding['encoder']]['time'] += $encoding['time'];
  216.                 }
  217.             }
  219.             $this->data[$collected['method']][] = $data;
  220.         }
  221.     }
  223.     private function getMethodLocation(string $class, string $method): array
  224.     {
  225.         $reflection = new \ReflectionClass($class);
  227.         return [
  228.             'class' => $reflection->getShortName(),
  229.             'file' => $reflection->getFileName(),
  230.             'line' => $reflection->getMethod($method)->getStartLine(),
  231.         ];
  232.     }
  233. }