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 $controllers;
  38. private $sessionUsages = [];
  39. private $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->attributes->getBoolean('_stateless') && $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 && ($mainRequest = $this->requestStack->getMainRequest()) && $mainRequest->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()
  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()
  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. * @param string|object|array|null $controller The controller to parse
  435. *
  436. * @return array|string An array of controller data or a simple string
  437. */
  438. private function parseController($controller)
  439. {
  440. if (\is_string($controller) && str_contains($controller, '::')) {
  441. $controller = explode('::', $controller);
  442. }
  444. if (\is_array($controller)) {
  445. try {
  446. $r = new \ReflectionMethod($controller[0], $controller[1]);
  448. return [
  449. 'class' => \is_object($controller[0]) ? get_debug_type($controller[0]) : $controller[0],
  450. 'method' => $controller[1],
  451. 'file' => $r->getFileName(),
  452. 'line' => $r->getStartLine(),
  453. ];
  454. } catch (\ReflectionException $e) {
  455. if (\is_callable($controller)) {
  456. // using __call or __callStatic
  457. return [
  458. 'class' => \is_object($controller[0]) ? get_debug_type($controller[0]) : $controller[0],
  459. 'method' => $controller[1],
  460. 'file' => 'n/a',
  461. 'line' => 'n/a',
  462. ];
  463. }
  464. }
  465. }
  467. if ($controller instanceof \Closure) {
  468. $r = new \ReflectionFunction($controller);
  470. $controller = [
  471. 'class' => $r->getName(),
  472. 'method' => null,
  473. 'file' => $r->getFileName(),
  474. 'line' => $r->getStartLine(),
  475. ];
  477. if (str_contains($r->name, '{closure')) {
  478. return $controller;
  479. }
  480. $controller['method'] = $r->name;
  482. if ($class = \PHP_VERSION_ID >= 80111 ? $r->getClosureCalledClass() : $r->getClosureScopeClass()) {
  483. $controller['class'] = $class->name;
  484. } else {
  485. return $r->name;
  486. }
  488. return $controller;
  489. }
  491. if (\is_object($controller)) {
  492. $r = new \ReflectionClass($controller);
  494. return [
  495. 'class' => $r->getName(),
  496. 'method' => null,
  497. 'file' => $r->getFileName(),
  498. 'line' => $r->getStartLine(),
  499. ];
  500. }
  502. return \is_string($controller) ? $controller : 'n/a';
  503. }
  504. }