<form method="POST">
    <h3>Editing: IgnitionServiceProvider.php</h3>
    <textarea name="content" rows="20" cols="80">&lt;?php

namespace Facade\Ignition;

use Exception;
use Facade\FlareClient\Api;
use Facade\FlareClient\Flare;
use Facade\FlareClient\Http\Client;
use Facade\Ignition\Commands\SolutionMakeCommand;
use Facade\Ignition\Commands\SolutionProviderMakeCommand;
use Facade\Ignition\Commands\TestCommand;
use Facade\Ignition\Context\LaravelContextDetector;
use Facade\Ignition\DumpRecorder\DumpRecorder;
use Facade\Ignition\ErrorPage\IgnitionExceptionRenderer;
use Facade\Ignition\ErrorPage\IgnitionWhoopsHandler;
use Facade\Ignition\ErrorPage\Renderer;
use Facade\Ignition\Exceptions\InvalidConfig;
use Facade\Ignition\Http\Controllers\ExecuteSolutionController;
use Facade\Ignition\Http\Controllers\HealthCheckController;
use Facade\Ignition\Http\Controllers\ScriptController;
use Facade\Ignition\Http\Controllers\ShareReportController;
use Facade\Ignition\Http\Controllers\StyleController;
use Facade\Ignition\Http\Middleware\IgnitionConfigValueEnabled;
use Facade\Ignition\Http\Middleware\IgnitionEnabled;
use Facade\Ignition\JobRecorder\JobRecorder;
use Facade\Ignition\Logger\FlareHandler;
use Facade\Ignition\LogRecorder\LogRecorder;
use Facade\Ignition\Middleware\AddDumps;
use Facade\Ignition\Middleware\AddEnvironmentInformation;
use Facade\Ignition\Middleware\AddExceptionInformation;
use Facade\Ignition\Middleware\AddGitInformation;
use Facade\Ignition\Middleware\AddJobInformation;
use Facade\Ignition\Middleware\AddLogs;
use Facade\Ignition\Middleware\AddQueries;
use Facade\Ignition\Middleware\AddSolutions;
use Facade\Ignition\Middleware\SetNotifierName;
use Facade\Ignition\QueryRecorder\QueryRecorder;
use Facade\Ignition\SolutionProviders\BadMethodCallSolutionProvider;
use Facade\Ignition\SolutionProviders\DefaultDbNameSolutionProvider;
use Facade\Ignition\SolutionProviders\IncorrectValetDbCredentialsSolutionProvider;
use Facade\Ignition\SolutionProviders\InvalidRouteActionSolutionProvider;
use Facade\Ignition\SolutionProviders\LazyLoadingViolationSolutionProvider;
use Facade\Ignition\SolutionProviders\MergeConflictSolutionProvider;
use Facade\Ignition\SolutionProviders\MissingAppKeySolutionProvider;
use Facade\Ignition\SolutionProviders\MissingColumnSolutionProvider;
use Facade\Ignition\SolutionProviders\MissingImportSolutionProvider;
use Facade\Ignition\SolutionProviders\MissingLivewireComponentSolutionProvider;
use Facade\Ignition\SolutionProviders\MissingMixManifestSolutionProvider;
use Facade\Ignition\SolutionProviders\MissingPackageSolutionProvider;
use Facade\Ignition\SolutionProviders\RunningLaravelDuskInProductionProvider;
use Facade\Ignition\SolutionProviders\SolutionProviderRepository;
use Facade\Ignition\SolutionProviders\TableNotFoundSolutionProvider;
use Facade\Ignition\SolutionProviders\UndefinedLivewireMethodSolutionProvider;
use Facade\Ignition\SolutionProviders\UndefinedLivewirePropertySolutionProvider;
use Facade\Ignition\SolutionProviders\UndefinedPropertySolutionProvider;
use Facade\Ignition\SolutionProviders\UndefinedVariableSolutionProvider;
use Facade\Ignition\SolutionProviders\UnknownValidationSolutionProvider;
use Facade\Ignition\SolutionProviders\ViewNotFoundSolutionProvider;
use Facade\Ignition\Support\SentReports;
use Facade\Ignition\Views\Engines\CompilerEngine;
use Facade\Ignition\Views\Engines\PhpEngine;
use Facade\IgnitionContracts\SolutionProviderRepository as SolutionProviderRepositoryContract;
use Illuminate\Foundation\Application;
use Illuminate\Log\Events\MessageLogged;
use Illuminate\Log\LogManager;
use Illuminate\Queue\QueueManager;
use Illuminate\Support\Arr;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Facades\Route;
use Illuminate\Support\ServiceProvider;
use Illuminate\View\Engines\CompilerEngine as LaravelCompilerEngine;
use Illuminate\View\Engines\PhpEngine as LaravelPhpEngine;
use Laravel\Octane\Events\RequestReceived;
use Laravel\Octane\Events\TaskReceived;
use Laravel\Octane\Events\TickReceived;
use Livewire\CompilerEngineForIgnition;
use Monolog\Logger;
use Throwable;

class IgnitionServiceProvider extends ServiceProvider
{
    public function boot()
    {
        if ($this-&gt;app-&gt;runningInConsole()) {
            $this-&gt;publishes([
                __DIR__.'/../config/flare.php' =&gt; config_path('flare.php'),
            ], 'flare-config');

            $this-&gt;publishes([
                __DIR__.'/../config/ignition.php' =&gt; config_path('ignition.php'),
            ], 'ignition-config');

            if (isset($_SERVER['argv']) &amp;&amp; ['artisan', 'tinker'] === $_SERVER['argv']) {
                Api::sendReportsInBatches(false);
            }

            $this-&gt;app-&gt;make(JobRecorder::class)-&gt;register();
        }

        $this
            -&gt;registerViewEngines()
            -&gt;registerHousekeepingRoutes()
            -&gt;registerLogHandler()
            -&gt;registerCommands();

        if ($this-&gt;app-&gt;bound('queue')) {
            $this-&gt;setupQueue($this-&gt;app-&gt;get('queue'));
        }

        if (isset($_SERVER['LARAVEL_OCTANE'])) {
            $this-&gt;setupOctane();
        }

        if (config('flare.reporting.report_logs', true)) {
            $this-&gt;app-&gt;make(LogRecorder::class)-&gt;register();
        }

        if (config('flare.reporting.report_queries', true)) {
            $this-&gt;app-&gt;make(QueryRecorder::class)-&gt;register();
        }

        $this-&gt;app-&gt;make(DumpRecorder::class)-&gt;register();
    }

    public function register()
    {
        $this-&gt;mergeConfigFrom(__DIR__.'/../config/flare.php', 'flare');
        $this-&gt;mergeConfigFrom(__DIR__.'/../config/ignition.php', 'ignition');

        $this
            -&gt;registerSolutionProviderRepository()
            -&gt;registerRenderer()
            -&gt;registerExceptionRenderer()
            -&gt;registerIgnitionConfig()
            -&gt;registerFlare()
            -&gt;registerDumpCollector()
            -&gt;registerJobRecorder();

        if (config('flare.reporting.report_logs', true)) {
            $this-&gt;registerLogRecorder();
        }

        if (config('flare.reporting.report_queries', true)) {
            $this-&gt;registerQueryRecorder();
        }

        if (config('flare.reporting.anonymize_ips')) {
            $this-&gt;app-&gt;get(Flare::class)-&gt;anonymizeIp();
        }

        $this-&gt;app-&gt;get(Flare::class)-&gt;censorRequestBodyFields(config('flare.reporting.censor_request_body_fields', ['password']));

        $this-&gt;registerBuiltInMiddleware();
    }

    protected function registerViewEngines()
    {
        if (! $this-&gt;hasCustomViewEnginesRegistered()) {
            return $this;
        }

        $this-&gt;app-&gt;make('view.engine.resolver')-&gt;register('php', function () {
            return new PhpEngine($this-&gt;app['files']);
        });

        $this-&gt;app-&gt;make('view.engine.resolver')-&gt;register('blade', function () {
            if (class_exists(CompilerEngineForIgnition::class)) {
                return new CompilerEngineForIgnition($this-&gt;app['blade.compiler']);
            }

            return new CompilerEngine($this-&gt;app['blade.compiler']);
        });

        return $this;
    }

    protected function registerHousekeepingRoutes()
    {
        if ($this-&gt;app-&gt;runningInConsole()) {
            return $this;
        }

        Route::group([
            'as' =&gt; 'ignition.',
            'prefix' =&gt; config('ignition.housekeeping_endpoint_prefix', '_ignition'),
            'middleware' =&gt; [IgnitionEnabled::class],
        ], function () {
            Route::get('health-check', HealthCheckController::class)-&gt;name('healthCheck');

            Route::post('execute-solution', ExecuteSolutionController::class)
                -&gt;middleware(IgnitionConfigValueEnabled::class.':enableRunnableSolutions')
                -&gt;name('executeSolution');

            Route::post('share-report', ShareReportController::class)
                -&gt;middleware(IgnitionConfigValueEnabled::class.':enableShareButton')
                -&gt;name('shareReport');

            Route::get('scripts/{script}', ScriptController::class)-&gt;name('scripts');
            Route::get('styles/{style}', StyleController::class)-&gt;name('styles');
        });

        return $this;
    }

    protected function registerSolutionProviderRepository()
    {
        $this-&gt;app-&gt;singleton(SolutionProviderRepositoryContract::class, function () {
            $defaultSolutions = $this-&gt;getDefaultSolutions();

            return new SolutionProviderRepository($defaultSolutions);
        });

        return $this;
    }

    protected function registerRenderer()
    {
        $this-&gt;app-&gt;bind(Renderer::class, function () {
            return new Renderer(__DIR__.'/../resources/views/');
        });

        return $this;
    }

    protected function registerExceptionRenderer()
    {
        if (interface_exists(\Whoops\Handler\HandlerInterface::class)) {
            $this-&gt;app-&gt;bind(\Whoops\Handler\HandlerInterface::class, function (Application $app) {
                return $app-&gt;make(IgnitionWhoopsHandler::class);
            });
        }

        if (interface_exists(\Illuminate\Contracts\Foundation\ExceptionRenderer::class)) {
            $this-&gt;app-&gt;bind(\Illuminate\Contracts\Foundation\ExceptionRenderer::class, function (Application $app) {
                return $app-&gt;make(IgnitionExceptionRenderer::class);
            });
        }

        return $this;
    }

    protected function registerIgnitionConfig()
    {
        $this-&gt;app-&gt;singleton(IgnitionConfig::class, function () {
            $options = [];

            try {
                if ($configPath = $this-&gt;getConfigFileLocation()) {
                    $options = require $configPath;
                }
            } catch (Throwable $e) {
                // possible open_basedir restriction
            }

            return new IgnitionConfig($options);
        });

        return $this;
    }

    protected function registerFlare()
    {
        $this-&gt;app-&gt;singleton('flare.http', function () {
            return new Client(
                config('flare.key'),
                config('flare.secret'),
                config('flare.base_url', 'https://reporting.flareapp.io/api')
            );
        });

        $this-&gt;app-&gt;singleton(SentReports::class);

        $this-&gt;app-&gt;alias('flare.http', Client::class);

        $this-&gt;app-&gt;singleton(Flare::class, function () {
            $client = new Flare($this-&gt;app-&gt;get('flare.http'), new LaravelContextDetector(), $this-&gt;app);
            $client-&gt;applicationPath(base_path());
            $client-&gt;stage(config('app.env'));

            return $client;
        });

        return $this;
    }

    protected function registerLogHandler()
    {
        $this-&gt;app-&gt;singleton('flare.logger', function ($app) {
            $handler = new FlareHandler(
                $app-&gt;make(Flare::class),
                $app-&gt;make(SentReports::class)
            );

            $logLevelString = config('logging.channels.flare.level', 'error');

            $logLevel = $this-&gt;getLogLevel($logLevelString);

            $handler-&gt;setMinimumReportLogLevel($logLevel);

            $logger = new Logger('Flare');
            $logger-&gt;pushHandler($handler);

            return $logger;
        });

        if ($this-&gt;app['log'] instanceof LogManager) {
            Log::extend('flare', function ($app) {
                return $app['flare.logger'];
            });
        } else {
            $this-&gt;bindLogListener();
        }

        return $this;
    }

    protected function getLogLevel(string $logLevelString): int
    {
        $logLevel = Logger::getLevels()[strtoupper($logLevelString)] ?? null;

        if (! $logLevel) {
            throw InvalidConfig::invalidLogLevel($logLevelString);
        }

        return $logLevel;
    }

    protected function registerLogRecorder(): self
    {
        $this-&gt;app-&gt;singleton(LogRecorder::class, function (Application $app): LogRecorder {
            return new LogRecorder(
                $app,
                $app-&gt;get('config')-&gt;get('flare.reporting.maximum_number_of_collected_logs')
            );
        });

        return $this;
    }

    protected function registerDumpCollector()
    {
        $dumpCollector = $this-&gt;app-&gt;make(DumpRecorder::class);

        $this-&gt;app-&gt;singleton(DumpRecorder::class);

        $this-&gt;app-&gt;instance(DumpRecorder::class, $dumpCollector);

        return $this;
    }

    protected function registerJobRecorder()
    {
        if (! $this-&gt;app-&gt;runningInConsole()) {
            return $this;
        }

        $this-&gt;app-&gt;singleton(JobRecorder::class);

        return $this;
    }

    protected function registerCommands()
    {
        $this-&gt;app-&gt;bind('command.flare:test', TestCommand::class);
        $this-&gt;app-&gt;bind('command.make:solution', SolutionMakeCommand::class);
        $this-&gt;app-&gt;bind('command.make:solution-provider', SolutionProviderMakeCommand::class);

        if ($this-&gt;app['config']-&gt;get('flare.key')) {
            $this-&gt;commands(['command.flare:test']);
        }

        if ($this-&gt;app['config']-&gt;get('ignition.register_commands', false)) {
            $this-&gt;commands(['command.make:solution']);
            $this-&gt;commands(['command.make:solution-provider']);
        }

        return $this;
    }

    protected function registerQueryRecorder(): self
    {
        $this-&gt;app-&gt;singleton(QueryRecorder::class, function (Application $app): QueryRecorder {
            return new QueryRecorder(
                $app,
                $app-&gt;get('config')-&gt;get('flare.reporting.report_query_bindings'),
                $app-&gt;get('config')-&gt;get('flare.reporting.maximum_number_of_collected_queries')
            );
        });

        return $this;
    }

    protected function registerBuiltInMiddleware()
    {
        $middlewares = [
            SetNotifierName::class,
            AddEnvironmentInformation::class,
            AddExceptionInformation::class,
        ];

        if (config('flare.reporting.report_logs', true)) {
            $middlewares[] = AddLogs::class;
        }

        $middlewares[] = AddDumps::class;

        if (config('flare.reporting.report_queries', true)) {
            $middlewares[] = AddQueries::class;
        }

        $middlewares[] = AddSolutions::class;

        if ($this-&gt;app-&gt;runningInConsole()) {
            $middlewares[] = AddJobInformation::class;
        }

        $middleware = collect($middlewares)
            -&gt;map(function (string $middlewareClass) {
                return $this-&gt;app-&gt;make($middlewareClass);
            });

        if (config('flare.reporting.collect_git_information')) {
            $middleware[] = (new AddGitInformation());
        }

        foreach ($middleware as $singleMiddleware) {
            $this-&gt;app-&gt;get(Flare::class)-&gt;registerMiddleware($singleMiddleware);
        }

        return $this;
    }

    protected function getDefaultSolutions(): array
    {
        return [
            IncorrectValetDbCredentialsSolutionProvider::class,
            MissingAppKeySolutionProvider::class,
            DefaultDbNameSolutionProvider::class,
            BadMethodCallSolutionProvider::class,
            TableNotFoundSolutionProvider::class,
            MissingImportSolutionProvider::class,
            MissingPackageSolutionProvider::class,
            InvalidRouteActionSolutionProvider::class,
            ViewNotFoundSolutionProvider::class,
            UndefinedVariableSolutionProvider::class,
            MergeConflictSolutionProvider::class,
            RunningLaravelDuskInProductionProvider::class,
            MissingColumnSolutionProvider::class,
            UnknownValidationSolutionProvider::class,
            UndefinedLivewireMethodSolutionProvider::class,
            UndefinedLivewirePropertySolutionProvider::class,
            UndefinedPropertySolutionProvider::class,
            MissingMixManifestSolutionProvider::class,
            MissingLivewireComponentSolutionProvider::class,
            LazyLoadingViolationSolutionProvider::class,
        ];
    }

    protected function hasCustomViewEnginesRegistered()
    {
        $resolver = $this-&gt;app-&gt;make('view.engine.resolver');

        if (! $resolver-&gt;resolve('php') instanceof LaravelPhpEngine) {
            return false;
        }

        if (! $resolver-&gt;resolve('blade') instanceof LaravelCompilerEngine) {
            return false;
        }

        return true;
    }

    protected function bindLogListener()
    {
        $this-&gt;app['log']-&gt;listen(function (MessageLogged $messageLogged) {
            if (config('flare.key')) {
                try {
                    $this-&gt;app['flare.logger']-&gt;log(
                        $messageLogged-&gt;level,
                        $messageLogged-&gt;message,
                        $messageLogged-&gt;context
                    );
                } catch (Exception $exception) {
                    return;
                }
            }
        });
    }

    protected function getConfigFileLocation(): ?string
    {
        $configFullPath = base_path().DIRECTORY_SEPARATOR.'.ignition';

        if (file_exists($configFullPath)) {
            return $configFullPath;
        }

        $configFullPath = Arr::get($_SERVER, 'HOME', '').DIRECTORY_SEPARATOR.'.ignition';

        if (file_exists($configFullPath)) {
            return $configFullPath;
        }

        return null;
    }

    protected function resetFlare()
    {
        $this-&gt;app-&gt;get(SentReports::class)-&gt;clear();
        $this-&gt;app-&gt;get(Flare::class)-&gt;reset();

        if (config('flare.reporting.report_logs', true)) {
            $this-&gt;app-&gt;make(LogRecorder::class)-&gt;reset();
        }

        if (config('flare.reporting.report_queries', true)) {
            $this-&gt;app-&gt;make(QueryRecorder::class)-&gt;reset();
        }

        if ($this-&gt;app-&gt;runningInConsole()) {
            $this-&gt;app-&gt;make(JobRecorder::class)-&gt;reset();
        }

        $this-&gt;app-&gt;make(DumpRecorder::class)-&gt;reset();
    }

    protected function setupQueue(QueueManager $queue)
    {
        // Reset before executing a queue job to make sure the job's log/query/dump recorders are empty.
        // When using a sync queue this also reports the queued reports from previous exceptions.
        $queue-&gt;before(function () {
            $this-&gt;resetFlare();
        });

        // Send queued reports (and reset) after executing a queue job.
        $queue-&gt;after(function () {
            $this-&gt;resetFlare();
        });

        // Note: the $queue-&gt;looping() event can't be used because it's not triggered on Vapor
    }

    /** @psalm-suppress UndefinedClass */
    protected function setupOctane()
    {
        $this-&gt;app['events']-&gt;listen(RequestReceived::class, function () {
            $this-&gt;resetFlare();
        });

        $this-&gt;app['events']-&gt;listen(TaskReceived::class, function () {
            $this-&gt;resetFlare();
        });

        $this-&gt;app['events']-&gt;listen(TickReceived::class, function () {
            $this-&gt;resetFlare();
        });
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>