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

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\Response;
  19. use Symfony\Component\HttpKernel\Event\FilterControllerEvent;
  20. use Symfony\Component\HttpKernel\Event\FilterResponseEvent;
  21. use Symfony\Component\HttpKernel\KernelEvents;
  23. /**
  24.  * @author Fabien Potencier <fabien@symfony.com>
  25.  *
  26.  * @final since Symfony 4.4
  27.  */
  28. class RequestDataCollector extends DataCollector implements EventSubscriberInterface, LateDataCollectorInterface
  29. {
  30.     protected $controllers;
  32.     public function __construct()
  33.     {
  34.         $this->controllers = new \SplObjectStorage();
  35.     }
  37.     /**
  38.      * {@inheritdoc}
  39.      *
  40.      * @param \Throwable|null $exception
  41.      */
  42.     public function collect(Request $request, Response $response/*, \Throwable $exception = null*/)
  43.     {
  44.         // attributes are serialized and as they can be anything, they need to be converted to strings.
  45.         $attributes = [];
  46.         $route = '';
  47.         foreach ($request->attributes->all() as $key => $value) {
  48.             if ('_route' === $key) {
  49.                 $route = \is_object($value) ? $value->getPath() : $value;
  50.                 $attributes[$key] = $route;
  51.             } else {
  52.                 $attributes[$key] = $value;
  53.             }
  54.         }
  56.         $content = $request->getContent();
  58.         $sessionMetadata = [];
  59.         $sessionAttributes = [];
  60.         $flashes = [];
  61.         if ($request->hasSession()) {
  62.             $session = $request->getSession();
  63.             if ($session->isStarted()) {
  64.                 $sessionMetadata['Created'] = date(\DATE_RFC822, $session->getMetadataBag()->getCreated());
  65.                 $sessionMetadata['Last used'] = date(\DATE_RFC822, $session->getMetadataBag()->getLastUsed());
  66.                 $sessionMetadata['Lifetime'] = $session->getMetadataBag()->getLifetime();
  67.                 $sessionAttributes = $session->all();
  68.                 $flashes = $session->getFlashBag()->peekAll();
  69.             }
  70.         }
  72.         $statusCode = $response->getStatusCode();
  74.         $responseCookies = [];
  75.         foreach ($response->headers->getCookies() as $cookie) {
  76.             $responseCookies[$cookie->getName()] = $cookie;
  77.         }
  79.         $dotenvVars = [];
  80.         foreach (explode(',', $_SERVER['SYMFONY_DOTENV_VARS'] ?? $_ENV['SYMFONY_DOTENV_VARS'] ?? '') as $name) {
  81.             if ('' !== $name && isset($_ENV[$name])) {
  82.                 $dotenvVars[$name] = $_ENV[$name];
  83.             }
  84.         }
  86.         $this->data = [
  87.             'method' => $request->getMethod(),
  88.             'format' => $request->getRequestFormat(),
  89.             'content' => $content,
  90.             'content_type' => $response->headers->get('Content-Type', 'text/html'),
  91.             'status_text' => Response::$statusTexts[$statusCode] ?? '',
  92.             'status_code' => $statusCode,
  93.             'request_query' => $request->query->all(),
  94.             'request_request' => $request->request->all(),
  95.             'request_files' => $request->files->all(),
  96.             'request_headers' => $request->headers->all(),
  97.             'request_server' => $request->server->all(),
  98.             'request_cookies' => $request->cookies->all(),
  99.             'request_attributes' => $attributes,
  100.             'route' => $route,
  101.             'response_headers' => $response->headers->all(),
  102.             'response_cookies' => $responseCookies,
  103.             'session_metadata' => $sessionMetadata,
  104.             'session_attributes' => $sessionAttributes,
  105.             'flashes' => $flashes,
  106.             'path_info' => $request->getPathInfo(),
  107.             'controller' => 'n/a',
  108.             'locale' => $request->getLocale(),
  109.             'dotenv_vars' => $dotenvVars,
  110.         ];
  112.         if (isset($this->data['request_headers']['php-auth-pw'])) {
  113.             $this->data['request_headers']['php-auth-pw'] = '******';
  114.         }
  116.         if (isset($this->data['request_server']['PHP_AUTH_PW'])) {
  117.             $this->data['request_server']['PHP_AUTH_PW'] = '******';
  118.         }
  120.         if (isset($this->data['request_request']['_password'])) {
  121.             $this->data['request_request']['_password'] = '******';
  122.         }
  124.         foreach ($this->data as $key => $value) {
  125.             if (!\is_array($value)) {
  126.                 continue;
  127.             }
  128.             if ('request_headers' === $key || 'response_headers' === $key) {
  129.                 $this->data[$key] = array_map(function ($v) { return isset($v[0]) && !isset($v[1]) ? $v[0] : $v; }, $value);
  130.             }
  131.         }
  133.         if (isset($this->controllers[$request])) {
  134.             $this->data['controller'] = $this->parseController($this->controllers[$request]);
  135.             unset($this->controllers[$request]);
  136.         }
  138.         if ($request->attributes->has('_redirected') && $redirectCookie = $request->cookies->get('sf_redirect')) {
  139.             $this->data['redirect'] = json_decode($redirectCookie, true);
  141.             $response->headers->clearCookie('sf_redirect');
  142.         }
  144.         if ($response->isRedirect()) {
  145.             $response->headers->setCookie(new Cookie(
  146.                 'sf_redirect',
  147.                 json_encode([
  148.                     'token' => $response->headers->get('x-debug-token'),
  149.                     'route' => $request->attributes->get('_route', 'n/a'),
  150.                     'method' => $request->getMethod(),
  151.                     'controller' => $this->parseController($request->attributes->get('_controller')),
  152.                     'status_code' => $statusCode,
  153.                     'status_text' => Response::$statusTexts[(int) $statusCode],
  154.                 ]),
  155.                 0, '/', null, $request->isSecure(), true, false, 'lax'
  156.             ));
  157.         }
  159.         $this->data['identifier'] = $this->data['route'] ?: (\is_array($this->data['controller']) ? $this->data['controller']['class'].'::'.$this->data['controller']['method'].'()' : $this->data['controller']);
  161.         if ($response->headers->has('x-previous-debug-token')) {
  162.             $this->data['forward_token'] = $response->headers->get('x-previous-debug-token');
  163.         }
  164.     }
  166.     public function lateCollect()
  167.     {
  168.         $this->data = $this->cloneVar($this->data);
  169.     }
  171.     public function reset()
  172.     {
  173.         $this->data = [];
  174.         $this->controllers = new \SplObjectStorage();
  175.     }
  177.     public function getMethod()
  178.     {
  179.         return $this->data['method'];
  180.     }
  182.     public function getPathInfo()
  183.     {
  184.         return $this->data['path_info'];
  185.     }
  187.     public function getRequestRequest()
  188.     {
  189.         return new ParameterBag($this->data['request_request']->getValue());
  190.     }
  192.     public function getRequestQuery()
  193.     {
  194.         return new ParameterBag($this->data['request_query']->getValue());
  195.     }
  197.     public function getRequestFiles()
  198.     {
  199.         return new ParameterBag($this->data['request_files']->getValue());
  200.     }
  202.     public function getRequestHeaders()
  203.     {
  204.         return new ParameterBag($this->data['request_headers']->getValue());
  205.     }
  207.     public function getRequestServer($raw = false)
  208.     {
  209.         return new ParameterBag($this->data['request_server']->getValue($raw));
  210.     }
  212.     public function getRequestCookies($raw = false)
  213.     {
  214.         return new ParameterBag($this->data['request_cookies']->getValue($raw));
  215.     }
  217.     public function getRequestAttributes()
  218.     {
  219.         return new ParameterBag($this->data['request_attributes']->getValue());
  220.     }
  222.     public function getResponseHeaders()
  223.     {
  224.         return new ParameterBag($this->data['response_headers']->getValue());
  225.     }
  227.     public function getResponseCookies()
  228.     {
  229.         return new ParameterBag($this->data['response_cookies']->getValue());
  230.     }
  232.     public function getSessionMetadata()
  233.     {
  234.         return $this->data['session_metadata']->getValue();
  235.     }
  237.     public function getSessionAttributes()
  238.     {
  239.         return $this->data['session_attributes']->getValue();
  240.     }
  242.     public function getFlashes()
  243.     {
  244.         return $this->data['flashes']->getValue();
  245.     }
  247.     public function getContent()
  248.     {
  249.         return $this->data['content'];
  250.     }
  252.     public function isJsonRequest()
  253.     {
  254.         return 1 === preg_match('{^application/(?:\w+\++)*json$}i', $this->data['request_headers']['content-type']);
  255.     }
  257.     public function getPrettyJson()
  258.     {
  259.         $decoded = json_decode($this->getContent());
  261.         return \JSON_ERROR_NONE === json_last_error() ? json_encode($decoded, \JSON_PRETTY_PRINT) : null;
  262.     }
  264.     public function getContentType()
  265.     {
  266.         return $this->data['content_type'];
  267.     }
  269.     public function getStatusText()
  270.     {
  271.         return $this->data['status_text'];
  272.     }
  274.     public function getStatusCode()
  275.     {
  276.         return $this->data['status_code'];
  277.     }
  279.     public function getFormat()
  280.     {
  281.         return $this->data['format'];
  282.     }
  284.     public function getLocale()
  285.     {
  286.         return $this->data['locale'];
  287.     }
  289.     public function getDotenvVars()
  290.     {
  291.         return new ParameterBag($this->data['dotenv_vars']->getValue());
  292.     }
  294.     /**
  295.      * Gets the route name.
  296.      *
  297.      * The _route request attributes is automatically set by the Router Matcher.
  298.      *
  299.      * @return string The route
  300.      */
  301.     public function getRoute()
  302.     {
  303.         return $this->data['route'];
  304.     }
  306.     public function getIdentifier()
  307.     {
  308.         return $this->data['identifier'];
  309.     }
  311.     /**
  312.      * Gets the route parameters.
  313.      *
  314.      * The _route_params request attributes is automatically set by the RouterListener.
  315.      *
  316.      * @return array The parameters
  317.      */
  318.     public function getRouteParams()
  319.     {
  320.         return isset($this->data['request_attributes']['_route_params']) ? $this->data['request_attributes']['_route_params']->getValue() : [];
  321.     }
  323.     /**
  324.      * Gets the parsed controller.
  325.      *
  326.      * @return array|string The controller as a string or array of data
  327.      *                      with keys 'class', 'method', 'file' and 'line'
  328.      */
  329.     public function getController()
  330.     {
  331.         return $this->data['controller'];
  332.     }
  334.     /**
  335.      * Gets the previous request attributes.
  336.      *
  337.      * @return array|bool A legacy array of data from the previous redirection response
  338.      *                    or false otherwise
  339.      */
  340.     public function getRedirect()
  341.     {
  342.         return $this->data['redirect'] ?? false;
  343.     }
  345.     public function getForwardToken()
  346.     {
  347.         return $this->data['forward_token'] ?? null;
  348.     }
  350.     /**
  351.      * @final since Symfony 4.3
  352.      */
  353.     public function onKernelController(FilterControllerEvent $event)
  354.     {
  355.         $this->controllers[$event->getRequest()] = $event->getController();
  356.     }
  358.     /**
  359.      * @final since Symfony 4.3
  360.      */
  361.     public function onKernelResponse(FilterResponseEvent $event)
  362.     {
  363.         if (!$event->isMasterRequest()) {
  364.             return;
  365.         }
  367.         if ($event->getRequest()->cookies->has('sf_redirect')) {
  368.             $event->getRequest()->attributes->set('_redirected', true);
  369.         }
  370.     }
  372.     public static function getSubscribedEvents()
  373.     {
  374.         return [
  375.             KernelEvents::CONTROLLER => 'onKernelController',
  376.             KernelEvents::RESPONSE => 'onKernelResponse',
  377.         ];
  378.     }
  380.     /**
  381.      * {@inheritdoc}
  382.      */
  383.     public function getName()
  384.     {
  385.         return 'request';
  386.     }
  388.     /**
  389.      * Parse a controller.
  390.      *
  391.      * @param string|object|array|null $controller The controller to parse
  392.      *
  393.      * @return array|string An array of controller data or a simple string
  394.      */
  395.     protected function parseController($controller)
  396.     {
  397.         if (\is_string($controller) && str_contains($controller, '::')) {
  398.             $controller = explode('::', $controller);
  399.         }
  401.         if (\is_array($controller)) {
  402.             try {
  403.                 $r = new \ReflectionMethod($controller[0], $controller[1]);
  405.                 return [
  406.                     'class' => \is_object($controller[0]) ? \get_class($controller[0]) : $controller[0],
  407.                     'method' => $controller[1],
  408.                     'file' => $r->getFileName(),
  409.                     'line' => $r->getStartLine(),
  410.                 ];
  411.             } catch (\ReflectionException $e) {
  412.                 if (\is_callable($controller)) {
  413.                     // using __call or  __callStatic
  414.                     return [
  415.                         'class' => \is_object($controller[0]) ? \get_class($controller[0]) : $controller[0],
  416.                         'method' => $controller[1],
  417.                         'file' => 'n/a',
  418.                         'line' => 'n/a',
  419.                     ];
  420.                 }
  421.             }
  422.         }
  424.         if ($controller instanceof \Closure) {
  425.             $r = new \ReflectionFunction($controller);
  427.             $controller = [
  428.                 'class' => $r->getName(),
  429.                 'method' => null,
  430.                 'file' => $r->getFileName(),
  431.                 'line' => $r->getStartLine(),
  432.             ];
  434.             if (str_contains($r->name, '{closure}')) {
  435.                 return $controller;
  436.             }
  437.             $controller['method'] = $r->name;
  439.             if ($class = $r->getClosureScopeClass()) {
  440.                 $controller['class'] = $class->name;
  441.             } else {
  442.                 return $r->name;
  443.             }
  445.             return $controller;
  446.         }
  448.         if (\is_object($controller)) {
  449.             $r = new \ReflectionClass($controller);
  451.             return [
  452.                 'class' => $r->getName(),
  453.                 'method' => null,
  454.                 'file' => $r->getFileName(),
  455.                 'line' => $r->getStartLine(),
  456.             ];
  457.         }
  459.         return \is_string($controller) ? $controller : 'n/a';
  460.     }
  461. }