vendor/sentry/sentry/src/Transport/HttpTransport.php line 131

  1. <?php
  3. declare(strict_types=1);
  5. namespace Sentry\Transport;
  7. use GuzzleHttp\Promise\FulfilledPromise;
  8. use GuzzleHttp\Promise\PromiseInterface;
  9. use GuzzleHttp\Promise\RejectedPromise;
  10. use Http\Client\HttpAsyncClient as HttpAsyncClientInterface;
  11. use Psr\Http\Message\RequestFactoryInterface;
  12. use Psr\Http\Message\ResponseInterface;
  13. use Psr\Http\Message\StreamFactoryInterface;
  14. use Psr\Log\LoggerInterface;
  15. use Psr\Log\NullLogger;
  16. use Sentry\Event;
  17. use Sentry\EventType;
  18. use Sentry\Options;
  19. use Sentry\Response;
  20. use Sentry\ResponseStatus;
  21. use Sentry\Serializer\PayloadSerializerInterface;
  23. /**
  24.  * This transport sends the events using a syncronous HTTP client that will
  25.  * delay sending of the requests until the shutdown of the application.
  26.  *
  27.  * @author Stefano Arlandini <sarlandini@alice.it>
  28.  */
  29. final class HttpTransport implements TransportInterface
  30. {
  31.     /**
  32.      * @var Options The Sentry client options
  33.      */
  34.     private $options;
  36.     /**
  37.      * @var HttpAsyncClientInterface The HTTP client
  38.      */
  39.     private $httpClient;
  41.     /**
  42.      * @var StreamFactoryInterface The PSR-7 stream factory
  43.      */
  44.     private $streamFactory;
  46.     /**
  47.      * @var RequestFactoryInterface The PSR-7 request factory
  48.      */
  49.     private $requestFactory;
  51.     /**
  52.      * @var PayloadSerializerInterface The event serializer
  53.      */
  54.     private $payloadSerializer;
  56.     /**
  57.      * @var LoggerInterface A PSR-3 logger
  58.      */
  59.     private $logger;
  61.     /**
  62.      * @var RateLimiter The rate limiter
  63.      */
  64.     private $rateLimiter;
  66.     /**
  67.      * Constructor.
  68.      *
  69.      * @param Options                    $options           The Sentry client configuration
  70.      * @param HttpAsyncClientInterface   $httpClient        The HTTP client
  71.      * @param StreamFactoryInterface     $streamFactory     The PSR-7 stream factory
  72.      * @param RequestFactoryInterface    $requestFactory    The PSR-7 request factory
  73.      * @param PayloadSerializerInterface $payloadSerializer The event serializer
  74.      * @param LoggerInterface|null       $logger            An instance of a PSR-3 logger
  75.      */
  76.     public function __construct(
  77.         Options $options,
  78.         HttpAsyncClientInterface $httpClient,
  79.         StreamFactoryInterface $streamFactory,
  80.         RequestFactoryInterface $requestFactory,
  81.         PayloadSerializerInterface $payloadSerializer,
  82.         ?LoggerInterface $logger = null
  83.     ) {
  84.         $this->options = $options;
  85.         $this->httpClient = $httpClient;
  86.         $this->streamFactory = $streamFactory;
  87.         $this->requestFactory = $requestFactory;
  88.         $this->payloadSerializer = $payloadSerializer;
  89.         $this->logger = $logger ?? new NullLogger();
  90.         $this->rateLimiter = new RateLimiter($this->logger);
  91.     }
  93.     /**
  94.      * {@inheritdoc}
  95.      */
  96.     public function send(Event $event): PromiseInterface
  97.     {
  98.         $dsn = $this->options->getDsn();
  100.         if (null === $dsn) {
  101.             throw new \RuntimeException(sprintf('The DSN option must be set to use the "%s" transport.', self::class));
  102.         }
  104.         $eventType = $event->getType();
  106.         if ($this->rateLimiter->isRateLimited($eventType)) {
  107.             $this->logger->warning(
  108.                 sprintf('Rate limit exceeded for sending requests of type "%s".', (string) $eventType),
  109.                 ['event' => $event]
  110.             );
  112.             return new RejectedPromise(new Response(ResponseStatus::rateLimit(), $event));
  113.         }
  115.         if (
  116.             $this->options->isTracingEnabled() ||
  117.             EventType::transaction() === $eventType ||
  118.             EventType::checkIn() === $eventType
  119.         ) {
  120.             $request = $this->requestFactory->createRequest('POST', $dsn->getEnvelopeApiEndpointUrl())
  121.                 ->withHeader('Content-Type', 'application/x-sentry-envelope')
  122.                 ->withBody($this->streamFactory->createStream($this->payloadSerializer->serialize($event)));
  123.         } else {
  124.             $request = $this->requestFactory->createRequest('POST', $dsn->getStoreApiEndpointUrl())
  125.                 ->withHeader('Content-Type', 'application/json')
  126.                 ->withBody($this->streamFactory->createStream($this->payloadSerializer->serialize($event)));
  127.         }
  129.         try {
  130.             /** @var ResponseInterface $response */
  131.             $response = $this->httpClient->sendAsyncRequest($request)->wait();
  132.         } catch (\Throwable $exception) {
  133.             $this->logger->error(
  134.                 sprintf('Failed to send the event to Sentry. Reason: "%s".', $exception->getMessage()),
  135.                 ['exception' => $exception, 'event' => $event]
  136.             );
  138.             return new RejectedPromise(new Response(ResponseStatus::failed(), $event));
  139.         }
  141.         $sendResponse = $this->rateLimiter->handleResponse($event, $response);
  143.         if (ResponseStatus::success() === $sendResponse->getStatus()) {
  144.             return new FulfilledPromise($sendResponse);
  145.         }
  147.         return new RejectedPromise($sendResponse);
  148.     }
  150.     /**
  151.      * {@inheritdoc}
  152.      */
  153.     public function close(?int $timeout = null): PromiseInterface
  154.     {
  155.         return new FulfilledPromise(true);
  156.     }
  157. }