IgnitionServiceProvider::setupQueue() - Code Metrics - facade/ignition - Measure and Improve Code Quality continuously with Scrutinizer

IgnitionServiceProvider::setupQueue() A
last analyzed 2020-06-08 09:16 UTC

↳ Parent: IgnitionServiceProvider

Complexity

Conditions	2
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	14
rs	9.7998
c	0
b	0
f	0
cc	2
nc	1
nop	1

<?php

namespace Facade\Ignition;

use Facade\FlareClient\Flare;
use Facade\FlareClient\Http\Client;
use Facade\Ignition\Commands\SolutionMakeCommand;
use Facade\Ignition\Commands\TestCommand;
use Facade\Ignition\Context\LaravelContextDetector;
use Facade\Ignition\DumpRecorder\DumpRecorder;
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\Logger\FlareHandler;
use Facade\Ignition\LogRecorder\LogRecorder;
use Facade\Ignition\Middleware\AddDumps;
use Facade\Ignition\Middleware\AddEnvironmentInformation;
use Facade\Ignition\Middleware\AddGitInformation;
use Facade\Ignition\Middleware\AddLogs;
use Facade\Ignition\Middleware\AddQueries;
use Facade\Ignition\Middleware\AddSolutions;
use Facade\Ignition\Middleware\CustomizeGrouping;
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\MergeConflictSolutionProvider;
use Facade\Ignition\SolutionProviders\MissingAppKeySolutionProvider;
use Facade\Ignition\SolutionProviders\MissingColumnSolutionProvider;
use Facade\Ignition\SolutionProviders\MissingImportSolutionProvider;
use Facade\Ignition\SolutionProviders\MissingPackageSolutionProvider;
use Facade\Ignition\SolutionProviders\RunningLaravelDuskInProductionProvider;
use Facade\Ignition\SolutionProviders\SolutionProviderRepository;
use Facade\Ignition\SolutionProviders\TableNotFoundSolutionProvider;
use Facade\Ignition\SolutionProviders\UndefinedVariableSolutionProvider;
use Facade\Ignition\SolutionProviders\UnknownValidationSolutionProvider;
use Facade\Ignition\SolutionProviders\ViewNotFoundSolutionProvider;
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 Monolog\Logger;
use Throwable;
use Whoops\Handler\HandlerInterface;

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

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

        $this
            ->registerViewEngines()
            ->registerHousekeepingRoutes()
            ->registerLogHandler()
            ->registerCommands()
            ->setupQueue($this->app->queue);
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}

        $this->app->make(QueryRecorder::class)->register();
        $this->app->make(LogRecorder::class)->register();
        $this->app->make(DumpRecorder::class)->register();
    }

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

        $this
            ->registerSolutionProviderRepository()
            ->registerExceptionRenderer()
            ->registerWhoopsHandler()
            ->registerIgnitionConfig()
            ->registerFlare()
            ->registerLogRecorder()
            ->registerDumpCollector();

        if (config('flare.reporting.report_queries')) {
            $this->registerQueryRecorder();
        }

        if (config('flare.reporting.anonymize_ips')) {
            $this->app->get('flare.client')->anonymizeIp();
        }

        $this->registerBuiltInMiddleware();
    }

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

        $this->app->make('view.engine.resolver')->register('php', function () {
            return new PhpEngine();
        });

        $this->app->make('view.engine.resolver')->register('blade', function () {
            return new CompilerEngine($this->app['blade.compiler']);
        });

        return $this;
    }

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

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

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

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

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

        return $this;
    }

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

            return new SolutionProviderRepository($defaultSolutions);
        });

        return $this;
    }

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

        return $this;
    }

    protected function registerWhoopsHandler()
    {
        $this->app->bind(HandlerInterface::class, function (Application $app) {
            return $app->make(IgnitionWhoopsHandler::class);
        });

        return $this;
    }

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

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

            return new IgnitionConfig($options);
        });

        return $this;
    }

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

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

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

            return $client;
        });

        $this->app->alias('flare.client', Flare::class);

        return $this;
    }

    protected function registerLogHandler()
    {
        $this->app->singleton('flare.logger', function ($app) {
            $handler = new FlareHandler($app->make('flare.client'));

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

            $logLevel = $this->getLogLevel($logLevelString);

            $handler->setMinimumReportLogLevel($logLevel);

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

            return $logger;
        });

        if ($this->app['log'] instanceof LogManager) {
            Log::extend('flare', function ($app) {
                return $app['flare.logger'];
            });
        } else {
            $this->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()
    {
        $logCollector = $this->app->make(LogRecorder::class);

        $this->app->singleton(LogRecorder::class);

        $this->app->instance(LogRecorder::class, $logCollector);

        return $this;
    }

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

        $this->app->singleton(DumpRecorder::class);

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

        return $this;
    }

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

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

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

        return $this;
    }

    protected function registerQueryRecorder()
    {
        $queryCollector = $this->app->make(QueryRecorder::class);

        $this->app->singleton(QueryRecorder::class);

        $this->app->instance(QueryRecorder::class, $queryCollector);

        return $this;
    }

    protected function registerBuiltInMiddleware()
    {
        $middleware = collect([
            SetNotifierName::class,
            AddEnvironmentInformation::class,
            AddLogs::class,
            AddDumps::class,
            AddQueries::class,
            AddSolutions::class,
        ])
        ->map(function (string $middlewareClass) {
            return $this->app->make($middlewareClass);
        });

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

        if (! is_null(config('flare.reporting.grouping_type'))) {
            $middleware[] = new CustomizeGrouping(config('flare.reporting.grouping_type'));
        }

        foreach ($middleware as $singleMiddleware) {
            $this->app->get('flare.client')->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,
        ];
    }

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

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

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

        return true;
    }

    protected function bindLogListener()
    {
        $this->app['log']->listen(function (MessageLogged $messageLogged) {
            if (config('flare.key')) {
                try {
                    $this->app['flare.logger']->log(
                        $messageLogged->level,
                        $messageLogged->message,
                        $messageLogged->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 setupQueue(QueueManager $queue)
    {
        $queue->looping(function () {
            $this->app->get('flare.client')->reset();

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

            $this->app->make(LogRecorder::class)->reset();

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


1			<?php
2
3			namespace Facade\Ignition;
4
5			use Facade\FlareClient\Flare;
6			use Facade\FlareClient\Http\Client;
7			use Facade\Ignition\Commands\SolutionMakeCommand;
8			use Facade\Ignition\Commands\TestCommand;
9			use Facade\Ignition\Context\LaravelContextDetector;
10			use Facade\Ignition\DumpRecorder\DumpRecorder;
11			use Facade\Ignition\ErrorPage\IgnitionWhoopsHandler;
12			use Facade\Ignition\ErrorPage\Renderer;
13			use Facade\Ignition\Exceptions\InvalidConfig;
14			use Facade\Ignition\Http\Controllers\ExecuteSolutionController;
15			use Facade\Ignition\Http\Controllers\HealthCheckController;
16			use Facade\Ignition\Http\Controllers\ScriptController;
17			use Facade\Ignition\Http\Controllers\ShareReportController;
18			use Facade\Ignition\Http\Controllers\StyleController;
19			use Facade\Ignition\Http\Middleware\IgnitionConfigValueEnabled;
20			use Facade\Ignition\Http\Middleware\IgnitionEnabled;
21			use Facade\Ignition\Logger\FlareHandler;
22			use Facade\Ignition\LogRecorder\LogRecorder;
23			use Facade\Ignition\Middleware\AddDumps;
24			use Facade\Ignition\Middleware\AddEnvironmentInformation;
25			use Facade\Ignition\Middleware\AddGitInformation;
26			use Facade\Ignition\Middleware\AddLogs;
27			use Facade\Ignition\Middleware\AddQueries;
28			use Facade\Ignition\Middleware\AddSolutions;
29			use Facade\Ignition\Middleware\CustomizeGrouping;
30			use Facade\Ignition\Middleware\SetNotifierName;
31			use Facade\Ignition\QueryRecorder\QueryRecorder;
32			use Facade\Ignition\SolutionProviders\BadMethodCallSolutionProvider;
33			use Facade\Ignition\SolutionProviders\DefaultDbNameSolutionProvider;
34			use Facade\Ignition\SolutionProviders\IncorrectValetDbCredentialsSolutionProvider;
35			use Facade\Ignition\SolutionProviders\InvalidRouteActionSolutionProvider;
36			use Facade\Ignition\SolutionProviders\MergeConflictSolutionProvider;
37			use Facade\Ignition\SolutionProviders\MissingAppKeySolutionProvider;
38			use Facade\Ignition\SolutionProviders\MissingColumnSolutionProvider;
39			use Facade\Ignition\SolutionProviders\MissingImportSolutionProvider;
40			use Facade\Ignition\SolutionProviders\MissingPackageSolutionProvider;
41			use Facade\Ignition\SolutionProviders\RunningLaravelDuskInProductionProvider;
42			use Facade\Ignition\SolutionProviders\SolutionProviderRepository;
43			use Facade\Ignition\SolutionProviders\TableNotFoundSolutionProvider;
44			use Facade\Ignition\SolutionProviders\UndefinedVariableSolutionProvider;
45			use Facade\Ignition\SolutionProviders\UnknownValidationSolutionProvider;
46			use Facade\Ignition\SolutionProviders\ViewNotFoundSolutionProvider;
47			use Facade\Ignition\Views\Engines\CompilerEngine;
48			use Facade\Ignition\Views\Engines\PhpEngine;
49			use Facade\IgnitionContracts\SolutionProviderRepository as SolutionProviderRepositoryContract;
50			use Illuminate\Foundation\Application;
51			use Illuminate\Log\Events\MessageLogged;
52			use Illuminate\Log\LogManager;
53			use Illuminate\Queue\QueueManager;
54			use Illuminate\Support\Arr;
55			use Illuminate\Support\Facades\Log;
56			use Illuminate\Support\Facades\Route;
57			use Illuminate\Support\ServiceProvider;
58			use Illuminate\View\Engines\CompilerEngine as LaravelCompilerEngine;
59			use Illuminate\View\Engines\PhpEngine as LaravelPhpEngine;
60			use Monolog\Logger;
61			use Throwable;
62			use Whoops\Handler\HandlerInterface;
63
64			class IgnitionServiceProvider extends ServiceProvider
65			{
66			public function boot()
67			{
68			if ($this->app->runningInConsole()) {
69			$this->publishes([
70			__DIR__.'/../config/flare.php' => config_path('flare.php'),
71			], 'flare-config');
72
73			$this->publishes([
74			__DIR__.'/../config/ignition.php' => config_path('ignition.php'),
75			], 'ignition-config');
76			}
77
78			$this
79			->registerViewEngines()
80			->registerHousekeepingRoutes()
81			->registerLogHandler()
82			->registerCommands()
83			->setupQueue($this->app->queue);
			0 ignored issues – show Bug introduced 2019-09-02 10:16 UTC by Report Bug Copy Issue Report Accessing `queue` on the interface `Illuminate\Contracts\Foundation\Application` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
84
85			$this->app->make(QueryRecorder::class)->register();
86			$this->app->make(LogRecorder::class)->register();
87			$this->app->make(DumpRecorder::class)->register();
88			}
89
90			public function register()
91			{
92			$this->mergeConfigFrom(__DIR__.'/../config/flare.php', 'flare');
93			$this->mergeConfigFrom(__DIR__.'/../config/ignition.php', 'ignition');
94
95			$this
96			->registerSolutionProviderRepository()
97			->registerExceptionRenderer()
98			->registerWhoopsHandler()
99			->registerIgnitionConfig()
100			->registerFlare()
101			->registerLogRecorder()
102			->registerDumpCollector();
103
104			if (config('flare.reporting.report_queries')) {
105			$this->registerQueryRecorder();
106			}
107
108			if (config('flare.reporting.anonymize_ips')) {
109			$this->app->get('flare.client')->anonymizeIp();
110			}
111
112			$this->registerBuiltInMiddleware();
113			}
114
115			protected function registerViewEngines()
116			{
117			if (! $this->hasCustomViewEnginesRegistered()) {
118			return $this;
119			}
120
121			$this->app->make('view.engine.resolver')->register('php', function () {
122			return new PhpEngine();
123			});
124
125			$this->app->make('view.engine.resolver')->register('blade', function () {
126			return new CompilerEngine($this->app['blade.compiler']);
127			});
128
129			return $this;
130			}
131
132			protected function registerHousekeepingRoutes()
133			{
134			if ($this->app->runningInConsole()) {
135			return $this;
136			}
137
138			Route::group([
139			'as' => 'ignition.',
140			'prefix' => config('ignition.housekeeping_endpoint_prefix', '_ignition'),
141			'middleware' => [IgnitionEnabled::class],
142			], function () {
143			Route::get('health-check', HealthCheckController::class)->name('healthCheck');
144
145			Route::post('execute-solution', ExecuteSolutionController::class)
146			->middleware(IgnitionConfigValueEnabled::class.':enableRunnableSolutions')
147			->name('executeSolution');
148
149			Route::post('share-report', ShareReportController::class)
150			->middleware(IgnitionConfigValueEnabled::class.':enableShareButton')
151			->name('shareReport');
152
153			Route::get('scripts/{script}', ScriptController::class)->name('scripts');
154			Route::get('styles/{style}', StyleController::class)->name('styles');
155			});
156
157			return $this;
158			}
159
160			protected function registerSolutionProviderRepository()
161			{
162			$this->app->singleton(SolutionProviderRepositoryContract::class, function () {
163			$defaultSolutions = $this->getDefaultSolutions();
164
165			return new SolutionProviderRepository($defaultSolutions);
166			});
167
168			return $this;
169			}
170
171			protected function registerExceptionRenderer()
172			{
173			$this->app->bind(Renderer::class, function () {
174			return new Renderer(__DIR__.'/../resources/views/');
175			});
176
177			return $this;
178			}
179
180			protected function registerWhoopsHandler()
181			{
182			$this->app->bind(HandlerInterface::class, function (Application $app) {
183			return $app->make(IgnitionWhoopsHandler::class);
184			});
185
186			return $this;
187			}
188
189			protected function registerIgnitionConfig()
190			{
191			$this->app->singleton(IgnitionConfig::class, function () {
192			$options = [];
193
194			try {
195			if ($configPath = $this->getConfigFileLocation()) {
196			$options = require $configPath;
197			}
198			} catch (Throwable $e) {
199			// possible open_basedir restriction
200			}
201
202			return new IgnitionConfig($options);
203			});
204
205			return $this;
206			}
207
208			protected function registerFlare()
209			{
210			$this->app->singleton('flare.http', function () {
211			return new Client(
212			config('flare.key'),
213			config('flare.secret'),
214			config('flare.base_url', 'https://flareapp.io/api')
215			);
216			});
217
218			$this->app->alias('flare.http', Client::class);
219
220			$this->app->singleton('flare.client', function () {
221			$client = new Flare($this->app->get('flare.http'), new LaravelContextDetector, $this->app);
222			$client->applicationPath(base_path());
223			$client->stage(config('app.env'));
224
225			return $client;
226			});
227
228			$this->app->alias('flare.client', Flare::class);
229
230			return $this;
231			}
232
233			protected function registerLogHandler()
234			{
235			$this->app->singleton('flare.logger', function ($app) {
236			$handler = new FlareHandler($app->make('flare.client'));
237
238			$logLevelString = config('logging.channels.flare.level', 'error');
239
240			$logLevel = $this->getLogLevel($logLevelString);
241
242			$handler->setMinimumReportLogLevel($logLevel);
243
244			$logger = new Logger('Flare');
245			$logger->pushHandler($handler);
246
247			return $logger;
248			});
249
250			if ($this->app['log'] instanceof LogManager) {
251			Log::extend('flare', function ($app) {
252			return $app['flare.logger'];
253			});
254			} else {
255			$this->bindLogListener();
256			}
257
258			return $this;
259			}
260
261			protected function getLogLevel(string $logLevelString): int
262			{
263			$logLevel = Logger::getLevels()[strtoupper($logLevelString)] ?? null;
264
265			if (! $logLevel) {
266			throw InvalidConfig::invalidLogLevel($logLevelString);
267			}
268
269			return $logLevel;
270			}
271
272			protected function registerLogRecorder()
273			{
274			$logCollector = $this->app->make(LogRecorder::class);
275
276			$this->app->singleton(LogRecorder::class);
277
278			$this->app->instance(LogRecorder::class, $logCollector);
279
280			return $this;
281			}
282
283			protected function registerDumpCollector()
284			{
285			$dumpCollector = $this->app->make(DumpRecorder::class);
286
287			$this->app->singleton(DumpRecorder::class);
288
289			$this->app->instance(DumpRecorder::class, $dumpCollector);
290
291			return $this;
292			}
293
294			protected function registerCommands()
295			{
296			$this->app->bind('command.flare:test', TestCommand::class);
297			$this->app->bind('command.make:solution', SolutionMakeCommand::class);
298
299			if ($this->app['config']->get('flare.key')) {
300			$this->commands(['command.flare:test']);
301			}
302
303			if ($this->app['config']->get('ignition.register_commands', false)) {
304			$this->commands(['command.make:solution']);
305			}
306
307			return $this;
308			}
309
310			protected function registerQueryRecorder()
311			{
312			$queryCollector = $this->app->make(QueryRecorder::class);
313
314			$this->app->singleton(QueryRecorder::class);
315
316			$this->app->instance(QueryRecorder::class, $queryCollector);
317
318			return $this;
319			}
320
321			protected function registerBuiltInMiddleware()
322			{
323			$middleware = collect([
324			SetNotifierName::class,
325			AddEnvironmentInformation::class,
326			AddLogs::class,
327			AddDumps::class,
328			AddQueries::class,
329			AddSolutions::class,
330			])
331			->map(function (string $middlewareClass) {
332			return $this->app->make($middlewareClass);
333			});
334
335			if (config('flare.reporting.collect_git_information')) {
336			$middleware[] = (new AddGitInformation());
337			}
338
339			if (! is_null(config('flare.reporting.grouping_type'))) {
340			$middleware[] = new CustomizeGrouping(config('flare.reporting.grouping_type'));
341			}
342
343			foreach ($middleware as $singleMiddleware) {
344			$this->app->get('flare.client')->registerMiddleware($singleMiddleware);
345			}
346
347			return $this;
348			}
349
350			protected function getDefaultSolutions(): array
351			{
352			return [
353			IncorrectValetDbCredentialsSolutionProvider::class,
354			MissingAppKeySolutionProvider::class,
355			DefaultDbNameSolutionProvider::class,
356			BadMethodCallSolutionProvider::class,
357			TableNotFoundSolutionProvider::class,
358			MissingImportSolutionProvider::class,
359			MissingPackageSolutionProvider::class,
360			InvalidRouteActionSolutionProvider::class,
361			ViewNotFoundSolutionProvider::class,
362			UndefinedVariableSolutionProvider::class,
363			MergeConflictSolutionProvider::class,
364			RunningLaravelDuskInProductionProvider::class,
365			MissingColumnSolutionProvider::class,
366			UnknownValidationSolutionProvider::class,
367			];
368			}
369
370			protected function hasCustomViewEnginesRegistered()
371			{
372			$resolver = $this->app->make('view.engine.resolver');
373
374			if (! $resolver->resolve('php') instanceof LaravelPhpEngine) {
375			return false;
376			}
377
378			if (! $resolver->resolve('blade') instanceof LaravelCompilerEngine) {
379			return false;
380			}
381
382			return true;
383			}
384
385			protected function bindLogListener()
386			{
387			$this->app['log']->listen(function (MessageLogged $messageLogged) {
388			if (config('flare.key')) {
389			try {
390			$this->app['flare.logger']->log(
391			$messageLogged->level,
392			$messageLogged->message,
393			$messageLogged->context
394			);
395			} catch (Exception $exception) {
			0 ignored issues – show Bug introduced 2019-08-30 23:38 UTC by Report Bug Copy Issue Report The class `Facade\Ignition\Exception` does not exist. Did you forget a USE statement, or did you not list all dependencies? Scrutinizer analyzes your `composer.json`/`composer.lock` file if available to determine the classes, and functions that are defined by your dependencies. It seems like the listed class was neither found in your dependencies, nor was it found in the analyzed files in your repository. If you are using some other form of dependency management, you might want to disable this analysis. Loading history...
396			return;
397			}
398			}
399			});
400			}
401
402			protected function getConfigFileLocation(): ?string
403			{
404			$configFullPath = base_path().DIRECTORY_SEPARATOR.'.ignition';
405
406			if (file_exists($configFullPath)) {
407			return $configFullPath;
408			}
409
410			$configFullPath = Arr::get($_SERVER, 'HOME', '').DIRECTORY_SEPARATOR.'.ignition';
411
412			if (file_exists($configFullPath)) {
413			return $configFullPath;
414			}
415
416			return null;
417			}
418
419			protected function setupQueue(QueueManager $queue)
420			{
421			$queue->looping(function () {
422			$this->app->get('flare.client')->reset();
423
424			if (config('flare.reporting.report_queries')) {
425			$this->app->make(QueryRecorder::class)->reset();
426			}
427
428			$this->app->make(LogRecorder::class)->reset();
429
430			$this->app->make(DumpRecorder::class)->reset();
431			});
432			}
433			}
434

facade / ignition

IgnitionServiceProvider::setupQueue() A last analyzed 2020-06-08 09:16 UTC

Complexity

Size

Duplication

Importance

Available Fixes

Duplication Side-by-Side

Filter issues like

IgnitionServiceProvider::setupQueue() A
last analyzed 2020-06-08 09:16 UTC