vendor/symfony/http-kernel/DataCollector/RequestDataCollector.php line 73

  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\EventDispatcher\EventSubscriberInterface;
  15. use Symfony\Component\HttpFoundation\Cookie;
  16. use Symfony\Component\HttpFoundation\ParameterBag;
  17. use Symfony\Component\HttpFoundation\Request;
  18. use Symfony\Component\HttpFoundation\RequestStack;
  19. use Symfony\Component\HttpFoundation\Response;
  20. use Symfony\Component\HttpFoundation\Session\SessionBagInterface;
  21. use Symfony\Component\HttpFoundation\Session\SessionInterface;
  22. use Symfony\Component\HttpKernel\Event\ControllerEvent;
  23. use Symfony\Component\HttpKernel\Event\ResponseEvent;
  24. use Symfony\Component\HttpKernel\KernelEvents;
  25. use Symfony\Component\VarDumper\Cloner\Data;
  27. /**
  28.  * @author Fabien Potencier <fabien@symfony.com>
  29.  *
  30.  * @final
  31.  */
  32. class RequestDataCollector extends DataCollector implements EventSubscriberInterface, LateDataCollectorInterface
  33. {
  34.     /**
  35.      * @var \SplObjectStorage<Request, callable>
  36.      */
  37.     private \SplObjectStorage $controllers;
  38.     private array $sessionUsages = [];
  40.     public function __construct(
  41.         private ?RequestStack $requestStack = null,
  42.     ) {
  43.         $this->controllers = new \SplObjectStorage();
  44.     }
  46.     public function collect(Request $request, Response $response, ?\Throwable $exception = null): void
  47.     {
  48.         // attributes are serialized and as they can be anything, they need to be converted to strings.
  49.         $attributes = [];
  50.         $route = '';
  51.         foreach ($request->attributes->all() as $key => $value) {
  52.             if ('_route' === $key) {
  53.                 $route = \is_object($value) ? $value->getPath() : $value;
  54.                 $attributes[$key] = $route;
  55.             } else {
  56.                 $attributes[$key] = $value;
  57.             }
  58.         }
  60.         $content = $request->getContent();
  62.         $sessionMetadata = [];
  63.         $sessionAttributes = [];
  64.         $flashes = [];
  65.         if (!$request->attributes->getBoolean('_stateless') && $request->hasSession()) {
  66.             $session = $request->getSession();
  67.             if ($session->isStarted()) {
  68.                 $sessionMetadata['Created'] = date(\DATE_RFC822, $session->getMetadataBag()->getCreated());
  69.                 $sessionMetadata['Last used'] = date(\DATE_RFC822, $session->getMetadataBag()->getLastUsed());
  70.                 $sessionMetadata['Lifetime'] = $session->getMetadataBag()->getLifetime();
  71.                 $sessionAttributes = $session->all();
  72.                 $flashes = $session->getFlashBag()->peekAll();
  73.             }
  74.         }
  76.         $statusCode = $response->getStatusCode();
  78.         $responseCookies = [];
  79.         foreach ($response->headers->getCookies() as $cookie) {
  80.             $responseCookies[$cookie->getName()] = $cookie;
  81.         }
  83.         $dotenvVars = [];
  84.         foreach (explode(',', $_SERVER['SYMFONY_DOTENV_VARS'] ?? $_ENV['SYMFONY_DOTENV_VARS'] ?? '') as $name) {
  85.             if ('' !== $name && isset($_ENV[$name])) {
  86.                 $dotenvVars[$name] = $_ENV[$name];
  87.             }
  88.         }
  90.         $this->data = [
  91.             'method' => $request->getMethod(),
  92.             'format' => $request->getRequestFormat(),
  93.             'content_type' => $response->headers->get('Content-Type', 'text/html'),
  94.             'status_text' => Response::$statusTexts[$statusCode] ?? '',
  95.             'status_code' => $statusCode,
  96.             'request_query' => $request->query->all(),
  97.             'request_request' => $request->request->all(),
  98.             'request_files' => $request->files->all(),
  99.             'request_headers' => $request->headers->all(),
  100.             'request_server' => $request->server->all(),
  101.             'request_cookies' => $request->cookies->all(),
  102.             'request_attributes' => $attributes,
  103.             'route' => $route,
  104.             'response_headers' => $response->headers->all(),
  105.             'response_cookies' => $responseCookies,
  106.             'session_metadata' => $sessionMetadata,
  107.             'session_attributes' => $sessionAttributes,
  108.             'session_usages' => array_values($this->sessionUsages),
  109.             'stateless_check' => $this->requestStack?->getMainRequest()?->attributes->get('_stateless') ?? false,
  110.             'flashes' => $flashes,
  111.             'path_info' => $request->getPathInfo(),
  112.             'controller' => 'n/a',
  113.             'locale' => $request->getLocale(),
  114.             'dotenv_vars' => $dotenvVars,
  115.         ];
  117.         if (isset($this->data['request_headers']['php-auth-pw'])) {
  118.             $this->data['request_headers']['php-auth-pw'] = '******';
  119.         }
  121.         if (isset($this->data['request_server']['PHP_AUTH_PW'])) {
  122.             $this->data['request_server']['PHP_AUTH_PW'] = '******';
  123.         }
  125.         if (isset($this->data['request_request']['_password'])) {
  126.             $encodedPassword = rawurlencode($this->data['request_request']['_password']);
  127.             $content = str_replace('_password='.$encodedPassword, '_password=******', $content);
  128.             $this->data['request_request']['_password'] = '******';
  129.         }
  131.         $this->data['content'] = $content;
  133.         foreach ($this->data as $key => $value) {
  134.             if (!\is_array($value)) {
  135.                 continue;
  136.             }
  137.             if ('request_headers' === $key || 'response_headers' === $key) {
  138.                 $this->data[$key] = array_map(fn ($v) => isset($v[0]) && !isset($v[1]) ? $v[0] : $v, $value);
  139.             }
  140.         }
  142.         if (isset($this->controllers[$request])) {
  143.             $this->data['controller'] = $this->parseController($this->controllers[$request]);
  144.             unset($this->controllers[$request]);
  145.         }
  147.         if ($request->attributes->has('_redirected') && $redirectCookie = $request->cookies->get('sf_redirect')) {
  148.             $this->data['redirect'] = json_decode($redirectCookie, true);
  150.             $response->headers->clearCookie('sf_redirect');
  151.         }
  153.         if ($response->isRedirect()) {
  154.             $response->headers->setCookie(new Cookie(
  155.                 'sf_redirect',
  156.                 json_encode([
  157.                     'token' => $response->headers->get('x-debug-token'),
  158.                     'route' => $request->attributes->get('_route', 'n/a'),
  159.                     'method' => $request->getMethod(),
  160.                     'controller' => $this->parseController($request->attributes->get('_controller')),
  161.                     'status_code' => $statusCode,
  162.                     'status_text' => Response::$statusTexts[$statusCode],
  163.                 ]),
  164.                 0, '/', null, $request->isSecure(), true, false, 'lax'
  165.             ));
  166.         }
  168.         $this->data['identifier'] = $this->data['route'] ?: (\is_array($this->data['controller']) ? $this->data['controller']['class'].'::'.$this->data['controller']['method'].'()' : $this->data['controller']);
  170.         if ($response->headers->has('x-previous-debug-token')) {
  171.             $this->data['forward_token'] = $response->headers->get('x-previous-debug-token');
  172.         }
  173.     }
  175.     public function lateCollect(): void
  176.     {
  177.         $this->data = $this->cloneVar($this->data);
  178.     }
  180.     public function reset(): void
  181.     {
  182.         parent::reset();
  183.         $this->controllers = new \SplObjectStorage();
  184.         $this->sessionUsages = [];
  185.     }
  187.     public function getMethod(): string
  188.     {
  189.         return $this->data['method'];
  190.     }
  192.     public function getPathInfo(): string
  193.     {
  194.         return $this->data['path_info'];
  195.     }
  197.     public function getRequestRequest(): ParameterBag
  198.     {
  199.         return new ParameterBag($this->data['request_request']->getValue());
  200.     }
  202.     public function getRequestQuery(): ParameterBag
  203.     {
  204.         return new ParameterBag($this->data['request_query']->getValue());
  205.     }
  207.     public function getRequestFiles(): ParameterBag
  208.     {
  209.         return new ParameterBag($this->data['request_files']->getValue());
  210.     }
  212.     public function getRequestHeaders(): ParameterBag
  213.     {
  214.         return new ParameterBag($this->data['request_headers']->getValue());
  215.     }
  217.     public function getRequestServer(bool $raw = false): ParameterBag
  218.     {
  219.         return new ParameterBag($this->data['request_server']->getValue($raw));
  220.     }
  222.     public function getRequestCookies(bool $raw = false): ParameterBag
  223.     {
  224.         return new ParameterBag($this->data['request_cookies']->getValue($raw));
  225.     }
  227.     public function getRequestAttributes(): ParameterBag
  228.     {
  229.         return new ParameterBag($this->data['request_attributes']->getValue());
  230.     }
  232.     public function getResponseHeaders(): ParameterBag
  233.     {
  234.         return new ParameterBag($this->data['response_headers']->getValue());
  235.     }
  237.     public function getResponseCookies(): ParameterBag
  238.     {
  239.         return new ParameterBag($this->data['response_cookies']->getValue());
  240.     }
  242.     public function getSessionMetadata(): array
  243.     {
  244.         return $this->data['session_metadata']->getValue();
  245.     }
  247.     public function getSessionAttributes(): array
  248.     {
  249.         return $this->data['session_attributes']->getValue();
  250.     }
  252.     public function getStatelessCheck(): bool
  253.     {
  254.         return $this->data['stateless_check'];
  255.     }
  257.     public function getSessionUsages(): Data|array
  258.     {
  259.         return $this->data['session_usages'];
  260.     }
  262.     public function getFlashes(): array
  263.     {
  264.         return $this->data['flashes']->getValue();
  265.     }
  267.     /**
  268.      * @return string|resource
  269.      */
  270.     public function getContent()
  271.     {
  272.         return $this->data['content'];
  273.     }
  275.     public function isJsonRequest(): bool
  276.     {
  277.         return 1 === preg_match('{^application/(?:\w+\++)*json$}i', $this->data['request_headers']['content-type']);
  278.     }
  280.     public function getPrettyJson(): ?string
  281.     {
  282.         $decoded = json_decode($this->getContent());
  284.         return \JSON_ERROR_NONE === json_last_error() ? json_encode($decoded, \JSON_PRETTY_PRINT) : null;
  285.     }
  287.     public function getContentType(): string
  288.     {
  289.         return $this->data['content_type'];
  290.     }
  292.     public function getStatusText(): string
  293.     {
  294.         return $this->data['status_text'];
  295.     }
  297.     public function getStatusCode(): int
  298.     {
  299.         return $this->data['status_code'];
  300.     }
  302.     public function getFormat(): string
  303.     {
  304.         return $this->data['format'];
  305.     }
  307.     public function getLocale(): string
  308.     {
  309.         return $this->data['locale'];
  310.     }
  312.     public function getDotenvVars(): ParameterBag
  313.     {
  314.         return new ParameterBag($this->data['dotenv_vars']->getValue());
  315.     }
  317.     /**
  318.      * Gets the route name.
  319.      *
  320.      * The _route request attributes is automatically set by the Router Matcher.
  321.      */
  322.     public function getRoute(): string
  323.     {
  324.         return $this->data['route'];
  325.     }
  327.     public function getIdentifier(): string
  328.     {
  329.         return $this->data['identifier'];
  330.     }
  332.     /**
  333.      * Gets the route parameters.
  334.      *
  335.      * The _route_params request attributes is automatically set by the RouterListener.
  336.      */
  337.     public function getRouteParams(): array
  338.     {
  339.         return isset($this->data['request_attributes']['_route_params']) ? $this->data['request_attributes']['_route_params']->getValue() : [];
  340.     }
  342.     /**
  343.      * Gets the parsed controller.
  344.      *
  345.      * @return array|string|Data The controller as a string or array of data
  346.      *                           with keys 'class', 'method', 'file' and 'line'
  347.      */
  348.     public function getController(): array|string|Data
  349.     {
  350.         return $this->data['controller'];
  351.     }
  353.     /**
  354.      * Gets the previous request attributes.
  355.      *
  356.      * @return array|Data|false A legacy array of data from the previous redirection response
  357.      *                          or false otherwise
  358.      */
  359.     public function getRedirect(): array|Data|false
  360.     {
  361.         return $this->data['redirect'] ?? false;
  362.     }
  364.     public function getForwardToken(): ?string
  365.     {
  366.         return $this->data['forward_token'] ?? null;
  367.     }
  369.     public function onKernelController(ControllerEvent $event): void
  370.     {
  371.         $this->controllers[$event->getRequest()] = $event->getController();
  372.     }
  374.     public function onKernelResponse(ResponseEvent $event): void
  375.     {
  376.         if (!$event->isMainRequest()) {
  377.             return;
  378.         }
  380.         if ($event->getRequest()->cookies->has('sf_redirect')) {
  381.             $event->getRequest()->attributes->set('_redirected', true);
  382.         }
  383.     }
  385.     public static function getSubscribedEvents(): array
  386.     {
  387.         return [
  388.             KernelEvents::CONTROLLER => 'onKernelController',
  389.             KernelEvents::RESPONSE => 'onKernelResponse',
  390.         ];
  391.     }
  393.     public function getName(): string
  394.     {
  395.         return 'request';
  396.     }
  398.     public function collectSessionUsage(): void
  399.     {
  400.         $trace = debug_backtrace(\DEBUG_BACKTRACE_IGNORE_ARGS);
  402.         $traceEndIndex = \count($trace) - 1;
  403.         for ($i = $traceEndIndex; $i > 0; --$i) {
  404.             if (null !== ($class = $trace[$i]['class'] ?? null) && (is_subclass_of($class, SessionInterface::class) || is_subclass_of($class, SessionBagInterface::class))) {
  405.                 $traceEndIndex = $i;
  406.                 break;
  407.             }
  408.         }
  410.         if ((\count($trace) - 1) === $traceEndIndex) {
  411.             return;
  412.         }
  414.         // Remove part of the backtrace that belongs to session only
  415.         array_splice($trace, 0, $traceEndIndex);
  417.         // Merge identical backtraces generated by internal call reports
  418.         $name = sprintf('%s:%s', $trace[1]['class'] ?? $trace[0]['file'], $trace[0]['line']);
  419.         if (!\array_key_exists($name, $this->sessionUsages)) {
  420.             $this->sessionUsages[$name] = [
  421.                 'name' => $name,
  422.                 'file' => $trace[0]['file'],
  423.                 'line' => $trace[0]['line'],
  424.                 'trace' => $trace,
  425.             ];
  426.         }
  427.     }
  429.     /**
  430.      * @return array|string An array of controller data or a simple string
  431.      */
  432.     private function parseController(array|object|string|null $controller): array|string
  433.     {
  434.         if (\is_string($controller) && str_contains($controller, '::')) {
  435.             $controller = explode('::', $controller);
  436.         }
  438.         if (\is_array($controller)) {
  439.             try {
  440.                 $r = new \ReflectionMethod($controller[0], $controller[1]);
  442.                 return [
  443.                     'class' => \is_object($controller[0]) ? get_debug_type($controller[0]) : $controller[0],
  444.                     'method' => $controller[1],
  445.                     'file' => $r->getFileName(),
  446.                     'line' => $r->getStartLine(),
  447.                 ];
  448.             } catch (\ReflectionException) {
  449.                 if (\is_callable($controller)) {
  450.                     // using __call or  __callStatic
  451.                     return [
  452.                         'class' => \is_object($controller[0]) ? get_debug_type($controller[0]) : $controller[0],
  453.                         'method' => $controller[1],
  454.                         'file' => 'n/a',
  455.                         'line' => 'n/a',
  456.                     ];
  457.                 }
  458.             }
  459.         }
  461.         if ($controller instanceof \Closure) {
  462.             $r = new \ReflectionFunction($controller);
  464.             $controller = [
  465.                 'class' => $r->getName(),
  466.                 'method' => null,
  467.                 'file' => $r->getFileName(),
  468.                 'line' => $r->getStartLine(),
  469.             ];
  471.             if ($r->isAnonymous()) {
  472.                 return $controller;
  473.             }
  474.             $controller['method'] = $r->name;
  476.             if ($class = $r->getClosureCalledClass()) {
  477.                 $controller['class'] = $class->name;
  478.             } else {
  479.                 return $r->name;
  480.             }
  482.             return $controller;
  483.         }
  485.         if (\is_object($controller)) {
  486.             $r = new \ReflectionClass($controller);
  488.             return [
  489.                 'class' => $r->getName(),
  490.                 'method' => null,
  491.                 'file' => $r->getFileName(),
  492.                 'line' => $r->getStartLine(),
  493.             ];
  494.         }
  496.         return \is_string($controller) ? $controller : 'n/a';
  497.     }
  498. }