composer require spatie/laravel-health
composer require spatie/cpu-load-health-check
composer require spatie/security-advisories-health-check
composer require srwiez/queue-size-health-check
composer require victord11/ssl-certification-health-check

<?php

namespace Modules\HealthCheck\Providers;

use Ahtinurme\OctaneCheck;
use Illuminate\Console\Scheduling\Schedule;
use Illuminate\Contracts\Foundation\CachesRoutes;
use Illuminate\Support\Facades\Route;
use Illuminate\Support\ServiceProvider;
use Lorisleiva\Actions\Facades\Actions;
use Modules\HealthCheck\Actions\CheckSystemHealth;
use QueueSizeCheck\QueueSizeCheck;
use Spatie\CpuLoadHealthCheck\CpuLoadCheck;
use Spatie\Health\Checks\Checks\CacheCheck;
use Spatie\Health\Checks\Checks\DatabaseConnectionCountCheck;
use Spatie\Health\Checks\Checks\DatabaseSizeCheck;
use Spatie\Health\Checks\Checks\DebugModeCheck;
use Spatie\Health\Checks\Checks\HorizonCheck;
use Spatie\Health\Checks\Checks\OptimizedAppCheck;
use Spatie\Health\Checks\Checks\RedisCheck;
use Spatie\Health\Checks\Checks\RedisMemoryUsageCheck;
use Spatie\Health\Checks\Checks\ScheduleCheck;
use Spatie\Health\Checks\Checks\UsedDiskSpaceCheck;
use Spatie\Health\Commands\ScheduleCheckHeartbeatCommand;
use Spatie\Health\Facades\Health;
use Spatie\Health\Http\Controllers\HealthCheckResultsController;
use Spatie\Health\Models\HealthCheckResultHistoryItem;
use Spatie\SecurityAdvisoriesHealthCheck\SecurityAdvisoriesCheck;
use VictoRD11\SslCertificationHealthCheck\SslCertificationExpiredCheck;
use VictoRD11\SslCertificationHealthCheck\SslCertificationValidCheck;

class HealthCheckServiceProvider extends ServiceProvider
{
    protected string $moduleName = 'HealthCheck';

    public function boot(): void
    {
        $this->registerHealthCheck();
        $this->registerSchedule();
        $this->registerRoutes();
        $this->registerCommands();
    }

    private function registerCommands(): void
    {
        if ($this->app->runningInConsole()) {
            Actions::registerCommands(module_path($this->moduleName, 'Actions'));
        }
    }

    private function registerSchedule(): void
    {
        $this->app->booted(function () {
            $schedule = $this->app->make(Schedule::class);
            $schedule->command(ScheduleCheckHeartbeatCommand::class)->everyMinute();

            $schedule->command('model:prune', [
                '--model' => [
                    HealthCheckResultHistoryItem::class,
                ],
            ])->daily();
        });
    }

    private function registerRoutes(): void
    {
        if ($this->app instanceof CachesRoutes && $this->app->routesAreCached()) {
            return;
        }

        Route::get(config('health.path'), HealthCheckResultsController::class)
            ->middleware(config('health.middleware', 'web'));

        Route::get(config('health.check_path'), CheckSystemHealth::class)
            ->middleware(config('health.middleware', 'web'));

        Route::get('/up', fn () => '');
    }
    private function registerHealthCheck(): void
    {
        $isLocal = app()->environment('local');
        $appUrl = config('app.url');
        Health::checks([
            OctaneCheck::new(),
            HorizonCheck::new(),
            ScheduleCheck::new()
                ->useCacheStore(config('cache.default')),
            DatabaseConnectionCountCheck::new()
                ->failWhenMoreConnectionsThan(20),
            DatabaseSizeCheck::new()
                ->failWhenSizeAboveGb(errorThresholdGb: 25.0),
            QueueSizeCheck::new()
                ->queue('default', 100),
            UsedDiskSpaceCheck::new()->unless($isLocal),
            RedisCheck::new()->unless($isLocal),
            CpuLoadCheck::new()
                ->unless($isLocal)
                ->failWhenLoadIsHigherInTheLastMinute(8)
                ->failWhenLoadIsHigherInTheLast5Minutes(8.0)
                ->failWhenLoadIsHigherInTheLast15Minutes(8.5),
            DebugModeCheck::new()
                ->unless($isLocal),
            RedisMemoryUsageCheck::new()
                ->unless($isLocal)
                ->failWhenAboveMb(3000),
            SecurityAdvisoriesCheck::new()
                ->unless($isLocal),
            SslCertificationExpiredCheck::new()
                ->unless($isLocal)
                ->url($appUrl)->warnWhenSslCertificationExpiringDay(7)
                ->failWhenSslCertificationExpiringDay(3),
            SslCertificationValidCheck::new()
                ->unless($isLocal)
                ->url($appUrl),
            OptimizedAppCheck::new()
                ->unless($isLocal),
            CacheCheck::new()
                ->unless($isLocal)
        ]);
    }
}

<?php

use Olssonm\VeryBasicAuth\Http\Middleware\VeryBasicAuth;

return [

    'path' => env('HEALTH_PATH', 'health'),
    'check_path' => env('HEALTH_CHECK_PATH', 'health-check'),

    'middleware' => [
        'web',
        VeryBasicAuth::class
    ],

    /*
     * A result store is responsible for saving the results of the checks. The
     * `EloquentHealthResultStore` will save results in the database. You
     * can use multiple stores at the same time.
     */
    'result_stores' => [
        Spatie\Health\ResultStores\EloquentHealthResultStore::class => [
            'connection' => env('HEALTH_DB_CONNECTION', env('DB_CONNECTION')),
            'model' => Spatie\Health\Models\HealthCheckResultHistoryItem::class,
            'keep_history_for_days' => 5,
        ],

        /*
        Spatie\Health\ResultStores\CacheHealthResultStore::class => [
            'store' => 'file',
        ],

        Spatie\Health\ResultStores\JsonFileHealthResultStore::class => [
            'disk' => 's3',
            'path' => 'health.json',
        ],

        Spatie\Health\ResultStores\InMemoryHealthResultStore::class,
        */
    ],

    /*
     * You can get notified when specific events occur. Out of the box you can use 'mail' and 'slack'.
     * For Slack you need to install laravel/slack-notification-channel.
     */
    'notifications' => [
        /*
         * Notifications will only get sent if this option is set to `true`.
         */
        'enabled' =>  false,

        'notifications' => [
            Spatie\Health\Notifications\CheckFailedNotification::class => ['mail'],
        ],

        /*
         * Here you can specify the notifiable to which the notifications should be sent. The default
         * notifiable will use the variables specified in this config file.
         */
        'notifiable' => Spatie\Health\Notifications\Notifiable::class,

        /*
         * When checks start failing, you could potentially end up getting
         * a notification every minute.
         *
         * With this setting, notifications are throttled. By default, you'll
         * only get one notification per hour.
         */
        'throttle_notifications_for_minutes' => 60,
        'throttle_notifications_key' => 'health:latestNotificationSentAt:',

        'mail' => [
            'to' => 'your@example.com',

            'from' => [
                'address' => env('MAIL_FROM_ADDRESS', 'hello@example.com'),
                'name' => env('MAIL_FROM_NAME', 'Example'),
            ],
        ],

        'slack' => [
            'webhook_url' => env('HEALTH_SLACK_WEBHOOK_URL', ''),

            /*
             * If this is set to null the default channel of the webhook will be used.
             */
            'channel' => null,

            'username' => null,

            'icon' => null,
        ],
    ],

    /*
     * You can let Oh Dear monitor the results of all health checks. This way, you'll
     * get notified of any problems even if your application goes totally down. Via
     * Oh Dear, you can also have access to more advanced notification options.
     */
    'oh_dear_endpoint' => [
        'enabled' => false,

        /*
         * When this option is enabled, the checks will run before sending a response.
         * Otherwise, we'll send the results from the last time the checks have run.
         */
        'always_send_fresh_results' => false,

        /*
         * The secret that is displayed at the Application Health settings at Oh Dear.
         */
        'secret' => env('OH_DEAR_HEALTH_CHECK_SECRET'),

        /*
         * The URL that should be configured in the Application health settings at Oh Dear.
         */
        'url' => '/oh-dear-health-check-results',
    ],

    /*
     * You can set a theme for the local results page
     *
     * - light: light mode
     * - dark: dark mode
     */
    'theme' => 'dark',

    /*
     * When enabled,  completed `HealthQueueJob`s will be displayed
     * in Horizon's silenced jobs screen.
     */
    'silence_health_queue_job' => true,
];

<?php

namespace Modules\HealthCheck\Actions;

use Illuminate\Console\Command;
use Illuminate\Support\Facades\Artisan;
use Illuminate\Support\Str;
use Lorisleiva\Actions\Concerns\AsCommand;
use Spatie\Health\Commands\RunHealthChecksCommand;
use Spatie\Health\Enums\Status as HealthCheckStatus;
use Spatie\Health\Models\HealthCheckResultHistoryItem;

class CheckPropertyHealth
{
    use AsCommand;

    public $commandSignature = 'health:check-property {name} {--fresh}';
    public $commandDescription = 'Check single health property by name';

    public function handle(
        string $name
    ): ?string {
        return HealthCheckResultHistoryItem::query()
            ->whereRaw("LOWER(health_check_result_history_items.check_name) = '{$name}'")
            ->orderByDesc('health_check_result_history_items.created_at')
            ->value('health_check_result_history_items.status');
    }

    public function asCommand(Command $command)
    {
        $name = Str::lower($command->argument('name'));

        if ($command->option('fresh')) {
            Artisan::call(RunHealthChecksCommand::class);
        }

        $status = $this->handle($name);

        if (!$status) {
            $command->warn("No health check results found for {$name}");
            return $command::INVALID;
        }

        if ($status !== HealthCheckStatus::ok()->value) {
            $command->error($status);
            return $command::FAILURE;
        }

        $command->info($status);
        return $command::SUCCESS;
    }
}

app:
 # ...
 healthcheck:
   test: php artisan health:check-property octane --fresh
   interval: 60s
   timeout: 5s
   retries: 3

horizon:
 # ...
 depends_on:
  - app
 healthcheck:
   test: php artisan health:check-property horizon
   start_period: 5s
   interval: 60s
   timeout: 5s
   retries: 3

schedule:
 # ...
 depends_on:
   - app
 healthcheck:
   test: php artisan health:check-property schedule
   start_period: 5s
   interval: 60s
   timeout: 10s
   retries: 3