Server IP : 104.21.14.48 / Your IP : 3.133.151.199 [ Web Server : Apache System : Linux b70eb322-3aee-0c53-7c82-0db91281f2c6.secureserver.net 6.1.90-1.el9.elrepo.x86_64 #1 SMP PREEMPT_DYNAMIC Thu May 2 12:09:22 EDT 2024 x86_64 User : root ( 0) PHP Version : 8.0.30.2 Disable Function : NONE Domains : 0 Domains MySQL : ON | cURL : ON | WGET : ON | Perl : OFF | Python : OFF | Sudo : OFF | Pkexec : OFF Directory : /var/www/wp-content/mu-plugins/vendor/godaddy/mwc-core/vendor/sentry/sentry/src/ |
Upload File : |
<?php declare(strict_types=1); namespace Sentry; use Sentry\Metrics\Metrics; use Sentry\State\Scope; use Sentry\Tracing\PropagationContext; use Sentry\Tracing\SpanContext; use Sentry\Tracing\Transaction; use Sentry\Tracing\TransactionContext; /** * Creates a new Client and Hub which will be set as current. * * @param array<string, mixed> $options The client options */ function init(array $options = []): void { $client = ClientBuilder::create($options)->getClient(); SentrySdk::init()->bindClient($client); } /** * Captures a message event and sends it to Sentry. * * @param string $message The message * @param Severity|null $level The severity level of the message * @param EventHint|null $hint Object that can contain additional information about the event */ function captureMessage(string $message, ?Severity $level = null, ?EventHint $hint = null): ?EventId { return SentrySdk::getCurrentHub()->captureMessage($message, $level, $hint); } /** * Captures an exception event and sends it to Sentry. * * @param \Throwable $exception The exception * @param EventHint|null $hint Object that can contain additional information about the event */ function captureException(\Throwable $exception, ?EventHint $hint = null): ?EventId { return SentrySdk::getCurrentHub()->captureException($exception, $hint); } /** * Captures a new event using the provided data. * * @param Event $event The event being captured * @param EventHint|null $hint May contain additional information about the event */ function captureEvent(Event $event, ?EventHint $hint = null): ?EventId { return SentrySdk::getCurrentHub()->captureEvent($event, $hint); } /** * Logs the most recent error (obtained with {@see error_get_last()}). * * @param EventHint|null $hint Object that can contain additional information about the event */ function captureLastError(?EventHint $hint = null): ?EventId { return SentrySdk::getCurrentHub()->captureLastError($hint); } /** * Captures a check-in and sends it to Sentry. * * @param string $slug Identifier of the Monitor * @param CheckInStatus $status The status of the check-in * @param int|float|null $duration The duration of the check-in * @param MonitorConfig|null $monitorConfig Configuration of the Monitor * @param string|null $checkInId A check-in ID from the previous check-in */ function captureCheckIn(string $slug, CheckInStatus $status, $duration = null, ?MonitorConfig $monitorConfig = null, ?string $checkInId = null): ?string { return SentrySdk::getCurrentHub()->captureCheckIn($slug, $status, $duration, $monitorConfig, $checkInId); } /** * Records a new breadcrumb which will be attached to future events. They * will be added to subsequent events to provide more context on user's * actions prior to an error or crash. * * @param Breadcrumb|string $category The category of the breadcrumb, can be a Breadcrumb instance as well (in which case the other parameters are ignored) * @param string|null $message Breadcrumb message * @param array<string, mixed> $metadata Additional information about the breadcrumb * @param string $level The error level of the breadcrumb * @param string $type The type of the breadcrumb * @param float|null $timestamp Optional timestamp of the breadcrumb */ function addBreadcrumb($category, ?string $message = null, array $metadata = [], string $level = Breadcrumb::LEVEL_INFO, string $type = Breadcrumb::TYPE_DEFAULT, ?float $timestamp = null): void { SentrySdk::getCurrentHub()->addBreadcrumb( $category instanceof Breadcrumb ? $category : new Breadcrumb($level, $type, $category, $message, $metadata, $timestamp) ); } /** * Calls the given callback passing to it the current scope so that any * operation can be run within its context. * * @param callable $callback The callback to be executed */ function configureScope(callable $callback): void { SentrySdk::getCurrentHub()->configureScope($callback); } /** * Creates a new scope with and executes the given operation within. The scope * is automatically removed once the operation finishes or throws. * * @param callable $callback The callback to be executed * * @return mixed|void The callback's return value, upon successful execution * * @psalm-template T * * @psalm-param callable(Scope): T $callback * * @psalm-return T */ function withScope(callable $callback) { return SentrySdk::getCurrentHub()->withScope($callback); } /** * Starts a new `Transaction` and returns it. This is the entry point to manual * tracing instrumentation. * * A tree structure can be built by adding child spans to the transaction, and * child spans to other spans. To start a new child span within the transaction * or any span, call the respective `startChild()` method. * * Every child span must be finished before the transaction is finished, * otherwise the unfinished spans are discarded. * * The transaction must be finished with a call to its `finish()` method, at * which point the transaction with all its finished child spans will be sent to * Sentry. * * @param TransactionContext $context Properties of the new transaction * @param array<string, mixed> $customSamplingContext Additional context that will be passed to the {@see \Sentry\Tracing\SamplingContext} */ function startTransaction(TransactionContext $context, array $customSamplingContext = []): Transaction { return SentrySdk::getCurrentHub()->startTransaction($context, $customSamplingContext); } /** * Execute the given callable while wrapping it in a span added as a child to the current transaction and active span. * * If there is no transaction active this is a no-op and the scope passed to the trace callable will be unused. * * @template T * * @param callable(Scope): T $trace The callable that is going to be traced * @param SpanContext $context The context of the span to be created * * @return T */ function trace(callable $trace, SpanContext $context) { return SentrySdk::getCurrentHub()->withScope(function (Scope $scope) use ($context, $trace) { $parentSpan = $scope->getSpan(); // If there's a span set on the scope there is a transaction // active currently. If that is the case we create a child span // and set it on the scope. Otherwise we only execute the callable if ($parentSpan !== null) { $span = $parentSpan->startChild($context); $scope->setSpan($span); } try { return $trace($scope); } finally { if (isset($span)) { $span->finish(); $scope->setSpan($parentSpan); } } }); } /** * Creates the current traceparent string, to be used as a HTTP header value * or HTML meta tag value. * This function is context aware, as in it either returns the traceparent based * on the current span, or the scope's propagation context. */ function getTraceparent(): string { $hub = SentrySdk::getCurrentHub(); $client = $hub->getClient(); if ($client !== null) { $options = $client->getOptions(); if ($options !== null && $options->isTracingEnabled()) { $span = SentrySdk::getCurrentHub()->getSpan(); if ($span !== null) { return $span->toTraceparent(); } } } $traceParent = ''; $hub->configureScope(function (Scope $scope) use (&$traceParent) { $traceParent = $scope->getPropagationContext()->toTraceparent(); }); return $traceParent; } /** * Creates the baggage content string, to be used as a HTTP header value * or HTML meta tag value. * This function is context aware, as in it either returns the baggage based * on the current span or the scope's propagation context. */ function getBaggage(): string { $hub = SentrySdk::getCurrentHub(); $client = $hub->getClient(); if ($client !== null) { $options = $client->getOptions(); if ($options !== null && $options->isTracingEnabled()) { $span = SentrySdk::getCurrentHub()->getSpan(); if ($span !== null) { return $span->toBaggage(); } } } $baggage = ''; $hub->configureScope(function (Scope $scope) use (&$baggage) { $baggage = $scope->getPropagationContext()->toBaggage(); }); return $baggage; } /** * Continue a trace based on HTTP header values. * If the SDK is configured with enabled tracing, * this function returns a populated TransactionContext. * In any other cases, it populates the propagation context on the scope. */ function continueTrace(string $sentryTrace, string $baggage): TransactionContext { $hub = SentrySdk::getCurrentHub(); $hub->configureScope(function (Scope $scope) use ($sentryTrace, $baggage) { $propagationContext = PropagationContext::fromHeaders($sentryTrace, $baggage); $scope->setPropagationContext($propagationContext); }); return TransactionContext::fromHeaders($sentryTrace, $baggage); } function metrics(): Metrics { return Metrics::getInstance(); }