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

Open in your IDE?
  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\Response;
  16. use Symfony\Component\HttpKernel\Event\FilterControllerEvent;
  17. use Symfony\Component\HttpKernel\Event\FilterResponseEvent;
  18. use Symfony\Component\HttpKernel\KernelEvents;
  19. /**
  20.  * @author Fabien Potencier <fabien@symfony.com>
  21.  *
  22.  * @final since Symfony 4.4
  23.  */
  24. class RequestDataCollector extends DataCollector implements EventSubscriberInterfaceLateDataCollectorInterface
  25. {
  26.     protected $controllers;
  27.     public function __construct()
  28.     {
  29.         $this->controllers = new \SplObjectStorage();
  30.     }
  31.     /**
  32.      * {@inheritdoc}
  33.      *
  34.      * @param \Throwable|null $exception
  35.      */
  36.     public function collect(Request $requestResponse $response/*, \Throwable $exception = null*/)
  37.     {
  38.         // attributes are serialized and as they can be anything, they need to be converted to strings.
  39.         $attributes = [];
  40.         $route '';
  41.         foreach ($request->attributes->all() as $key => $value) {
  42.             if ('_route' === $key) {
  43.                 $route = \is_object($value) ? $value->getPath() : $value;
  44.                 $attributes[$key] = $route;
  45.             } else {
  46.                 $attributes[$key] = $value;
  47.             }
  48.         }
  49.         try {
  50.             $content $request->getContent();
  51.         } catch (\LogicException $e) {
  52.             // the user already got the request content as a resource
  53.             $content false;
  54.         }
  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' => $content,
  83.             'content_type' => $response->headers->get('Content-Type''text/html'),
  84.             'status_text' => isset(Response::$statusTexts[$statusCode]) ? Response::$statusTexts[$statusCode] : '',
  85.             'status_code' => $statusCode,
  86.             'request_query' => $request->query->all(),
  87.             'request_request' => $request->request->all(),
  88.             'request_files' => $request->files->all(),
  89.             'request_headers' => $request->headers->all(),
  90.             'request_server' => $request->server->all(),
  91.             'request_cookies' => $request->cookies->all(),
  92.             'request_attributes' => $attributes,
  93.             'route' => $route,
  94.             'response_headers' => $response->headers->all(),
  95.             'response_cookies' => $responseCookies,
  96.             'session_metadata' => $sessionMetadata,
  97.             'session_attributes' => $sessionAttributes,
  98.             'flashes' => $flashes,
  99.             'path_info' => $request->getPathInfo(),
  100.             'controller' => 'n/a',
  101.             'locale' => $request->getLocale(),
  102.             'dotenv_vars' => $dotenvVars,
  103.         ];
  104.         if (isset($this->data['request_headers']['php-auth-pw'])) {
  105.             $this->data['request_headers']['php-auth-pw'] = '******';
  106.         }
  107.         if (isset($this->data['request_server']['PHP_AUTH_PW'])) {
  108.             $this->data['request_server']['PHP_AUTH_PW'] = '******';
  109.         }
  110.         if (isset($this->data['request_request']['_password'])) {
  111.             $this->data['request_request']['_password'] = '******';
  112.         }
  113.         foreach ($this->data as $key => $value) {
  114.             if (!\is_array($value)) {
  115.                 continue;
  116.             }
  117.             if ('request_headers' === $key || 'response_headers' === $key) {
  118.                 $this->data[$key] = array_map(function ($v) { return isset($v[0]) && !isset($v[1]) ? $v[0] : $v; }, $value);
  119.             }
  120.         }
  121.         if (isset($this->controllers[$request])) {
  122.             $this->data['controller'] = $this->parseController($this->controllers[$request]);
  123.             unset($this->controllers[$request]);
  124.         }
  125.         if ($request->attributes->has('_redirected') && $redirectCookie $request->cookies->get('sf_redirect')) {
  126.             $this->data['redirect'] = json_decode($redirectCookietrue);
  127.             $response->headers->clearCookie('sf_redirect');
  128.         }
  129.         if ($response->isRedirect()) {
  130.             $response->headers->setCookie(new Cookie(
  131.                 'sf_redirect',
  132.                 json_encode([
  133.                     'token' => $response->headers->get('x-debug-token'),
  134.                     'route' => $request->attributes->get('_route''n/a'),
  135.                     'method' => $request->getMethod(),
  136.                     'controller' => $this->parseController($request->attributes->get('_controller')),
  137.                     'status_code' => $statusCode,
  138.                     'status_text' => Response::$statusTexts[(int) $statusCode],
  139.                 ]),
  140.                 0'/'null$request->isSecure(), truefalse'lax'
  141.             ));
  142.         }
  143.         $this->data['identifier'] = $this->data['route'] ?: (\is_array($this->data['controller']) ? $this->data['controller']['class'].'::'.$this->data['controller']['method'].'()' $this->data['controller']);
  144.         if ($response->headers->has('x-previous-debug-token')) {
  145.             $this->data['forward_token'] = $response->headers->get('x-previous-debug-token');
  146.         }
  147.     }
  148.     public function lateCollect()
  149.     {
  150.         $this->data $this->cloneVar($this->data);
  151.     }
  152.     public function reset()
  153.     {
  154.         $this->data = [];
  155.         $this->controllers = new \SplObjectStorage();
  156.     }
  157.     public function getMethod()
  158.     {
  159.         return $this->data['method'];
  160.     }
  161.     public function getPathInfo()
  162.     {
  163.         return $this->data['path_info'];
  164.     }
  165.     public function getRequestRequest()
  166.     {
  167.         return new ParameterBag($this->data['request_request']->getValue());
  168.     }
  169.     public function getRequestQuery()
  170.     {
  171.         return new ParameterBag($this->data['request_query']->getValue());
  172.     }
  173.     public function getRequestFiles()
  174.     {
  175.         return new ParameterBag($this->data['request_files']->getValue());
  176.     }
  177.     public function getRequestHeaders()
  178.     {
  179.         return new ParameterBag($this->data['request_headers']->getValue());
  180.     }
  181.     public function getRequestServer($raw false)
  182.     {
  183.         return new ParameterBag($this->data['request_server']->getValue($raw));
  184.     }
  185.     public function getRequestCookies($raw false)
  186.     {
  187.         return new ParameterBag($this->data['request_cookies']->getValue($raw));
  188.     }
  189.     public function getRequestAttributes()
  190.     {
  191.         return new ParameterBag($this->data['request_attributes']->getValue());
  192.     }
  193.     public function getResponseHeaders()
  194.     {
  195.         return new ParameterBag($this->data['response_headers']->getValue());
  196.     }
  197.     public function getResponseCookies()
  198.     {
  199.         return new ParameterBag($this->data['response_cookies']->getValue());
  200.     }
  201.     public function getSessionMetadata()
  202.     {
  203.         return $this->data['session_metadata']->getValue();
  204.     }
  205.     public function getSessionAttributes()
  206.     {
  207.         return $this->data['session_attributes']->getValue();
  208.     }
  209.     public function getFlashes()
  210.     {
  211.         return $this->data['flashes']->getValue();
  212.     }
  213.     public function getContent()
  214.     {
  215.         return $this->data['content'];
  216.     }
  217.     public function isJsonRequest()
  218.     {
  219.         return === preg_match('{^application/(?:\w+\++)*json$}i'$this->data['request_headers']['content-type']);
  220.     }
  221.     public function getPrettyJson()
  222.     {
  223.         $decoded json_decode($this->getContent());
  224.         return \JSON_ERROR_NONE === json_last_error() ? json_encode($decoded, \JSON_PRETTY_PRINT) : null;
  225.     }
  226.     public function getContentType()
  227.     {
  228.         return $this->data['content_type'];
  229.     }
  230.     public function getStatusText()
  231.     {
  232.         return $this->data['status_text'];
  233.     }
  234.     public function getStatusCode()
  235.     {
  236.         return $this->data['status_code'];
  237.     }
  238.     public function getFormat()
  239.     {
  240.         return $this->data['format'];
  241.     }
  242.     public function getLocale()
  243.     {
  244.         return $this->data['locale'];
  245.     }
  246.     public function getDotenvVars()
  247.     {
  248.         return new ParameterBag($this->data['dotenv_vars']->getValue());
  249.     }
  250.     /**
  251.      * Gets the route name.
  252.      *
  253.      * The _route request attributes is automatically set by the Router Matcher.
  254.      *
  255.      * @return string The route
  256.      */
  257.     public function getRoute()
  258.     {
  259.         return $this->data['route'];
  260.     }
  261.     public function getIdentifier()
  262.     {
  263.         return $this->data['identifier'];
  264.     }
  265.     /**
  266.      * Gets the route parameters.
  267.      *
  268.      * The _route_params request attributes is automatically set by the RouterListener.
  269.      *
  270.      * @return array The parameters
  271.      */
  272.     public function getRouteParams()
  273.     {
  274.         return isset($this->data['request_attributes']['_route_params']) ? $this->data['request_attributes']['_route_params']->getValue() : [];
  275.     }
  276.     /**
  277.      * Gets the parsed controller.
  278.      *
  279.      * @return array|string The controller as a string or array of data
  280.      *                      with keys 'class', 'method', 'file' and 'line'
  281.      */
  282.     public function getController()
  283.     {
  284.         return $this->data['controller'];
  285.     }
  286.     /**
  287.      * Gets the previous request attributes.
  288.      *
  289.      * @return array|bool A legacy array of data from the previous redirection response
  290.      *                    or false otherwise
  291.      */
  292.     public function getRedirect()
  293.     {
  294.         return isset($this->data['redirect']) ? $this->data['redirect'] : false;
  295.     }
  296.     public function getForwardToken()
  297.     {
  298.         return isset($this->data['forward_token']) ? $this->data['forward_token'] : null;
  299.     }
  300.     /**
  301.      * @final since Symfony 4.3
  302.      */
  303.     public function onKernelController(FilterControllerEvent $event)
  304.     {
  305.         $this->controllers[$event->getRequest()] = $event->getController();
  306.     }
  307.     /**
  308.      * @final since Symfony 4.3
  309.      */
  310.     public function onKernelResponse(FilterResponseEvent $event)
  311.     {
  312.         if (!$event->isMasterRequest()) {
  313.             return;
  314.         }
  315.         if ($event->getRequest()->cookies->has('sf_redirect')) {
  316.             $event->getRequest()->attributes->set('_redirected'true);
  317.         }
  318.     }
  319.     public static function getSubscribedEvents()
  320.     {
  321.         return [
  322.             KernelEvents::CONTROLLER => 'onKernelController',
  323.             KernelEvents::RESPONSE => 'onKernelResponse',
  324.         ];
  325.     }
  326.     /**
  327.      * {@inheritdoc}
  328.      */
  329.     public function getName()
  330.     {
  331.         return 'request';
  332.     }
  333.     /**
  334.      * Parse a controller.
  335.      *
  336.      * @param mixed $controller The controller to parse
  337.      *
  338.      * @return array|string An array of controller data or a simple string
  339.      */
  340.     protected function parseController($controller)
  341.     {
  342.         if (\is_string($controller) && false !== strpos($controller'::')) {
  343.             $controller explode('::'$controller);
  344.         }
  345.         if (\is_array($controller)) {
  346.             try {
  347.                 $r = new \ReflectionMethod($controller[0], $controller[1]);
  348.                 return [
  349.                     'class' => \is_object($controller[0]) ? \get_class($controller[0]) : $controller[0],
  350.                     'method' => $controller[1],
  351.                     'file' => $r->getFileName(),
  352.                     'line' => $r->getStartLine(),
  353.                 ];
  354.             } catch (\ReflectionException $e) {
  355.                 if (\is_callable($controller)) {
  356.                     // using __call or  __callStatic
  357.                     return [
  358.                         'class' => \is_object($controller[0]) ? \get_class($controller[0]) : $controller[0],
  359.                         'method' => $controller[1],
  360.                         'file' => 'n/a',
  361.                         'line' => 'n/a',
  362.                     ];
  363.                 }
  364.             }
  365.         }
  366.         if ($controller instanceof \Closure) {
  367.             $r = new \ReflectionFunction($controller);
  368.             $controller = [
  369.                 'class' => $r->getName(),
  370.                 'method' => null,
  371.                 'file' => $r->getFileName(),
  372.                 'line' => $r->getStartLine(),
  373.             ];
  374.             if (false !== strpos($r->name'{closure}')) {
  375.                 return $controller;
  376.             }
  377.             $controller['method'] = $r->name;
  378.             if ($class $r->getClosureScopeClass()) {
  379.                 $controller['class'] = $class->name;
  380.             } else {
  381.                 return $r->name;
  382.             }
  383.             return $controller;
  384.         }
  385.         if (\is_object($controller)) {
  386.             $r = new \ReflectionClass($controller);
  387.             return [
  388.                 'class' => $r->getName(),
  389.                 'method' => null,
  390.                 'file' => $r->getFileName(),
  391.                 'line' => $r->getStartLine(),
  392.             ];
  393.         }
  394.         return \is_string($controller) ? $controller 'n/a';
  395.     }
  396. }