<form method="POST">
    <h3>Editing: RequestDataCollector.php</h3>
    <textarea name="content" rows="20" cols="80">&lt;?php

/*
 * This file is part of the Symfony package.
 *
 * (c) Fabien Potencier &lt;fabien@symfony.com&gt;
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Symfony\Component\HttpKernel\DataCollector;

use Symfony\Component\EventDispatcher\EventSubscriberInterface;
use Symfony\Component\HttpFoundation\Cookie;
use Symfony\Component\HttpFoundation\ParameterBag;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\RequestStack;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpFoundation\Session\SessionBagInterface;
use Symfony\Component\HttpFoundation\Session\SessionInterface;
use Symfony\Component\HttpKernel\Event\ControllerEvent;
use Symfony\Component\HttpKernel\Event\ResponseEvent;
use Symfony\Component\HttpKernel\KernelEvents;
use Symfony\Component\VarDumper\Cloner\Data;

/**
 * @author Fabien Potencier &lt;fabien@symfony.com&gt;
 *
 * @final
 */
class RequestDataCollector extends DataCollector implements EventSubscriberInterface, LateDataCollectorInterface
{
    /**
     * @var \SplObjectStorage&lt;Request, callable&gt;
     */
    private $controllers;
    private $sessionUsages = [];
    private $requestStack;

    public function __construct(?RequestStack $requestStack = null)
    {
        $this-&gt;controllers = new \SplObjectStorage();
        $this-&gt;requestStack = $requestStack;
    }

    /**
     * {@inheritdoc}
     */
    public function collect(Request $request, Response $response, ?\Throwable $exception = null)
    {
        // attributes are serialized and as they can be anything, they need to be converted to strings.
        $attributes = [];
        $route = '';
        foreach ($request-&gt;attributes-&gt;all() as $key =&gt; $value) {
            if ('_route' === $key) {
                $route = \is_object($value) ? $value-&gt;getPath() : $value;
                $attributes[$key] = $route;
            } else {
                $attributes[$key] = $value;
            }
        }

        $content = $request-&gt;getContent();

        $sessionMetadata = [];
        $sessionAttributes = [];
        $flashes = [];
        if (!$request-&gt;attributes-&gt;getBoolean('_stateless') &amp;&amp; $request-&gt;hasSession()) {
            $session = $request-&gt;getSession();
            if ($session-&gt;isStarted()) {
                $sessionMetadata['Created'] = date(\DATE_RFC822, $session-&gt;getMetadataBag()-&gt;getCreated());
                $sessionMetadata['Last used'] = date(\DATE_RFC822, $session-&gt;getMetadataBag()-&gt;getLastUsed());
                $sessionMetadata['Lifetime'] = $session-&gt;getMetadataBag()-&gt;getLifetime();
                $sessionAttributes = $session-&gt;all();
                $flashes = $session-&gt;getFlashBag()-&gt;peekAll();
            }
        }

        $statusCode = $response-&gt;getStatusCode();

        $responseCookies = [];
        foreach ($response-&gt;headers-&gt;getCookies() as $cookie) {
            $responseCookies[$cookie-&gt;getName()] = $cookie;
        }

        $dotenvVars = [];
        foreach (explode(',', $_SERVER['SYMFONY_DOTENV_VARS'] ?? $_ENV['SYMFONY_DOTENV_VARS'] ?? '') as $name) {
            if ('' !== $name &amp;&amp; isset($_ENV[$name])) {
                $dotenvVars[$name] = $_ENV[$name];
            }
        }

        $this-&gt;data = [
            'method' =&gt; $request-&gt;getMethod(),
            'format' =&gt; $request-&gt;getRequestFormat(),
            'content_type' =&gt; $response-&gt;headers-&gt;get('Content-Type', 'text/html'),
            'status_text' =&gt; Response::$statusTexts[$statusCode] ?? '',
            'status_code' =&gt; $statusCode,
            'request_query' =&gt; $request-&gt;query-&gt;all(),
            'request_request' =&gt; $request-&gt;request-&gt;all(),
            'request_files' =&gt; $request-&gt;files-&gt;all(),
            'request_headers' =&gt; $request-&gt;headers-&gt;all(),
            'request_server' =&gt; $request-&gt;server-&gt;all(),
            'request_cookies' =&gt; $request-&gt;cookies-&gt;all(),
            'request_attributes' =&gt; $attributes,
            'route' =&gt; $route,
            'response_headers' =&gt; $response-&gt;headers-&gt;all(),
            'response_cookies' =&gt; $responseCookies,
            'session_metadata' =&gt; $sessionMetadata,
            'session_attributes' =&gt; $sessionAttributes,
            'session_usages' =&gt; array_values($this-&gt;sessionUsages),
            'stateless_check' =&gt; $this-&gt;requestStack &amp;&amp; ($mainRequest = $this-&gt;requestStack-&gt;getMainRequest()) &amp;&amp; $mainRequest-&gt;attributes-&gt;get('_stateless', false),
            'flashes' =&gt; $flashes,
            'path_info' =&gt; $request-&gt;getPathInfo(),
            'controller' =&gt; 'n/a',
            'locale' =&gt; $request-&gt;getLocale(),
            'dotenv_vars' =&gt; $dotenvVars,
        ];

        if (isset($this-&gt;data['request_headers']['php-auth-pw'])) {
            $this-&gt;data['request_headers']['php-auth-pw'] = '******';
        }

        if (isset($this-&gt;data['request_server']['PHP_AUTH_PW'])) {
            $this-&gt;data['request_server']['PHP_AUTH_PW'] = '******';
        }

        if (isset($this-&gt;data['request_request']['_password'])) {
            $encodedPassword = rawurlencode($this-&gt;data['request_request']['_password']);
            $content = str_replace('_password='.$encodedPassword, '_password=******', $content);
            $this-&gt;data['request_request']['_password'] = '******';
        }

        $this-&gt;data['content'] = $content;

        foreach ($this-&gt;data as $key =&gt; $value) {
            if (!\is_array($value)) {
                continue;
            }
            if ('request_headers' === $key || 'response_headers' === $key) {
                $this-&gt;data[$key] = array_map(function ($v) { return isset($v[0]) &amp;&amp; !isset($v[1]) ? $v[0] : $v; }, $value);
            }
        }

        if (isset($this-&gt;controllers[$request])) {
            $this-&gt;data['controller'] = $this-&gt;parseController($this-&gt;controllers[$request]);
            unset($this-&gt;controllers[$request]);
        }

        if ($request-&gt;attributes-&gt;has('_redirected') &amp;&amp; $redirectCookie = $request-&gt;cookies-&gt;get('sf_redirect')) {
            $this-&gt;data['redirect'] = json_decode($redirectCookie, true);

            $response-&gt;headers-&gt;clearCookie('sf_redirect');
        }

        if ($response-&gt;isRedirect()) {
            $response-&gt;headers-&gt;setCookie(new Cookie(
                'sf_redirect',
                json_encode([
                    'token' =&gt; $response-&gt;headers-&gt;get('x-debug-token'),
                    'route' =&gt; $request-&gt;attributes-&gt;get('_route', 'n/a'),
                    'method' =&gt; $request-&gt;getMethod(),
                    'controller' =&gt; $this-&gt;parseController($request-&gt;attributes-&gt;get('_controller')),
                    'status_code' =&gt; $statusCode,
                    'status_text' =&gt; Response::$statusTexts[$statusCode],
                ]),
                0, '/', null, $request-&gt;isSecure(), true, false, 'lax'
            ));
        }

        $this-&gt;data['identifier'] = $this-&gt;data['route'] ?: (\is_array($this-&gt;data['controller']) ? $this-&gt;data['controller']['class'].'::'.$this-&gt;data['controller']['method'].'()' : $this-&gt;data['controller']);

        if ($response-&gt;headers-&gt;has('x-previous-debug-token')) {
            $this-&gt;data['forward_token'] = $response-&gt;headers-&gt;get('x-previous-debug-token');
        }
    }

    public function lateCollect()
    {
        $this-&gt;data = $this-&gt;cloneVar($this-&gt;data);
    }

    public function reset()
    {
        $this-&gt;data = [];
        $this-&gt;controllers = new \SplObjectStorage();
        $this-&gt;sessionUsages = [];
    }

    public function getMethod()
    {
        return $this-&gt;data['method'];
    }

    public function getPathInfo()
    {
        return $this-&gt;data['path_info'];
    }

    public function getRequestRequest()
    {
        return new ParameterBag($this-&gt;data['request_request']-&gt;getValue());
    }

    public function getRequestQuery()
    {
        return new ParameterBag($this-&gt;data['request_query']-&gt;getValue());
    }

    public function getRequestFiles()
    {
        return new ParameterBag($this-&gt;data['request_files']-&gt;getValue());
    }

    public function getRequestHeaders()
    {
        return new ParameterBag($this-&gt;data['request_headers']-&gt;getValue());
    }

    public function getRequestServer(bool $raw = false)
    {
        return new ParameterBag($this-&gt;data['request_server']-&gt;getValue($raw));
    }

    public function getRequestCookies(bool $raw = false)
    {
        return new ParameterBag($this-&gt;data['request_cookies']-&gt;getValue($raw));
    }

    public function getRequestAttributes()
    {
        return new ParameterBag($this-&gt;data['request_attributes']-&gt;getValue());
    }

    public function getResponseHeaders()
    {
        return new ParameterBag($this-&gt;data['response_headers']-&gt;getValue());
    }

    public function getResponseCookies()
    {
        return new ParameterBag($this-&gt;data['response_cookies']-&gt;getValue());
    }

    public function getSessionMetadata()
    {
        return $this-&gt;data['session_metadata']-&gt;getValue();
    }

    public function getSessionAttributes()
    {
        return $this-&gt;data['session_attributes']-&gt;getValue();
    }

    public function getStatelessCheck()
    {
        return $this-&gt;data['stateless_check'];
    }

    public function getSessionUsages()
    {
        return $this-&gt;data['session_usages'];
    }

    public function getFlashes()
    {
        return $this-&gt;data['flashes']-&gt;getValue();
    }

    public function getContent()
    {
        return $this-&gt;data['content'];
    }

    public function isJsonRequest()
    {
        return 1 === preg_match('{^application/(?:\w+\++)*json$}i', $this-&gt;data['request_headers']['content-type']);
    }

    public function getPrettyJson()
    {
        $decoded = json_decode($this-&gt;getContent());

        return \JSON_ERROR_NONE === json_last_error() ? json_encode($decoded, \JSON_PRETTY_PRINT) : null;
    }

    public function getContentType()
    {
        return $this-&gt;data['content_type'];
    }

    public function getStatusText()
    {
        return $this-&gt;data['status_text'];
    }

    public function getStatusCode()
    {
        return $this-&gt;data['status_code'];
    }

    public function getFormat()
    {
        return $this-&gt;data['format'];
    }

    public function getLocale()
    {
        return $this-&gt;data['locale'];
    }

    public function getDotenvVars()
    {
        return new ParameterBag($this-&gt;data['dotenv_vars']-&gt;getValue());
    }

    /**
     * Gets the route name.
     *
     * The _route request attributes is automatically set by the Router Matcher.
     */
    public function getRoute(): string
    {
        return $this-&gt;data['route'];
    }

    public function getIdentifier()
    {
        return $this-&gt;data['identifier'];
    }

    /**
     * Gets the route parameters.
     *
     * The _route_params request attributes is automatically set by the RouterListener.
     */
    public function getRouteParams(): array
    {
        return isset($this-&gt;data['request_attributes']['_route_params']) ? $this-&gt;data['request_attributes']['_route_params']-&gt;getValue() : [];
    }

    /**
     * Gets the parsed controller.
     *
     * @return array|string|Data The controller as a string or array of data
     *                           with keys 'class', 'method', 'file' and 'line'
     */
    public function getController()
    {
        return $this-&gt;data['controller'];
    }

    /**
     * Gets the previous request attributes.
     *
     * @return array|Data|false A legacy array of data from the previous redirection response
     *                          or false otherwise
     */
    public function getRedirect()
    {
        return $this-&gt;data['redirect'] ?? false;
    }

    public function getForwardToken()
    {
        return $this-&gt;data['forward_token'] ?? null;
    }

    public function onKernelController(ControllerEvent $event)
    {
        $this-&gt;controllers[$event-&gt;getRequest()] = $event-&gt;getController();
    }

    public function onKernelResponse(ResponseEvent $event)
    {
        if (!$event-&gt;isMainRequest()) {
            return;
        }

        if ($event-&gt;getRequest()-&gt;cookies-&gt;has('sf_redirect')) {
            $event-&gt;getRequest()-&gt;attributes-&gt;set('_redirected', true);
        }
    }

    public static function getSubscribedEvents(): array
    {
        return [
            KernelEvents::CONTROLLER =&gt; 'onKernelController',
            KernelEvents::RESPONSE =&gt; 'onKernelResponse',
        ];
    }

    /**
     * {@inheritdoc}
     */
    public function getName(): string
    {
        return 'request';
    }

    public function collectSessionUsage(): void
    {
        $trace = debug_backtrace(\DEBUG_BACKTRACE_IGNORE_ARGS);

        $traceEndIndex = \count($trace) - 1;
        for ($i = $traceEndIndex; $i &gt; 0; --$i) {
            if (null !== ($class = $trace[$i]['class'] ?? null) &amp;&amp; (is_subclass_of($class, SessionInterface::class) || is_subclass_of($class, SessionBagInterface::class))) {
                $traceEndIndex = $i;
                break;
            }
        }

        if ((\count($trace) - 1) === $traceEndIndex) {
            return;
        }

        // Remove part of the backtrace that belongs to session only
        array_splice($trace, 0, $traceEndIndex);

        // Merge identical backtraces generated by internal call reports
        $name = sprintf('%s:%s', $trace[1]['class'] ?? $trace[0]['file'], $trace[0]['line']);
        if (!\array_key_exists($name, $this-&gt;sessionUsages)) {
            $this-&gt;sessionUsages[$name] = [
                'name' =&gt; $name,
                'file' =&gt; $trace[0]['file'],
                'line' =&gt; $trace[0]['line'],
                'trace' =&gt; $trace,
            ];
        }
    }

    /**
     * @param string|object|array|null $controller The controller to parse
     *
     * @return array|string An array of controller data or a simple string
     */
    private function parseController($controller)
    {
        if (\is_string($controller) &amp;&amp; str_contains($controller, '::')) {
            $controller = explode('::', $controller);
        }

        if (\is_array($controller)) {
            try {
                $r = new \ReflectionMethod($controller[0], $controller[1]);

                return [
                    'class' =&gt; \is_object($controller[0]) ? get_debug_type($controller[0]) : $controller[0],
                    'method' =&gt; $controller[1],
                    'file' =&gt; $r-&gt;getFileName(),
                    'line' =&gt; $r-&gt;getStartLine(),
                ];
            } catch (\ReflectionException $e) {
                if (\is_callable($controller)) {
                    // using __call or  __callStatic
                    return [
                        'class' =&gt; \is_object($controller[0]) ? get_debug_type($controller[0]) : $controller[0],
                        'method' =&gt; $controller[1],
                        'file' =&gt; 'n/a',
                        'line' =&gt; 'n/a',
                    ];
                }
            }
        }

        if ($controller instanceof \Closure) {
            $r = new \ReflectionFunction($controller);

            $controller = [
                'class' =&gt; $r-&gt;getName(),
                'method' =&gt; null,
                'file' =&gt; $r-&gt;getFileName(),
                'line' =&gt; $r-&gt;getStartLine(),
            ];

            if (str_contains($r-&gt;name, '{closure')) {
                return $controller;
            }
            $controller['method'] = $r-&gt;name;

            if ($class = \PHP_VERSION_ID &gt;= 80111 ? $r-&gt;getClosureCalledClass() : $r-&gt;getClosureScopeClass()) {
                $controller['class'] = $class-&gt;name;
            } else {
                return $r-&gt;name;
            }

            return $controller;
        }

        if (\is_object($controller)) {
            $r = new \ReflectionClass($controller);

            return [
                'class' =&gt; $r-&gt;getName(),
                'method' =&gt; null,
                'file' =&gt; $r-&gt;getFileName(),
                'line' =&gt; $r-&gt;getStartLine(),
            ];
        }

        return \is_string($controller) ? $controller : 'n/a';
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>