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

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