vendor\symfony\http-kernel\DataCollector\RequestDataCollector.php line 370

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\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 = [];
  39.     private ?RequestStack $requestStack;
  41.     public function __construct(RequestStack $requestStack = null)
  42.     {
  43.         $this->controllers = new \SplObjectStorage();
  44.         $this->requestStack = $requestStack;
  45.     }
  47.     /**
  48.      * {@inheritdoc}
  49.      */
  50.     public function collect(Request $request, Response $response, \Throwable $exception = null)
  51.     {
  52.         // attributes are serialized and as they can be anything, they need to be converted to strings.
  53.         $attributes = [];
  54.         $route = '';
  55.         foreach ($request->attributes->all() as $key => $value) {
  56.             if ('_route' === $key) {
  57.                 $route = \is_object($value) ? $value->getPath() : $value;
  58.                 $attributes[$key] = $route;
  59.             } else {
  60.                 $attributes[$key] = $value;
  61.             }
  62.         }
  64.         $content = $request->getContent();
  66.         $sessionMetadata = [];
  67.         $sessionAttributes = [];
  68.         $flashes = [];
  69.         if ($request->hasSession()) {
  70.             $session = $request->getSession();
  71.             if ($session->isStarted()) {
  72.                 $sessionMetadata['Created'] = date(\DATE_RFC822, $session->getMetadataBag()->getCreated());
  73.                 $sessionMetadata['Last used'] = date(\DATE_RFC822, $session->getMetadataBag()->getLastUsed());
  74.                 $sessionMetadata['Lifetime'] = $session->getMetadataBag()->getLifetime();
  75.                 $sessionAttributes = $session->all();
  76.                 $flashes = $session->getFlashBag()->peekAll();
  77.             }
  78.         }
  80.         $statusCode = $response->getStatusCode();
  82.         $responseCookies = [];
  83.         foreach ($response->headers->getCookies() as $cookie) {
  84.             $responseCookies[$cookie->getName()] = $cookie;
  85.         }
  87.         $dotenvVars = [];
  88.         foreach (explode(',', $_SERVER['SYMFONY_DOTENV_VARS'] ?? $_ENV['SYMFONY_DOTENV_VARS'] ?? '') as $name) {
  89.             if ('' !== $name && isset($_ENV[$name])) {
  90.                 $dotenvVars[$name] = $_ENV[$name];
  91.             }
  92.         }
  94.         $this->data = [
  95.             'method' => $request->getMethod(),
  96.             'format' => $request->getRequestFormat(),
  97.             'content_type' => $response->headers->get('Content-Type', 'text/html'),
  98.             'status_text' => Response::$statusTexts[$statusCode] ?? '',
  99.             'status_code' => $statusCode,
  100.             'request_query' => $request->query->all(),
  101.             'request_request' => $request->request->all(),
  102.             'request_files' => $request->files->all(),
  103.             'request_headers' => $request->headers->all(),
  104.             'request_server' => $request->server->all(),
  105.             'request_cookies' => $request->cookies->all(),
  106.             'request_attributes' => $attributes,
  107.             'route' => $route,
  108.             'response_headers' => $response->headers->all(),
  109.             'response_cookies' => $responseCookies,
  110.             'session_metadata' => $sessionMetadata,
  111.             'session_attributes' => $sessionAttributes,
  112.             'session_usages' => array_values($this->sessionUsages),
  113.             'stateless_check' => $this->requestStack?->getMainRequest()?->attributes->get('_stateless') ?? false,
  114.             'flashes' => $flashes,
  115.             'path_info' => $request->getPathInfo(),
  116.             'controller' => 'n/a',
  117.             'locale' => $request->getLocale(),
  118.             'dotenv_vars' => $dotenvVars,
  119.         ];
  121.         if (isset($this->data['request_headers']['php-auth-pw'])) {
  122.             $this->data['request_headers']['php-auth-pw'] = '******';
  123.         }
  125.         if (isset($this->data['request_server']['PHP_AUTH_PW'])) {
  126.             $this->data['request_server']['PHP_AUTH_PW'] = '******';
  127.         }
  129.         if (isset($this->data['request_request']['_password'])) {
  130.             $encodedPassword = rawurlencode($this->data['request_request']['_password']);
  131.             $content = str_replace('_password='.$encodedPassword, '_password=******', $content);
  132.             $this->data['request_request']['_password'] = '******';
  133.         }
  135.         $this->data['content'] = $content;
  137.         foreach ($this->data as $key => $value) {
  138.             if (!\is_array($value)) {
  139.                 continue;
  140.             }
  141.             if ('request_headers' === $key || 'response_headers' === $key) {
  142.                 $this->data[$key] = array_map(function ($v) { return isset($v[0]) && !isset($v[1]) ? $v[0] : $v; }, $value);
  143.             }
  144.         }
  146.         if (isset($this->controllers[$request])) {
  147.             $this->data['controller'] = $this->parseController($this->controllers[$request]);
  148.             unset($this->controllers[$request]);
  149.         }
  151.         if ($request->attributes->has('_redirected') && $redirectCookie = $request->cookies->get('sf_redirect')) {
  152.             $this->data['redirect'] = json_decode($redirectCookie, true);
  154.             $response->headers->clearCookie('sf_redirect');
  155.         }
  157.         if ($response->isRedirect()) {
  158.             $response->headers->setCookie(new Cookie(
  159.                 'sf_redirect',
  160.                 json_encode([
  161.                     'token' => $response->headers->get('x-debug-token'),
  162.                     'route' => $request->attributes->get('_route', 'n/a'),
  163.                     'method' => $request->getMethod(),
  164.                     'controller' => $this->parseController($request->attributes->get('_controller')),
  165.                     'status_code' => $statusCode,
  166.                     'status_text' => Response::$statusTexts[$statusCode],
  167.                 ]),
  168.                 0, '/', null, $request->isSecure(), true, false, 'lax'
  169.             ));
  170.         }
  172.         $this->data['identifier'] = $this->data['route'] ?: (\is_array($this->data['controller']) ? $this->data['controller']['class'].'::'.$this->data['controller']['method'].'()' : $this->data['controller']);
  174.         if ($response->headers->has('x-previous-debug-token')) {
  175.             $this->data['forward_token'] = $response->headers->get('x-previous-debug-token');
  176.         }
  177.     }
  179.     public function lateCollect()
  180.     {
  181.         $this->data = $this->cloneVar($this->data);
  182.     }
  184.     public function reset()
  185.     {
  186.         $this->data = [];
  187.         $this->controllers = new \SplObjectStorage();
  188.         $this->sessionUsages = [];
  189.     }
  191.     public function getMethod()
  192.     {
  193.         return $this->data['method'];
  194.     }
  196.     public function getPathInfo()
  197.     {
  198.         return $this->data['path_info'];
  199.     }
  201.     public function getRequestRequest()
  202.     {
  203.         return new ParameterBag($this->data['request_request']->getValue());
  204.     }
  206.     public function getRequestQuery()
  207.     {
  208.         return new ParameterBag($this->data['request_query']->getValue());
  209.     }
  211.     public function getRequestFiles()
  212.     {
  213.         return new ParameterBag($this->data['request_files']->getValue());
  214.     }
  216.     public function getRequestHeaders()
  217.     {
  218.         return new ParameterBag($this->data['request_headers']->getValue());
  219.     }
  221.     public function getRequestServer(bool $raw = false)
  222.     {
  223.         return new ParameterBag($this->data['request_server']->getValue($raw));
  224.     }
  226.     public function getRequestCookies(bool $raw = false)
  227.     {
  228.         return new ParameterBag($this->data['request_cookies']->getValue($raw));
  229.     }
  231.     public function getRequestAttributes()
  232.     {
  233.         return new ParameterBag($this->data['request_attributes']->getValue());
  234.     }
  236.     public function getResponseHeaders()
  237.     {
  238.         return new ParameterBag($this->data['response_headers']->getValue());
  239.     }
  241.     public function getResponseCookies()
  242.     {
  243.         return new ParameterBag($this->data['response_cookies']->getValue());
  244.     }
  246.     public function getSessionMetadata()
  247.     {
  248.         return $this->data['session_metadata']->getValue();
  249.     }
  251.     public function getSessionAttributes()
  252.     {
  253.         return $this->data['session_attributes']->getValue();
  254.     }
  256.     public function getStatelessCheck()
  257.     {
  258.         return $this->data['stateless_check'];
  259.     }
  261.     public function getSessionUsages()
  262.     {
  263.         return $this->data['session_usages'];
  264.     }
  266.     public function getFlashes()
  267.     {
  268.         return $this->data['flashes']->getValue();
  269.     }
  271.     public function getContent()
  272.     {
  273.         return $this->data['content'];
  274.     }
  276.     public function isJsonRequest()
  277.     {
  278.         return 1 === preg_match('{^application/(?:\w+\++)*json$}i', $this->data['request_headers']['content-type']);
  279.     }
  281.     public function getPrettyJson()
  282.     {
  283.         $decoded = json_decode($this->getContent());
  285.         return \JSON_ERROR_NONE === json_last_error() ? json_encode($decoded, \JSON_PRETTY_PRINT) : null;
  286.     }
  288.     public function getContentType()
  289.     {
  290.         return $this->data['content_type'];
  291.     }
  293.     public function getStatusText()
  294.     {
  295.         return $this->data['status_text'];
  296.     }
  298.     public function getStatusCode()
  299.     {
  300.         return $this->data['status_code'];
  301.     }
  303.     public function getFormat()
  304.     {
  305.         return $this->data['format'];
  306.     }
  308.     public function getLocale()
  309.     {
  310.         return $this->data['locale'];
  311.     }
  313.     public function getDotenvVars()
  314.     {
  315.         return new ParameterBag($this->data['dotenv_vars']->getValue());
  316.     }
  318.     /**
  319.      * Gets the route name.
  320.      *
  321.      * The _route request attributes is automatically set by the Router Matcher.
  322.      */
  323.     public function getRoute(): string
  324.     {
  325.         return $this->data['route'];
  326.     }
  328.     public function getIdentifier()
  329.     {
  330.         return $this->data['identifier'];
  331.     }
  333.     /**
  334.      * Gets the route parameters.
  335.      *
  336.      * The _route_params request attributes is automatically set by the RouterListener.
  337.      */
  338.     public function getRouteParams(): array
  339.     {
  340.         return isset($this->data['request_attributes']['_route_params']) ? $this->data['request_attributes']['_route_params']->getValue() : [];
  341.     }
  343.     /**
  344.      * Gets the parsed controller.
  345.      *
  346.      * @return array|string|Data The controller as a string or array of data
  347.      *                           with keys 'class', 'method', 'file' and 'line'
  348.      */
  349.     public function getController(): array|string|Data
  350.     {
  351.         return $this->data['controller'];
  352.     }
  354.     /**
  355.      * Gets the previous request attributes.
  356.      *
  357.      * @return array|Data|false A legacy array of data from the previous redirection response
  358.      *                          or false otherwise
  359.      */
  360.     public function getRedirect(): array|Data|false
  361.     {
  362.         return $this->data['redirect'] ?? false;
  363.     }
  365.     public function getForwardToken()
  366.     {
  367.         return $this->data['forward_token'] ?? null;
  368.     }
  370.     public function onKernelController(ControllerEvent $event)
  371.     {
  372.         $this->controllers[$event->getRequest()] = $event->getController();
  373.     }
  375.     public function onKernelResponse(ResponseEvent $event)
  376.     {
  377.         if (!$event->isMainRequest()) {
  378.             return;
  379.         }
  381.         if ($event->getRequest()->cookies->has('sf_redirect')) {
  382.             $event->getRequest()->attributes->set('_redirected', true);
  383.         }
  384.     }
  386.     public static function getSubscribedEvents(): array
  387.     {
  388.         return [
  389.             KernelEvents::CONTROLLER => 'onKernelController',
  390.             KernelEvents::RESPONSE => 'onKernelResponse',
  391.         ];
  392.     }
  394.     /**
  395.      * {@inheritdoc}
  396.      */
  397.     public function getName(): string
  398.     {
  399.         return 'request';
  400.     }
  402.     public function collectSessionUsage(): void
  403.     {
  404.         $trace = debug_backtrace(\DEBUG_BACKTRACE_IGNORE_ARGS);
  406.         $traceEndIndex = \count($trace) - 1;
  407.         for ($i = $traceEndIndex; $i > 0; --$i) {
  408.             if (null !== ($class = $trace[$i]['class'] ?? null) && (is_subclass_of($class, SessionInterface::class) || is_subclass_of($class, SessionBagInterface::class))) {
  409.                 $traceEndIndex = $i;
  410.                 break;
  411.             }
  412.         }
  414.         if ((\count($trace) - 1) === $traceEndIndex) {
  415.             return;
  416.         }
  418.         // Remove part of the backtrace that belongs to session only
  419.         array_splice($trace, 0, $traceEndIndex);
  421.         // Merge identical backtraces generated by internal call reports
  422.         $name = sprintf('%s:%s', $trace[1]['class'] ?? $trace[0]['file'], $trace[0]['line']);
  423.         if (!\array_key_exists($name, $this->sessionUsages)) {
  424.             $this->sessionUsages[$name] = [
  425.                 'name' => $name,
  426.                 'file' => $trace[0]['file'],
  427.                 'line' => $trace[0]['line'],
  428.                 'trace' => $trace,
  429.             ];
  430.         }
  431.     }
  433.     /**
  434.      * @return array|string An array of controller data or a simple string
  435.      */
  436.     private function parseController(array|object|string|null $controller): array|string
  437.     {
  438.         if (\is_string($controller) && str_contains($controller, '::')) {
  439.             $controller = explode('::', $controller);
  440.         }
  442.         if (\is_array($controller)) {
  443.             try {
  444.                 $r = new \ReflectionMethod($controller[0], $controller[1]);
  446.                 return [
  447.                     'class' => \is_object($controller[0]) ? get_debug_type($controller[0]) : $controller[0],
  448.                     'method' => $controller[1],
  449.                     'file' => $r->getFileName(),
  450.                     'line' => $r->getStartLine(),
  451.                 ];
  452.             } catch (\ReflectionException) {
  453.                 if (\is_callable($controller)) {
  454.                     // using __call or  __callStatic
  455.                     return [
  456.                         'class' => \is_object($controller[0]) ? get_debug_type($controller[0]) : $controller[0],
  457.                         'method' => $controller[1],
  458.                         'file' => 'n/a',
  459.                         'line' => 'n/a',
  460.                     ];
  461.                 }
  462.             }
  463.         }
  465.         if ($controller instanceof \Closure) {
  466.             $r = new \ReflectionFunction($controller);
  468.             $controller = [
  469.                 'class' => $r->getName(),
  470.                 'method' => null,
  471.                 'file' => $r->getFileName(),
  472.                 'line' => $r->getStartLine(),
  473.             ];
  475.             if (str_contains($r->name, '{closure}')) {
  476.                 return $controller;
  477.             }
  478.             $controller['method'] = $r->name;
  480.             if ($class = $r->getClosureScopeClass()) {
  481.                 $controller['class'] = $class->name;
  482.             } else {
  483.                 return $r->name;
  484.             }
  486.             return $controller;
  487.         }
  489.         if (\is_object($controller)) {
  490.             $r = new \ReflectionClass($controller);
  492.             return [
  493.                 'class' => $r->getName(),
  494.                 'method' => null,
  495.                 'file' => $r->getFileName(),
  496.                 'line' => $r->getStartLine(),
  497.             ];
  498.         }
  500.         return \is_string($controller) ? $controller : 'n/a';
  501.     }
  502. }