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

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. class RequestDataCollector extends DataCollector implements EventSubscriberInterfaceLateDataCollectorInterface {
  23.     protected $controllers;
  24.     public function __construct() {
  25.         $this->controllers = new \SplObjectStorage();
  26.     }
  27.     /**
  28.      * {@inheritdoc}
  29.      */
  30.     public function collect(Request $requestResponse $response, \Exception $exception null) {
  31.         // attributes are serialized and as they can be anything, they need to be converted to strings.
  32.         $attributes = [];
  33.         $route '';
  34.         foreach ($request->attributes->all() as $key => $value) {
  35.             if ('_route' === $key) {
  36.                 $route = \is_object($value) ? $value->getPath() : $value;
  37.                 $attributes[$key] = $route;
  38.             } else {
  39.                 $attributes[$key] = $value;
  40.             }
  41.         }
  42.         $content null;
  43.         try {
  44.             $content $request->getContent();
  45.         } catch (\LogicException $e) {
  46.             // the user already got the request content as a resource
  47.             $content false;
  48.         }
  49.         $sessionMetadata = [];
  50.         $sessionAttributes = [];
  51.         $session null;
  52.         $flashes = [];
  53.         if ($request->hasSession()) {
  54.             $session $request->getSession();
  55.             if ($session->isStarted()) {
  56.                 $sessionMetadata['Created'] = date(DATE_RFC822$session->getMetadataBag()->getCreated());
  57.                 $sessionMetadata['Last used'] = date(DATE_RFC822$session->getMetadataBag()->getLastUsed());
  58.                 $sessionMetadata['Lifetime'] = $session->getMetadataBag()->getLifetime();
  59.                 $sessionAttributes $session->all();
  60.                 $flashes $session->getFlashBag()->peekAll();
  61.             }
  62.         }
  63.         $statusCode $response->getStatusCode();
  64.         $responseCookies = [];
  65.         foreach ($response->headers->getCookies() as $cookie) {
  66.             $responseCookies[$cookie->getName()] = $cookie;
  67.         }
  68.         $dotenvVars = [];
  69.         foreach (explode(','getenv('SYMFONY_DOTENV_VARS')) as $name) {
  70.             if ('' !== $name && false !== $value getenv($name)) {
  71.                 $dotenvVars[$name] = $value;
  72.             }
  73.         }
  74.         $this->data = [
  75.             'method' => $request->getMethod(),
  76.             'format' => $request->getRequestFormat(),
  77.             'content' => $content,
  78.             'content_type' => $response->headers->get('Content-Type''text/html'),
  79.             'status_text' => isset(Response::$statusTexts[$statusCode]) ? Response::$statusTexts[$statusCode] : '',
  80.             'status_code' => $statusCode,
  81.             'request_query' => $request->query->all(),
  82.             'request_request' => $request->request->all(),
  83.             'request_files' => $request->files->all(),
  84.             'request_headers' => $request->headers->all(),
  85.             'request_server' => $request->server->all(),
  86.             'request_cookies' => $request->cookies->all(),
  87.             'request_attributes' => $attributes,
  88.             'route' => $route,
  89.             'response_headers' => $response->headers->all(),
  90.             'response_cookies' => $responseCookies,
  91.             'session_metadata' => $sessionMetadata,
  92.             'session_attributes' => $sessionAttributes,
  93.             'flashes' => $flashes,
  94.             'path_info' => $request->getPathInfo(),
  95.             'controller' => 'n/a',
  96.             'locale' => $request->getLocale(),
  97.             'dotenv_vars' => $dotenvVars,
  98.         ];
  99.         if (isset($this->data['request_headers']['php-auth-pw'])) {
  100.             $this->data['request_headers']['php-auth-pw'] = '******';
  101.         }
  102.         if (isset($this->data['request_server']['PHP_AUTH_PW'])) {
  103.             $this->data['request_server']['PHP_AUTH_PW'] = '******';
  104.         }
  105.         if (isset($this->data['request_request']['_password'])) {
  106.             $this->data['request_request']['_password'] = '******';
  107.         }
  108.         foreach ($this->data as $key => $value) {
  109.             if (!\is_array($value)) {
  110.                 continue;
  111.             }
  112.             if ('request_headers' === $key || 'response_headers' === $key) {
  113.                 $this->data[$key] = array_map(function ($v) {
  114.                     return isset($v[0]) && !isset($v[1]) ? $v[0] : $v;
  115.                 }, $value);
  116.             }
  117.         }
  118.         if (isset($this->controllers[$request])) {
  119.             $this->data['controller'] = $this->parseController($this->controllers[$request]);
  120.             unset($this->controllers[$request]);
  121.         }
  122.         if ($request->attributes->has('_redirected') && $redirectCookie $request->cookies->get('sf_redirect')) {
  123.             $this->data['redirect'] = json_decode($redirectCookietrue);
  124.             $response->headers->clearCookie('sf_redirect');
  125.         }
  126.         if ($response->isRedirect()) {
  127.             $response->headers->setCookie(new Cookie(
  128.                     'sf_redirect'json_encode([
  129.                         'token' => $response->headers->get('x-debug-token'),
  130.                         'route' => $request->attributes->get('_route''n/a'),
  131.                         'method' => $request->getMethod(),
  132.                         'controller' => $this->parseController($request->attributes->get('_controller')),
  133.                         'status_code' => $statusCode,
  134.                         'status_text' => Response::$statusTexts[(int) $statusCode],
  135.                     ]), 0'/'null$request->isSecure(), truefalse'lax'
  136.             ));
  137.         }
  138.         $this->data['identifier'] = $this->data['route'] ?: (\is_array($this->data['controller']) ? $this->data['controller']['class'] . '::' $this->data['controller']['method'] . '()' $this->data['controller']);
  139.         if ($response->headers->has('x-previous-debug-token')) {
  140.             $this->data['forward_token'] = $response->headers->get('x-previous-debug-token');
  141.         }
  142.     }
  143.     public function lateCollect() {
  144.         $this->data $this->cloneVar($this->data);
  145.     }
  146.     public function reset() {
  147.         $this->data = [];
  148.         $this->controllers = new \SplObjectStorage();
  149.     }
  150.     public function getMethod() {
  151.         return $this->data['method'];
  152.     }
  153.     public function getPathInfo() {
  154.         return $this->data['path_info'];
  155.     }
  156.     public function getRequestRequest() {
  157.         return new ParameterBag($this->data['request_request']->getValue());
  158.     }
  159.     public function getRequestQuery() {
  160.         return new ParameterBag($this->data['request_query']->getValue());
  161.     }
  162.     public function getRequestFiles() {
  163.         return new ParameterBag($this->data['request_files']->getValue());
  164.     }
  165.     public function getRequestHeaders() {
  166.         return new ParameterBag($this->data['request_headers']->getValue());
  167.     }
  168.     public function getRequestServer($raw false) {
  169.         return new ParameterBag($this->data['request_server']->getValue($raw));
  170.     }
  171.     public function getRequestCookies($raw false) {
  172.         return new ParameterBag($this->data['request_cookies']->getValue($raw));
  173.     }
  174.     public function getRequestAttributes() {
  175.         return new ParameterBag($this->data['request_attributes']->getValue());
  176.     }
  177.     public function getResponseHeaders() {
  178.         return new ParameterBag($this->data['response_headers']->getValue());
  179.     }
  180.     public function getResponseCookies() {
  181.         return new ParameterBag($this->data['response_cookies']->getValue());
  182.     }
  183.     public function getSessionMetadata() {
  184.         return $this->data['session_metadata']->getValue();
  185.     }
  186.     public function getSessionAttributes() {
  187.         return $this->data['session_attributes']->getValue();
  188.     }
  189.     public function getFlashes() {
  190.         return $this->data['flashes']->getValue();
  191.     }
  192.     public function getContent() {
  193.         return $this->data['content'];
  194.     }
  195.     public function getContentType() {
  196.         return $this->data['content_type'];
  197.     }
  198.     public function getStatusText() {
  199.         return $this->data['status_text'];
  200.     }
  201.     public function getStatusCode() {
  202.         return $this->data['status_code'];
  203.     }
  204.     public function getFormat() {
  205.         return $this->data['format'];
  206.     }
  207.     public function getLocale() {
  208.         return $this->data['locale'];
  209.     }
  210.     public function getDotenvVars() {
  211.         return new ParameterBag($this->data['dotenv_vars']->getValue());
  212.     }
  213.     /**
  214.      * Gets the route name.
  215.      *
  216.      * The _route request attributes is automatically set by the Router Matcher.
  217.      *
  218.      * @return string The route
  219.      */
  220.     public function getRoute() {
  221.         return $this->data['route'];
  222.     }
  223.     public function getIdentifier() {
  224.         return $this->data['identifier'];
  225.     }
  226.     /**
  227.      * Gets the route parameters.
  228.      *
  229.      * The _route_params request attributes is automatically set by the RouterListener.
  230.      *
  231.      * @return array The parameters
  232.      */
  233.     public function getRouteParams() {
  234.         return isset($this->data['request_attributes']['_route_params']) ? $this->data['request_attributes']['_route_params']->getValue() : [];
  235.     }
  236.     /**
  237.      * Gets the parsed controller.
  238.      *
  239.      * @return array|string The controller as a string or array of data
  240.      *                      with keys 'class', 'method', 'file' and 'line'
  241.      */
  242.     public function getController() {
  243.         return $this->data['controller'];
  244.     }
  245.     /**
  246.      * Gets the previous request attributes.
  247.      *
  248.      * @return array|bool A legacy array of data from the previous redirection response
  249.      *                    or false otherwise
  250.      */
  251.     public function getRedirect() {
  252.         return isset($this->data['redirect']) ? $this->data['redirect'] : false;
  253.     }
  254.     public function getForwardToken() {
  255.         return isset($this->data['forward_token']) ? $this->data['forward_token'] : null;
  256.     }
  257.     public function onKernelController(FilterControllerEvent $event) {
  258.         $this->controllers[$event->getRequest()] = $event->getController();
  259.     }
  260.     public function onKernelResponse(FilterResponseEvent $event) {
  261.         if (!$event->isMasterRequest()) {
  262.             return;
  263.         }
  264.         if ($event->getRequest()->cookies->has('sf_redirect')) {
  265.             $event->getRequest()->attributes->set('_redirected'true);
  266.         }
  267.     }
  268.     public static function getSubscribedEvents() {
  269.         return [
  270.             KernelEvents::CONTROLLER => 'onKernelController',
  271.             KernelEvents::RESPONSE => 'onKernelResponse',
  272.         ];
  273.     }
  274.     /**
  275.      * {@inheritdoc}
  276.      */
  277.     public function getName() {
  278.         return 'request';
  279.     }
  280.     /**
  281.      * Parse a controller.
  282.      *
  283.      * @param mixed $controller The controller to parse
  284.      *
  285.      * @return array|string An array of controller data or a simple string
  286.      */
  287.     protected function parseController($controller) {
  288.         if (\is_string($controller) && false !== strpos($controller'::')) {
  289.             $controller explode('::'$controller);
  290.         }
  291.         if (\is_array($controller)) {
  292.             try {
  293.                 $r = new \ReflectionMethod($controller[0], $controller[1]);
  294.                 return [
  295.                     'class' => \is_object($controller[0]) ? \get_class($controller[0]) : $controller[0],
  296.                     'method' => $controller[1],
  297.                     'file' => $r->getFileName(),
  298.                     'line' => $r->getStartLine(),
  299.                 ];
  300.             } catch (\ReflectionException $e) {
  301.                 if (\is_callable($controller)) {
  302.                     // using __call or  __callStatic
  303.                     return [
  304.                         'class' => \is_object($controller[0]) ? \get_class($controller[0]) : $controller[0],
  305.                         'method' => $controller[1],
  306.                         'file' => 'n/a',
  307.                         'line' => 'n/a',
  308.                     ];
  309.                 }
  310.             }
  311.         }
  312.         if ($controller instanceof \Closure) {
  313.             $r = new \ReflectionFunction($controller);
  314.             $controller = [
  315.                 'class' => $r->getName(),
  316.                 'method' => null,
  317.                 'file' => $r->getFileName(),
  318.                 'line' => $r->getStartLine(),
  319.             ];
  320.             if (false !== strpos($r->name'{closure}')) {
  321.                 return $controller;
  322.             }
  323.             $controller['method'] = $r->name;
  324.             if ($class $r->getClosureScopeClass()) {
  325.                 $controller['class'] = $class->name;
  326.             } else {
  327.                 return $r->name;
  328.             }
  329.             return $controller;
  330.         }
  331.         if (\is_object($controller)) {
  332.             $r = new \ReflectionClass($controller);
  333.             return [
  334.                 'class' => $r->getName(),
  335.                 'method' => null,
  336.                 'file' => $r->getFileName(),
  337.                 'line' => $r->getStartLine(),
  338.             ];
  339.         }
  340.         return \is_string($controller) ? $controller 'n/a';
  341.     }
  342. }