Use NullSender for Ignition mode; report() takes throwable-or-report

- Ignition mode now swaps in the existing NullSender instead of an Api
  sendingDisabled flag, so transmission is a no-op with no Api change.
- report()'s first argument is a Throwable|ReportFactory union: pass a
  pre-built report and it is rendered first, then the ignore/filter gating runs.
- renderAndReport is inlined: handleException/handleError build the report when
  a renderer is registered and hand it to report().

Author: rubenvanassche

src/Api.php

@@ -36,7 +36,6 @@ public function __construct(
         protected Scope $scope,
         protected Sender $sender,
         protected bool $disableQueue,
-        protected bool $sendingDisabled = false,
     ) {
     }
 
@@ -137,10 +136,6 @@ public function sendQueue(): void
 
     protected function sendEntity(FlareEntityType $type, mixed $payload, bool $immediately, bool $test = false): void
     {
-        if ($this->sendingDisabled) {
-            return;
-        }
-
         if ($immediately === false && $test === false && $this->disableQueue === false) {
             match ($type) {
                 FlareEntityType::Errors => $this->reportQueue[] = $payload,

src/FlareProvider.php

@@ -14,6 +14,7 @@
 use Spatie\FlareClient\Sampling\NeverSampler;
 use Spatie\FlareClient\Sampling\Sampler;
 use Spatie\FlareClient\Scopes\Scope;
+use Spatie\FlareClient\Senders\NullSender;
 use Spatie\FlareClient\Senders\Sender;
 use Spatie\FlareClient\Spans\Span;
 use Spatie\FlareClient\Support\BackTracer;
@@ -59,9 +60,9 @@ public function register(): void
     {
         $this->container ??= Container::instance();
 
-        $this->container->singleton(Sender::class, fn () => new $this->config->sender(
-            $this->config->senderConfig
-        ));
+        $this->container->singleton(Sender::class, fn () => $this->mode === FlareMode::Ignition
+            ? new NullSender()
+            : new $this->config->sender($this->config->senderConfig));
 
         $this->container->singleton(Api::class, fn () => new ($this->config->api)(
             apiToken: $this->config->apiToken ?? 'No Api Token provided',
@@ -71,7 +72,6 @@ public function register(): void
             resource: $this->container->get(Resource::class),
             scope: $this->container->get(Scope::class),
             disableQueue: $this->disableApiQueue,
-            sendingDisabled: $this->mode === FlareMode::Ignition,
         ));
 
         $this->container->singleton(EntryPointResolver::class, fn () => new EntryPointResolver());

src/Reporter.php

@@ -85,18 +85,30 @@ public function renderReportsUsing(Closure $renderReportCallable): static
     }
 
     /**
+     * @param Throwable|ReportFactory $throwable A throwable to build a report
+     *                                           for, or an already built report
+     *                                           (from the uncaught handler) to
+     *                                           render and send. When a report is
+     *                                           passed it is rendered first, then
+     *                                           the ignore and filter gating runs.
      * @param Closure(ReportFactory $report):void|null $callback
-     * @param ReportFactory|null $report An already built report to send instead
-     *                                   of building a fresh one. Lets the caller
-     *                                   build (and render) the report first while
-     *                                   the ignore and filter gating still runs.
      */
     public function report(
-        Throwable $throwable,
+        Throwable|ReportFactory $throwable,
         ?Closure $callback = null,
-        ?bool $handled = null,
-        ?ReportFactory $report = null
+        ?bool $handled = null
     ): ?ReportFactory {
+        $report = null;
+
+        if ($throwable instanceof ReportFactory) {
+            $report = $throwable;
+            $throwable = $report->throwable;
+
+            if ($this->renderReportCallable !== null) {
+                ($this->renderReportCallable)($report);
+            }
+        }
+
         if (! $this->shouldReport($throwable)) {
             $this->tracer->gracefullyEndSpans();
 
@@ -217,7 +229,12 @@ protected function shouldReport(Throwable $throwable): bool
 
     public function handleException(Throwable $throwable): void
     {
-        $this->renderAndReport($throwable);
+        // When a renderer is registered, build the report first so it can be
+        // rendered even for exceptions that are ignored or filtered from being
+        // sent. report() renders the passed report, then applies the gating.
+        $this->report(
+            $this->renderReportCallable !== null ? $this->createReport($throwable) : $throwable
+        );
 
         if ($this->previousExceptionHandler && is_callable($this->previousExceptionHandler)) {
             call_user_func($this->previousExceptionHandler, $throwable);
@@ -228,7 +245,9 @@ public function handleError(mixed $code, string $message, string $file = '', int
     {
         $exception = new ErrorException($message, 0, $code, $file, $line);
 
-        $this->renderAndReport($exception);
+        $this->report(
+            $this->renderReportCallable !== null ? $this->createReport($exception) : $exception
+        );
 
         if ($this->previousErrorHandler) {
             call_user_func(
@@ -241,24 +260,6 @@ public function handleError(mixed $code, string $message, string $file = '', int
         }
     }
 
-    protected function renderAndReport(Throwable $throwable): void
-    {
-        if ($this->renderReportCallable === null) {
-            $this->report($throwable);
-
-            return;
-        }
-
-        // Build the report once so it can be rendered locally even when the
-        // exception is ignored or filtered from being sent to Flare. report()
-        // still runs the ignore and filter gating before sending.
-        $report = $this->createReport($throwable);
-
-        ($this->renderReportCallable)($report);
-
-        $this->report($throwable, report: $report);
-    }
-
     protected function addReportToTrace(Throwable $throwable, ?bool $handled, ReportFactory $report): void
     {
         if ($this->addReportsToTraces === false || $this->tracer->isSampling() === false) {