vendor/symfony/serializer/Debug/TraceableSerializer.php line 41

  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\Debug;
  14. use Symfony\Component\Serializer\DataCollector\SerializerDataCollector;
  15. use Symfony\Component\Serializer\Encoder\DecoderInterface;
  16. use Symfony\Component\Serializer\Encoder\EncoderInterface;
  17. use Symfony\Component\Serializer\Normalizer\DenormalizerInterface;
  18. use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
  19. use Symfony\Component\Serializer\SerializerInterface;
  21. /**
  22.  * Collects some data about serialization.
  23.  *
  24.  * @author Mathias Arlaud <mathias.arlaud@gmail.com>
  25.  *
  26.  * @internal
  27.  */
  28. class TraceableSerializer implements SerializerInterface, NormalizerInterface, DenormalizerInterface, EncoderInterface, DecoderInterface
  29. {
  30.     public const DEBUG_TRACE_ID = 'debug_trace_id';
  32.     /**
  33.      * @param SerializerInterface&NormalizerInterface&DenormalizerInterface&EncoderInterface&DecoderInterface $serializer
  34.      */
  35.     public function __construct(
  36.         private SerializerInterface $serializer,
  37.         private SerializerDataCollector $dataCollector,
  38.     ) {
  39.     }
  41.     public function serialize(mixed $data, string $format, array $context = []): string
  42.     {
  43.         $context[self::DEBUG_TRACE_ID] = $traceId = uniqid();
  45.         $startTime = microtime(true);
  46.         $result = $this->serializer->serialize($data, $format, $context);
  47.         $time = microtime(true) - $startTime;
  49.         $caller = $this->getCaller(__FUNCTION__, SerializerInterface::class);
  51.         $this->dataCollector->collectSerialize($traceId, $data, $format, $context, $time, $caller);
  53.         return $result;
  54.     }
  56.     public function deserialize(mixed $data, string $type, string $format, array $context = []): mixed
  57.     {
  58.         $context[self::DEBUG_TRACE_ID] = $traceId = uniqid();
  60.         $startTime = microtime(true);
  61.         $result = $this->serializer->deserialize($data, $type, $format, $context);
  62.         $time = microtime(true) - $startTime;
  64.         $caller = $this->getCaller(__FUNCTION__, SerializerInterface::class);
  66.         $this->dataCollector->collectDeserialize($traceId, $data, $type, $format, $context, $time, $caller);
  68.         return $result;
  69.     }
  71.     public function normalize(mixed $object, string $format = null, array $context = []): array|string|int|float|bool|\ArrayObject|null
  72.     {
  73.         $context[self::DEBUG_TRACE_ID] = $traceId = uniqid();
  75.         $startTime = microtime(true);
  76.         $result = $this->serializer->normalize($object, $format, $context);
  77.         $time = microtime(true) - $startTime;
  79.         $caller = $this->getCaller(__FUNCTION__, NormalizerInterface::class);
  81.         $this->dataCollector->collectNormalize($traceId, $object, $format, $context, $time, $caller);
  83.         return $result;
  84.     }
  86.     public function denormalize(mixed $data, string $type, string $format = null, array $context = []): mixed
  87.     {
  88.         $context[self::DEBUG_TRACE_ID] = $traceId = uniqid();
  90.         $startTime = microtime(true);
  91.         $result = $this->serializer->denormalize($data, $type, $format, $context);
  92.         $time = microtime(true) - $startTime;
  94.         $caller = $this->getCaller(__FUNCTION__, DenormalizerInterface::class);
  96.         $this->dataCollector->collectDenormalize($traceId, $data, $type, $format, $context, $time, $caller);
  98.         return $result;
  99.     }
  101.     public function encode(mixed $data, string $format, array $context = []): string
  102.     {
  103.         $context[self::DEBUG_TRACE_ID] = $traceId = uniqid();
  105.         $startTime = microtime(true);
  106.         $result = $this->serializer->encode($data, $format, $context);
  107.         $time = microtime(true) - $startTime;
  109.         $caller = $this->getCaller(__FUNCTION__, EncoderInterface::class);
  111.         $this->dataCollector->collectEncode($traceId, $data, $format, $context, $time, $caller);
  113.         return $result;
  114.     }
  116.     public function decode(string $data, string $format, array $context = []): mixed
  117.     {
  118.         $context[self::DEBUG_TRACE_ID] = $traceId = uniqid();
  120.         $startTime = microtime(true);
  121.         $result = $this->serializer->decode($data, $format, $context);
  122.         $time = microtime(true) - $startTime;
  124.         $caller = $this->getCaller(__FUNCTION__, DecoderInterface::class);
  126.         $this->dataCollector->collectDecode($traceId, $data, $format, $context, $time, $caller);
  128.         return $result;
  129.     }
  131.     public function supportsNormalization(mixed $data, string $format = null, array $context = []): bool
  132.     {
  133.         return $this->serializer->supportsNormalization($data, $format, $context);
  134.     }
  136.     public function supportsDenormalization(mixed $data, string $type, string $format = null, array $context = []): bool
  137.     {
  138.         return $this->serializer->supportsDenormalization($data, $type, $format, $context);
  139.     }
  141.     public function supportsEncoding(string $format, array $context = []): bool
  142.     {
  143.         return $this->serializer->supportsEncoding($format, $context);
  144.     }
  146.     public function supportsDecoding(string $format, array $context = []): bool
  147.     {
  148.         return $this->serializer->supportsDecoding($format, $context);
  149.     }
  151.     /**
  152.      * Proxies all method calls to the original serializer.
  153.      */
  154.     public function __call(string $method, array $arguments): mixed
  155.     {
  156.         return $this->serializer->{$method}(...$arguments);
  157.     }
  159.     private function getCaller(string $method, string $interface): array
  160.     {
  161.         $trace = debug_backtrace(\DEBUG_BACKTRACE_IGNORE_ARGS, 8);
  163.         $file = $trace[0]['file'];
  164.         $line = $trace[0]['line'];
  166.         for ($i = 1; $i < 8; ++$i) {
  167.             if (isset($trace[$i]['class'], $trace[$i]['function'])
  168.                 && $method === $trace[$i]['function']
  169.                 && is_a($trace[$i]['class'], $interface, true)
  170.             ) {
  171.                 $file = $trace[$i]['file'];
  172.                 $line = $trace[$i]['line'];
  174.                 break;
  175.             }
  176.         }
  178.         $name = str_replace('\\', '/', $file);
  179.         $name = substr($name, strrpos($name, '/') + 1);
  181.         return compact('name', 'file', 'line');
  182.     }
  183. }