vendor/sentry/sentry/src/State/Hub.php line 150

  1. <?php
  3. declare(strict_types=1);
  5. namespace Sentry\State;
  7. use Sentry\Breadcrumb;
  8. use Sentry\CheckIn;
  9. use Sentry\CheckInStatus;
  10. use Sentry\ClientInterface;
  11. use Sentry\Event;
  12. use Sentry\EventHint;
  13. use Sentry\EventId;
  14. use Sentry\Integration\IntegrationInterface;
  15. use Sentry\MonitorConfig;
  16. use Sentry\Severity;
  17. use Sentry\Tracing\SamplingContext;
  18. use Sentry\Tracing\Span;
  19. use Sentry\Tracing\Transaction;
  20. use Sentry\Tracing\TransactionContext;
  22. /**
  23.  * This class is a basic implementation of the {@see HubInterface} interface.
  24.  */
  25. final class Hub implements HubInterface
  26. {
  27.     /**
  28.      * @var Layer[] The stack of client/scope pairs
  29.      */
  30.     private $stack = [];
  32.     /**
  33.      * @var EventId|null The ID of the last captured event
  34.      */
  35.     private $lastEventId;
  37.     /**
  38.      * Hub constructor.
  39.      *
  40.      * @param ClientInterface|null $client The client bound to the hub
  41.      * @param Scope|null           $scope  The scope bound to the hub
  42.      */
  43.     public function __construct(?ClientInterface $client = null, ?Scope $scope = null)
  44.     {
  45.         $this->stack[] = new Layer($client, $scope ?? new Scope());
  46.     }
  48.     /**
  49.      * {@inheritdoc}
  50.      */
  51.     public function getClient(): ?ClientInterface
  52.     {
  53.         return $this->getStackTop()->getClient();
  54.     }
  56.     /**
  57.      * {@inheritdoc}
  58.      */
  59.     public function getLastEventId(): ?EventId
  60.     {
  61.         return $this->lastEventId;
  62.     }
  64.     /**
  65.      * {@inheritdoc}
  66.      */
  67.     public function pushScope(): Scope
  68.     {
  69.         $clonedScope = clone $this->getScope();
  71.         $this->stack[] = new Layer($this->getClient(), $clonedScope);
  73.         return $clonedScope;
  74.     }
  76.     /**
  77.      * {@inheritdoc}
  78.      */
  79.     public function popScope(): bool
  80.     {
  81.         if (1 === \count($this->stack)) {
  82.             return false;
  83.         }
  85.         return null !== array_pop($this->stack);
  86.     }
  88.     /**
  89.      * {@inheritdoc}
  90.      */
  91.     public function withScope(callable $callback)
  92.     {
  93.         $scope = $this->pushScope();
  95.         try {
  96.             return $callback($scope);
  97.         } finally {
  98.             $this->popScope();
  99.         }
  100.     }
  102.     /**
  103.      * {@inheritdoc}
  104.      */
  105.     public function configureScope(callable $callback): void
  106.     {
  107.         $callback($this->getScope());
  108.     }
  110.     /**
  111.      * {@inheritdoc}
  112.      */
  113.     public function bindClient(ClientInterface $client): void
  114.     {
  115.         $layer = $this->getStackTop();
  116.         $layer->setClient($client);
  117.     }
  119.     /**
  120.      * {@inheritdoc}
  121.      */
  122.     public function captureMessage(string $message, ?Severity $level = null, ?EventHint $hint = null): ?EventId
  123.     {
  124.         $client = $this->getClient();
  126.         if (null !== $client) {
  127.             return $this->lastEventId = $client->captureMessage($message, $level, $this->getScope(), $hint);
  128.         }
  130.         return null;
  131.     }
  133.     /**
  134.      * {@inheritdoc}
  135.      */
  136.     public function captureException(\Throwable $exception, ?EventHint $hint = null): ?EventId
  137.     {
  138.         $client = $this->getClient();
  140.         if (null !== $client) {
  141.             return $this->lastEventId = $client->captureException($exception, $this->getScope(), $hint);
  142.         }
  144.         return null;
  145.     }
  147.     /**
  148.      * {@inheritdoc}
  149.      */
  150.     public function captureEvent(Event $event, ?EventHint $hint = null): ?EventId
  151.     {
  152.         $client = $this->getClient();
  154.         if (null !== $client) {
  155.             return $this->lastEventId = $client->captureEvent($event, $hint, $this->getScope());
  156.         }
  158.         return null;
  159.     }
  161.     /**
  162.      * {@inheritdoc}
  163.      */
  164.     public function captureLastError(?EventHint $hint = null): ?EventId
  165.     {
  166.         $client = $this->getClient();
  168.         if (null !== $client) {
  169.             return $this->lastEventId = $client->captureLastError($this->getScope(), $hint);
  170.         }
  172.         return null;
  173.     }
  175.     /**
  176.      * {@inheritdoc}
  177.      *
  178.      * @param int|float|null $duration
  179.      */
  180.     public function captureCheckIn(string $slug, CheckInStatus $status, $duration = null, ?MonitorConfig $monitorConfig = null, ?string $checkInId = null): ?string
  181.     {
  182.         $client = $this->getClient();
  184.         if (null === $client) {
  185.             return null;
  186.         }
  188.         $options = $client->getOptions();
  189.         $event = Event::createCheckIn();
  190.         $checkIn = new CheckIn(
  191.             $slug,
  192.             $status,
  193.             $checkInId,
  194.             $options->getRelease(),
  195.             $options->getEnvironment(),
  196.             $duration,
  197.             $monitorConfig
  198.         );
  199.         $event->setCheckIn($checkIn);
  200.         $this->captureEvent($event);
  202.         return $checkIn->getId();
  203.     }
  205.     /**
  206.      * {@inheritdoc}
  207.      */
  208.     public function addBreadcrumb(Breadcrumb $breadcrumb): bool
  209.     {
  210.         $client = $this->getClient();
  212.         if (null === $client) {
  213.             return false;
  214.         }
  216.         $options = $client->getOptions();
  217.         $beforeBreadcrumbCallback = $options->getBeforeBreadcrumbCallback();
  218.         $maxBreadcrumbs = $options->getMaxBreadcrumbs();
  220.         if ($maxBreadcrumbs <= 0) {
  221.             return false;
  222.         }
  224.         $breadcrumb = $beforeBreadcrumbCallback($breadcrumb);
  226.         if (null !== $breadcrumb) {
  227.             $this->getScope()->addBreadcrumb($breadcrumb, $maxBreadcrumbs);
  228.         }
  230.         return null !== $breadcrumb;
  231.     }
  233.     /**
  234.      * {@inheritdoc}
  235.      */
  236.     public function getIntegration(string $className): ?IntegrationInterface
  237.     {
  238.         $client = $this->getClient();
  240.         if (null !== $client) {
  241.             return $client->getIntegration($className);
  242.         }
  244.         return null;
  245.     }
  247.     /**
  248.      * {@inheritdoc}
  249.      *
  250.      * @param array<string, mixed> $customSamplingContext Additional context that will be passed to the {@see SamplingContext}
  251.      */
  252.     public function startTransaction(TransactionContext $context, array $customSamplingContext = []): Transaction
  253.     {
  254.         $transaction = new Transaction($context, $this);
  255.         $client = $this->getClient();
  256.         $options = null !== $client ? $client->getOptions() : null;
  258.         if (null === $options || !$options->isTracingEnabled()) {
  259.             $transaction->setSampled(false);
  261.             return $transaction;
  262.         }
  264.         $samplingContext = SamplingContext::getDefault($context);
  265.         $samplingContext->setAdditionalContext($customSamplingContext);
  267.         $tracesSampler = $options->getTracesSampler();
  269.         if (null === $transaction->getSampled()) {
  270.             if (null !== $tracesSampler) {
  271.                 $sampleRate = $tracesSampler($samplingContext);
  272.             } else {
  273.                 $sampleRate = $this->getSampleRate(
  274.                     $samplingContext->getParentSampled(),
  275.                     $options->getTracesSampleRate() ?? 0
  276.                 );
  277.             }
  279.             if (!$this->isValidSampleRate($sampleRate)) {
  280.                 $transaction->setSampled(false);
  282.                 return $transaction;
  283.             }
  285.             $transaction->getMetadata()->setSamplingRate($sampleRate);
  287.             if (0.0 === $sampleRate) {
  288.                 $transaction->setSampled(false);
  290.                 return $transaction;
  291.             }
  293.             $transaction->setSampled($this->sample($sampleRate));
  294.         }
  296.         if (!$transaction->getSampled()) {
  297.             return $transaction;
  298.         }
  300.         $transaction->initSpanRecorder();
  302.         $profilesSampleRate = $options->getProfilesSampleRate();
  303.         if ($this->sample($profilesSampleRate)) {
  304.             $transaction->initProfiler();
  305.             $profiler = $transaction->getProfiler();
  306.             if (null !== $profiler) {
  307.                 $profiler->start();
  308.             }
  309.         }
  311.         return $transaction;
  312.     }
  314.     /**
  315.      * {@inheritdoc}
  316.      */
  317.     public function getTransaction(): ?Transaction
  318.     {
  319.         return $this->getScope()->getTransaction();
  320.     }
  322.     /**
  323.      * {@inheritdoc}
  324.      */
  325.     public function setSpan(?Span $span): HubInterface
  326.     {
  327.         $this->getScope()->setSpan($span);
  329.         return $this;
  330.     }
  332.     /**
  333.      * {@inheritdoc}
  334.      */
  335.     public function getSpan(): ?Span
  336.     {
  337.         return $this->getScope()->getSpan();
  338.     }
  340.     /**
  341.      * Gets the scope bound to the top of the stack.
  342.      */
  343.     private function getScope(): Scope
  344.     {
  345.         return $this->getStackTop()->getScope();
  346.     }
  348.     /**
  349.      * Gets the topmost client/layer pair in the stack.
  350.      */
  351.     private function getStackTop(): Layer
  352.     {
  353.         return $this->stack[\count($this->stack) - 1];
  354.     }
  356.     private function getSampleRate(?bool $hasParentBeenSampled, float $fallbackSampleRate): float
  357.     {
  358.         if (true === $hasParentBeenSampled) {
  359.             return 1;
  360.         }
  362.         if (false === $hasParentBeenSampled) {
  363.             return 0;
  364.         }
  366.         return $fallbackSampleRate;
  367.     }
  369.     /**
  370.      * @param mixed $sampleRate
  371.      */
  372.     private function sample($sampleRate): bool
  373.     {
  374.         if (0.0 === $sampleRate) {
  375.             return false;
  376.         }
  378.         if (1.0 === $sampleRate) {
  379.             return true;
  380.         }
  382.         return mt_rand(0, mt_getrandmax() - 1) / mt_getrandmax() < $sampleRate;
  383.     }
  385.     /**
  386.      * @param mixed $sampleRate
  387.      */
  388.     private function isValidSampleRate($sampleRate): bool
  389.     {
  390.         if (!\is_float($sampleRate) && !\is_int($sampleRate)) {
  391.             return false;
  392.         }
  394.         if ($sampleRate < 0 || $sampleRate > 1) {
  395.             return false;
  396.         }
  398.         return true;
  399.     }
  400. }