Upgrade framework

vendor/spatie/flare-client-php/src/Flare.php

@@ -0,0 +1,434 @@
+<?php
+
+namespace Spatie\FlareClient;
+
+use Closure;
+use Error;
+use ErrorException;
+use Exception;
+use Illuminate\Contracts\Container\Container;
+use Illuminate\Pipeline\Pipeline;
+use Spatie\FlareClient\Concerns\HasContext;
+use Spatie\FlareClient\Context\BaseContextProviderDetector;
+use Spatie\FlareClient\Context\ContextProviderDetector;
+use Spatie\FlareClient\Enums\MessageLevels;
+use Spatie\FlareClient\FlareMiddleware\AddEnvironmentInformation;
+use Spatie\FlareClient\FlareMiddleware\AddGlows;
+use Spatie\FlareClient\FlareMiddleware\CensorRequestBodyFields;
+use Spatie\FlareClient\FlareMiddleware\FlareMiddleware;
+use Spatie\FlareClient\FlareMiddleware\RemoveRequestIp;
+use Spatie\FlareClient\Glows\Glow;
+use Spatie\FlareClient\Glows\GlowRecorder;
+use Spatie\FlareClient\Http\Client;
+use Throwable;
+
+class Flare
+{
+    use HasContext;
+
+    protected Client $client;
+
+    protected Api $api;
+
+    /** @var array<int, FlareMiddleware|class-string<FlareMiddleware>> */
+    protected array $middleware = [];
+
+    protected GlowRecorder $recorder;
+
+    protected ?string $applicationPath = null;
+
+    protected ContextProviderDetector $contextDetector;
+
+    protected ?Closure $previousExceptionHandler = null;
+
+    /** @var null|callable */
+    protected $previousErrorHandler = null;
+
+    /** @var null|callable */
+    protected $determineVersionCallable = null;
+
+    protected ?int $reportErrorLevels = null;
+
+    /** @var null|callable */
+    protected $filterExceptionsCallable = null;
+
+    /** @var null|callable */
+    protected $filterReportsCallable = null;
+
+    protected ?string $stage = null;
+
+    protected ?string $requestId = null;
+
+    protected ?Container $container = null;
+
+    public static function make(
+        string $apiKey = null,
+        ContextProviderDetector $contextDetector = null
+    ): self {
+        $client = new Client($apiKey);
+
+        return new self($client, $contextDetector);
+    }
+
+    public function setApiToken(string $apiToken): self
+    {
+        $this->client->setApiToken($apiToken);
+
+        return $this;
+    }
+
+    public function apiTokenSet(): bool
+    {
+        return $this->client->apiTokenSet();
+    }
+
+    public function setBaseUrl(string $baseUrl): self
+    {
+        $this->client->setBaseUrl($baseUrl);
+
+        return $this;
+    }
+
+    public function setStage(?string $stage): self
+    {
+        $this->stage = $stage;
+
+        return $this;
+    }
+
+    public function sendReportsImmediately(): self
+    {
+        $this->api->sendReportsImmediately();
+
+        return $this;
+    }
+
+    public function determineVersionUsing(callable $determineVersionCallable): self
+    {
+        $this->determineVersionCallable = $determineVersionCallable;
+
+        return $this;
+    }
+
+    public function reportErrorLevels(int $reportErrorLevels): self
+    {
+        $this->reportErrorLevels = $reportErrorLevels;
+
+        return $this;
+    }
+
+    public function filterExceptionsUsing(callable $filterExceptionsCallable): self
+    {
+        $this->filterExceptionsCallable = $filterExceptionsCallable;
+
+        return $this;
+    }
+
+    public function filterReportsUsing(callable $filterReportsCallable): self
+    {
+        $this->filterReportsCallable = $filterReportsCallable;
+
+        return $this;
+    }
+
+    public function version(): ?string
+    {
+        if (! $this->determineVersionCallable) {
+            return null;
+        }
+
+        return ($this->determineVersionCallable)();
+    }
+
+    /**
+     * @param \Spatie\FlareClient\Http\Client $client
+     * @param \Spatie\FlareClient\Context\ContextProviderDetector|null $contextDetector
+     * @param array<int, FlareMiddleware> $middleware
+     */
+    public function __construct(
+        Client $client,
+        ContextProviderDetector $contextDetector = null,
+        array $middleware = []
+    ) {
+        $this->client = $client;
+        $this->recorder = new GlowRecorder();
+        $this->contextDetector = $contextDetector ?? new BaseContextProviderDetector();
+        $this->middleware = $middleware;
+        $this->api = new Api($this->client);
+
+        $this->registerDefaultMiddleware();
+    }
+
+    /** @return array<int, FlareMiddleware|class-string<FlareMiddleware>> */
+    public function getMiddleware(): array
+    {
+        return $this->middleware;
+    }
+
+    public function setContextProviderDetector(ContextProviderDetector $contextDetector): self
+    {
+        $this->contextDetector = $contextDetector;
+
+        return $this;
+    }
+
+    public function setContainer(Container $container): self
+    {
+        $this->container = $container;
+
+        return $this;
+    }
+
+    public function registerFlareHandlers(): self
+    {
+        $this->registerExceptionHandler();
+
+        $this->registerErrorHandler();
+
+        return $this;
+    }
+
+    public function registerExceptionHandler(): self
+    {
+        /** @phpstan-ignore-next-line */
+        $this->previousExceptionHandler = set_exception_handler([$this, 'handleException']);
+
+        return $this;
+    }
+
+    public function registerErrorHandler(): self
+    {
+        $this->previousErrorHandler = set_error_handler([$this, 'handleError']);
+
+        return $this;
+    }
+
+    protected function registerDefaultMiddleware(): self
+    {
+        return $this->registerMiddleware([
+            new AddGlows($this->recorder),
+            new AddEnvironmentInformation(),
+        ]);
+    }
+
+    /**
+     * @param FlareMiddleware|array<FlareMiddleware>|class-string<FlareMiddleware> $middleware
+     *
+     * @return $this
+     */
+    public function registerMiddleware($middleware): self
+    {
+        if (! is_array($middleware)) {
+            $middleware = [$middleware];
+        }
+
+        $this->middleware = array_merge($this->middleware, $middleware);
+
+        return $this;
+    }
+
+    /**
+     * @return array<int,FlareMiddleware|class-string<FlareMiddleware>>
+     */
+    public function getMiddlewares(): array
+    {
+        return $this->middleware;
+    }
+
+    /**
+     * @param string $name
+     * @param string $messageLevel
+     * @param array<int, mixed> $metaData
+     *
+     * @return $this
+     */
+    public function glow(
+        string $name,
+        string $messageLevel = MessageLevels::INFO,
+        array $metaData = []
+    ): self {
+        $this->recorder->record(new Glow($name, $messageLevel, $metaData));
+
+        return $this;
+    }
+
+    public function handleException(Throwable $throwable): void
+    {
+        $this->report($throwable);
+
+        if ($this->previousExceptionHandler) {
+            call_user_func($this->previousExceptionHandler, $throwable);
+        }
+    }
+
+    /**
+     * @return mixed
+     */
+    public function handleError(mixed $code, string $message, string $file = '', int $line = 0)
+    {
+        $exception = new ErrorException($message, 0, $code, $file, $line);
+
+        $this->report($exception);
+
+        if ($this->previousErrorHandler) {
+            return call_user_func(
+                $this->previousErrorHandler,
+                $message,
+                $code,
+                $file,
+                $line
+            );
+        }
+    }
+
+    public function applicationPath(string $applicationPath): self
+    {
+        $this->applicationPath = $applicationPath;
+
+        return $this;
+    }
+
+    public function report(Throwable $throwable, callable $callback = null, Report $report = null): ?Report
+    {
+        if (! $this->shouldSendReport($throwable)) {
+            return null;
+        }
+
+        $report ??= $this->createReport($throwable);
+
+        if (! is_null($callback)) {
+            call_user_func($callback, $report);
+        }
+
+        $this->recorder->reset();
+
+        $this->sendReportToApi($report);
+
+        return $report;
+    }
+
+    protected function shouldSendReport(Throwable $throwable): bool
+    {
+        if (isset($this->reportErrorLevels) && $throwable instanceof Error) {
+            return (bool)($this->reportErrorLevels & $throwable->getCode());
+        }
+
+        if (isset($this->reportErrorLevels) && $throwable instanceof ErrorException) {
+            return (bool)($this->reportErrorLevels & $throwable->getSeverity());
+        }
+
+        if ($this->filterExceptionsCallable && $throwable instanceof Exception) {
+            return (bool)(call_user_func($this->filterExceptionsCallable, $throwable));
+        }
+
+        return true;
+    }
+
+    public function reportMessage(string $message, string $logLevel, callable $callback = null): void
+    {
+        $report = $this->createReportFromMessage($message, $logLevel);
+
+        if (! is_null($callback)) {
+            call_user_func($callback, $report);
+        }
+
+        $this->sendReportToApi($report);
+    }
+
+    public function sendTestReport(Throwable $throwable): void
+    {
+        $this->api->sendTestReport($this->createReport($throwable));
+    }
+
+    protected function sendReportToApi(Report $report): void
+    {
+        if ($this->filterReportsCallable) {
+            if (! call_user_func($this->filterReportsCallable, $report)) {
+                return;
+            }
+        }
+
+        try {
+            $this->api->report($report);
+        } catch (Exception $exception) {
+        }
+    }
+
+    public function reset(): void
+    {
+        $this->api->sendQueuedReports();
+
+        $this->userProvidedContext = [];
+
+        $this->recorder->reset();
+    }
+
+    protected function applyAdditionalParameters(Report $report): void
+    {
+        $report
+            ->stage($this->stage)
+            ->messageLevel($this->messageLevel)
+            ->setApplicationPath($this->applicationPath)
+            ->userProvidedContext($this->userProvidedContext);
+    }
+
+    public function anonymizeIp(): self
+    {
+        $this->registerMiddleware(new RemoveRequestIp());
+
+        return $this;
+    }
+
+    /**
+     * @param array<int, string> $fieldNames
+     *
+     * @return $this
+     */
+    public function censorRequestBodyFields(array $fieldNames): self
+    {
+        $this->registerMiddleware(new CensorRequestBodyFields($fieldNames));
+
+        return $this;
+    }
+
+    public function createReport(Throwable $throwable): Report
+    {
+        $report = Report::createForThrowable(
+            $throwable,
+            $this->contextDetector->detectCurrentContext(),
+            $this->applicationPath,
+            $this->version()
+        );
+
+        return $this->applyMiddlewareToReport($report);
+    }
+
+    public function createReportFromMessage(string $message, string $logLevel): Report
+    {
+        $report = Report::createForMessage(
+            $message,
+            $logLevel,
+            $this->contextDetector->detectCurrentContext(),
+            $this->applicationPath
+        );
+
+        return $this->applyMiddlewareToReport($report);
+    }
+
+    protected function applyMiddlewareToReport(Report $report): Report
+    {
+        $this->applyAdditionalParameters($report);
+        $middleware = array_map(function ($singleMiddleware) {
+            return is_string($singleMiddleware)
+                ? new $singleMiddleware
+                : $singleMiddleware;
+        }, $this->middleware);
+
+        $report = (new Pipeline())
+            ->send($report)
+            ->through($middleware)
+            ->then(fn ($report) => $report);
+
+        return $report;
+    }
+}