vendor/symfony/http-client/DataCollector/HttpClientDataCollector.php line 39

  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\HttpClient\DataCollector;
  14. use Symfony\Component\HttpClient\HttpClientTrait;
  15. use Symfony\Component\HttpClient\TraceableHttpClient;
  16. use Symfony\Component\HttpFoundation\Request;
  17. use Symfony\Component\HttpFoundation\Response;
  18. use Symfony\Component\HttpKernel\DataCollector\DataCollector;
  19. use Symfony\Component\HttpKernel\DataCollector\LateDataCollectorInterface;
  20. use Symfony\Component\VarDumper\Caster\ImgStub;
  22. /**
  23.  * @author Jérémy Romey <jeremy@free-agent.fr>
  24.  */
  25. final class HttpClientDataCollector extends DataCollector implements LateDataCollectorInterface
  26. {
  27.     use HttpClientTrait;
  29.     /**
  30.      * @var TraceableHttpClient[]
  31.      */
  32.     private array $clients = [];
  34.     public function registerClient(string $name, TraceableHttpClient $client)
  35.     {
  36.         $this->clients[$name] = $client;
  37.     }
  39.     public function collect(Request $request, Response $response, \Throwable $exception = null)
  40.     {
  41.         $this->lateCollect();
  42.     }
  44.     public function lateCollect()
  45.     {
  46.         $this->data['request_count'] = $this->data['request_count'] ?? 0;
  47.         $this->data['error_count'] = $this->data['error_count'] ?? 0;
  48.         $this->data += ['clients' => []];
  50.         foreach ($this->clients as $name => $client) {
  51.             [$errorCount, $traces] = $this->collectOnClient($client);
  53.             $this->data['clients'] += [
  54.                 $name => [
  55.                     'traces' => [],
  56.                     'error_count' => 0,
  57.                 ],
  58.             ];
  60.             $this->data['clients'][$name]['traces'] = array_merge($this->data['clients'][$name]['traces'], $traces);
  61.             $this->data['request_count'] += \count($traces);
  62.             $this->data['error_count'] += $errorCount;
  63.             $this->data['clients'][$name]['error_count'] += $errorCount;
  65.             $client->reset();
  66.         }
  67.     }
  69.     public function getClients(): array
  70.     {
  71.         return $this->data['clients'] ?? [];
  72.     }
  74.     public function getRequestCount(): int
  75.     {
  76.         return $this->data['request_count'] ?? 0;
  77.     }
  79.     public function getErrorCount(): int
  80.     {
  81.         return $this->data['error_count'] ?? 0;
  82.     }
  84.     public function getName(): string
  85.     {
  86.         return 'http_client';
  87.     }
  89.     public function reset()
  90.     {
  91.         $this->data = [
  92.             'clients' => [],
  93.             'request_count' => 0,
  94.             'error_count' => 0,
  95.         ];
  96.     }
  98.     private function collectOnClient(TraceableHttpClient $client): array
  99.     {
  100.         $traces = $client->getTracedRequests();
  101.         $errorCount = 0;
  102.         $baseInfo = [
  103.             'response_headers' => 1,
  104.             'retry_count' => 1,
  105.             'redirect_count' => 1,
  106.             'redirect_url' => 1,
  107.             'user_data' => 1,
  108.             'error' => 1,
  109.             'url' => 1,
  110.         ];
  112.         foreach ($traces as $i => $trace) {
  113.             if (400 <= ($trace['info']['http_code'] ?? 0)) {
  114.                 ++$errorCount;
  115.             }
  117.             $info = $trace['info'];
  118.             $traces[$i]['http_code'] = $info['http_code'] ?? 0;
  120.             unset($info['filetime'], $info['http_code'], $info['ssl_verify_result'], $info['content_type']);
  122.             if (($info['http_method'] ?? null) === $trace['method']) {
  123.                 unset($info['http_method']);
  124.             }
  126.             if (($info['url'] ?? null) === $trace['url']) {
  127.                 unset($info['url']);
  128.             }
  130.             foreach ($info as $k => $v) {
  131.                 if (!$v || (is_numeric($v) && 0 > $v)) {
  132.                     unset($info[$k]);
  133.                 }
  134.             }
  136.             if (\is_string($content = $trace['content'])) {
  137.                 $contentType = 'application/octet-stream';
  139.                 foreach ($info['response_headers'] ?? [] as $h) {
  140.                     if (0 === stripos($h, 'content-type: ')) {
  141.                         $contentType = substr($h, \strlen('content-type: '));
  142.                         break;
  143.                     }
  144.                 }
  146.                 if (str_starts_with($contentType, 'image/') && class_exists(ImgStub::class)) {
  147.                     $content = new ImgStub($content, $contentType, '');
  148.                 } else {
  149.                     $content = [$content];
  150.                 }
  152.                 $content = ['response_content' => $content];
  153.             } elseif (\is_array($content)) {
  154.                 $content = ['response_json' => $content];
  155.             } else {
  156.                 $content = [];
  157.             }
  159.             if (isset($info['retry_count'])) {
  160.                 $content['retries'] = $info['previous_info'];
  161.                 unset($info['previous_info']);
  162.             }
  164.             $debugInfo = array_diff_key($info, $baseInfo);
  165.             $info = ['info' => $debugInfo] + array_diff_key($info, $debugInfo) + $content;
  166.             unset($traces[$i]['info']); // break PHP reference used by TraceableHttpClient
  167.             $traces[$i]['info'] = $this->cloneVar($info);
  168.             $traces[$i]['options'] = $this->cloneVar($trace['options']);
  169.             $traces[$i]['curlCommand'] = $this->getCurlCommand($trace);
  170.         }
  172.         return [$errorCount, $traces];
  173.     }
  175.     private function getCurlCommand(array $trace): ?string
  176.     {
  177.         if (!isset($trace['info']['debug'])) {
  178.             return null;
  179.         }
  181.         $url = $trace['info']['original_url'] ?? $trace['info']['url'] ?? $trace['url'];
  182.         $command = ['curl', '--compressed'];
  184.         if (isset($trace['options']['resolve'])) {
  185.             $port = parse_url($url, \PHP_URL_PORT) ?: (str_starts_with('http:', $url) ? 80 : 443);
  186.             foreach ($trace['options']['resolve'] as $host => $ip) {
  187.                 if (null !== $ip) {
  188.                     $command[] = '--resolve '.escapeshellarg("$host:$port:$ip");
  189.                 }
  190.             }
  191.         }
  193.         $dataArg = [];
  195.         if ($json = $trace['options']['json'] ?? null) {
  196.             if (!$this->argMaxLengthIsSafe($payload = self::jsonEncode($json))) {
  197.                 return null;
  198.             }
  199.             $dataArg[] = '--data '.escapeshellarg($payload);
  200.         } elseif ($body = $trace['options']['body'] ?? null) {
  201.             if (\is_string($body)) {
  202.                 if (!$this->argMaxLengthIsSafe($body)) {
  203.                     return null;
  204.                 }
  205.                 try {
  206.                     $dataArg[] = '--data '.escapeshellarg($body);
  207.                 } catch (\ValueError) {
  208.                     return null;
  209.                 }
  210.             } elseif (\is_array($body)) {
  211.                 $body = explode('&', self::normalizeBody($body));
  212.                 foreach ($body as $value) {
  213.                     if (!$this->argMaxLengthIsSafe($payload = urldecode($value))) {
  214.                         return null;
  215.                     }
  216.                     $dataArg[] = '--data '.escapeshellarg($payload);
  217.                 }
  218.             } else {
  219.                 return null;
  220.             }
  221.         }
  223.         $dataArg = empty($dataArg) ? null : implode(' ', $dataArg);
  225.         foreach (explode("\n", $trace['info']['debug']) as $line) {
  226.             $line = substr($line, 0, -1);
  228.             if (str_starts_with('< ', $line)) {
  229.                 // End of the request, beginning of the response. Stop parsing.
  230.                 break;
  231.             }
  233.             if ('' === $line || preg_match('/^[*<]|(Host: )/', $line)) {
  234.                 continue;
  235.             }
  237.             if (preg_match('/^> ([A-Z]+)/', $line, $match)) {
  238.                 $command[] = sprintf('--request %s', $match[1]);
  239.                 $command[] = sprintf('--url %s', escapeshellarg($url));
  240.                 continue;
  241.             }
  243.             $command[] = '--header '.escapeshellarg($line);
  244.         }
  246.         if (null !== $dataArg) {
  247.             $command[] = $dataArg;
  248.         }
  250.         return implode(" \\\n  ", $command);
  251.     }
  253.     /**
  254.      * Let's be defensive : we authorize only size of 8kio on Windows for escapeshellarg() argument to avoid a fatal error.
  255.      *
  256.      * @see https://github.com/php/php-src/blob/9458f5f2c8a8e3d6c65cc181747a5a75654b7c6e/ext/standard/exec.c#L397
  257.      */
  258.     private function argMaxLengthIsSafe(string $payload): bool
  259.     {
  260.         return \strlen($payload) < ('\\' === \DIRECTORY_SEPARATOR ? 8100 : 256000);
  261.     }
  262. }