vendor/sentry/sentry-symfony/src/Tracing/HttpClient/AbstractTraceableResponse.php line 83

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. namespace Sentry\SentryBundle\Tracing\HttpClient;
  7. use Sentry\Tracing\Span;
  8. use Sentry\Tracing\SpanStatus;
  9. use Symfony\Contracts\HttpClient\ChunkInterface;
  10. use Symfony\Contracts\HttpClient\HttpClientInterface;
  11. use Symfony\Contracts\HttpClient\ResponseInterface;
  13. /**
  14.  * @internal
  15.  */
  16. abstract class AbstractTraceableResponse implements ResponseInterface
  17. {
  18.     /**
  19.      * @var ResponseInterface
  20.      */
  21.     protected $response;
  23.     /**
  24.      * @var HttpClientInterface
  25.      */
  26.     protected $client;
  28.     /**
  29.      * @var Span|null
  30.      */
  31.     protected $span;
  33.     public function __construct(HttpClientInterface $client, ResponseInterface $response, ?Span $span)
  34.     {
  35.         $this->client = $client;
  36.         $this->response = $response;
  37.         $this->span = $span;
  38.     }
  40.     public function __destruct()
  41.     {
  42.         try {
  43.             if (method_exists($this->response, '__destruct')) {
  44.                 $this->response->__destruct();
  45.             }
  46.         } finally {
  47.             $this->finishSpan();
  48.         }
  49.     }
  51.     public function __sleep(): array
  52.     {
  53.         throw new \BadMethodCallException('Serializing instances of this class is forbidden.');
  54.     }
  56.     public function __wakeup()
  57.     {
  58.         throw new \BadMethodCallException('Unserializing instances of this class is forbidden.');
  59.     }
  61.     public function getStatusCode(): int
  62.     {
  63.         return $this->response->getStatusCode();
  64.     }
  66.     public function getHeaders(bool $throw = true): array
  67.     {
  68.         return $this->response->getHeaders($throw);
  69.     }
  71.     public function getContent(bool $throw = true): string
  72.     {
  73.         try {
  74.             return $this->response->getContent($throw);
  75.         } finally {
  76.             $this->finishSpan();
  77.         }
  78.     }
  80.     public function toArray(bool $throw = true): array
  81.     {
  82.         try {
  83.             return $this->response->toArray($throw);
  84.         } finally {
  85.             $this->finishSpan();
  86.         }
  87.     }
  89.     public function cancel(): void
  90.     {
  91.         $this->response->cancel();
  92.         $this->finishSpan();
  93.     }
  95.     /**
  96.      * @internal
  97.      *
  98.      * @param iterable<AbstractTraceableResponse> $responses
  99.      *
  100.      * @return \Generator<AbstractTraceableResponse, ChunkInterface>
  101.      */
  102.     public static function stream(HttpClientInterface $client, iterable $responses, ?float $timeout): \Generator
  103.     {
  104.         /** @var \SplObjectStorage<ResponseInterface, AbstractTraceableResponse> $traceableMap */
  105.         $traceableMap = new \SplObjectStorage();
  106.         $wrappedResponses = [];
  108.         foreach ($responses as $response) {
  109.             if (!$response instanceof self) {
  110.                 throw new \TypeError(\sprintf('"%s::stream()" expects parameter 1 to be an iterable of TraceableResponse objects, "%s" given.', TraceableHttpClient::class, get_debug_type($response)));
  111.             }
  113.             $traceableMap[$response->response] = $response;
  114.             $wrappedResponses[] = $response->response;
  115.         }
  117.         foreach ($client->stream($wrappedResponses, $timeout) as $response => $chunk) {
  118.             $traceableResponse = $traceableMap[$response];
  119.             $traceableResponse->finishSpan();
  121.             yield $traceableResponse => $chunk;
  122.         }
  123.     }
  125.     private function finishSpan(): void
  126.     {
  127.         if (null === $this->span) {
  128.             return;
  129.         }
  131.         // We finish the span (which means setting the span end timestamp) first
  132.         // to ensure the measured time is as close as possible to the duration of
  133.         // the HTTP request
  134.         $this->span->finish();
  136.         /** @var int $statusCode */
  137.         $statusCode = $this->response->getInfo('http_code');
  139.         // If the returned status code is 0, it means that this info isn't available
  140.         // yet (e.g. an error happened before the request was sent), hence we cannot
  141.         // determine what happened.
  142.         if (0 === $statusCode) {
  143.             $this->span->setStatus(SpanStatus::unknownError());
  144.         } else {
  145.             $this->span->setStatus(SpanStatus::createFromHttpStatusCode($statusCode));
  146.         }
  148.         $this->span = null;
  149.     }
  150. }