vendor/sentry/sentry/src/Client.php line 177

  1. <?php
  3. declare(strict_types=1);
  5. namespace Sentry;
  7. use GuzzleHttp\Promise\PromiseInterface;
  8. use Psr\Log\LoggerInterface;
  9. use Psr\Log\NullLogger;
  10. use Sentry\Integration\IntegrationInterface;
  11. use Sentry\Integration\IntegrationRegistry;
  12. use Sentry\Serializer\RepresentationSerializer;
  13. use Sentry\Serializer\RepresentationSerializerInterface;
  14. use Sentry\Serializer\SerializerInterface;
  15. use Sentry\State\Scope;
  16. use Sentry\Transport\TransportInterface;
  18. /**
  19.  * Default implementation of the {@see ClientInterface} interface.
  20.  *
  21.  * @author Stefano Arlandini <sarlandini@alice.it>
  22.  */
  23. final class Client implements ClientInterface
  24. {
  25.     /**
  26.      * The version of the protocol to communicate with the Sentry server.
  27.      */
  28.     public const PROTOCOL_VERSION = '7';
  30.     /**
  31.      * The identifier of the SDK.
  32.      */
  33.     public const SDK_IDENTIFIER = 'sentry.php';
  35.     /**
  36.      * The version of the SDK.
  37.      */
  38.     public const SDK_VERSION = '3.22.1';
  40.     /**
  41.      * @var Options The client options
  42.      */
  43.     private $options;
  45.     /**
  46.      * @var TransportInterface The transport
  47.      */
  48.     private $transport;
  50.     /**
  51.      * @var LoggerInterface The PSR-3 logger
  52.      */
  53.     private $logger;
  55.     /**
  56.      * @var array<string, IntegrationInterface> The stack of integrations
  57.      *
  58.      * @psalm-var array<class-string<IntegrationInterface>, IntegrationInterface>
  59.      */
  60.     private $integrations;
  62.     /**
  63.      * @var StacktraceBuilder
  64.      */
  65.     private $stacktraceBuilder;
  67.     /**
  68.      * @var string The Sentry SDK identifier
  69.      */
  70.     private $sdkIdentifier;
  72.     /**
  73.      * @var string The SDK version of the Client
  74.      */
  75.     private $sdkVersion;
  77.     /**
  78.      * Constructor.
  79.      *
  80.      * @param Options                                $options                  The client configuration
  81.      * @param TransportInterface                     $transport                The transport
  82.      * @param string|null                            $sdkIdentifier            The Sentry SDK identifier
  83.      * @param string|null                            $sdkVersion               The Sentry SDK version
  84.      * @param SerializerInterface|null               $serializer               The serializer argument is deprecated since version 3.3 and will be removed in 4.0. It's currently unused.
  85.      * @param RepresentationSerializerInterface|null $representationSerializer The serializer for function arguments
  86.      * @param LoggerInterface|null                   $logger                   The PSR-3 logger
  87.      */
  88.     public function __construct(
  89.         Options $options,
  90.         TransportInterface $transport,
  91.         ?string $sdkIdentifier = null,
  92.         ?string $sdkVersion = null,
  93.         ?SerializerInterface $serializer = null,
  94.         ?RepresentationSerializerInterface $representationSerializer = null,
  95.         ?LoggerInterface $logger = null
  96.     ) {
  97.         $this->options = $options;
  98.         $this->transport = $transport;
  99.         $this->logger = $logger ?? new NullLogger();
  100.         $this->integrations = IntegrationRegistry::getInstance()->setupIntegrations($options, $this->logger);
  101.         $this->stacktraceBuilder = new StacktraceBuilder($options, $representationSerializer ?? new RepresentationSerializer($this->options));
  102.         $this->sdkIdentifier = $sdkIdentifier ?? self::SDK_IDENTIFIER;
  103.         $this->sdkVersion = $sdkVersion ?? self::SDK_VERSION;
  104.     }
  106.     /**
  107.      * {@inheritdoc}
  108.      */
  109.     public function getOptions(): Options
  110.     {
  111.         return $this->options;
  112.     }
  114.     /**
  115.      * {@inheritdoc}
  116.      */
  117.     public function getCspReportUrl(): ?string
  118.     {
  119.         $dsn = $this->options->getDsn();
  121.         if (null === $dsn) {
  122.             return null;
  123.         }
  125.         $endpoint = $dsn->getCspReportEndpointUrl();
  126.         $query = array_filter([
  127.             'sentry_release' => $this->options->getRelease(),
  128.             'sentry_environment' => $this->options->getEnvironment(),
  129.         ]);
  131.         if (!empty($query)) {
  132.             $endpoint .= '&' . http_build_query($query, '', '&');
  133.         }
  135.         return $endpoint;
  136.     }
  138.     /**
  139.      * {@inheritdoc}
  140.      */
  141.     public function captureMessage(string $message, ?Severity $level = null, ?Scope $scope = null, ?EventHint $hint = null): ?EventId
  142.     {
  143.         $event = Event::createEvent();
  144.         $event->setMessage($message);
  145.         $event->setLevel($level);
  147.         return $this->captureEvent($event, $hint, $scope);
  148.     }
  150.     /**
  151.      * {@inheritdoc}
  152.      */
  153.     public function captureException(\Throwable $exception, ?Scope $scope = null, ?EventHint $hint = null): ?EventId
  154.     {
  155.         $hint = $hint ?? new EventHint();
  157.         if (null === $hint->exception) {
  158.             $hint->exception = $exception;
  159.         }
  161.         return $this->captureEvent(Event::createEvent(), $hint, $scope);
  162.     }
  164.     /**
  165.      * {@inheritdoc}
  166.      */
  167.     public function captureEvent(Event $event, ?EventHint $hint = null, ?Scope $scope = null): ?EventId
  168.     {
  169.         $event = $this->prepareEvent($event, $hint, $scope);
  171.         if (null === $event) {
  172.             return null;
  173.         }
  175.         try {
  176.             /** @var Response $response */
  177.             $response = $this->transport->send($event)->wait();
  178.             $event = $response->getEvent();
  180.             if (null !== $event) {
  181.                 return $event->getId();
  182.             }
  183.         } catch (\Throwable $exception) {
  184.         }
  186.         return null;
  187.     }
  189.     /**
  190.      * {@inheritdoc}
  191.      */
  192.     public function captureLastError(?Scope $scope = null, ?EventHint $hint = null): ?EventId
  193.     {
  194.         $error = error_get_last();
  196.         if (null === $error || !isset($error['message'][0])) {
  197.             return null;
  198.         }
  200.         $exception = new \ErrorException(@$error['message'], 0, @$error['type'], @$error['file'], @$error['line']);
  202.         return $this->captureException($exception, $scope, $hint);
  203.     }
  205.     /**
  206.      * {@inheritdoc}
  207.      *
  208.      * @psalm-template T of IntegrationInterface
  209.      */
  210.     public function getIntegration(string $className): ?IntegrationInterface
  211.     {
  212.         /** @psalm-var T|null */
  213.         return $this->integrations[$className] ?? null;
  214.     }
  216.     /**
  217.      * {@inheritdoc}
  218.      */
  219.     public function flush(?int $timeout = null): PromiseInterface
  220.     {
  221.         return $this->transport->close($timeout);
  222.     }
  224.     /**
  225.      * {@inheritdoc}
  226.      */
  227.     public function getStacktraceBuilder(): StacktraceBuilder
  228.     {
  229.         return $this->stacktraceBuilder;
  230.     }
  232.     /**
  233.      * Assembles an event and prepares it to be sent of to Sentry.
  234.      *
  235.      * @param Event          $event The payload that will be converted to an Event
  236.      * @param EventHint|null $hint  May contain additional information about the event
  237.      * @param Scope|null     $scope Optional scope which enriches the Event
  238.      *
  239.      * @return Event|null The prepared event object or null if it must be discarded
  240.      */
  241.     private function prepareEvent(Event $event, ?EventHint $hint = null, ?Scope $scope = null): ?Event
  242.     {
  243.         if (null !== $hint) {
  244.             if (null !== $hint->exception && empty($event->getExceptions())) {
  245.                 $this->addThrowableToEvent($event, $hint->exception, $hint);
  246.             }
  248.             if (null !== $hint->stacktrace && null === $event->getStacktrace()) {
  249.                 $event->setStacktrace($hint->stacktrace);
  250.             }
  251.         }
  253.         $this->addMissingStacktraceToEvent($event);
  255.         $event->setSdkIdentifier($this->sdkIdentifier);
  256.         $event->setSdkVersion($this->sdkVersion);
  257.         $event->setTags(array_merge($this->options->getTags(), $event->getTags()));
  259.         if (null === $event->getServerName()) {
  260.             $event->setServerName($this->options->getServerName());
  261.         }
  263.         if (null === $event->getRelease()) {
  264.             $event->setRelease($this->options->getRelease());
  265.         }
  267.         if (null === $event->getEnvironment()) {
  268.             $event->setEnvironment($this->options->getEnvironment() ?? Event::DEFAULT_ENVIRONMENT);
  269.         }
  271.         if (null === $event->getLogger()) {
  272.             $event->setLogger($this->options->getLogger(false));
  273.         }
  275.         $isTransaction = EventType::transaction() === $event->getType();
  276.         $sampleRate = $this->options->getSampleRate();
  278.         if (!$isTransaction && $sampleRate < 1 && mt_rand(1, 100) / 100.0 > $sampleRate) {
  279.             $this->logger->info('The event will be discarded because it has been sampled.', ['event' => $event]);
  281.             return null;
  282.         }
  284.         $event = $this->applyIgnoreOptions($event);
  286.         if (null === $event) {
  287.             return null;
  288.         }
  290.         if (null !== $scope) {
  291.             $beforeEventProcessors = $event;
  292.             $event = $scope->applyToEvent($event, $hint, $this->options);
  294.             if (null === $event) {
  295.                 $this->logger->info(
  296.                     'The event will be discarded because one of the event processors returned "null".',
  297.                     ['event' => $beforeEventProcessors]
  298.                 );
  300.                 return null;
  301.             }
  302.         }
  304.         $beforeSendCallback = $event;
  305.         $event = $this->applyBeforeSendCallback($event, $hint);
  307.         if (null === $event) {
  308.             $this->logger->info(
  309.                 sprintf(
  310.                     'The event will be discarded because the "%s" callback returned "null".',
  311.                     $this->getBeforeSendCallbackName($beforeSendCallback)
  312.                 ),
  313.                 ['event' => $beforeSendCallback]
  314.             );
  315.         }
  317.         return $event;
  318.     }
  320.     private function applyIgnoreOptions(Event $event): ?Event
  321.     {
  322.         if ($event->getType() === EventType::event()) {
  323.             $exceptions = $event->getExceptions();
  325.             if (empty($exceptions)) {
  326.                 return $event;
  327.             }
  329.             foreach ($exceptions as $exception) {
  330.                 if (\in_array($exception->getType(), $this->options->getIgnoreExceptions(), true)) {
  331.                     $this->logger->info(
  332.                         'The event will be discarded because it matches an entry in "ignore_exceptions".',
  333.                         ['event' => $event]
  334.                     );
  336.                     return null;
  337.                 }
  338.             }
  339.         }
  341.         if ($event->getType() === EventType::transaction()) {
  342.             $transactionName = $event->getTransaction();
  344.             if (null === $transactionName) {
  345.                 return $event;
  346.             }
  348.             if (\in_array($transactionName, $this->options->getIgnoreTransactions(), true)) {
  349.                 $this->logger->info(
  350.                     'The event will be discarded because it matches a entry in "ignore_transactions".',
  351.                     ['event' => $event]
  352.                 );
  354.                 return null;
  355.             }
  356.         }
  358.         return $event;
  359.     }
  361.     private function applyBeforeSendCallback(Event $event, ?EventHint $hint): ?Event
  362.     {
  363.         if ($event->getType() === EventType::event()) {
  364.             return ($this->options->getBeforeSendCallback())($event, $hint);
  365.         }
  367.         if ($event->getType() === EventType::transaction()) {
  368.             return ($this->options->getBeforeSendTransactionCallback())($event, $hint);
  369.         }
  371.         return $event;
  372.     }
  374.     private function getBeforeSendCallbackName(Event $event): string
  375.     {
  376.         $beforeSendCallbackName = 'before_send';
  378.         if ($event->getType() === EventType::transaction()) {
  379.             $beforeSendCallbackName = 'before_send_transaction';
  380.         }
  382.         return $beforeSendCallbackName;
  383.     }
  385.     /**
  386.      * Optionally adds a missing stacktrace to the Event if the client is configured to do so.
  387.      *
  388.      * @param Event $event The Event to add the missing stacktrace to
  389.      */
  390.     private function addMissingStacktraceToEvent(Event $event): void
  391.     {
  392.         if (!$this->options->shouldAttachStacktrace()) {
  393.             return;
  394.         }
  396.         // We should not add a stacktrace when the event already has one or contains exceptions
  397.         if (null !== $event->getStacktrace() || !empty($event->getExceptions())) {
  398.             return;
  399.         }
  401.         $event->setStacktrace($this->stacktraceBuilder->buildFromBacktrace(
  402.             debug_backtrace(0),
  403.             __FILE__,
  404.             __LINE__ - 3
  405.         ));
  406.     }
  408.     /**
  409.      * Stores the given exception in the passed event.
  410.      *
  411.      * @param Event      $event     The event that will be enriched with the exception
  412.      * @param \Throwable $exception The exception that will be processed and added to the event
  413.      * @param EventHint  $hint      Contains additional information about the event
  414.      */
  415.     private function addThrowableToEvent(Event $event, \Throwable $exception, EventHint $hint): void
  416.     {
  417.         if ($exception instanceof \ErrorException && null === $event->getLevel()) {
  418.             $event->setLevel(Severity::fromError($exception->getSeverity()));
  419.         }
  421.         $exceptions = [];
  423.         do {
  424.             $exceptions[] = new ExceptionDataBag(
  425.                 $exception,
  426.                 $this->stacktraceBuilder->buildFromException($exception),
  427.                 $hint->mechanism ?? new ExceptionMechanism(ExceptionMechanism::TYPE_GENERIC, true, ['code' => $exception->getCode()])
  428.             );
  429.         } while ($exception = $exception->getPrevious());
  431.         $event->setExceptions($exceptions);
  432.     }
  433. }